Boost.Python - <boost/python/type_id.hpp>

###  | # Boost.Python ## Header <boost/python/type_id.hpp>

## Contents

Introduction
Classes
  Class `type_info`
    Class `type_info` synopsis
    Class `type_info` constructor
    Class `type_info` comparison functions
    Class `type_info` observer functions
Functions
  type_id
Example

## Introduction

`<boost/python/type_id.hpp>` provides types and functions for runtime type identification like those of of `<typeinfo>`. It exists mostly to work around certain compiler bugs and platform-dependent interactions with shared libraries.

## Classes

### Class `type_info`

`type_info` instances identify a type. As `std::type_info` is specified to (but unlike its implementation in some compilers), `boost::python::type_info` never represents top-level references or cv-qualification (see section 5.2.8 in the C++ standard). Unlike `std::type_info`, `boost::python::type_info` instances are copyable, and comparisons always work reliably across shared library boundaries.

#### Class type_info synopsis

    namespace boost { namespace python
    {
      class type_info : totally_ordered<type_info>
      {
       public:
          // constructor
          type_info(std::type_info const& = typeid(void));

          // comparisons
          bool operator<(type_info const& rhs) const;
          bool operator==(type_info const& rhs) const;

          // observers
          char const* name() const;
      };
    }}

#### Class `type_info` constructor

    type_info(std::type_info const& = typeid(void));

Effects: constructs a `type_info` object which identifies the same type as its argument.
Rationale: Since it is occasionally neccessary to make an array of `type_info` objects a benign default argument is supplied. Note: this constructor does not correct for non-conformance of compiler `typeid()` implementations. See `type_id`, below.

#### Class `type_info` comparisons

    bool operator<(type_info const& rhs) const;

Effects: yields a total order over `type_info` objects.

    bool operator==(type_info const& rhs) const;

Returns: `true` iff the two values describe the same type.

Note: The use of `totally_ordered<type_info>` as a private base class supplies operators `<=`, `>=`, `>`, and `!=`

#### Class `type_info` observers

    char const* name() const;

Returns: The result of calling `name()` on the argument used to construct the object.

## Functions

    std::ostream& operator<<(std::ostream&s, type_info const&x);

Effects: Writes a description of the type described by to `x` into `s`.
Rationale: Not every C++ implementation provides a truly human-readable `type_info::name()` string, but for some we may be able to decode the string and produce a reasonable representation.

    template <class T> type_info type_id()

Returns: `type_info(typeid(T))`
Note: On some non-conforming C++ implementations, the code is not actually as simple as described above; the semantics are adjusted to work as-if the C++ implementation were conforming.

## Example

The following example, though silly, illustrates how the `type_id` facility might be used

    #include <boost/python/type_id.hpp>

    // Returns true iff the user passes an int argument
    template <class T>
    bool is_int(T x)
    {
       using boost::python::type_id;
       return type_id<T>() == type_id<int>();
    }

Revised 13 November, 2002

© Copyright Dave Abrahams 2002. All Rights Reserved.