RefPtr.h

Go to the documentation of this file.

/*
    ------------------------------------------------------------------------------------
    LICENSE:
    ------------------------------------------------------------------------------------
    This file is part of EVEmu: EVE Online Server Emulator
    Copyright 2006 - 2021 The EVEmu Team
    For the latest information visit https://evemu.dev
    ------------------------------------------------------------------------------------
    This program is free software; you can redistribute it and/or modify it under
    the terms of the GNU Lesser General Public License as published by the Free Software
    Foundation; either version 2 of the License, or (at your option) any later
    version.

    This program is distributed in the hope that it will be useful, but WITHOUT
    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
    FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details.

    You should have received a copy of the GNU Lesser General Public License along with
    this program; if not, write to the Free Software Foundation, Inc., 59 Temple
    Place - Suite 330, Boston, MA 02111-1307, USA, or go to
    http://www.gnu.org/copyleft/lesser.txt.
    ------------------------------------------------------------------------------------
    Author:     Bloody.Rabbit
    Update:     Allan
*/

#ifndef __UTILS__REF_PTR_H__INCL__
#define __UTILS__REF_PTR_H__INCL__


#include <cassert>
#include <cstdio>
#include <iostream>

#include "utils/misc.h"

class RefObject
{
    template<typename X>
    friend class RefPtr;

public:
    RefObject( size_t initRefCount )
    : mRefCount( initRefCount )
    {
        mDeleted = false;
    }

    virtual ~RefObject()
    {
        // this isnt completely accurate yet.  disable to avoid crashes i cant trace 
        //assert( mRefCount == 0);
        mDeleted = true;
    }

    size_t GetCount()           { return mRefCount; }

protected:
    void IncRef() const
    {
        if (mDeleted) {
            _log(REFPTR__ERROR, "IncRef() - mDeleted = true.  Count is %u", mRefCount);
            EvE::traceStack();
            return;
        }
        assert( mDeleted == false );
        ++mRefCount;
        //assert( mRefCount > 0 );  // RefPtr objects are created with a ref count of 0, then incremented during RefPtr c'tor
        //_log(REFPTR__INC, "IncRef() is %u.", mRefCount);
    }
    void DecRef() const
    {
        if (mDeleted) {
            _log(REFPTR__ERROR, "DecRef() - mDeleted = true.  Count is %u", mRefCount);
            EvE::traceStack();
            return;
        }

        assert( mDeleted == false );
        assert( mRefCount > 0 );
        --mRefCount;
        //_log(REFPTR__DEC, "DecRef() is %u.", mRefCount);

        if (mRefCount < 1)
            delete this;
    }

    mutable size_t mRefCount;
    mutable bool mDeleted;
};

template<typename X>
class RefPtr
{
public:
    explicit RefPtr( X* p = nullptr)
    : mPtr( p )
    {
        if (*this)
            (*this)->IncRef();
    }
    RefPtr( const RefPtr& oth )
    : mPtr( oth.get() )
    {
        if (*this)
            (*this)->IncRef();
    }
    template<typename Y>
    RefPtr( const RefPtr<Y>& oth )
    : mPtr( oth.get() )
    {
        if (*this)
            (*this)->IncRef();
    }

    virtual ~RefPtr()
    {
        if (*this)
            (*this)->DecRef();
    }

    RefPtr& operator=( const RefPtr& oth )
    {
        if (*this)
            (*this)->DecRef();
        mPtr = oth.get();
        if (*this)
            (*this)->IncRef();
        return *this;
    }
    template<typename Y>
    RefPtr& operator=( const RefPtr<Y>& oth )
    {
        if (*this)
            (*this)->DecRef();
        mPtr = oth.get();
        if (*this)
            (*this)->IncRef();
        return *this;
    }

    X* get() const { return mPtr; }

    operator bool() const { return ( mPtr != nullptr ); }

    X& operator*() const { assert( *this ); return *mPtr; }
    X* operator->() const { assert( *this ); return mPtr; }

    template<typename Y>
    bool operator==( const RefPtr<Y>& oth ) const
    {
        return ( mPtr == oth.get() );
    }

    template<typename Y>
    static RefPtr StaticCast( const RefPtr<Y>& oth )
    {
        return RefPtr( static_cast<X*>( oth.get() ) );
    }

protected:
    X* mPtr;
};

#endif /* !__UTILS__REF_PTR_H__INCL__ */