songsenand
/
cgal
mirror of https://github.com/CGAL/cgal
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Storage with index for gmap.

This commit is contained in:
Guillaume Damiand 2022-04-12 15:22:01 +02:00
parent 2e076fa6f3
commit 3d874e8e1e
19 changed files with 1588 additions and 225 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

48
Combinatorial_map/include/CGAL/Cell_attribute.h
View File

@ -85,22 +85,22 @@ namespace CGAL {
public Add_id<WithID> public Add_id<WithID>
{ {
template<unsigned int, class, class, class> template<unsigned int, class, class, class>
friend class Combinatorial_map_storage_1; friend class CGAL::Combinatorial_map_storage_1;
template<unsigned int, class, class, class> template<unsigned int, class, class, class>
friend class Generalized_map_storage_1; friend class CGAL::Generalized_map_storage_1;
template<unsigned int, unsigned int, class, class, class, class> template<unsigned int, unsigned int, class, class, class, class>
friend class CMap_linear_cell_complex_storage_1; friend class CGAL::CMap_linear_cell_complex_storage_1;
template<unsigned int, unsigned int, class, class, class, class> template<unsigned int, unsigned int, class, class, class, class>
friend class GMap_linear_cell_complex_storage_1; friend class CGAL::GMap_linear_cell_complex_storage_1;
template <class, class, class, class> template <class, class, class, class>
friend class Compact_container; friend class CGAL::Compact_container;
template <class, class> template <class, class>
friend class Concurrent_compact_container; friend class CGAL::Concurrent_compact_container;
template<class, class> template<class, class>
friend struct internal::Init_id; friend struct internal::Init_id;
@ -195,22 +195,22 @@ namespace CGAL {
OnMerge, OnSplit, WithID>: public Add_id<WithID> OnMerge, OnSplit, WithID>: public Add_id<WithID>
{ {
template<unsigned int, class, class, class> template<unsigned int, class, class, class>
friend class Combinatorial_map_storage_1; friend class CGAL::Combinatorial_map_storage_1;
template<unsigned int, class, class, class> template<unsigned int, class, class, class>
friend class Generalized_map_storage_1; friend class CGAL::Generalized_map_storage_1;
template<unsigned int, unsigned int, class, class, class, class> template<unsigned int, unsigned int, class, class, class, class>
friend class CMap_linear_cell_complex_storage_1; friend class CGAL::CMap_linear_cell_complex_storage_1;
template<unsigned int, unsigned int, class, class, class, class> template<unsigned int, unsigned int, class, class, class, class>
friend class GMap_linear_cell_complex_storage_1; friend class CGAL::GMap_linear_cell_complex_storage_1;
template <class, class, class, class> template <class, class, class, class>
friend class Compact_container; friend class CGAL::Compact_container;
template <class, class> template <class, class>
friend class Concurrent_compact_container; friend class CGAL::Concurrent_compact_container;
template<class, class> template<class, class>
friend struct internal::Init_id; friend struct internal::Init_id;
@ -311,22 +311,22 @@ namespace CGAL {
public Cell_attribute_without_info<Refs, Tag_, OnMerge, OnSplit, WithID> public Cell_attribute_without_info<Refs, Tag_, OnMerge, OnSplit, WithID>
{ {
template<unsigned int, class, class, class> template<unsigned int, class, class, class>
friend class Combinatorial_map_storage_1; friend class CGAL::Combinatorial_map_storage_1;
template<unsigned int, class, class, class> template<unsigned int, class, class, class>
friend class Generalized_map_storage_1; friend class CGAL::Generalized_map_storage_1;
template<unsigned int, unsigned int, class, class, class, class> template<unsigned int, unsigned int, class, class, class, class>
friend class CMap_linear_cell_complex_storage_1; friend class CGAL::CMap_linear_cell_complex_storage_1;
template<unsigned int, unsigned int, class, class, class, class> template<unsigned int, unsigned int, class, class, class, class>
friend class GMap_linear_cell_complex_storage_1; friend class CGAL::GMap_linear_cell_complex_storage_1;
template <class, class, class, class> template <class, class, class, class>
friend class Compact_container; friend class CGAL::Compact_container;
template <class, class> template <class, class>
friend class Concurrent_compact_container; friend class CGAL::Concurrent_compact_container;
public: public:
typedef Tag_ Supports_cell_dart; typedef Tag_ Supports_cell_dart;
@ -351,22 +351,22 @@ namespace CGAL {
public Info_for_cell_attribute<Info_> public Info_for_cell_attribute<Info_>
{ {
template<unsigned int, class, class, class> template<unsigned int, class, class, class>
friend class Combinatorial_map_storage_1; friend class CGAL::Combinatorial_map_storage_1;
template<unsigned int, class, class, class> template<unsigned int, class, class, class>
friend class Generalized_map_storage_1; friend class CGAL::Generalized_map_storage_1;
template<unsigned int, unsigned int, class, class, class, class> template<unsigned int, unsigned int, class, class, class, class>
friend class CMap_linear_cell_complex_storage_1; friend class CGAL::CMap_linear_cell_complex_storage_1;
template<unsigned int, unsigned int, class, class, class, class> template<unsigned int, unsigned int, class, class, class, class>
friend class GMap_linear_cell_complex_storage_1; friend class CGAL::GMap_linear_cell_complex_storage_1;
template <class, class, class, class> template <class, class, class, class>
friend class Compact_container; friend class CGAL::Compact_container;
template <class, class> template <class, class>
friend class Concurrent_compact_container; friend class CGAL::Concurrent_compact_container;
public: public:
typedef Cell_attribute<Refs, Info_, Tag_, OnMerge, OnSplit, WithID> Self; typedef Cell_attribute<Refs, Info_, Tag_, OnMerge, OnSplit, WithID> Self;

77
Combinatorial_map/include/CGAL/Cell_attribute_with_index.h
View File

@ -25,6 +25,15 @@ namespace CGAL {
template<unsigned int, class, class, class> template<unsigned int, class, class, class>
class Combinatorial_map_storage_2; class Combinatorial_map_storage_2;
template<unsigned int, class, class, class>
class Generalized_map_storage_2;
template<unsigned int, unsigned int, class, class, class, class>
class CMap_linear_cell_complex_storage_2;
template<unsigned int, unsigned int, class, class, class, class>
class GMap_linear_cell_complex_storage_2;
namespace Index namespace Index
{ {
// Versions to use with containers using index // Versions to use with containers using index
@ -38,11 +47,20 @@ namespace CGAL {
class Cell_attribute_without_info<Refs, Tag_false, class Cell_attribute_without_info<Refs, Tag_false,
OnMerge, OnSplit> OnMerge, OnSplit>
{ {
template <class, class, class, class>
friend class CGAL::Compact_container_with_index_2;
template<unsigned int, class, class, class> template<unsigned int, class, class, class>
friend class CGAL::Combinatorial_map_storage_2; friend class CGAL::Combinatorial_map_storage_2;
template <class, class, class, class> template<unsigned int, class, class, class>
friend class CGAL::Compact_container_with_index_2; friend class CGAL::Generalized_map_storage_2;
template<unsigned int, unsigned int, class, class, class, class>
friend class CGAL::CMap_linear_cell_complex_storage_2;
template<unsigned int, unsigned int, class, class, class, class>
friend class CGAL::GMap_linear_cell_complex_storage_2;
public: public:
typedef Tag_false Supports_cell_dart; typedef Tag_false Supports_cell_dart;
@ -83,7 +101,7 @@ namespace CGAL {
bool operator!=(const Cell_attribute_without_info& other) const bool operator!=(const Cell_attribute_without_info& other) const
{ return !operator==(other); } { return !operator==(other); }
// protected: protected:
/// Contructor without parameter. /// Contructor without parameter.
Cell_attribute_without_info(): mrefcounting(0) Cell_attribute_without_info(): mrefcounting(0)
{} {}
@ -130,11 +148,20 @@ namespace CGAL {
class Cell_attribute_without_info<Refs, Tag_true, class Cell_attribute_without_info<Refs, Tag_true,
OnMerge, OnSplit> OnMerge, OnSplit>
{ {
template <class, class, class, class>
friend class CGAL::Compact_container_with_index_2;
template<unsigned int, class, class, class> template<unsigned int, class, class, class>
friend class CGAL::Combinatorial_map_storage_2; friend class CGAL::Combinatorial_map_storage_2;
template <class, class, class, class> template<unsigned int, class, class, class>
friend class CGAL::Compact_container_with_index; friend class CGAL::Generalized_map_storage_2;
template<unsigned int, unsigned int, class, class, class, class>
friend class CGAL::CMap_linear_cell_complex_storage_2;
template<unsigned int, unsigned int, class, class, class, class>
friend class CGAL::GMap_linear_cell_complex_storage_2;
public: public:
typedef Tag_true Supports_cell_dart; typedef Tag_true Supports_cell_dart;
@ -166,7 +193,7 @@ namespace CGAL {
void set_dart(Dart_handle adart) { mdart = adart; } void set_dart(Dart_handle adart) { mdart = adart; }
/// Test if the cell is valid. /// Test if the cell is valid.
/// A cell is valid if its dart is not NULL. /// A cell is valid if its dart is not null_handle.
bool is_valid() const bool is_valid() const
{ return mdart!=Refs::null_handle; } { return mdart!=Refs::null_handle; }
@ -212,11 +239,11 @@ namespace CGAL {
{ return mdart.for_compact_container_with_index(); } { return mdart.for_compact_container_with_index(); }
private: private:
/// Reference counting: the number of darts linked to this cell.
std::size_t mrefcounting;
/// The dart handle associated with the cell. /// The dart handle associated with the cell.
Dart_handle mdart; Dart_handle mdart;
/// Reference counting: the number of darts linked to this cell.
std::size_t mrefcounting;
}; };
/// Cell associated with an attribute, with or without info depending /// Cell associated with an attribute, with or without info depending
@ -234,12 +261,21 @@ namespace CGAL {
public Cell_attribute_without_info<Refs, Tag_, public Cell_attribute_without_info<Refs, Tag_,
OnSplit, OnMerge> OnSplit, OnMerge>
{ {
template < unsigned int, class, class, class, class >
friend class CGAL::Combinatorial_map_base;
template <class, class, class, class> template <class, class, class, class>
friend class CGAL::Compact_container_with_index_2; friend class CGAL::Compact_container_with_index_2;
template<unsigned int, class, class, class>
friend class CGAL::Combinatorial_map_storage_2;
template<unsigned int, class, class, class>
friend class CGAL::Generalized_map_storage_2;
template<unsigned int, unsigned int, class, class, class, class>
friend class CGAL::CMap_linear_cell_complex_storage_2;
template<unsigned int, unsigned int, class, class, class, class>
friend class CGAL::GMap_linear_cell_complex_storage_2;
public: public:
typedef Tag_ Supports_cell_dart; typedef Tag_ Supports_cell_dart;
typedef typename Refs::Dart_handle Dart_handle; typedef typename Refs::Dart_handle Dart_handle;
@ -249,7 +285,7 @@ namespace CGAL {
typedef OnSplit On_split; typedef OnSplit On_split;
typedef void Info; typedef void Info;
// protected: protected:
/// Default contructor. /// Default contructor.
Cell_attribute() Cell_attribute()
{} {}
@ -263,12 +299,21 @@ namespace CGAL {
OnMerge, OnSplit>, OnMerge, OnSplit>,
public CGAL::Info_for_cell_attribute<Info_> public CGAL::Info_for_cell_attribute<Info_>
{ {
template < unsigned int, class, class, class, class >
friend class CGAL::Combinatorial_map_base;
template <class, class, class, class> template <class, class, class, class>
friend class CGAL::Compact_container_with_index_2; friend class CGAL::Compact_container_with_index_2;
template<unsigned int, class, class, class>
friend class CGAL::Combinatorial_map_storage_2;
template<unsigned int, class, class, class>
friend class CGAL::Generalized_map_storage_2;
template<unsigned int, unsigned int, class, class, class, class>
friend class CGAL::CMap_linear_cell_complex_storage_2;
template<unsigned int, unsigned int, class, class, class, class>
friend class CGAL::GMap_linear_cell_complex_storage_2;
public: public:
typedef Cell_attribute<Refs, Info_, Tag_, OnMerge, OnSplit> Self; typedef Cell_attribute<Refs, Info_, Tag_, OnMerge, OnSplit> Self;

3
Combinatorial_map/include/CGAL/Combinatorial_map_storages.h
View File

@ -34,9 +34,6 @@ namespace CGAL {
struct Container_type; struct Container_type;
} }
/** @file Combinatorial_map_storages.h
* Definition of storages for dD Combinatorial map.
*/
// Storage of darts with compact container, beta with handles // Storage of darts with compact container, beta with handles
template<unsigned int d_, class Items_, class Alloc_, class Concurrent_tag > template<unsigned int d_, class Items_, class Alloc_, class Concurrent_tag >
class Combinatorial_map_storage_1 class Combinatorial_map_storage_1

26
Combinatorial_map/include/CGAL/Combinatorial_map_storages_with_index.h
View File

@ -14,7 +14,6 @@
#include <CGAL/Compact_container_with_index_2.h> #include <CGAL/Compact_container_with_index_2.h>
#include <CGAL/Dart.h> #include <CGAL/Dart.h>
#include <CGAL/Handle_hash_function.h>
#include <bitset> #include <bitset>
#include <boost/config.hpp> #include <boost/config.hpp>
@ -31,14 +30,6 @@ namespace CGAL {
template<typename Concurrent_tag, class T, class Alloc_> template<typename Concurrent_tag, class T, class Alloc_>
struct Container_type; struct Container_type;
struct Index_hash_function {
typedef std::size_t result_type;
template <class H>
std::size_t operator() (const H& h) const {
return h;
}
};
} }
// Storage with combinatorial maps using index // Storage with combinatorial maps using index
@ -192,6 +183,8 @@ namespace CGAL {
CGAL_assertion(i <= dimension); CGAL_assertion(i <= dimension);
return mdarts[dh].mf[i]==null_dart_handle; return mdarts[dh].mf[i]==null_dart_handle;
} }
bool is_perforated(Dart_const_handle /*dh*/) const
{ return false; }
/// Set simultaneously all the marks of this dart to a given value. /// Set simultaneously all the marks of this dart to a given value.
void set_dart_marks(Dart_const_handle ADart, void set_dart_marks(Dart_const_handle ADart,
@ -225,24 +218,24 @@ namespace CGAL {
// Access to beta maps // Access to beta maps
Dart_handle get_beta(Dart_handle ADart, int B1) Dart_handle get_beta(Dart_handle ADart, int B1)
{ {
CGAL_assertion(B1>=0 && B1<=dimension); CGAL_assertion(B1>=0 && B1<=(int)dimension);
return mdarts[ADart].mf[B1]; return mdarts[ADart].mf[B1];
} }
Dart_const_handle get_beta(Dart_const_handle ADart, int B1) const Dart_const_handle get_beta(Dart_const_handle ADart, int B1) const
{ {
CGAL_assertion(B1>=0 && B1<=dimension); CGAL_assertion(B1>=0 && B1<=(int)dimension);
return mdarts[ADart].mf[B1]; return mdarts[ADart].mf[B1];
} }
template<int B1> template<int B1>
Dart_handle get_beta(Dart_handle ADart) Dart_handle get_beta(Dart_handle ADart)
{ {
CGAL_assertion(B1>=0 && B1<=dimension); CGAL_assertion(B1>=0 && B1<=(int)dimension);
return mdarts[ADart].mf[B1]; return mdarts[ADart].mf[B1];
} }
template<int B1> template<int B1>
Dart_const_handle get_beta(Dart_const_handle ADart) const Dart_const_handle get_beta(Dart_const_handle ADart) const
{ {
CGAL_assertion(B1>=0 && B1<=dimension); CGAL_assertion(B1>=0 && B1<=(int)dimension);
return mdarts[ADart].mf[B1]; return mdarts[ADart].mf[B1];
} }
@ -417,11 +410,11 @@ namespace CGAL {
protected: protected:
// Set the handle on the i th attribute // Set the handle on the i th attribute
template<unsigned int i> template<unsigned int i>
void basic_set_dart_attribute(Dart_handle ADart, void basic_set_dart_attribute(Dart_handle dh,
typename Attribute_handle<i>::type ah) typename Attribute_handle<i>::type ah)
{ {
std::get<Helper::template Dimension_index<i>::value> std::get<Helper::template Dimension_index<i>::value>
(mdarts[ADart].mattribute_handles) = ah; (mdarts[dh].mattribute_handles) = ah;
} }
/** Link a dart with a given dart for a given dimension. /** Link a dart with a given dart for a given dimension.
@ -467,6 +460,9 @@ namespace CGAL {
/// Dart container. /// Dart container.
Dart_container mdarts; Dart_container mdarts;
Dart_range mdarts_range; Dart_range mdarts_range;
/// Container for the null_dart_handle: unused; to be compatible with handle version
Dart_container mnull_dart_container;
/// Tuple of attributes containers /// Tuple of attributes containers
typename Helper::Attribute_containers mattribute_containers; typename Helper::Attribute_containers mattribute_containers;

17
Combinatorial_map/include/CGAL/Compact_container_with_index_2.h
View File

@ -71,6 +71,17 @@
namespace CGAL { namespace CGAL {
namespace internal
{
struct Index_hash_function {
typedef std::size_t result_type;
template <class H>
std::size_t operator() (const H& h) const {
return h;
}
};
}
template < class T, class Allocator_, class Increment_policy, template < class T, class Allocator_, class Increment_policy,
class IndexType = std::size_t > class IndexType = std::size_t >
class Compact_container_with_index_2 class Compact_container_with_index_2
@ -347,6 +358,12 @@ public:
return alloc; return alloc;
} }
size_type index(const_iterator cit) const
{ return static_cast<size_type>(cit); }
size_type index(Index idx) const
{ return static_cast<size_type>(idx); }
// Returns whether the iterator "cit" is in the range [begin(), end()]. // Returns whether the iterator "cit" is in the range [begin(), end()].
// Complexity : O(#blocks) = O(sqrt(capacity())). // Complexity : O(#blocks) = O(sqrt(capacity())).
// This function is mostly useful for purposes of efficient debugging at // This function is mostly useful for purposes of efficient debugging at

9
Combinatorial_map/include/CGAL/Dart.h
View File

@ -36,6 +36,9 @@ namespace CGAL {
template<unsigned int, unsigned int, class, class, class, class> template<unsigned int, unsigned int, class, class, class, class>
class CMap_linear_cell_complex_storage_1; class CMap_linear_cell_complex_storage_1;
template<unsigned int, unsigned int, class, class, class, class>
class CMap_linear_cell_complex_storage_2;
template<unsigned int, unsigned int, class, class, class, class> template<unsigned int, unsigned int, class, class, class, class>
class GMap_linear_cell_complex_storage_1; class GMap_linear_cell_complex_storage_1;
@ -70,6 +73,9 @@ namespace CGAL {
template<unsigned int, unsigned int, class, class, class, class> template<unsigned int, unsigned int, class, class, class, class>
friend class CMap_linear_cell_complex_storage_1; friend class CMap_linear_cell_complex_storage_1;
template<unsigned int, unsigned int, class, class, class, class>
friend class CMap_linear_cell_complex_storage_2;
template<unsigned int, unsigned int, class, class, class, class> template<unsigned int, unsigned int, class, class, class, class>
friend class GMap_linear_cell_complex_storage_1; friend class GMap_linear_cell_complex_storage_1;
@ -217,6 +223,9 @@ namespace CGAL {
template<unsigned int, unsigned int, class, class, class, class> template<unsigned int, unsigned int, class, class, class, class>
friend class CMap_linear_cell_complex_storage_1; friend class CMap_linear_cell_complex_storage_1;
template<unsigned int, unsigned int, class, class, class, class>
friend class CMap_linear_cell_complex_storage_2;
template<unsigned int, unsigned int, class, class, class, class> template<unsigned int, unsigned int, class, class, class, class>
friend class GMap_linear_cell_complex_storage_1; friend class GMap_linear_cell_complex_storage_1;

45
Combinatorial_map/include/CGAL/Dart_with_index.h
View File

@ -20,19 +20,40 @@
namespace CGAL { namespace CGAL {
namespace Index template <class, class, class, class>
class Compact_container_with_index_2;
template<unsigned int, class, class, class>
class Combinatorial_map_storage_2;
template<unsigned int, class, class, class>
class Generalized_map_storage_2;
template<unsigned int, unsigned int, class, class, class, class>
class CMap_linear_cell_complex_storage_2;
template<unsigned int, unsigned int, class, class, class, class>
class GMap_linear_cell_complex_storage_2;
namespace Index
{ {
template <unsigned int d, typename Refs> template <unsigned int d, typename Refs>
struct Dart_without_info struct Dart_without_info
{ {
template <class, class, class, class>
friend class CGAL::Compact_container_with_index_2;
template<unsigned int, class, class, class> template<unsigned int, class, class, class>
friend class CGAL::Combinatorial_map_storage_2; friend class CGAL::Combinatorial_map_storage_2;
// TODO template<unsigned int, unsigned int, class, class, class, class> template<unsigned int, class, class, class>
// friend class CGAL::CMap_linear_cell_complex_storage_2; friend class CGAL::Generalized_map_storage_2;
template <class, class, class, class> template<unsigned int, unsigned int, class, class, class, class>
friend class CGAL::Compact_container_with_index_2; friend class CGAL::CMap_linear_cell_complex_storage_2;
template<unsigned int, unsigned int, class, class, class, class>
friend class CGAL::GMap_linear_cell_complex_storage_2;
typedef Dart_without_info<d,Refs> Self; typedef Dart_without_info<d,Refs> Self;
typedef typename Refs::Dart_handle Dart_handle; typedef typename Refs::Dart_handle Dart_handle;
@ -159,14 +180,20 @@ namespace CGAL {
struct Dart : public Dart_without_info<d, Refs> struct Dart : public Dart_without_info<d, Refs>
{ {
public: public:
template <class, class, class, class>
friend class CGAL::Compact_container_with_index_2;
template<unsigned int, class, class, class> template<unsigned int, class, class, class>
friend class CGAL::Combinatorial_map_storage_2; friend class CGAL::Combinatorial_map_storage_2;
/* TODO template<unsigned int, unsigned int, class, class, class, class> template<unsigned int, class, class, class>
friend class CMap_linear_cell_complex_storage_2; */ friend class CGAL::Generalized_map_storage_2;
template <class, class, class, class> template<unsigned int, unsigned int, class, class, class, class>
friend class CGAL::Compact_container_with_index_2; friend class CGAL::CMap_linear_cell_complex_storage_2;
template<unsigned int, unsigned int, class, class, class, class>
friend class CGAL::GMap_linear_cell_complex_storage_2;
typedef Dart<d, Refs, Info_> Self; typedef Dart<d, Refs, Info_> Self;
typedef Info_ Info; typedef Info_ Info;

196
Generalized_map/include/CGAL/Generalized_map.h
View File

@ -21,6 +21,7 @@
#include <CGAL/Generalized_map/internal/Generalized_map_sewable.h> #include <CGAL/Generalized_map/internal/Generalized_map_sewable.h>
#include <CGAL/Generalized_map_storages.h> #include <CGAL/Generalized_map_storages.h>
#include <CGAL/Generalized_map_storages_with_index.h>
#include <CGAL/Combinatorial_map_functors.h> #include <CGAL/Combinatorial_map_functors.h>
#include <CGAL/Combinatorial_map_basic_operations.h> #include <CGAL/Combinatorial_map_basic_operations.h>
#include <CGAL/Generalized_map_operations.h> #include <CGAL/Generalized_map_operations.h>
@ -38,8 +39,6 @@
#include <boost/type_traits/is_same.hpp> #include <boost/type_traits/is_same.hpp>
#include <CGAL/config.h> #include <CGAL/config.h>
#include <unordered_map>
#if defined( __INTEL_COMPILER ) #if defined( __INTEL_COMPILER )
// Workarounf for warning in function basic_link_beta_0 // Workarounf for warning in function basic_link_beta_0
#pragma warning disable 1017 #pragma warning disable 1017
@ -102,6 +101,8 @@ namespace CGAL {
typedef typename Base::Items Items; typedef typename Base::Items Items;
typedef typename Base::Alloc Alloc; typedef typename Base::Alloc Alloc;
typedef typename Base::Use_index Use_index; typedef typename Base::Use_index Use_index;
typedef typename Base::Dart_range Dart_range;
typedef typename Base::Dart_const_range Dart_const_range;
static const size_type NB_MARKS = Base::NB_MARKS; static const size_type NB_MARKS = Base::NB_MARKS;
static const size_type INVALID_MARK = NB_MARKS; static const size_type INVALID_MARK = NB_MARKS;
@ -128,10 +129,9 @@ namespace CGAL {
using Base::info_of_attribute; using Base::info_of_attribute;
using Base::info; using Base::info;
using Base::dart; using Base::dart;
using Base::darts;
/// Typedef for Dart_range, a range through all the darts of the map. using Base::number_of_darts;
typedef Dart_container Dart_range; using Base::is_empty;
typedef const Dart_container Dart_const_range;
/// Typedef for attributes /// Typedef for attributes
template<int i> template<int i>
@ -262,7 +262,7 @@ namespace CGAL {
internal::Copy_dart_info_functor internal::Copy_dart_info_functor
<typename GMap2::Refs, Refs, DartInfoConverter>::run <typename GMap2::Refs, Refs, DartInfoConverter>::run
(static_cast<const typename GMap2::Refs&>(amap), static_cast<Refs&>(*this), (static_cast<typename GMap2::Refs&>(amap), static_cast<Refs&>(*this),
it, new_dart, dartinfoconverter); it, new_dart, dartinfoconverter);
} }
} }
@ -545,6 +545,7 @@ namespace CGAL {
*/ */
void clear() void clear()
{ {
this->clear_storage();
mdarts.clear(); mdarts.clear();
for ( size_type i = 0; i < NB_MARKS; ++i) for ( size_type i = 0; i < NB_MARKS; ++i)
this->mnb_marked_darts[i] = 0; this->mnb_marked_darts[i] = 0;
@ -553,12 +554,6 @@ namespace CGAL {
this->init_storage(); this->init_storage();
} }
/** Test if the map is empty.
* @return true iff the map is empty.
*/
bool is_empty() const
{ return mdarts.empty(); }
friend std::ostream& operator<< (std::ostream& os, const Self& amap) friend std::ostream& operator<< (std::ostream& os, const Self& amap)
{ {
save_generalized_map(amap, os); save_generalized_map(amap, os);
@ -604,26 +599,43 @@ namespace CGAL {
mdarts.erase(adart); mdarts.erase(adart);
} }
/** Erase a dart from the list of darts. Restricted version
* which do not delete attribute having no more dart associated.
* @param adart the dart to erase.
*/
void restricted_erase_dart(Dart_handle adart)
{
// 1) We update the number of marked darts.
for ( size_type i = 0; i < mnb_used_marks; ++i)
{
if (is_marked(adart, mused_marks_stack[i]))
--mnb_marked_darts[mused_marks_stack[i]];
}
// 2) We update the attribute_ref_counting.
Helper::template Foreach_enabled_attributes
<internal::Restricted_decrease_attribute_functor<Self> >::run(*this,adart);
// 3) We erase the dart.
mdarts.erase(adart);
}
/// @return true if dh points to a used dart (i.e. valid). /// @return true if dh points to a used dart (i.e. valid).
bool is_dart_used(Dart_const_handle dh) const bool is_dart_used(Dart_const_handle dh) const
{ return mdarts.is_used(dh); } { return mdarts.is_used(dh); }
/// @return a Dart_range (range through all the darts of the map).
Dart_range& darts() { return mdarts;}
Dart_const_range& darts() const { return mdarts; }
/** Get the first dart of this map. /** Get the first dart of this map.
* @return the first dart. * @return the first dart.
*/ */
Dart_handle first_dart() Dart_handle first_dart()
{ {
if (darts().begin() == darts().end()) return null_handle; if (darts().begin() == darts().end()) return null_handle;
return mdarts.begin(); return darts().begin();
} }
Dart_const_handle first_dart() const Dart_const_handle first_dart() const
{ {
if (darts().begin() == darts().end()) return null_handle; if (darts().begin() == darts().end()) return null_handle;
return mdarts.begin(); return darts().begin();
} }
/// @return the Dart_handle corresponding to the given dart. /// @return the Dart_handle corresponding to the given dart.
@ -669,6 +681,31 @@ namespace CGAL {
return null_handle; return null_handle;
} }
// Set the handle on the i th attribute
// Restricted version which do not use delete attributes when their ref
// counting become null, nor that update the dart of attribute.
template<unsigned int i>
void restricted_set_dart_attribute(Dart_handle dh,
typename Attribute_handle<i>::type ah)
{
CGAL_static_assertion_msg(Helper::template Dimension_index<i>::value>=0,
"set_dart_attribute<i> called but i-attributes are disabled.");
if ( this->template attribute<i>(dh)==ah ) return;
if ( this->template attribute<i>(dh)!=null_handle )
{
this->template dec_attribute_ref_counting<i>(this->template attribute<i>(dh));
}
Base::template basic_set_dart_attribute<i>(dh, ah);
if ( ah!=null_handle )
{
this->template inc_attribute_ref_counting<i>(ah);
}
}
// Set the handle on the i th attribute // Set the handle on the i th attribute
template<unsigned int i> template<unsigned int i>
void set_dart_attribute(Dart_handle dh, void set_dart_attribute(Dart_handle dh,
@ -712,6 +749,8 @@ namespace CGAL {
Helper::template Foreach_enabled_attributes Helper::template Foreach_enabled_attributes
<internal::Init_attribute_functor<Self> >::run(*this, adart); <internal::Init_attribute_functor<Self> >::run(*this, adart);
internal::Init_id<Dart_container>::run(mdarts, adart);
} }
// Initialize a given dart: all alpha to this and all // Initialize a given dart: all alpha to this and all
// attributes to null, marks are given. // attributes to null, marks are given.
@ -725,6 +764,8 @@ namespace CGAL {
Helper::template Foreach_enabled_attributes Helper::template Foreach_enabled_attributes
<internal::Init_attribute_functor<Self> >::run(*this, adart); <internal::Init_attribute_functor<Self> >::run(*this, adart);
internal::Init_id<Dart_container>::run(mdarts, adart);
} }
public: public:
@ -1168,7 +1209,7 @@ namespace CGAL {
/** Test if the map is valid. /** Test if the map is valid.
* @return true iff the map is valid. * @return true iff the map is valid.
*/ */
bool is_valid() const bool is_valid(bool show_errors=true) const
{ {
bool valid = true; bool valid = true;
unsigned int i = 0, j = 0; unsigned int i = 0, j = 0;
@ -1194,9 +1235,11 @@ namespace CGAL {
for ( i = 0; i <= dimension; ++i) for ( i = 0; i <= dimension; ++i)
if (alpha(it, i, i)!=it) if (alpha(it, i, i)!=it)
{ {
std::cerr << "Map not valid: alpha(" << i if (show_errors)
{ std::cerr << "Map not valid: alpha(" << i
<< ") is not an involution for dart " << ") is not an involution for dart "
<<darts().index(it)<< std::endl; <<darts().index(it)<< std::endl;
}
valid = false; valid = false;
} }
@ -1206,10 +1249,12 @@ namespace CGAL {
for ( j = i + 2; j <= dimension; ++j) for ( j = i + 2; j <= dimension; ++j)
if (alpha(it, i, j)!=alpha(it, j, i)) if (alpha(it, i, j)!=alpha(it, j, i))
{ {
std::cerr <<"Map not valid: alpha(" << i if (show_errors)
<<") o alpha(" << j { std::cerr <<"Map not valid: alpha(" << i
<<") is not an involution for dart " <<") o alpha(" << j
<<darts().index(it)<< std::endl; <<") is not an involution for dart "
<<darts().index(it)<< std::endl;
}
valid = false; valid = false;
} }
} }
@ -1259,10 +1304,6 @@ namespace CGAL {
run(*this); run(*this);
} }
/// @return the number of darts.
size_type number_of_darts() const
{ return mdarts.size(); }
/// @return an estimation of the bytes used by the generalized map. /// @return an estimation of the bytes used by the generalized map.
size_type bytes() const size_type bytes() const
{ {
@ -1375,6 +1416,8 @@ namespace CGAL {
// Reinitialize the ref counting of the new attribute. This is normally // Reinitialize the ref counting of the new attribute. This is normally
// not required except if create_attribute is used as "copy contructor". // not required except if create_attribute is used as "copy contructor".
this->template init_attribute_ref_counting<i>(res); this->template init_attribute_ref_counting<i>(res);
internal::Init_id<typename Attribute_range<i>::type>::run
(this->template attributes<i>(), res);
return res; return res;
} }
@ -1757,6 +1800,30 @@ namespace CGAL {
else topo_unsew<i>(adart); else topo_unsew<i>(adart);
} }
/// Keep the biggest connected component.
/// @return the size (in number of darts) of the biggest cc.
std::size_t keep_biggest_connected_component()
{
std::map<std::size_t, Dart_handle> ccs;
size_type treated=get_new_mark();
for (auto it=darts().begin(), itend=darts().end(); it!=itend; ++it)
{
if (!is_marked(it, treated))
{ ccs[mark_cell<dimension+1>(it, treated)]=it; }
}
if (ccs.size()>1)
{ // Here all darts are marked
this->template unmark_cell<dimension+1>(ccs.rbegin()->second, treated); // Unmark the biggest cc
erase_marked_darts(treated);
}
free_mark(treated);
return ccs.rbegin()->first;
}
/** Count the marked cells (at least one marked dart). /** Count the marked cells (at least one marked dart).
* @param amark the mark to consider. * @param amark the mark to consider.
* @param avector containing the dimensions of the cells to count. * @param avector containing the dimensions of the cells to count.
@ -1890,6 +1957,7 @@ namespace CGAL {
} }
public: public:
/// @return the positive turn between the two given darts. /// @return the positive turn between the two given darts.
// @pre next(d1) and d2 must belong to the same vertex. // @pre next(d1) and d2 must belong to the same vertex.
std::size_t positive_turn(Dart_const_handle d1, Dart_const_handle d2) const std::size_t positive_turn(Dart_const_handle d1, Dart_const_handle d2) const
@ -2527,7 +2595,7 @@ namespace CGAL {
if (!is_marked(current, m1)) if (!is_marked(current, m1))
{ {
if (map2.is_marked(other, m2)) if (map2.is_marked(other, m2))
match=false; { match=false; }
else else
{ {
bijection[current] = other; bijection[current] = other;
@ -3050,7 +3118,7 @@ namespace CGAL {
* @param adart an intial dart * @param adart an intial dart
* @return true iff the volume containing adart is a combinatorial tetrahedron. * @return true iff the volume containing adart is a combinatorial tetrahedron.
*/ */
bool is_volume_combinatorial_tetrahedron(Dart_const_handle d1) bool is_volume_combinatorial_tetrahedron(Dart_const_handle d1) const
{ {
Dart_const_handle d2 = alpha(d1, 0, 2); Dart_const_handle d2 = alpha(d1, 0, 2);
Dart_const_handle d3 = alpha(d2, 1, 2); Dart_const_handle d3 = alpha(d2, 1, 2);
@ -3127,7 +3195,7 @@ namespace CGAL {
* @param adart an intial dart * @param adart an intial dart
* @return true iff the volume containing adart is a combinatorial hexahedron. * @return true iff the volume containing adart is a combinatorial hexahedron.
*/ */
bool is_volume_combinatorial_hexahedron(Dart_const_handle d1) bool is_volume_combinatorial_hexahedron(Dart_const_handle d1) const
{ {
Dart_const_handle d2 = alpha(d1,1,0,1,2); Dart_const_handle d2 = alpha(d1,1,0,1,2);
Dart_const_handle d3 = alpha(d2,1,0,1,2); Dart_const_handle d3 = alpha(d2,1,0,1,2);
@ -3612,7 +3680,7 @@ namespace CGAL {
* @param afirst iterator on the beginning of the path. * @param afirst iterator on the beginning of the path.
* @param alast iterator on the end of the path. * @param alast iterator on the end of the path.
* @return true iff a 2-cell can be inserted along the path. * @return true iff a 2-cell can be inserted along the path.
* the path is a sequence of dartd, one per edge * the path is a sequence of dart, one per edge
* where the face will be inserted. * where the face will be inserted.
*/ */
template <class InputIterator> template <class InputIterator>
@ -3919,6 +3987,68 @@ namespace CGAL {
{} {}
}; };
namespace Index
{
template<unsigned int d_, class Items_, class Alloc_,class Storage_>
class Generalized_map :
public Generalized_map_base<d_,
Generalized_map<d_,Items_,Alloc_, Storage_>,
Items_, Alloc_, Storage_ >
{
public:
typedef Generalized_map<d_, Items_,Alloc_, Storage_> Self;
typedef Generalized_map_base<d_, Self, Items_, Alloc_, Storage_> Base;
typedef typename Base::Dart_handle Dart_handle;
typedef typename Base::Dart_const_handle Dart_const_handle;
typedef typename Base::Alloc Alloc;
typedef typename Base::Exception_no_more_available_mark
Exception_no_more_available_mark;
Generalized_map() : Base()
{}
Generalized_map(const Self & amap) : Base(amap)
{}
Generalized_map(Self && amap) : Base(amap)
{}
template <unsigned int d2, typename Refs2, typename Items2, typename Alloc2,
typename Storage2>
Generalized_map(const Generalized_map_base<d2, Refs2, Items2, Alloc2, Storage2>& amap) :
Base(amap)
{}
template <unsigned int d2, typename Refs2, typename Items2, typename Alloc2,
typename Storage2, typename Converters>
Generalized_map(const Generalized_map_base<d2, Refs2, Items2, Alloc2, Storage2>& amap,
const Converters& converters) :
Base(amap, converters)
{}
template <unsigned int d2, typename Refs2, typename Items2, typename Alloc2,
typename Storage2,
typename Converters, typename DartInfoConverter>
Generalized_map(const Generalized_map_base<d2, Refs2, Items2, Alloc2, Storage2>& amap,
const Converters& converters,
const DartInfoConverter& dartinfoconverter) :
Base(amap, converters, dartinfoconverter)
{}
template <unsigned int d2, typename Refs2, typename Items2, typename Alloc2,
typename Storage2,
typename Converters, typename DartInfoConverter,
typename PointConverter >
Generalized_map(const Generalized_map_base<d2, Refs2, Items2, Alloc2, Storage2>& amap,
const Converters& converters,
const DartInfoConverter& dartinfoconverter,
const PointConverter& pointconverter) :
Base(amap, converters, dartinfoconverter, pointconverter)
{}
};
} // namespace Index
} // namespace CGAL } // namespace CGAL
#if defined(BOOST_GCC) #if defined(BOOST_GCC)

33
Generalized_map/include/CGAL/Generalized_map_storages.h
View File

@ -34,17 +34,13 @@ namespace CGAL {
struct Container_type; struct Container_type;
} }
/** @file Generalized_map_storages.h
* Definition of storages for dD Generalized map.
*/
// Storage of darts with compact container, alpha with handles // Storage of darts with compact container, alpha with handles
template<unsigned int d_, class Items_, class Alloc_, class Concurrent_tag > template<unsigned int d_, class Items_, class Alloc_, class Concurrent_tag >
class Generalized_map_storage_1 class Generalized_map_storage_1
{ {
public: public:
typedef Generalized_map_storage_1<d_, Items_, Alloc_, Concurrent_tag> Self; using Self=Generalized_map_storage_1<d_, Items_, Alloc_, Concurrent_tag>;
typedef CGAL::Tag_false Use_index; using Use_index=CGAL::Tag_false;
typedef internal::Combinatorial_map_helper<Self> Helper; typedef internal::Combinatorial_map_helper<Self> Helper;
@ -62,7 +58,6 @@ namespace CGAL {
typedef typename internal::Container_type typedef typename internal::Container_type
<Concurrent_tag, Dart, Dart_allocator>::type Dart_container; <Concurrent_tag, Dart, Dart_allocator>::type Dart_container;
typedef typename Dart_container::iterator Dart_handle; typedef typename Dart_container::iterator Dart_handle;
typedef typename Dart_container::const_iterator Dart_const_handle; typedef typename Dart_container::const_iterator Dart_const_handle;
typedef typename Dart_container::size_type size_type; typedef typename Dart_container::size_type size_type;
@ -72,7 +67,6 @@ namespace CGAL {
typedef Items_ Items; typedef Items_ Items;
typedef Alloc_ Alloc; typedef Alloc_ Alloc;
template <typename T> template <typename T>
struct Container_for_attributes : struct Container_for_attributes :
public internal::Container_type public internal::Container_type
@ -109,14 +103,33 @@ namespace CGAL {
typedef Handle_hash_function Hash_function; typedef Handle_hash_function Hash_function;
typedef Dart_container Dart_range;
typedef const Dart_container Dart_const_range;
/// @return a Dart_range (range through all the darts of the map).
Dart_range& darts() { return mdarts;}
Dart_const_range& darts() const { return mdarts; }
// Init // Init
void init_storage() void init_storage()
{ null_dart_handle=nullptr; } { null_dart_handle=nullptr; }
/** Return if this dart is free for adimension. void clear_storage()
{}
/** Test if the map is empty.
* @return true iff the map is empty.
*/
bool is_empty() const
{ return mdarts.empty(); }
/// @return the number of darts.
size_type number_of_darts() const
{ return mdarts.size(); }
/** Return if this dart is free for adimension.
* @param dh a dart handle * @param dh a dart handle
* @param i the dimension. * @param i the dimension.
* @return true iff dh is linked with nullptr for \em adimension. * @return true iff dh is linked with itself for \em adimension.
*/ */
template<unsigned int i> template<unsigned int i>
bool is_free(Dart_const_handle dh) const bool is_free(Dart_const_handle dh) const

439
Generalized_map/include/CGAL/Generalized_map_storages_with_index.h Normal file
View File

@ -0,0 +1,439 @@
// Copyright (c) 2016 CNRS and LIRIS' Establishments (France).
// All rights reserved.
//
// This file is part of CGAL (www.cgal.org)
//
// $URL$
// $Id$
// SPDX-License-Identifier: LGPL-3.0-or-later OR LicenseRef-Commercial
//
// Author(s) : Guillaume Damiand <guillaume.damiand@liris.cnrs.fr>
//
#ifndef CGAL_GENERALIZED_MAP_STORAGES_WITH_INDEX_H
#define CGAL_GENERALIZED_MAP_STORAGES_WITH_INDEX_H 1
#include <CGAL/Compact_container_with_index_2.h>
#include <CGAL/Dart.h>
#include <bitset>
#include <boost/config.hpp>
#if defined(BOOST_GCC)
_Pragma("GCC diagnostic push")
_Pragma("GCC diagnostic ignored \"-Warray-bounds\"")
#endif
namespace CGAL {
namespace internal {
template <typename M>
struct Combinatorial_map_helper;
template<typename Concurrent_tag, class T, class Alloc_>
struct Container_type;
}
// Storage of darts with compact container, alpha with indices
template<unsigned int d_, class Items_, class Alloc_, class Index_type_ >
class Generalized_map_storage_2
{
public:
using Self=Generalized_map_storage_2<d_, Items_, Alloc_, Index_type_>;
using Use_index=CGAL::Tag_true;
using Index_type=Index_type_;
typedef internal::Combinatorial_map_helper<Self> Helper;
typedef typename Items_::template Dart_wrapper<Self> Dart_wrapper;
typedef typename internal::template Get_dart_info<Dart_wrapper>::type
Dart_info;
typedef CGAL::Index::Dart<d_, Self, Dart_info> Dart;
typedef std::allocator_traits<Alloc_> Allocator_traits;
typedef typename Allocator_traits::template rebind_alloc<Dart> Dart_allocator;
typedef Compact_container_with_index_2<Dart,Dart_allocator,
Multiply_by_two_policy_for_cc_with_size<64>, Index_type>
Dart_container;
// typedef unsigned int Dart_index;
// typedef MyIndex<unsigned int> Dart_index;
typedef typename Dart_container::Index Dart_index;
// Definition of old types, for backward compatibility.
typedef Dart_index Dart_handle;
typedef Dart_index Dart_const_handle;
typedef typename Dart_container::size_type size_type;
typedef Dart_index Null_handle_type;
static Null_handle_type null_handle;
typedef Items_ Items;
typedef Alloc_ Alloc;
template <typename T>
struct Container_for_attributes : public
Compact_container_with_index_2<T,
typename Alloc_::template rebind<T>::other,
Multiply_by_two_policy_for_cc_with_size<64>, size_type >
{};
/// Typedef for attributes
typedef typename internal::template Get_attributes_tuple<Dart_wrapper>::type
Attributes;
template<int i>
struct Attribute_type: public Helper::template Attribute_type<i>
{};
template<int i>
struct Attribute_handle: public Helper::template Attribute_handle<i>
{};
template<int i>
struct Attribute_const_handle:
public Helper::template Attribute_const_handle<i>
{};
template<int i>
struct Attribute_range: public Helper::template Attribute_range<i>
{};
template<int i>
struct Attribute_const_range:
public Helper::template Attribute_const_range<i>
{};
/// Number of marks
static const size_type NB_MARKS = 32;
/// The dimension of the generalized map.
static const unsigned int dimension = d_;
typedef internal::Index_hash_function Hash_function;
typedef Dart_container Dart_range;
typedef const Dart_container Dart_const_range;
/// @return a Dart_range (range through all the darts of the map).
Dart_range& darts() { return mdarts;}
Dart_const_range& darts() const { return mdarts; }
// Init
void init_storage()
{ null_dart_handle=nullptr; }
void clear_storage()
{}
/** Test if the map is empty.
* @return true iff the map is empty.
*/
bool is_empty() const
{ return mdarts.empty(); }
/// @return the number of darts.
size_type number_of_darts() const
{ return mdarts.size(); }
/** Return if this dart is free for adimension.
* @param dh a dart handle
* @param i the dimension.
* @return true iff dh is linked with itself for \em adimension.
*/
template<unsigned int i>
bool is_free(Dart_const_handle dh) const
{
CGAL_assertion(i <= dimension);
return mdarts[dh].mf[i]==dh;
}
bool is_free(Dart_const_handle dh, unsigned int i) const
{
CGAL_assertion(i <= dimension);
return mdarts[dh].mf[i]==dh;
}
bool is_perforated(Dart_const_handle /*dh*/) const
{ return false; }
/// Set simultaneously all the marks of this dart to a given value.
void set_dart_marks(Dart_const_handle ADart,
const std::bitset<NB_MARKS>& amarks) const
{
mdarts[ADart].set_marks(amarks);
}
/// Return all the marks of a dart.
std::bitset<NB_MARKS> get_dart_marks(Dart_const_handle ADart) const
{
return mdarts[ADart].get_marks();
}
/// Return the mark value of dart a given mark number.
bool get_dart_mark(Dart_const_handle ADart, size_type amark) const
{
return mdarts[ADart].get_mark(amark);
}
/// Set the mark of a given mark number to a given value.
void set_dart_mark(Dart_const_handle ADart, size_type amark, bool avalue) const
{
mdarts[ADart].set_mark(amark, avalue);
}
/// Flip the mark of a given mark number to a given value.
void flip_dart_mark(Dart_const_handle ADart, size_type amark) const
{
mdarts[ADart].flip_mark(amark);
}
// Access to alpha maps
Dart_handle get_alpha(Dart_handle ADart, int B1)
{
CGAL_assertion(B1>=0 && B1<=(int)dimension);
return mdarts[ADart].mf[B1];
}
Dart_const_handle get_alpha(Dart_const_handle ADart, int B1) const
{
CGAL_assertion(B1>=0 && B1<=(int)dimension);
return mdarts[ADart].mf[B1];
}
template<int B1>
Dart_handle get_alpha(Dart_handle ADart)
{
CGAL_assertion(B1>=0 && B1<=(int)dimension);
return mdarts[ADart].mf[B1];
}
template<int B1>
Dart_const_handle get_alpha(Dart_const_handle ADart) const
{
CGAL_assertion(B1>=0 && B1<=(int)dimension);
return mdarts[ADart].mf[B1];
}
// return a handle on the i-attribute
template<unsigned int i>
typename Attribute_handle<i>::type attribute(Dart_handle ADart)
{
CGAL_static_assertion_msg(Helper::template Dimension_index<i>::value>=0,
"attribute<i> called but i-attributes are disabled.");
return std::get<Helper::template Dimension_index<i>::value>
(mdarts[ADart].mattribute_handles);
}
template<unsigned int i>
typename Attribute_const_handle<i>::type
attribute(Dart_const_handle ADart) const
{
CGAL_static_assertion_msg(Helper::template Dimension_index<i>::value>=0,
"attribute<i> called but i-attributes are disabled.");
return std::get<Helper::template Dimension_index<i>::value>
(mdarts[ADart].mattribute_handles);
}
// Copy a given attribute
template<unsigned int i>
typename Attribute_handle<i>::type copy_attribute
(typename Attribute_const_handle<i>::type ah)
{
CGAL_static_assertion_msg(Helper::template Dimension_index<i>::value>=0,
"copy_attribute<i> called but i-attributes are disabled.");
typename Attribute_handle<i>::type res=
std::get<Helper::template Dimension_index<i>::value>
(mattribute_containers).emplace(get_attribute<i>(ah));
this->template init_attribute_ref_counting<i>(res);
return res;
}
// Test if a given attribute is valid
template<unsigned int i>
bool is_valid_attribute(typename Attribute_const_handle<i>::type ah) const
{
return get_attribute<i>(ah).is_valid();
}
// accessors and modifiers to the attribute ref counting given its handle
template<unsigned int i>
std::size_t get_attribute_ref_counting
(typename Attribute_const_handle<i>::type ah) const
{
return get_attribute<i>(ah).get_nb_refs();
}
template<unsigned int i>
void init_attribute_ref_counting(typename Attribute_handle<i>::type ah)
{
get_attribute<i>(ah).mrefcounting=0;
}
template<unsigned int i>
void inc_attribute_ref_counting(typename Attribute_handle<i>::type ah)
{
get_attribute<i>(ah).inc_nb_refs();
}
template<unsigned int i>
void dec_attribute_ref_counting(typename Attribute_handle<i>::type ah)
{
get_attribute<i>(ah).dec_nb_refs();
}
// get the attribute given its index
template<unsigned int i>
typename Attribute_type<i>::type&
get_attribute(typename Attribute_handle<i>::type ah)
{
CGAL_assertion( ah!=null_handle );
return std::get<Helper::template Dimension_index<i>::value>
(mattribute_containers)[ah];
}
template<unsigned int i>
const typename Attribute_type<i>::type&
get_attribute(typename Attribute_const_handle<i>::type ah) const
{
CGAL_assertion( ah!=null_handle );
return std::get<Helper::template Dimension_index<i>::value>
(mattribute_containers)[ah];
}
// Get the dart of the given attribute
template<unsigned int i>
Dart_handle dart_of_attribute(typename Attribute_handle<i>::type ah)
{
CGAL_assertion( ah!=null_handle );
return get_attribute<i>(ah).dart();
}
template<unsigned int i>
Dart_const_handle
dart_of_attribute(typename Attribute_const_handle<i>::type ah) const
{
CGAL_assertion( ah!=null_handle );
return get_attribute<i>(ah).dart();
}
// Set the dart of the given attribute
template<unsigned int i>
void set_dart_of_attribute(typename Attribute_handle<i>::type ah,
Dart_handle adart)
{
CGAL_assertion( ah!=null_handle );
get_attribute<i>(ah).set_dart(adart);
}
// Get the information associated with a given dart
Dart_info& info(Dart_handle adart)
{ return mdarts[adart].info(); }
const Dart_info& info(Dart_const_handle adart) const
{ return mdarts[adart].info(); }
// Get the info of the given attribute
template<unsigned int i>
typename Attribute_type<i>::type::Info &
info_of_attribute(typename Attribute_handle<i>::type ah)
{
CGAL_assertion( ah!=null_handle );
return get_attribute<i>(ah).info();
}
template<unsigned int i>
const typename Attribute_type<i>::type::Info &
info_of_attribute(typename Attribute_const_handle<i>::type ah) const
{
CGAL_assertion( ah!=null_handle );
return get_attribute<i>(ah).info();
}
// Get the info of the i-cell attribute associated with the given dart
template<unsigned int i>
typename Attribute_type<i>::type::Info & info(Dart_handle adart)
{
CGAL_assertion( adart!=null_handle );
CGAL_assertion( this->template attribute<i>(adart)!=null_handle );
return info_of_attribute<i>(attribute<i>(adart));
}
template<unsigned int i>
const typename Attribute_type<i>::type::Info &
info(Dart_const_handle adart) const
{
CGAL_assertion( adart!=null_handle );
CGAL_assertion( attribute<i>(adart)!=null_handle );
return info_of_attribute<i>(attribute<i>(adart));
}
// Get the dart of the i-cell attribute associated with the given dart
template<unsigned int i>
Dart_handle dart(Dart_handle adart)
{
CGAL_assertion( adart!=null_handle );
CGAL_assertion( attribute<i>(adart)!=null_handle );
return dart_of_attribute<i>(attribute<i>(adart));
}
template<unsigned int i>
Dart_const_handle dart(Dart_const_handle adart) const
{
CGAL_assertion( adart!=null_handle );
CGAL_assertion( attribute<i>(adart)!=null_handle );
return dart_of_attribute<i>(attribute<i>(adart));
}
// Debug function
void display_dart(Dart_const_handle ADart) const
{ std::cout<<ADart; }
template<unsigned int i>
void display_attribute(typename Attribute_const_handle<i>::type ah) const
{ std::cout<<ah; }
protected:
// Set the handle on the i th attribute
template<unsigned int i>
void basic_set_dart_attribute(Dart_handle dh,
typename Attribute_handle<i>::type ah)
{
std::get<Helper::template Dimension_index<i>::value>
(mdarts[dh].mattribute_handles) = ah;
}
/** Link a dart with a given dart for a given dimension.
* @param adart the dart to link.
* @param adart2 the dart to link with.
* @param i the dimension.
*/
template<unsigned int i>
void dart_link_alpha(Dart_handle adart, Dart_handle adart2)
{
CGAL_assertion(i <= dimension);
CGAL_assertion(adart!=nullptr && adart2!=nullptr);
mdarts[adart].mf[i] = adart2;
}
void dart_link_alpha(Dart_handle adart, Dart_handle adart2, unsigned int i)
{
CGAL_assertion(i <= dimension);
CGAL_assertion(adart!=nullptr && adart2!=nullptr);
mdarts[adart].mf[i] = adart2;
}
/** Unlink a dart for a given dimension.
* @param adart a dart.
* @param i the dimension.
*/
template<unsigned int i>
void dart_unlink_alpha(Dart_handle adart)
{
CGAL_assertion(adart!=nullptr && i <= dimension);
mdarts[adart].mf[i] = adart;
}
void dart_unlink_alpha(Dart_handle adart, unsigned int i)
{
CGAL_assertion(adart!=nullptr && i <= dimension);
mdarts[adart].mf[i] = adart;
}
protected:
Dart_handle null_dart_handle; // To be compatible with combinatorial map
/// Dart container.
Dart_container mdarts;
/// Tuple of attributes containers
typename Helper::Attribute_containers mattribute_containers;
};
/// null_handle
template<unsigned int d_, class Items_, class Alloc_, class Size_type>
typename Generalized_map_storage_2<d_, Items_, Alloc_, Size_type>::Null_handle_type
Generalized_map_storage_2<d_, Items_, Alloc_, Size_type>::null_handle((std::numeric_limits<size_type>::max)()/2);
} // namespace CGAL
#if defined(BOOST_GCC)
_Pragma("GCC diagnostic pop")
#endif
#endif // CGAL_GENERALIZED_MAP_STORAGES_WITH_INDEX_H //
// EOF //

11
Linear_cell_complex/include/CGAL/CMap_linear_cell_complex_storages.h
View File

@ -34,9 +34,6 @@ namespace CGAL {
struct Container_type; struct Container_type;
} }
/** @file CMap_linear_cell_complex_storages.h
* Definition of storages for dD Linear cell complex for combinatorial maps.
*/
// Storage of darts with compact container, beta with handles // Storage of darts with compact container, beta with handles
// Copy of Combinatorial_map_storage_1 and add new types related // Copy of Combinatorial_map_storage_1 and add new types related
// to geometry (not possible to inherith because we use Self type // to geometry (not possible to inherith because we use Self type
@ -47,9 +44,9 @@ namespace CGAL {
class CMap_linear_cell_complex_storage_1 class CMap_linear_cell_complex_storage_1
{ {
public: public:
typedef CMap_linear_cell_complex_storage_1<d_, ambient_dim, Traits_, using Self=CMap_linear_cell_complex_storage_1<d_, ambient_dim, Traits_,
Items_, Alloc_, Concurrent_tag> Self; Items_, Alloc_, Concurrent_tag>;
typedef CGAL::Tag_false Use_index; using Use_index=CGAL::Tag_false;
typedef typename Traits_::Point Point; typedef typename Traits_::Point Point;
typedef typename Traits_::Vector Vector; typedef typename Traits_::Vector Vector;
@ -156,7 +153,7 @@ namespace CGAL {
/** Return if this dart is free for adimension. /** Return if this dart is free for adimension.
* @param dh a dart handle * @param dh a dart handle
* @param i the dimension. * @param i the dimension.
* @return true iff dh is linked with nullptr for \em adimension. * @return true iff dh is linked with null_dart_handle for \em adimension.
*/ */
template<unsigned int i> template<unsigned int i>
bool is_free(Dart_const_handle dh) const bool is_free(Dart_const_handle dh) const

37
Linear_cell_complex/include/CGAL/CMap_linear_cell_complex_storages_with_index.h
View File

@ -14,7 +14,6 @@
#include <CGAL/Compact_container_with_index_2.h> #include <CGAL/Compact_container_with_index_2.h>
#include <CGAL/Dart.h> #include <CGAL/Dart.h>
#include <CGAL/Combinatorial_map_storages_with_index.h>
#include <bitset> #include <bitset>
#include <boost/config.hpp> #include <boost/config.hpp>
@ -33,16 +32,13 @@ namespace CGAL {
struct Container_type; struct Container_type;
} }
/** @file CMap_linear_cell_complex_storages_with_index.h // Storage of darts with compact container, alpha using index
* Definition of storages for dD Linear cell complex for combinatorial maps index version.
*/
// Storage with combinatorial maps using index
// Copy of Combinatorial_map_storage_2 and add new types related // Copy of Combinatorial_map_storage_2 and add new types related
// to geometry (not possible to inherith because we use Self type // to geometry (not possible to inherith because we use Self type
// as template parameter of Dart_wrapper. If we inherit, Self is not // as template parameter of Dart_wrapper. If we inherit, Self is not
// the correct type.) // the correct type).
template<unsigned int d_, unsigned int ambient_dim, template<unsigned int d_, unsigned int ambient_dim, class Traits_,
class Traits_, class Items_, class Alloc_, class Index_type_ > class Items_, class Alloc_, class Index_type_ >
class CMap_linear_cell_complex_storage_2 class CMap_linear_cell_complex_storage_2
{ {
public: public:
@ -206,6 +202,8 @@ namespace CGAL {
CGAL_assertion(i <= dimension); CGAL_assertion(i <= dimension);
return mdarts[dh].mf[i]==null_dart_handle; return mdarts[dh].mf[i]==null_dart_handle;
} }
bool is_perforated(Dart_const_handle /*dh*/) const
{ return false; }
/// Set simultaneously all the marks of this dart to a given value. /// Set simultaneously all the marks of this dart to a given value.
void set_dart_marks(Dart_const_handle ADart, void set_dart_marks(Dart_const_handle ADart,
@ -239,24 +237,24 @@ namespace CGAL {
// Access to beta maps // Access to beta maps
Dart_handle get_beta(Dart_handle ADart, int B1) Dart_handle get_beta(Dart_handle ADart, int B1)
{ {
CGAL_assertion(B1>=0 && B1<=dimension); CGAL_assertion(B1>=0 && B1<=(int)dimension);
return mdarts[ADart].mf[B1]; return mdarts[ADart].mf[B1];
} }
Dart_const_handle get_beta(Dart_const_handle ADart, int B1) const Dart_const_handle get_beta(Dart_const_handle ADart, int B1) const
{ {
CGAL_assertion(B1>=0 && B1<=dimension); CGAL_assertion(B1>=0 && B1<=(int)dimension);
return mdarts[ADart].mf[B1]; return mdarts[ADart].mf[B1];
} }
template<int B1> template<int B1>
Dart_handle get_beta(Dart_handle ADart) Dart_handle get_beta(Dart_handle ADart)
{ {
CGAL_assertion(B1>=0 && B1<=dimension); CGAL_assertion(B1>=0 && B1<=(int)dimension);
return mdarts[ADart].mf[B1]; return mdarts[ADart].mf[B1];
} }
template<int B1> template<int B1>
Dart_const_handle get_beta(Dart_const_handle ADart) const Dart_const_handle get_beta(Dart_const_handle ADart) const
{ {
CGAL_assertion(B1>=0 && B1<=dimension); CGAL_assertion(B1>=0 && B1<=(int)dimension);
return mdarts[ADart].mf[B1]; return mdarts[ADart].mf[B1];
} }
@ -445,11 +443,11 @@ namespace CGAL {
protected: protected:
// Set the handle on the i th attribute // Set the handle on the i th attribute
template<unsigned int i> template<unsigned int i>
void basic_set_dart_attribute(Dart_handle ADart, void basic_set_dart_attribute(Dart_handle dh,
typename Attribute_handle<i>::type ah) typename Attribute_handle<i>::type ah)
{ {
std::get<Helper::template Dimension_index<i>::value> std::get<Helper::template Dimension_index<i>::value>
(mdarts[ADart].mattribute_handles) = ah; (mdarts[dh].mattribute_handles) = ah;
} }
/** Link a dart with a given dart for a given dimension. /** Link a dart with a given dart for a given dimension.
@ -496,6 +494,9 @@ namespace CGAL {
Dart_container mdarts; Dart_container mdarts;
Dart_range mdarts_range; Dart_range mdarts_range;
/// Container for the null_dart_handle: unused; to be compatible with handle version
Dart_container mnull_dart_container;
/// Tuple of attributes containers /// Tuple of attributes containers
typename Helper::Attribute_containers mattribute_containers; typename Helper::Attribute_containers mattribute_containers;
}; };
@ -508,11 +509,11 @@ namespace CGAL {
null_dart_handle(0); null_dart_handle(0);
/// null_handle /// null_handle
template<unsigned int d_, unsigned int ambient_dim, template<unsigned int d_, unsigned int ambient_dim, class Traits_,
class Traits_, class Items_, class Alloc_, class Index_type_> class Items_, class Alloc_, class Index_type_>
typename CMap_linear_cell_complex_storage_2<d_, ambient_dim, Traits_, Items_, Alloc_, Index_type_>:: typename CMap_linear_cell_complex_storage_2<d_, ambient_dim, Traits_, Items_, Alloc_, Index_type_>::
Null_handle_type CMap_linear_cell_complex_storage_2<d_, ambient_dim, Traits_, Null_handle_type CMap_linear_cell_complex_storage_2<d_, ambient_dim, Traits_,
Items_, Alloc_, Index_type_>:: Items_, Alloc_, Index_type_>::
null_handle((std::numeric_limits<Index_type_>::max)()/2); null_handle((std::numeric_limits<Index_type_>::max)()/2);
} // namespace CGAL } // namespace CGAL

36
Linear_cell_complex/include/CGAL/GMap_linear_cell_complex_storages.h
View File

@ -13,6 +13,7 @@
#define CGAL_GMAP_LINEAR_CELL_COMPLEX_STORAGES_H 1 #define CGAL_GMAP_LINEAR_CELL_COMPLEX_STORAGES_H 1
#include <CGAL/Compact_container.h> #include <CGAL/Compact_container.h>
#include <CGAL/Concurrent_compact_container.h>
#include <CGAL/Dart.h> #include <CGAL/Dart.h>
#include <CGAL/Handle_hash_function.h> #include <CGAL/Handle_hash_function.h>
#include <bitset> #include <bitset>
@ -33,10 +34,6 @@ namespace CGAL {
struct Container_type; struct Container_type;
} }
/** @file GMap_linear_cell_complex_storages.h
* Definition of storages for dD Linear cell complex for generalized map.
*/
// Storage of darts with compact container, alpha with handles // Storage of darts with compact container, alpha with handles
// Copy of Generalized_map_storage_1 and add new types related // Copy of Generalized_map_storage_1 and add new types related
// to geometry (not possible to inherith because we use Self type // to geometry (not possible to inherith because we use Self type
@ -47,14 +44,14 @@ namespace CGAL {
class GMap_linear_cell_complex_storage_1 class GMap_linear_cell_complex_storage_1
{ {
public: public:
using Self=GMap_linear_cell_complex_storage_1<d_, ambient_dim, Traits_,
Items_, Alloc_, Concurrent_tag>;
using Use_index=CGAL::Tag_false;
typedef typename Traits_::Point Point; typedef typename Traits_::Point Point;
typedef typename Traits_::Vector Vector; typedef typename Traits_::Vector Vector;
typedef typename Traits_::FT FT; typedef typename Traits_::FT FT;
typedef GMap_linear_cell_complex_storage_1<d_, ambient_dim, Traits_,
Items_, Alloc_, Concurrent_tag> Self;
typedef CGAL::Tag_false Use_index;
typedef internal::Combinatorial_map_helper<Self> Helper; typedef internal::Combinatorial_map_helper<Self> Helper;
typedef typename Items_::template Dart_wrapper<Self> Dart_wrapper; typedef typename Items_::template Dart_wrapper<Self> Dart_wrapper;
@ -71,7 +68,6 @@ namespace CGAL {
typedef typename internal::Container_type typedef typename internal::Container_type
<Concurrent_tag, Dart, Dart_allocator>::type Dart_container; <Concurrent_tag, Dart, Dart_allocator>::type Dart_container;
typedef typename Dart_container::iterator Dart_handle; typedef typename Dart_container::iterator Dart_handle;
typedef typename Dart_container::const_iterator Dart_const_handle; typedef typename Dart_container::const_iterator Dart_const_handle;
typedef typename Dart_container::size_type size_type; typedef typename Dart_container::size_type size_type;
@ -81,7 +77,6 @@ namespace CGAL {
typedef Items_ Items; typedef Items_ Items;
typedef Alloc_ Alloc; typedef Alloc_ Alloc;
template <typename T> template <typename T>
struct Container_for_attributes : struct Container_for_attributes :
public internal::Container_type public internal::Container_type
@ -127,14 +122,33 @@ namespace CGAL {
typedef Handle_hash_function Hash_function; typedef Handle_hash_function Hash_function;
typedef Dart_container Dart_range;
typedef const Dart_container Dart_const_range;
/// @return a Dart_range (range through all the darts of the map).
Dart_range& darts() { return mdarts;}
Dart_const_range& darts() const { return mdarts; }
// Init // Init
void init_storage() void init_storage()
{ null_dart_handle=nullptr; } { null_dart_handle=nullptr; }
void clear_storage()
{}
/** Test if the map is empty.
* @return true iff the map is empty.
*/
bool is_empty() const
{ return mdarts.empty(); }
/// @return the number of darts.
size_type number_of_darts() const
{ return mdarts.size(); }
/** Return if this dart is free for adimension. /** Return if this dart is free for adimension.
* @param dh a dart handle * @param dh a dart handle
* @param i the dimension. * @param i the dimension.
* @return true iff dh is linked with nullptr for \em adimension. * @return true iff dh is linked with itself for \em adimension.
*/ */
template<unsigned int i> template<unsigned int i>
bool is_free(Dart_const_handle dh) const bool is_free(Dart_const_handle dh) const

475
Linear_cell_complex/include/CGAL/GMap_linear_cell_complex_storages_with_index.h Normal file
View File

@ -0,0 +1,475 @@
// Copyright (c) 2016 CNRS and LIRIS' Establishments (France).
// All rights reserved.
//
// This file is part of CGAL (www.cgal.org)
//
// $URL$
// $Id$
// SPDX-License-Identifier: LGPL-3.0-or-later OR LicenseRef-Commercial
//
// Author(s) : Guillaume Damiand <guillaume.damiand@liris.cnrs.fr>
//
#ifndef CGAL_GMAP_LINEAR_CELL_COMPLEX_STORAGES_WITH_INDEX_H
#define CGAL_GMAP_LINEAR_CELL_COMPLEX_STORAGES_WITH_INDEX_H 1
#include <CGAL/Compact_container_with_index_2.h>
#include <CGAL/Dart.h>
#include <bitset>
#include <boost/config.hpp>
#if defined(BOOST_GCC)
_Pragma("GCC diagnostic push")
_Pragma("GCC diagnostic ignored \"-Warray-bounds\"")
#endif
namespace CGAL {
namespace internal {
template <typename M>
struct Combinatorial_map_helper;
template<typename Concurrent_tag, class T, class Alloc_>
struct Container_type;
}
// Storage of darts with compact container, alpha using index
// Copy of Generalized_map_storage_2 and add new types related
// to geometry (not possible to inherith because we use Self type
// as template parameter of Dart_wrapper. If we inherit, Self is not
// the correct type).
template<unsigned int d_, unsigned int ambient_dim, class Traits_,
class Items_, class Alloc_, class Index_type_ >
class GMap_linear_cell_complex_storage_2
{
public:
using Self=GMap_linear_cell_complex_storage_2<d_, ambient_dim, Traits_,
Items_, Alloc_, Index_type_>;
using Use_index=CGAL::Tag_true;
using Index_type=Index_type_;
typedef typename Traits_::Point Point;
typedef typename Traits_::Vector Vector;
typedef typename Traits_::FT FT;
typedef internal::Combinatorial_map_helper<Self> Helper;
typedef typename Items_::template Dart_wrapper<Self> Dart_wrapper;
typedef typename internal::template Get_dart_info<Dart_wrapper>::type
Dart_info;
typedef CGAL::Index::Dart<d_, Self, Dart_info> Dart;
typedef std::allocator_traits<Alloc_> Allocator_traits;
typedef typename Allocator_traits::template rebind_alloc<Dart> Dart_allocator;
typedef Compact_container_with_index_2<Dart,Dart_allocator,
Multiply_by_two_policy_for_cc_with_size<64>, Index_type>
Dart_container;
// typedef unsigned int Dart_index;
// typedef MyIndex<unsigned int> Dart_index;
typedef typename Dart_container::Index Dart_index;
// Definition of old types, for backward compatibility.
typedef Dart_index Dart_handle;
typedef Dart_index Dart_const_handle;
typedef typename Dart_container::size_type size_type;
typedef Dart_index Null_handle_type;
static Null_handle_type null_handle;
typedef Items_ Items;
typedef Alloc_ Alloc;
template <typename T>
struct Container_for_attributes : public
Compact_container_with_index_2<T,
typename Alloc_::template rebind<T>::other,
Multiply_by_two_policy_for_cc_with_size<64>, size_type >
{};
/// Typedef for attributes
typedef typename internal::template Get_attributes_tuple<Dart_wrapper>::type
Attributes;
template<int i>
struct Attribute_type: public Helper::template Attribute_type<i>
{};
template<int i>
struct Attribute_handle: public Helper::template Attribute_handle<i>
{};
template<int i>
struct Attribute_const_handle:
public Helper::template Attribute_const_handle<i>
{};
template<int i>
struct Attribute_range: public Helper::template Attribute_range<i>
{};
template<int i>
struct Attribute_const_range:
public Helper::template Attribute_const_range<i>
{};
typedef typename Attribute_type<0>::type Vertex_attribute;
typedef typename Attribute_handle<0>::type Vertex_attribute_handle;
typedef typename Attribute_const_handle<0>::type
Vertex_attribute_const_handle;
typedef typename Attribute_range<0>::type Vertex_attribute_range;
typedef typename Attribute_const_range<0>::type
Vertex_attribute_const_range;
/// Number of marks
static const size_type NB_MARKS = 32;
/// The dimension of the generalized map.
static const unsigned int dimension = d_;
typedef internal::Index_hash_function Hash_function;
typedef Dart_container Dart_range;
typedef const Dart_container Dart_const_range;
/// @return a Dart_range (range through all the darts of the map).
Dart_range& darts() { return mdarts;}
Dart_const_range& darts() const { return mdarts; }
// Init
void init_storage()
{ null_dart_handle=nullptr; }
void clear_storage()
{}
/** Test if the map is empty.
* @return true iff the map is empty.
*/
bool is_empty() const
{ return mdarts.empty(); }
/// @return the number of darts.
size_type number_of_darts() const
{ return mdarts.size(); }
/** Return if this dart is free for adimension.
* @param dh a dart handle
* @param i the dimension.
* @return true iff dh is linked with itself for \em adimension.
*/
template<unsigned int i>
bool is_free(Dart_const_handle dh) const
{
CGAL_assertion(i <= dimension);
return mdarts[dh].mf[i]==dh;
}
bool is_free(Dart_const_handle dh, unsigned int i) const
{
CGAL_assertion(i <= dimension);
return mdarts[dh].mf[i]==dh;
}
bool is_perforated(Dart_const_handle /*dh*/) const
{ return false; }
/// Set simultaneously all the marks of this dart to a given value.
void set_dart_marks(Dart_const_handle ADart,
const std::bitset<NB_MARKS>& amarks) const
{
mdarts[ADart].set_marks(amarks);
}
/// Return all the marks of a dart.
std::bitset<NB_MARKS> get_dart_marks(Dart_const_handle ADart) const
{
return mdarts[ADart].get_marks();
}
/// Return the mark value of dart a given mark number.
bool get_dart_mark(Dart_const_handle ADart, size_type amark) const
{
return mdarts[ADart].get_mark(amark);
}
/// Set the mark of a given mark number to a given value.
void set_dart_mark(Dart_const_handle ADart, size_type amark, bool avalue) const
{
mdarts[ADart].set_mark(amark, avalue);
}
/// Flip the mark of a given mark number to a given value.
void flip_dart_mark(Dart_const_handle ADart, size_type amark) const
{
mdarts[ADart].flip_mark(amark);
}
// Access to alpha maps
Dart_handle get_alpha(Dart_handle ADart, int B1)
{
CGAL_assertion(B1>=0 && B1<=(int)dimension);
return mdarts[ADart].mf[B1];
}
Dart_const_handle get_alpha(Dart_const_handle ADart, int B1) const
{
CGAL_assertion(B1>=0 && B1<=(int)dimension);
return mdarts[ADart].mf[B1];
}
template<int B1>
Dart_handle get_alpha(Dart_handle ADart)
{
CGAL_assertion(B1>=0 && B1<=(int)dimension);
return mdarts[ADart].mf[B1];
}
template<int B1>
Dart_const_handle get_alpha(Dart_const_handle ADart) const
{
CGAL_assertion(B1>=0 && B1<=(int)dimension);
return mdarts[ADart].mf[B1];
}
// return a handle on the i-attribute
template<unsigned int i>
typename Attribute_handle<i>::type attribute(Dart_handle ADart)
{
CGAL_static_assertion_msg(Helper::template Dimension_index<i>::value>=0,
"attribute<i> called but i-attributes are disabled.");
return std::get<Helper::template Dimension_index<i>::value>
(mdarts[ADart].mattribute_handles);
}
template<unsigned int i>
typename Attribute_const_handle<i>::type
attribute(Dart_const_handle ADart) const
{
CGAL_static_assertion_msg(Helper::template Dimension_index<i>::value>=0,
"attribute<i> called but i-attributes are disabled.");
return std::get<Helper::template Dimension_index<i>::value>
(mdarts[ADart].mattribute_handles);
}
// Copy a given attribute
template<unsigned int i>
typename Attribute_handle<i>::type copy_attribute
(typename Attribute_const_handle<i>::type ah)
{
CGAL_static_assertion_msg(Helper::template Dimension_index<i>::value>=0,
"copy_attribute<i> called but i-attributes are disabled.");
typename Attribute_handle<i>::type res=
std::get<Helper::template Dimension_index<i>::value>
(mattribute_containers).emplace(get_attribute<i>(ah));
this->template init_attribute_ref_counting<i>(res);
return res;
}
// Test if a given attribute is valid
template<unsigned int i>
bool is_valid_attribute(typename Attribute_const_handle<i>::type ah) const
{
return get_attribute<i>(ah).is_valid();
}
// accessors and modifiers to the attribute ref counting given its handle
template<unsigned int i>
std::size_t get_attribute_ref_counting
(typename Attribute_const_handle<i>::type ah) const
{
return get_attribute<i>(ah).get_nb_refs();
}
template<unsigned int i>
void init_attribute_ref_counting(typename Attribute_handle<i>::type ah)
{
get_attribute<i>(ah).mrefcounting=0;
}
template<unsigned int i>
void inc_attribute_ref_counting(typename Attribute_handle<i>::type ah)
{
get_attribute<i>(ah).inc_nb_refs();
}
template<unsigned int i>
void dec_attribute_ref_counting(typename Attribute_handle<i>::type ah)
{
get_attribute<i>(ah).dec_nb_refs();
}
// get the attribute given its index
template<unsigned int i>
typename Attribute_type<i>::type&
get_attribute(typename Attribute_handle<i>::type ah)
{
CGAL_assertion( ah!=null_handle );
return std::get<Helper::template Dimension_index<i>::value>
(mattribute_containers)[ah];
}
template<unsigned int i>
const typename Attribute_type<i>::type&
get_attribute(typename Attribute_const_handle<i>::type ah) const
{
CGAL_assertion( ah!=null_handle );
return std::get<Helper::template Dimension_index<i>::value>
(mattribute_containers)[ah];
}
// Get the dart of the given attribute
template<unsigned int i>
Dart_handle dart_of_attribute(typename Attribute_handle<i>::type ah)
{
CGAL_assertion( ah!=null_handle );
return get_attribute<i>(ah).dart();
}
template<unsigned int i>
Dart_const_handle
dart_of_attribute(typename Attribute_const_handle<i>::type ah) const
{
CGAL_assertion( ah!=null_handle );
return get_attribute<i>(ah).dart();
}
// Set the dart of the given attribute
template<unsigned int i>
void set_dart_of_attribute(typename Attribute_handle<i>::type ah,
Dart_handle adart)
{
CGAL_assertion( ah!=null_handle );
get_attribute<i>(ah).set_dart(adart);
}
// Get the information associated with a given dart
Dart_info& info(Dart_handle adart)
{ return mdarts[adart].info(); }
const Dart_info& info(Dart_const_handle adart) const
{ return mdarts[adart].info(); }
// Get the info of the given attribute
template<unsigned int i>
typename Attribute_type<i>::type::Info &
info_of_attribute(typename Attribute_handle<i>::type ah)
{
CGAL_assertion( ah!=null_handle );
return get_attribute<i>(ah).info();
}
template<unsigned int i>
const typename Attribute_type<i>::type::Info &
info_of_attribute(typename Attribute_const_handle<i>::type ah) const
{
CGAL_assertion( ah!=null_handle );
return get_attribute<i>(ah).info();
}
// Get the info of the i-cell attribute associated with the given dart
template<unsigned int i>
typename Attribute_type<i>::type::Info & info(Dart_handle adart)
{
CGAL_assertion( adart!=null_handle );
CGAL_assertion( this->template attribute<i>(adart)!=null_handle );
return info_of_attribute<i>(attribute<i>(adart));
}
template<unsigned int i>
const typename Attribute_type<i>::type::Info &
info(Dart_const_handle adart) const
{
CGAL_assertion( adart!=null_handle );
CGAL_assertion( attribute<i>(adart)!=null_handle );
return info_of_attribute<i>(attribute<i>(adart));
}
// Get the dart of the i-cell attribute associated with the given dart
template<unsigned int i>
Dart_handle dart(Dart_handle adart)
{
CGAL_assertion( adart!=null_handle );
CGAL_assertion( attribute<i>(adart)!=null_handle );
return dart_of_attribute<i>(attribute<i>(adart));
}
template<unsigned int i>
Dart_const_handle dart(Dart_const_handle adart) const
{
CGAL_assertion( adart!=null_handle );
CGAL_assertion( attribute<i>(adart)!=null_handle );
return dart_of_attribute<i>(attribute<i>(adart));
}
// Get the dart of the given 0-attribute
Point & point_of_vertex_attribute(typename Attribute_handle<0>::type vh)
{
CGAL_assertion( vh!=null_handle );
return get_attribute<0>(vh).point();
}
const Point & point_of_vertex_attribute
(typename Attribute_const_handle<0>::type vh) const
{
CGAL_assertion( vh!=null_handle );
return get_attribute<0>(vh).point();
}
// Debug function
void display_dart(Dart_const_handle ADart) const
{ std::cout<<ADart; }
template<unsigned int i>
void display_attribute(typename Attribute_const_handle<i>::type ah) const
{ std::cout<<ah; }
protected:
// Set the handle on the i th attribute
template<unsigned int i>
void basic_set_dart_attribute(Dart_handle dh,
typename Attribute_handle<i>::type ah)
{
std::get<Helper::template Dimension_index<i>::value>
(mdarts[dh].mattribute_handles) = ah;
}
/** Link a dart with a given dart for a given dimension.
* @param adart the dart to link.
* @param adart2 the dart to link with.
* @param i the dimension.
*/
template<unsigned int i>
void dart_link_alpha(Dart_handle adart, Dart_handle adart2)
{
CGAL_assertion(i <= dimension);
CGAL_assertion(adart!=nullptr && adart2!=nullptr);
mdarts[adart].mf[i] = adart2;
}
void dart_link_alpha(Dart_handle adart, Dart_handle adart2, unsigned int i)
{
CGAL_assertion(i <= dimension);
CGAL_assertion(adart!=nullptr && adart2!=nullptr);
mdarts[adart].mf[i] = adart2;
}
/** Unlink a dart for a given dimension.
* @param adart a dart.
* @param i the dimension.
*/
template<unsigned int i>
void dart_unlink_alpha(Dart_handle adart)
{
CGAL_assertion(adart!=nullptr && i <= dimension);
mdarts[adart].mf[i] = adart;
}
void dart_unlink_alpha(Dart_handle adart, unsigned int i)
{
CGAL_assertion(adart!=nullptr && i <= dimension);
mdarts[adart].mf[i] = adart;
}
protected:
Dart_handle null_dart_handle; // To be compatible with combinatorial map
/// Dart container.
Dart_container mdarts;
/// Tuple of attributes containers
typename Helper::Attribute_containers mattribute_containers;
};
/// null_handle
template<unsigned int d_, unsigned int ambient_dim, class Traits_,
class Items_, class Alloc_, class Index_type_>
typename GMap_linear_cell_complex_storage_2<d_, ambient_dim, Traits_, Items_, Alloc_, Index_type_>::
Null_handle_type GMap_linear_cell_complex_storage_2<d_, ambient_dim, Traits_,
Items_, Alloc_, Index_type_>::
null_handle((std::numeric_limits<Index_type_>::max)()/2);
} // namespace CGAL
#if defined(BOOST_GCC)
_Pragma("GCC diagnostic pop")
#endif
#endif // CGAL_GMAP_LINEAR_CELL_COMPLEX_STORAGES_WITH_INDEX_H //
// EOF //

62
Linear_cell_complex/include/CGAL/Linear_cell_complex_for_combinatorial_map.h
View File

@ -29,32 +29,26 @@ namespace CGAL {
* points associated to all vertices. * points associated to all vertices.
*/ */
// Linear_cell_complex_for_combinatorial_map class. // Linear_cell_complex_for_combinatorial_map_base class.
// No difference with class Linear_cell_complex_base except the default
// template parameters for Refs class which is a combinatorial map.
template < unsigned int d_, unsigned int ambient_dim, template < unsigned int d_, unsigned int ambient_dim,
class Traits_, class Items_, class Alloc_, class Traits_, class Items_, class Alloc_,
template<unsigned int,class,class,class,class> class CMap, template<unsigned int,class,class,class,class> class CMap,
class Storage_ > class Refs_, class Storage_ >
class Linear_cell_complex_for_combinatorial_map_base: class Linear_cell_complex_for_combinatorial_map_base:
public Linear_cell_complex_base<d_, ambient_dim, Traits_, public Linear_cell_complex_base<d_, ambient_dim, Traits_,
Items_, Alloc_, CMap, Items_, Alloc_, CMap, Refs_, Storage_>
Linear_cell_complex_for_combinatorial_map
<d_, ambient_dim,
Traits_, Items_,
Alloc_, CMap, Storage_>,
Storage_>
{ {
public: public:
typedef Linear_cell_complex_for_combinatorial_map_base<d_, ambient_dim, typedef Linear_cell_complex_for_combinatorial_map_base<d_, ambient_dim,
Traits_, Items_, Alloc_, CMap, Storage_> Self; Traits_, Items_, Alloc_, CMap, Refs_, Storage_> Self;
typedef Linear_cell_complex_base<d_, ambient_dim, typedef Linear_cell_complex_base<d_, ambient_dim,
Traits_, Items_, Alloc_, CMap, Self, Storage_> Base; Traits_, Items_, Alloc_, CMap, Refs_, Storage_> Base;
typedef Traits_ Traits; typedef Traits_ Traits;
typedef Items_ Items; typedef Items_ Items;
typedef Alloc_ Alloc; typedef Alloc_ Alloc;
typedef Refs_ Refs;
static const unsigned int ambient_dimension = Base::ambient_dimension; static const unsigned int ambient_dimension = Base::ambient_dimension;
static const unsigned int dimension = Base::dimension; static const unsigned int dimension = Base::dimension;
@ -104,29 +98,29 @@ namespace CGAL {
template <unsigned int d2, unsigned int ambient_dim2, class Traits2, template <unsigned int d2, unsigned int ambient_dim2, class Traits2,
class Items2, class Alloc2, class Items2, class Alloc2,
template<unsigned int,class,class,class,class> class CMap2, template<unsigned int,class,class,class,class> class CMap2,
class Storage2> class Ref2, class Storage2>
Linear_cell_complex_for_combinatorial_map_base Linear_cell_complex_for_combinatorial_map_base
(const Linear_cell_complex_for_combinatorial_map_base<d2, ambient_dim2, (const Linear_cell_complex_for_combinatorial_map_base<d2, ambient_dim2,
Traits2, Items2, Alloc2, CMap2, Storage2>& alcc) : Base(alcc) Traits2, Items2, Alloc2, CMap2, Ref2, Storage2>& alcc) : Base(alcc)
{} {}
template <unsigned int d2, unsigned int ambient_dim2, class Traits2, template <unsigned int d2, unsigned int ambient_dim2, class Traits2,
class Items2, class Alloc2, class Items2, class Alloc2,
template<unsigned int,class,class,class,class> class CMap2, template<unsigned int,class,class,class,class> class CMap2,
class Storage2, typename Converters> class Ref2, class Storage2, typename Converters>
Linear_cell_complex_for_combinatorial_map_base Linear_cell_complex_for_combinatorial_map_base
(const Linear_cell_complex_for_combinatorial_map_base<d2, ambient_dim2, (const Linear_cell_complex_for_combinatorial_map_base<d2, ambient_dim2,
Traits2, Items2, Alloc2, CMap2, Storage2>& alcc, Traits2, Items2, Alloc2, CMap2, Ref2, Storage2>& alcc,
const Converters& converters) : Base(alcc, converters) const Converters& converters) : Base(alcc, converters)
{} {}
template <unsigned int d2, unsigned int ambient_dim2, class Traits2, template <unsigned int d2, unsigned int ambient_dim2, class Traits2,
class Items2, class Alloc2, class Items2, class Alloc2,
template<unsigned int,class,class,class,class> class CMap2, template<unsigned int,class,class,class,class> class CMap2,
class Storage2, typename Converters, typename DartInfoConverter> class Ref2, class Storage2, typename Converters, typename DartInfoConverter>
Linear_cell_complex_for_combinatorial_map_base Linear_cell_complex_for_combinatorial_map_base
(const Linear_cell_complex_for_combinatorial_map_base<d2, ambient_dim2, (const Linear_cell_complex_for_combinatorial_map_base<d2, ambient_dim2,
Traits2, Items2, Alloc2, CMap2, Storage2>& alcc, Traits2, Items2, Alloc2, CMap2, Ref2, Storage2>& alcc,
const Converters& converters, const Converters& converters,
const DartInfoConverter& dartinfoconverter) : const DartInfoConverter& dartinfoconverter) :
Base(alcc, converters, dartinfoconverter) Base(alcc, converters, dartinfoconverter)
@ -135,11 +129,11 @@ namespace CGAL {
template <unsigned int d2, unsigned int ambient_dim2, class Traits2, template <unsigned int d2, unsigned int ambient_dim2, class Traits2,
class Items2, class Alloc2, class Items2, class Alloc2,
template<unsigned int,class,class,class,class> class CMap2, template<unsigned int,class,class,class,class> class CMap2,
class Storage2, typename Converters, class Ref2, class Storage2, typename Converters,
typename DartInfoConverter, typename PointConverter> typename DartInfoConverter, typename PointConverter>
Linear_cell_complex_for_combinatorial_map_base Linear_cell_complex_for_combinatorial_map_base
(const Linear_cell_complex_for_combinatorial_map_base<d2, ambient_dim2, (const Linear_cell_complex_for_combinatorial_map_base<d2, ambient_dim2,
Traits2, Items2, Alloc2, CMap2, Storage2>& alcc, Traits2, Items2, Alloc2, CMap2, Ref2, Storage2>& alcc,
const Converters& converters, const DartInfoConverter& dartinfoconverter, const Converters& converters, const DartInfoConverter& dartinfoconverter,
const PointConverter& pointconverter) : const PointConverter& pointconverter) :
Base(alcc, converters, dartinfoconverter, pointconverter) Base(alcc, converters, dartinfoconverter, pointconverter)
@ -232,14 +226,16 @@ namespace CGAL {
class Storage_ > class Storage_ >
class Linear_cell_complex_for_combinatorial_map: class Linear_cell_complex_for_combinatorial_map:
public Linear_cell_complex_for_combinatorial_map_base public Linear_cell_complex_for_combinatorial_map_base
<d_, ambient_dim, Traits_, Items_, Alloc_, CMap, Storage_> <d_, ambient_dim, Traits_, Items_, Alloc_, CMap,
Linear_cell_complex_for_combinatorial_map<d_, ambient_dim, Traits_,
Items_, Alloc_, CMap, Storage_>, Storage_>
{ {
public: public:
typedef Linear_cell_complex_for_combinatorial_map<d_, ambient_dim, typedef Linear_cell_complex_for_combinatorial_map<d_, ambient_dim,
Traits_, Items_, Alloc_, CMap, Storage_> Self; Traits_, Items_, Alloc_, CMap, Storage_> Self;
typedef Linear_cell_complex_for_combinatorial_map_base<d_, ambient_dim, typedef Linear_cell_complex_for_combinatorial_map_base<d_, ambient_dim,
Traits_, Items_, Alloc_, CMap, Storage_> Base; Traits_, Items_, Alloc_, CMap, Self, Storage_> Base;
typedef Traits_ Traits; typedef Traits_ Traits;
typedef Items_ Items; typedef Items_ Items;
@ -302,6 +298,14 @@ namespace CGAL {
const PointConverter& pointconverter) : const PointConverter& pointconverter) :
Base(alcc, converters, dartinfoconverter, pointconverter) Base(alcc, converters, dartinfoconverter, pointconverter)
{} {}
Self & operator= (const Self & alcc)
{
Base::operator=(alcc);
return *this;
}
void clear() { Base::clear(); } //need explicit definition for Has_member_clear in bgl helpers
}; };
namespace Index namespace Index
@ -317,14 +321,16 @@ template< unsigned int d_, unsigned int ambient_dim,
class CMap, class Storage_> class CMap, class Storage_>
class Linear_cell_complex_for_combinatorial_map: class Linear_cell_complex_for_combinatorial_map:
public Linear_cell_complex_for_combinatorial_map_base public Linear_cell_complex_for_combinatorial_map_base
<d_, ambient_dim, Traits_, Items_, Alloc_, CMap, Storage_> <d_, ambient_dim, Traits_, Items_, Alloc_, CMap,
Linear_cell_complex_for_combinatorial_map<d_, ambient_dim, Traits_,
Items_, Alloc_, CMap, Storage_>, Storage_>
{ {
public: public:
typedef Linear_cell_complex_for_combinatorial_map<d_, ambient_dim, typedef Linear_cell_complex_for_combinatorial_map<d_, ambient_dim,
Traits_, Items_, Alloc_, CMap, Storage_> Self; Traits_, Items_, Alloc_, CMap, Storage_> Self;
typedef Linear_cell_complex_for_combinatorial_map_base<d_, ambient_dim, typedef Linear_cell_complex_for_combinatorial_map_base<d_, ambient_dim,
Traits_, Items_, Alloc_, CMap, Storage_> Base; Traits_, Items_, Alloc_, CMap, Self, Storage_> Base;
typedef Traits_ Traits; typedef Traits_ Traits;
typedef Items_ Items; typedef Items_ Items;
@ -387,6 +393,14 @@ public:
const PointConverter& pointconverter) : const PointConverter& pointconverter) :
Base(alcc, converters, dartinfoconverter, pointconverter) Base(alcc, converters, dartinfoconverter, pointconverter)
{} {}
Self & operator= (const Self & alcc)
{
Base::operator=(alcc);
return *this;
}
void clear() { Base::clear(); } //need explicit definition for Has_member_clear in bgl helpers
}; };
} // namespace Index } // namespace Index
} // namespace CGAL } // namespace CGAL

240
Linear_cell_complex/include/CGAL/Linear_cell_complex_for_generalized_map.h
View File

@ -18,6 +18,7 @@
#include <CGAL/Linear_cell_complex_min_items.h> #include <CGAL/Linear_cell_complex_min_items.h>
#include <CGAL/Generalized_map.h> #include <CGAL/Generalized_map.h>
#include <CGAL/GMap_linear_cell_complex_storages.h> #include <CGAL/GMap_linear_cell_complex_storages.h>
#include <CGAL/GMap_linear_cell_complex_storages_with_index.h>
namespace CGAL { namespace CGAL {
@ -26,32 +27,26 @@ namespace CGAL {
* points associated to all vertices. * points associated to all vertices.
*/ */
// Linear_cell_complex_for_generalized_map class. // Linear_cell_complex_for_generalized_map class_base.
// No difference with class Linear_cell_complex_base except the default
// template parameters for Refs class which is a generalized map.
template < unsigned int d_, unsigned int ambient_dim, template < unsigned int d_, unsigned int ambient_dim,
class Traits_, class Items_, class Alloc_, class Traits_, class Items_, class Alloc_,
template<unsigned int,class,class,class,class> class CMap, template<unsigned int,class,class,class,class> class CMap,
class Storage_ > class Refs_, class Storage_ >
class Linear_cell_complex_for_generalized_map: class Linear_cell_complex_for_generalized_map_base:
public Linear_cell_complex_base<d_, ambient_dim, Traits_, public Linear_cell_complex_base<d_, ambient_dim, Traits_,
Items_, Alloc_, CMap, Items_, Alloc_, CMap, Refs_, Storage_>
Linear_cell_complex_for_generalized_map
<d_, ambient_dim,
Traits_, Items_,
Alloc_, CMap, Storage_>,
Storage_>
{ {
public: public:
typedef Linear_cell_complex_for_generalized_map<d_, ambient_dim, typedef Linear_cell_complex_for_generalized_map_base<d_, ambient_dim,
Traits_, Items_, Alloc_, CMap, Storage_> Self; Traits_, Items_, Alloc_, CMap, Refs_, Storage_> Self;
typedef Linear_cell_complex_base<d_, ambient_dim, typedef Linear_cell_complex_base<d_, ambient_dim,
Traits_, Items_, Alloc_, CMap, Self, Storage_> Base; Traits_, Items_, Alloc_, CMap, Refs_, Storage_> Base;
typedef Traits_ Traits; typedef Traits_ Traits;
typedef Items_ Items; typedef Items_ Items;
typedef Alloc_ Alloc; typedef Alloc_ Alloc;
typedef Refs_ Refs;
static const unsigned int ambient_dimension = Base::ambient_dimension; static const unsigned int ambient_dimension = Base::ambient_dimension;
static const unsigned int dimension = Base::dimension; static const unsigned int dimension = Base::dimension;
@ -84,6 +79,105 @@ namespace CGAL {
typedef typename Base::Exception_no_more_available_mark typedef typename Base::Exception_no_more_available_mark
Exception_no_more_available_mark; Exception_no_more_available_mark;
Linear_cell_complex_for_generalized_map_base() : Base()
{}
/** Copy the given linear cell complex into *this.
* Note that both LCC can have different dimensions and/or non void attributes.
* @param alcc the linear cell complex to copy.
* @post *this is valid.
*/
Linear_cell_complex_for_generalized_map_base(const Self & alcc) : Base(alcc)
{}
Linear_cell_complex_for_generalized_map_base(Self && alcc) : Base(alcc)
{}
template <unsigned int d2, unsigned int ambient_dim2, class Traits2,
class Items2, class Alloc2,
template<unsigned int,class,class,class,class> class CMap2,
class Ref2, class Storage2>
Linear_cell_complex_for_generalized_map_base
(const Linear_cell_complex_for_generalized_map_base<d2, ambient_dim2,
Traits2, Items2, Alloc2, CMap2, Ref2, Storage2>& alcc) : Base(alcc)
{}
template <unsigned int d2, unsigned int ambient_dim2, class Traits2,
class Items2, class Alloc2,
template<unsigned int,class,class,class,class> class CMap2,
class Ref2, class Storage2, typename Converters>
Linear_cell_complex_for_generalized_map_base
(const Linear_cell_complex_for_generalized_map_base<d2, ambient_dim2,
Traits2, Items2, Alloc2, CMap2, Ref2, Storage2>& alcc,
const Converters& converters) : Base(alcc, converters)
{}
template <unsigned int d2, unsigned int ambient_dim2, class Traits2,
class Items2, class Alloc2,
template<unsigned int,class,class,class,class> class CMap2,
class Ref2, class Storage2, typename Converters, typename DartInfoConverter>
Linear_cell_complex_for_generalized_map_base
(const Linear_cell_complex_for_generalized_map_base<d2, ambient_dim2,
Traits2, Items2, Alloc2, CMap2, Ref2, Storage2>& alcc,
const Converters& converters,
const DartInfoConverter& dartinfoconverter) :
Base(alcc, converters, dartinfoconverter)
{}
template <unsigned int d2, unsigned int ambient_dim2, class Traits2,
class Items2, class Alloc2,
template<unsigned int,class,class,class,class> class CMap2,
class Ref2, class Storage2, typename Converters, typename DartInfoConverter,
typename PointConverter>
Linear_cell_complex_for_generalized_map_base
(const Linear_cell_complex_for_generalized_map_base<d2, ambient_dim2,
Traits2, Items2, Alloc2, CMap2, Ref2, Storage2>& alcc,
const Converters& converters,
const DartInfoConverter& dartinfoconverter,
const PointConverter& pointconverter) :
Base(alcc, converters, dartinfoconverter, pointconverter)
{}
Self & operator= (const Self & alcc)
{
Base::operator=(alcc);
return *this;
}
friend std::ostream& operator<< (std::ostream& os, const Self& amap)
{
save_generalized_map(amap, os);
return os;
}
friend std::ifstream& operator>> (std::ifstream& is, Self& amap)
{
load_generalized_map(is, amap);
return is;
}
};
template < unsigned int d_, unsigned int ambient_dim,
class Traits_, class Items_, class Alloc_,
template<unsigned int,class,class,class,class> class CMap,
class Storage_ >
class Linear_cell_complex_for_generalized_map:
public Linear_cell_complex_for_generalized_map_base
<d_, ambient_dim, Traits_, Items_, Alloc_, CMap,
Linear_cell_complex_for_generalized_map<d_, ambient_dim, Traits_,
Items_, Alloc_, CMap, Storage_>, Storage_>
{
public:
typedef Linear_cell_complex_for_generalized_map<d_, ambient_dim,
Traits_, Items_, Alloc_, CMap, Storage_> Self;
typedef Linear_cell_complex_for_generalized_map_base<d_, ambient_dim,
Traits_, Items_, Alloc_, CMap, Self, Storage_> Base;
typedef Traits_ Traits;
typedef Items_ Items;
typedef Alloc_ Alloc;
Linear_cell_complex_for_generalized_map() : Base() Linear_cell_complex_for_generalized_map() : Base()
{} {}
@ -92,10 +186,10 @@ namespace CGAL {
* @param alcc the linear cell complex to copy. * @param alcc the linear cell complex to copy.
* @post *this is valid. * @post *this is valid.
*/ */
Linear_cell_complex_for_generalized_map(const Self & alcc) : Base(alcc) Linear_cell_complex_for_generalized_map(const Self& alcc) : Base(alcc)
{} {}
Linear_cell_complex_for_generalized_map(Self && alcc) : Base(alcc) Linear_cell_complex_for_generalized_map(Self&& alcc) : Base(alcc)
{} {}
template <unsigned int d2, unsigned int ambient_dim2, class Traits2, template <unsigned int d2, unsigned int ambient_dim2, class Traits2,
@ -132,13 +226,12 @@ namespace CGAL {
template <unsigned int d2, unsigned int ambient_dim2, class Traits2, template <unsigned int d2, unsigned int ambient_dim2, class Traits2,
class Items2, class Alloc2, class Items2, class Alloc2,
template<unsigned int,class,class,class,class> class CMap2, template<unsigned int,class,class,class,class> class CMap2,
class Storage2, typename Converters, typename DartInfoConverter, class Storage2, typename Converters,
typename PointConverter> typename DartInfoConverter, typename PointConverter>
Linear_cell_complex_for_generalized_map Linear_cell_complex_for_generalized_map
(const Linear_cell_complex_for_generalized_map<d2, ambient_dim2, (const Linear_cell_complex_for_generalized_map<d2, ambient_dim2,
Traits2, Items2, Alloc2, CMap2, Storage2>& alcc, Traits2, Items2, Alloc2, CMap2, Storage2>& alcc,
const Converters& converters, const Converters& converters, const DartInfoConverter& dartinfoconverter,
const DartInfoConverter& dartinfoconverter,
const PointConverter& pointconverter) : const PointConverter& pointconverter) :
Base(alcc, converters, dartinfoconverter, pointconverter) Base(alcc, converters, dartinfoconverter, pointconverter)
{} {}
@ -149,19 +242,104 @@ namespace CGAL {
return *this; return *this;
} }
friend std::ostream& operator<< (std::ostream& os, const Self& amap) void clear() { Base::clear(); } //need explicit definition for Has_member_clear in bgl helpers
{ };
save_generalized_map(amap, os);
return os;
}
friend std::ifstream& operator>> (std::ifstream& is, Self& amap) namespace Index
{ {
load_generalized_map(is, amap); // New class Linear_cell_complex using compact container with index.
return is; // No difference with class Linear_cell_complex_base except the default
} // template parameters and the default parameter for Refs class.
}; // NOTE: If we want to inherit from this class, we need to add the Refs class
// template parameter.
template< unsigned int d_, unsigned int ambient_dim,
class Traits_, class Items_, class Alloc_,
template<unsigned int,class,class,class,class>
class CMap, class Storage_>
class Linear_cell_complex_for_generalized_map:
public Linear_cell_complex_for_generalized_map_base
<d_, ambient_dim, Traits_, Items_, Alloc_, CMap,
Linear_cell_complex_for_generalized_map<d_, ambient_dim, Traits_,
Items_, Alloc_, CMap, Storage_>, Storage_>
{
public:
typedef Linear_cell_complex_for_generalized_map<d_, ambient_dim,
Traits_, Items_, Alloc_, CMap, Storage_> Self;
typedef Linear_cell_complex_for_generalized_map_base<d_, ambient_dim,
Traits_, Items_, Alloc_, CMap, Self, Storage_> Base;
typedef Traits_ Traits;
typedef Items_ Items;
typedef Alloc_ Alloc;
Linear_cell_complex_for_generalized_map() : Base()
{}
/** Copy the given linear cell complex into *this.
* Note that both LCC can have different dimensions and/or non void attributes.
* @param alcc the linear cell complex to copy.
* @post *this is valid.
*/
Linear_cell_complex_for_generalized_map(const Self& alcc) : Base(alcc)
{}
Linear_cell_complex_for_generalized_map(Self&& alcc) : Base(alcc)
{}
template <unsigned int d2, unsigned int ambient_dim2, class Traits2,
class Items2, class Alloc2,
template<unsigned int,class,class,class,class> class CMap2,
class Storage2>
Linear_cell_complex_for_generalized_map
(const Linear_cell_complex_for_generalized_map<d2, ambient_dim2,
Traits2, Items2, Alloc2, CMap2, Storage2>& alcc) : Base(alcc)
{}
template <unsigned int d2, unsigned int ambient_dim2, class Traits2,
class Items2, class Alloc2,
template<unsigned int,class,class,class,class> class CMap2,
class Storage2, typename Converters>
Linear_cell_complex_for_generalized_map
(const Linear_cell_complex_for_generalized_map<d2, ambient_dim2,
Traits2, Items2, Alloc2, CMap2, Storage2>& alcc,
const Converters& converters) : Base(alcc, converters)
{}
template <unsigned int d2, unsigned int ambient_dim2, class Traits2,
class Items2, class Alloc2,
template<unsigned int,class,class,class,class> class CMap2,
class Storage2, typename Converters, typename DartInfoConverter>
Linear_cell_complex_for_generalized_map
(const Linear_cell_complex_for_generalized_map<d2, ambient_dim2,
Traits2, Items2, Alloc2, CMap2, Storage2>& alcc,
const Converters& converters,
const DartInfoConverter& dartinfoconverter) :
Base(alcc, converters, dartinfoconverter)
{}
template <unsigned int d2, unsigned int ambient_dim2, class Traits2,
class Items2, class Alloc2,
template<unsigned int,class,class,class,class> class CMap2,
class Storage2, typename Converters,
typename DartInfoConverter, typename PointConverter>
Linear_cell_complex_for_generalized_map
(const Linear_cell_complex_for_generalized_map<d2, ambient_dim2,
Traits2, Items2, Alloc2, CMap2, Storage2>& alcc,
const Converters& converters, const DartInfoConverter& dartinfoconverter,
const PointConverter& pointconverter) :
Base(alcc, converters, dartinfoconverter, pointconverter)
{}
Self & operator= (const Self & alcc)
{
Base::operator=(alcc);
return *this;
}
void clear() { Base::clear(); } //need explicit definition for Has_member_clear in bgl helpers
};
} // namespace Index
} // namespace CGAL } // namespace CGAL
#endif // CGAL_LINEAR_CELL_COMPLEX_FOR_GENERALIZED_MAP_H // #endif // CGAL_LINEAR_CELL_COMPLEX_FOR_GENERALIZED_MAP_H //

20
Linear_cell_complex/include/CGAL/Linear_cell_complex_fwd.h
View File

@ -89,17 +89,17 @@ template < unsigned int d_, unsigned int ambient_dim = d_,
// TODO READD CGAL::Tag_false> > // TODO READD CGAL::Tag_false> >
class Linear_cell_complex_for_combinatorial_map; class Linear_cell_complex_for_combinatorial_map;
/* TODO GMap_linear_cell_complex_storage_2 template < unsigned int d_, unsigned int ambient_dim = d_,
template < unsigned int d_, unsigned int ambient_dim = d_, class Traits_ = Linear_cell_complex_traits<ambient_dim>,
class Traits_ = Linear_cell_complex_traits<ambient_dim>, class Items_ = Linear_cell_complex_min_items,
class Items_ = Linear_cell_complex_min_items, class Alloc_ = CGAL_ALLOCATOR(int),
class Alloc_ = CGAL_ALLOCATOR(int), template<unsigned int,class,class,class,class>
template<unsigned int,class,class,class,class> class CMap = Generalized_map_base,
class CMap = Generalized_map_base, class Storage_ = GMap_linear_cell_complex_storage_2<d_, ambient_dim,
class Storage_ = GMap_linear_cell_complex_storage_2<d_, ambient_dim, Traits_, Items_,
Traits_, Items_, unsigned int>> Alloc_, unsigned int>>
// TODO READD CGAL::Tag_false> > // TODO READD CGAL::Tag_false> >
class Linear_cell_complex_for_generalized_map; */ class Linear_cell_complex_for_generalized_map;
} // namespace Index } // namespace Index
} // CGAL } // CGAL

34
Linear_cell_complex/test/Linear_cell_complex/CMakeLists.txt
View File

@ -6,16 +6,28 @@ project(Linear_cell_complex_Tests)
find_package(CGAL REQUIRED) find_package(CGAL REQUIRED)
file( set(hfiles Linear_cell_complex_2_test.h
GLOB hfiles Linear_cell_complex_3_test.h Linear_cell_complex_3_test.h)
RELATIVE ${CMAKE_CURRENT_SOURCE_DIR}
${CMAKE_CURRENT_SOURCE_DIR}/*.h)
# create a target per cppfile # create a target per cppfile
file( create_single_source_cgal_program(Linear_cell_complex_2_test.cpp ${hfiles})
GLOB cppfiles create_single_source_cgal_program(Linear_cell_complex_3_test.cpp ${hfiles})
RELATIVE ${CMAKE_CURRENT_SOURCE_DIR} create_single_source_cgal_program(Linear_cell_complex_4_test.cpp ${hfiles})
${CMAKE_CURRENT_SOURCE_DIR}/*.cpp) create_single_source_cgal_program(Linear_cell_complex_copy_test.cpp ${hfiles})
foreach(cppfile ${cppfiles})
create_single_source_cgal_program("${cppfile}" "${hfiles}") # Same targets, defining USE_COMPACT_CONTAINER_WITH_INDEX to test index version
endforeach() add_executable(Linear_cell_complex_2_test_index Linear_cell_complex_2_test.cpp ${hfiles})
target_compile_definitions(Linear_cell_complex_2_test_index PUBLIC USE_COMPACT_CONTAINER_WITH_INDEX)
target_link_libraries(Linear_cell_complex_2_test_index PUBLIC CGAL)
add_executable(Linear_cell_complex_3_test_index Linear_cell_complex_3_test.cpp ${hfiles})
target_compile_definitions(Linear_cell_complex_3_test_index PUBLIC USE_COMPACT_CONTAINER_WITH_INDEX)
target_link_libraries(Linear_cell_complex_3_test_index PUBLIC CGAL)
add_executable(Linear_cell_complex_4_test_index Linear_cell_complex_4_test.cpp ${hfiles})
target_compile_definitions(Linear_cell_complex_4_test_index PUBLIC USE_COMPACT_CONTAINER_WITH_INDEX)
target_link_libraries(Linear_cell_complex_4_test_index PUBLIC CGAL)
add_executable(Linear_cell_complex_copy_test_index Linear_cell_complex_copy_test.cpp ${hfiles})
target_compile_definitions(Linear_cell_complex_copy_test_index PUBLIC USE_COMPACT_CONTAINER_WITH_INDEX)
target_link_libraries(Linear_cell_complex_copy_test_index PUBLIC CGAL)

5
Linear_cell_complex/test/Linear_cell_complex/Linear_cell_complex_copy_test.cpp
View File

@ -23,10 +23,9 @@ template<unsigned int d, unsigned int ambient_dim,
using My_lcc_cmap=CGAL::Index::Linear_cell_complex_for_combinatorial_map using My_lcc_cmap=CGAL::Index::Linear_cell_complex_for_combinatorial_map
<d, ambient_dim, Traits, Items>; <d, ambient_dim, Traits, Items>;
// TODO use CGAL::Index::Linear_cell_complex_for_generalized_map
template<unsigned int d, unsigned int ambient_dim, template<unsigned int d, unsigned int ambient_dim,
class Traits, class Items> class Traits, class Items>
using My_lcc_gmap=CGAL::Linear_cell_complex_for_generalized_map using My_lcc_gmap=CGAL::Index::Linear_cell_complex_for_generalized_map
<d, ambient_dim, Traits, Items>; <d, ambient_dim, Traits, Items>;
#else #else
template<class Refs, class Info> template<class Refs, class Info>
@ -56,7 +55,7 @@ struct Map_2_dart_items
{ {
typedef My_cell_attribute< Refs, int > Int_attrib; typedef My_cell_attribute< Refs, int > Int_attrib;
typedef My_cell_attribute< Refs, double > Double_attrib; typedef My_cell_attribute< Refs, double > Double_attrib;
typedef My_cell_attribute< Refs, double > Double_attrib_wp; typedef My_cell_attribute_with_point< Refs, double > Double_attrib_wp;
typedef std::tuple<Double_attrib_wp, void, Double_attrib> Attributes; typedef std::tuple<Double_attrib_wp, void, Double_attrib> Attributes;
}; };
}; };