Typename.h

説明を見る。

// -*- C++ -*-
#ifndef RTC_TYPENAME_H
#define RTC_TYPENAME_H

#include <iostream>
#include <rtm/RTC.h>

namespace CORBA_Util
{
  template <class T, typename T::_ptr_type (*)(void)>
  struct has_nil_helper
  {
    typedef void type;
  };
  
  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;
      T tmp_var;
      any_var <<= tmp_var;
      return any_var.type()->id();
    }
    static const char* name()
    {
      CORBA::Any any_var;
      T tmp_var;
      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

---