2005-11-21 01:55:47 +00:00
|
|
|
/* $Id$ */
|
|
|
|
/*
|
|
|
|
* Copyright (C)2003-2006 Benny Prijono <benny@prijono.org>
|
|
|
|
*
|
|
|
|
* This program 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 2 of the License, or
|
|
|
|
* (at your option) any later version.
|
|
|
|
*
|
|
|
|
* This program 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 program; if not, write to the Free Software
|
|
|
|
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
|
|
|
|
*/
|
|
|
|
#ifndef __PJPP_POOL_HPP__
|
|
|
|
#define __PJPP_POOL_HPP__
|
|
|
|
|
|
|
|
#include <pj/pool.h>
|
|
|
|
|
|
|
|
class Pj_Pool;
|
|
|
|
class Pj_Caching_Pool;
|
|
|
|
|
|
|
|
//
|
|
|
|
// Base class for all Pjlib objects
|
|
|
|
//
|
|
|
|
class Pj_Object
|
|
|
|
{
|
|
|
|
public:
|
|
|
|
void *operator new(unsigned int class_size, Pj_Pool *pool);
|
|
|
|
void *operator new(unsigned int class_size, Pj_Pool &pool);
|
|
|
|
|
|
|
|
void operator delete(void*)
|
|
|
|
{
|
|
|
|
}
|
|
|
|
|
|
|
|
void operator delete(void*, Pj_Pool*)
|
|
|
|
{
|
|
|
|
}
|
|
|
|
|
|
|
|
void operator delete(void*, Pj_Pool&)
|
|
|
|
{
|
|
|
|
}
|
|
|
|
|
|
|
|
//
|
|
|
|
// Inline implementations at the end of this file.
|
|
|
|
//
|
|
|
|
|
|
|
|
private:
|
|
|
|
// Can not use normal new operator; must use pool.
|
|
|
|
// e.g.:
|
|
|
|
// obj = new(pool) Pj_The_Object(pool, ...);
|
|
|
|
//
|
|
|
|
void *operator new(unsigned int)
|
|
|
|
{}
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
//
|
|
|
|
// Pool.
|
|
|
|
//
|
|
|
|
class Pj_Pool : public Pj_Object
|
|
|
|
{
|
|
|
|
public:
|
|
|
|
//
|
|
|
|
// Default constructor, initializes internal pool to NULL.
|
|
|
|
// Application must call attach() some time later.
|
|
|
|
//
|
|
|
|
Pj_Pool()
|
|
|
|
: p_(NULL)
|
|
|
|
{
|
|
|
|
}
|
|
|
|
|
|
|
|
//
|
|
|
|
// Create pool.
|
|
|
|
//
|
|
|
|
Pj_Pool(Pj_Caching_Pool &caching_pool,
|
|
|
|
pj_size_t initial_size,
|
|
|
|
pj_size_t increment_size,
|
|
|
|
const char *name = NULL,
|
|
|
|
pj_pool_callback *callback = NULL);
|
|
|
|
|
|
|
|
//
|
|
|
|
// Construct from existing pool.
|
|
|
|
//
|
|
|
|
explicit Pj_Pool(pj_pool_t *pool)
|
|
|
|
: p_(pool)
|
|
|
|
{
|
|
|
|
}
|
|
|
|
|
|
|
|
//
|
|
|
|
// Attach existing pool.
|
|
|
|
//
|
|
|
|
void attach(pj_pool_t *pool)
|
|
|
|
{
|
|
|
|
p_ = pool;
|
|
|
|
}
|
|
|
|
|
|
|
|
//
|
|
|
|
// Destructor.
|
|
|
|
//
|
|
|
|
// Release pool back to factory. Remember: if you delete pool, then
|
|
|
|
// make sure that all objects that have been allocated from this pool
|
|
|
|
// have been properly destroyed.
|
|
|
|
//
|
|
|
|
// This is where C++ is trickier than plain C!!
|
|
|
|
//
|
|
|
|
~Pj_Pool()
|
|
|
|
{
|
|
|
|
if (p_)
|
|
|
|
pj_pool_release(p_);
|
|
|
|
}
|
|
|
|
|
|
|
|
//
|
|
|
|
// Get name.
|
|
|
|
//
|
|
|
|
const char *getobjname() const
|
|
|
|
{
|
|
|
|
return pj_pool_getobjname(p_);
|
|
|
|
}
|
|
|
|
|
|
|
|
//
|
|
|
|
// Get pjlib compatible pool object.
|
|
|
|
//
|
|
|
|
pj_pool_t *pool_()
|
|
|
|
{
|
|
|
|
return p_;
|
|
|
|
}
|
|
|
|
|
|
|
|
//
|
|
|
|
// Get pjlib compatible pool object.
|
|
|
|
//
|
|
|
|
const pj_pool_t *pool_() const
|
|
|
|
{
|
|
|
|
return p_;
|
|
|
|
}
|
|
|
|
|
|
|
|
//
|
|
|
|
// Get pjlib compatible pool object.
|
|
|
|
//
|
|
|
|
pj_pool_t *pj_pool_t_()
|
|
|
|
{
|
|
|
|
return p_;
|
|
|
|
}
|
|
|
|
|
|
|
|
//
|
|
|
|
// Reset pool.
|
|
|
|
//
|
|
|
|
void reset()
|
|
|
|
{
|
|
|
|
pj_pool_reset(p_);
|
|
|
|
}
|
|
|
|
|
|
|
|
//
|
|
|
|
// Get current capacity.
|
|
|
|
//
|
|
|
|
pj_size_t get_capacity()
|
|
|
|
{
|
|
|
|
pj_pool_get_capacity(p_);
|
|
|
|
}
|
|
|
|
|
|
|
|
//
|
|
|
|
// Get current total bytes allocated from the pool.
|
|
|
|
//
|
|
|
|
pj_size_t get_used_size()
|
|
|
|
{
|
|
|
|
pj_pool_get_used_size(p_);
|
|
|
|
}
|
|
|
|
|
|
|
|
//
|
|
|
|
// Allocate.
|
|
|
|
//
|
|
|
|
void *alloc(pj_size_t size)
|
|
|
|
{
|
|
|
|
return pj_pool_alloc(p_, size);
|
|
|
|
}
|
|
|
|
|
|
|
|
//
|
|
|
|
// Allocate elements and zero fill the memory.
|
|
|
|
//
|
|
|
|
void *calloc(pj_size_t count, pj_size_t elem)
|
|
|
|
{
|
|
|
|
return pj_pool_calloc(p_, count, elem);
|
|
|
|
}
|
|
|
|
|
|
|
|
//
|
|
|
|
// Allocate and zero fill memory.
|
|
|
|
//
|
|
|
|
void *zalloc(pj_size_t size)
|
|
|
|
{
|
|
|
|
return pj_pool_zalloc(p_, size);
|
|
|
|
}
|
|
|
|
|
|
|
|
private:
|
|
|
|
pj_pool_t *p_;
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
//
|
|
|
|
// Caching pool.
|
|
|
|
//
|
|
|
|
class Pj_Caching_Pool
|
|
|
|
{
|
|
|
|
public:
|
|
|
|
//
|
|
|
|
// Construct caching pool.
|
|
|
|
//
|
|
|
|
Pj_Caching_Pool( pj_size_t cache_capacity = 0,
|
|
|
|
const pj_pool_factory_policy *pol=&pj_pool_factory_default_policy)
|
|
|
|
{
|
|
|
|
pj_caching_pool_init(&cp_, pol, cache_capacity);
|
|
|
|
}
|
|
|
|
|
|
|
|
//
|
|
|
|
// Destroy caching pool.
|
|
|
|
//
|
|
|
|
~Pj_Caching_Pool()
|
|
|
|
{
|
|
|
|
pj_caching_pool_destroy(&cp_);
|
|
|
|
}
|
|
|
|
|
|
|
|
//
|
|
|
|
// Create pool.
|
|
|
|
//
|
|
|
|
pj_pool_t *create_pool( pj_size_t initial_size,
|
|
|
|
pj_size_t increment_size,
|
|
|
|
const char *name = NULL,
|
|
|
|
pj_pool_callback *callback = NULL)
|
|
|
|
{
|
|
|
|
return (pj_pool_t*)(*cp_.factory.create_pool)(&cp_.factory, name,
|
|
|
|
initial_size,
|
|
|
|
increment_size,
|
|
|
|
callback);
|
|
|
|
}
|
|
|
|
|
|
|
|
private:
|
|
|
|
pj_caching_pool cp_;
|
|
|
|
};
|
|
|
|
|
|
|
|
//
|
|
|
|
// Inlines for Pj_Object
|
|
|
|
//
|
|
|
|
inline void *Pj_Object::operator new(unsigned int class_size, Pj_Pool *pool)
|
|
|
|
{
|
|
|
|
return pool->alloc(class_size);
|
|
|
|
}
|
|
|
|
inline void *Pj_Object::operator new(unsigned int class_size, Pj_Pool &pool)
|
|
|
|
{
|
|
|
|
return pool.alloc(class_size);
|
|
|
|
}
|
|
|
|
|
|
|
|
//
|
|
|
|
// Inlines for Pj_Pool
|
|
|
|
//
|
|
|
|
inline Pj_Pool::Pj_Pool( Pj_Caching_Pool &caching_pool,
|
|
|
|
pj_size_t initial_size,
|
|
|
|
pj_size_t increment_size,
|
|
|
|
const char *name,
|
|
|
|
pj_pool_callback *callback)
|
|
|
|
{
|
|
|
|
p_ = caching_pool.create_pool(initial_size, increment_size, name,
|
|
|
|
callback);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
#endif /* __PJPP_POOL_HPP__ */
|
|
|
|
|