Core_Utilities.hpp

#pragma once
#ifndef KJY_OBJECT_ORIENTED_OPENGL_CORE_UTILITIES_HPP_
#define KJY_OBJECT_ORIENTED_OPENGL_CORE_UTILITIES_HPP_
#include <map>
#include <vector>
#include <optional>
#include <type_traits>
#include "OOOGL_Core.hpp"

namespace OOOGL {


/* ------- Possessor Utilities ------- */

template<class... Possessibles> class AbstractGenericPossessor{
 protected:
    std::map<GLuint, ConstPersistentOglName> possessed_items;
};

template<class P, class... Possessibles>
class AbstractGenericPossessor<P, Possessibles...> : public OglPossessorInterface<P>,  public AbstractGenericPossessor<Possessibles...>{
    typedef std::pair<GLuint, ConstPersistentOglName> item_pair_t;
 public:
    virtual size_t numPossessed() const {return(AbstractGenericPossessor::possessed_items.size());}
    virtual void possessObject(P possessible_object) override{
        AbstractGenericPossessor::possessed_items.emplace(item_pair_t(possessible_object.getNameDirect(), possessible_object));
    }
    virtual bool doesPossessObject(P possessible_object) const override{
        return(AbstractGenericPossessor::possessed_items.find(possessible_object.getNameDirect()) == AbstractGenericPossessor::possessed_items.end());
    }
    virtual void dispossessObject(const P& possessible_object) override{
        if(doesPossessObject(possessible_object)){
            AbstractGenericPossessor::possessed_items.erase(possessible_object.getNameDirect());
        }
    }
};


class GenericPossessor
    : public OglPossessorInterface<PersistentOglName, ConstPersistentOglName, OglObject>
{
   public:
    virtual void possessObject(PersistentOglName object) override;
    virtual void possessObject(ConstPersistentOglName object) override;
    virtual void possessObject(OglObject object) override;

    virtual bool doesPossessObject(PersistentOglName object) const override;
    virtual bool doesPossessObject(ConstPersistentOglName object) const override;
    virtual bool doesPossessObject(OglObject object) const override;

    virtual void dispossessObject(const PersistentOglName& object) override;
    virtual void dispossessObject(const ConstPersistentOglName& object) override;
    virtual void dispossessObject(const OglObject& object) override;

   protected:
    std::map<GLuint, ConstPersistentOglName> possessed_items;
};

/* ------- My own specialized optional container for OpenGL objects */ 

template<class T>
class OptionalGlObject {
 public:

    struct EmptyOptionalException : public std::exception{
        virtual const char* what() const noexcept override{
            return("Optional OpenGL object does not contain a value");
        }
    };

    OptionalGlObject() : _encapsulated_object_(_zombie_name) {}
    OptionalGlObject(const T& t) : _encapsulated_object_(t) {}
    template<typename... Args> OptionalGlObject(Args&&... args) : _encapsulated_object_(args...) {}

    void reset() {_encapsulated_object_ = T(_zombie_name);}
    bool has_value() const {return(_has_value_());}
    T& value() & {_assert_has_value(); return(_encapsulated_object_);}
    const T& value() const& {_assert_has_value(); return(_encapsulated_object_);}
    // T&& value() && {_assert_has_value(); return(_encapsulated_object_);}
    // const T&& value() const&& {_assert_has_value(); return(_encapsulated_object_);}

    template<typename... Args> void emplace(Args&&... args) {_encapsulated_object_ = T(args...);}

    OptionalGlObject& operator=(const std::nullopt_t nullopt){_encapsulated_object_ = T(_zombie_name);}
    const T* operator->() const {_assert_has_value(); return(&_encapsulated_object_);}
    T* operator->() {_assert_has_value(); return(&_encapsulated_object_);}
    const T& operator*() const& {_assert_has_value(); return(_encapsulated_object_);}
    T& operator*() & {_assert_has_value(); return(_encapsulated_object_);}
    // const T&& operator*() const&& {_assert_has_value(); return(_encapsulated_object_);}
    // T&& operator*() && {_assert_has_value(); return(_encapsulated_object_);}
    operator bool() const {return(_has_value_());}

 private:
    inline bool _has_value_() const {return(!_encapsulated_object_.isZombie());}
    inline void _assert_has_value() const {if(!_has_value_()) throw EmptyOptionalException();}
    T _encapsulated_object_;
};



/* ------- Indexed Binding Vector ------- AKA: Home of the least readable code I've ever written */

class IndexBindingInvalidIndexException : public BaseGraphicsException{
    public:
        IndexBindingInvalidIndexException(GLuint index) : _whatstr("Invalid index in access of IndexBindingVector: '" + std::to_string(index) + "'") {}
        virtual const char* what() const noexcept override{return(_whatstr.c_str());}
    private:
        const std::string _whatstr;
};
class UnoccupiedIndexException : public BaseGraphicsException{
    public:
        UnoccupiedIndexException(GLuint index) : _whatstr("Attempted to extract reference from unoccupied index in IndexBindingVector: '" + std::to_string(index) + "'") {}
        virtual const char* what() const noexcept override{return(_whatstr.c_str());}
    private:
        const std::string _whatstr;
};

template<class BoundType, class IteratorBundle, typename SizeType = size_t, class Allocator = std::allocator<BoundType>>
class IndexBindingVectorInferface{
 public:
    using iterator = typename IteratorBundle::iterator;
    using const_iterator = typename IteratorBundle::const_iterator;
    using size_type = SizeType;
    using allocator_type = Allocator;

    bool isOccupied(size_type pos) const = delete;
    iterator begin() = delete;
    const_iterator begin() const = delete;
    BoundType& at(size_type pos) = delete;
    const BoundType& at(size_type pos) const = delete;
    size_type size() const = delete;
    void set(size_type pos, const BoundType& value) = delete;
    void clear() = delete;
    void clearIndex(size_type pos) = delete;
    iterator erase(iterator pos) = delete;
    const_iterator erase(const_iterator pos) = delete;
};

template<typename internal_iterator, template<typename _internal_iterator> class OccupationChecker, typename index_type = GLuint>
struct AbstractIndexedBindingIterator{
    template<typename B, typename IB, typename ST, typename A>
    friend class IndexBindingVectorInferface;
    static_assert(std::is_trivially_constructible<OccupationChecker<internal_iterator>>::value, "Occupation checker must be trivially constructable");
    static_assert(std::is_invocable<OccupationChecker<internal_iterator>, internal_iterator>::value, "Occupation checker must be a callable bool function taking <internal_iterator> as its only parameter");
    using reference = std::nullptr_t /*error_t* no error_t on some compilers*/ ; // Intended to be overwritten by derived class
    using pointer = std::nullptr_t /*error_t* no error_t on some compilers*/ ; // Intended to be overwritten by derived class

    AbstractIndexedBindingIterator(const internal_iterator& start, const internal_iterator& end) : _internal(start), _end(end) {}
    reference operator*() const = delete;
    pointer operator->() const = delete;
    AbstractIndexedBindingIterator& operator++(){
        if(_internal == _end) return(*this);
        do{
            index++;
            std::advance(_internal,1);
        }while(_internal != _end && !_is_occupied(_internal));
        return(*this);
    }
    AbstractIndexedBindingIterator operator++(int) {const auto tmp(*this); ++*this; return(tmp);}
    bool equal(AbstractIndexedBindingIterator const& rhs) const {return(_internal == rhs._internal);}
    bool operator==(const AbstractIndexedBindingIterator& other) const {return(equal(other));}
    bool operator!=(const AbstractIndexedBindingIterator& other) const {return(!equal(other));}
    index_type getIndex() const {return(index);}
 protected:
    index_type index = 0;
    internal_iterator _internal;
    internal_iterator _end;
    const OccupationChecker<internal_iterator> _is_occupied;
};

template<typename iterator>
struct IndexedPointersOccupationChecker{ IndexedPointersOccupationChecker() = default; bool operator()(iterator itr) const {return(bool(*itr));} };

template<class BoundType, typename internal_iterator, template<typename _internal_iterator> class OccupationChecker>
struct IndexedPointersBindingIteratorTemplate : public AbstractIndexedBindingIterator<internal_iterator, OccupationChecker>
{
    using Abstract_Parent = AbstractIndexedBindingIterator<internal_iterator, OccupationChecker>;
    using reference = std::pair<GLuint, BoundType&>;
    using pointer = BoundType*;
    IndexedPointersBindingIteratorTemplate(const internal_iterator& start, const internal_iterator& end) : Abstract_Parent(start, end) {}
    IndexedPointersBindingIteratorTemplate(const Abstract_Parent& abstract) : Abstract_Parent(abstract) {}
    reference operator*() const{
        return(std::pair<GLuint, BoundType&>(Abstract_Parent::index, **Abstract_Parent::_internal));
    }
    pointer operator->() const{
        return(&**Abstract_Parent::_internal);
    }
};

template<class BoundType>
struct IndexedPointersIteratorBundle{
    using iterator = IndexedPointersBindingIteratorTemplate 
        // < BoundType, internal iterator, callable object to check if index is occupied >
        <BoundType, typename std::vector<BoundType*>::iterator, IndexedPointersOccupationChecker>
    ;
    using const_iterator = IndexedPointersBindingIteratorTemplate 
        // < BoundType, internal iterator, callable object to check if index is occupied >
        <BoundType, typename std::vector<BoundType*>::const_iterator, IndexedPointersOccupationChecker>
    ;
};

template<class BoundType>
class IndexedPointersVector : public IndexBindingVectorInferface<BoundType, IndexedPointersIteratorBundle<BoundType>>, protected std::vector<BoundType*>{
 public:
    typedef std::vector<BoundType*> base_vector;
    using internal_iterator = typename std::vector<BoundType*>::iterator;
    using const_internal_iterator =typename  std::vector<BoundType*>::const_iterator;
    using iterator = typename IndexBindingVectorInferface<BoundType, IndexedPointersIteratorBundle<BoundType>>::iterator;
    using const_iterator = typename IndexBindingVectorInferface<BoundType, IndexedPointersIteratorBundle<BoundType>>::const_iterator;
    using reference = typename const_iterator::reference;
    using const_reference = typename const_iterator::reference;
    using size_type = typename std::vector<BoundType*>::size_type;
    using allocator_type = typename std::vector<BoundType*>::allocator_type; 

 public:
    IndexedPointersVector() : base_vector() {}
    IndexedPointersVector(size_type count, BoundType* value, const allocator_type& alloc = allocator_type()) : base_vector(count, value, alloc) {}
    ~IndexedPointersVector() {
        for(const_internal_iterator itr = base_vector::begin(); itr != base_vector::end(); itr++){
            if(*itr!=nullptr) delete *itr;
        }
    }

    iterator begin() {return(IndexedPointersVector<BoundType>::iterator(base_vector::begin(), base_vector::end()));}
    const_iterator begin() const {return(IndexedPointersVector<BoundType>::const_iterator(base_vector::begin(), base_vector::end()));}
    iterator end() {return(IndexedPointersVector<BoundType>::iterator(base_vector::end(), base_vector::end()));}
    const_iterator end() const {return(IndexedPointersVector<BoundType>::const_iterator(base_vector::end(), base_vector::end()));}
    internal_iterator beginInternal() {return(base_vector::begin());}
    const_internal_iterator beginInternal() const {return(base_vector::begin());}
    internal_iterator endInternal() {return(base_vector::end());}
    const_internal_iterator endInternal() const {return(base_vector::end());}

    inline bool isOccupied(size_type pos) const {return(pos >= 0 && pos < base_vector::size() && base_vector::at(pos) != nullptr);}

    BoundType& at(size_type pos) {_assert_occupied_index(pos); return(*base_vector::at(pos));}
    const BoundType& at(size_type pos) const {_assert_occupied_index(pos); return(*base_vector::at(pos));}
    inline BoundType& operator[](size_type pos) {return(at(pos));}
    inline const BoundType& operator[](size_type pos) const {return(at(pos));}
    size_type size() const {return(_occupied_count);}
    using base_vector::capacity;
    
    void set(size_type pos, const BoundType& value) {
        _assert_valid_index(pos);
        if(isOccupied(pos)){
            delete base_vector::at(pos);
        }else{
            _occupied_count++;
        }
        base_vector::at(pos) = new BoundType(value);
    }
    void clearIndex(size_type pos) {
        _assert_valid_index(pos);
        const BoundType* ptr_at_index = base_vector::at(pos);
        if(ptr_at_index != nullptr){
            delete ptr_at_index;
            base_vector::at(pos) = nullptr;
            _occupied_count--;
        }
    }
    void clear(){
        for(internal_iterator itr = base_vector::begin(); itr != base_vector::end(); itr++){
            if(*itr != nullptr) delete (*itr);
        }
        _occupied_count = 0;
    }
    iterator erase(iterator pos){
        if(pos == end()) return(end());
            clearIndex(pos.getIndex());
        return(++pos);
    }
    const_iterator erase(const_iterator pos){
        if(pos == end()) return(end());
            clearIndex(pos.getIndex());
        return(++pos);
    }

 private:
    size_t _occupied_count = 0;
    void _assert_valid_index(size_type index){if(index < 0 || index >= base_vector::size()) throw IndexBindingInvalidIndexException(index);}
    void _assert_occupied_index(size_type index){_assert_valid_index(index); if(!isOccupied(index)) throw UnoccupiedIndexException(index);}
};

template<typename iterator>
struct OptionalOccupationChecker{OptionalOccupationChecker() = default; bool operator()(iterator itr) const {return(*itr);}};

template<class BoundType>
struct OptionalIteratorBundle{
    using iterator = IndexedPointersBindingIteratorTemplate 
        // < BoundType, internal iterator, callable object to check if index is occupied >
        <BoundType, typename std::vector<std::optional<BoundType>>::iterator, IndexedPointersOccupationChecker>
    ;
    using const_iterator = IndexedPointersBindingIteratorTemplate 
        // < BoundType, internal iterator, callable object to check if index is occupied >
        <BoundType, typename std::vector<std::optional<BoundType>>::const_iterator, IndexedPointersOccupationChecker>
    ;
};

template<class BoundType>
class OptionalIndexedBindingVector : public IndexBindingVectorInferface<BoundType, OptionalIteratorBundle<BoundType>>, protected std::vector<std::optional<BoundType>>{
 public:
    typedef std::vector<std::optional<BoundType>> base_vector;
    using internal_iterator = typename base_vector::iterator;
    using const_internal_iterator =typename  base_vector::const_iterator;
    using iterator = typename IndexBindingVectorInferface<BoundType, OptionalIteratorBundle<BoundType>>::iterator;
    using const_iterator = typename IndexBindingVectorInferface<BoundType, OptionalIteratorBundle<BoundType>>::const_iterator;
    using reference = typename const_iterator::reference;
    using const_reference = typename const_iterator::reference;
    using size_type = typename base_vector::size_type;
    using allocator_type = typename base_vector::allocator_type; 

 public:
    OptionalIndexedBindingVector() : base_vector() {}
    OptionalIndexedBindingVector(size_type count, const std::optional<BoundType>& value, const allocator_type& alloc = allocator_type()) : base_vector(count, value, alloc) {}
    OptionalIndexedBindingVector(size_type count) : OptionalIndexedBindingVector(count, std::optional<BoundType>()) {}

    iterator begin() {return(OptionalIndexedBindingVector<BoundType>::iterator(base_vector::begin(), base_vector::end()));}
    const_iterator begin() const {return(OptionalIndexedBindingVector<BoundType>::const_iterator(base_vector::begin(), base_vector::end()));}
    iterator end() {return(OptionalIndexedBindingVector<BoundType>::iterator(base_vector::end(), base_vector::end()));}
    const_iterator end() const {return(OptionalIndexedBindingVector<BoundType>::const_iterator(base_vector::end(), base_vector::end()));}
    internal_iterator beginInternal() {return(base_vector::begin());}
    const_internal_iterator beginInternal() const {return(base_vector::begin());}
    internal_iterator endInternal() {return(base_vector::end());}
    const_internal_iterator endInternal() const {return(base_vector::end());}

    inline bool isOccupied(size_type pos) const {return(pos >= 0 && pos < base_vector::size() && base_vector::at(pos));}

    BoundType& at(size_type pos) {_assert_occupied_index(pos); return(*base_vector::at(pos));}
    const BoundType& at(size_type pos) const {_assert_occupied_index(pos); return(*base_vector::at(pos));}
    inline BoundType& operator[](size_type pos) {return(at(pos));}
    inline const BoundType& operator[](size_type pos) const {return(at(pos));}
    size_type size() const {return(_occupied_count);}
    using base_vector::capacity;
    
    void set(size_type pos, const BoundType& value) {
        _assert_valid_index(pos);
        if(!isOccupied(pos)){
            _occupied_count++;
        }
        base_vector::at(pos) = std::optional<BoundType>(value);
    }
    void clearIndex(size_type pos) {
        _assert_valid_index(pos);
        if(base_vector::at(pos)){
            base_vector::at(pos) = std::optional<BoundType>();
            _occupied_count--;
        }
    }
    void clear(){
        for(internal_iterator itr = base_vector::begin(); itr != base_vector::end(); itr++){
            *itr = std::optional<BoundType>();
        }
        _occupied_count = 0;
    }
    iterator erase(iterator pos){
        if(pos == end()) return(end());
            clearIndex(pos.getIndex());
        return(++pos);
    }
    const_iterator erase(const_iterator pos){
        if(pos == end()) return(end());
            clearIndex(pos.getIndex());
        return(++pos);
    }

 private:
    size_t _occupied_count = 0;
    void _assert_valid_index(size_type index) const {if(index < 0 || index >= base_vector::size()) throw IndexBindingInvalidIndexException(index);}
    void _assert_occupied_index(size_type index) const {_assert_valid_index(index); if(!isOccupied(index)) throw UnoccupiedIndexException(index);}
};

}  // namespace OOOGL

#endif