AIFFace.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
 
#include <iostream>
#include <vector>
//#include <set>
#include <stdexcept>
#include <boost/shared_ptr.hpp>
#include <boost/range/iterator_range.hpp>
 
 
namespace FEVV {
namespace DataStructures {
namespace AIF {
 
class AIFVertex;
class AIFEdge;
class AIFFace;
 
} // namespace AIF
} // namespace DataStructures
} // namespace FEVV
 
 
namespace FEVV {
namespace DataStructures {
namespace AIF {
 
class AIFFace
{
public:
  friend class AIFTopologyHelpers;
 
public:
  typedef AIFFace self;
  typedef boost::shared_ptr< self > ptr;
  typedef boost::shared_ptr< self > ptr_face;
 
  typedef AIFVertex vertex_type;
  typedef AIFEdge edge_type;
  typedef boost::shared_ptr< vertex_type > ptr_vertex;
  typedef boost::shared_ptr< edge_type > ptr_edge;
 
  typedef std::vector< ptr_vertex > VertexContainerType;
  typedef std::vector< ptr_edge > EdgeContainerType;
  typedef std::vector< ptr_face > FaceContainerType;
 
  typedef double NormalCoordinateType;
 
private:
  std::size_t m_Index;
  EdgeContainerType m_Incident_PtrEdges;
 
private:
  VertexContainerType m_Incident_PtrVertices;
 
  bool m_Is_Incident_PtrVertices_Computed;
 
private:
  AIFFace()
      : m_Index(-1), m_Incident_PtrEdges(), m_Incident_PtrVertices(),
        m_Is_Incident_PtrVertices_Computed(false)
  {
  }
  AIFFace(const self &other)
      : m_Index(other.m_Index),
        m_Incident_PtrEdges(),    // incidence relations are not copied
        m_Incident_PtrVertices(), // incidence relations are not copied
        m_Is_Incident_PtrVertices_Computed(false)
  {
  }
 
public:
  static ptr_face New();
 
  static ptr_face New(const self &other);
 
  std::size_t GetIndex() const { return m_Index; }
  void SetIndex(std::size_t idx) { m_Index = idx; }
 
  boost::iterator_range< VertexContainerType::const_iterator >
  GetIncidentVertices(); // cannot be const since it updates vertex incidency
                         // caching when necessary
 
  boost::iterator_range< EdgeContainerType::const_iterator >
  GetIncidentEdges() const
  {
    return boost::make_iterator_range(m_Incident_PtrEdges.cbegin(),
                                      m_Incident_PtrEdges.cend());
  }
 
  boost::iterator_range< EdgeContainerType::iterator > GetIncidentEdges()
  {
    return boost::make_iterator_range(m_Incident_PtrEdges.begin(),
                                      m_Incident_PtrEdges.end());
  }
 
  unsigned int GetDegree()
  {
    return static_cast< unsigned int >(m_Incident_PtrEdges.size());
  }
  void Print() const;
 
  void clear_vertex_incidency()
  {
    // DBG std::cout << "clear face-incident-vertices cache for face " << this
    // << std::endl;
    m_Is_Incident_PtrVertices_Computed = false;
    m_Incident_PtrVertices.clear();
  }
 
  bool operator<(const self &other) const { return this < &other; }
  bool operator==(const self &other) const { return this == &other; }
  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/AIFFace.inl"