Teuchos_PtrDecl.hpp

// @HEADER
// *****************************************************************************
//                    Teuchos: Common Tools Package
//
// Copyright 2004 NTESS and the Teuchos contributors.
// SPDX-License-Identifier: BSD-3-Clause
// *****************************************************************************
// @HEADER
 
#ifndef TEUCHOS_PTR_DECL_HPP
#define TEUCHOS_PTR_DECL_HPP
 
 
#include "Teuchos_RCPDecl.hpp"
#include "Teuchos_dyn_cast.hpp"
 
 
namespace Teuchos {
 

template<class T>
class Ptr {
public:

  inline Ptr( ENull null_in = null );

  inline explicit Ptr( T *ptr );

  inline Ptr(const Ptr<T>& ptr);

  template<class T2>
  inline Ptr(const Ptr<T2>& ptr);

  Ptr<T>& operator=(const Ptr<T>& ptr);

  inline T* operator->() const;

  inline T& operator*() const;

  inline T* get() const;

  inline T* getRawPtr() const;

  inline bool is_null () const;

  inline const Ptr<T>& assert_not_null() const;

  inline const Ptr<T> ptr() const;

  inline Ptr<const T> getConst() const;
 
private:
 
  T *ptr_;
 
#ifdef TEUCHOS_DEBUG
  RCP<T> rcp_;
#endif
 
  void debug_assert_not_null() const
    {
#ifdef TEUCHOS_DEBUG
      assert_not_null();
#endif
    }
 
  inline void debug_assert_valid_ptr() const;
 
public: // Bad bad bad
 
#ifdef TEUCHOS_DEBUG
  Ptr( const RCP<T> &p );
  T* access_private_ptr() const
    { return ptr_; }
  const RCP<T> access_rcp() const
    { return rcp_; }
#endif
 
 
};
 

template<typename T> inline
Ptr<T> outArg( T& arg )
{
  return Ptr<T>(&arg);
}
 

template<typename T> inline
Ptr<T> inOutArg( T& arg )
{
  return Ptr<T>(&arg);
}
 

template<typename T> inline
Ptr<T> inoutArg( T& arg )
{
  return Ptr<T>(&arg);
}
 

template<typename T> inline
Ptr<const T> ptrInArg( T& arg )
{
  return Ptr<const T>(&arg);
}
 

template<typename T> inline
Ptr<T> optInArg( T& arg )
{
  return Ptr<T>(&arg);
}
 

template<typename T> inline
Ptr<const T> constOptInArg( T& arg )
{
  return Ptr<const T>(&arg);
}
 

template<typename T> inline
Ptr<T> ptrFromRef( T& arg )
{
  return Ptr<T>(&arg);
}
 

template<typename T> inline
RCP<T> rcpFromPtr( const Ptr<T>& ptr )
{
  if (is_null(ptr))
    return null;
#ifdef TEUCHOS_DEBUG
  // In a debug build, just grab out the WEAK RCP and return it.  That way we
  // can get dangling reference checking without having to turn on more
  // expensive RCPNode tracing.
  if (!is_null(ptr.access_rcp()))
    return ptr.access_rcp();
#endif
  return rcpFromRef(*ptr);
}
 

template<typename T> inline
Ptr<T> ptr( T* p )
{
  return Ptr<T>(p);
}
 

template<typename T> inline
Ptr<const T> constPtr( T& arg )
{
  return Ptr<const T>(&arg);
}
 

template<class T> inline
bool is_null( const Ptr<T> &p )
{
  return p.get() == 0;
}
 

template<class T> inline
bool nonnull( const Ptr<T> &p )
{
  return p.get() != 0;
}
 

template<class T> inline
bool operator==( const Ptr<T> &p, ENull )
{
  return p.get() == 0;
}
 

template<class T>
bool operator!=( const Ptr<T> &p, ENull )
{
  return p.get() != 0;
}
 

template<class T1, class T2>
bool operator==( const Ptr<T1> &p1, const Ptr<T2> &p2 )
{
  return p1.get() == p2.get();
}
 

template<class T1, class T2>
bool operator!=( const Ptr<T1> &p1, const Ptr<T2> &p2 )
{
  return p1.get() != p2.get();
}
 

template<class T2, class T1>
Ptr<T2> ptr_implicit_cast(const Ptr<T1>& p1)
{
  return Ptr<T2>(p1.get()); // Will only compile if conversion is legal!
}
 

template<class T2, class T1>
Ptr<T2> ptr_static_cast(const Ptr<T1>& p1)
{
  return Ptr<T2>(static_cast<T2*>(p1.get())); // Will only compile if conversion is legal!
}
 

template<class T2, class T1>
Ptr<T2> ptr_const_cast(const Ptr<T1>& p1)
{
  return Ptr<T2>(const_cast<T2*>(p1.get())); // Will only compile if conversion is legal!
}
 

template<class T2, class T1>
Ptr<T2> ptr_dynamic_cast(
  const Ptr<T1>& p1, bool throw_on_fail = false
  )
{
  if( p1.get() ) {
    T2 *check = NULL;
    if(throw_on_fail)
      check = &dyn_cast<T2>(*p1);
    else
      check = dynamic_cast<T2*>(p1.get());
    if(check) {
      return Ptr<T2>(check);
    }
  }
  return null;
}
 

template<class T>
std::ostream& operator<<( std::ostream& out, const Ptr<T>& p );
 
 
} // namespace Teuchos
 
 
#endif // TEUCHOS_PTR_DECL_HPP