Teuchos_Ptr.hpp

// @HEADER
// ***********************************************************************
// 
//                    Teuchos: Common Tools Package
//                 Copyright (2004) Sandia Corporation
// 
// Under terms of Contract DE-AC04-94AL85000, there is a non-exclusive
// license for use of this work by or on behalf of the U.S. Government.
// 
// This library 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.1 of the
// License, or (at your option) any later version.
//  
// This library 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 library; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
// USA
// Questions? Contact Michael A. Heroux (maherou@sandia.gov) 
// 
// ***********************************************************************
// @HEADER


#ifndef TEUCHOS_PTR_HPP
#define TEUCHOS_PTR_HPP


#include "Teuchos_ENull.hpp"
#include "Teuchos_TypeNameTraits.hpp"
#include "Teuchos_dyn_cast.hpp"


namespace Teuchos {


template<class T>
class Ptr {
public:

  Ptr( ENull null_in = null );

  explicit Ptr( T *ptr );

  Ptr(const Ptr<T>& ptr);

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

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

  T* operator->() const;

  T& operator*() const;

  T* get() const;

  T* getRawPtr() const;

  const Ptr<T>& assert_not_null() const;

private:

  T *ptr_;

};


template<typename T> inline
Ptr<T> outArg( 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> ptrRef( T& arg )
{
  return Ptr<T>(&arg);
}


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


// 2007/11/07: rabartl: ToDo: Add the casting functions
// ptr_[const,dynamic,static]_cast(...) to allow conversions.


template<class T> inline
bool is_null( 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<typename T>
class TypeNameTraits<Ptr<T> > {
public:
  static std::string name() { return "Ptr<"+TypeNameTraits<T>::name()+">"; }
  static std::string concreteName( const Ptr<T>& t )
    { return name(); }
};


} // namespace Teuchos


// /////////////////////////////////////////////////////////////////////////
// Inline implementations below, not for the client to look at.


namespace Teuchos {
namespace PtrPrivateUtilityPack {
void throw_null( const std::string &type_name );
} // namespace PtrPrivateUtilityPack
} // namespace Teuchos


namespace Teuchos {


template<class T> inline
Ptr<T>::Ptr( ENull null_in )
  : ptr_(0)
{}


template<class T> inline
Ptr<T>::Ptr( T *ptr )
  : ptr_(ptr)
{}


template<class T> inline
Ptr<T>::Ptr(const Ptr<T>& ptr)
  :ptr_(ptr.ptr_)
{}


template<class T>
template<class T2> inline
Ptr<T>::Ptr(const Ptr<T2>& ptr)
  :ptr_(ptr.get())
{}


template<class T> inline
Ptr<T>& Ptr<T>::operator=(const Ptr<T>& ptr)
{
  ptr_ = ptr.get();
  return *this;
}


template<class T> inline
T* Ptr<T>::operator->() const
{
#ifdef TEUCHOS_DEBUG
  assert_not_null();
#endif
  return ptr_;
}


template<class T> inline
T& Ptr<T>::operator*() const
{
#ifdef TEUCHOS_DEBUG
  assert_not_null();
#endif
  return *ptr_;
}


template<class T> inline
T* Ptr<T>::get() const
{
  return ptr_;
}


template<class T> inline
T* Ptr<T>::getRawPtr() const
{
  return ptr_;
}


template<class T>
const Ptr<T>& Ptr<T>::assert_not_null() const
{
  if(!ptr_)
    PtrPrivateUtilityPack::throw_null(TypeNameTraits<T>::name());
  return *this;
}


} // namespace Teuchos


#endif // TEUCHOS_PTR_HPP

---