Collection.h

// Copyright (c) 2013 - 2019 Marc-Michael Horstmann;
// Copyright (c) 2020 - 2024 Trend Verlag;
//
//  trax track library
//  AD 2016
//
//  "If I don't go crazy, I'll loose my mind"
//
//                              Death In Vegas
 
#pragma once
 
#include "ObjectIDDecorator.h"
 
#include <map>
 
namespace trax{
 
    template<class Collection_Type,class Value_Type>
    struct Collection{

        using collection_type = Collection_Type;
        using value_type = Value_Type;
 
 
        template<typename _value_type, typename _std_iterator_type>
        class iterator_imp{
        public:
            using iterator_category = std::bidirectional_iterator_tag;
            using value_type = _value_type;
            using difference_type = int;
            using distance_type = int;
            using pointer = std::shared_ptr<_value_type>;
            using reference = _value_type&;
 
 
            inline iterator_imp( const _std_iterator_type& iter ) noexcept
                : m_Current{iter}
            {}
 

            inline bool operator==( const iterator_imp& iter ) const noexcept{
                return m_Current == iter.m_Current;
            }
 
            inline bool operator!=( const iterator_imp& iter ) const noexcept{
                return m_Current != iter.m_Current;
            }
 
            inline iterator_imp& operator++() noexcept{
                ++m_Current;
                return *this;
            }
 
            inline iterator_imp operator++(int) noexcept{
                iterator_imp retval( *this );
                ++m_Current;
                return retval;
            }
 
            inline iterator_imp& operator--() noexcept{     
                --m_Current;
                return *this;
            }
 
            inline iterator_imp operator--(int) noexcept{
                iterator_imp retval( *this );
                --m_Current;
                return retval;
            }
 
            inline reference operator*() const noexcept{
                return *m_Current->second;
            }
 
            inline pointer operator->() const noexcept{
                return m_Current->second;
            }
        private:
            _std_iterator_type m_Current;
        };
 
        using iterator = iterator_imp<value_type,typename std::map<IDType,std::shared_ptr<value_type>>::const_iterator>;
 
        using const_iterator = iterator_imp<const value_type,typename std::map<IDType,std::shared_ptr<value_type>>::const_iterator>;
 

        virtual const char* TypeName() const noexcept = 0;
 

        virtual bool IsValid() const noexcept = 0;
 

        virtual IDType Add( std::shared_ptr<Value_Type> pValue_Type ) = 0;
 

        virtual IDType AddRelaxed( std::shared_ptr<Value_Type> pTraxType ) = 0;
 

        virtual bool Remove( Value_Type* pValue_Type, bool zeroIDs = false ) = 0;
 

        virtual int Take( Collection_Type& collection_Type ) = 0;
 

        virtual void Clear() = 0;
 

        virtual int Count() const = 0;
 

        virtual iterator begin() = 0;
 

        virtual const_iterator begin() const = 0;
        
        virtual const_iterator cbegin() const = 0;
 

        virtual iterator end() = 0;
 

        virtual const_iterator end() const = 0;
 
        virtual const_iterator cend() const = 0;
 

        virtual std::shared_ptr<Value_Type> GetFirst() const = 0;
 

        virtual std::shared_ptr<Value_Type> GetNext( const std::shared_ptr<Value_Type>& pValue_Type ) const = 0;
 

        virtual std::shared_ptr<Value_Type> GetLast() const = 0;
 

        virtual std::shared_ptr<Value_Type> GetPrevious( const std::shared_ptr<Value_Type>& pValue_Type ) const = 0;
 

        virtual std::shared_ptr<Value_Type> Get( IDType id ) const = 0;
 
        virtual std::shared_ptr<Value_Type> Get( const std::string& name ) const = 0;
 

        virtual void PushActive( IDType id ) = 0;
 

        virtual void PopActive() = 0;
 

        virtual std::shared_ptr<Value_Type> GetActive() const = 0;
 

        virtual bool IsMember( const value_type& item ) const = 0;
 
        virtual bool IsMember( IDType id ) const = 0;
 

        virtual void ShiftIDs( int offset ) = 0;
 

        virtual IDType MaxID() const = 0;
 

        virtual IDType MinID() const = 0;
 
 
        virtual ~Collection() = default;
        Collection( const Collection& ) = delete;
        Collection( Collection&& ) = delete;
        Collection& operator=( const Collection& ) = delete;
        Collection& operator=( Collection&& ) = delete;
    protected:
        Collection() = default;
 
        friend Decorator<Collection_Type>;
        virtual void SetDecorator( Collection_Type* pCollection_TypeDecorator ) = 0;
    };
 
}