Teuchos_any.hpp

Go to the documentation of this file.

#ifndef TEUCHOS_ANY_HPP
#define TEUCHOS_ANY_HPP

#include "Teuchos_TestForException.hpp"
#include "Teuchos_TypeNameTraits.hpp"

//
// This file was taken from the boost library which contained the
// following notice:
//
// *************************************************************
//
// what:  variant type boost::any
// who:   contributed by Kevlin Henney,
//        with features contributed and bugs found by
//        Ed Brey, Mark Rodgers, Peter Dimov, and James Curran
// when:  July 2001
// where: tested with BCC 5.5, MSVC 6.0, and g++ 2.95
//
// Copyright Kevlin Henney, 2000, 2001, 2002. All rights reserved.
//
// Permission to use, copy, modify, and distribute this software for any
// purpose is hereby granted without fee, provided that this copyright and
// permissions notice appear in all copies and derivatives.
//
// This software is provided "as is" without express or implied warranty.
//
// *************************************************************
//
// RAB modified the file for use in Teuchos.  I changed the nature of
// the any_cast<> to be easier to use.
//

namespace Teuchos {

class any
{
public:
  any()
    : content(0)
    {}

  template<typename ValueType>
  explicit any(const ValueType & value)
    : content(new holder<ValueType>(value))
    {}
  
  any(const any & other)
    : content(other.content ? other.content->clone() : 0)
    {}

  ~any()
    {
      delete content;
    }

  any & swap(any & rhs)
    {
      std::swap(content, rhs.content);
      return *this;
    }
  
  template<typename ValueType>
  any & operator=(const ValueType & rhs)
    {
      any(rhs).swap(*this);
      return *this;
    }
  
  any & operator=(const any & rhs)
    {
      any(rhs).swap(*this);
      return *this;
    }
  
  bool empty() const
    {
      return !content;
    }
  
  const std::type_info & type() const
    {
      return content ? content->type() : typeid(void);
    }
  
  std::string typeName() const
    {
      return content ? content->typeName() : "NONE";
    }
  
  bool same( const any &other ) const
    {
      if( this->empty() && other.empty() )
        return true;
      else if( this->empty() && !other.empty() )
        return false;
      else if( !this->empty() && other.empty() )
        return false;
      // !this->empty() && !other.empty()
      return content->same(*other.content);
    }

  void print(std::ostream& os) const
    {
      if (content) content->print(os);
    }

#ifndef DOXYGEN_SHOULD_SKIP_THIS


  class placeholder
  {
  public:
    virtual ~placeholder() {}
    virtual const std::type_info & type() const = 0;
    virtual std::string typeName() const = 0;
    virtual placeholder * clone() const = 0;
    virtual bool same( const placeholder &other ) const = 0;
    virtual void print(std::ostream & os) const = 0;
  };
  
  template<typename ValueType>
  class holder : public placeholder
  {
  public:
    holder(const ValueType & value)
      : held(value)
      {}
    const std::type_info & type() const
      { return typeid(ValueType); }
    std::string typeName() const
      { return TypeNameTraits<ValueType>::name(); }
    placeholder * clone() const
      { return new holder(held); }
    bool same( const placeholder &other ) const
      {
        if( type() != other.type() ) {
          return false;
        }
        // type() == other.type()
        const ValueType
          &other_held = dynamic_cast<const holder<ValueType>&>(other).held;
        return held == other_held;
      }
    void print(std::ostream & os) const
      { os << held; }
    ValueType held;
  };


public:
  // Danger: This is made public to allow any_cast to be non-friend
  placeholder* access_content()
    { return content; }
  const placeholder* access_content() const
    { return content; }
#endif

private:

  // /////////////////////////
  // Private data members
  
  placeholder * content;

};

class bad_any_cast : public std::runtime_error
{
public:
  bad_any_cast( const std::string msg ) : std::runtime_error(msg) {}
};

template<typename ValueType>
ValueType& any_cast(any &operand)
{

  const std::string ValueTypeName = TypeNameTraits<ValueType>::name();
  bool type_mismatch = ( operand.type() != typeid(ValueType) );
#ifdef HAVE_SHARED
  // For shared libraries, the above may resolve as true because one
  // of the types is not fully qualified.  The following check will
  // compensate for that.
  if ( type_mismatch )
    type_mismatch = ( strcmp(operand.type().name(), typeid(ValueType).name()) != 0 );
#endif
  TEST_FOR_EXCEPTION(
    type_mismatch, bad_any_cast
    ,"any_cast<"<<ValueTypeName<<">(operand): Error, cast to type "
    << "any::holder<"<<ValueTypeName<<"> failed since the actual underlying type is \'"
    << typeName(*operand.access_content()) << "!"
    );

  TEST_FOR_EXCEPTION(
    !operand.access_content(), bad_any_cast
    ,"any_cast<"<<ValueTypeName<<">(operand): Error, cast to type "
    << "any::holder<"<<ValueTypeName<<"> failed because the content is NULL"
    );

  // 2007/11/28: rabartl: Note: If we get here, then the rest of this function
  // should succeed and should be a formality.  The dynamic cast is the safe
  // thing to do and therefore we try that.  However, this may actually fail
  // with shared libraries with g++ (see below).
  any::holder<ValueType>
    *dyn_cast_content = dynamic_cast<any::holder<ValueType>*>(operand.access_content());
#ifdef HAVE_SHARED
  // For shared libraries, dynamic_cast does not work across shared
  // library boundaries, so we use static_cast, which will prevent any
  // runtime errors at the expense of being more dangerous.
  if ( !dyn_cast_content )
    dyn_cast_content = static_cast<any::holder<ValueType>*>(operand.access_content());
  // 2007/11/28: rabartl: Above, this static cast is not safe for some
  // possible types but that should be very rare.  Note that if a program
  // performing the dynamic casts works correctly with a static library
  // (i.e. HAVE_SHARED is not defined), and if the compiler can figure out the
  // static case correctly, then this should be safe for the shared library
  // case.  We really need to look into issues of RTTI and shared libraries
  // and see what the C++ standard says about this and if there are any g++
  // command-line options for fixing this ...
#endif
  TEST_FOR_EXCEPTION(
    !dyn_cast_content, std::logic_error
    ,"any_cast<"<<ValueTypeName <<">(operand): Error, cast to type "
    << "any::holder<"<<ValueTypeName<<"> failed but should not have and the actual underlying type is \'"
    << typeName(*operand.access_content()) << "!"
    );

  return dyn_cast_content->held;

}

template<typename ValueType>
const ValueType& any_cast(const any &operand)
{
  return any_cast<ValueType>(const_cast<any&>(operand));
}

inline std::string toString(const any &rhs)
{
  std::ostringstream oss;
  rhs.print(oss);
  return oss.str();
}

inline bool operator==( const any &a, const any &b )
{
  return a.same(b);
}

inline bool operator!=( const any &a, const any &b )
{
  return !a.same(b);
}

inline std::ostream & operator<<(std::ostream & os, const any &rhs)
{
  rhs.print(os);
  return os;
}

} // namespace Teuchos

#endif // TEUCHOS_ANY_HPP

---