bbtkRTTI.h

Go to the documentation of this file.

/*=========================================================================                                                                               
  Program:   bbtk
  Module:    $RCSfile: bbtkRTTI.h,v $
  Language:  C++
  Date:      $Date: 2008/10/17 08:18:14 $
  Version:   $Revision: 1.6 $
=========================================================================*/

/* ---------------------------------------------------------------------

* Copyright (c) CREATIS-LRMN (Centre de Recherche en Imagerie Medicale)
* Authors : Eduardo Davila, Laurent Guigues, Jean-Pierre Roux
*
*  This software is governed by the CeCILL-B license under French law and 
*  abiding by the rules of distribution of free software. You can  use, 
*  modify and/ or redistribute the software under the terms of the CeCILL-B 
*  license as circulated by CEA, CNRS and INRIA at the following URL 
*  http://www.cecill.info/licences/Licence_CeCILL-B_V1-en.html 
*  or in the file LICENSE.txt.
*
*  As a counterpart to the access to the source code and  rights to copy,
*  modify and redistribute granted by the license, users are provided only
*  with a limited warranty  and the software's author,  the holder of the
*  economic rights,  and the successive licensors  have only  limited
*  liability. 
*
*  The fact that you are presently reading this means that you have had
*  knowledge of the CeCILL-B license and that you accept its terms.
* ------------------------------------------------------------------------ */                                                                         

#ifndef __BBTKRTTI_H_INCLUDED__
#define __BBTKRTTI_H_INCLUDED__

#include "bbtkSystem.h"
#include <vector>

//-----------------------------------------------------------------------------
// RRTI type_info.name() demangling
// For type_info.name() demangling (gcc >= 3.1, see http://gcc.gnu.org/onlinedocs/libstdc++/latest-doxygen/namespaceabi.html)
// Test for GCC > 3.1.0 //
#if __GNUC__ > 3 ||                                     \
  (__GNUC__ == 3 && (__GNUC_MINOR__ > 1 ||              \
                     (__GNUC_MINOR__ == 1 &&            \
                      __GNUC_PATCHLEVEL__ > 0)))
#include <cxxabi.h>
#include <stdlib.h>
namespace bbtk
{
  inline std::string demangle_type_name(const char* name) 
  {
    int  status;
    char* dem = abi::__cxa_demangle(name, 0, 0, &status);
    std::string demangled(dem);
    free(dem);
    if (!status) return demangled;
    return name;
  }

}

#define BBTK_DEMANGLE_TYPE_NAME(NAME) bbtk::demangle_type_name(NAME)

//==========================================================================
#elif defined(_WIN32)
// WIN32
//#include "Windows.h"
//#include "stdafx.h"
#include <windows.h>
#include <imagehlp.h>
// include the right library in the linker stage
#pragma comment( lib, "imagehlp.lib" )

namespace bbtk
{

  
  
  
  inline std::string demangle_type_name(const char* name) 
  {
    char demangled[513]; 
    if (UnDecorateSymbolName(name, demangled, 
                             sizeof(name), UNDNAME_COMPLETE))
      {
                  return name; //demangled;
      }
    else 
      {
        return name;
      }
  }
}
#define BBTK_DEMANGLE_TYPE_NAME(NAME) bbtk::demangle_type_name(NAME)

#else 
// OTHER
#define BBTK_DEMANGLE_TYPE_NAME(NAME) NAME
#endif 

#define BBTK_GET_CURRENT_OBJECT_NAME \
  BBTK_DEMANGLE_TYPE_NAME(typeid(*this).name())

#define BBTK_GET_TYPE_NAME(A)           \
  BBTK_DEMANGLE_TYPE_NAME(typeid(A).name())
//-----------------------------------------------------------------------------


namespace bbtk 
{
  template <class T>
  inline std::string TypeName() 
  { return BBTK_DEMANGLE_TYPE_NAME(typeid(T).name()); }
  template <class T>
  inline std::string TypeName(const T& t) 
  { return BBTK_DEMANGLE_TYPE_NAME(typeid(t).name()); }
  template <> 
  inline std::string TypeName<std::type_info>(const std::type_info& t)
  { return BBTK_DEMANGLE_TYPE_NAME(t.name()); }

  template <class T>
  inline std::string HumanTypeName() 
  { return TypeName<T>(); }
  template <class T>
  inline std::string HumanTypeName(const T& t) 
  { return TypeName(t); }
  template <> 
  inline std::string HumanTypeName<std::type_info>(const std::type_info& t)
  { return TypeName<std::type_info>(t); }
#define BBTK_DEFINE_HUMAN_READABLE_TYPE_NAME(TYPE,NAME)                 \
  template <> inline std::string HumanTypeName< TYPE >()                \
  { return NAME; }                                                      \
    template <> inline std::string HumanTypeName< TYPE >(const TYPE&)   \
    { return NAME; }    
  
  BBTK_DEFINE_HUMAN_READABLE_TYPE_NAME(std::string,"String");
  BBTK_DEFINE_HUMAN_READABLE_TYPE_NAME(signed char,"Char");
  BBTK_DEFINE_HUMAN_READABLE_TYPE_NAME(signed short,"Short");
  BBTK_DEFINE_HUMAN_READABLE_TYPE_NAME(signed int,"Int");
  BBTK_DEFINE_HUMAN_READABLE_TYPE_NAME(unsigned char,"UChar");
  BBTK_DEFINE_HUMAN_READABLE_TYPE_NAME(unsigned short,"UShort");
  BBTK_DEFINE_HUMAN_READABLE_TYPE_NAME(unsigned int,"UInt");
  BBTK_DEFINE_HUMAN_READABLE_TYPE_NAME(float,"Float");
  BBTK_DEFINE_HUMAN_READABLE_TYPE_NAME(double,"Double");
  BBTK_DEFINE_HUMAN_READABLE_TYPE_NAME(bool,"Bool");
  BBTK_DEFINE_HUMAN_READABLE_TYPE_NAME(long,"Long");

  // Human readable strings for std::vector
#define BBTK_DEFINE_HUMAN_READABLE_VECTOR_TYPE_NAME(TYPE)               \
  template <> inline std::string HumanTypeName< std::vector<TYPE> >()   \
  { std::string t("Vector"); t += HumanTypeName<TYPE>(); return t;}                             \
    template <> inline std::string HumanTypeName< std::vector<TYPE> >   \
        (const std::vector<TYPE>&) \
  { std::string t("Vector"); t += HumanTypeName<TYPE>(); return t;}     

  BBTK_DEFINE_HUMAN_READABLE_VECTOR_TYPE_NAME(int8_t);
  BBTK_DEFINE_HUMAN_READABLE_VECTOR_TYPE_NAME(uint8_t);
  BBTK_DEFINE_HUMAN_READABLE_VECTOR_TYPE_NAME(int16_t);
  BBTK_DEFINE_HUMAN_READABLE_VECTOR_TYPE_NAME(uint16_t);
  BBTK_DEFINE_HUMAN_READABLE_VECTOR_TYPE_NAME(int32_t);
  BBTK_DEFINE_HUMAN_READABLE_VECTOR_TYPE_NAME(uint32_t);
  BBTK_DEFINE_HUMAN_READABLE_VECTOR_TYPE_NAME(long);
  BBTK_DEFINE_HUMAN_READABLE_VECTOR_TYPE_NAME(float);
  BBTK_DEFINE_HUMAN_READABLE_VECTOR_TYPE_NAME(double);
  BBTK_DEFINE_HUMAN_READABLE_VECTOR_TYPE_NAME(std::string);

  typedef const std::type_info& TypeInfo;


  BBTK_EXPORT void*  run_time_up_or_down_cast( const std::type_info& target_type,
                                  const std::type_info& source_type,
                                  void*  source_pointer
                                  );
 BBTK_EXPORT void*  run_time_up_or_down_cast( const std::type_info& target_type,
                                  const std::type_info& source_type,
                                  const void*  source_pointer
                                  );


}

#endif