reuse.h

Go to the documentation of this file.

// Copyright (C) 2006-2014 David Sugar, Tycho Softworks.
// Copyright (C) 2015 Cherokees of Idaho.
//
// This file is part of GNU uCommon C++.
//
// GNU uCommon C++ is free software: you can redistribute it and/or modify
// it under the terms of the GNU Lesser General Public License as published
// by the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// GNU uCommon C++ 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 Lesser General Public License for more details.
//
// You should have received a copy of the GNU Lesser General Public License
// along with GNU uCommon C++.  If not, see <http://www.gnu.org/licenses/>.
 
#ifndef _UCOMMON_REUSE_H_
#define _UCOMMON_REUSE_H_
 
#ifndef _UCOMMON_THREAD_H_
#include <ucommon/thread.h>
#endif
 
namespace ucommon {
 
typedef unsigned short vectorsize_t;
 
class __EXPORT ArrayReuse : public ReusableAllocator
{
private:
    size_t objsize;
    unsigned count, limit, used;
    caddr_t mem;
 
    __DELETE_DEFAULTS(ArrayReuse);
 
protected:
    ArrayReuse(size_t objsize, unsigned c);
    ArrayReuse(size_t objsize, unsigned c, void *memory);
 
public:
    ~ArrayReuse();
 
protected:
    bool avail(void) const;
 
    ReusableObject *get(timeout_t timeout);
    ReusableObject *get(void);
    ReusableObject *request(void);
};
 
class __EXPORT PagerReuse : protected __PROTOCOL MemoryRedirect, protected ReusableAllocator
{
private:
    unsigned limit, count;
    size_t osize;
 
    __DELETE_DEFAULTS(PagerReuse);
 
protected:
    PagerReuse(mempager *pager, size_t objsize, unsigned count);
    ~PagerReuse();
 
    bool avail(void) const;
    ReusableObject *get(void);
    ReusableObject *get(timeout_t timeout);
    ReusableObject *request(void);
};
 
template<class T>
class array_reuse : protected ArrayReuse
{
private:
    __DELETE_DEFAULTS(array_reuse);
 
public:
    inline array_reuse(unsigned count) :
        ArrayReuse(sizeof(T), count) {}
 
    inline array_reuse(unsigned count, void *memory) :
        ArrayReuse(sizeof(T), count, memory) {}
 
    inline operator bool() const {
        return avail();
    }
 
    inline bool operator!() const {
        return !avail();
    }
 
    inline T* request(void) {
        return static_cast<T*>(ArrayReuse::request());
    }
 
    inline T* get(void) {
        return static_cast<T*>(ArrayReuse::get());
    }
 
    inline T* create(void) {
        return init<T>(static_cast<T*>(ArrayReuse::get()));
    }
 
    inline T* get(timeout_t timeout) {
        return static_cast<T*>(ArrayReuse::get(timeout));
    }
 
    inline T* create(timeout_t timeout) {
        return init<T>(static_cast<T*>(ArrayReuse::get(timeout)));
    }
 
    inline void release(T *object) {
        ArrayReuse::release(object);
    }
 
    inline operator T*() {
        return array_reuse::get();
    }
 
    inline T *operator*() {
        return array_reuse::get();
    }
};
 
template <class T>
class paged_reuse : protected PagerReuse
{
private:
    __DELETE_DEFAULTS(paged_reuse);
 
public:
    inline paged_reuse(mempager *pager, unsigned count) :
        PagerReuse(pager, sizeof(T), count) {}
 
    inline operator bool() const {
        return PagerReuse::avail();
    }
 
    inline bool operator!() const {
        return !PagerReuse::avail();
    }
 
    inline T *get(void) {
        return static_cast<T*>(PagerReuse::get());
    }
 
    inline T *create(void) {
        return init<T>(static_cast<T*>(PagerReuse::get()));
    }
 
    inline T *get(timeout_t timeout) {
        return static_cast<T*>(PagerReuse::get(timeout));
    }
 
    inline T *create(timeout_t timeout) {
        return init<T>(static_cast<T*>(PagerReuse::get(timeout)));
    }
 
    inline T *request(void) {
        return static_cast<T*>(PagerReuse::request());
    }
 
    inline void release(T *object) {
        PagerReuse::release(object);
    }
 
    inline T *operator*() {
        return paged_reuse::get();
    }
 
    inline operator T*() {
        return paged_reuse::get();
    }
};
 
} // namespace ucommon
 
#endif