Introspecting an inner function

| Home | Libraries | People | FAQ | More

## Introspecting an inner function

The TTI macro `BOOST_TTI_HAS_FUNCTION` introspects an inner function of a class. The function can be either a member function or a static member function.

BOOST_TTI_HAS_FUNCTION takes a single parameter which is the name of an inner function whose existence the programmer wants to check. The macro generates a metafunction called 'has_function_'name_of_inner_function'.

The metafunction can be invoked by passing it the enclosing type to introspect and a signature for the function as separate template arguments. The signature for the function consists of a return type, optional parameter types in the form of a boost::mpl forward sequence of types, and an optional Boost FunctionTypes tag type. A typical boost::mpl forward sequence of types is a boost::mpl::vector<>.

The metafunction returns a single type called 'type', which is a boost::mpl::bool_. As a convenience the metafunction returns the value of this type directly as a compile time bool constant called 'value'. This is true or false depending on whether the inner function, of the specified signature, exists or not.

#### Generating the metafunction

You generate the metafunction by invoking the macro with the name of an inner function:

    BOOST_TTI_HAS_FUNCTION(AnInnerFunction)

generates a metafunction called 'has_function_AnInnerFunction' in the current scope.

#### Invoking the metafunction

You invoke the metafunction by instantiating the template with an enclosing type to introspect and the signature of the function as a series of template parameters.

A return value called 'value' is a compile time bool constant.

    has_function_AnInnerFunction
      <
      Enclosing_Type,
      Function_ReturnType,
      boost::mpl::vector<Function_ParameterTypes>, // optional, can be any mpl forward sequence
      boost::function_types::SomeTagType           // optional, can be any FunctionTypes tag type
      >::value

#### Examples

First we generate metafunctions for various inner function names:

    #include <boost/tti/has_function.hpp>

    BOOST_TTI_HAS_FUNCTION(function1)
    BOOST_TTI_HAS_FUNCTION(function2)
    BOOST_TTI_HAS_FUNCTION(function3)

Next let us create some user-defined types we want to introspect.

    struct AClass { };
    struct Top
      {
      static int function1();
      AClass function2(double,short *);
      };
    struct Top2
      {
      long function2(Top &,int,bool,short,float);
      static Top * function3(long,int,AClass &);
      };

Finally we invoke our metafunction and return our value. This all happens at compile time, and can be used by programmers doing compile time template metaprogramming.

    has_function_function1<Top,int>::value; // true
    has_function_function1<Top2,int>::value; // false

    has_function_function2<Top,AClass,boost::mpl::vector<double,short *> >::value; // true
    has_function_function2<Top2,AClass,boost::mpl::vector<double,short *> >::value; // false

    has_function_function3<Top2,int>::value; // false
    has_function_function3<Top2,Top *,boost::mpl::vector<long,int,AClass &> >::value; // true;

#### Metafunction re-use

The macro encodes only the name of the function for which we are searching and the fact that we are introspecting for a function within an enclosing type.

Because of this, once we create our metafunction for introspecting a function by name, we can reuse the metafunction for introspecting any enclosing type, having any function, for that name.