41#ifndef GEOGRAM_BASIC_ATTRIBUTES
42#define GEOGRAM_BASIC_ATTRIBUTES
77 base_addr_(nullptr), size_(0), dimension_(0),
78 disconnected_(false) {
91 base_addr_ = base_addr;
119 return size_ * dimension_;
150 base_addr_ =
nullptr;
153 disconnected_ =
true;
163 return disconnected_;
206 std::string element_type_name_;
207 std::string element_typeid_name_;
250 const std::string& type_name
274 return cached_capacity_;
295 virtual void clear(
bool keep_memory =
false) = 0;
303 return !observers_.empty();
386 size_t item_size = element_size_ * dimension_;
387 if(lifecycle_.is_null()) {
389 cached_base_addr_+to*item_size,
390 cached_base_addr_+from*item_size,
395 cached_base_addr_+to*item_size,
396 cached_base_addr_+from*item_size
407 size_t item_size = element_size_ * dimension_;
408 if(lifecycle_.is_null()) {
410 cached_base_addr_+to*item_size,
414 lifecycle_->reset(cached_base_addr_+to*item_size);
448 return cached_base_addr_;
456 return cached_base_addr_;
464 return element_size_;
476 const std::string& element_type_name
479 type_name_to_creator_.find(element_type_name) !=
480 type_name_to_creator_.end()
493 const std::string& element_typeid_name
496 typeid_name_to_type_name_.find(element_typeid_name) !=
497 typeid_name_to_type_name_.end()
511 const std::string& element_type_name
515 type_name_to_creator_[
517 ]->elements_are_trivially_copyable()
531 const std::string& element_typeid_name
534 std::string element_type_name =
535 typeid_name_to_type_name_[element_typeid_name];
536 return element_by_type_name_is_trivially_copyable(element_type_name);
546 const std::string& element_type_name,
549 geo_assert(element_type_name_is_known(element_type_name));
550 return type_name_to_creator_[element_type_name]->
551 create_attribute_store(dimension);
562 const std::string& element_typeid_name
564 geo_assert(element_typeid_name_is_known(element_typeid_name));
565 return typeid_name_to_type_name_[element_typeid_name];
577 const std::string& element_type_name
579 geo_assert(element_type_name_is_known(element_type_name));
580 return type_name_to_typeid_name_[element_type_name];
595 const std::string& element_type_name,
596 const std::string& element_typeid_name
654 size_t element_size_;
660 std::set<AttributeStoreObserver*> observers_;
663 static std::map<std::string, AttributeStoreCreator_var>
664 type_name_to_creator_;
666 static std::map<std::string, std::string>
667 typeid_name_to_type_name_;
669 static std::map<std::string, std::string>
670 type_name_to_typeid_name_;
693 if(!std::is_trivially_copyable<T>::value) {
699 store_.resize(new_size*dimension_);
709 store_.reserve(new_capacity*dimension_);
710 cached_capacity_ = new_capacity;
719 void clear(
bool keep_memory=
false)
override {
725 notify(
nullptr, 0, dimension_);
736 for(
index_t c = 0; c < copy_dim; ++c) {
737 new_store[dim * i + c] = store_[dimension_ * i + c];
740 store_.swap(new_store);
749 return type_name ==
typeid(T).name();
753 return typeid(T).name();
760 result->store_ = store_;
761 result->lifecycle_ = lifecycle_;
771 for(
index_t i=0; i<dimension_; ++i) {
772 scale_value(store_[to*dimension_+i], s);
779 for(
index_t i=0; i<dimension_; ++i) {
781 store_[to*dimension_+i], s, store_[from*dimension_+i]
794 template<
class TT>
static void scale_value(TT& to,
double s) {
799 static void scale_value(uint8_t& to,
double s) {
800 to = uint8_t(
double(to)*s != 0.0);
803 static void scale_value(int32_t& to,
double s) {
804 to = int32_t(
double(to)*s);
807 static void scale_value(uint32_t& to,
double s) {
808 to = uint32_t(
double(to)*s);
811 static void scale_value(
float& to,
double s) {
812 to = float(
double(to)*s);
815 static void scale_value(
double& to,
double s) {
819 template<
class TT>
static void madd_value(TT& to,
double s, TT& from) {
825 static void madd_value(uint8_t& to,
double s, uint8_t& from) {
826 to = uint8_t(
double(to) + s*
double(from) != 0.0);
829 static void madd_value(int32_t& to,
double s, int32_t& from) {
830 to = int32_t(
double(to) + s*
double(from));
833 static void madd_value(uint32_t& to,
double s, uint32_t& from) {
834 to = uint32_t(
double(to) + s*
double(from));
837 static void madd_value(
float& to,
double s,
float& from) {
838 to = float(
double(to) + s*
double(from));
841 static void madd_value(
double& to,
double s,
double& from) {
870 return(std::is_trivially_copyable<T>::value);
895 if(type_name ==
"bool") {
904 read_ascii_attribute<T>,
905 write_ascii_attribute<T>
936 return index_t(attributes_.size());
989 void clear(
bool keep_attributes,
bool keep_memory =
false);
1022 const std::string& name
1033 return (find_attribute_store(name) !=
nullptr);
1143 const std::string& name,
const std::string& new_name
1155 const std::string& old_name,
const std::string& new_name
1180 std::map<std::string, AttributeStore*> attributes_;
1223 return (store_ !=
nullptr && !disconnected_);
1235 if(!disconnected_) {
1255 if(store_ ==
nullptr) {
1279 if(store_ !=
nullptr) {
1302 if(store_ !=
nullptr) {
1322 const std::string& name,
1358 store_->
redim(new_dim);
1390 ((dim == 0) || (store->
dimension() == dim))
1440 return typed_store->get_vector();
1453 return typed_store->get_vector();
1508 return ((T*)(
void*)superclass::base_addr_)[i];
1519 return ((
const T*)(
void*)superclass::base_addr_)[i];
1544 (*this)[i] = rhs[i];
1553 return (T*)AttributeStoreObserver::base_addr_;
1561 return (
const T*)AttributeStoreObserver::base_addr_;
1597 class BoolAttributeAccessor;
1604 class ConstBoolAttributeAccessor {
1613 attribute_(&attribute),
1621 operator bool()
const {
1622 return (attribute_->element(index_) != 0);
1629 friend class BoolAttributeAccessor;
1636 class BoolAttributeAccessor {
1645 attribute_(&attribute),
1653 operator bool()
const {
1654 return (attribute_->element(index_) != 0);
1663 attribute_ = rhs.attribute_;
1664 index_ = rhs.index_;
1682 const BoolAttributeAccessor& rhs
1685 attribute_->element(index_) =
1686 rhs.attribute_->element(rhs.index_);
1697 const ConstBoolAttributeAccessor& rhs
1699 attribute_->element(index_) =
1700 rhs.attribute_->element(rhs.index_);
1711 return BoolAttributeAccessor(*
this,i);
1715 return ConstBoolAttributeAccessor(*
this,i);
1739 element(i) = rhs.element(i);
1745 friend class BoolAttributeAccessor;
1746 friend class ConstBoolAttributeAccessor;
1814 ) : attribute_(attribute), index_(index) {
1817 operator double()
const {
1818 return attribute_.get_element_as_double(index_);
1821 void operator=(
double x) {
1822 attribute_.set_element_as_double(index_, x);
1839 ) : attribute_(attribute), index_(index) {
1842 operator double()
const {
1843 return attribute_.get_element_as_double(index_);
1857 element_type_(ET_NONE),
1875 bind_if_is_defined(manager, name);
1884 return (store_ !=
nullptr);
1896 element_type_ = ET_NONE;
1944 return (store_ ==
nullptr) ? 0 : store_->size();
1955 return element_type_;
1965 return element_index_;
1985 return element_type(store) != ET_NONE;
2035 double result = 0.0;
2036 switch(element_type()) {
2038 result = double(get_element<Numeric::uint8>(i));
2041 result = double(get_element<Numeric::int8>(i));
2044 result = double(get_element<Numeric::uint32>(i));
2047 result = double(get_element<Numeric::int32>(i));
2050 result = double(get_element<Numeric::float32>(i));
2053 result = double(get_element<Numeric::float64>(i));
2056 result = double(get_element<Numeric::float64>(i,2));
2059 result = double(get_element<Numeric::float64>(i,3));
2078 return static_cast<const T*
>(store_->data())[
2079 (i * store_->dimension() * multiplier) +
2091 double result = 0.0;
2092 switch(element_type()) {
2137 const_cast<T*
>(
static_cast<const T*
>(store_->data()))[
2138 (i * store_->dimension() * multiplier) +
2146 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.
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 types ...
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 bool elements_are_trivially_copyable() const =0
Tests whether elements of this attribute can be trivially copyable.
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.
bool disconnected() const
Tests whether this AttributeStoreObserver was disconnected.
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.
Memory::pointer base_addr() const
Gets a pointer to the storage.
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.
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.
void zero_item(index_t to)
Sets an item to zero.
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...
AttributeStore(size_t elemsize, index_t dim=1)
AttributeStore constructor.
index_t capacity() const
Gets the capacity.
virtual void madd_item(index_t to, double s, index_t from)
Adds a scaled item to another item \detais item[to] += s * item[from].
static bool element_by_typeid_name_is_trivially_copyable(const std::string &element_typeid_name)
Tests whether an element type is trivially copyable.
static bool element_type_name_is_known(const std::string &element_type_name)
Tests whether a given element type is registered in the system.
void apply_permutation_with_lifecycle(const vector< index_t > &permutation)
implementation of apply_permutation() used when there is a lifecycle, that is, when attribute type is...
virtual void compress(const vector< index_t > &old2new)
Compresses the stored attributes, by applying an index mapping that fills-in the gaps.
LifeCycle * lifecycle() const
Gets the LifeCycle.
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.
virtual void scale_item(index_t to, double s)
Scales an item.
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.
static bool element_by_type_name_is_trivially_copyable(const std::string &element_type_name)
Tests whether an element type is trivially copyable.
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.
void copy(const Attribute< bool > &rhs)
Copies all the values from another attribute.
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.
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 zero_item(index_t to)
Sets an item to zero.
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.
void scale_item(index_t to, double s)
Scales an item.
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.
void madd_item(index_t to, double s, index_t from)
Adds a scaled item to another item \detais item[to] += s * item[from].
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.
Concrete implementation of LifeCycle.
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.
Manages the life cycle of an object.
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.
bool elements_are_trivially_copyable() const override
Tests whether elements of this attribute can be trivially copyable.
Stores an array of elements of a given type, and notifies a set of AttributeStoreObservers each time ...
void scale_item(index_t to, double s) override
Scales an item.
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 madd_item(index_t to, double s, index_t from) override
Adds a scaled item to another item \detais item[to] += s * item[from].
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.
Common include file, providing basic definitions. Should be included before anything else by all head...
Implementation of generic object lifecycle service.
Generic logging mechanism.
Types and functions for memory manipulation.
byte * pointer
Pointer to unsigned byte(s)
std::atomic_flag spinlock
A lightweight synchronization structure.
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.
void geo_argused(const T &)
Suppresses compiler warnings about unused parameters.
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.