nekohook/modules/source2013/sdk/mathlib/public/tier1/smartptr.h

//========= Copyright Valve Corporation, All rights reserved. ============//
//
// Purpose:
//
// $NoKeywords: $
//=============================================================================//

#ifndef SMARTPTR_H
#define SMARTPTR_H
#ifdef _WIN32
#pragma once
#endif

class CRefCountAccessor {
   public:
    template <class T>
    static void AddRef(T *pObj) {
        pObj->AddRef();
    }

    template <class T>
    static void Release(T *pObj) {
        pObj->Release();
    }
};

// This can be used if your objects use AddReference/ReleaseReference function
// names.
class CRefCountAccessorLongName {
   public:
    template <class T>
    static void AddRef(T *pObj) {
        pObj->AddReference();
    }

    template <class T>
    static void Release(T *pObj) {
        pObj->ReleaseReference();
    }
};

//
//	CPlainAutoPtr
//		is a smart wrapper for a pointer on the stack that performs
//"delete" upon destruction.
//
//	No reference counting is performed, copying is prohibited "s_p2.Attach(
//s_p1.Detach() )" should be used 	for readability and ease of maintenance.
//
//	Auto pointer supports an "arrow" operator for invoking methods on the
//pointee and a "dereference" operator 	for getting a pointee reference.
//
//	No automatic casting to bool/ptrtype is performed to avoid bugs and
//problems (read on "safe bool idiom" 	if casting to bool or pointer happens to
//be useful).
//
//	Test for validity with "IsValid", get the pointer with "Get".
//
template <typename T>
class CPlainAutoPtr {
   public:
    explicit CPlainAutoPtr(T *p = NULL) : m_p(p) {}
    ~CPlainAutoPtr(void) { Delete(); }

   public:
    void Delete(void) { delete Detach(); }

   private:  // Disallow copying, use Detach() instead to avoid ambiguity
    CPlainAutoPtr(CPlainAutoPtr const &x);
    CPlainAutoPtr &operator=(CPlainAutoPtr const &x);

   public:
    void Attach(T *p) { m_p = p; }
    T *Detach(void) {
        T *p(m_p);
        m_p = NULL;
        return p;
    }

   public:
    bool IsValid(void) const { return m_p != NULL; }
    T *Get(void) const { return m_p; }
    T *operator->(void)const { return Get(); }
    T &operator*(void)const { return *Get(); }

   private:
    T *m_p;
};

//
//	CArrayAutoPtr
//		is a smart wrapper for an array pointer on the stack that performs
//"delete []" upon destruction.
//
//	No reference counting is performed, copying is prohibited "s_p2.Attach(
//s_p1.Detach() )" should be used 	for readability and ease of maintenance.
//
//	Auto pointer supports an "indexing" operator for accessing array
//elements.
//
//	No automatic casting to bool/ptrtype is performed to avoid bugs and
//problems (read on "safe bool idiom" 	if casting to bool or pointer happens to
//be useful).
//
//	Test for validity with "IsValid", get the array pointer with "Get".
//
template <typename T>
class CArrayAutoPtr
    : public CPlainAutoPtr<T>  // Warning: no polymorphic destructor (delete on
                               // base class will be a mistake)
{
   public:
    explicit CArrayAutoPtr(T *p = NULL) { this->Attach(p); }
    ~CArrayAutoPtr(void) { this->Delete(); }

   public:
    void Delete(void) { delete[] CPlainAutoPtr<T>::Detach(); }

   public:
    T &operator[](int k) const { return CPlainAutoPtr<T>::Get()[k]; }
};

// Smart pointers can be used to automatically free an object when nobody points
// at it anymore. Things contained in smart pointers must implement AddRef and
// Release functions. If those functions are private, then the class must make
// CRefCountAccessor a friend.
template <class T, class RefCountAccessor = CRefCountAccessor>
class CSmartPtr {
   public:
    CSmartPtr();
    CSmartPtr(T *pObj);
    CSmartPtr(const CSmartPtr<T, RefCountAccessor> &other);
    ~CSmartPtr();

    T *operator=(T *pObj);
    void operator=(const CSmartPtr<T, RefCountAccessor> &other);
    const T *operator->() const;
    T *operator->();
    bool operator!() const;
    bool operator==(const T *pOther) const;
    bool IsValid() const;  // Tells if the pointer is valid.
    T *GetObject()
        const;  // Get temporary object pointer, don't store it for later reuse!
    void MarkDeleted();

   private:
    T *m_pObj;
};

template <class T, class RefCountAccessor>
inline CSmartPtr<T, RefCountAccessor>::CSmartPtr() {
    m_pObj = NULL;
}

template <class T, class RefCountAccessor>
inline CSmartPtr<T, RefCountAccessor>::CSmartPtr(T *pObj) {
    m_pObj = NULL;
    *this = pObj;
}

template <class T, class RefCountAccessor>
inline CSmartPtr<T, RefCountAccessor>::CSmartPtr(
    const CSmartPtr<T, RefCountAccessor> &other) {
    m_pObj = NULL;
    *this = other;
}

template <class T, class RefCountAccessor>
inline CSmartPtr<T, RefCountAccessor>::~CSmartPtr() {
    if (m_pObj) {
        RefCountAccessor::Release(m_pObj);
    }
}

template <class T, class RefCountAccessor>
inline T *CSmartPtr<T, RefCountAccessor>::operator=(T *pObj) {
    if (pObj == m_pObj) return pObj;

    if (pObj) {
        RefCountAccessor::AddRef(pObj);
    }
    if (m_pObj) {
        RefCountAccessor::Release(m_pObj);
    }
    m_pObj = pObj;
    return pObj;
}

template <class T, class RefCountAccessor>
inline void CSmartPtr<T, RefCountAccessor>::MarkDeleted() {
    m_pObj = NULL;
}

template <class T, class RefCountAccessor>
inline void CSmartPtr<T, RefCountAccessor>::operator=(
    const CSmartPtr<T, RefCountAccessor> &other) {
    *this = other.m_pObj;
}

template <class T, class RefCountAccessor>
inline const T *CSmartPtr<T, RefCountAccessor>::operator->() const {
    return m_pObj;
}

template <class T, class RefCountAccessor>
inline T *CSmartPtr<T, RefCountAccessor>::operator->() {
    return m_pObj;
}

template <class T, class RefCountAccessor>
inline bool CSmartPtr<T, RefCountAccessor>::operator!() const {
    return !m_pObj;
}

template <class T, class RefCountAccessor>
inline bool CSmartPtr<T, RefCountAccessor>::operator==(const T *pOther) const {
    return m_pObj == pOther;
}

template <class T, class RefCountAccessor>
inline bool CSmartPtr<T, RefCountAccessor>::IsValid() const {
    return m_pObj != NULL;
}

template <class T, class RefCountAccessor>
inline T *CSmartPtr<T, RefCountAccessor>::GetObject() const {
    return m_pObj;
}

//
// CAutoPushPop
//				allows you to set value of a variable upon
//construction and destruction.
// Constructors:
//		CAutoPushPop x( myvar )
//			saves the value and restores upon destruction.
//		CAutoPushPop x( myvar, newvalue )
//			saves the value, assigns new value upon construction,
//restores saved value upon destruction. 		CAutoPushPop x( myvar, newvalue,
//restorevalue ) 			assigns new value upon construction, assignes restorevalue upon
//destruction.
//
template <typename T>
class CAutoPushPop {
   public:
    explicit CAutoPushPop(T &var) : m_rVar(var), m_valPop(var) {}
    CAutoPushPop(T &var, T const &valPush) : m_rVar(var), m_valPop(var) {
        m_rVar = valPush;
    }
    CAutoPushPop(T &var, T const &valPush, T const &valPop)
        : m_rVar(var), m_valPop(var) {
        m_rVar = valPush;
    }

    ~CAutoPushPop() { m_rVar = m_valPop; }

   private:  // forbid copying
    CAutoPushPop(CAutoPushPop const &x);
    CAutoPushPop &operator=(CAutoPushPop const &x);

   public:
    T &Get() { return m_rVar; }

   private:
    T &m_rVar;
    T m_valPop;
};

#endif  // SMARTPTR_H