pool.h

Go to the documentation of this file.

 
 
 
// Copyright (C) 1997-2020 by Pawel Pilarczyk.
//
// This file is part of my research software package. This is free software:
// you can redistribute it and/or modify it under the terms of the GNU
// General Public License as published by the Free Software Foundation,
// either version 3 of the License, or (at your option) any later version.
//
// This software 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.
//
// You should have received a copy of the GNU General Public License
// along with this software; see the file "license.txt". If not,
// please, see <https://www.gnu.org/licenses/>.
 
// Started on August 13, 2007. Last revision: August 13, 2007.
 
 
#ifndef _CHOMP_STRUCT_POOL_H_
#define _CHOMP_STRUCT_POOL_H_
 
 
#include <chomp/struct/multitab.h>
 
 
namespace chomp {
namespace homology {
 
 
// --------------------------------------------------
// ---------------------- POOL ----------------------
// --------------------------------------------------
 
template <class element>
class pool
{
public:
        pool ();
 
        ~pool ();
 
        int get ();
 
        element &operator [] (int number);
 
        void release (int number);
 
private:
        pool (const pool<element> &);
 
        pool<element> &operator = (const pool<element> &);
 
        multitable<element> elem;
 
        int elemCount;
 
        multitable<int> unused;
 
        int unusedCount;
 
}; /* class pool */
 
// --------------------------------------------------
 
template <class element>
inline pool<element>::pool (): elemCount (0), unusedCount (0)
{
        return;
} /* pool::pool */
 
template <class element>
inline pool<element>::~pool ()
{
        return;
} /* pool::~pool */
 
template <class element>
inline pool<element>::pool (const pool<element> &)
{
        throw "Copy constructor for a pool not implemented.";
        return;
} /* pool::pool */
 
template <class element>
inline pool<element> &pool<element>::operator = (const pool<element> &)
{
        throw "Assignment operator for a pool not implemented.";
        return *this;
} /* pool::operator = */
 
template <class element>
inline int pool<element>::get ()
{
        if (unusedCount)
                return unused [-- unusedCount];
        else
                return elemCount ++;
} /* pool::get */
 
template <class element>
inline element &pool<element>::operator [] (int n)
{
        return elem [n];
} /* pool::operator [] */
 
template <class element>
inline void pool<element>::release (int n)
{
        if (n == elemCount - 1)
                -- elemCount;
        else
                unused [unusedCount ++] = n;
        return;
} /* pool::release */
 
 
} // namespace homology
} // namespace chomp
 
#endif // _CHOMP_STRUCT_POOL_H_