SharedResourcePool.hpp

/*
 *
 */
 
 
#ifndef H_POTTU_SHAREDRESOURCEPOOL
#define H_POTTU_SHAREDRESOURCEPOOL
 
 
#include "memory.hpp"
 
#include <vector>
 
namespace pottu {
 
    template <class Pool>
    struct PooledResourceDeleter {
    
    PooledResourceDeleter() = default;
    PooledResourceDeleter( Pool *pool ) : _pool(pool) {}
    void operator()( typename Pool::resource_t *e ) {
        if( _pool )
        _pool->_returnToPool( e );
        //else
        //  Pool::_releaseResourceNoPool( e );
    }
    Pool *_pool{nullptr};
    };
    
    
    template <class Ev>
    class SharedResourcePool {
    public:
    
    using resource_t = Ev;
    using resource_deleter_t = PooledResourceDeleter< SharedResourcePool<Ev> >;
    using logical_event_handle_t = SharedResourceHandle<Ev, resource_deleter_t>;
 
    
    SharedResourcePool()
        {}
 
    
    ~SharedResourcePool() {
        for( auto &ev : _pool )
        delete ev;
    }
 
 
    SharedResourcePool( const SharedResourcePool &o ) = delete;
    SharedResourcePool( SharedResourcePool &&o ) = delete;
 
 
 
    
    /*****************************************************/
    // Returns a new or recycled logical event. This speeds up since
    // less memory allocations needed.
    /*****************************************************/
    std::vector<Ev *> _pool;
    size_t _eventsAllocated{0};
    size_t _eventsGiven{0};
    size_t _eventsReturned{0};
    logical_event_handle_t get() noexcept {
        ++_eventsGiven;
        if( _pool.size() ) {
        Ev *e{ _pool.back() };
        _pool.pop_back();
        return logical_event_handle_t{ e, resource_deleter_t(this) };
        } else {
        ++_eventsAllocated;
        auto p = new Ev;
        p->clear();
        return logical_event_handle_t{ p, resource_deleter_t(this) };
        }
    }
 
    private:
    friend resource_deleter_t;
    /*****************************************************/
    // Puts back the logical event into the pool for next use.
    /*****************************************************/
    void _returnToPool( Ev *e ) noexcept {
        //ContextBase::logInfo( "_returnToPool" );
        ++_eventsReturned;
        e->clear();
        _pool.push_back( e );
    }
 
    static void _releaseResourceNoPool( Ev *e ) noexcept {
        delete e;
    }
    
    };
    
}
 
 
#endif