Vertice.h

Go to the documentation of this file.

/*****************************************************************************
 * Copyright (C) 2011 by Benjamin Hadorn (b_hadorn@bluewin.ch)
 *****************************************************************************
 * Project    : Zeus Math Library
 * Module     : Vertice
 * Package    : Zeus.ZeusMath.System
 * Author     : Benjamin Hadorn
 * Date       : 27.12.2011
 * System     : Zeus-Framework
 *****************************************************************************
 * Licence:                                                                  *
 *   This library is free software; you can redistribute it and/or modify    *
 *   it under the terms of the GNU Lesser General Public License as          *
 *   published by the Free Software Foundation; either version               *
 *   2.1 of the License, or (at your option) any later version.              *
 *                                                                           *
 *   This library is distributed in the hope that it will be useful,         *
 *   but WITHOUT ANY WARRANTY; without even the implied warranty of          *
 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the            *
 *   GNU Lesser General Public License for more details.                     *
 *                                                                           *
 *   You should have received a copy of the GNU Lesser General Public        *
 *   License along with this library; if not, write to the Free Software     *
 *   Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110, USA    *
 *****************************************************************************/

/*****************************************************************************
 * Changes:
 *  27.12.2011 bha: created zeus 2.0
 *****************************************************************************/

#ifndef VerticeH
#define VerticeH

#include <zeusmath/Config/PlatformDefines.hpp>
#include <zeusbase/System/ZObject.h>
#include <zeusbase/System/SingleLinkedList.hpp>


BEGIN_NAMESPACE_Zeus

/****************************************************************************/
/****************************************************************************/
zeusmath_class TEdge  : public TZObject
{
  public:
    /************************************************************************/
    /************************************************************************/
    inline TEdge()
    {
      m_uiVertice1 = 0;
      m_uiVertice2 = 0;
      m_fWeight = 0;
    }

    /************************************************************************/
    /************************************************************************/
    inline TEdge(Uint uiVertice1, Uint uiVertice2, Float fWeight)
    {
      m_uiVertice1 = uiVertice1;
      m_uiVertice2 = uiVertice2;
      m_fWeight = fWeight;
    }

    /************************************************************************/
    /************************************************************************/
    inline virtual ~TEdge() {}

    /************************************************************************/
    /************************************************************************/
    inline void assign(const TEdge& rInPar)
    {
      m_uiVertice1 =  rInPar.m_uiVertice1;
      m_uiVertice2 =  rInPar.m_uiVertice2;
      m_fWeight =  rInPar.m_fWeight;
    }
    
    /************************************************************************/
    /************************************************************************/
    inline bool equals(const TEdge& rInPar, bool bIgnoreWeight = false) const
    {
      return (m_uiVertice1 == rInPar.m_uiVertice1 &&
              m_uiVertice2 == rInPar.m_uiVertice2 &&
              (bIgnoreWeight || m_fWeight == rInPar.m_fWeight));
    }

    inline Uint getVertice1() const { return m_uiVertice1; }
    inline Uint getVertice2() const { return m_uiVertice2; }
    inline Float getWeight() const { return m_fWeight; }

    /************************************************************************/
    /************************************************************************/
    inline TEdge inverse() const
    {
      return TEdge(m_uiVertice2, m_uiVertice1, m_fWeight);
    }

    inline void setWeight(Float fValue) { m_fWeight = fValue; }

    /************************************************************************/
    /************************************************************************/
    inline TEdge& operator=(const TEdge& rInPar)
    {
      this->assign(rInPar);
      return *this;
    }

    /************************************************************************/
    /************************************************************************/
    inline bool operator==(const TEdge& rInPar) const
    {
      return equals(rInPar);
    }

    /************************************************************************/
    /************************************************************************/
    inline bool operator!=(const TEdge& rInPar) const
    {
      return !equals(rInPar);
    }

  protected:

  private:
    Uint m_uiVertice1;
    Uint m_uiVertice2;
    Float m_fWeight;
};


/****************************************************************************/
/****************************************************************************/
zeusmath_class TVertice  : public TZObject
{
  public:
    TVertice(Uint uiID, const IZUnknown* pObject);

    virtual Retval clone(TVertice*& rpVertice) const;
    virtual bool equals(const TVertice& rVertice, bool bIgnoreID = false) const;
    virtual Int getEdgeCount() const;
    virtual void getEdgeList(IList<TEdge>& rList) const;
    virtual void getEdgeList(Uint uiNeighbourVertice, IList<TEdge>& rList) const;
    virtual void getNextVertices(IList<Uint>& rList) const;
    virtual void getNextVertices(IList<Uint>& rList, IList<Float>& rWeights) const;
    virtual Retval getObject(IZUnknown*& rpObject) const;
    Float getWeightSum(Uint uiToID) const;

    bool hasEdge(Uint uiNextVertice) const;

    /************************************************************************/
    /************************************************************************/
    inline Uint getID() const
    {
      return m_uiID;
    }

  protected:
    virtual ~TVertice();

    virtual Retval addEdge(TEdge& rEdge);
    virtual void clearEdges();
    virtual void removeEdge(TEdge& rEdge);

  private:
    Uint m_uiID;
    IZUnknown* m_pObject;
    TSingleLinkedList<TEdge> m_lstEdges;

    //Must be used because some methods has to be accessed by graph class only
    friend class TGraph;
};

/****************************************************************************/
/****************************************************************************/
inline void TVertice::clearEdges()
{
  m_lstEdges.clear();
}

/****************************************************************************/
/****************************************************************************/
inline Int TVertice::getEdgeCount() const
{
  return m_lstEdges.getCount();
}


/****************************************************************************/
/****************************************************************************/
inline void TVertice::getEdgeList(IList<TEdge>& rList) const
{
  m_lstEdges.copyToList(rList);
}

/****************************************************************************/
/****************************************************************************/
inline void TVertice::removeEdge(TEdge& rEdge)
{
  m_lstEdges.remove(rEdge);
}

END_NAMESPACE_Zeus
//---------------------------------------------------------------------------
#endif