40#ifndef GEOGRAM_BASIC_ATTRIBUTES
41#define GEOGRAM_BASIC_ATTRIBUTES
76 base_addr_(nullptr), size_(0), dimension_(0),
77 disconnected_(false) {
90 base_addr_ = base_addr;
118 return size_ * dimension_;
141 base_addr_ =
nullptr;
144 disconnected_ =
true;
179 std::string element_type_name_;
180 std::string element_typeid_name_;
223 const std::string& type_name
247 return cached_capacity_;
268 virtual void clear(
bool keep_memory =
false) = 0;
276 return !observers_.empty();
365 index_t item_size = element_size_ * dimension_;
367 cached_base_addr_+to*item_size,
368 cached_base_addr_+from*item_size,
384 return cached_base_addr_;
392 return cached_base_addr_;
400 return size_t(element_size_);
412 const std::string& element_type_name
415 type_name_to_creator_.find(element_type_name) !=
416 type_name_to_creator_.end()
429 const std::string& element_typeid_name
432 typeid_name_to_type_name_.find(element_typeid_name) !=
433 typeid_name_to_type_name_.end()
444 const std::string& element_type_name,
447 geo_assert(element_type_name_is_known(element_type_name));
448 return type_name_to_creator_[element_type_name]->
449 create_attribute_store(dimension);
460 const std::string& element_typeid_name
462 geo_assert(element_typeid_name_is_known(element_typeid_name));
463 return typeid_name_to_type_name_[element_typeid_name];
475 const std::string& element_type_name
477 geo_assert(element_type_name_is_known(element_type_name));
478 return type_name_to_typeid_name_[element_type_name];
493 const std::string& element_type_name,
494 const std::string& element_typeid_name
496 if(element_type_name_is_known(element_type_name)) {
497 Logger::warn(
"Attributes") << element_type_name
498 <<
" already registered"
500 if(element_typeid_name_is_known(element_typeid_name)) {
501 bool already_registered_attribute_has_same_type = (
502 type_name_to_typeid_name_[element_type_name] ==
505 geo_assert(already_registered_attribute_has_same_type);
508 type_name_to_creator_[element_type_name] = creator;
509 typeid_name_to_type_name_[element_typeid_name] = element_type_name;
510 type_name_to_typeid_name_[element_type_name] = element_typeid_name;
552 std::set<AttributeStoreObserver*> observers_;
555 static std::map<std::string, AttributeStoreCreator_var>
556 type_name_to_creator_;
558 static std::map<std::string, std::string>
559 typeid_name_to_type_name_;
561 static std::map<std::string, std::string>
562 type_name_to_typeid_name_;
588 store_.resize(new_size*dimension_);
598 store_.reserve(new_capacity*dimension_);
599 cached_capacity_ = new_capacity;
608 void clear(
bool keep_memory=
false)
override {
614 notify(
nullptr, 0, dimension_);
626 for(
index_t c = 0; c < copy_dim; ++c) {
627 new_store[dim * i + c] = store_[dimension_ * i + c];
630 store_.swap(new_store);
639 const std::string& type_name
641 return type_name ==
typeid(T).name();
645 return typeid(T).name();
652 result->store_ = store_;
710 if(type_name ==
"bool") {
719 read_ascii_attribute<T>,
720 write_ascii_attribute<T>
751 return index_t(attributes_.size());
804 void clear(
bool keep_attributes,
bool keep_memory =
false);
837 const std::string& name
848 return (find_attribute_store(name) !=
nullptr);
933 const std::string& name,
const std::string& new_name
945 const std::string& old_name,
const std::string& new_name
970 std::map<std::string, AttributeStore*> attributes_;
1013 return (store_ !=
nullptr && !disconnected_);
1025 if(!disconnected_) {
1045 if(store_ ==
nullptr) {
1069 if(store_ !=
nullptr) {
1092 if(store_ !=
nullptr) {
1112 const std::string& name,
1148 store_->
redim(new_dim);
1180 ((dim == 0) || (store->
dimension() == dim))
1230 return typed_store->get_vector();
1243 return typed_store->get_vector();
1280#if __GNUG__ && __GNUC__ < 5
1282 __has_trivial_copy(T),
1283 "Attribute only implemented for types that can be copied with memcpy()"
1287 std::is_trivially_copyable<T>::value,
1288 "Attribute only implemented for types that can be copied with memcpy()"
1321 return ((T*)(
void*)superclass::base_addr_)[i];
1331 return ((
const T*)(
void*)superclass::base_addr_)[i];
1355 (*this)[i] = rhs[i];
1364 return (T*)AttributeStoreObserver::base_addr_;
1372 return (
const T*)AttributeStoreObserver::base_addr_;
1408 class BoolAttributeAccessor;
1415 class ConstBoolAttributeAccessor {
1424 attribute_(&attribute),
1432 operator bool()
const {
1433 return (attribute_->element(index_) != 0);
1440 friend class BoolAttributeAccessor;
1447 class BoolAttributeAccessor {
1456 attribute_(&attribute),
1464 operator bool()
const {
1465 return (attribute_->element(index_) != 0);
1474 attribute_ = rhs.attribute_;
1475 index_ = rhs.index_;
1493 const BoolAttributeAccessor& rhs
1496 attribute_->element(index_) =
1497 rhs.attribute_->element(rhs.index_);
1508 const ConstBoolAttributeAccessor& rhs
1510 attribute_->element(index_) =
1511 rhs.attribute_->element(rhs.index_);
1522 return BoolAttributeAccessor(*
this,i);
1526 return ConstBoolAttributeAccessor(*
this,i);
1542 friend class BoolAttributeAccessor;
1543 friend class ConstBoolAttributeAccessor;
1611 ) : attribute_(attribute), index_(index) {
1614 operator double()
const {
1615 return attribute_.get_element_as_double(index_);
1618 void operator=(
double x) {
1619 attribute_.set_element_as_double(index_, x);
1636 ) : attribute_(attribute), index_(index) {
1639 operator double()
const {
1640 return attribute_.get_element_as_double(index_);
1654 element_type_(ET_NONE),
1672 bind_if_is_defined(manager, name);
1681 return (store_ !=
nullptr);
1693 element_type_ = ET_NONE;
1741 return (store_ ==
nullptr) ? 0 : store_->size();
1752 return element_type_;
1762 return element_index_;
1782 return element_type(store) != ET_NONE;
1832 double result = 0.0;
1833 switch(element_type()) {
1835 result = double(get_element<Numeric::uint8>(i));
1838 result = double(get_element<Numeric::int8>(i));
1841 result = double(get_element<Numeric::uint32>(i));
1844 result = double(get_element<Numeric::int32>(i));
1847 result = double(get_element<Numeric::float32>(i));
1850 result = double(get_element<Numeric::float64>(i));
1853 result = double(get_element<Numeric::float64>(i,2));
1856 result = double(get_element<Numeric::float64>(i,3));
1875 return static_cast<const T*
>(store_->data())[
1876 (i * store_->dimension() * multiplier) +
1888 double result = 0.0;
1889 switch(element_type()) {
1934 const_cast<T*
>(
static_cast<const T*
>(store_->data()))[
1935 (i * store_->dimension() * multiplier) +
1943 ElementType element_type_;
#define geo_assert_not_reached
Sets a non reachable point in the program.
#define geo_assert(x)
Verifies that a condition is met.
#define geo_debug_assert(x)
Verifies that a condition is met.
Common include file, providing basic definitions. Should be included before anything else by all head...
Base class for Attributes, that manipulates an attribute stored in an AttributesManager.
void create_vector_attribute(AttributesManager &manager, const std::string &name, index_t dimension)
Creates and binds a new vector attribute.
AttributesManager * manager() const
Gets the AttributesManager this Attribute is bound to.
~AttributeBase()
Attribute destructor.
index_t size() const
Gets the size.
AttributeBase(AttributesManager &manager, const std::string &name)
Creates or retrieves a persistent attribute attached to a given AttributesManager.
const vector< T > & get_vector() const
Gets a const reference to the internal vector<T> used to store the attribute.
void zero()
Sets all the elements of this Attribute to zero.
bool is_bound() const
Tests whether an Attribute is bound.
void unbind()
Unbinds this Attribute.
void redim(index_t new_dim)
Sets the dimension.
void destroy()
Destroys this attribute in the AttributesManager.
vector< T > & get_vector()
Gets a reference to the internal vector<T> used to store the attribute.
bool bind_if_is_compatible(AttributesManager &manager, const std::string &name)
Binds this Attribute to an AttributesManager if it already exists in the AttributesManager and tyopes...
static bool is_defined(AttributesManager &manager, const std::string &name, index_t dim=0)
Tests whether an attribute with the specified name and with corresponding type exists in an Attribute...
bool can_get_vector()
Tests whether get_vector() can be called on this Attribute.
AttributeBase()
Creates an uninitialized (unbound) Attribute.
void bind(AttributesManager &manager, const std::string &name)
Binds this Attribute to an AttributesManager.
bool bind_if_is_defined(AttributesManager &manager, const std::string &name)
Binds this Attribute to an AttributesManager if it already exists in the AttributesManager.
Internal class for creating an AttributeStore from the type name of its elements.
~AttributeStoreCreator() override
AttributeStoreCreator destructor.
virtual AttributeStore * create_attribute_store(index_t dimension)=0
Creates a new attribute store.
Base class for attributes. They are notified whenever the AttributeStore is modified.
AttributeStoreObserver()
Creates a new uninitialied AttributeStore.
void register_me(AttributeStore *store)
Registers this observer to an AttributeStore.
index_t size() const
Gets the size.
void notify(Memory::pointer base_addr, index_t size, index_t dim)
Callback function, called by the AttributeStore whenever it is modified.
index_t nb_elements() const
Gets the total number of elements.
void disconnect()
Disconnects this AttributeStoreObserver from its AttributeStore.
void unregister_me(AttributeStore *store)
Unregisters this observer from an AttributeStore.
index_t dimension() const
Gets the dimension.
Notifies a set of AttributeStoreObservers each time the stored array changes size and/or base address...
void * data()
Gets a pointer to the stored data.
AttributeStore(index_t elemsize, index_t dim=1)
AttributeStore constructor.
static AttributeStore * create_attribute_store_by_element_type_name(const std::string &element_type_name, index_t dimension)
Creates an attribute store of a given type.
bool has_observers() const
Tests whether observers listen to this AttributeStore.
virtual ~AttributeStore()
AttributeStore destructor.
static std::string element_typeid_name_by_element_type_name(const std::string &element_type_name)
Gets an element mangled type name from its C++ name.
static void register_attribute_creator(AttributeStoreCreator *creator, const std::string &element_type_name, const std::string &element_typeid_name)
Registers a new element type.
index_t size() const
Gets the size.
const void * data() const
Gets a pointer to the stored data.
virtual void clear(bool keep_memory=false)=0
Resizes this AttributeStore to 0.
virtual void notify(Memory::pointer base_addr, index_t size, index_t dim)
If size or base address differ from the cached values, notify all the observers, and update the cache...
index_t capacity() const
Gets the capacity.
static bool element_type_name_is_known(const std::string &element_type_name)
Tests whether a given element type is registered in the system.
virtual void compress(const vector< index_t > &old2new)
Compresses the stored attributes, by applying an index mapping that fills-in the gaps.
virtual std::string element_typeid_name() const =0
Gets the typeid name of the element type stored in this AttributeStore.
void copy_item(index_t to, index_t from)
Copies an item.
virtual AttributeStore * clone() const =0
Creates a new AttributeStore that is a carbon copy of this AttributeStore.
static bool element_typeid_name_is_known(const std::string &element_typeid_name)
Tests whether a given element type is registered in the system.
void register_observer(AttributeStoreObserver *observer)
Registers an observer.
virtual void apply_permutation(const vector< index_t > &permutation)
Applies a permutation to the stored attributes.
virtual void resize(index_t new_size)=0
Resizes this AttributeStore.
void unregister_observer(AttributeStoreObserver *observer)
Unregisters an observer.
virtual void redim(index_t dim)=0
Sets the dimension.
index_t dimension() const
Gets the dimension.
static std::string element_type_name_by_element_typeid_name(const std::string &element_typeid_name)
Gets an element type name from its mangled name.
virtual bool elements_type_matches(const std::string &type_name) const =0
Tests whether this AttributeStore stores elements of a given type.
void swap_items(index_t i, index_t j)
Swaps two items.
size_t element_size() const
Gets the element size.
virtual void reserve(index_t new_capacity)=0
Reserves memory.
virtual void zero()
Zeroes all the memory associated with this AttributeStore.
BoolAttributeAccessor(Attribute< bool > &attribute, index_t index)
BoolAttributeAccessor constructor.
BoolAttributeAccessor & operator=(const BoolAttributeAccessor &rhs)
Copies a bool from another attribute.
BoolAttributeAccessor & operator=(const ConstBoolAttributeAccessor &rhs)
Copies a bool from another attribute.
BoolAttributeAccessor & operator=(bool x)
Assigns a bool to a BoolAttributeAccessor.
BoolAttributeAccessor(const BoolAttributeAccessor &rhs)
Copy-constructor.
ConstBoolAttributeAccessor(const Attribute< bool > &attribute, index_t index)
ConstBoolAttributeAccessor constructor.
Numeric::uint8 & element(index_t i)
Gets a modifiable element by index.
void fill(bool val)
Sets all the elements in this attribute to a specified value.
const Numeric::uint8 & element(index_t i) const
Gets an element by index.
Manages an attribute attached to a set of object.
Attribute(AttributesManager &manager, const std::string &name)
Creates or retrieves a persistent attribute attached to a given AttributesManager.
const T & operator[](index_t i) const
Gets an element by index.
Attribute()
Creates an uninitialized (unbound) Attribute.
T * data()
Gets the pointer to the data.
void fill(const T &val)
Sets all the elements in this attribute to a specified value.
const T * data() const
Gets the pointer to the data.
T & operator[](index_t i)
Gets a modifiable element by index.
void copy(const Attribute< T > &rhs)
Copies all the values from another attribute.
static void static_test_type()
Tests at compile time whether type can be used in an Attribute. If not the case generates a compile-t...
Managers a set of attributes attached to an object.
void delete_attribute_store(AttributeStore *as)
Deletes an AttributeStore.
void compress(const vector< index_t > &old2new)
Compresses the stored attributes, by applying an index mapping that fills-in the gaps.
void copy(const AttributesManager &rhs)
Copies all the attributes from another AttributesManager.
AttributesManager()
Constructs a new empty AttributesManager.
index_t nb() const
Gets the number of attributes.
bool rename_attribute(const std::string &old_name, const std::string &new_name)
Renames an attribute.
const AttributeStore * find_attribute_store(const std::string &name) const
Finds an AttributeStore by name.
void apply_permutation(const vector< index_t > &permutation)
Applies a permutation to the stored attributes.
AttributeStore * find_attribute_store(const std::string &name)
Finds an AttributeStore by name.
void bind_attribute_store(const std::string &name, AttributeStore *as)
Binds an AttributeStore with the specified name. Ownership of this AttributeStore is transferred to t...
void list_attribute_names(vector< std::string > &names) const
Gets the names of all the attributes in this AttributeStore.
~AttributesManager()
AttributesManager destructor.
void copy_item(index_t to, index_t from)
Copies all the attributes of an item into another one.
bool is_defined(const std::string &name) const
Tests whether an attribute is defined.
void swap_items(index_t i, index_t j)
Swaps all the attributes of two items.
index_t size() const
Gets the size.
void clear(bool keep_attributes, bool keep_memory=false)
Clears this AttributesManager.
index_t capacity() const
Gets the capacity.
void delete_attribute_store(const std::string &name)
Deletes an AttributeStore by name.
bool copy_attribute(const std::string &name, const std::string &new_name)
Copies an attribute.
void zero()
Zeroes all the attributes.
void reserve(index_t new_capacity)
Pre-allocates memory for a number of items.
void resize(index_t new_size)
Resizes all the attributes managed by this AttributesManager.
Base class for reference-counted objects.
static void register_ascii_attribute_serializer(const std::string &type_name, AsciiAttributeSerializer read, AsciiAttributeSerializer write)
Declares a new attribute type that can be read from and written to ascii files.
Readonly access to an attribute as a double regardless its type.
double operator[](index_t i)
Gets a property value.
Readwrite access to an attribute as a double regardless its type.
Accessor class used by ScalarAttributeAdapter to implement indexing operator.
Accessor class used by ScalarAttributeAdapter to implement indexing operator (const version).
Access to an attribute as a double regardless its type.
index_t element_index() const
Gets the element index.
T get_element(index_t i, index_t multiplier=1) const
Gets an element.
ElementType
Internal representation of the attribute.
static std::string attribute_base_name(const std::string &name)
Gets the base attribute name from a compound name.
void bind_if_is_defined(const AttributesManager &manager, const std::string &name)
Binds this Attribute to an AttributesManager if it already exists in the AttributesManager.
bool is_bound() const
Tests whether an Attribute is bound.
static index_t nb_scalar_elements_per_item(const AttributeStore *store)
Gets the number of scalar components per item in an AttributeStore.
double get_element_as_double(index_t i) const
Gets an attribute value.
~ScalarAttributeAdapterBase()
ReadonlyScalarAttributeAdapterBase destructor.
static ElementType element_type(const AttributeStore *store)
Gets the element type stored in an AttributeStore.
const AttributeStore * attribute_store() const
Gets the AttributeStore.
ScalarAttributeAdapterBase()
ScalarAttributeAdapterBase constructor.
static bool can_be_bound_to(const AttributeStore *store)
Tests whether a ScalarAttributeAdapterBase can be bound to a given attribute store.
void unbind()
Unbinds this Attribute.
static bool is_defined(const AttributesManager &manager, const std::string &name)
Tests whether an attribute with the specified name and with a type that can be converted to double ex...
ScalarAttributeAdapterBase(const AttributesManager &manager, const std::string &name)
ScalarAttributeAdapterBase constructor.
double set_element_as_double(index_t i, double value)
Sets an attribute value.
void set_element(T value, index_t i, index_t multiplier=1) const
Sets an element.
static index_t attribute_element_index(const std::string &name)
Gets the base attribute name from a compound name.
index_t size() const
Gets the size.
ElementType element_type() const
Gets the internal representation of the elements.
A smart pointer with reference-counted copy semantics.
Implementation of AttributeStoreCreator for a specific type.
AttributeStore * create_attribute_store(index_t dim) override
Creates a new attribute store.
Stores an array of elements of a given type, and notifies a set of AttributeStoreObservers each time ...
TypedAttributeStore(index_t dim=1)
Creates a new empty attribute store.
void notify(Memory::pointer base_addr, index_t size, index_t dim) override
If size or base address differ from the cached values, notify all the observers, and update the cache...
void clear(bool keep_memory=false) override
Resizes this AttributeStore to 0.
AttributeStore * clone() const override
Creates a new AttributeStore that is a carbon copy of this AttributeStore.
void resize(index_t new_size) override
Resizes this AttributeStore.
std::string element_typeid_name() const override
Gets the typeid name of the element type stored in this AttributeStore.
void reserve(index_t new_capacity) override
Reserves memory.
bool elements_type_matches(const std::string &type_name) const override
Tests whether this AttributeStore stores elements of a given type.
void redim(index_t dim) override
Sets the dimension.
Helper class to register new attribute types.
geo_register_attribute_type(const std::string &type_name)
geo_register_attribute_type constructor
Vector with aligned memory allocation.
Functions to read and write structured files.
Generic logging mechanism.
Types and functions for memory manipulation.
byte * pointer
Pointer to unsigned byte(s)
Global Vorpaline namespace.
bool write_ascii_attribute< bool >(FILE *file, Memory::pointer base_addr, index_t nb_elements)
Writes an ASCII attribute to a file.
geo_index_t index_t
The type for storing and manipulating indices.
SmartPointer< AttributeStoreCreator > AttributeStoreCreator_var
An automatic reference-counted pointer to an AttributeStoreCreator.
bool read_ascii_attribute< bool >(FILE *file, Memory::pointer base_addr, index_t nb_elements)
Reads an ASCII attribute from a file.
Types and functions for numbers manipulation.
Function and classes for process manipulation.