H:/gfcppsancout/product/include/gfcpp/SharedPtr.hpp

Go to the documentation of this file.

#ifndef _GEMFIRE_SHAREDPTR_HPP_
#define _GEMFIRE_SHAREDPTR_HPP_

/*=========================================================================
 * (c) Copyright 2004-2007, GemStone Systems, Inc. All Rights Reserved.
 * 1260 NW Waterhouse Ave Suite 200, Beaverton OR 97006.
 *=========================================================================
 */

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

namespace gemfire {

class CPPCACHE_EXPORT SPEHelper 
{
  public:
  
  static void throwNullPointerException( const char* ename );

  static void throwClassCastException( const char* msg,
      const char* fromType, const char* toType );
};

#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

template<class Target>
class SharedPtr {

public:
  typedef Target* rawPtrType;

  inline SharedPtr()
    : m_ptr(NULL)
  {}

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

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

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

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

    m_ptr = NULL;
  }

  inline Target* operator -> () const
  {
    GF_CHECK_NPE( m_ptr );
    GF_DEV_ASSERT( 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)
      other->preserveSB();

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

    m_ptr = other;

    return *this;
  }

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

    if ( NULL != otherPtr ) {
      otherPtr->preserveSB( );
    }
    if ( NULL != m_ptr ) {
      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( );

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

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

    return *this;
  }

  template<class Other>
  inline SharedPtr& operator = (Other* other)
  {
    if ( NULL != other ) {
      other->preserveSB( );
    }
    if ( NULL != m_ptr ) {
      m_ptr->releaseSB( );
    }
    m_ptr = other;

    return *this;
  }

  template<class Other>
  inline SharedPtr& operator = (const Other* other)
  {
    if ( NULL != other ) {
      other->preserveSB( );
    }
    if ( NULL != m_ptr ) {
      m_ptr->releaseSB( );
    }
    m_ptr = other;

    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 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:

  Target* m_ptr;

};

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 NULL;
  } 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 NULL;
  }
}

}

#endif

---