function.hpp

// -*- C++ -*-
//
// Copyright Sylvain Bougerel 2009 - 2013.
// Distributed under the Boost Software License, Version 1.0.
// (See accompanying file COPYING or copy at
// http://www.boost.org/LICENSE_1_0.txt)

#ifndef SPATIAL_FUNCTION_HPP
#define SPATIAL_FUNCTION_HPP

#include <iterator> // std::advance
#include "spatial.hpp"

namespace spatial
{
  template <typename Accessor, typename Tp, typename Unit>
  struct accessor_minus
    : private Accessor // empty member optimization
  {
    explicit accessor_minus(Accessor accessor_ = Accessor())
      : Accessor(accessor_)
    { }

    template <typename AnyUnit>
    accessor_minus(const accessor_minus<Accessor, Tp, AnyUnit>& other)
      : Accessor(other.accessor())
    { }

    Unit
    operator() (dimension_type n, const Tp& x, const Tp& y) const
    { return Accessor::operator()(n, x) - Accessor::operator()(n, y); }

    Accessor accessor() const { return *static_cast<const Accessor*>(this); }
  };

  template <typename Tp, typename Unit>
  struct bracket_minus
  {
    bracket_minus() { }

    template <typename AnyUnit>
    bracket_minus(const bracket_minus<Tp, AnyUnit>&) { }

    Unit
    operator() (dimension_type n, const Tp& x, const Tp& y) const
    { return x[n] - y[n]; }
  };

  template <typename Tp, typename Unit>
  struct paren_minus
  {
    paren_minus() { }

    template <typename AnyUnit>
    paren_minus(const paren_minus<Tp, AnyUnit>&) { }

    Unit
    operator() (dimension_type n, const Tp& x, const Tp& y) const
    { return x(n) - y(n); }
  };

  template <typename Tp, typename Unit>
  struct iterator_minus
  {
    iterator_minus() { }

    template <typename AnyUnit>
    iterator_minus(const iterator_minus<Tp, AnyUnit>&) { }

    Unit
    operator() (dimension_type n, const Tp& x, const Tp& y) const
    {
      typename Tp::const_iterator ix = x.begin();
      typename Tp::const_iterator iy = y.begin();
      {
        using namespace std;
        typedef typename std::iterator_traits<typename Tp::const_iterator>
          ::difference_type diff_t;
        advance(ix, static_cast<diff_t>(n));
        advance(iy, static_cast<diff_t>(n));
      }
      return *ix - *iy;
    }
  };

  template<typename Accessor, typename Tp>
  struct accessor_less
    : private Accessor // empty member optimization
  {
    explicit accessor_less(Accessor access = Accessor())
      : Accessor(access)
    { }

    bool
    operator() (dimension_type n, const Tp& x, const Tp& y) const
    {
      return (Accessor::operator()(n, x) < Accessor::operator()(n, y));
    }

    bool operator()
    (dimension_type a, const Tp& x, dimension_type b, const Tp& y) const
    {
      return (Accessor::operator()(a, x) < Accessor::operator()(b, y));
    }

    const Accessor& accessor() const
    { return *static_cast<const Accessor*>(this); }
  };

  template <typename Tp>
  struct bracket_less
  {
    bool
    operator() (dimension_type n, const Tp& x, const Tp& y) const
    {
      return (x[n] < y[n]);
    }

    bool operator()
    (dimension_type a, const Tp& x, dimension_type b, const Tp& y) const
    {
      return (x[a] < y[b]);
    }
  };

  template <typename Tp>
  struct paren_less
  {
    bool
    operator() (dimension_type n, const Tp& x, const Tp& y) const
    {
      return (x(n) < y(n));
    }

    bool operator()
    (dimension_type a, const Tp& x, dimension_type b, const Tp& y) const
    {
      return (x(a) < y(b));
    }
  };

  template <typename Tp>
  struct iterator_less
  {
    bool
    operator() (dimension_type n, const Tp& x, const Tp& y) const
    {
      typename Tp::const_iterator ix = x.begin();
      typename Tp::const_iterator iy = y.begin();
      {
        using namespace std;
        typedef typename std::iterator_traits<typename Tp::const_iterator>
          ::difference_type diff_t;
        advance(ix, static_cast<diff_t>(n));
        advance(iy, static_cast<diff_t>(n));
      }
      return (*ix < *iy);
    }

    bool operator()
    (dimension_type a, const Tp& x, dimension_type b, const Tp& y) const
    {
      typename Tp::const_iterator ix = x.begin();
      typename Tp::const_iterator iy = y.begin();
      {
        using namespace std;
        typedef typename std::iterator_traits<typename Tp::const_iterator>
          ::difference_type diff_t;
        advance(ix, static_cast<diff_t>(a));
        advance(iy, static_cast<diff_t>(b));
      }
      return (*ix < *iy);
    }
  };

} // namespace spatial

#endif // SPATIAL_FUNCTION_HPP