type_info.h

Go to the documentation of this file.

// $Header$
//
// Copyright (C) 2000 - 2004, by
//
// Carlo Wood, Run on IRC <carlo@alinoe.com>
// RSA-1024 0x624ACAD5 1997-01-26                    Sign & Encrypt
// Fingerprint16 = 32 EC A7 B6 AC DB 65 A6  F6 F6 55 DD 1C DC FF 61
//
// This file may be distributed under the terms of the Q Public License
// version 1.0 as appearing in the file LICENSE.QPL included in the
// packaging of this file.
//
 
#ifndef LIBCWD_TYPE_INFO_H
#define LIBCWD_TYPE_INFO_H
 
#ifndef LIBCWD_PRIVATE_THREADING_H
#include "private_threading.h"
#endif
#ifndef LIBCW_TYPEINFO
#define LIBCW_TYPEINFO
#include <typeinfo>             // Needed for typeid()
#endif
#ifndef LIBCW_CSTDDEF
#define LIBCW_CSTDDEF
#include <cstddef>              // Needed for size_t
#endif
 
namespace libcwd {
 
namespace _private_ {
  extern char const* make_label(char const* mangled_name);
 
  template<typename T>
  struct size_of_completed {
    static constexpr size_t size = sizeof(T);
  };
 
  struct size_of_not_completed {
    static constexpr size_t size = 0;
  };
 
  template<typename T>
  struct sizeof_ref {
    template<typename U>
    static size_of_completed<T> test(int (*)[sizeof(U)]);
 
    template<typename>
    static size_of_not_completed test(...);
 
    static constexpr size_t value = decltype(test<T>(nullptr))::size;
  };
 
  template<typename T>
  size_t sizeof_ref_v = sizeof_ref<T>::value;
} // namespace _private_
 
class type_info_ct {
protected:
  size_t M_type_size;                   
  size_t M_type_ref_size;               
  char const* M_name;                   
  char const* M_dem_name;               
public:
  type_info_ct() { }
  type_info_ct(int) : M_type_size(0), M_type_ref_size(0), M_name(NULL), M_dem_name("<unknown type>") { }
  void init(char const* type_encoding, size_t s, size_t rs)
  {
    M_type_size = s;
    M_type_ref_size = rs;
    M_name = type_encoding;
    M_dem_name = _private_::make_label(type_encoding);
  }
  char const* demangled_name() const { return M_dem_name; }
  char const* name() const { return M_name; }
  size_t size() const { return M_type_size; }
  size_t ref_size() const { return M_type_ref_size; }
};
 
namespace _private_ {
 
  extern char const* extract_exact_name(char const*, char const* LIBCWD_COMMA_TSD_PARAM);
 
  //-------------------------------------------------------------------------------------------------
  // type_info_of
 
  // _private_::
  template<typename T>
    struct type_info {
    private:
      static type_info_ct S_value;
      static bool S_initialized;
    public:
      static type_info_ct const& value();
    };
 
  // Specialization for general pointers.
  // _private_::
  template<typename T>
    struct type_info<T*> {
    private:
      static type_info_ct S_value;
      static bool S_initialized;
    public:
      static type_info_ct const& value();
    };
 
  // Specialization for `void*'.
  // _private_::
  template<>
    struct type_info<void*> {
    private:
      static type_info_ct S_value;
      static bool S_initialized;
    public:
      static type_info_ct const& value();
    };
 
  // _private_::
  template<typename T>
    type_info_ct type_info<T>::S_value;
 
  // _private_::
  template<typename T>
    bool type_info<T>::S_initialized;
 
  // _private_::
  template<typename T>
    type_info_ct const& type_info<T>::value()
    {
      if (!S_initialized)
      {
        S_value.init(typeid(T).name(), sizeof(T), 0);
        S_initialized = true;
      }
      return S_value;
    }
 
  // _private_::
  template<typename T>
    type_info_ct type_info<T*>::S_value;
 
  // _private_::
  template<typename T>
    bool type_info<T*>::S_initialized;
 
  // _private_::
  template<typename T>
    type_info_ct const& type_info<T*>::value()
    {
      if (!S_initialized)
      {
        S_value.init(typeid(T*).name(), sizeof(T*), sizeof_ref_v<T>);
        S_initialized = true;
      }
      return S_value;
    }
 
} // namespace _private_
 
} // namespace libcwd
 
//---------------------------------------------------------------------------------------------------
// libcwd_type_info_exact
 
template<typename T>
  struct libcwd_type_info_exact {
  private:
    static ::libcwd::type_info_ct S_value;
    static bool S_initialized;
  public:
    static ::libcwd::type_info_ct const& value();
  };
 
// Specialization for general pointers.
template<typename T>
  struct libcwd_type_info_exact<T*> {
  private:
    static ::libcwd::type_info_ct S_value;
    static bool S_initialized;
  public:
    static ::libcwd::type_info_ct const& value();
  };
 
// Specialization for `void*'.
template<>
  struct libcwd_type_info_exact<void*> {
  private:
    static ::libcwd::type_info_ct S_value;
    static bool S_initialized;
  public:
    static ::libcwd::type_info_ct const& value();
  };
 
template<typename T>
  ::libcwd::type_info_ct libcwd_type_info_exact<T>::S_value;
 
template<typename T>
  bool libcwd_type_info_exact<T>::S_initialized;
 
template<typename T>
  ::libcwd::type_info_ct const& libcwd_type_info_exact<T>::value()
  {
    if (!S_initialized)
    {
      S_value.init(::libcwd::_private_::extract_exact_name(typeid(libcwd_type_info_exact<T>).name(), typeid(T).name() LIBCWD_COMMA_TSD_INSTANCE), sizeof(T), 0);
      S_initialized = true;
    }
    return S_value;
  }
 
template<typename T>
  ::libcwd::type_info_ct libcwd_type_info_exact<T*>::S_value;
 
template<typename T>
  bool libcwd_type_info_exact<T*>::S_initialized;
 
template<typename T>
  ::libcwd::type_info_ct const& libcwd_type_info_exact<T*>::value()
  {
    if (!S_initialized)
    {
      S_value.init(::libcwd::_private_::extract_exact_name(typeid(libcwd_type_info_exact<T*>).name(), typeid(T*).name() LIBCWD_COMMA_TSD_INSTANCE), sizeof(T*), ::libcwd::_private_::sizeof_ref_v<T>);
      S_initialized = true;
    }
    return S_value;
  }
 
namespace libcwd {
 
#ifndef LIBCWD_DOXYGEN
// Prototype of `type_info_of'.
template<typename T>
  inline
  type_info_ct const&
  type_info_of(T const&);
#endif
 
template<typename T>
  inline
  type_info_ct const&
  type_info_of()
  {
    return ::libcwd_type_info_exact<T>::value();
  }
 
template<typename T>
  inline
  type_info_ct const&
  type_info_of(T const&)                // If we don't use a reference, this would _still_ cause the copy constructor to be called.
                                        // Besides, using `const&' doesn't harm the result as typeid() always ignores the top-level
                                        // CV-qualifiers anyway (see C++ standard ISO+IEC+14882, 5.2.8 point 5).
  {
    return _private_::type_info<T>::value();
  }
 
extern type_info_ct const unknown_type_info_c;
 
} // namespace libcwd
 
#endif // LIBCWD_TYPE_INFO_H