ParticlePoolMap.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
 
template <typename T>
class ParticlePoolMap{
 
    public:
 
        typedef std::multimap<Ogre::String, T*> PoolMapMap;
 
        // The 'typename' MUST be added, since T is not a fixed type.
        typedef typename PoolMapMap::iterator PoolMapIterator;
 
        ParticlePoolMap(){};
 
        virtual ~ParticlePoolMap(){};
 
        bool IsEmpty(){return released_.empty();};
 
        size_t GetSize(){return released_.size();};
 
        void ResetIterator(){pool_map_iterator_ = released_.begin();};
 
        T* GetFirst(){
            ResetIterator();
            if (End()) return NULL;
            T* t = pool_map_iterator_->second;
            return t;
        };
 
        T* GetNext(){
            if (End()) return NULL;
            ++ pool_map_iterator_;
            if (End()) return NULL;
            T* t = pool_map_iterator_->second;
            return t;
        };
 
        bool End(){return pool_map_iterator_ == released_.end();};
 
        void Clear(){
            locked_.clear();
            released_.clear();
        };
 
        void AddElement(const Ogre::String& key, T* element){
            locked_.insert(make_pair(key, element));
        };
 
        T* ReleaseElement(const Ogre::String& key){
            // Return with 0 if no elements left
            if (locked_.empty()) return NULL;
 
            // Return the first element that is encountered
            T* t = 0;
            PoolMapIterator it;
            it = locked_.find(key);
            if (it != locked_.end()){
                // Get the element and move it to the released elements list
                t = it->second;
                released_.insert(make_pair(key, t));
                locked_.erase(it);
            }
            return t;
        };
 
        void ReleaseAllElements(){
            // Move all elements from locked elements to released elements
            PoolMapIterator it;
            for (it = locked_.begin(); it != locked_.end(); ++ it)
                released_.insert(make_pair(it->first, it->second));
            locked_.clear();
            ResetIterator();
        };
 
        void LockLatestElement(){
            // Move element pointed by iterator from released elements to
            // locked elements
            locked_.insert(
              make_pair(pool_map_iterator_->first, pool_map_iterator_->second)
            );
            // Watch the ++ at the end to set mPoolMapIterator to the next
            // element
            released_.erase(pool_map_iterator_ ++);
        };
 
        void LockAllElements() {
            // Move all elements from release elements to locked elements
            PoolMapIterator it;
            for (it = released_.begin(); it != released_.end(); ++ it)
                locked_.insert(make_pair(it->first, it->second));
            released_.clear();
            ResetIterator();
        };
 
    protected:
        PoolMapMap released_;
 
        PoolMapMap locked_;
 
         PoolMapIterator pool_map_iterator_;
};