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 _Functor, class res_type>
        struct FunctorRef0
        {
          FunctorRef0( _Functor & f_r )
          : _f( f_r )
          {}

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

        private:
          _Functor & _f;
        };

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

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

        private:
          _Functor & _f;
        };

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

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

        private:
          _Functor & _f;
        };

      struct nil
      {};
    }

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

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

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

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



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

      template<class _Tp>
      T operator()( _Tp ) const
      { return _value; }

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

      T _value;
    };

    template<class T>
    inline Constant<T> constant( const T &value )
    { return Constant<T>(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 _Condition>
      struct Not
      {
        Not( _Condition cond_r )
        : _cond( cond_r )
        {}

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

        _Condition _cond;
      };

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

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

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

        _ACondition _conda;
        _BCondition _condb;
      };

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

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

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

        _ACondition _conda;
        _BCondition _condb;
      };

    template<class _ACondition, class _BCondition>
      inline Chain<_ACondition, _BCondition> chain( _ACondition conda_r, _BCondition condb_r )
      {
        return Chain<_ACondition, _BCondition>( 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 _OutputIterator>
    struct GetAll
    {
      GetAll( _OutputIterator result_r )
        : _result( result_r )
      {}

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

      private:
        mutable _OutputIterator _result;
    };

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


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