Typename.h

[詳解]

// -*- C++ -*-
#ifndef RTC_TYPENAME_H
#define RTC_TYPENAME_H
 
#include <rtm/RTC.h>
 
#include <iostream>
 
namespace CORBA_Util
{
  template <class T, typename T::_ptr_type (*)(void)>
  struct has_nil_helper
  {
    using type = void;
  };
 
  template <class T, class U = void>
  struct has_nil_impl
  {
    static const bool value = false;
  };
 
  template <class T>
  struct has_nil_impl<T, typename has_nil_helper<T, &T::_nil>::type>
  {
    static const bool value = true;
  };
 
  template <class T>
  struct has_nil : has_nil_impl<T>
  {
  };
 
  template <typename T>
  struct is_corba_object
  {
    static const bool value = has_nil<T>::value;
  };
 
  template <bool cond, class T>
  class typecode;
 
  template <class T>
  class typecode<true, T>
  {
  public:
    static const char* id()
    {
      CORBA::Any any_var;
      typename T::_ptr_type tmp_var;
      tmp_var = T::_nil();
      any_var <<= tmp_var;
      return any_var.type()->id();
    }
    static const char* name()
    {
      CORBA::Any any_var;
      typename T::_ptr_type tmp_var;
      tmp_var = T::_nil();
      any_var <<= tmp_var;
      return any_var.type()->name();
    }
  };
 
  template <class T>
  class typecode<false, T>
  {
  public:
    static const char* id()
    {
      CORBA::Any any_var;
#ifdef ORB_IS_TAO
      T tmp_var = T();
#else
      T tmp_var;
#endif
      any_var <<= tmp_var;
      return any_var.type()->id();
    }
    static const char* name()
    {
      CORBA::Any any_var;
#ifdef ORB_IS_TAO
      T tmp_var = T();
#else
      T tmp_var;
#endif
      any_var <<= tmp_var;
      return any_var.type()->name();
    }
  };
 
 
  template <class T>
  const char* toTypename()
  {
    return typecode<is_corba_object<T>::value, T>::name();
  }
 
  template <class T>
  const char* toTypenameOfStruct()
  {
    return typecode<false, T>::name();
  }
 
  template <class T>
  const char* toTypenameOfObject()
  {
    return typecode<true, T>::name();
  }
 
  template <class T>
  const char* toRepositoryId()
  {
    return typecode<is_corba_object<T>::value, T>::id();
  }
 
  template <class T>
  const char* toRepositoryIdOfStruct()
  {
    return typecode<false, T>::id();
  }
 
  template <class T>
  const char* toRepositoryIdOfObject()
  {
    return typecode<true, T>::id();
  }
 
} // namespace CORBA_Util
 
template <class T>
const char* toTypename()
{
  std::cerr << "toTypename() is obsolete." << std::endl;
  std::cerr << "Please use CORBA_Util::toTypename() instead." << std::endl;
  return CORBA_Util::typecode<CORBA_Util::is_corba_object<T>::value, T>::name();
}
 
#endif  // RTC_TYPENAME_H