//////////////////////////////////////////////////////////////////////////////// // The Loki Library // Copyright (c) 2006 by Guillaume Chatelet // // Code covered by the MIT License // // Permission to use, copy, modify, distribute and sell this software for any // purpose is hereby granted without fee, provided that the above copyright // notice appear in all copies and that both that copyright notice and this // permission notice appear in supporting documentation. // // The authors make no representations about the suitability of this software // for any purpose. It is provided "as is" without express or implied warranty. // // This code DOES NOT accompany the book: // Alexandrescu, Andrei. "Modern C++ Design: Generic Programming and Design // Patterns Applied". Copyright (c) 2001. Addison-Wesley. // //////////////////////////////////////////////////////////////////////////////// // $Id: SPCachedFactory.h 896 2008-08-08 22:20:05Z syntheticpp $ #ifndef SPCACHEDFACTORY_H_ #define SPCACHEDFACTORY_H_ /** * This file is intented to be used if you want a CachedFactory with * a SmartPointer encapsulation policy. * It as been defined in a separate file because of the many introduced * dependencies (SmartPtr.h would depend on Functor.h and CachedFactory.h * would depend on SmartPtr.h). By defining another header you pay for those * extra dependencies only if you need it. * * This file defines FunctionStorage a new SmartPointer storage policy and * SmartPointer a new CachedFactory encapsulation policy. */ #include <loki/Functor.h> #include <loki/SmartPtr.h> #include <loki/CachedFactory.h> namespace Loki { //////////////////////////////////////////////////////////////////////////////// /// \class FunctionStorage /// /// \ingroup SmartPointerStorageGroup /// \brief Implementation of the StoragePolicy used by SmartPtr. /// /// This storage policy is used by SmartPointer CachedFactory's encapsulation /// policy. It's purpose is to call a Functor instead of deleting the /// underlying pointee object. You have to set the callback functor by calling /// SetCallBackFunction(const FunctorType &functor). /// /// Unfortunately, the functor argument is not a reference to the SmartPtr but /// a void *. Making functor argument a reference to the pointer would require /// the FunctionStorage template to know the full definition of the SmartPtr. //////////////////////////////////////////////////////////////////////////////// template <class T> class FunctionStorage { public: /// the type of the pointee_ object typedef T* StoredType; /// type used to declare OwnershipPolicy type. typedef T* InitPointerType; /// type returned by operator-> typedef T* PointerType; /// type returned by operator* typedef T& ReferenceType; /// type of the Functor to set typedef Functor< void , Seq< void* > > FunctorType; FunctionStorage() : pointee_(Default()), functor_() {} // The storage policy doesn't initialize the stored pointer // which will be initialized by the OwnershipPolicy's Clone fn FunctionStorage(const FunctionStorage& rsh) : pointee_(0), functor_(rsh.functor_) {} template <class U> FunctionStorage(const FunctionStorage<U>& rsh) : pointee_(0), functor_(rsh.functor_) {} FunctionStorage(const StoredType& p) : pointee_(p), functor_() {} PointerType operator->() const { return pointee_; } ReferenceType operator*() const { return *pointee_; } void Swap(FunctionStorage& rhs) { std::swap(pointee_, rhs.pointee_); std::swap(functor_, rhs.functor_); } /// Sets the callback function to call. You have to specify it or /// the smartPtr will throw a bad_function_call exception. void SetCallBackFunction(const FunctorType& functor) { functor_ = functor; } // Accessors template <class F> friend typename FunctionStorage<F>::PointerType GetImpl(const FunctionStorage<F>& sp); template <class F> friend const typename FunctionStorage<F>::StoredType& GetImplRef(const FunctionStorage<F>& sp); template <class F> friend typename FunctionStorage<F>::StoredType& GetImplRef(FunctionStorage<F>& sp); protected: // Destroys the data stored // (Destruction might be taken over by the OwnershipPolicy) void Destroy() { functor_(this); } // Default value to initialize the pointer static StoredType Default() { return 0; } private: // Data StoredType pointee_; FunctorType functor_; }; template <class T> inline typename FunctionStorage<T>::PointerType GetImpl(const FunctionStorage<T>& sp) { return sp.pointee_; } template <class T> inline const typename FunctionStorage<T>::StoredType& GetImplRef(const FunctionStorage<T>& sp) { return sp.pointee_; } template <class T> inline typename FunctionStorage<T>::StoredType& GetImplRef(FunctionStorage<T>& sp) { return sp.pointee_; } /** * \class SmartPointer * \ingroup EncapsulationPolicyCachedFactoryGroup * \brief Encapsulate the object in a SmartPtr with FunctionStorage policy. * * The object will come back to the Cache as soon as no more SmartPtr are * referencing this object. You can customize the SmartPointer with the standard * SmartPtr policies (OwnershipPolicy, ConversionPolicy, CheckingPolicy, * ConstnessPolicy) but StoragePolicy is forced to FunctionStorage. */ template < class AbstractProduct, template <class> class OwnershipPolicy = RefCounted, class ConversionPolicy = DisallowConversion, template <class> class CheckingPolicy = AssertCheck, template<class> class ConstnessPolicy = LOKI_DEFAULT_CONSTNESS > class SmartPointer { private: typedef SmartPtr< AbstractProduct,OwnershipPolicy, ConversionPolicy, CheckingPolicy, FunctionStorage, ConstnessPolicy > CallBackSP; protected: typedef CallBackSP ProductReturn; SmartPointer() : fun(this, &SmartPointer::smartPointerCallbackFunction) {} virtual ~SmartPointer() {} ProductReturn encapsulate(AbstractProduct* pProduct) { CallBackSP SP(pProduct); SP.SetCallBackFunction(fun); return SP; } AbstractProduct* release(ProductReturn& pProduct) { return GetImpl(pProduct); } const char* name() {return "smart pointer";} private: SmartPointer& operator=(const SmartPointer&); SmartPointer(const SmartPointer&); void smartPointerCallbackFunction(void* pSP) { CallBackSP& SP(*reinterpret_cast<CallBackSP*>(pSP)); ReleaseObject(SP); } virtual void ReleaseObject(ProductReturn& object)=0; const typename CallBackSP::FunctorType fun; }; } // namespace Loki #endif /*SPCACHEDFACTORY_H_*/