Instigate Open Source Documentation

---

src/stl/functional.hpp

Go to the documentation of this file.

#ifndef INSTIGATE_STL_FUNCTIONAL_HPP
#define INSTIGATE_STL_FUNCTIONAL_HPP

// headers from this project
#include "concept.hpp"

// headers from other projects
#include <generic/base.hpp>

// headers from standard libraries

// forward declarations
namespace instigate {
        namespace stl {

                template <typename UF> 
                struct ubinder;

                template <typename UF, typename Value>
                ubinder<UF> bind( UF, const Value& );

                template <typename BF> 
                struct bbinder;

                template <typename BF, typename Value1, typename Value2 > 
                bbinder<BF> bind( BF f, const Value1& x, const Value2& y ); 

                template <typename BF> 
                struct bbinder1st;

                template <typename BF, typename Value> 
                bbinder1st<BF> bind1st( BF f, const Value& x );

                template <typename BF> 
                struct bbinder2nd;

                template <typename BF, typename Value> 
                bbinder2nd<BF> bind2nd( BF f, const Value& x );

                template <typename TF> 
                struct tbinder;

                template <typename TF, typename Value1, typename Value2,
                         typename Value3> 
                tbinder<TF> bind( TF f, const Value1& x, const Value2& y,
                                const Value3& z);

                template <typename TF> 
                        struct tbinder1st;

                template <typename TF, typename Value> 
                tbinder1st<TF> 
                tbind1st( TF f, const Value& x);

                template <typename TF> 
                struct tbinder2nd;

                template <typename TF, typename Value > 
                tbinder2nd<TF> 
                tbind2nd( TF f, const Value& y );

                template <typename TF> 
                struct tbinder3rd;

                template <typename TF, typename Value> 
                tbinder3rd<TF> 
                tbind3rd( TF f, const Value& z );

                template <typename BF, typename UF1, typename UF2>
                class binary_compose;

                template <typename BF, typename UF1, typename UF2>
                binary_compose<BF, UF1, UF2> 
                compose( BF b, UF1 f1, UF2 f2 );

                template <typename UF1, typename UF2>
                class unary_compose;

                template <typename UF1, typename UF2>
                unary_compose<UF1, UF2> 
                compose( UF1 f1, UF2 f2 );

                template <typename T>
                class constant_generator;

                template <typename BP> 
                struct bnot2;

                template <typename BP>
                bnot2<BP>
                not2(BP p);

                template <typename UP> 
                struct unot1;

                template <typename UP>
                unot1<UP>
                not1(UP p);
        } // namespace stl
} // namespace instigate

template <typename UF>
struct instigate::stl::ubinder
{
private:
        typedef typename instigate::stl::unary_function::interface<UF> UFI;
        UF m_function;
        typename UFI::argument_type m_argument;

public:
        typedef typename UFI::result_type result_type;

        result_type operator() () const
        {
                return UFI::invoke(m_function, m_argument);
        }

        ubinder(UF f, typename UFI::argument_type x) throw()
                : m_function(f)
                , m_argument(x)
        {}

}; // struct instigate::stl::ubinder

template <typename UF, typename Value>
inline instigate::stl::ubinder<UF> 
instigate::stl::bind(UF f, const Value& x)
{
        CHECK(instigate::stl::unary_function::requirements<UF>);
        typedef instigate::stl::unary_function::interface<UF> UFI;
        CHECK_CONVERTIBILITY(Value, typename UFI::argument_type);
        return instigate::stl::ubinder<UF>(f, x);
}

template <typename BF>
struct instigate::stl::bbinder
{
private:
        typedef typename instigate::stl::binary_function::interface<BF> BFI;
        BF m_function;
        typename BFI::first_argument_type m_argument1;
        typename BFI::second_argument_type m_argument2;
public:
        typedef typename BFI::result_type result_type;
        
        result_type operator() ()
        {
                return BFI::invoke(m_function, m_argument1, m_argument2);
        }

        bbinder(const BF& f, const typename BFI::first_argument_type& x, 
                        const typename BFI::second_argument_type& y)  throw()
                 : m_function(f)
                 , m_argument1(x)
                 , m_argument2(y)
        {}

}; // struct instigate::stl::bbinder

template <typename BF, typename Value1, typename Value2>
inline instigate::stl::bbinder<BF> 
instigate::stl::bind(BF f, const Value1& x, const Value2& y) 
{
        CHECK(instigate::stl::binary_function::requirements<BF>);
        typedef instigate::stl::binary_function::interface<BF> BFI;
        CHECK_CONVERTIBILITY(Value1, typename BFI::first_argument_type);
        CHECK_CONVERTIBILITY(Value2, typename BFI::second_argument_type);
        return instigate::stl::bbinder<BF>(f, x, y);
}

template <typename BF>
struct instigate::stl::bbinder1st
{
private:
        typedef typename instigate::stl::binary_function::interface<BF> BFI;
        BF m_function;
        typename BFI::first_argument_type m_argument;
public:
        typedef typename BFI::result_type result_type;
        
        typedef typename BFI::second_argument_type argument_type;
        
        result_type operator() (argument_type v) const
        {
                return BFI::invoke(m_function, m_argument, v);
        }
        
        bbinder1st(BF f, typename BFI::first_argument_type x)  throw()
                 : m_function(f)
                 , m_argument(x)
        {}

}; // struct instigate::stl::bbinder1st

template <typename BF, typename Value>
inline instigate::stl::bbinder1st<BF> 
instigate::stl::bind1st( BF f, const Value& x )
{
        CHECK(instigate::stl::binary_function::requirements<BF>);
        typedef instigate::stl::binary_function::interface<BF> BFI;
        CHECK_CONVERTIBILITY(Value, typename BFI::first_argument_type);
        return instigate::stl::bbinder1st<BF>(f, x);
}

template <typename BF>
class instigate::stl::bbinder2nd
{
private:
        typedef typename instigate::stl::binary_function::interface<BF> BFI;
        BF m_function;
        typename BFI::second_argument_type m_argument;
public:
        typedef typename BFI::result_type result_type;

        typedef typename BFI::first_argument_type argument_type;

        result_type operator() (argument_type v) const
        {
                return BFI::invoke(m_function, v, m_argument);
        }

        bbinder2nd(BF f, typename BFI::second_argument_type x)  throw()
                 : m_function(f)
                 , m_argument(x)
        {}

}; // struct instigate::stl::bbinder2nd

template <typename BF, typename Value>
inline instigate::stl::bbinder2nd<BF> 
instigate::stl::bind2nd(BF f, const Value& x)
{
        CHECK(instigate::stl::binary_function::requirements<BF>);
        typedef instigate::stl::binary_function::interface<BF> BFI;
        CHECK_CONVERTIBILITY(Value, typename BFI::second_argument_type);
        return instigate::stl::bbinder2nd<BF>(f, x);
}

template <typename TF>
struct instigate::stl::tbinder
{
private:
        typedef typename instigate::stl::ternary_function::interface<TF> TFI;
        TF m_function;
        typename TFI::first_argument_type m_argument1;
        typename TFI::second_argument_type m_argument2;
        typename TFI::third_argument_type m_argument3;

public:
        typedef typename TFI::result_type result_type;

        result_type operator() ()
        {
                return TFI::invoke(m_function, m_argument1, m_argument2,
                                        m_argument3);
        }

        tbinder(
                TF f, 
                const typename TFI::first_argument_type& x, 
                const typename TFI::second_argument_type& y,
                const typename TFI::third_argument_type& z)  throw()
                 : m_function(f)
                 , m_argument1(x)
                 , m_argument2(y)
                 , m_argument3(z)
        {}

}; // struct instigate::stl::tbinder

template <typename TF, typename Value1, typename Value2, typename Value3>
inline instigate::stl::tbinder<TF> 
instigate::stl::bind(TF f, const Value1& x,const Value2& y, const Value3& z)
{
        CHECK(instigate::stl::ternary_function::requirements<TF>);
        typedef instigate::stl::ternary_function::interface<TF> TFI;
        CHECK_CONVERTIBILITY(Value1, typename TFI::first_argument_type);
        CHECK_CONVERTIBILITY(Value2, typename TFI::second_argument_type);
        CHECK_CONVERTIBILITY(Value3, typename TFI::third_argument_type);
        return instigate::stl::tbinder<TF>(f, x, y, z);
}

template <typename TF>
struct instigate::stl::tbinder1st
{
private:
        typedef typename instigate::stl::ternary_function::interface<TF> TFI;
        TF m_function;
        typename TFI::first_argument_type m_argument;

public:
        typedef typename TFI::result_type result_type;

        typedef typename TFI::second_argument_type first_argument_type;

        typedef typename TFI::third_argument_type second_argument_type;

        result_type operator() (first_argument_type v, second_argument_type w) const
        {
                return TFI::invoke(m_function, m_argument, v, w);
        }


        tbinder1st(TF f, typename TFI::first_argument_type x)  throw()
                 : m_function(f)
                 , m_argument(x)
        {}

}; // struct instigate::stl::tbinder1st

template <typename TF, typename Value>
inline instigate::stl::tbinder1st<TF> 
instigate::stl::tbind1st( TF f, const Value& x )
{
        CHECK(instigate::stl::ternary_function::requirements<TF>);
        typedef instigate::stl::ternary_function::interface<TF> TFI;
        CHECK_CONVERTIBILITY(Value, typename TFI::first_argument_type);
        return instigate::stl::tbinder1st<TF>(f, x);
}

template <typename TF>
class instigate::stl::tbinder2nd
{
private:
        typedef typename instigate::stl::ternary_function::interface<TF> TFI;
        TF m_function;
        typename TFI::second_argument_type m_argument;

public:
        typedef typename TFI::result_type result_type;

        typedef typename TFI::first_argument_type first_argument_type;

        typedef typename TFI::third_argument_type second_argument_type;

        result_type operator() (first_argument_type v, second_argument_type w)
        {
                return TFI::invoke(m_function, v, m_argument, w);
        }

        tbinder2nd(TF f, typename TFI::second_argument_type x)  throw()
                : m_function(f)
                , m_argument(x)
        {}

}; // struct instigate::stl::tbinder2nd

template <typename TF, typename Value>
inline instigate::stl::tbinder2nd<TF> 
instigate::stl::tbind2nd( TF f, const Value& x )
{
        CHECK(instigate::stl::ternary_function::requirements<TF>);
        typedef instigate::stl::ternary_function::interface<TF> TFI;
        CHECK_CONVERTIBILITY(Value, typename TFI::second_argument_type);
        return instigate::stl::tbinder2nd<TF>(f, x);
}

template <typename TF>
class instigate::stl::tbinder3rd
{
private:
        typedef typename instigate::stl::ternary_function::interface<TF> TFI;
        TF m_function;
        typename TFI::third_argument_type m_argument;

public:
        typedef typename TFI::result_type result_type;

        typedef typename TFI::first_argument_type first_argument_type;

        typedef typename TFI::second_argument_type second_argument_type;

        result_type operator() (first_argument_type v, second_argument_type w)
        {
                return TFI::invoke(m_function, v, w, m_argument);
        }

        tbinder3rd(TF f, typename TFI::third_argument_type x)  throw()
                : m_function(f)
                , m_argument(x)
        {}

}; // struct instigate::stl::tbinder3rd

template <typename TF, typename Value>
inline instigate::stl::tbinder3rd<TF> 
instigate::stl::tbind3rd( TF f, const Value& x )
{
        CHECK(instigate::stl::ternary_function::requirements<TF>);
        typedef instigate::stl::ternary_function::interface<TF> TFI;
        CHECK_CONVERTIBILITY(Value, typename TFI::third_argument_type);
        return instigate::stl::tbinder3rd<TF>(f, x);
}

template <typename UF1, typename UF2>
class instigate::stl::unary_compose 
{
private:
        UF1 m_uf1;
        UF2 m_uf2;

        typedef typename instigate::stl::unary_function::interface<UF1> UF1I;
        typedef typename instigate::stl::unary_function::interface<UF2> UF2I;
public:
        typedef typename UF1I::result_type result_type;

        typedef typename UF2I::argument_type argument_type;

        result_type operator() (argument_type a) const
        {
                return UF1I::invoke(m_uf1, UF2I::invoke(m_uf2, a));
        }
        
        unary_compose(UF1 uf1, UF2 uf2) 
                : m_uf1(uf1)
                , m_uf2(uf2)
        {
        }
};

template <typename UF1, typename UF2>
instigate::stl::unary_compose<UF1, UF2> 
instigate::stl::compose(UF1 f1, UF2 f2)
{
        CHECK(instigate::stl::unary_function::requirements<UF1>);
        CHECK(instigate::stl::unary_function::requirements<UF2>);
        typedef instigate::stl::unary_function::interface<UF1> UFI1;
        typedef instigate::stl::unary_function::interface<UF2> UFI2;
        CHECK_CONVERTIBILITY(typename UFI2::result_type, 
                        typename UFI1::argument_type);
        return instigate::stl::unary_compose<UF1, UF2>(f1, f2);
}

template <typename BF, typename UF1, typename UF2>
class instigate::stl::binary_compose 
{
private:
        BF m_bf;
        UF1 m_uf1;
        UF2 m_uf2;
        typedef typename instigate::stl::binary_function::interface<BF> BFI;
        typedef typename instigate::stl::unary_function::interface<UF1> UF1I;
        typedef typename instigate::stl::unary_function::interface<UF2> UF2I;
public:
        typedef typename BFI::result_type result_type;

        typedef typename UF1I::argument_type argument_type;

        result_type operator() (argument_type a)
        {
                return BFI::invoke(m_bf, UF1I::invoke(m_uf1, a), 
                                UF2I::invoke(m_uf2, a));
        }

        binary_compose(BF bf, UF1 uf1, UF2 uf2) 
                : m_bf(bf)
                , m_uf1(uf1)
                , m_uf2(uf2)
        {
        }
};


template <typename BF, typename UF1, typename UF2>
instigate::stl::binary_compose<BF, UF1, UF2> 
instigate::stl::compose(BF b, UF1 f1, UF2 f2)
{
        CHECK(instigate::stl::binary_function::requirements<BF>);
        CHECK(instigate::stl::unary_function::requirements<UF1>);
        CHECK(instigate::stl::unary_function::requirements<UF2>);
        typedef instigate::stl::binary_function::interface<BF> BFI;
        typedef instigate::stl::unary_function::interface<UF1> UFI1;
        typedef instigate::stl::unary_function::interface<UF2> UFI2;
        CHECK_CONVERTIBILITY(typename UFI1::result_type, 
                             typename BFI::first_argument_type);
        CHECK_CONVERTIBILITY(typename UFI2::result_type, 
                             typename BFI::second_argument_type);
        return instigate::stl::binary_compose<BF, UF1, UF2>(b, f1, f2);
}

template <typename T>
class instigate::stl::constant_generator {
private:
        T m_t;
        
public:
        T operator()()        
        {
                return m_t;
        }

        constant_generator(T t)
                : m_t(t)
        {
        }
                
}; // class instigate::stl::constant_generator

template <typename BP>
struct instigate::stl::bnot2
{
private:
        typedef typename instigate::stl::binary_predicate::interface<BP> BPI;
        BP m_predicate;

public:
        typedef typename BPI::result_type result_type;

        typedef typename BPI::first_argument_type first_argument_type;

        typedef typename BPI::second_argument_type second_argument_type;

        result_type operator() (first_argument_type f,
                        second_argument_type s)
        {
                return ! BPI::invoke(m_predicate, f, s);
        }

        bnot2(BP p) throw()
                : m_predicate(p)
        {}

}; // struct instigate::stl::bnot2

template <typename BP>
inline instigate::stl::bnot2<BP> 
instigate::stl::not2(BP p)
{
        CHECK(instigate::stl::binary_predicate::requirements<BP>);
        return instigate::stl::bnot2<BP>(p);
}

template <typename UP>
struct instigate::stl::unot1
{
private:
        typedef typename instigate::stl::unary_predicate::interface<UP> UPI;
        UP m_predicate;

public:
        typedef typename UPI::result_type result_type;

        typedef typename UPI::argument_type argument_type;

        result_type operator() (argument_type a)
        {
                return ! UPI::invoke(m_predicate, a);
        }

        unot1(UP p) throw()
                : m_predicate(p)
        {}

}; // struct instigate::stl::unot1

template <typename UP>
inline instigate::stl::unot1<UP> 
instigate::stl::not1(UP p)
{
        CHECK(instigate::stl::unary_predicate::requirements<UP>);
        return instigate::stl::unot1<UP>(p);
}


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

#endif // INSTIGATE_STL_FUNCTIONAL_HPP

---

© Instigate CJSC, Open Source