PlayaHandle.hpp

/* @HEADER@ */
//   
/* @HEADER@ */

#ifndef PLAYA_HANDLE_HPP
#define PLAYA_HANDLE_HPP

#include "PlayaDefs.hpp"
#include "PlayaOut.hpp"
#include "PlayaPrintable.hpp"
#include "Teuchos_Describable.hpp"
#include "PlayaHandleable.hpp"
#include "PlayaExceptions.hpp"
#include "PlayaObjectWithVerbosity.hpp"
#include "Teuchos_RefCountPtr.hpp"
#include "Teuchos_TypeNameTraits.hpp"


#define HANDLE_CTORS(handle, contents) \
 \
handle() : Playa::Handle<contents >() {;} \
 \
  handle(Playa::Handleable<contents >* rawPtr) : Playa::Handle<contents >(rawPtr) {;} \
 \
  handle(const Teuchos::RCP<contents >& smartPtr) : Playa::Handle<contents >(smartPtr){;}



namespace Playa
{
using Teuchos::RCP;
using Teuchos::rcp;


template <class X>
class ConstHandleTraits
{
public:
  typedef X NonconstType;
};

template <class X>
class ConstHandleTraits<const X>
{
public:
  typedef X NonconstType;
};



template <class PointerType>
class Handle 
{
public:
  Handle() : ptr_() {;}

  Handle(const RCP<PointerType>& _ptr) : ptr_(_ptr) {;}

  Handle(Handleable<PointerType>* rawPtr) : ptr_(rawPtr->getRcp()) {;}

  const RCP<PointerType>& ptr() const {return ptr_;}

  RCP<PointerType>& ptr() {return ptr_;}

  void print(std::ostream& os) const ;


  std::string description() const ;

  std::string fallbackDescription() const ;

  int verb() const ;

  void setVerb(int v);

private:
  RCP<PointerType> ptr_;
};

/* implementation of print() */
template <class PointerType> inline 
void Handle<PointerType>::print(std::ostream& os) const 
{
  const Printable* p = dynamic_cast<const Printable*>(ptr_.get());
  const Describable* d = dynamic_cast<const Describable*>(ptr_.get());

  if (p!=0) p->print(os);
  else if (d!=0) os << d->description();
  else os << fallbackDescription();
}

/* implementation of description() */
template <class PointerType> inline
std::string Handle<PointerType>::description() const 
{
  const Describable* d = dynamic_cast<const Describable*>(ptr_.get());
  TeuchosOStringStream oss;

  if (d!=0) oss << d->description();
  else oss << fallbackDescription();

  return oss.str();
}

template <class PointerType> inline
std::string Handle<PointerType>::fallbackDescription() const
{
  typedef typename ConstHandleTraits<PointerType>::NonconstType NC;
  TeuchosOStringStream oss;

  oss << "Handle[" << TypeNameTraits<NC>::name()
      << ", ptr=" << ptr_.get() << "]";
  return oss.str();
}



/* implementation of verb() */
template <class PointerType> inline
int Handle<PointerType>::verb() const 
{
  const ObjectWithVerbosity* v 
    = dynamic_cast<const ObjectWithVerbosity*>(ptr_.get());
  if (v) return v->verb();
  return 0;
}


/* implementation of verb() */
template <class PointerType> inline
void Handle<PointerType>::setVerb(int verbosity) 
{
  ObjectWithVerbosity* v 
    = dynamic_cast<ObjectWithVerbosity*>(ptr_.get());
  if (v) v->setVerb(verbosity);
  TEUCHOS_TEST_FOR_EXCEPTION(v==0, RuntimeError, 
    "attempt to set verbosity on a handle that doesn't wrap "
    "an ObjectWithVerbosity subtype");
}

template <class PointerType> inline
std::ostream& operator<<(std::ostream& os, const Playa::Handle<PointerType>& h)
{
  h.print(os);
  return os;
}

}

#define STREAM_OUT(handleType) \
                        inline std::ostream& operator<<(std::ostream& os, const handleType& h) \
                        {h.print(os); return os;}



#endif