RefPointer.h

/*******************************************************************************
 * Copyright (c) 2024, 2026, Olivier Ayache.  All rights reserved.
 *
 * This file is part of AVPKit.
 *
 * AVPKit 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 3 of the License, or
 * (at your option) any later version.
 *
 * AVPKit 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 AVPKit.  If not, see <http://www.gnu.org/licenses/>.
 *******************************************************************************/
 
#ifndef REFPOINTER_H_
#define REFPOINTER_H_
 
#ifdef VS_DEBUG
#include <assert.h>
#endif
#include <com/avpkit/ferry/RefCounted.h>
namespace com { namespace avpkit { namespace ferry
  {
 
  template <class T> class RefPointer
  {
  public:
    RefPointer() : mPtr(0)
    {
    }
 
    RefPointer(T* ptr) : mPtr(ptr)
    {
    }
 
    RefPointer(const RefPointer& rPtr) : mPtr(rPtr.mPtr)
    {
      VS_REF_ACQUIRE(mPtr);
    }
    RefPointer(RefPointer& rPtr) : mPtr(rPtr.mPtr)
    {
      VS_REF_ACQUIRE(mPtr);
    }
 
    RefPointer& operator=(const RefPointer& rPtr)
    {
      reset(static_cast<T*>(rPtr.mPtr));
      VS_REF_ACQUIRE(mPtr);
      return *this;
    }
 
    RefPointer& operator=(RefPointer& rPtr)
    {
      reset(static_cast<T*>(rPtr.mPtr));
      VS_REF_ACQUIRE(mPtr);
      return *this;
    }
 
    RefPointer& operator=(T* ptr)
    {
      reset(ptr);
      return *this;
    }
 
    T* operator->() const
    {
      // we don't protect against a null defer here.
      return static_cast<T*>(mPtr);
    }
 
 
    operator bool()
    {
      return mPtr!=0;
    }
 
    virtual ~RefPointer()
    {
  #ifdef VS_DEBUG
      {
        if (mPtr)
        {
          // This check should never fail in a multi-thread
          // environment, even though the underlying
          // objects ref can change.
          // If the object is bad, this should cause
          // a READ error in memory tools
          int refCount = mPtr->getCurrentRefCount();
          assert(refCount >= 1);
        }
      }
  #endif // VS_DEBUG
      VS_REF_RELEASE(mPtr);
    }
 
    T* get()
    {
      VS_REF_ACQUIRE(mPtr);
      return static_cast<T*>(mPtr);
    }
 
    T* value()
    {
      return static_cast<T*>(mPtr);
    }
 
    void reset(T* ptr=0, bool acquire=false)
    {
      VS_REF_RELEASE(mPtr);
      mPtr = ptr;
      if (acquire)
        VS_REF_ACQUIRE(mPtr);
    }
  private:
    // And the underlying thing we manage.
    // Must derive from RefCounted; We used to keep
    // a RefCounted here, but it's much nicer to
    // a debugger if you keep the actual type here.
    T *mPtr;
  };
 
  }}}
 
#endif /*REFPOINTER_H_*/