smart_ptr.hpp

#ifndef smart_ptr_HPP_HEADER_GUARD_
#define smart_ptr_HPP_HEADER_GUARD_
/*
For more details, which include example usage, full introduction, parameters, and tutorial,
see following link:
http://axter.com/smartptr
SET A SIDE NOTES:
For ease of testing and distribution, all the policies are included in the same header with the smart_ptr.
Once testing is near completion, the policies will be moved to separate header,  and the smart_ptr header 
will have an #include to the new policy headers.

This source file is documented in a Doxygen friendly format.
This format allows Doxygen to pull the comments out, and to create help
documents in HTML, RTF, man, and XML formats.
http://www.stack.nl/~dimitri/doxygen/index.html
*/

#ifndef __BORLANDC__ 
#if !defined(_MSC_VER) || (_MSC_VER > 1200)
//Both VC++6.0 and borland compilers don't support type defined via policy
#define SMART_PTR_SUPPORT_RETURN_TYPE_THROUGH_POLICY_
#endif
#endif

struct allocator_default_policy
{
        template<typename T_obj> static inline T_obj* allocate(const T_obj* ptr)
        {
                if (ptr) return new T_obj(*ptr);
                return NULL;
        }
        template<typename T_obj> static inline void deallocate(T_obj* ptr){delete ptr;}
};

struct clone_function_allocator_policy
{
        template<typename T_obj> static inline T_obj* allocate(const T_obj* ptr)
        {
                if(!ptr) return NULL;
                return static_cast<T_obj*>(ptr->do_clone());
        }
        template<typename T_obj> static inline void deallocate(T_obj* ptr){delete ptr;}
};

struct clone_static_function_allocator_policy
{
        template<typename T_obj> static inline T_obj* allocate(const T_obj* ptr)
        {
                if(!ptr) return NULL;
                return T_obj::do_clone(*ptr);
        }
        template<typename T_obj> static inline void deallocate(T_obj* ptr){delete ptr;}
};

// @cond INCLUDE_ALL_OBJS_
template<size_t size_array>
struct allocator_array_policy
{
        template<typename T_obj> static T_obj* allocate(const T_obj* ptr)
        {
                if (!ptr) return NULL;
#ifdef BOOST_ASSERT
                BOOST_ASSERT(size_array);
#endif //BOOST_ASSERT
                T_obj *arr = new T_obj[size_array];
                for(size_t i = 0;i < size_array;++i)
                        arr[i] = ptr[i];
                return arr;
        }
        template<typename T_obj> static inline void deallocate(T_obj* ptr){delete[] ptr;}
};
// @endcond 

struct value_comparsion_semantic_policy
{
        template<class T1, class T2> static bool less_than(const T1 & a, const T2 & b){return (*a.c_ptr()) < (*b.c_ptr());}
        template<class T1, class T2> static bool greater_than(const T1 & a, const T2 & b){return (*a.c_ptr()) > (*b.c_ptr());}
        template<class T1, class T2> static bool less_than_or_equal(const T1 & a, const T2 & b){return (*a.c_ptr()) <= (*b.c_ptr());}
        template<class T1, class T2> static bool greater_than_or_equal(const T1 & a, const T2 & b){return (*a.c_ptr()) >= (*b.c_ptr());}
        template<class T1, class T2> static bool is_equal(const T1 & a, const T2 & b){return (*a.c_ptr()) == (*b.c_ptr());}
};

struct pointer_comparsion_semantic_policy
{
        template<class T1, class T2> static bool less_than(const T1 & a, const T2 & b){return (a.c_ptr()) < (b.c_ptr());}
        template<class T1, class T2> static bool greater_than(const T1 & a, const T2 & b){return (a.c_ptr()) > (b.c_ptr());}
        template<class T1, class T2> static bool less_than_or_equal(const T1 & a, const T2 & b){return (a.c_ptr()) <= (b.c_ptr());}
        template<class T1, class T2> static bool greater_than_or_equal(const T1 & a, const T2 & b){return (a.c_ptr()) >= (b.c_ptr());}
        template<class T1, class T2> static bool is_equal(const T1 & a, const T2 & b){return (a.c_ptr()) == (b.c_ptr());}
};

struct no_comparsion_semantic_policy{};

struct value_stream_operator_semantic_policy
{
        template<class T1, class T2> static T1& input_stream(T1 &is, T2 &smart_pointer){is >> (*smart_pointer.get_ptr());return is;}
        template<class T1, class T2> static T1& output_stream(T1 &io, T2 &smart_pointer){io << (*smart_pointer.c_ptr());return io;}
};

struct no_stream_operator_semantic_policy{};

struct value_arithmetic_semantic_policy
{
        // @cond INCLUDE_ALL_OBJS_
        template<class T> struct return_type{typedef T type;};
        // @endcond
        template<class T1, class T2> static T1& plus_equal_smart_ptr(T1 & a, const T2 & b){a.get_ptr()->operator+=(*b.c_ptr());return a;}
        template<class T1, class T2> static T1& plus_equal(T1 & a, const T2 & b){a.get_ptr()->operator+=(b);return a;}
        template<class T1, class T2> static T1& minus_equal_smart_ptr(T1 & a, const T2 & b){a.get_ptr()->operator-=(*b.c_ptr());return a;}
        template<class T1, class T2> static T1& minus_equal(T1 & a, const T2 & b){a.get_ptr()->operator-=(b);return a;}
        template<class T1, class T2> static T1 plus(const T1 & a, const T2 & b)
        {
                T1 c(a);
                c.get_ptr()->operator+=(*b.c_ptr());
                return c;
        }
        template<class T1, class T2> static T1 minus(const T1 & a, const T2 & b)
        {
                T1 c(a);
                c.get_ptr()->operator-=(*b.c_ptr());
                return c;
        }
};

// @cond INCLUDE_ALL_OBJS_
struct no_arithmetic_semantic_policy{template<class T>struct return_type{typedef T type;};};
// @endcond

class ref_link_policy
{
        struct ref_link
        {
                ref_link():m_back(NULL), m_front(NULL){}
                ref_link *m_back;
                ref_link *m_front;
        private:  //Disallow copy constructor and assignment op
                ref_link(const ref_link&);
                ref_link& operator=(const ref_link&);
        };
        ref_link m_ref_link;
        void pop_link()
        {
                if (m_ref_link.m_back)
                {
                        m_ref_link.m_back->m_front = m_ref_link.m_front;
                }
                if (m_ref_link.m_front)
                {
                        m_ref_link.m_front->m_back = m_ref_link.m_back;
                }
                m_ref_link.m_front = NULL;
                m_ref_link.m_back = NULL;
        }
        void insert_link(ref_link *Target)
        {
                m_ref_link.m_back = Target;
                m_ref_link.m_front = Target->m_front;
                if (m_ref_link.m_front)
                {
                        m_ref_link.m_front->m_back = &m_ref_link;
                }
                if (m_ref_link.m_back)
                {
                        m_ref_link.m_back->m_front = &m_ref_link;
                }
        }
        ref_link_policy(const ref_link_policy&);
        ref_link_policy& operator=(const ref_link_policy&);
protected:
        template<class T>
                inline bool is_referenced(T&)const{return (m_ref_link.m_back || m_ref_link.m_front);}
public:
        ref_link_policy(){}
        template<class T1>
        inline ref_link_policy(ref_link_policy& src, T1&)
        {
                insert_link(&src.m_ref_link);
        }
        template<class T, class F, class LCK>
                void release(T& type, F clone_fct, LCK &lck_policy)
        {
                if (!is_referenced(type)){
                        if (type && clone_fct)
                        {
                                clone_fct(type, false, NULL, NULL, NULL);
                        }
                        type = NULL;
                }
                else
                {
                        pop_link();
                        lck_policy.assignment_unlock_policy(type);
                }
        }
        template<class T1, class F1, class T2, class F2, class LCK>
                void assign(T1& type1, F1& clone_fct1, T2 type2, const F2 clone_fct2, ref_link_policy& src_policy, LCK &lck_policy)
        {
                if (!type1 || type1 != type2)
                {
                        lck_policy.assignment_lock_policy(type1);
                        const bool src_policy_eq_this = (this == &src_policy);
                        release(type1, clone_fct1, lck_policy);
                        type1 = type2;
                        clone_fct1 = clone_fct2;
                        if (src_policy_eq_this)
                        {
                                m_ref_link.m_back = NULL;
                                m_ref_link.m_front = NULL;
                        }
                        else
                                insert_link(&src_policy.m_ref_link);
                }
        }
};

class ref_count_policy
{
        struct ref_count
        {
                ref_count():m_count(new size_t(1)){}
                ref_count(size_t *count_):m_count(count_){}
                size_t *m_count;
        private:  //Disallow copy constructor and assignment op
                ref_count(const ref_count&);
                ref_count& operator=(const ref_count&);
        };
        ref_count m_ref_count;
        ref_count_policy(const ref_count_policy&);
        ref_count_policy& operator=(const ref_count_policy&);
protected:
        template<class T>
                inline bool is_referenced(T&)const{return (m_ref_count.m_count && (*m_ref_count.m_count) > 1);}
public:
        ref_count_policy(){}
        template<class T1>
                inline ref_count_policy(ref_count_policy& src, T1&):m_ref_count(src.m_ref_count.m_count)
        {
                if (m_ref_count.m_count) ++(*m_ref_count.m_count);
        }
        template<class T, class F, class LCK>
                void release(T& type, F clone_fct, LCK &lck_policy)
        {
                if (!is_referenced(type)){
                        if (type && clone_fct)
                        {
                                clone_fct(type, false, NULL, NULL, NULL);
                        }
                        type = NULL;
                        delete m_ref_count.m_count;
                        m_ref_count.m_count = NULL;
                }
                else
                {
                        if (m_ref_count.m_count) --(*m_ref_count.m_count);
                        lck_policy.assignment_unlock_policy(type);
                }
        }
        template<class T1, class F1, class T2, class F2, class LCK>
                void assign(T1& type1, F1& clone_fct1, T2 type2, const F2 clone_fct2, ref_count_policy& src_policy, LCK &lck_policy)
        {
                if (!type1 || type1 != type2)
                {
                        lck_policy.assignment_lock_policy(type1);
                        const bool src_policy_eq_this = (this == &src_policy);
                        release(type1, clone_fct1, lck_policy);
                        type1 = type2;
                        clone_fct1 = clone_fct2;
                        if (src_policy_eq_this)
                                m_ref_count.m_count = new size_t(0); //Set to zero, because of increment below
                        else
                                m_ref_count.m_count = src_policy.m_ref_count.m_count;
                        if (m_ref_count.m_count) ++(*m_ref_count.m_count);
                }
        }
};

class ref_intrusive_policy
{
        ref_intrusive_policy(const ref_intrusive_policy&);
        ref_intrusive_policy& operator=(const ref_intrusive_policy&);
protected:
        template<class T>
                inline bool is_referenced(T& type)const{return intrusive_ptr_is_ref(type);}
public:
        ref_intrusive_policy(){}
        template<class T>
        inline ref_intrusive_policy(ref_intrusive_policy&, T& type)
        {
                if (type) intrusive_ptr_add_ref(type);
        }
        template<class T, class F, class LCK>
                void release(T& type, F, LCK &)
        {
                //intrusive_ptr_release must perform assignment_unlock_policy (unlock)
                if (type) intrusive_ptr_release(type);
        }
        template<class T1, class F1, class T2, class F2, class LCK>
                void assign(T1& type1, F1& clone_fct1, T2 type2, const F2 clone_fct2, ref_intrusive_policy &src_policy, LCK &lck_policy)
        {
                if (!type1 || type1 != type2)
                {
                        lck_policy.assignment_lock_policy(type1);
                        const bool src_policy_eq_this = (this == &src_policy);
                        release(type1, clone_fct1, lck_policy);
                        type1 = type2;
                        clone_fct1 = clone_fct2;
                        if (type1 && !src_policy_eq_this) intrusive_ptr_add_ref(type1);
                }
        }
};

struct no_lock_policy
{
        no_lock_policy(){}
        template<class T_obj> inline void pointee_lock_policy(T_obj*){}
        template<class T_obj> inline void const_pointee_lock_policy(T_obj*){}
        template<class T_obj> inline void assignment_lock_policy(T_obj*){}
        template<class T_obj> inline void assignment_unlock_policy(T_obj*){}
        template<class T_obj> inline void destructor_lock_policy(T_obj*){}
        template<class T_obj> inline void destructor_unlock_policy(T_obj*){}
        template<class T_obj> inline T_obj* constructor_lock_policy(T_obj* p){return p;}
        template<class T_obj> inline void constructor_unlock_policy(T_obj*){}
        // @cond INCLUDE_ALL_OBJS_
        template<class T> struct return_type{typedef T* type_pointee;typedef T& type_ref;};//The struct type is here for a future optional feature
        // @endcond
        //A lock policy should have the following two functions implemented
        template<class T_obj> inline void lock(T_obj*){}
        template<class T_obj> inline void unlock(T_obj*){}
private:
        //A lock policy can optionally have the following two functions implemented and public
        template<class T_obj> inline bool trylock(T_obj*);
        template<class T_obj> inline bool islock(T_obj*);// Should only be used with trylock
        //The following should always be private with non implementation
        no_lock_policy(const no_lock_policy&);
        no_lock_policy& operator=(const no_lock_policy&);
};

struct intrusive_lock_policy
{
        intrusive_lock_policy(){}
        template<class T_obj> inline void pointee_lock_policy(T_obj* p){}
        template<class T_obj> inline void const_pointee_lock_policy(T_obj* p){}
        template<class T_obj> inline void assignment_lock_policy(T_obj* p){if (p) lock(p);}
        template<class T_obj> inline void assignment_unlock_policy(T_obj* p){if (p) unlock(p);}
        template<class T_obj> inline void destructor_lock_policy(T_obj* p){if (p) lock(p);}
        template<class T_obj> inline void destructor_unlock_policy(T_obj* p){if (p) unlock(p);}
        template<class T_obj> inline T_obj* constructor_lock_policy(T_obj* p){if (p) lock(p);return p;}
        template<class T_obj> inline void constructor_unlock_policy(T_obj* p){if (p) unlock(p);}
        template<class T_obj> inline void lock(T_obj* p){intrusive_ptr_lock(p);}
        template<class T_obj> inline void unlock(T_obj* p){intrusive_ptr_unlock(p);}
        template<class T_obj> inline bool trylock(T_obj* p){return intrusive_ptr_trylock(p);}
        template<class T_obj> inline bool islock(T_obj* p){return intrusive_ptr_islock(p);}// Should only be used with trylock
        // @cond INCLUDE_ALL_OBJS_
        template<class T> struct return_type{typedef T* type_pointee;typedef T& type_ref;};//The struct type is here for a future optional feature
        // @endcond
private: //The following should always be private with no implementation
        intrusive_lock_policy(const intrusive_lock_policy&);
        intrusive_lock_policy& operator=(const intrusive_lock_policy&);
};

//See Note#2 listed below
#ifndef SMART_PTR_EXCLUDE_DEFAULT_POLICY_SPECIFICATIONS_
typedef no_lock_policy                                                                                          lock_default_policy;
typedef ref_link_policy                                                                                         ref_default_policy;
#endif // not SMART_PTR_EXCLUDE_DEFAULT_POLICY_SPECIFICATIONS_

//weak_storage implementation is still in progress
struct weak_storage
{
        struct ref_count
        {
                ref_count():m_count(new size_t(1)){}
                size_t *m_count;
        private:  //Disallow copy constructor and assignment op
                ref_count(const ref_count&);
                ref_count& operator=(const ref_count&);
        };
        ref_count m_ref_count;
};

struct no_weak_support{};

template<class REFERENCE_POLICY = ref_default_policy, class LOCK_POLICY = lock_default_policy, class WEAK_SUPPORT_POLICY = no_weak_support>
class copy_on_write_policy : public REFERENCE_POLICY, public LOCK_POLICY
{
public:
        copy_on_write_policy(){}
        template<class T1, class F1, class T2>
                inline copy_on_write_policy(REFERENCE_POLICY& src, const T1& type, const F1&, const T2&):REFERENCE_POLICY(src, type)
        {
        }
        template<class T, class F>
                T get_non_constant_ptr(T& type, F clone_fct)
        {
                if (REFERENCE_POLICY::is_referenced(type) && type && clone_fct)
                {
                        assign(type, clone_fct, 
                                clone_fct(type, true, NULL, NULL, NULL), 
                                clone_fct, *this, *this);
                }
                return type;
        }
};

template<class REFERENCE_POLICY = ref_default_policy, class LOCK_POLICY = lock_default_policy, class WEAK_SUPPORT_POLICY = no_weak_support>
class shared_ptr_policy : public REFERENCE_POLICY, public LOCK_POLICY
{
public:
        shared_ptr_policy(){}
        template<class T1, class F1, class T2>
                inline shared_ptr_policy(REFERENCE_POLICY& src, const T1& type, const F1&, const T2&):REFERENCE_POLICY(src, type)
        {
        }
        template<class T, class F>
                inline T& get_non_constant_ptr(T& type, const F&){return type;}
};

template<class LOCK_POLICY = lock_default_policy>
class deep_copy_policy : public LOCK_POLICY
{
public:
        deep_copy_policy(){}
        template<class T1, class F1, class T2>
                inline deep_copy_policy(deep_copy_policy&, T1 type_src, F1 clone_fct, T2& type_target)
        {
                type_target = clone_fct(type_src, true, NULL, NULL, NULL);
        }
        template<class T, class F, class LCK>
                inline void release(T& type, F clone_fct, LCK &)
        {
                if (type && clone_fct)
                {
                        clone_fct(type, false, NULL, NULL, NULL);
                }
                type = NULL;
        }
        template<class T1, class F1, class T2, class F2, class LCK>
                void assign(T1& type1, F1& clone_fct1, T2 type2, const F2 clone_fct2, deep_copy_policy&, LCK &lck_policy)
        {
                if (!type1 && type1 != type2)
                {
                        lck_policy.assignment_lock_policy(type1);
                        release(type1, clone_fct1, lck_policy);
                        if (type2)
                                type1 = clone_fct2(type2, true, NULL, NULL, NULL);
                        clone_fct1 = clone_fct2;
                }
        }
        template<class T, class F>
                inline T& get_non_constant_ptr(T& type, const F&)
        {//deep copy policy always clones on the constructor, so no need to clone here, and we can just return the pointer
                return type;
        }
};

struct no_checking_policy
{
        template<class T_obj> static void check_type_pass_to_constructor(T_obj*){}
        template<class T_obj> static void on_dereference(T_obj*){}
        template<class T_obj> static void on_const_dereference(T_obj*){}
        template<class T_obj> static void before_release(T_obj*){}
        template<class T_obj> static void after_release(T_obj*){}
};

// @cond INCLUDE_ALL_OBJS_
struct boost_assert_checking_policy
{
#ifdef BOOST_ASSERT
        template<class T_obj> static void check_type_pass_to_constructor(T_obj*){}
        template<class T_obj> static void on_dereference(T_obj*){}
        template<class T_obj> static void on_const_dereference(T_obj*){}
#else
        template<class T_obj> static void check_type_pass_to_constructor(T_obj* type)
        {
                BOOST_ASSERT(type != NULL);
                BOOST_ASSERT(typeid(*type) == typeid(T_obj));
        }
        template<class T_obj> static void on_dereference(T_obj* type)
        {
                BOOST_ASSERT(type != NULL);
                BOOST_ASSERT(typeid(*type) == typeid(T_obj));
        }
        template<class T_obj> static void on_const_dereference(T_obj* type)
        {
                BOOST_ASSERT(type != NULL);
                BOOST_ASSERT(typeid(*type) == typeid(T_obj));
        }
#endif //BOOST_ASSERT
        template<class T_obj> static void before_release(T_obj*){}
        template<class T_obj> static void after_release(T_obj*){}
};
// @endcond 


#if defined(_MSC_VER) && (_MSC_VER <= 1200)
template < typename TT, typename DT, typename AL> TT * constructor_and_destructor_allocator_function( TT *  ptr, bool bConstruct, DT*, AL* , void*) //Seen Note#1 below, for details on the last three arguments
{// The clone function method: (Thanks to Kai-Uwe Bux)
        if (!ptr) return NULL;
        if (bConstruct){return AL::allocate(static_cast<const DT*>(ptr));}
        AL::deallocate(ptr);
        return NULL;
}
#endif //defined(_MSC_VER) && (_MSC_VER <= 1200)


#ifndef SMART_PTR_EXCLUDE_DEFAULT_POLICY_SPECIFICATIONS_
typedef value_comparsion_semantic_policy                                                                comparison_default_policy;
typedef no_stream_operator_semantic_policy                                                              stream_default_policy;
typedef no_checking_policy                                                                                              checking_default_policy;
//The following two default policies are declared above the ownership polices
//typedef no_lock_policy                                                                                                lock_default_policy;
//typedef ref_link_policy                                                                                               ref_default_policy;
typedef copy_on_write_policy<ref_default_policy, lock_default_policy>   ownership_default_policy;
typedef no_arithmetic_semantic_policy                                                                   arithmetic_default_policy;
#endif // not SMART_PTR_EXCLUDE_DEFAULT_POLICY_SPECIFICATIONS_

template<class T, class ALLOCATOR_POLICY>
class smart_ptr_base
{
protected:
        typedef T * ( *clone_fct_Type ) (const T *, bool, void*, ALLOCATOR_POLICY*, void*);//Last two values are not used (See note#1 at end of file)
        T* m_type;
        clone_fct_Type m_clone_fct;
        inline smart_ptr_base(T* type, clone_fct_Type clone_fct): m_type(type), m_clone_fct(clone_fct){}
        inline ~smart_ptr_base() throw()
        {
                if (m_type) m_clone_fct(m_type, false, NULL, NULL, NULL);
        }
private:
        smart_ptr_base(const smart_ptr_base&);
        smart_ptr_base& operator=(const smart_ptr_base& Src);
};


//----------------------------------------------------------------------------------------
//----------------------------------------------------------------------------------------
//----------------------------------------------------------------------------------------
//----------------------------------------------------------------------------------------
//Start of smart_ptr class

template<class T, 
        //Available OWNERSHIP_POLICY policies:                          shared_ptr_policy<ref_link_policy>, copy_on_write_policy<ref_link_policy>, deep_copy_policy, shared_ptr_policy<ref_count_policy>, copy_on_write_policy<ref_count_policy>, shared_ptr_policy<ref_intrusive_policy>, copy_on_write_policy<ref_intrusive_policy>
        class OWNERSHIP_POLICY = ownership_default_policy , 
        //Available ALLOCATOR_POLICY policies:                          allocator_default_policy, clone_function_allocator_policy, clone_static_function_allocator_policy
        class ALLOCATOR_POLICY =  allocator_default_policy,
        //Available CHECKING_POLICY policies:                           no_checking_policy, boost_assert_checking_policy
        class CHECKING_POLICY =  checking_default_policy,
        //Available COMPARISON_SEMANTIC_POLICY policies:        value_comparsion_semantic_policy, pointer_comparsion_semantic_policy, no_comparsion_semantic_policy 
        class COMPARISON_SEMANTIC_POLICY = comparison_default_policy,
        //Available STREAM_OP_SEMANTIC_POLICY policies:         value_stream_operator_semantic_policy, no_stream_operator_semantic_policy  (Not supported on VC++6.0)
        class STREAM_OP_SEMANTIC_POLICY = stream_default_policy,
        //Available ARITHMETIC_SEMANTIC_POLICY policies:        no_arithmetic_semantic_policy, value_arithmetic_semantic_policy  (Not support for non-compliant compilers like VC++6.0 and BCC55)
        class ARITHMETIC_SEMANTIC_POLICY = arithmetic_default_policy>
class smart_ptr : smart_ptr_base<T, ALLOCATOR_POLICY>
{
        enum implement_default_object{eYes, eNo};
        mutable OWNERSHIP_POLICY m_ownership_policy;
public:
        template<typename T_obj>
                inline smart_ptr(T_obj* type):smart_ptr_base<T,ALLOCATOR_POLICY>(type, get_alloc_func(type))
        {
                CHECKING_POLICY::check_type_pass_to_constructor(type);
        }
        inline smart_ptr(const smart_ptr& Src):smart_ptr_base<T,ALLOCATOR_POLICY>(Src.m_ownership_policy.constructor_lock_policy(Src.m_type), Src.m_clone_fct), m_ownership_policy(Src.m_ownership_policy, Src.m_type, Src.m_clone_fct, m_type){Src.m_ownership_policy.constructor_unlock_policy(Src.m_type);}
        smart_ptr(implement_default_object use_default_obj = eYes):smart_ptr_base<T,ALLOCATOR_POLICY>(NULL, NULL)
        {
                if (use_default_obj == eYes)
                {
                        smart_ptr& default_obj = get_or_set_default_object();
                        default_obj.lock();
                        m_ownership_policy.assign(m_type, m_clone_fct, default_obj.m_type, default_obj.m_clone_fct, default_obj.m_ownership_policy, m_ownership_policy);
                        default_obj.unlock();
                }
        }
        inline ~smart_ptr() throw()
        {
                m_ownership_policy.destructor_lock_policy(m_type);
                CHECKING_POLICY::before_release(m_type);
                m_ownership_policy.release(m_type, m_clone_fct, m_ownership_policy);
                CHECKING_POLICY::after_release(m_type);
                m_type = NULL;
        }
#if !defined(_MSC_VER) || (_MSC_VER > 1200)

        template<class CompatibleDerivedT,      class OWNERSHIP_POLICY_T,       class ALLOCATOR_POLICY_T,       class CHECKING_POLICY_T,        class COMPARISON_SEMANTIC_POLICY_T,     class STREAM_OPERATOR_SEMANTIC_POLICY_T,        class ARITHMETIC_SEMANTIC_POLICY_T>
                smart_ptr(const smart_ptr<CompatibleDerivedT, OWNERSHIP_POLICY_T, ALLOCATOR_POLICY_T, CHECKING_POLICY_T, COMPARISON_SEMANTIC_POLICY_T, STREAM_OPERATOR_SEMANTIC_POLICY_T, ARITHMETIC_SEMANTIC_POLICY_T>& Src):smart_ptr_base<T,ALLOCATOR_POLICY>(NULL, NULL)
        {//No clean way to do this, so just clone it
                Src.lock();
                Src.make_clone(m_type, m_clone_fct);
                Src.unlock();
        }

        template<class CompatibleDerivedT,      class OWNERSHIP_POLICY_T,       class ALLOCATOR_POLICY_T,       class CHECKING_POLICY_T,        class COMPARISON_SEMANTIC_POLICY_T, class STREAM_OPERATOR_SEMANTIC_POLICY_T,    class ARITHMETIC_SEMANTIC_POLICY_T>
                smart_ptr& operator=(const smart_ptr<CompatibleDerivedT, OWNERSHIP_POLICY_T, ALLOCATOR_POLICY_T, CHECKING_POLICY_T, COMPARISON_SEMANTIC_POLICY_T, STREAM_OPERATOR_SEMANTIC_POLICY_T, ARITHMETIC_SEMANTIC_POLICY_T>& Src)
        {//No clean way to do this, so just clone it
                if (m_type != Src.c_ptr())
                {
                        m_ownership_policy.assignment_lock_policy(m_type);
                        CHECKING_POLICY::before_release(m_type);
                        m_ownership_policy.release(m_type, m_clone_fct, m_ownership_policy);
                        CHECKING_POLICY::after_release(m_type);
                        Src.lock();
                        Src.make_clone(m_type, m_clone_fct);
                        Src.unlock();
                }
                return *this;
        }
#else
        //For VC++6.0 the smart_ptr is only interchangeable through assignment operator
        template<class CompatiblePointerTypeForVC60>
        smart_ptr& operator=(const CompatiblePointerTypeForVC60& Src)
        {//No clean way to do this, so just clone it
                m_ownership_policy.assignment_lock_policy(m_type);
                CHECKING_POLICY::before_release(m_type);
                m_ownership_policy.release(m_type, m_clone_fct, m_ownership_policy);
                if (m_type) m_ownership_policy.assignment_unlock_policy(m_type);
                CHECKING_POLICY::after_release(m_type);
                Src.lock();
                Src.make_clone(m_type, m_clone_fct);
                Src.unlock();
                return *this;
        }
#endif //_MSC_VER noteq 1200

        smart_ptr& operator=(smart_ptr& Src)
        {
                if (m_type != Src.m_type)
                {
                        Src.lock();
                        m_ownership_policy.assign(m_type, m_clone_fct, Src.m_type, Src.m_clone_fct, Src.m_ownership_policy, m_ownership_policy);
                        Src.unlock();
                }
                return *this;
        }
        bool operator! () const{return c_ptr() == 0;}
#ifdef SMART_PTR_SUPPORT_RETURN_TYPE_THROUGH_POLICY_
        // @cond INCLUDE_ALL_OBJS_
        //Return type for arithmetic operators
        typedef typename ARITHMETIC_SEMANTIC_POLICY::template return_type<smart_ptr>::type arith_retrn_type;
        // @endcond 
        //The arithmetic semantic policy might not make it through boost peer review, so for now there's only
        //a limited set for demonstration purposes.
        arith_retrn_type& operator+=(const smart_ptr& Src){return ARITHMETIC_SEMANTIC_POLICY::plus_equal_smart_ptr(*this, Src);}
        template<class T2>      arith_retrn_type& operator+=(const T2& Src){return ARITHMETIC_SEMANTIC_POLICY::plus_equal(*this, Src);}
        arith_retrn_type& operator-=(const smart_ptr& Src){return ARITHMETIC_SEMANTIC_POLICY::minus_equal_smart_ptr(*this, Src);}
        template<class T2>      arith_retrn_type& operator-=(const T2& Src){return ARITHMETIC_SEMANTIC_POLICY::minus_equal(*this, Src);}
        friend arith_retrn_type operator+(const smart_ptr& a, const smart_ptr& b){return ARITHMETIC_SEMANTIC_POLICY::plus(a, b);}
        friend arith_retrn_type operator-(const smart_ptr& a, const smart_ptr& b){return ARITHMETIC_SEMANTIC_POLICY::minus(a, b);}
        //
        // @cond INCLUDE_ALL_OBJS_
        typedef typename OWNERSHIP_POLICY::template return_type<T>::type_pointee ownership_retrn_type_pointee;
        typedef typename OWNERSHIP_POLICY::template return_type<T>::type_ref ownership_retrn_type_ref;
        // @endcond 
        //Operators that will force exclusive pointer
        inline ownership_retrn_type_pointee operator->() 
        {
                m_ownership_policy.pointee_lock_policy(m_type);
                CHECKING_POLICY::on_dereference(m_type);
                return m_ownership_policy.get_non_constant_ptr(m_type, m_clone_fct);
        }
        inline ownership_retrn_type_ref operator*() 
        {
                m_ownership_policy.pointee_lock_policy(m_type);
                CHECKING_POLICY::on_dereference(m_type);
                return *m_ownership_policy.get_non_constant_ptr(m_type, m_clone_fct);
        }
        inline ownership_retrn_type_pointee operator->()const {
                m_ownership_policy.const_pointee_lock_policy(m_type);
                CHECKING_POLICY::on_const_dereference(m_type);
                return m_type;
        }
        inline ownership_retrn_type_ref operator*() const {
                m_ownership_policy.const_pointee_lock_policy(m_type);
                CHECKING_POLICY::on_const_dereference(m_type);
                return *m_type;
        }
#else
        //Operators that will force exclusive pointer
        inline T* operator->() 
        {
                m_ownership_policy.pointee_lock_policy(m_type);
                CHECKING_POLICY::on_dereference(m_type);
                return m_ownership_policy.get_non_constant_ptr(m_type, m_clone_fct);
        }
        inline T& operator*() 
        {
                m_ownership_policy.pointee_lock_policy(m_type);
                CHECKING_POLICY::on_dereference(m_type);
                return *m_ownership_policy.get_non_constant_ptr(m_type, m_clone_fct);
        }
        inline const T* operator->()const {
                m_ownership_policy.const_pointee_lock_policy(m_type);
                CHECKING_POLICY::on_const_dereference(m_type);
                return m_type;
        }
        inline const T& operator*() const {
                m_ownership_policy.const_pointee_lock_policy(m_type);
                CHECKING_POLICY::on_const_dereference(m_type);
                return *m_type;
        }
#endif //SMART_PTR_SUPPORT_RETURN_TYPE_THROUGH_POLICY_


        void lock() const {if (m_type) m_ownership_policy.lock(m_type);}
        void unlock() const {if (m_type) m_ownership_policy.unlock(m_type);}
        void trylock() const {if (m_type) m_ownership_policy.trylock(m_type);}
        void islock() const {if (m_type) m_ownership_policy.islock(m_type);}// Should only be used with trylock


        static void set_default_object(const smart_ptr& NewValue){get_or_set_default_object(&NewValue);}
        template<class T2>      smart_ptr& equal(const T2& Src){
                (*get_ptr()) = (Src);
                return *this;
        }
        clone_fct_Type get_function_ptr()const{return m_clone_fct;}
        void swap(smart_ptr<T> & other)throw(){std::swap(m_ownership_policy, other.m_ownership_policy);std::swap(m_type, other.m_type);std::swap(m_clone_fct, other.m_clone_fct);}
        template<class PT, class FPT>   void make_clone(PT*& ptr, FPT& func_ptr) const
        {
                if (m_type && m_clone_fct)
                {
                        ptr = m_clone_fct(m_type, true, NULL, NULL, NULL);
                        func_ptr = (FPT)m_clone_fct;
                }
                else
                        ptr = NULL;
        }


        inline T* get_ptr(){return m_ownership_policy.get_non_constant_ptr(m_type, m_clone_fct);}
        inline const T* c_ptr()const{return  m_type;}
        inline const T& c_ref()const{return  *m_type;}

        // @cond INCLUDE_ALL_OBJS_
        typedef COMPARISON_SEMANTIC_POLICY comparison_semantic_policy_type;
        typedef T* pointer;
        typedef T& reference;
        // @endcond 
private:
#if !defined(_MSC_VER) || (_MSC_VER > 1200)
/*
Note#1:
The constructor_and_destructor_allocator_function function has three extra arguments that are not used.  These arguments are not required at all in more compliant compilers
like VC++ 7.x and GNU 3.x.  However, for none compliant (pre-standard) compilers like VC++ 6.0 and BCC55, the extra argument declaration is required
so as to be able to fully qualify the function template type.  The argument declarations are needed for these compilers, but the actual argument variables
are not needed.  Anything pass to these last three arguments is discarded.
*/
        template < typename TT, typename DT, typename AL> static TT * constructor_and_destructor_allocator_function( TT *  ptr, bool bConstruct, DT*, AL* , void*) 
        {
                if (!ptr) return NULL;
                if (bConstruct){return AL::allocate(static_cast<const DT*>(ptr));}
                AL::deallocate(ptr);
                return NULL;
        } 
        template<typename T_obj>
                inline static   clone_fct_Type get_alloc_func(T_obj*)
        {
                T * ( *tmp ) (T *, bool, T_obj*, ALLOCATOR_POLICY*, void*) = constructor_and_destructor_allocator_function<T,T_obj,ALLOCATOR_POLICY>;
                return (clone_fct_Type)tmp;
        }
#else
        template<typename T_obj>
                inline static   clone_fct_Type get_alloc_func(T_obj*)
        {
                T * ( *tmp ) (T *, bool, T_obj*, ALLOCATOR_POLICY*, void*) = constructor_and_destructor_allocator_function<T,T_obj,ALLOCATOR_POLICY>;
                if (!tmp) constructor_and_destructor_allocator_function((T*)NULL, false, (T_obj*)NULL, (ALLOCATOR_POLICY*)NULL, NULL);
                return (clone_fct_Type)tmp;
        }
#endif //_MSC_VER noteq 1200

        static smart_ptr& get_or_set_default_object(const smart_ptr* NewValue = NULL)
        {
                static smart_ptr DefaultObj(eNo);
                if (NewValue && NewValue->m_type)
                        DefaultObj = *NewValue;
                return DefaultObj;
        }

#if !defined(_MSC_VER) || (_MSC_VER > 1200)
        template<class T1> friend bool operator==(const smart_ptr & a, const T1 & b){return T1::comparison_semantic_policy_type::is_equal(a,b);}
        template<class T1> friend bool operator!=(const smart_ptr & a, const T1 & b){return !T1::comparison_semantic_policy_type::is_equal(a,b);}
        template<class T1> friend bool operator> (const smart_ptr & a, const T1 & b){return T1::comparison_semantic_policy_type::greater_than(a,b);}
        template<class T1> friend bool operator< (const smart_ptr & a, const T1 & b){return T1::comparison_semantic_policy_type::less_than(a,b);}
        template<class T1> friend bool operator>=(const smart_ptr & a, const T1 & b){return T1::comparison_semantic_policy_type::greater_than_or_equal(a,b);}
        template<class T1> friend bool operator<=(const smart_ptr & a, const T1 & b){return T1::comparison_semantic_policy_type::less_than_or_equal(a,b);}
#else //Can not support exchangeable comparison in VC++ 6.0 
        friend inline bool operator==(const smart_ptr & a, const smart_ptr & b){return COMPARISON_SEMANTIC_POLICY::is_equal(a,b);}
        friend inline bool operator!=(const smart_ptr & a, const smart_ptr & b){return !COMPARISON_SEMANTIC_POLICY::is_equal(a,b);}
        friend inline bool operator< (const smart_ptr & a, const smart_ptr & b){return COMPARISON_SEMANTIC_POLICY::less_than(a,b);}
        friend inline bool operator> (const smart_ptr & a, const smart_ptr & b){return COMPARISON_SEMANTIC_POLICY::greater_than(a,b);}
        friend inline bool operator<=(const smart_ptr & a, const smart_ptr & b){return COMPARISON_SEMANTIC_POLICY::less_than_or_equal(a,b);}
        friend inline bool operator>=(const smart_ptr & a, const smart_ptr & b){return COMPARISON_SEMANTIC_POLICY::greater_than_or_equal(a,b);}
#endif //not defined(_MSC_VER) || (_MSC_VER > 1200)

#if __GNUC__ == 2 && __GNUC_MINOR__ <= 96
// Resolve the ambiguity between our op!= and the one in rel_ops
        template<class T> friend bool operator!=(const smart_ptr<T> & a, const smart_ptr<T> & b){return !COMPARISON_SEMANTIC_POLICY::is_equal(a,b);}
#endif

        template<class T1> T1& input_stream(T1 &is){return STREAM_OP_SEMANTIC_POLICY::input_stream(is, *this);}
        template<class T1> T1& output_stream(T1 &io) const {return STREAM_OP_SEMANTIC_POLICY::output_stream(io, *this);}

        template<class TS> inline friend TS& operator >>(TS &is,smart_ptr &obj){return obj.input_stream(is);}
        template<class TS> inline friend TS& operator <<(TS &io,const smart_ptr &obj){return obj.output_stream(io);}

};

// @cond INCLUDE_ALL_OBJS_

//The following smart_ptr_type, allows typedef declarations for certain types
//Example:
//typedef smart_ptr_type<copy_on_write_policy<ref_link_policy, intrusive_lock_policy> > MyCowSyncSmartPtr;
//MyCowSyncSmartPtr::to<Shape>::type pShape1;
template< 
//Available OWNERSHIP_POLICY policies:                          shared_ptr_policy<ref_link_policy>, copy_on_write_policy<ref_link_policy>, deep_copy_policy, shared_ptr_policy<ref_count_policy>, copy_on_write_policy<ref_count_policy>, shared_ptr_policy<ref_intrusive_policy>, copy_on_write_policy<ref_intrusive_policy>
class OWNERSHIP_POLICY = ownership_default_policy , 
        //Available ALLOCATOR_POLICY policies:                          allocator_default_policy, clone_function_allocator_policy, clone_static_function_allocator_policy
class ALLOCATOR_POLICY =  allocator_default_policy,
        //Available CHECKING_POLICY policies:                           no_checking_policy, boost_assert_checking_policy
class CHECKING_POLICY =  checking_default_policy,
        //Available COMPARISON_SEMANTIC_POLICY policies:        value_comparsion_semantic_policy, pointer_comparsion_semantic_policy, no_comparsion_semantic_policy 
class COMPARISON_SEMANTIC_POLICY = comparison_default_policy,
        //Available STREAM_OP_SEMANTIC_POLICY policies:         value_stream_operator_semantic_policy, no_stream_operator_semantic_policy  (Not supported on VC++6.0)
class STREAM_OP_SEMANTIC_POLICY = stream_default_policy,
        //Available ARITHMETIC_SEMANTIC_POLICY policies:        no_arithmetic_semantic_policy, value_arithmetic_semantic_policy  (Not support for non-compliant compilers like VC++6.0 and BCC55)
class ARITHMETIC_SEMANTIC_POLICY = arithmetic_default_policy>
struct smart_ptr_type
{//Future version of this class will have struct 'to' removed, and ptr_to, might get renamed to 'to'
        template<class T> struct to{typedef smart_ptr<T, OWNERSHIP_POLICY, ALLOCATOR_POLICY, CHECKING_POLICY, COMPARISON_SEMANTIC_POLICY, STREAM_OP_SEMANTIC_POLICY, ARITHMETIC_SEMANTIC_POLICY> type;};
        template<class T> struct ptr_to : public smart_ptr<T, OWNERSHIP_POLICY, ALLOCATOR_POLICY, CHECKING_POLICY, COMPARISON_SEMANTIC_POLICY, STREAM_OP_SEMANTIC_POLICY, ARITHMETIC_SEMANTIC_POLICY>{};
        template<class T1> inline smart_ptr_type(T1 &t1): smart_ptr(t1){}
};


struct smart_ptr_policies  //Common policies
{
        typedef smart_ptr_type<copy_on_write_policy<ref_link_policy, intrusive_lock_policy> >   cow_sync_ptr; 
        typedef smart_ptr_type<deep_copy_policy<intrusive_lock_policy> >                                                copy_sync_ptr; 
        typedef smart_ptr_type<shared_ptr_policy<ref_link_policy, intrusive_lock_policy> >              shared_sync_ptr; 
        typedef smart_ptr_type<copy_on_write_policy<ref_link_policy> >                                                  cow_ptr; 
        typedef smart_ptr_type<deep_copy_policy<> >                                                                                             copy_ptr; 
        typedef smart_ptr_type<shared_ptr_policy<ref_link_policy> >                                                             shared_ptr; 
};
// @endcond 

#endif //not smart_ptr_HPP_HEADER_GUARD_

---