attributes.h

Go to the documentation of this file.

/*
 *  Copyright (c) 2000-2022 Inria
 *  All rights reserved.
 *
 *  Redistribution and use in source and binary forms, with or without
 *  modification, are permitted provided that the following conditions are met:
 *
 *  * Redistributions of source code must retain the above copyright notice,
 *  this list of conditions and the following disclaimer.
 *  * Redistributions in binary form must reproduce the above copyright notice,
 *  this list of conditions and the following disclaimer in the documentation
 *  and/or other materials provided with the distribution.
 *  * Neither the name of the ALICE Project-Team nor the names of its
 *  contributors may be used to endorse or promote products derived from this
 *  software without specific prior written permission.
 *
 *  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
 *  AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 *  IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 *  ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
 *  LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 *  CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
 *  SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
 *  INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
 *  CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 *  ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 *  POSSIBILITY OF SUCH DAMAGE.
 *
 *  Contact: Bruno Levy
 *
 *     https://www.inria.fr/fr/bruno-levy
 *
 *     Inria,
 *     Domaine de Voluceau,
 *     78150 Le Chesnay - Rocquencourt
 *     FRANCE
 *
 */
 
 
#ifndef GEOGRAM_BASIC_ATTRIBUTES
#define GEOGRAM_BASIC_ATTRIBUTES
 
#include <geogram/basic/common.h>
#include <geogram/basic/memory.h>
#include <geogram/basic/life_cycle.h>
#include <geogram/basic/numeric.h>
#include <geogram/basic/process.h>
#include <geogram/basic/geofile.h>
#include <geogram/basic/logger.h>
 
#include <map>
#include <typeinfo>
#include <set>
#include <type_traits>
 
namespace GEO {
 
    class AttributeStore;
 
    class GEOGRAM_API AttributeStoreObserver {
    public:
 
    AttributeStoreObserver() :
    base_addr_(nullptr), size_(0), dimension_(0),
    disconnected_(false) {
    }
 
    void notify(
        Memory::pointer base_addr, index_t size, index_t dim
    ) {
        base_addr_ = base_addr;
        size_ = size;
        dimension_ = dim;
    }
 
    index_t size() const {
        return size_;
    }
 
    index_t dimension() const {
        return dimension_;
    }
 
    index_t nb_elements() const {
        return size_ * dimension_;
    }
 
    Memory::pointer base_addr() const {
        return base_addr_;
    }
 
    void register_me(AttributeStore* store);
 
    void unregister_me(AttributeStore* store);
 
    void disconnect() {
        base_addr_ = nullptr;
        size_ = 0;
        dimension_ = 0;
        disconnected_ = true;
    }
 
    bool disconnected() const {
        return disconnected_;
    }
 
    protected:
    Memory::pointer base_addr_;
    index_t size_;
    index_t dimension_;
    bool disconnected_;
    };
 
 
    /*********************************************************************/
 
 
    class GEOGRAM_API AttributeStoreCreator : public Counted {
    public:
 
        ~AttributeStoreCreator() override;
 
        virtual AttributeStore* create_attribute_store(index_t dimension) = 0;
 
        virtual bool elements_are_trivially_copyable() const = 0;
 
    private:
        std::string element_type_name_;
        std::string element_typeid_name_;
    };
 
    typedef SmartPointer<AttributeStoreCreator> AttributeStoreCreator_var;
 
    class GEOGRAM_API AttributeStore {
    public:
    AttributeStore(size_t elemsize, index_t dim=1);
 
    virtual ~AttributeStore();
 
 
    virtual bool elements_type_matches(
        const std::string& type_name
    ) const = 0;
 
    virtual std::string element_typeid_name() const = 0;
 
    virtual std::string user_element_typeid_name() const = 0;
 
    index_t size() const {
        return cached_size_;
    }
 
    index_t capacity() const {
        return cached_capacity_;
    }
 
    virtual void resize(index_t new_size) = 0;
 
    virtual void reserve(index_t new_capacity) = 0;
 
    virtual void clear(bool keep_memory = false) = 0;
 
    bool has_observers() const {
        return !observers_.empty();
    }
 
    index_t dimension() const {
        return dimension_;
    }
 
    virtual void redim(index_t dim) = 0;
 
 
    virtual void apply_permutation(
        const vector<index_t>& permutation
    );
 
 
    virtual void compress(const vector<index_t>& old2new);
 
    virtual void zero();
 
    virtual AttributeStore* clone() const = 0;
 
 
    void copy_item(index_t to, index_t from) {
        geo_debug_assert(from < cached_size_);
        geo_debug_assert(to < cached_size_);
        size_t item_size = element_size_ * dimension_;
        if(lifecycle_.is_null()) {
            Memory::copy(
                cached_base_addr_+to*item_size,
                cached_base_addr_+from*item_size,
                item_size
            );
        } else {
            lifecycle_->assign(
                cached_base_addr_+to*item_size,
                cached_base_addr_+from*item_size
            );
        }
    }
 
    void zero_item(index_t to) {
        geo_debug_assert(to < cached_size_);
        size_t item_size = element_size_ * dimension_;
        if(lifecycle_.is_null()) {
            Memory::clear(
                cached_base_addr_+to*item_size,
                item_size
            );
        } else {
            lifecycle_->reset(cached_base_addr_+to*item_size);
        }
    }
 
    virtual void scale_item(index_t to, double s);
 
    virtual void madd_item(index_t to, double s, index_t from);
 
    void swap_items(index_t i, index_t j);
 
    void* data() {
        return cached_base_addr_;
    }
 
    const void* data() const {
        return cached_base_addr_;
    }
 
    size_t element_size() const {
        return element_size_;
    }
 
    static bool element_type_name_is_known(
        const std::string& element_type_name
    ) {
        return (
            type_name_to_creator_.find(element_type_name) !=
            type_name_to_creator_.end()
        );
    }
 
    static bool element_typeid_name_is_known(
        const std::string& element_typeid_name
    ) {
        return (
            typeid_name_to_type_name_.find(element_typeid_name) !=
            typeid_name_to_type_name_.end()
        );
    }
 
    static bool element_by_type_name_is_trivially_copyable(
        const std::string& element_type_name
    ) {
        geo_debug_assert(element_type_name_is_known(element_type_name));
        return (
            type_name_to_creator_[
                element_type_name
            ]->elements_are_trivially_copyable()
        );
    }
 
    static bool element_by_typeid_name_is_trivially_copyable(
        const std::string& element_typeid_name
    ) {
        geo_debug_assert(element_typeid_name_is_known(element_typeid_name));
        std::string element_type_name =
            typeid_name_to_type_name_[element_typeid_name];
        return element_by_type_name_is_trivially_copyable(element_type_name);
    }
 
    static AttributeStore* create_attribute_store_by_element_type_name(
        const std::string& element_type_name,
        index_t dimension
    ) {
        geo_assert(element_type_name_is_known(element_type_name));
        return type_name_to_creator_[element_type_name]->
            create_attribute_store(dimension);
    }
 
    static std::string element_type_name_by_element_typeid_name(
        const std::string& element_typeid_name
    ) {
        geo_assert(element_typeid_name_is_known(element_typeid_name));
        return typeid_name_to_type_name_[element_typeid_name];
    }
 
    static std::string element_typeid_name_by_element_type_name(
        const std::string& element_type_name
    ) {
        geo_assert(element_type_name_is_known(element_type_name));
        return type_name_to_typeid_name_[element_type_name];
    }
 
    static void register_attribute_creator(
        AttributeStoreCreator* creator,
        const std::string& element_type_name,
        const std::string& element_typeid_name
    );
 
    LifeCycle* lifecycle() const {
        return lifecycle_;
    }
 
    protected:
 
    void apply_permutation_with_lifecycle(
        const vector<index_t>& permutation
    );
 
    virtual void notify(
        Memory::pointer base_addr, index_t size, index_t dim
    );
 
    void register_observer(AttributeStoreObserver* observer);
 
    void unregister_observer(AttributeStoreObserver* observer);
 
 
    protected:
    size_t element_size_;
    index_t dimension_;
    Memory::pointer cached_base_addr_;
    index_t cached_size_;
    index_t cached_capacity_;
    LifeCycle_var lifecycle_;
    std::set<AttributeStoreObserver*> observers_;
    Process::spinlock lock_;
 
    static std::map<std::string, AttributeStoreCreator_var>
    type_name_to_creator_;
 
    static std::map<std::string, std::string>
    typeid_name_to_type_name_;
 
    static std::map<std::string, std::string>
    type_name_to_typeid_name_;
 
    friend class AttributeStoreObserver;
    };
 
    /*********************************************************************/
 
    template <class ST> class TypedAttributeStore : public AttributeStore {
    public:
 
        TypedAttributeStore(
            index_t dim=1, const std::type_info& user_type_info = typeid(ST)
        ) :
            AttributeStore(sizeof(ST),dim),
            storage_type_(typeid(ST)),
            user_type_(user_type_info) {
            if(!std::is_trivially_copyable<ST>::value) {
                lifecycle_ = new GenericLifeCycle<ST>();
            }
        }
 
        void resize(index_t new_size) override {
            store_.resize(new_size*dimension_);
            notify(
                store_.empty() ? nullptr : Memory::pointer(store_.data()),
                new_size,
                dimension_
            );
        }
 
        void reserve(index_t new_capacity) override {
            if(new_capacity > capacity()) {
                store_.reserve(new_capacity*dimension_);
                cached_capacity_ = new_capacity;
                notify(
                    store_.empty() ? nullptr : Memory::pointer(store_.data()),
                    size(),
                    dimension_
                );
            }
        }
 
        void clear(bool keep_memory=false) override {
            if(keep_memory) {
                store_.resize(0);
            } else {
                store_.clear();
            }
            notify(nullptr, 0, dimension_);
        }
 
        void redim(index_t dim) override {
            if(dim == dimension()) {
                return;
            }
            vector<ST> new_store(size()*dim);
            new_store.reserve(capacity()*dim);
            index_t copy_dim = std::min(dim, dimension());
            for(index_t i = 0; i < size(); ++i) {
                for(index_t c = 0; c < copy_dim; ++c) {
                    new_store[dim * i + c] = store_[dimension_ * i + c];
                }
            }
            store_.swap(new_store);
            notify(
                store_.empty() ? nullptr : Memory::pointer(store_.data()),
                size(),
                dim
            );
        }
 
        bool elements_type_matches(const std::string& type_name) const override {
            return (
                type_name == storage_type_.name() ||
                type_name == user_type_.name()
            );
        }
 
        std::string element_typeid_name() const override {
            return storage_type_.name();
        }
 
        std::string user_element_typeid_name() const override {
            return user_type_.name();
        }
 
        AttributeStore* clone() const override {
            TypedAttributeStore<ST>* result =
                new TypedAttributeStore<ST>(dimension(), user_type_);
            result->resize(size());
            result->store_ = store_;
            result->lifecycle_ = lifecycle_;
            return result;
        }
 
        vector<ST>& get_vector() {
            return store_;
        }
 
        void scale_item(index_t to, double s) override {
            geo_assert(to < size());
            for(index_t i=0; i<dimension_; ++i) {
                scale_value(store_[to*dimension_+i], s);
            }
        }
 
        void madd_item(index_t to, double s, index_t from) override {
            geo_assert(from < size());
            geo_assert(to < size());
            for(index_t i=0; i<dimension_; ++i) {
                madd_value(
                    store_[to*dimension_+i], s, store_[from*dimension_+i]
                );
            }
        }
 
    protected:
        void notify(
            Memory::pointer base_addr, index_t size, index_t dim
        ) override {
            AttributeStore::notify(base_addr, size, dim);
            geo_assert(size*dim <= store_.size());
        }
 
        template<class TT> static void scale_value(TT& to, double s) {
            geo_argused(to);
            geo_argused(s);
        }
 
        static void scale_value(uint8_t& to, double s) {
            to = uint8_t(double(to)*s != 0.0);
        }
 
        static void scale_value(int32_t& to, double s) {
            to = int32_t(double(to)*s);
        }
 
        static void scale_value(uint32_t& to, double s) {
            to = uint32_t(double(to)*s);
        }
 
        static void scale_value(float& to, double s) {
            to = float(double(to)*s);
        }
 
        static void scale_value(double& to, double s) {
            to *= s;
        }
 
        template<class TT> static void madd_value(TT& to, double s, TT& from) {
            geo_argused(to);
            geo_argused(s);
            geo_argused(from);
        }
 
        static void madd_value(uint8_t& to, double s, uint8_t& from) {
            to = uint8_t(double(to) + s*double(from) != 0.0);
        }
 
        static void madd_value(int32_t& to, double s, int32_t& from) {
            to = int32_t(double(to) + s*double(from));
        }
 
        static void madd_value(uint32_t& to, double s, uint32_t& from) {
            to = uint32_t(double(to) + s*double(from));
        }
 
        static void madd_value(float& to, double s, float& from) {
            to = float(double(to) + s*double(from));
        }
 
        static void madd_value(double& to, double s, double& from) {
            to += s*from;
        }
 
    private:
        vector<ST> store_;
        const std::type_info& storage_type_;
        const std::type_info& user_type_;
    };
 
    /*********************************************************************/
 
    template <class UT, class ST=UT>
    class TypedAttributeStoreCreator : public AttributeStoreCreator {
    public:
        AttributeStore* create_attribute_store(index_t dim) override{
            return new TypedAttributeStore<ST>(dim,typeid(UT));
        }
 
        bool elements_are_trivially_copyable() const override {
            return(std::is_trivially_copyable<ST>::value);
        }
    };
 
    /*********************************************************************/
 
    template <class UT, class ST=UT> class geo_register_attribute_type {
    public:
        geo_register_attribute_type(const std::string& type_name) {
            AttributeStore::register_attribute_creator(
                new TypedAttributeStoreCreator<UT,ST>,
                type_name, typeid(UT).name()
            );
            if(type_name == "bool") {
                GeoFile::register_ascii_attribute_serializer(
                    type_name,
                    read_ascii_attribute<bool>,
                    write_ascii_attribute<bool>
                );
            } else {
                GeoFile::register_ascii_attribute_serializer(
                    type_name,
                    read_ascii_attribute<UT>,
                    write_ascii_attribute<UT>
                );
            }
        }
    };
 
    /*********************************************************************/
 
    class GEOGRAM_API AttributesManager {
    public:
    AttributesManager();
 
 
    ~AttributesManager();
 
    index_t nb() const {
        return index_t(attributes_.size());
    }
 
    void list_attribute_names(vector<std::string>& names) const;
 
    index_t size() const {
        return size_;
    }
 
    index_t capacity() const {
        return capacity_;
    }
 
    void resize(index_t new_size);
 
    void reserve(index_t new_capacity);
 
    void clear(bool keep_attributes, bool keep_memory = false);
 
 
    void zero();
 
    void bind_attribute_store(const std::string& name, AttributeStore* as);
 
    AttributeStore* find_attribute_store(const std::string& name);
 
    const AttributeStore* find_attribute_store(
        const std::string& name
    ) const;
 
 
    bool is_defined(const std::string& name) const {
        return (find_attribute_store(name) != nullptr);
    }
 
    void delete_attribute_store(const std::string& name);
 
    void delete_attribute_store(AttributeStore* as);
 
    void apply_permutation(
        const vector<index_t>& permutation
    );
 
    void compress(const vector<index_t>& old2new);
 
    void copy(const AttributesManager& rhs);
 
 
    void copy_item(index_t to, index_t from);
 
    void swap_items(index_t i, index_t j);
 
 
    void zero_item(index_t to);
 
    void scale_item(index_t to, double s);
 
    void madd_item(index_t to, double s, index_t from);
 
    bool copy_attribute(
        const std::string& name, const std::string& new_name
    );
 
    bool rename_attribute(
        const std::string& old_name, const std::string& new_name
    );
 
    private:
    AttributesManager(const AttributesManager& rhs) = delete;
 
    const AttributesManager& operator=(const AttributesManager& rhs) = delete;
 
    private:
    index_t size_;
    index_t capacity_;
    std::map<std::string, AttributeStore*> attributes_;
    } ;
 
 
    /*********************************************************************/
 
 
    template <class UT, class ST = UT>
    class AttributeBase : public AttributeStoreObserver {
    public:
 
        AttributeBase() :
            manager_(nullptr),
            store_(nullptr),
            existed_already_(false) {
        }
 
        AttributeBase(AttributesManager& manager, const std::string& name) :
            manager_(nullptr),
            store_(nullptr),
            existed_already_(false) {
            bind(manager, name);
        }
 
        bool is_bound() const {
            return (store_ != nullptr && !disconnected_);
        }
 
        bool existed_already() const {
            return existed_already_;
        }
 
        void unbind() {
            geo_assert(is_bound());
            // If the AttributesManager was destroyed before, do not
            // do anything. This can occur in Lua scripting when using
            // Attribute wrapper objects.
            if(!disconnected_) {
                unregister_me(store_);
            }
            manager_ = nullptr;
            store_ = nullptr;
            existed_already_ = false;
        }
 
        void bind(AttributesManager& manager, const std::string& name) {
            geo_assert(!is_bound());
            manager_ = &manager;
            store_ = manager_->find_attribute_store(name);
            if(store_ == nullptr) {
                store_ = new TypedAttributeStore<ST>(1,typeid(UT));
                manager_->bind_attribute_store(name,store_);
                existed_already_ = false;
            } else {
                geo_assert(can_bind_to(store_));
                existed_already_ = true;
            }
            register_me(store_);
        }
 
 
        bool bind_if_is_defined(
            AttributesManager& manager, const std::string& name
        ) {
            geo_assert(!is_bound());
            manager_ = &manager;
            store_ = manager_->find_attribute_store(name);
            if(store_ != nullptr) {
                geo_assert(can_bind_to(store_));
                register_me(store_);
                existed_already_ = true;
                return true;
            }
            existed_already_ = false;
            return false;
        }
 
        bool bind_if_is_compatible(
            AttributesManager& manager, const std::string& name
        ) {
            if( is_bound() ) {
                unbind();
            }
            store_ = manager.find_attribute_store(name);
            if(store_ != nullptr) {
                existed_already_ = true;
                if(!can_bind_to(store_)) {
                    store_ = nullptr;
                    return false;
                }
                manager_ = &manager;
                register_me(store_);
                return true;
            }
            existed_already_ = false;
            return false;
        }
 
        void create_vector_attribute(
            AttributesManager& manager,
            const std::string& name,
            index_t dimension
        ) {
            geo_assert(!is_bound());
            manager_ = &manager;
            geo_assert(manager_->find_attribute_store(name) == nullptr);
            store_ = new TypedAttributeStore<ST>(dimension,typeid(UT));
            manager_->bind_attribute_store(name,store_);
            register_me(store_);
        }
 
        void destroy() {
            geo_assert(is_bound());
            unregister_me(store_);
            manager_->delete_attribute_store(store_);
            store_ = nullptr;
            manager_ = nullptr;
        }
 
        void redim(index_t new_dim) {
            geo_assert(is_bound());
            store_->redim(new_dim);
        }
 
        ~AttributeBase() {
            if(is_bound()) {
                unbind();
            }
        }
 
 
        static bool is_defined(
            AttributesManager& manager, const std::string& name,
            index_t dim = 0
        ) {
            AttributeStore* store = manager.find_attribute_store(name);
            return (
                store != nullptr &&
                can_bind_to(store) &&
                ((dim == 0) || (store->dimension() == dim))
            );
        }
 
        index_t size() const {
            return size_;
        }
 
        void zero() {
            geo_debug_assert(is_bound());
            store_->zero();
        }
 
        bool can_get_vector() {
            return(
                dynamic_cast<TypedAttributeStore<ST>*>(store_) != nullptr
            );
        }
 
        vector<ST>& get_vector() {
            TypedAttributeStore<ST>* typed_store =
                dynamic_cast<TypedAttributeStore<ST>*>(store_);
            geo_assert(typed_store != nullptr);
            return typed_store->get_vector();
        }
 
        const vector<ST>& get_vector() const {
            TypedAttributeStore<ST>* typed_store =
                dynamic_cast<TypedAttributeStore<ST>*>(store_);
            geo_assert(typed_store != nullptr);
            return typed_store->get_vector();
        }
 
        AttributesManager* manager() const {
            return manager_;
        }
 
    protected:
 
        static bool can_bind_to(const AttributeStore* store) {
            return (
                store->elements_type_matches(typeid(UT).name()) ||
                store->elements_type_matches(typeid(ST).name())
            );
        }
 
    protected:
        AttributesManager* manager_;
        AttributeStore* store_;
        bool existed_already_;
    } ;
 
    /*********************************************************************/
 
    template <class T> class Attribute : public AttributeBase<T> {
    public:
        typedef AttributeBase<T> superclass;
 
        Attribute() : superclass() {
        }
 
        Attribute(AttributesManager& manager, const std::string& name) :
            superclass(manager, name) {
        }
 
        T& operator[](index_t i) {
            geo_debug_assert(superclass::is_bound());
            geo_debug_assert(i < superclass::nb_elements());
            return ((T*)(void*)superclass::base_addr_)[i];
        }
 
        const T& operator[](index_t i) const {
            geo_debug_assert(superclass::is_bound());
            geo_debug_assert(i < superclass::nb_elements());
            return ((const T*)(void*)superclass::base_addr_)[i];
        }
 
        void fill(const T& val) {
            geo_debug_assert(superclass::is_bound());
            for(index_t i=0; i<superclass::nb_elements(); ++i) {
                (*this)[i] = val;
            }
        }
 
        void copy(const Attribute<T>& rhs) {
            geo_assert(rhs.size() == superclass::size());
            geo_assert(rhs.dimension() == superclass::dimension());
            for(index_t i=0; i<superclass::nb_elements(); ++i) {
                (*this)[i] = rhs[i];
            }
        }
 
        T* data() {
            return (T*)AttributeStoreObserver::base_addr_;
        }
 
        const T* data() const {
            return (const T*)AttributeStoreObserver::base_addr_;
        }
 
 
    private:
        Attribute(const Attribute<T>& rhs) = delete;
        Attribute<T>& operator=(const Attribute<T>& rhs) = delete;
    };
 
    /*********************************************************************/
 
    template <> class Attribute<bool> :
        public AttributeBase<bool,Numeric::uint8> {
    public:
        typedef AttributeBase<bool,Numeric::uint8> superclass;
 
        Attribute() : superclass() {
        }
 
        Attribute(AttributesManager& manager, const std::string& name) :
            superclass(manager,name) {
        }
 
        class BoolAttributeAccessor;
 
        class ConstBoolAttributeAccessor {
        public:
            ConstBoolAttributeAccessor(
                const Attribute<bool>& attribute,
                index_t index
            ) :
                attribute_(&attribute),
                index_(index) {
            }
 
            operator bool() const {
                return (attribute_->element(index_) != 0);
            }
 
        private:
            const Attribute<bool>* attribute_;
            index_t index_;
 
            friend class BoolAttributeAccessor;
        };
 
        class BoolAttributeAccessor {
        public:
            BoolAttributeAccessor(
                Attribute<bool>& attribute,
                index_t index
            ) :
                attribute_(&attribute),
                index_(index) {
            }
 
            operator bool() const {
                return (attribute_->element(index_) != 0);
            }
 
            BoolAttributeAccessor(const BoolAttributeAccessor& rhs) {
                attribute_ = rhs.attribute_;
                index_ = rhs.index_;
            }
 
            BoolAttributeAccessor& operator=(bool x) {
                attribute_->element(index_) = Numeric::uint8(x);
                return *this;
            }
 
            BoolAttributeAccessor& operator=(
                const BoolAttributeAccessor& rhs
            ) {
                if(&rhs != this) {
                    attribute_->element(index_) =
                        rhs.attribute_->element(rhs.index_);
                }
                return *this;
            }
 
            BoolAttributeAccessor& operator=(
                const ConstBoolAttributeAccessor& rhs
            ) {
                attribute_->element(index_) =
                    rhs.attribute_->element(rhs.index_);
                return *this;
            }
 
        private:
            Attribute<bool>* attribute_;
            index_t index_;
        };
 
 
        BoolAttributeAccessor operator[](index_t i) {
            return BoolAttributeAccessor(*this,i);
        }
 
        ConstBoolAttributeAccessor operator[](index_t i) const {
            return ConstBoolAttributeAccessor(*this,i);
        }
 
        void fill(bool val) {
            for(index_t i=0; i<superclass::nb_elements(); ++i) {
                element(i) = Numeric::uint8(val);
            }
        }
 
        void copy(const Attribute<bool>& rhs) {
            geo_assert(rhs.size() == superclass::size());
            geo_assert(rhs.dimension() == superclass::dimension());
            for(index_t i=0; i<superclass::nb_elements(); ++i) {
                element(i) = rhs.element(i);
            }
        }
 
    protected:
 
        friend class BoolAttributeAccessor;
        friend class ConstBoolAttributeAccessor;
 
        Numeric::uint8& element(index_t i) {
            geo_debug_assert(i < superclass::nb_elements());
            return ((Numeric::uint8*)superclass::base_addr_)[i];
        }
 
        const Numeric::uint8& element(index_t i) const {
            geo_debug_assert(i < superclass::nb_elements());
            return ((const Numeric::uint8*)superclass::base_addr_)[i];
        }
 
    private:
        Attribute(const Attribute<bool>& rhs) = delete;
        Attribute<bool>& operator=(const Attribute<bool>& rhs) = delete;
    } ;
 
    /***********************************************************/
 
    class GEOGRAM_API ScalarAttributeAdapterBase :
        public AttributeStoreObserver {
 
    public:
        enum ElementType {
            ET_NONE=0,
            ET_UINT8=1,
            ET_INT8=2,
            ET_UINT32=3,
            ET_INT32=4,
            ET_FLOAT32=5,
            ET_FLOAT64=6,
            ET_VEC2=7,
            ET_VEC3=8
        };
 
 
        class Accessor {
        public:
            Accessor(
                ScalarAttributeAdapterBase& attribute,
                index_t index
            ) : attribute_(attribute), index_(index) {
            }
 
            operator double() const {
                return attribute_.get_element_as_double(index_);
            }
 
            void operator=(double x) {
                attribute_.set_element_as_double(index_, x);
            }
 
        private:
            ScalarAttributeAdapterBase& attribute_;
            index_t index_;
        };
 
        class ConstAccessor {
        public:
            ConstAccessor(
                const ScalarAttributeAdapterBase& attribute,
                index_t index
            ) : attribute_(attribute), index_(index) {
            }
 
            operator double() const {
                return attribute_.get_element_as_double(index_);
            }
 
        private:
            const ScalarAttributeAdapterBase& attribute_;
            index_t index_;
        };
 
        ScalarAttributeAdapterBase() :
            manager_(nullptr),
            store_(nullptr),
            element_type_(ET_NONE),
            element_index_(index_t(-1)) {
        }
 
        ScalarAttributeAdapterBase(
            const AttributesManager& manager, const std::string& name
        ) :
            manager_(nullptr),
            store_(nullptr) {
            bind_if_is_defined(manager, name);
        }
 
        bool is_bound() const {
            return (store_ != nullptr);
        }
 
        void unbind() {
            geo_assert(is_bound());
            unregister_me(const_cast<AttributeStore*>(store_));
            manager_ = nullptr;
            store_ = nullptr;
            element_type_ = ET_NONE;
            element_index_ = index_t(-1);
        }
 
        void bind_if_is_defined(
            const AttributesManager& manager, const std::string& name
        );
 
        ~ScalarAttributeAdapterBase() {
            if(is_bound()) {
                unbind();
            }
        }
 
        static bool is_defined(
            const AttributesManager& manager, const std::string& name
        );
 
        index_t size() const {
            return (store_ == nullptr) ? 0 : store_->size();
        }
 
        ElementType element_type() const {
            return element_type_;
        }
 
        index_t element_index() const {
            return element_index_;
        }
 
        const AttributeStore* attribute_store() const {
            return store_;
        }
 
 
        static bool can_be_bound_to(const AttributeStore* store) {
            return element_type(store) != ET_NONE;
        }
 
        static index_t nb_scalar_elements_per_item(const AttributeStore* store);
 
    protected:
        static std::string attribute_base_name(const std::string& name);
 
        static index_t attribute_element_index(const std::string& name);
 
        static ElementType element_type(const AttributeStore* store);
 
        double get_element_as_double(index_t i) const {
            double result = 0.0;
            switch(element_type()) {
            case ET_UINT8:
                result = double(get_element<Numeric::uint8>(i));
                break;
            case ET_INT8:
                result = double(get_element<Numeric::int8>(i));
                break;
            case ET_UINT32:
                result = double(get_element<Numeric::uint32>(i));
                break;
            case ET_INT32:
                result = double(get_element<Numeric::int32>(i));
                break;
            case ET_FLOAT32:
                result = double(get_element<Numeric::float32>(i));
                break;
            case ET_FLOAT64:
                result = double(get_element<Numeric::float64>(i));
                break;
            case ET_VEC2:
                result = double(get_element<Numeric::float64>(i,2));
                break;
            case ET_VEC3:
                result = double(get_element<Numeric::float64>(i,3));
                break;
            case ET_NONE:
                geo_assert_not_reached;
            }
            return result;
        }
 
        template <class T> T get_element(index_t i,index_t multiplier=1) const {
            geo_debug_assert(is_bound());
            geo_debug_assert(i < size());
            return static_cast<const T*>(store_->data())[
                (i * store_->dimension() * multiplier) +
                element_index_
            ];
        }
 
        double set_element_as_double(index_t i, double value) {
            double result = 0.0;
            switch(element_type()) {
            case ET_UINT8:
                set_element<Numeric::uint8>(Numeric::uint8(value), i);
                break;
            case ET_INT8:
                set_element<Numeric::int8>(Numeric::int8(value),i);
                break;
            case ET_UINT32:
                set_element<Numeric::uint32>(Numeric::uint32(value),i);
                break;
            case ET_INT32:
                set_element<Numeric::int32>(Numeric::int32(value),i);
                break;
            case ET_FLOAT32:
                set_element<Numeric::float32>(Numeric::float32(value),i);
                break;
            case ET_FLOAT64:
                set_element<Numeric::float64>(Numeric::float64(value),i);
                break;
            case ET_VEC2:
                set_element<Numeric::float64>(Numeric::float64(value),i,2);
                break;
            case ET_VEC3:
                set_element<Numeric::float64>(Numeric::float64(value),i,3);
                break;
            case ET_NONE:
                geo_assert_not_reached;
            }
            return result;
        }
 
        template <class T> void set_element(
            T value, index_t i, index_t multiplier=1
        ) const {
            geo_debug_assert(is_bound());
            geo_debug_assert(i < size());
            const_cast<T*>(static_cast<const T*>(store_->data()))[
                (i * store_->dimension() * multiplier) +
                element_index_
            ] = value;
        }
 
    protected:
        const AttributesManager* manager_;
        const AttributeStore* store_;
        ElementType element_type_;
        index_t element_index_;
    };
 
    /***********************************************************/
 
    class ReadOnlyScalarAttributeAdapter : public ScalarAttributeAdapterBase {
    public:
        ReadOnlyScalarAttributeAdapter() : ScalarAttributeAdapterBase() {
        }
 
        ReadOnlyScalarAttributeAdapter(
            const AttributesManager& manager, const std::string& name
        ) : ScalarAttributeAdapterBase(manager, name) {
        }
 
        double operator[](index_t i) {
            return get_element_as_double(i);
        }
    };
 
    /***********************************************************/
 
    class ReadWriteScalarAttributeAdapter : public ScalarAttributeAdapterBase {
    public:
        ReadWriteScalarAttributeAdapter() : ScalarAttributeAdapterBase() {
        }
 
        ReadWriteScalarAttributeAdapter(
            const AttributesManager& manager, const std::string& name
        ) : ScalarAttributeAdapterBase(manager, name) {
        }
 
        Accessor operator[](index_t i) {
            return Accessor(*this, i);
        }
 
        ConstAccessor operator[](index_t i) const {
            return ConstAccessor(*this, i);
        }
 
    protected:
    };
 
 
}
 
#endif