benn/lumiera_
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

removed all custom allocator / deleter stuff (it's the wrong aproach)

Browse source
This commit is contained in:
Fischlurch 2007-08-31 16:53:23 +02:00
parent b11ac46b76
commit b1ea774ef1
2 changed files with 15 additions and 72 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

79
src/common/factory.hpp
View file

@ -32,24 +32,6 @@ namespace cinelerra
{
namespace factory
{
/**
* Example NOP Allocator using just the normal C++ memory management.
* The intended use is for a Factory instance to iherit from this class.
* Specialized Allocators typically overload operator new and delete.
*/
class VanillaAllocator {};
/**
* Example Allocator using plain C memory management.
*/
class MallocAllocator
{
void* operator new (size_t siz) { return malloc (siz); };
void operator delete (void* p) { if (p) free (p); };
};
typedef VanillaAllocator DefaultALO; // Allocator facility to be used by default //////////////TODO
/**
* Wrapping any object created by the Factory into some smart ptr class.
* The Factory class inherits this functionallity, so it can be exchanged
@ -66,12 +48,8 @@ namespace cinelerra
protected:
SMP wrap (T* product) { return SMP (product); }
public:
typedef SMP PType;
typedef void (*DelHandler) (T* victim); ///< custom deleter function
void setDelHandler (DelHandler) {}; ///< if non-standard deleting is necessary
};
@ -82,38 +60,29 @@ namespace cinelerra
* the clients get just a smart-pointer or similar handle to the
* created object, which will manage the ownership.
*
* The provided default implementation uses just std::auto_ptr,
* but delegates the allocation to cinelerra's backend-layer.
*
* @todo actually do the delgation of memory management instead of using VanillaAllocator!
* The provided default implementation uses just std::auto_ptr.
*/
template
< class T, // the product to be created
class WR = Wrapper<T>, // used for fabricating the wrapper
class ALO = DefaultALO // Allocator facility to be used
< class T, // the product to be created
class WR = Wrapper<T> // used for fabricating the wrapper
>
class Factory : public WR, protected ALO
class Factory : public WR
{
public:
/** Object creating facility.
* Intended to be over/written/ with a variant taking
* the appropriate number of parameters and using the
* (privately inherited) functions of the allocator.
* the appropriate number of parameters and maybe
* using some special custom allocator.
* Note: non-virtual.
*/
typename WR::PType operator() () { return wrap (new T ); }
protected:
/** this custom deleter function can be used if the
* operator delete call needs to be in the current scope.
* @see RefcountPtr
*/
static void destroy (T* victim) { delete victim; };
};
/* -- some example and default instantiiations -- */
using std::tr1::shared_ptr;
@ -125,22 +94,11 @@ namespace cinelerra
template<class T>
class Wrapper<T, shared_ptr<T> >
{
protected:
shared_ptr<T> wrap (T* product) { return shared_ptr<T> (product, destroy_ ); }
shared_ptr<T> wrap (T* product) { return shared_ptr<T> (product); }
public:
typedef shared_ptr<T> PType;
Wrapper () : destroy_(&stdDelete) { }
typedef void (*DelHandler) (T* victim); ///< custom deleter function
void setDelHandler (DelHandler d) { this->destroy_ = d; } ///< custom deleter used by shard_ptr
private:
DelHandler destroy_;
static void stdDelete (T* victim) { delete victim; }; ///< by default just delete objects normally
};
@ -149,20 +107,11 @@ namespace cinelerra
* generating refcounting shared_ptr wrapped Objects. Built upon
* the corresponding special intstantiation of the Wrapper template.
*/
template
< class T, // the product to be created
class ALO = DefaultALO // Allocator facility to be used
>
class RefcountPtr : public Factory<T, Wrapper<T,shared_ptr<T> >, ALO>
template<class T>
class RefcountPtr : public Factory<T, Wrapper<T,shared_ptr<T> > >
{
public:
typedef shared_ptr<T> PType;
/** especially the shared_ptr will use Factory::destroy,
* so it is sufficient to make Factory a friend if the
* Target class to be produced has private ctor/dtors
*/
RefcountPtr() { setDelHandler(&this->destroy); }
};
@ -171,14 +120,14 @@ namespace cinelerra
* Creating an implementation subclass and wraps into auto_ptr.
*/
template
< class T, // Interface class
class TImpl, // Implementation class to be created
class ALO = DefaultALO // Allocator facility to be used
< class T, // Interface class
class TImpl // Implementation class to be created
>
class PImplPtr : public Factory<T, Wrapper<T>, ALO>
class PImplPtr : public Factory<T, Wrapper<T> >
{
public:
typedef std::auto_ptr<T> PType;
PType operator() (){ return wrap (new TImpl); };
};

8
tests/components/common/factorytest.cpp
View file

@ -76,6 +76,7 @@ namespace cinelerra
}
friend class ObjFactory;
friend class std::tr1::_Sp_deleter<TargetObj>;
public:
@ -116,13 +117,6 @@ namespace cinelerra
*/
PType operator() (uint param) { return wrap (new TargetObj(param) ); }
ObjFactory () { setDelHandler(&destroy); }
protected:
/** define a custom deleter function, so the actual destrucor call
* happenes within the scope of ObjFactory, which is friend of TargetObj
*/
static void destroy (TargetObj* victim) { delete victim; };
};