SharedPtr.hpp

Go to the documentation of this file.

#ifndef _GEMFIRE_SHAREDPTR_HPP_
#define _GEMFIRE_SHAREDPTR_HPP_

/*=========================================================================
 * Copyright (c) 2004-2014 Pivotal Software, Inc. All Rights Reserved.
 * This product is protected by U.S. and international copyright
 * and intellectual property laws. Pivotal products are covered by
 * more patents listed at http://www.pivotal.io/patents.
 *=========================================================================
 */

#include "SharedBase.hpp"
#include "Assert.hpp"
#include "TypeHelper.hpp"
#include <typeinfo>
#include "SharedPtrHelper.hpp"

namespace gemfire {

#if GF_DEVEL_ASSERTS == 1
#define GF_CHECK_NPE(x) if ( x != NULL ) { } else gemfire::SPEHelper::throwNullPointerException( typeid( *this ).name() )
#else
#define GF_CHECK_NPE(x)
#endif

class MapEntry;
class MapEntryImpl;

template<class Target>
class SharedPtr
{

public:
  inline SharedPtr()
    : m_ptr(NULL)
  {}

  inline SharedPtr(const NullSharedBase* ptr)
    : m_ptr(NULL)
  {}

  inline explicit SharedPtr(const Target* ptr)
    : m_ptr(const_cast<Target *>(ptr))
  {
    if (NULL != m_ptr)
      getSB( m_ptr )->preserveSB();
  }

  inline SharedPtr(const SharedPtr& other)
    : m_ptr(other.m_ptr)
  {
    if (NULL != m_ptr)
      getSB( m_ptr )->preserveSB();
  }

  template<class Other>
  inline SharedPtr(const SharedPtr<Other>& other)
    : m_ptr( getTarget< Target >( other.ptr( ) ) )
  {
    if (NULL != m_ptr)
      getSB( m_ptr )->preserveSB();
  }

  inline ~SharedPtr()
  {
    if (NULL != m_ptr)
      getSB( m_ptr )->releaseSB();

    m_ptr = NULL;
  }

  inline Target* operator -> () const
  {
    GF_CHECK_NPE( m_ptr );
    GF_DEV_ASSERT( getSB( m_ptr )->refCount( ) > 0 );

    return m_ptr;
  }

  inline Target& operator * () const
  {
    GF_CHECK_NPE( m_ptr );
    return *m_ptr;
  }

  inline SharedPtr& operator = (Target * other)
  {
    if (NULL != other)
      getSB( other )->preserveSB();

    if (NULL != m_ptr)
      getSB( m_ptr )->releaseSB();

    m_ptr = other;

    return *this;
  }

  inline SharedPtr& operator = (const SharedPtr& other)
  {
    Target* otherPtr = other.m_ptr;

    if ( NULL != otherPtr ) {
      getSB( otherPtr )->preserveSB( );
    }
    if ( NULL != m_ptr ) {
      getSB( m_ptr )->releaseSB( );
    }
    m_ptr = otherPtr;

    GF_DEV_ASSERT( otherPtr == other.m_ptr );

    return *this;
  }

  template<class Other>
  inline SharedPtr& operator = (const SharedPtr<Other>& other)
  {
    Other* otherPtr = other.ptr( );

    Target* otherTargetPtr = getTarget< Target >( otherPtr );

    if ( NULL != otherPtr ) {
      getSB( otherPtr )->preserveSB( );
    }
    if ( NULL != m_ptr ) {
      getSB( m_ptr )->releaseSB( );
    }
    m_ptr = otherTargetPtr;

    GF_DEV_ASSERT( otherPtr == other.ptr( ) );

    return *this;
  }

  inline SharedPtr& operator = (const NullSharedBase* nullOther)
  {
    if (m_ptr != NULL) {
      getSB( m_ptr )->releaseSB();
    }
    m_ptr = NULL;
    return *this;
  }

  template<class Other>
  inline SharedPtr& operator = (Other* other)
  {
    Target* otherTargetPtr = getTarget< Target >( other );

    if ( NULL != other ) {
      getSB( other )->preserveSB( );
    }
    if ( NULL != m_ptr ) {
      getSB( m_ptr )->releaseSB( );
    }
    m_ptr = otherTargetPtr;

    return *this;
  }

  inline bool operator == (const Target* other) const
    { return m_ptr == other; }

  inline bool operator != (const Target* other) const
    { return m_ptr != other; }

  inline bool operator == (const NullSharedBase* nullOther) const
    { return m_ptr == NULL; }

  inline bool operator != (const NullSharedBase* nullOther) const
    { return m_ptr != NULL; }

  inline bool operator == (const SharedPtr& other) const
    { return m_ptr == other.m_ptr; }

  inline bool operator != (const SharedPtr& other) const
    { return m_ptr != other.m_ptr; }

  template<class Other>
  inline bool operator == (const SharedPtr<Other>& other)
  {
    return ((const void*)m_ptr) == ((const void*) other.ptr() );
  }

  template<class Other>
  inline bool operator != (const SharedPtr<Other>& other)
    { return ! operator == (other); }

  inline Target* ptr() const
  {
    return m_ptr;
  }


private:

  inline explicit SharedPtr(bool noInit)
  {}

  Target* m_ptr;

friend class MapEntry;
friend class MapEntryImpl;

};

typedef SharedPtr<SharedBase> SharedBasePtr;


template <class TargetSP, class Other>
TargetSP staticCast( const SharedPtr<Other>& other )
{
  GF_D_ASSERT( ( other.ptr( ) == NULL ) ||
      ( dynamic_cast<GF_UNWRAP_SP( TargetSP )*>( other.ptr( ) ) != NULL ) );

  return TargetSP( static_cast<GF_UNWRAP_SP( TargetSP )*>( other.ptr( ) ) );
}

template <class TargetSP, class Other>
TargetSP dynCast( const SharedPtr<Other>& other )
{
  GF_UNWRAP_SP( TargetSP )* otherPtr;

  if ( ( other.ptr( ) == NULL ) ) {
    return NULLPTR;
  } else if ( ( otherPtr = dynamic_cast<GF_UNWRAP_SP( TargetSP )*>
        ( other.ptr( ) ) ) != NULL ) {
    return TargetSP( otherPtr );
  } else {
    SPEHelper::throwClassCastException( "dynCast: cast failed",
        typeid( other ).name( ), typeid( TargetSP ).name( ) );
    return NULLPTR;
  }
}

template<class TargetSP, class Other>
bool instanceOf(const SharedPtr<Other>& other)
{
  return (dynamic_cast<GF_UNWRAP_SP(TargetSP)*> (other.ptr()) != NULL);
}

}

#endif