#include <iostream>
#include <memory>
#include <queue>
#include <boost/shared_ptr.hpp>
using namespace std;

template<bool COND, typename TrueType, typename FalseType>
struct IfThenElseT {
    using Type = TrueType;
};

template<typename TrueType, typename FalseType>
struct IfThenElseT<false, TrueType, FalseType> {
    using Type = FalseType;
};
template<bool COND, typename TrueType, typename FalseType>
using IfThenElse = typename IfThenElseT<COND, TrueType, FalseType>::Type;


template <typename Head, typename... Tail>
class LargestTypeT
{
    private:
        using First = Head;
        using Rest = typename LargestTypeT<Tail...>::Type;
    public:
        using Type = IfThenElse<(sizeof(First) >= sizeof(Rest)), First, Rest>;
};

template<typename _Type>
class LargestTypeT<_Type>
{
    public:
        using Type = _Type;
};
template<typename... Args>
using LargestType = typename LargestTypeT<Args ...>::Type;


template <typename T>
class ObjectCounter
{
    public:
        static unsigned int allocate_counter;
        static unsigned int object_counter;

        ~ObjectCounter(){
            std::cout << "object_counter =" << object_counter << "  allocated_mem counter " << allocate_counter << std::endl; 
        }
};

template<typename T>
unsigned int ObjectCounter<T>::allocate_counter = 0;

template<typename T>
unsigned int ObjectCounter<T>::object_counter = 0;


template <typename _PacketType, unsigned _PoolSize = 60>
class ObjectMemPool:ObjectCounter<ObjectMemPool<_PacketType>>
{
    public:
        typedef _PacketType* Pointer;

        ObjectMemPool():m_RingStart{0}, m_RingEnd{_PoolSize - 1}{
            for(int i = 0; i< _PoolSize; ++i){
                m_RingBuffer[i] = i;
            }
        }

        ObjectMemPool(const ObjectMemPool& ) = delete;

        template <typename _Type, typename ... Args>
            typename _Type::Pointer  Get(Args&&... args){
                void* __p;
                int index = 0;
                if(m_RingStart == m_RingEnd){
                    ++(this->allocate_counter);
                    ++(this->object_counter);
                    return typename _Type::Pointer(::new _Type(std::forward<Args>(args)...));
                }else{
                    index = m_RingBuffer[m_RingStart]; 
                    m_RingStart = (m_RingStart+1) % _PoolSize;
                    __p = (void*)(m_Pool + index);//m_MemQueue.front();
                    ::new(__p) _Type(std::forward<Args>(args)...);

                    ++(this->object_counter);
                    return  typename _Type::Pointer((_Type*)__p, [this, index]( _Type* p){
                            p->~_Type();
                            this->m_RingEnd = (this->m_RingEnd + 1) % _PoolSize;
                            this->m_RingBuffer[this->m_RingEnd] = index;
                            }
                            );
                }
            }

        ~ObjectMemPool(){
            ::operator delete(m_Pool);
        }


    private:
        int m_RingBuffer[_PoolSize]; 
        int m_RingStart;
        int m_RingEnd;
        Pointer m_Pool = static_cast<Pointer> (::operator new(_PoolSize*sizeof(_PacketType)));
};


struct T1{
    int dummy_1;
    int dummy_2;
    using Pointer = std::shared_ptr<T1>;

    T1(int _d1, int _d2):dummy_1(_d1), dummy_2(_d2){;}
    T1() = default;
};


struct T2{
    int dummy_1;
    int dummy_2;
    int dummy_3;
    using Pointer = boost::shared_ptr<T2>;

    T2(int _d1, int _d2, int _d3):dummy_1(_d1), dummy_2(_d2), dummy_3(_d3){;}
    T2() = default;
};

int main(){
    using MaxType = LargestType<T1, T2>;
    ObjectMemPool<MaxType, 3> pmp;

    {
        auto t1 = pmp.Get<T1>();
        auto t1_a = pmp.Get<T1>(100, 100);
        auto t2 = pmp.Get<T2>();
        auto t2_a = pmp.Get<T2>(100, 100, 100);
    }

    auto t1 = pmp.Get<T1>();
    auto t1_a = pmp.Get<T1>(100, 100);
    auto t2 = pmp.Get<T2>();
    auto t2_a = pmp.Get<T2>(100, 100, 100);

    return 0;
}