spatial_builtin.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_COMPARE_BUILTIN_HPP
#define SPATIAL_COMPARE_BUILTIN_HPP

#include "spatial_import_type_traits.hpp"
#include "spatial_check_concept.hpp"

namespace spatial
{
  // Forward declarations for builtin compartors and difference
  template<typename Accessor, typename Tp, typename Unit> struct accessor_minus;
  template<typename Tp, typename Unit> struct bracket_minus;
  template<typename Tp, typename Unit> struct paren_minus;
  template<typename Tp, typename Unit> struct iterator_minus;
  template<typename Accessor, typename Tp> struct accessor_less;
  template<typename Tp> struct bracket_less;
  template<typename Tp> struct paren_less;
  template<typename Tp> struct iterator_less;

  namespace details
  {
    template <typename>
    struct is_compare_builtin_helper : import::false_type { };
    template <typename Tp>
    struct is_compare_builtin_helper<bracket_less<Tp> >
      : import::true_type { };
    template <typename Tp>
    struct is_compare_builtin_helper<paren_less<Tp> >
      : import::true_type { };
    template <typename Tp>
    struct is_compare_builtin_helper<iterator_less<Tp> >
      : import::true_type { };
    template <typename Accessor, typename Tp>
    struct is_compare_builtin_helper<accessor_less<Accessor, Tp> >
      : import::true_type { };

    template <typename Ct>
    struct is_compare_builtin
      : is_compare_builtin_helper<typename container_traits<Ct>::key_compare>
    { };

    template<typename Container, typename Enable = void>
    struct with_builtin_difference { }; // sink for not using built-in compare

    template<typename Container>
    struct with_builtin_difference
    <Container,
     typename enable_if<is_compare_builtin<Container> >::type>
    {
      template<typename>
      struct builtin_difference { }; // sink type, never used normally

      template<typename Key>
      struct builtin_difference<bracket_less<Key> >
      {
        typedef bracket_minus<Key, void> type;
        type operator() (const bracket_less<Key>&) const
        { return type(); }
      };

      template<typename Key>
      struct builtin_difference<paren_less<Key> >
      {
        typedef paren_minus<Key, void> type;
        type operator() (const paren_less<Key>&) const
        { return type(); }
      };

      template<typename Key>
      struct builtin_difference<iterator_less<Key> >
      {
        typedef iterator_minus<Key, void> type;
        type operator() (const iterator_less<Key>&) const
        { return type(); }
      };

      template<typename Key, typename Accessor>
      struct builtin_difference<accessor_less<Accessor, Key> >
      {
        typedef accessor_minus<Accessor, Key, void> type;
        type operator() (const accessor_less<Accessor, Key>& cmp) const
        { return type(cmp.accessor()); }
      };

      typedef typename builtin_difference
      <typename container_traits<Container>::key_compare>::type type;

      type operator()(const Container& container) const
      {
        return builtin_difference
          <typename container_traits<Container>::key_compare>()
          (container.key_comp());
      }
    };

    template <typename>
    struct is_difference_builtin : import::false_type { };
    template <typename Tp, typename Unit>
    struct is_difference_builtin<bracket_minus<Tp, Unit> >
      : import::true_type { };
    template <typename Tp, typename Unit>
    struct is_difference_builtin<paren_minus<Tp, Unit> >
      : import::true_type { };
    template <typename Tp, typename Unit>
    struct is_difference_builtin<iterator_minus<Tp, Unit> >
      : import::true_type { };
    template <typename Accessor, typename Tp, typename Unit>
    struct is_difference_builtin<accessor_minus<Accessor, Tp, Unit> >
      : import::true_type { };
    template <typename Diff, typename DistanceType>
    struct rebind_builtin_difference
    { typedef Diff type; }; // sink type

    template <typename Tp, typename Unit, typename DistanceType>
    struct rebind_builtin_difference<bracket_minus<Tp, Unit>, DistanceType>
    { typedef bracket_minus<Tp, DistanceType> type; };

    template <typename Tp, typename Unit, typename DistanceType>
    struct rebind_builtin_difference<paren_minus<Tp, Unit>, DistanceType>
    { typedef paren_minus<Tp, DistanceType> type; };

    template <typename Tp, typename Unit, typename DistanceType>
    struct rebind_builtin_difference<iterator_minus<Tp, Unit>, DistanceType>
    { typedef iterator_minus<Tp, DistanceType> type; };

    template <typename Accessor, typename Tp, typename Unit,
              typename DistanceType>
    struct rebind_builtin_difference<accessor_minus<Accessor, Tp, Unit>,
                                     DistanceType>
    { typedef accessor_minus<Accessor, Tp, DistanceType> type; };
  }
}

#endif // SPATIAL_COMPARE_BUILTIN_HPP