pool.h

/*
 * pool.h
 * This file is part of dbPager Classes Library (DCL)
 *
 * Copyright (c) 2008 Dennis Prochko <wolfsoft@mail.ru>
 *
 * DCL 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 version 3.
 *
 * DCL 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 DCL; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin St, Fifth Floor,
 * Boston, MA  02110-1301  USA
 */

#ifndef _POOL_H_
#define _POOL_H_

#include <algorithm>
#include <queue>
#include <map>

#include <dcl/mutex.h>
#include <dcl/noncopyable.h>

namespace dbp {

template <class T>
class pool_ptr;


template <class T>
class pool: public noncopyable {
        friend class pool_ptr<T>;
public:
        virtual ~pool() {
                std::for_each(_all.begin(), _all.end(), delete_item);
        }

        pool_ptr<T> acquire(const std::string &key = std::string("")) {
                return pool_ptr<T>(acquire_item(key), this, key);
        }
        int size() const {
                return _all.size();
        }
        int in_use() const {
                int total = 0;
                for (queue_idx_iterator it = _free.begin();
                  it != _free.end(); ++it) {
                        total += it->second.size();
                }
                return _all.size() - total;
        }
private:
        typedef std::map<std::string, std::queue<T*> > queue_idx;
        typedef typename queue_idx::const_iterator queue_idx_iterator;
        queue_idx _free;
        std::vector<T*> _all;
        mutex cs;
        T* acquire_item(const std::string &key) {
                mutex_guard guard(cs);
                std::queue<T*> &q = _free[key];
                if (q.empty()) {
                        T *item = new T();
                        _all.push_back(item);
                        return item;
                }
                T *item = q.front();
                q.pop();
                return item;
        }
        void release_item(T *item, const std::string &key) {
                mutex_guard guard(cs);
                std::queue<T*> &q = _free[key];
                q.push(item);
        }
        static void delete_item(T *item) {
                delete item;
        }
};


template <class T>
class pool_ptr {
        friend class pool<T>;
public:
        ~pool_ptr() {
                if (_main) {
                        _pool->release_item(_item, _key);
                }
        }
        pool_ptr(const pool_ptr<T> &src): _item(src._item), _pool(src._pool),
          _key(src._key), _main(src._main) {
                const_cast<pool_ptr<T>&>(src)._main = false;
        }
        const pool_ptr<T>& operator=(const pool_ptr<T> &src) {
                _item = src._item;
                _pool = src._pool;
                _key = src._key;
                _main = true;
                const_cast<pool_ptr<T>&>(src)._main = false;
        }
        T& operator*() const {
                return *_item;
        }
        T* operator->() const {
                return _item;
        }
private:
        T *_item;
        pool<T> *_pool;
        const std::string _key;
        bool _main;
        pool_ptr() { }
        pool_ptr(T *item, pool<T> *pool, const std::string &key): _item(item),
          _pool(pool), _key(key), _main(true) { }
};

}

#endif /*_POOL_H_*/