rtti.h

Go to the documentation of this file.

// -*- Mode: C++; tab-width: 2; -*-
// vi: set ts=2:
//

#ifndef BALL_COMMON_RTTI_H
#define BALL_COMMON_RTTI_H

#ifndef BALL_CONFIG_CONFIG_H
# include <BALL/CONFIG/config.h>
#endif

#ifndef BALL_COMMON_H
# include <BALL/common.h>
#endif

#include <string>
#include <typeinfo>
using std::string;

namespace BALL 
{

# ifdef __GNUC__
  // EGCS produces a nearly unreadable name mangling that requires 
  // further interpretation
  namespace GNUDemangling 
  {
    BALL_EXPORT string demangle(string s);
  }
# endif

  BALL_EXPORT string streamClassName(const std::type_info& t);

  namespace RTTI
  {

    template <typename T>
    const T& getDefault() 
    {
      static T t;
      return t;
    }

    template <typename T>
    void* getNew()
    {
      return static_cast<void*>(new T);
    }

    template <typename T>
    const char* getName()
    {
      return typeid(T).name();
    }

    template <typename T>
    void* getClassID()
    {
      static char dummy;
      return (void*)&dummy;
    }

    template <typename T>
    const char* getStreamName()
    {
      // define portable names for the portable
      // types (some platforms use Size, some unsigned int, 
      // SUN CC even unsigned  for the Size type)
      if ((typeid(T) == typeid(Size)) 
          || (typeid(T) == typeid(Position))
          || (typeid(T) == typeid(HashIndex))
          || (typeid(T) == typeid(Property))
          || (typeid(T) == typeid(Handle)))
      {
        return "BALL::Size";
      }
      if ((typeid(T) == typeid(Index))
          || (typeid(T) == typeid(ErrorCode))
          || (typeid(T) == typeid(Distance)))
      {
        return "BALL::Index";
      }
      if (typeid(T) == typeid(::std::string))
      {
        return "::std::string";
      }
      if (typeid(T) == typeid(LongSize))
      {
        return "BALL::LongSize";
      }
      if (typeid(T) == typeid(bool))
      {
        return "bool";
      }
      if (typeid(T) == typeid(float))
      {
        return "float";
      }
      if (typeid(T) == typeid(char))
      {
        return "char";
      }
      if (typeid(T) == typeid(unsigned char))
      {
        return "unsigned_char";
      }
      if (typeid(T) == typeid(double))
      {
        return "double";
      }
      static string s("");
      static bool is_set = false;

      if (!is_set)
      {
        is_set = true;
        s = streamClassName(typeid(T));
      }

      return s.c_str();
    }

    template <typename T, typename U>
    bool isKindOf(const U&  u)
    {
      return (0 != dynamic_cast<const T*>(&u));
    }

    template <typename T, typename U>
    T* castTo(const U& u)
    {
      return const_cast<T*>(dynamic_cast<const T*>(&u));
    }

    template <typename T, typename U>
    bool isInstanceOf(const U& u)
    {
      return (typeid(u) == typeid(T));
    }

  } // namespace RTTI
} // namespace BALL

#endif // BALL_COMMON_RTTI_H

---