sync_ptr.hpp

// sync_ptr.h 

#ifndef SYNC_PTR_H_BY_DAVID_MAISONAVE_HEADER_GUARD_
#define SYNC_PTR_H_BY_DAVID_MAISONAVE_HEADER_GUARD_

#include <memory>
#include "sync_ctrl.h"  //download at http://code.axter.com/sync_ctrl.h

template<class T, class SYNC_T = sync_ctrl_default, class AX_TYPE = std::allocator<T>, class AX_SYNC_CTRL = std::allocator<SYNC_T> >
class sync_ptr
{
protected:
        sync_ptr(T* type, SYNC_T *sync_ctrl_, int* RefCount_)
                :m_type(type), m_sync_ctrl(sync_ctrl_), m_RefCount(RefCount_)
        {
                m_sync_ctrl->lock();
                ++(*m_RefCount);
                m_sync_ctrl->unlock();
        }
public:
        sync_ptr(T* type, SYNC_T *sync_ctrl_ = new SYNC_T)
                :m_type(type), m_sync_ctrl(sync_ctrl_), m_RefCount(new int(1)){}
        virtual ~sync_ptr()
        {
                m_sync_ctrl->lock();
                if (m_RefCount) --(*m_RefCount);
                if (!m_RefCount || !(*m_RefCount))
                {
                        AX_TYPE alloc;
                        alloc.destroy(m_type);
                        alloc.deallocate(m_type, 1);
                        m_type=NULL;
                        if (m_RefCount) {delete m_RefCount;m_RefCount=NULL;}
                }
                m_sync_ctrl->unlock();
                if (!m_RefCount)
                {
                        AX_SYNC_CTRL alloc;
                        alloc.destroy(m_sync_ctrl);
                        alloc.deallocate(m_sync_ctrl, 1);
                }
        }
        class RefLockPtr
        {
                struct RefData{
                        int m_RefCount;
                        T* m_type;
                        SYNC_T *m_sync_ctrl;
                        bool *m_trylock_stat;
                };
                public:
                        friend class sync_ptr<T, SYNC_T, AX_TYPE, AX_SYNC_CTRL>;
                        RefLockPtr(const RefLockPtr& Src):m_RefData(Src.m_RefData)
                        {
                                ++m_RefData->m_RefCount;
                        }
                        ~RefLockPtr()
                        {
                                --m_RefData->m_RefCount;
                                if (!m_RefData->m_RefCount)
                                {
                                        if (!m_RefData->m_trylock_stat || (*m_RefData->m_trylock_stat)) 
                                        {
                                                m_RefData->m_sync_ctrl->unlock();
                                        }
                                        delete m_RefData;
                                        m_RefData=NULL;
                                }
                        }
                        T* operator->() const{return get_ptr();}
                        T& operator*() const{return *get_ptr();}
                        bool islocked()const{
                                if (!m_RefData->m_trylock_stat || (*m_RefData->m_trylock_stat)) return true;
                                return false;
                        }
                protected:
                        RefLockPtr(T* type, SYNC_T *sync_ctrl_, bool *trylock_stat = NULL)
                                :m_RefData(new RefData)
                        {
                                m_RefData->m_RefCount = 1;
                                m_RefData->m_type = type;
                                m_RefData->m_sync_ctrl = sync_ctrl_;
                                m_RefData->m_trylock_stat = trylock_stat;
                                if(m_RefData->m_trylock_stat)
                                {
                                        *m_RefData->m_trylock_stat = m_RefData->m_sync_ctrl->trylock();
                                }
                                else m_RefData->m_sync_ctrl->lock();
                        }
                        T* get_ptr()const
                        {
                                if (!m_RefData->m_trylock_stat || (*m_RefData->m_trylock_stat)) return m_RefData->m_type;
                                return NULL;
                        }
                        RefLockPtr& operator=(const RefLockPtr&);
                        RefData *m_RefData;
        };
        RefLockPtr operator->(){return RefLockPtr(m_type, m_sync_ctrl);}
        RefLockPtr operator*(){return RefLockPtr(m_type, m_sync_ctrl);}
        //T& operator*() {return (*RefLockPtr(m_type, m_sync_ctrl));}
        RefLockPtr get_locked_obj(bool *trylock_stat = NULL){return RefLockPtr(m_type, m_sync_ctrl, trylock_stat);}
        protected:
                sync_ptr& operator=(const sync_ptr&);
                sync_ptr(const sync_ptr& Src);
                bool operator==(const sync_ptr&);
                bool operator!=(const sync_ptr&);
                // Data members
                T* m_type;
                SYNC_T *m_sync_ctrl;
                int *m_RefCount;
};

template<class T, class SYNC_T = sync_ctrl_default, class AX_TYPE = std::allocator<T>, class AX_SYNC_CTRL = std::allocator<SYNC_T> >
class sync_ref_ptr : public sync_ptr<T, SYNC_T, AX_TYPE, AX_SYNC_CTRL>
{
public:
        sync_ref_ptr(const sync_ref_ptr& Src)
                :sync_ptr<T, SYNC_T, AX_TYPE, AX_SYNC_CTRL>(Src.m_type, Src.m_sync_ctrl, Src.m_RefCount){}
        sync_ref_ptr(T* type, SYNC_T *sync_ctrl_ = new SYNC_T)
                :sync_ptr<T, SYNC_T, AX_TYPE, AX_SYNC_CTRL>(type, sync_ctrl_){}
private:
        sync_ref_ptr& operator=(const sync_ref_ptr&);
        bool operator==(const sync_ref_ptr&);
        bool operator!=(const sync_ref_ptr&);
};

#endif 

---