smartptr.h

Go to the documentation of this file.

/*
 *  Original work: Copyright (c) 2014, Oculus VR, Inc.
 *  All rights reserved.
 *
 *  This source code is licensed under the BSD-style license found in the
 *  RakNet License.txt file in the licenses directory of this source tree. An additional grant 
 *  of patent rights can be found in the RakNet Patents.txt file in the same directory.
 *
 *
 *  Modified work: Copyright (c) 2017, SLikeSoft UG (haftungsbeschränkt)
 *
 *  This source code was modified by SLikeSoft. Modifications are licensed under the MIT-style
 *  license found in the license.txt file in the root directory of this source tree.
 */

#ifndef __RAKNET_SMART_PTR_H
#define __RAKNET_SMART_PTR_H

// From http://www.codeproject.com/KB/cpp/SmartPointers.aspx
// with bugs fixed

#include "memoryoverride.h"
#include "Export.h"

//static int allocCount=0;
//static int deallocCount=0;

namespace SLNet
{

class RAK_DLL_EXPORT ReferenceCounter
{
private:
    int refCount;

public:
    ReferenceCounter() {refCount=0;}
    ~ReferenceCounter() {}
    void AddRef() {refCount++;}
    int Release() {return --refCount;}
    int GetRefCount(void) const {return refCount;}
};

template < typename T > class RAK_DLL_EXPORT RakNetSmartPtr
{
private:
    T*    ptr;       // pointer
    ReferenceCounter* reference; // Reference refCount

public:
    RakNetSmartPtr() : ptr(0), reference(0)
    {
        // Do not allocate by default, wasteful if we just have a list of preallocated and unassigend smart pointers
    }

    RakNetSmartPtr(T* pValue) : ptr(pValue)
    {
        reference = SLNet::OP_NEW<ReferenceCounter>(_FILE_AND_LINE_);
        reference->AddRef();

//      allocCount+=2;
//      printf("allocCount=%i deallocCount=%i Line=%i\n",allocCount, deallocCount, __LINE__);
    }

    RakNetSmartPtr(const RakNetSmartPtr<T>& sp) : ptr(sp.ptr), reference(sp.reference)
    {
        if (reference)
            reference->AddRef();
    }

    ~RakNetSmartPtr()
    {
        if(reference && reference->Release() == 0)
        {
            SLNet::OP_DELETE(ptr, _FILE_AND_LINE_);
            SLNet::OP_DELETE(reference, _FILE_AND_LINE_);

//          deallocCount+=2;
//          printf("allocCount=%i deallocCount=%i Line=%i\n",allocCount, deallocCount, __LINE__);
        }
    }

    bool IsNull(void) const
    {
        return ptr==0;
    }

    void SetNull(void)
    {
        if(reference && reference->Release() == 0)
        {
            SLNet::OP_DELETE(ptr, _FILE_AND_LINE_);
            SLNet::OP_DELETE(reference, _FILE_AND_LINE_);

//          deallocCount+=2;
//          printf("allocCount=%i deallocCount=%i Line=%i\n",allocCount, deallocCount, __LINE__);
        }
        ptr=0;
        reference=0;
    }

    bool IsUnique(void) const
    {
        return reference->GetRefCount()==1;
    }

    // Allow you to change the values of the internal contents of the pointer, without changing what is pointed to by other instances of the smart pointer
    void Clone(bool copyContents)
    {
        if (IsUnique()==false)
        {
            reference->Release();

            reference = SLNet::OP_NEW<ReferenceCounter>(_FILE_AND_LINE_);
            reference->AddRef();
            T* oldPtr=ptr;
            ptr= SLNet::OP_NEW<T>(_FILE_AND_LINE_);
            if (copyContents)
                *ptr=*oldPtr;
        }
    }

    int GetRefCount(void) const
    {
        return reference->GetRefCount();
    }

    T& operator* ()
    {
        return *ptr;
    }

    const T& operator* () const
    {
        return *ptr;
    }

    T* operator-> ()
    {
        return ptr;
    }

    const T* operator-> () const
    {
        return ptr;
    }

    bool operator == (const RakNetSmartPtr<T>& sp)
    {
        return ptr == sp.ptr;
    }
    bool operator<( const RakNetSmartPtr<T> &right ) {return ptr < right.ptr;}
    bool operator>( const RakNetSmartPtr<T> &right ) {return ptr > right.ptr;}

    bool operator != (const RakNetSmartPtr<T>& sp)
    {
        return ptr != sp.ptr;
    }

    RakNetSmartPtr<T>& operator = (const RakNetSmartPtr<T>& sp)
    {
        // Assignment operator

        if (this != &sp) // Avoid self assignment
        {
            if(reference && reference->Release() == 0)
            {
                SLNet::OP_DELETE(ptr, _FILE_AND_LINE_);
                SLNet::OP_DELETE(reference, _FILE_AND_LINE_);

//              deallocCount+=2;
//              printf("allocCount=%i deallocCount=%i Line=%i\n",allocCount, deallocCount, __LINE__);
            }

            ptr = sp.ptr;
            reference = sp.reference;
            if (reference)
                reference->AddRef();
        }
        return *this;
    }


};

} // namespace SLNet

#endif