Functional.h

Go to the documentation of this file.

/*---------------------------------------------------------------------\
|                          ____ _   __ __ ___                          |
|                         |__  / \ / / . \ . \                         |
|                           / / \ V /|  _/  _/                         |
|                          / /__ | | | | | |                           |
|                         /_____||_| |_| |_|                           |
|                                                                      |
\---------------------------------------------------------------------*/
#ifndef ZYPP_BASE_FUNCTIONAL_H
#define ZYPP_BASE_FUNCTIONAL_H

#include <boost/functional.hpp>

#include "zypp/base/Function.h"

namespace zypp
{ 

  /* http://www.boost.org/libs/functional/mem_fun.html

   The header functional.hpp includes improved versions of
   the full range of member function adapters from the
   C++ Standard Library.
  */
  using boost::mem_fun;
  using boost::mem_fun_ref;

  namespace functor
  { 


    namespace functor_detail
    {
      template <class TFunctor, class res_type>
        struct FunctorRef0
        {
          FunctorRef0( TFunctor & f_r )
          : _f( f_r )
          {}

          res_type operator()() const
          {
          return _f();
          }

        private:
          TFunctor & _f;
        };

      template <class TFunctor, class res_type, class arg1_type>
        struct FunctorRef1 : public std::unary_function<arg1_type, res_type>
        {
          FunctorRef1( TFunctor & f_r )
          : _f( f_r )
          {}

          res_type operator()( arg1_type a1 ) const
          {
            return _f( a1 );
          }

        private:
          TFunctor & _f;
        };

      template <class TFunctor, class res_type, class arg1_type, class arg2_type>
        struct FunctorRef2 : public std::binary_function<arg1_type, arg2_type, res_type>
        {
          FunctorRef2( TFunctor & f_r )
          : _f( f_r )
          {}

          res_type operator()( arg1_type a1, arg2_type a2 ) const
          {
            return _f( a1, a2 );
          }

        private:
          TFunctor & _f;
        };

      struct nil
      {};
    }

    template <class TFunctor, class res_type, class arg1_type = functor_detail::nil,
                                              class arg2_type = functor_detail::nil>
      struct FunctorRef
      : public functor_detail::FunctorRef2<TFunctor, res_type, arg1_type, arg2_type>
      {
        FunctorRef( TFunctor & f_r )
        : functor_detail::FunctorRef2<TFunctor, res_type, arg1_type, arg2_type>( f_r )
        {}
      };

    template <class TFunctor, class res_type, class arg1_type>
      struct FunctorRef<TFunctor, res_type, arg1_type>
      : public functor_detail::FunctorRef1<TFunctor, res_type, arg1_type>
      {
        FunctorRef( TFunctor & f_r )
        : functor_detail::FunctorRef1<TFunctor, res_type, arg1_type>( f_r )
        {}
      };

    template <class TFunctor, class res_type>
      struct FunctorRef<TFunctor, res_type>
      : public functor_detail::FunctorRef0<TFunctor, res_type>
      {
        FunctorRef( TFunctor & f_r )
        : functor_detail::FunctorRef0<TFunctor, res_type>( f_r )
        {}
      };

    template <class res_type, class arg1_type, class arg2_type, class TFunctor>
      FunctorRef<TFunctor, res_type, arg1_type, arg2_type>
      functorRef( TFunctor & f_r )
      { return FunctorRef<TFunctor, res_type, arg1_type, arg2_type>( f_r ); }
    template <class res_type, class arg1_type, class TFunctor>
      FunctorRef<TFunctor, res_type, arg1_type>
      functorRef( TFunctor & f_r )
      { return FunctorRef<TFunctor, res_type, arg1_type>( f_r ); }
    template <class res_type, class TFunctor>
      FunctorRef<TFunctor, res_type>
      functorRef( TFunctor & f_r )
      { return FunctorRef<TFunctor, res_type>( f_r ); }



    /* functor that always returns a copied value */
    template<class TConst>
    struct Constant
    {
      Constant( const TConst &value )
        : _value(value)
      {}

      template<class Tp>
      TConst operator()( Tp ) const
      { return _value; }

      TConst operator()() const
      { return _value; }

      TConst _value;
    };

    template<class TConst>
    inline Constant<TConst> constant( const TConst &value )
    { return Constant<TConst>(value); }

    struct True
    {
      template<class Tp>
        bool operator()( Tp ) const
        {
          return true;
        }
    };

    inline True true_c()
    { return True(); }

    struct False
    {
      template<class Tp>
        bool operator()( Tp ) const
        {
          return false;
        }
    };

    inline False false_c()
    { return False(); }

    template<class TCondition>
      struct Not
      {
        Not( TCondition cond_r )
        : _cond( cond_r )
        {}

        template<class Tp>
          bool operator()( Tp t ) const
          {
            return ! _cond( t );
          }

        TCondition _cond;
      };

    template<class TCondition>
      inline Not<TCondition> not_c( TCondition cond_r )
      {
        return Not<TCondition>( cond_r );
      }

    template<class TACondition, class TBCondition>
      struct Or
      {
        Or( TACondition conda_r, TBCondition condb_r )
        : _conda( conda_r )
        , _condb( condb_r )
        {}

        template<class Tp>
          bool operator()( Tp t ) const
          {
            return _conda( t ) || _condb( t );
          }

        TACondition _conda;
        TBCondition _condb;
      };

    template<class TACondition, class TBCondition>
      inline Or<TACondition, TBCondition> or_c( TACondition conda_r, TBCondition condb_r )
      {
        return Or<TACondition, TBCondition>( conda_r, condb_r );
      }

    template<class TACondition, class TBCondition>
      struct Chain
      {
        Chain( TACondition conda_r, TBCondition condb_r )
        : _conda( conda_r )
        , _condb( condb_r )
        {}

        template<class Tp>
          bool operator()( Tp t ) const
          {
            return _conda( t ) && _condb( t );
          }

        TACondition _conda;
        TBCondition _condb;
      };

    template<class TACondition, class TBCondition>
      inline Chain<TACondition, TBCondition> chain( TACondition conda_r, TBCondition condb_r )
      {
        return Chain<TACondition, TBCondition>( conda_r, condb_r );
      }




    template<class Tp>
    struct GetFirst
    {
      GetFirst( Tp & result_r )
        : _result( &result_r )
      {}
      bool operator()( const Tp & val_r )
      { *_result = val_r; return false; }

      private:
        Tp * _result;
    };

    template<class Tp>
    GetFirst<Tp> getFirst( Tp & result_r )
    { return GetFirst<Tp>( result_r ); }


    template<class Tp>
    struct GetLast
    {
      GetLast( Tp & result_r )
        : _result( &result_r )
      {}
      bool operator()( const Tp & val_r )
      { *_result = val_r; return true; }

      private:
        Tp * _result;
    };

    template<class Tp>
    GetLast<Tp> getLast( Tp & result_r )
    { return GetLast<Tp>( result_r ); }


    template<class TOutputIterator>
    struct GetAll
    {
      GetAll( TOutputIterator result_r )
        : _result( result_r )
      {}

      template<class Tp>
      bool operator()(  const Tp & val_r ) const
      { *(_result++) = val_r; return true; }

      private:
        mutable TOutputIterator _result;
    };

    template<class TOutputIterator>
    GetAll<TOutputIterator> getAll( TOutputIterator result_r )
    { return GetAll<TOutputIterator>( result_r ); }



  } // namespace functor
} // namespace zypp
#endif // ZYPP_BASE_FUNCTIONAL_H