Instigate Open Source Documentation

---

src/stl/_unary_function.hpp

Go to the documentation of this file.

#ifndef _INSTIGATE_OPEN_SOURCE_INTERNAL_HEADER_IN_CONCEPT
#error This is an internal header file used to implement Instigate STL.\
        It should never be included directly by a program.
#endif

#ifndef INSTIGATE_STL_UNARY_FUNCTION_HPP
#define INSTIGATE_STL_UNARY_FUNCTION_HPP

// Headers from this project
#include "functor.hpp"

// Headers from other projects

// Headers from standard libraries

// Forward declarations
namespace instigate {
        namespace stl {
                namespace unary_function {
                        struct tag;
                        template <typename UF> 
                        struct interface;
                        template <typename A, typename R>
                        struct interface<R (*) (A)>;
                        template <typename A, typename R>
                        struct interface<R (A::*) ()>;
                        template <typename A, typename R>
                        struct interface<R (A::*) () const>;
                        template <typename UF> 
                        struct requirements;
                }
        } 
} 

struct instigate::stl::unary_function::tag
{
};

template <typename UF>
struct instigate::stl::unary_function::interface
        : instigate::generic::assignable::interface<UF>
{
        typedef typename instigate::stl::functor::interface<UF>::argument_type 
                                                argument_type;

        typedef typename instigate::stl::functor::interface<UF>::result_type 
                                                result_type;

        static result_type invoke(const UF& f, argument_type a)
        {
                return f(a);
        }
        
};

template <typename A, typename R>
struct instigate::stl::unary_function::interface<R (*) (A)>
        : instigate::generic::assignable::interface<R (*) (A)>
{
        typedef A argument_type;

        typedef R result_type;

        static result_type invoke(R (*f)(A), A a)
        {
                return f(a);
        }
};

template <typename A, typename R>
struct instigate::stl::unary_function::interface <R (A::*) ()>
        : instigate::generic::assignable::interface<R (A::*) ()>
{
        typedef A* argument_type;

        typedef R result_type;

        static result_type invoke(R (A::*f)(), A* a)
        {
                assert(a != 0);
                return (a->*f)();
        }
};

template <typename A, typename R>
struct instigate::stl::unary_function::interface <R (A::*) () const>
        : instigate::generic::assignable::interface<R (A::*) () const>
{
        typedef const A* argument_type;

        typedef R result_type;

        static result_type invoke(R (A::*f)() const, const A* a)
        {
                assert(a != 0);
                return (a->*f)();
        }
};

template <typename T>
struct instigate::stl::unary_function::requirements
        : instigate::generic::assignable::interface<T>
{
        static void require_nested_typename_argument_type()
        {
                typedef instigate::stl::unary_function::interface<T> I;
                typedef typename I::argument_type A;
        }

        static void require_nested_typename_result_type()
        {
                typedef instigate::stl::unary_function::interface<T> I;
                typedef typename I::result_type R;
        }

        static void require_method_invoke()
        {
                typedef instigate::stl::unary_function::interface<T> I;
                (void)&I::invoke;
        }

        typename instigate::stl::unary_function::interface<T>::
        result_type static 
        check_signature_of_the_invoke(T& f, 
                        typename instigate::stl::
                        unary_function::interface<T>::argument_type a)
        {
                namespace UF = instigate::stl::unary_function;
                return UF::interface<T>::invoke(f, a);
        }

        requirements()
        {
               (void)&require_nested_typename_argument_type;
               (void)&require_nested_typename_result_type;
               (void)&require_method_invoke;
               (void)&check_signature_of_the_invoke;
        }

};

// vim:et:tabstop=8:shiftwidth=8:cindent:fo=croq:textwidth=80:

#endif // INSTIGATE_STL_UNARY_FUNCTION_HPP

---

© Instigate CJSC, Open Source