typeinfo.cpp

Go to the documentation of this file.

 
#define _RWSTD_LIB_SRC
 
#include <rw/_defs.h>
 
#include <typeinfo>
#include <string.h>
 
 
_RWSTD_NAMESPACE (__rw) {
 
inline int
__rw_ticmp (const _STD::type_info &lhs, const _STD::type_info &rhs)
{
    const char* const n1 = lhs.name ();
    const char* const n2 = rhs.name ();
 
    return strcmp (n1 ? n1 : "", n2 ? n2 : "");
}
 
}   // namespace __rw
 
 
// class type_info members
 
#if defined _RWSTD_TYPEINFO_INCLUDED
 
// define type_info members only if our own <typeinfo> header
// (as opposed to the compiler's native) has been included
// SunPro always #includes its own, regardless of options
 
#  if    !defined (_RWSTD_NO_STD_TYPE_INFO) \
      || !defined (_RWSTD_NO_GLOBAL_TYPE_INFO)
 
// at least one of the config tests above succeeded,
// rely on config tests for each individual member
 
#    ifndef _RWSTD_NO_STD_TYPE_INFO
 
// define type_info et al in namespace std iff they are found to be
// defined in namespace std in the compiler's language support library
// or if they are not found to be defined in either namespace std or
// in the global namespace
 
_RWSTD_NAMESPACE (std) {
 
#    endif   // _RWSTD_NO_STD_TYPE_INFO
 
 
#    ifdef _RWSTD_NO_TYPE_INFO_DTOR
 
type_info::~type_info () { }
 
#    endif   // _RWSTD_NO_TYPE_INFO_DTOR
 
 
#    ifdef _RWSTD_NO_TYPE_INFO_BEFORE
 
bool type_info::before (const type_info &rhs) const
{
    return 0 > _RW::__rw_ticmp (*this, rhs);
}
 
#    endif   // _RWSTD_NO_TYPE_INFO_BEFORE
 
 
#    ifdef _RWSTD_NO_TYPE_INFO_NAME
 
// used in type_info::name() when the class has no member called _C_name
static const char _C_name[] = "";
 
const char* type_info::name () const
{
    // silence warning: _C_name declared but never used
#ifdef _RWSTD_NO_STD_TYPE_INFO
    _RWSTD_UNUSED (::_C_name);
#else
    _RWSTD_UNUSED (std::_C_name);
#endif   // _RWSTD_NO_STD_TYPE_INFO
 
    return _C_name;
}
 
#    endif   // _RWSTD_NO_TYPE_INFO_NAME
 
 
#    ifdef _RWSTD_NO_TYPE_INFO_EQUALITY
 
bool type_info::operator== (const type_info &rhs) const
{
    return !before (rhs) && !rhs.before (*this);
}
 
#    endif   // _RWSTD_NO_TYPE_INFO_EQUALITY
 
 
#    ifdef _RWSTD_NO_TYPE_INFO_INEQUALITY
 
bool type_info::operator!= (const type_info &rhs) const
{
    return !(*this == rhs);
}
 
#    endif   // _RWSTD_NO_TYPE_INFO_INEQUALITY
 
#    ifndef _RWSTD_NO_STD_TYPE_INFO
 
}   // namespace std
 
#    endif   // _RWSTD_NO_STD_TYPE_INFO
 
#  else   // if _RWSTD_NO_STD_TYPEINFO && _RWSTD_NO_GLOBAL_TYPEINFO
 
// both config tests for class type_info failed so config test
// results for each individual member are likely to be unreliable
// rely on platform knowledge instead
 
#    ifndef _RWSTD_NO_RUNTIME_IN_STD
 
_RWSTD_NAMESPACE (std) {
 
#    endif   // _RWSTD_NO_RUNTIME_IN_STD
 
#    if defined (__HP_aCC)
 
const char* type_info::name () const
{
    return _C_name;
}
 
#      ifdef _HP_IA64ABI
 
bool type_info::before (const type_info &rhs) const
{
    return name () < rhs.name ();
}
 
bool type_info::operator== (const type_info &rhs) const
{
    return name () == rhs.name ();
}
 
bool type_info::operator!= (const type_info &rhs) const
{
    return !(*this == rhs);
}
 
#      endif   // _HP_IA64ABI
 
#    elif defined (__INTEL_COMPILER) && !defined (_MSC_VER)
 
const char* type_info::name () const
{
    return _C_name;
}
 
bool type_info::before (const type_info &rhs) const
{
    return name () < rhs.name ();
}
 
bool type_info::operator== (const type_info &rhs) const
{
    return name () == rhs.name ();
}
 
bool type_info::operator!= (const type_info &rhs) const
{
    return !(*this == rhs);
}
 
#    elif defined (__GNUG__) && !defined (_RWSTD_NO_HONOR_STD)
 
// define member functions inline in namespace std (they are defined
// as members of ::type_info (as opposed to std::type_info) in libstdc++
// unless lib is built with -fhonor-std
 
const char* type_info::name () const
{
    return _C_name;
}
 
bool type_info::operator== (const type_info &rhs) const
{
    return !this->before (rhs) && !rhs.before (*this);
}
 
bool type_info::operator!= (const type_info &rhs) const
{
    return !(*this == rhs);
}
 
#    elif defined (__IBMCPP__)
 
const char* type_info::name () const
{
    return _C_typeName;
}
 
bool type_info::operator== (const type_info &rhs) const
{
    return !this->before (rhs) && !rhs.before (*this);
}
 
bool type_info::operator!= (const type_info &rhs) const
{
    return !(*this == rhs);
}
 
#    endif   // __IBMCPP__
 
 
#    if defined (__GNUG__) && !defined (_RWSTD_NO_HONOR_STD)
 
// define member function in namespace std (it is defined as a member
// of ::type_info (as opposed to std::type_info) in libstdc++
// unless lib is built with -fhonor-std
bool type_info::before (const type_info &rhs) const
{
    return 0 > _RW::__rw_ticmp (*this, rhs);
}
 
#    elif defined (__IBMCPP__)
 
bool type_info::before (const type_info &rhs) const
{
    return 0 > _RW::__rw_ticmp (*this, rhs);
}
 
#    endif   //  __GNUG__ && !_RWSTD_NO_HONOR_STD
 
 
#    ifdef _MSC_VER
 
const char* type_info::name () const
{
    return _C_name;
}
 
 
// define in global namespace just like MSVC wants it
bool type_info::before (const type_info &rhs) const
{
    return 0 > _RW::__rw_ticmp (*this, rhs);
}
 
 
bool type_info::operator== (const type_info &rhs) const
{
    return 0 == _RW::__rw_ticmp (*this, rhs);
}
 
 
bool type_info::operator!= (const type_info &rhs) const
{
    return !(*this == rhs);
}
 
#    endif   // _MSC_VER
 
#    ifndef _RWSTD_NO_RUNTIME_IN_STD
 
}   // namespace std
 
#    endif   // _RWSTD_NO_RUNTIME_IN_STD
 
#  endif   // !_RWSTD_NO_STD_TYPEINFO || !_RWSTD_NO_GLOBAL_TYPEINFO
 
 
//**************************************************************************
// class bad_cast members
 
#  ifndef _RWSTD_NO_STD_BAD_CAST
 
_RWSTD_NAMESPACE (std) {
 
#  endif   // _RWSTD_NO_STD_BAD_CAST
 
#  ifdef _RWSTD_NO_BAD_CAST_DEFAULT_CTOR
 
bad_cast::bad_cast () _THROWS (())
{
    // empty
}
 
#  endif   // _RWSTD_NO_BAD_CAST_DEFAULT_CTOR
 
#  ifdef _RWSTD_NO_BAD_CAST_COPY_CTOR
 
bad_cast::bad_cast (const bad_cast &rhs) _THROWS (())
    : exception (rhs)
{
    // empty
}
 
#  endif   // _RWSTD_NO_BAD_CAST_COPY_CTOR
 
#  ifdef _RWSTD_NO_BAD_CAST_DTOR
 
bad_cast::~bad_cast () _THROWS (())
{
    // empty
}
 
#  endif   // _RWSTD_NO_BAD_CAST_DTOR
 
#  ifdef _RWSTD_NO_BAD_CAST_ASSIGNMENT
 
bad_cast&
bad_cast::operator= (const bad_cast &rhs) _THROWS (())
{
    exception::operator= (rhs);
 
    return *this;
}
 
#  endif   // _RWSTD_NO_BAD_CAST_ASSIGNMENT
 
#  ifdef _RWSTD_NO_BAD_CAST_WHAT
 
const char* bad_cast::what () const _THROWS (())
{
    return "bad_cast";
}
 
#  endif   // _RWSTD_NO_BAD_CAST_WHAT
 
#  ifndef _RWSTD_NO_STD_BAD_CAST
 
}   // namespace std
 
#  endif   // _RWSTD_NO_STD_BAD_CAST
 
 
//**************************************************************************
// class bad_typeid members
 
#  ifndef _RWSTD_NO_STD_BAD_TYPEID
 
_RWSTD_NAMESPACE (std) {
 
#  endif   // _RWSTD_NO_STD_BAD_TYPEID
 
bad_typeid::bad_typeid () _THROWS (())
{
    // empty
}
 
bad_typeid::bad_typeid (const bad_typeid &rhs) _THROWS (())
    : exception (rhs)
{
    // empty
}
 
bad_typeid::~bad_typeid () _THROWS (())
{
    // empty
}
 
#  ifdef _RWSTD_NO_BAD_TYPEID_ASSIGNMENT
 
bad_typeid&
bad_typeid::operator= (const bad_typeid &rhs) _THROWS (())
{
    exception::operator= (rhs);
 
    return *this;
}
 
#  endif   // _RWSTD_NO_BAD_TYPEID_ASSIGNMENT
 
const char* bad_typeid::what () const _THROWS (())
{
    return "bad_typeid";
}
 
#  ifndef _RWSTD_NO_STD_BAD_TYPEID
 
}   // namespace std
 
#  endif   // _RWSTD_NO_STD_BAD_TYPEID
 
#endif   // _RWSTD_TYPEINFO_INCLUDED