AIFEdge.hpp

Go to the documentation of this file.

// Copyright (c) 2012-2019 University of Lyon and CNRS (France).
// All rights reserved.
//
// This file is part of MEPP2; 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 3 of
// the License, or (at your option) any later version.
//
// This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
// WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
#pragma once
 
#ifndef Q_MOC_RUN // See: https://bugreports.qt-project.org/browse/QTBUG-22829
#include <boost/property_map/property_map.hpp>
#endif
 
#include <iostream>
#include <vector>
#include <array>
#include <utility>
#include <stdexcept>
#include <boost/shared_ptr.hpp>
#include <boost/range/iterator_range.hpp>
 
#include "FEVV/DataStructures/AIF/AIFVertex.hpp"
 
 
namespace FEVV {
namespace DataStructures {
namespace AIF {
class AIFEdge;
class AIFFace;
} // namespace AIF
} // namespace DataStructures
} // namespace FEVV
 
namespace FEVV {
namespace DataStructures {
namespace AIF {
 
class AIFEdge
{
public:
  friend class AIFEdgeComparator;
  friend class AIFTopologyHelpers;
 
public:
  typedef AIFEdge self;
  typedef boost::shared_ptr< self > ptr;
  typedef boost::shared_ptr< self > ptr_edge;
 
  typedef AIFVertex vertex_type;
  typedef AIFFace face_type;
  typedef boost::shared_ptr< vertex_type > ptr_vertex;
  typedef boost::shared_ptr< face_type > ptr_face;
 
  typedef std::array< ptr_vertex, 2 > VertexContainerType;
  typedef std::vector< ptr_edge > EdgeContainerType;
  typedef std::vector< ptr_face > FaceContainerType;
 
private:
  std::size_t m_Index;
  VertexContainerType m_incident_vertices;
  FaceContainerType m_incident_PtrFaces;
 
private:
  AIFEdge() : m_Index(-1), m_incident_vertices(), m_incident_PtrFaces() {}
 
  AIFEdge(const self &other)
      : m_Index(other.m_Index),
        m_incident_vertices(), // vertex incidence relations are not copied
        m_incident_PtrFaces()  // face incidence relations are not copied
  {
  }
 
public:
  static ptr_edge New();
  static ptr_edge New(const self &other);
  boost::iterator_range< VertexContainerType::const_iterator >
  GetIncidentVertices()
  {
    return boost::make_iterator_range(m_incident_vertices.cbegin(),
                                      m_incident_vertices.cend());
  }
  boost::iterator_range< FaceContainerType::const_iterator >
  GetIncidentFaces() const
  {
    return boost::make_iterator_range(m_incident_PtrFaces.cbegin(),
                                      m_incident_PtrFaces.cend());
  }
 
  boost::iterator_range< FaceContainerType::iterator > GetIncidentFaces()
  {
    return boost::make_iterator_range(m_incident_PtrFaces.begin(),
                                      m_incident_PtrFaces.end());
  }
 
  unsigned int GetDegree()
  {
    return static_cast< unsigned int >(m_incident_PtrFaces.size());
  }
  ptr_vertex get_first_vertex() const { return m_incident_vertices[0]; }
 
  ptr_vertex get_second_vertex() const { return m_incident_vertices[1]; }
 
  std::size_t GetIndex() const { return m_Index; }
  void SetIndex(std::size_t idx) { m_Index = idx; }
  void set_first_vertex(ptr_vertex V1) { m_incident_vertices[0] = V1; }
  void set_second_vertex(ptr_vertex V2) { m_incident_vertices[1] = V2; }
  void Print() const;
 
  bool operator<(const self &other) const;
  bool operator==(const self &other) const;
  bool operator!=(const self &other) const { return !(*this == other); }
  bool operator<=(const self &other) const
  {
    return (*this < other) || (*this == other);
  }
  bool operator>=(const self &other) const { return !(*this < other); }
  bool operator>(const self &other) const { return (other < *this); }
};
 
} // namespace AIF
} // namespace DataStructures
} // namespace FEVV
 
 
#include "FEVV/DataStructures/AIF/AIFEdge.inl"