ParticlePool.h

Go to the documentation of this file.

/*
 * Copyright (C) 2022 The V-Gears Team
 *
 * This file is part of V-Gears
 *
 * V-Gears is free software: you can redistribute it and/or modify it under
 * terms of the GNU General Public License as published by the Free Software
 * Foundation, version 3.0 (GPLv3) of the License.
 *
 * V-Gears 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.
 */
 
#pragma once
 
#include <list>
 
template <typename T>
class ParticlePool{
 
    public:
 
        typedef std::list<T*> PoolList;
 
        // The 'typename' MUST be added, since T is not a fixed type
        typedef typename PoolList::iterator PoolIterator;
 
        ParticlePool(){};
 
        virtual ~ParticlePool(){};
 
        bool IsEmpty(){return released_.empty();};
 
        size_t GetSize(){return released_.size();};
 
        void ResetIterator(){pool_iterator_ = released_.begin();};
 
        T* GetFirst() {
            ResetIterator();
            if (End()) return NULL;
            T* t = *pool_iterator_;
            return t;
        };
 
        T* GetNext(){
            if (End()) return NULL;
            ++ pool_iterator_;
            if (End()) return NULL;
            T* t = *pool_iterator_;
            return t;
        };
 
        bool End(){
            return pool_iterator_ == released_.end();
        };
 
        void Clear(){
            locked_.clear();
            released_.clear();
        };
 
        void AddElement(T* element) {
            locked_.push_back(element);
        };
 
        T* ReleaseElement() {
            // Return with 0 if no elements left
            if (locked_.empty()) return 0;
 
            // Move element from locked elements to released elements and return it
            T* t = locked_.front();
            released_.splice(released_.end(), locked_, locked_.begin());
            return t;
        };
 
        void ReleaseAllElements(){
            // Move all elements from locked elements to released elements
            released_.splice(released_.end(), locked_);
            ResetIterator();
        };
 
        void LockLatestElement(){
            if (End() == false){
                locked_.push_back(*pool_iterator_);
                pool_iterator_ = released_.erase(pool_iterator_);
            }
        };
 
        void LockAllElements(){
            // Move all elements from released elements to locked elements
            locked_.splice(locked_.end(), released_);
            ResetIterator();
        };
 
        std::list<T*>& GetActiveElementsList(){
            return released_;
        };
 
    protected:
 
        PoolList released_;
 
        PoolList locked_;
 
        PoolIterator pool_iterator_;
};