compose.h

Go to the documentation of this file.

// -*- C++ -*-

#if !defined(__ads_compose_h__)
#define __ads_compose_h__

#include "../defs.h"

#include <functional>

BEGIN_NAMESPACE_ADS

//-----------------------------------------------------------------------------
// @{


template <class F, class G>
class unary_compose_unary_unary
  : public std::unary_function< typename G::argument_type,
                                typename F::result_type >
{
private:
  typedef std::unary_function< typename G::argument_type,
                               typename F::result_type > base_type;
protected:
  F _f;
  G _g;

public:
  typedef typename base_type::argument_type argument_type;
  typedef typename base_type::result_type result_type;

  unary_compose_unary_unary() 
    : _f(), _g() 
  {}

  unary_compose_unary_unary( const F& f, const G& g ) 
    : _f( f ), _g( g ) 
  {}

  result_type
  operator()( const argument_type& x ) const {
    return _f( _g( x ) );
  }
};


template <class F, class G>
class binary_compose_unary_binary
  : public std::binary_function< typename G::first_argument_type,
                                 typename G::second_argument_type,
                                 typename F::result_type >
{
private:
  typedef std::binary_function< typename G::first_argument_type,
                                typename G::second_argument_type,
                                typename F::result_type > base_type;
protected:
  F _f;
  G _g;

public:
  typedef typename base_type::first_argument_type first_argument_type;
  typedef typename base_type::second_argument_type second_argument_type;
  typedef typename base_type::result_type result_type;

  binary_compose_unary_binary()
    : _f(), _g() 
  {}

  binary_compose_unary_binary( const F& f, const G& g ) 
    : _f( f ), _g( g ) 
  {}

  result_type
  operator()( const first_argument_type& x, const second_argument_type& y ) 
    const {
    return _f( _g( x, y ) );
  }
};



template <class F, class G, class H>
class unary_compose_binary_unary
  : public std::unary_function< typename G::argument_type,
                                typename F::result_type >
{
private:
  typedef std::unary_function< typename G::argument_type,
                               typename F::result_type > base_type;
protected:
  F _f;
  G _g;
  H _h;

public:
  typedef typename base_type::argument_type argument_type;
  typedef typename base_type::result_type result_type;

  unary_compose_binary_unary()
    : _f(), _g(), _h() 
  {}

  unary_compose_binary_unary( const F& f, const G& g, const H& h ) 
    : _f( f ), _g( g ), _h( h ) 
  {}

  result_type
  operator()( const argument_type& x ) const {
    return _f( _g( x ), _h( x ) );
  }
};


template <class F, class G, class H>
class binary_compose_binary_unary
  : public std::binary_function< typename G::argument_type,
                                 typename H::argument_type,
                                 typename F::result_type >
{
private:
  typedef std::binary_function< typename G::argument_type,
                                typename H::argument_type,
                                typename F::result_type > base_type;
protected:
  F _f;
  G _g;
  H _h;

public:
  typedef typename base_type::first_argument_type first_argument_type;
  typedef typename base_type::second_argument_type second_argument_type;
  typedef typename base_type::result_type result_type;

  binary_compose_binary_unary()
    : _f(), _g(), _h()
  {}

  binary_compose_binary_unary( const F& f, const G& g, const H& h ) 
    : _f( f ), _g( g ), _h( h )
  {}

  result_type
  operator()( const first_argument_type& x, const second_argument_type& y ) 
    const {
    return _f( _g( x ), _h( y ) );
  }

  // CONTINUE: Are these a good idea?  Should I add them to the rest of the 
  // functors?
  F&
  outer()
  {
    return _f;
  }

  G&
  first_inner()
  {
    return _g;
  }

  H&
  second_inner()
  {
    return _h;
  }
};

// @}

END_NAMESPACE_ADS

#endif

---