functional.hpp

Go to the documentation of this file.

/*
  CLAW - a C++ Library Absolutely Wonderful
 
  CLAW is a free library without any particular aim but being useful to
  anyone.
 
  Copyright (C) 2005-2011 Julien Jorge
 
  This library is free software; you can redistribute it and/or
  modify it under the terms of the GNU Lesser General Public
  License as published by the Free Software Foundation; either
  version 2.1 of the License, or (at your option) any later version.
 
  This library is distributed in the hope that it will be useful,
  but WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  Lesser General Public License for more details.
 
  You should have received a copy of the GNU Lesser General Public
  License along with this library; if not, write to the Free Software
  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 
  contact: julien.jorge@stuff-o-matic.com
*/
#ifndef __CLAW_FUNCTIONAL_HPP__
#define __CLAW_FUNCTIONAL_HPP__
 
#include <functional>
#include <utility>
 
namespace claw
{
  template <class T1, class T2>
  class first : public std::unary_function<std::pair<T1, T2>, T1&>
  {
  public:
    T1& operator()(std::pair<T1, T2>& p) const
    {
      return p.first;
    }
  }; // class first

  template <class T1, class T2>
  class const_first
    : public std::unary_function<const std::pair<T1, T2>, const T1&>
  {
  public:
    const T1& operator()(const std::pair<T1, T2>& p) const
    {
      return p.first;
    }
 
  }; // class const_first

  template <class Pair>
  class pair_first
    : public first<typename Pair::first_type, typename Pair::second_type>
  {
    // nothing
  }; // class pair_first

  template <class Pair>
  class const_pair_first
    : public const_first<typename Pair::first_type, typename Pair::second_type>
  {
    // nothing
  }; // class const_pair_first

  template <class T1, class T2>
  class second : public std::unary_function<std::pair<T1, T2>, T2&>
  {
  public:
    T2& operator()(std::pair<T1, T2>& p) const
    {
      return p.second;
    }
  }; // class second

  template <class T1, class T2>
  class const_second
    : public std::unary_function<const std::pair<T1, T2>, const T2&>
  {
  public:
    const T2& operator()(const std::pair<T1, T2>& p) const
    {
      return p.second;
    }
 
  }; // class const_second

  template <class Pair>
  class pair_second
    : public second<typename Pair::first_type, typename Pair::second_type>
  {
    // nothing
  }; // class pair_second

  template <class Pair>
  class const_pair_second
    : public const_second<typename Pair::first_type,
                          typename Pair::second_type>
  {
  public:
    const_pair_second()
    {}
 
    template <typename F, typename S>
    const_pair_second(const second<F, S>&)
    {}
 
  }; // class const_pair_second

  template <class T>
  class unary_true : public std::unary_function<T, bool>
  {
  public:
    bool operator()(const T& t) const
    {
      return true;
    }
  }; // class unary_true

  template <class T, class U>
  class binary_true : public std::binary_function<T, U, bool>
  {
  public:
    bool operator()(const T& t, const U& u) const
    {
      return true;
    }
  }; // class binary_true

  template <typename F1, typename F2>
  class unary_compose
    : public std::unary_function<typename F2::argument_type,
                                 typename F1::result_type>
  {
  public:
    unary_compose()
    {}

    template <typename G1, typename G2>
    unary_compose(const unary_compose<G1, G2>& that)
    {}

    typename F1::result_type operator()(typename F2::argument_type& a) const
    {
      return F1()(F2()(a));
    }
  }; // class unary_compose

  template <typename T>
  class delete_function : public std::unary_function<T, void>
  {
  public:
    void operator()(const T& a) const
    {
      delete a;
    }
  }; // class delete_function

  template <typename T>
  class clone : public std::unary_function<T*, T*>
  {
  public:
    T* operator()(const T* a) const
    {
      return new T(*a);
    }
  }; // class clone

  template <typename T>
  class dereference : public std::unary_function<T*, T&>
  {
  public:
    T& operator()(T* a) const
    {
      return *a;
    }
 
  }; // class dereference

  template <typename T>
  class const_dereference : public std::unary_function<const T*, const T&>
  {
  public:
    const_dereference()
    {}
    const_dereference(const dereference<T>&)
    {}
    const_dereference(const const_dereference<T>&)
    {}
 
    const T& operator()(const T* a) const
    {
      return *a;
    }
 
  }; // class const_dereference
}
 
#endif // __CLAW_FUNCTIONAL_HPP__