41#ifndef GEOGRAM_BASIC_ATTRIBUTES
42#define GEOGRAM_BASIC_ATTRIBUTES
76 base_addr_(nullptr), size_(0), dimension_(0),
77 disconnected_(false) {
90 base_addr_ = base_addr;
118 return size_ * dimension_;
149 base_addr_ =
nullptr;
152 disconnected_ =
true;
162 return disconnected_;
197 std::string element_type_name_;
198 std::string element_typeid_name_;
241 const std::string& type_name
265 return cached_capacity_;
286 virtual void clear(
bool keep_memory =
false) = 0;
294 return !observers_.empty();
383 size_t item_size = element_size_ * dimension_;
385 cached_base_addr_+to*item_size,
386 cached_base_addr_+from*item_size,
397 size_t item_size = element_size_ * dimension_;
399 cached_base_addr_+to*item_size,
434 return cached_base_addr_;
442 return cached_base_addr_;
450 return element_size_;
462 const std::string& element_type_name
465 type_name_to_creator_.find(element_type_name) !=
466 type_name_to_creator_.end()
479 const std::string& element_typeid_name
482 typeid_name_to_type_name_.find(element_typeid_name) !=
483 typeid_name_to_type_name_.end()
494 const std::string& element_type_name,
497 geo_assert(element_type_name_is_known(element_type_name));
498 return type_name_to_creator_[element_type_name]->
499 create_attribute_store(dimension);
510 const std::string& element_typeid_name
512 geo_assert(element_typeid_name_is_known(element_typeid_name));
513 return typeid_name_to_type_name_[element_typeid_name];
525 const std::string& element_type_name
527 geo_assert(element_type_name_is_known(element_type_name));
528 return type_name_to_typeid_name_[element_type_name];
543 const std::string& element_type_name,
544 const std::string& element_typeid_name
581 size_t element_size_;
586 std::set<AttributeStoreObserver*> observers_;
589 static std::map<std::string, AttributeStoreCreator_var>
590 type_name_to_creator_;
592 static std::map<std::string, std::string>
593 typeid_name_to_type_name_;
595 static std::map<std::string, std::string>
596 type_name_to_typeid_name_;
622 store_.resize(new_size*dimension_);
632 store_.reserve(new_capacity*dimension_);
633 cached_capacity_ = new_capacity;
642 void clear(
bool keep_memory=
false)
override {
648 notify(
nullptr, 0, dimension_);
660 for(
index_t c = 0; c < copy_dim; ++c) {
661 new_store[dim * i + c] = store_[dimension_ * i + c];
664 store_.swap(new_store);
673 return type_name ==
typeid(T).name();
677 return typeid(T).name();
684 result->store_ = store_;
694 for(
index_t i=0; i<dimension_; ++i) {
695 scale_value(store_[to*dimension_+i], s);
702 for(
index_t i=0; i<dimension_; ++i) {
704 store_[to*dimension_+i], s, store_[from*dimension_+i]
717 template<
class TT>
static void scale_value(TT& to,
double s) {
722 static void scale_value(uint8_t& to,
double s) {
723 to = uint8_t(
double(to)*s != 0.0);
726 static void scale_value(int32_t& to,
double s) {
727 to = int32_t(
double(to)*s);
730 static void scale_value(uint32_t& to,
double s) {
731 to = uint32_t(
double(to)*s);
734 static void scale_value(
float& to,
double s) {
735 to = float(
double(to)*s);
738 static void scale_value(
double& to,
double s) {
742 template<
class TT>
static void madd_value(TT& to,
double s, TT& from) {
748 static void madd_value(uint8_t& to,
double s, uint8_t& from) {
749 to = uint8_t(
double(to) + s*
double(from) != 0.0);
752 static void madd_value(int32_t& to,
double s, int32_t& from) {
753 to = int32_t(
double(to) + s*
double(from));
756 static void madd_value(uint32_t& to,
double s, uint32_t& from) {
757 to = uint32_t(
double(to) + s*
double(from));
760 static void madd_value(
float& to,
double s,
float& from) {
761 to = float(
double(to) + s*
double(from));
764 static void madd_value(
double& to,
double s,
double& from) {
811 if(type_name ==
"bool") {
820 read_ascii_attribute<T>,
821 write_ascii_attribute<T>
852 return index_t(attributes_.size());
905 void clear(
bool keep_attributes,
bool keep_memory =
false);
938 const std::string& name
949 return (find_attribute_store(name) !=
nullptr);
1059 const std::string& name,
const std::string& new_name
1071 const std::string& old_name,
const std::string& new_name
1096 std::map<std::string, AttributeStore*> attributes_;
1139 return (store_ !=
nullptr && !disconnected_);
1151 if(!disconnected_) {
1171 if(store_ ==
nullptr) {
1195 if(store_ !=
nullptr) {
1218 if(store_ !=
nullptr) {
1238 const std::string& name,
1274 store_->
redim(new_dim);
1306 ((dim == 0) || (store->
dimension() == dim))
1356 return typed_store->get_vector();
1369 return typed_store->get_vector();
1406#if __GNUG__ && __GNUC__ < 5 && !__clang__
1408 __has_trivial_copy(T),
1409 "Attribute only implemented for types that can be copied with memcpy()"
1413 std::is_trivially_copyable<T>::value,
1414 "Attribute only implemented for types that can be copied with memcpy()"
1448 return ((T*)(
void*)superclass::base_addr_)[i];
1459 return ((
const T*)(
void*)superclass::base_addr_)[i];
1484 (*this)[i] = rhs[i];
1493 return (T*)AttributeStoreObserver::base_addr_;
1501 return (
const T*)AttributeStoreObserver::base_addr_;
1537 class BoolAttributeAccessor;
1544 class ConstBoolAttributeAccessor {
1553 attribute_(&attribute),
1561 operator bool()
const {
1562 return (attribute_->element(index_) != 0);
1569 friend class BoolAttributeAccessor;
1576 class BoolAttributeAccessor {
1585 attribute_(&attribute),
1593 operator bool()
const {
1594 return (attribute_->element(index_) != 0);
1603 attribute_ = rhs.attribute_;
1604 index_ = rhs.index_;
1622 const BoolAttributeAccessor& rhs
1625 attribute_->element(index_) =
1626 rhs.attribute_->element(rhs.index_);
1637 const ConstBoolAttributeAccessor& rhs
1639 attribute_->element(index_) =
1640 rhs.attribute_->element(rhs.index_);
1651 return BoolAttributeAccessor(*
this,i);
1655 return ConstBoolAttributeAccessor(*
this,i);
1679 element(i) = rhs.element(i);
1685 friend class BoolAttributeAccessor;
1686 friend class ConstBoolAttributeAccessor;
1754 ) : attribute_(attribute), index_(index) {
1757 operator double()
const {
1758 return attribute_.get_element_as_double(index_);
1761 void operator=(
double x) {
1762 attribute_.set_element_as_double(index_, x);
1779 ) : attribute_(attribute), index_(index) {
1782 operator double()
const {
1783 return attribute_.get_element_as_double(index_);
1797 element_type_(ET_NONE),
1815 bind_if_is_defined(manager, name);
1824 return (store_ !=
nullptr);
1836 element_type_ = ET_NONE;
1884 return (store_ ==
nullptr) ? 0 : store_->size();
1895 return element_type_;
1905 return element_index_;
1925 return element_type(store) != ET_NONE;
1975 double result = 0.0;
1976 switch(element_type()) {
1978 result = double(get_element<Numeric::uint8>(i));
1981 result = double(get_element<Numeric::int8>(i));
1984 result = double(get_element<Numeric::uint32>(i));
1987 result = double(get_element<Numeric::int32>(i));
1990 result = double(get_element<Numeric::float32>(i));
1993 result = double(get_element<Numeric::float64>(i));
1996 result = double(get_element<Numeric::float64>(i,2));
1999 result = double(get_element<Numeric::float64>(i,3));
2018 return static_cast<const T*
>(store_->data())[
2019 (i * store_->dimension() * multiplier) +
2031 double result = 0.0;
2032 switch(element_type()) {
2077 const_cast<T*
>(
static_cast<const T*
>(store_->data()))[
2078 (i * store_->dimension() * multiplier) +
2086 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 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_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.
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.
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.
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 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.
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 ...
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...
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.