brep-attribute-map.hpp

Go to the documentation of this file.

/*
 * Copyright (C) 2023  Christopher J. Howard
 *
 * This file is part of Antkeeper source code.
 *
 * Antkeeper source code is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * Antkeeper source code is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with Antkeeper source code.  If not, see <http://www.gnu.org/licenses/>.
 */
 
#ifndef ANTKEEPER_GEOM_BREP_ATTRIBUTE_MAP_HPP
#define ANTKEEPER_GEOM_BREP_ATTRIBUTE_MAP_HPP
 
#include <engine/geom/brep/brep-attribute.hpp>
#include <engine/utility/hash/fnv1a.hpp>
#include <iterator>
#include <memory>
#include <stdexcept>
#include <type_traits>
#include <unordered_map>
#include <utility>
 
namespace geom {
 
class brep_attribute_map
{
public:
    template <class Iter, bool Const>
    class iterator_template
    {
    public:
        using iterator_type = Iter;
        using iterator_category = std::bidirectional_iterator_tag;
        using iterator_concept = std::bidirectional_iterator_tag;
        using difference_type = std::iter_difference_t<Iter>;
        using value_type = brep_attribute_base;
        using pointer = std::conditional<Const, const value_type*, value_type*>::type;
        using reference = std::conditional<Const, const value_type&, value_type&>::type;
        
        [[nodiscard]] inline constexpr reference operator*() const noexcept
        {
            return *m_it->second;
        }
        
        [[nodiscard]] inline constexpr pointer operator->() const noexcept
        {
            return &(*m_it->second);
        }
        
        [[nodiscard]] inline constexpr reference operator[](difference_type i) const noexcept
        {
            return *(m_it[i]);
        }
        
        inline iterator_template& operator++() noexcept
        {
            ++m_it;
            return *this;
        }
        
        [[nodiscard]] inline iterator_template operator++(int) noexcept
        {
            iterator_template tmp = *this;
            ++(*this);
            return tmp;
        }
        
        inline iterator_template& operator--() noexcept
        {
            --m_it;
            return *this;
        }
        
        [[nodiscard]] inline iterator_template operator--(int) noexcept
        {
            iterator_template tmp = *this;
            --(*this);
            return tmp;
        }
        
        inline iterator_template& operator+=(difference_type n) noexcept
        {
            m_it += n;
            return *this;
        }
        
        inline iterator_template& operator-=(difference_type n) noexcept
        {
            m_it -= n;
            return *this;
        }
        
        [[nodiscard]] inline bool operator==(const iterator_template& other) const noexcept
        {
            return m_it == other.m_it;
        };
        
        [[nodiscard]] inline std::weak_ordering operator<=>(const iterator_template& other) const noexcept
        {
            return m_it <=> other.m_it;
        }
        
        [[nodiscard]] inline difference_type operator-(const iterator_template& rhs) const noexcept
        {
            return m_it - rhs.m_it;
        }
        
        [[nodiscard]] inline iterator_template operator+(difference_type n) const noexcept
        {
            return iterator_template{m_it + n};
        }
        
        [[nodiscard]] inline iterator_template operator-(difference_type n) const noexcept
        {
            return iterator_template{m_it - n};
        }
        
        [[nodiscard]] friend iterator_template operator+(difference_type lhs, const iterator_template& rhs) noexcept
        {
            return iterator_template{lhs + rhs.m_it};
        }
        
        [[nodiscard]] friend iterator_template operator-(difference_type lhs, const iterator_template& rhs) noexcept
        {
            return iterator_template{lhs - rhs.m_it};
        }
        
    private:
        friend class brep_attribute_map;
        
        iterator_type m_it;
    };
    
    using iterator = iterator_template<std::unordered_map<hash::fnv1a32_t, std::unique_ptr<brep_attribute_base>>::iterator, false>;
    using const_iterator = iterator_template<std::unordered_map<hash::fnv1a32_t, std::unique_ptr<brep_attribute_base>>::const_iterator, true>;
    
    
    [[nodiscard]] inline const_iterator begin() const noexcept
    {
        const_iterator it;
        it.m_it = m_attributes.begin();
        return it;
    }
    [[nodiscard]] inline iterator begin() noexcept
    {
        iterator it;
        it.m_it = m_attributes.begin();
        return it;
    }
    [[nodiscard]] inline const_iterator cbegin() const noexcept
    {
        return begin();
    }
    
    [[nodiscard]] inline const_iterator end() const noexcept
    {
        const_iterator it;
        it.m_it = m_attributes.end();
        return it;
    }
    [[nodiscard]] inline iterator end() noexcept
    {
        iterator it;
        it.m_it = m_attributes.end();
        return it;
    }
    [[nodiscard]] inline const_iterator cend() const noexcept
    {
        return end();
    }
    
    
    [[nodiscard]] inline bool empty() const noexcept
    {
        return m_attributes.empty();
    }
    
    [[nodiscard]] inline std::size_t size() const noexcept
    {
        return m_attributes.size();
    }
    
    
    inline void clear() noexcept
    {
        m_attributes.clear();
    }
    
    template <class T>
    iterator emplace(hash::fnv1a32_t name)
    {
        if (auto i = m_attributes.find(name); i != m_attributes.end())
        {
            i->second.reset();
            i->second = std::make_unique<brep_attribute<T>>(name, m_element_count);
            
            iterator it;
            it.m_it = i;
            return it;
        }
        
        iterator it;
        it.m_it = m_attributes.emplace(name, std::make_unique<brep_attribute<T>>(name, m_element_count)).first;
        return it;
    }
    
    inline iterator erase(iterator pos)
    {
        iterator it;
        it.m_it = m_attributes.erase(pos.m_it);
        return it;
    }
    
    inline std::size_t erase(hash::fnv1a32_t name)
    {
        return m_attributes.erase(name);
    }
    
    template <class T>
    std::pair<iterator, bool> try_emplace(hash::fnv1a32_t name)
    {
        if (auto i = m_attributes.find(name); i != m_attributes.end())
        {
            iterator it;
            it.m_it = i;
            return {it, false};
        }
        
        auto pair = m_attributes.emplace(name, std::make_unique<brep_attribute<T>>(name, m_element_count));
        iterator it;
        it.m_it = pair.first;
        return {it, pair.second};
    }
    
    
    template <class T>
    [[nodiscard]] const brep_attribute<T>& at(hash::fnv1a32_t name) const
    {
        auto it = find(name);
        if (it == end())
        {
            throw std::out_of_range("B-rep attribute not found");
        }
        
        return static_cast<const brep_attribute<T>&>(*it);
    }
    template <class T>
    [[nodiscard]] brep_attribute<T>& at(hash::fnv1a32_t name)
    {
        auto it = find(name);
        if (it == end())
        {
            throw std::out_of_range("B-rep attribute not found");
        }
        
        return static_cast<brep_attribute<T>&>(*it);
    }
    
    [[nodiscard]] inline const_iterator find(hash::fnv1a32_t name) const
    {
        const_iterator it;
        it.m_it = m_attributes.find(name);
        return it;
    }
    [[nodiscard]] inline iterator find(hash::fnv1a32_t name)
    {
        iterator it;
        it.m_it = m_attributes.find(name);
        return it;
    }
    
    [[nodiscard]] inline bool contains(hash::fnv1a32_t name) const
    {
        return m_attributes.contains(name);
    }
    
    
private:
    template <class T>
    friend class brep_element_container;
    friend class brep_mesh;
    
    brep_attribute_map& operator=(const brep_attribute_map& other)
    {
        m_element_count = other.m_element_count;
        m_attributes.clear();
        for (const auto& [key, value]: other.m_attributes)
        {
            m_attributes.emplace(key, value->clone());
        }
        
        return *this;
    }
    
    std::size_t m_element_count{};
    std::unordered_map<hash::fnv1a32_t, std::unique_ptr<brep_attribute_base>> m_attributes;
};
 
} // namespace geom
 
#endif // ANTKEEPER_GEOM_BREP_ATTRIBUTE_MAP_HPP