Node.hpp

Go to the documentation of this file.

#ifndef GL_NODE_HPP
#define GL_NODE_HPP

#include "Color.hpp"

namespace gl {

//    Node Class declaration

template <class SCALAR>
class Node
{
public:
  using val_t = SCALAR;            
  using idx_t = gl::index_type;    

  Node(const idx_t &id = 0, const val_t &capacity = 1, const gl::Color& color = Color("white"), const std::string &label = "", const float& x = 0., const float& y = 0.) : id_(id), label_(label), capacity_(capacity),
                                          color_(color), inDegree_(0), outDegree_(0),
                                          position_(std::make_pair(x,y)) {}

  Node(const Node<SCALAR>&) = default;                
  Node(Node<SCALAR>&&) noexcept = default;            
  Node &operator=(const Node<SCALAR>&) = default;     
  Node &operator=(Node<SCALAR>&&) noexcept = default; 
  ~Node() = default;                            

  bool operator== (const Node& rhs) const;
  bool operator!= (const Node& rhs) const;

  inline idx_t id() const;
  inline void id(const idx_t &id);

  inline std::string label() const;
  inline void label(const std::string &label);

  inline val_t capacity() const;
  inline void capacity(const val_t &capacity);

  inline Color color() const;
  inline void color(const Color &color);

  inline idx_t inDegree() const;
  inline void inDegreeIncrement(const idx_t &increment = 1);
  inline void inDegreeDecrement(const idx_t &decrement = 1);

  inline idx_t outDegree() const;
  inline void outDegreeIncrement(const idx_t &increment = 1);
  inline void outDegreeDecrement(const idx_t &decrement = 1);


  inline std::pair<float, float> position() const;
  inline void position(const std::pair<float, float> &pos);

private:
  idx_t id_;                         
  std::string label_;                
  val_t capacity_;                   
  Color color_;                      
  idx_t inDegree_;                   
  idx_t outDegree_;                  
  std::pair<float, float> position_; 
};

//    Node function implementations

// equality operator
template <class SCALAR>
bool Node<SCALAR>::operator== (const Node<SCALAR>& rhs) const
{
  return id_ == rhs.id_ 
      && label_ == rhs.label_
      && capacity_ == rhs.capacity_
      && color_ == rhs.color_
      && inDegree_ == rhs.inDegree_
      && outDegree_ == rhs.outDegree_
      && position_ == rhs.position_;
}
// inequality operator
template <class SCALAR>
bool Node<SCALAR>::operator!= (const Node<SCALAR>& rhs) const
{
  return !operator==(rhs);
}

// getter for id
template <class SCALAR>
inline typename Node<SCALAR>::idx_t Node<SCALAR>::id() const
{
  return id_;
}
// setter for id
template <class SCALAR>
inline void Node<SCALAR>::id(const idx_t &id)
{
  id_ = id;
}

// getter for label
template <class SCALAR>
inline std::string Node<SCALAR>::label() const
{
  return label_;
}
// setter for label
template <class SCALAR>
inline void Node<SCALAR>::label(const std::string &label)
{
  label_ = label;
}

// getter for capacity
template <class SCALAR>
inline typename Node<SCALAR>::val_t Node<SCALAR>::capacity() const
{
  return capacity_;
}
// setter for capacity
template <class SCALAR>
inline void Node<SCALAR>::capacity(const val_t &capacity)
{
  capacity_ = capacity;
}

// getter for inDegree
template <class SCALAR>
inline typename Node<SCALAR>::idx_t Node<SCALAR>::inDegree() const
{
  return inDegree_;
}
// increment for inDegree
template <class SCALAR>
inline void Node<SCALAR>::inDegreeIncrement(const idx_t &increment)
{
  inDegree_ += increment;
}
// decrement for inDegree
template <class SCALAR>
inline void Node<SCALAR>::inDegreeDecrement(const idx_t &decrement)
{
  GL_ASSERT(decrement <= inDegree_,"Node::inDegreeDecrement | Decrement results in negative inDegree")
  inDegree_ -= decrement;
}

// getter for outDegree
template <class SCALAR>
inline typename Node<SCALAR>::idx_t Node<SCALAR>::outDegree() const
{
  return outDegree_;
}
// increment for outDegree
template <class SCALAR>
inline void Node<SCALAR>::outDegreeIncrement(const idx_t &increment)
{
  outDegree_ += increment;
}
// decrement for outDegree
template <class SCALAR>
inline void Node<SCALAR>::outDegreeDecrement(const idx_t &decrement)
{
  GL_ASSERT(decrement <= outDegree_,"Node::outDegreeDecrement | Decrement results in negative outDegree")
  outDegree_ -= decrement;
}

// getter for color object
template <class SCALAR>
inline gl::Color Node<SCALAR>::color() const
{
  return color_;
}
// setter for color object
template <class SCALAR>
inline void Node<SCALAR>::color(const Color &color)
{
  color_ = color;
}

// getter for position
template <class SCALAR>
inline std::pair<float, float> Node<SCALAR>::position() const
{
  return position_;
}
// setter for position
template <class SCALAR>
inline void Node<SCALAR>::position(const std::pair<float, float> &pos)
{
  position_ = pos;
}

} // namespace gl

#endif // GL_NODE_HPP