spatial_closed_region.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_CLOSED_REGION_HPP
#define SPATIAL_CLOSED_REGION_HPP

#include "spatial_region.hpp"

namespace spatial
{
  template <typename Key, typename Compare>
  class closed_bounds
    : private Compare // empty member optimization
  {
  public:
    closed_bounds() : Compare(), _lower(), _upper() { }

    closed_bounds(const Compare& compare, const Key& lower,
                        const Key& upper)
      : Compare(compare), _lower(lower), _upper(upper)
    { }

    relative_order
    operator()(dimension_type dim, dimension_type, const Key& key) const
    {
      return (Compare::operator()(dim, key, _lower)
              ? below
              : (Compare::operator()(dim, _upper, key)
                 ? above
                 : matching));
    }

  private:
    Key _lower;

    Key _upper;
  };

  template <typename Tp>
  closed_bounds<typename container_traits<Tp>::key_type,
                typename container_traits<Tp>::key_compare>
  make_closed_bounds
  (const Tp& container,
   const typename container_traits<Tp>::key_type& lower,
   const typename container_traits<Tp>::key_type& upper)
  {
    except::check_closed_bounds(container, lower, upper);
    return closed_bounds
      <typename container_traits<Tp>::key_type,
      typename container_traits<Tp>::key_compare>
      (container.key_comp(), lower, upper);
  }

  template<typename Ct>
  struct closed_region_iterator
    : region_iterator
      <Ct, closed_bounds<typename container_traits<Ct>::key_type,
                         typename container_traits<Ct>::key_compare> >
  {
    closed_region_iterator() { }

    closed_region_iterator
    (const region_iterator
     <Ct, closed_bounds<typename container_traits<Ct>::key_type,
                        typename container_traits<Ct>::key_compare> >&
     other)
      : region_iterator
        <Ct, closed_bounds<typename container_traits<Ct>::key_type,
                           typename container_traits<Ct>::key_compare> >
        (other) { }
  };

  template<typename Ct>
  struct closed_region_iterator<const Ct>
    : region_iterator
      <const Ct, closed_bounds<typename container_traits<Ct>::key_type,
                               typename container_traits<Ct>::key_compare> >
  {
    closed_region_iterator() { }

    closed_region_iterator
    (const region_iterator
     <const Ct, closed_bounds<typename container_traits<Ct>::key_type,
                              typename container_traits<Ct>::key_compare> >&
     other)
      : region_iterator
        <const Ct, closed_bounds<typename container_traits<Ct>::key_type,
                                 typename container_traits<Ct>::key_compare> >
        (other) { }

    closed_region_iterator
    (const region_iterator
     <Ct, closed_bounds<typename container_traits<Ct>::key_type,
                        typename container_traits<Ct>::key_compare> >&
     other)
      : region_iterator
        <const Ct, closed_bounds<typename container_traits<Ct>::key_type,
                                 typename container_traits<Ct>::key_compare> >
        (other) { }
  };

  template<typename Ct>
  struct closed_region_iterator_pair
    : region_iterator_pair
  <Ct, closed_bounds<typename container_traits<Ct>::key_type,
                     typename container_traits<Ct>::key_compare> >
  {
  closed_region_iterator_pair() { }

  closed_region_iterator_pair
  (const region_iterator
   <Ct, closed_bounds<typename container_traits<Ct>::key_type,
                      typename container_traits<Ct>::key_compare> >& a,
   const region_iterator
    <Ct, closed_bounds<typename container_traits<Ct>::key_type,
                       typename container_traits<Ct>::key_compare> >& b)
    : region_iterator_pair
      <Ct, closed_bounds<typename container_traits<Ct>::key_type,
                         typename container_traits<Ct>::key_compare> >
      (a, b) { }
  };

  template<typename Ct>
  struct closed_region_iterator_pair<const Ct>
    : region_iterator_pair
      <const Ct, closed_bounds<typename container_traits<Ct>::key_type,
                               typename container_traits<Ct>::key_compare> >
  {
    closed_region_iterator_pair() { }

    closed_region_iterator_pair
    (const region_iterator
     <const Ct, closed_bounds<typename container_traits<Ct>::key_type,
                              typename container_traits<Ct>::key_compare> >& a,
     const region_iterator
     <const Ct, closed_bounds<typename container_traits<Ct>::key_type,
                              typename container_traits<Ct>::key_compare> >& b)
      : region_iterator_pair
        <const Ct, closed_bounds<typename container_traits<Ct>::key_type,
                                 typename container_traits<Ct>::key_compare> >
        (a, b) { }

    closed_region_iterator_pair(const closed_region_iterator_pair<Ct>& other)
      : region_iterator_pair
        <const Ct, closed_bounds<typename container_traits<Ct>::key_type,
                                 typename container_traits<Ct>::key_compare> >
        (other) { }
  };

  template <typename Ct>
  inline closed_region_iterator<Ct>
  closed_region_end(Ct& container,
                    const typename container_traits<Ct>::key_type& lower,
                    const typename container_traits<Ct>::key_type& upper)
  { return region_end(container, make_closed_bounds(container, lower, upper)); }

  template <typename Ct>
  inline closed_region_iterator<const Ct>
  closed_region_end(const Ct& container,
                    const typename container_traits<Ct>::key_type& lower,
                    const typename container_traits<Ct>::key_type& upper)
  { return region_end(container, make_closed_bounds(container, lower, upper)); }

  template <typename Ct>
  inline closed_region_iterator<const Ct>
  closed_region_cend(const Ct& container,
                     const typename container_traits<Ct>::key_type& lower,
                     const typename container_traits<Ct>::key_type& upper)
  {
    return region_cend(container, make_closed_bounds(container, lower, upper));
  }

  template <typename Ct>
  inline closed_region_iterator<Ct>
  closed_region_begin(Ct& container,
                      const typename container_traits<Ct>::key_type& lower,
                      const typename container_traits<Ct>::key_type& upper)
  {
    return region_begin(container, make_closed_bounds(container, lower, upper));
  }

  template <typename Ct>
  inline closed_region_iterator<const Ct>
  closed_region_begin(const Ct& container,
                      const typename container_traits<Ct>::key_type& lower,
                      const typename container_traits<Ct>::key_type& upper)
  {
    return region_begin(container, make_closed_bounds(container, lower, upper));
  }

  template <typename Ct>
  inline closed_region_iterator<const Ct>
  closed_region_cbegin(const Ct& container,
                       const typename container_traits<Ct>::key_type& lower,
                       const typename container_traits<Ct>::key_type& upper)
  {
    return region_cbegin(container,
                         make_closed_bounds(container, lower, upper));
  }

  template <typename Ct>
  inline closed_region_iterator_pair<Ct>
  closed_region_range(Ct& container,
                      const typename container_traits<Ct>::key_type& lower,
                      const typename container_traits<Ct>::key_type& upper)
  {
    return region_range(container, make_closed_bounds(container, lower, upper));
  }

  template <typename Ct>
  inline closed_region_iterator_pair<const Ct>
  closed_region_range(const Ct& container,
                      const typename container_traits<Ct>::key_type& lower,
                      const typename container_traits<Ct>::key_type& upper)
  {
    return region_range(container, make_closed_bounds(container, lower, upper));
  }

  template <typename Ct>
  inline closed_region_iterator_pair<const Ct>
  closed_region_crange(const Ct& container,
                       const typename container_traits<Ct>::key_type& lower,
                       const typename container_traits<Ct>::key_type& upper)
  {
    return region_crange(container,
                         make_closed_bounds(container, lower, upper));
  }

} // namespace spatial

#endif // SPATIAL_CLOSED_REGION_HPP