FM / index

/usr/include/boost/geometry/index

Name	Size	Mode	Actions
adaptors/	-	0755	rm
detail/	-	0755	rm
distance_predicates.hpp	8380	0644	edit dl rm
equal_to.hpp	10577	0644	edit dl rm
indexable.hpp	10678	0644	edit dl rm
inserter.hpp	1864	0644	edit dl rm
parameters.hpp	11190	0644	edit dl rm
predicates.hpp	12743	0644	edit dl rm
rtree.hpp	82960	0644	edit dl rm

Edit: /usr/include/boost/geometry/index/indexable.hpp (10678B)

#ifndef BOOST_GEOMETRY_INDEX_INDEXABLE_HPP
#define BOOST_GEOMETRY_INDEX_INDEXABLE_HPP

#include <boost/mpl/assert.hpp>
#include <boost/tuple/tuple.hpp>
#include <boost/type_traits/is_reference.hpp>
#include <boost/type_traits/is_same.hpp>
#include <boost/type_traits/remove_const.hpp>
#include <boost/type_traits/remove_reference.hpp>

#include <boost/geometry/index/detail/is_indexable.hpp>

namespace boost { namespace geometry { namespace index { namespace detail {

template <typename T>
struct remove_cr
    : boost::remove_const
        <
            typename boost::remove_reference<T>::type
        >
{};

template <typename From, typename To>
struct is_referencable
    : boost::is_same
        <
            typename remove_cr<From>::type,
            typename remove_cr<To>::type
        >
{};

template <typename Indexable, typename V>
inline Indexable const& indexable_prevent_any_type(V const& )
{
    BOOST_MPL_ASSERT_MSG(
        (false),
        UNEXPECTED_TYPE,
        (V)
    );
    return Indexable();
}

/*!
\brief The function object extracting Indexable from Value.

It translates Value object to Indexable object. The default version handles Values which are Indexables.
This template is also specialized for std::pair<Indexable, T2>, boost::tuple<Indexable, ...>
and std::tuple<Indexable, ...>.

\tparam Value       The Value type which may be translated directly to the Indexable.
\tparam IsIndexable If true, the const reference to Value is returned.
*/
template <typename Value, bool IsIndexable = is_indexable<Value>::value>
struct indexable
{
    BOOST_MPL_ASSERT_MSG(
        (detail::is_indexable<Value>::value),
        NOT_VALID_INDEXABLE_TYPE,
        (Value)
    );

/*! \brief The type of result returned by function object. */
    typedef Value const& result_type;

/*!
    \brief Return indexable extracted from the value.
    
    \param v The value.
    \return The indexable.
    */
    inline result_type operator()(Value const& v) const
    {
        return v;
    }

/*!
    \brief Prevent reference to temporary for types convertible to Value.
    */
    template <typename V>
    inline result_type operator()(V const& v) const
    {
        return indexable_prevent_any_type<Value>(v);
    }
};

/*!
\brief The function object extracting Indexable from Value.

This specialization translates from std::pair<Indexable, T2>.

\tparam Indexable       The Indexable type.
\tparam Second          The second type.
*/
template <typename Indexable, typename Second>
struct indexable<std::pair<Indexable, Second>, false>
{
    typedef std::pair<Indexable, Second> value_type;

BOOST_MPL_ASSERT_MSG(
        (detail::is_indexable<Indexable>::value),
        NOT_VALID_INDEXABLE_TYPE,
        (Indexable)
    );

/*! \brief The type of result returned by function object. */
    typedef Indexable const& result_type;

/*!
    \brief Return indexable extracted from the value.
    
    \param v The value.
    \return The indexable.
    */
    inline result_type operator()(value_type const& v) const
    {
        return v.first;
    }

/*!
    \brief Return indexable extracted from compatible type different than value_type.

\param v The value.
    \return The indexable.
    */
    template <typename I, typename S>
    inline result_type operator()(std::pair<I, S> const& v) const
    {
        BOOST_MPL_ASSERT_MSG(
            (is_referencable<I, result_type>::value),
            UNEXPECTED_TYPE,
            (std::pair<I, S>)
        );
        return v.first;
    }

/*!
\brief The function object extracting Indexable from Value.

This specialization translates from boost::tuple<Indexable, ...>
  or boost::tuples::cons<Indexable, ...>.

\tparam Value       The Value type.
\tparam Indexable   The Indexable type.
*/
template <typename Value, typename Indexable>
struct indexable_boost_tuple
{
    typedef Value value_type;

BOOST_MPL_ASSERT_MSG(
        (detail::is_indexable<Indexable>::value),
        NOT_VALID_INDEXABLE_TYPE,
        (Indexable)
        );

/*! \brief The type of result returned by function object. */
    typedef Indexable const& result_type;

/*!
    \brief Return indexable extracted from the value.
    
    \param v The value.
    \return The indexable.
    */
    inline result_type operator()(value_type const& v) const
    {
        return boost::get<0>(v);
    }

/*!
    \brief Return indexable extracted from compatible type different than value_type.

\param v The value.
    \return The indexable.
    */
    template <typename I, typename U1, typename U2, typename U3, typename U4,
              typename U5, typename U6, typename U7, typename U8, typename U9>
    inline result_type operator()(boost::tuple<I, U1, U2, U3, U4, U5, U6, U7, U8, U9> const& v) const
    {
        BOOST_MPL_ASSERT_MSG(
            (is_referencable<I, result_type>::value),
            UNEXPECTED_TYPE,
            (boost::tuple<I, U1, U2, U3, U4, U5, U6, U7, U8, U9>)
        );
        return boost::get<0>(v);
    }

/*!
    \brief Return indexable extracted from compatible type different than value_type.

\param v The value.
    \return The indexable.
    */
    template <typename I, typename T>
    inline result_type operator()(boost::tuples::cons<I, T> const& v) const
    {
        BOOST_MPL_ASSERT_MSG(
            (is_referencable<I, result_type>::value),
            UNEXPECTED_TYPE,
            (boost::tuples::cons<I, T>)
        );
        return boost::get<0>(v);
    }

/*!
\brief The function object extracting Indexable from Value.

This specialization translates from boost::tuple<Indexable, ...>.

\tparam Indexable   The Indexable type.
*/
template <typename Indexable, typename T1, typename T2, typename T3, typename T4,
          typename T5, typename T6, typename T7, typename T8, typename T9>
struct indexable<boost::tuple<Indexable, T1, T2, T3, T4, T5, T6, T7, T8, T9>, false>
    : indexable_boost_tuple
        <
            boost::tuple<Indexable, T1, T2, T3, T4, T5, T6, T7, T8, T9>,
            Indexable
        >
{};

/*!
\brief The function object extracting Indexable from Value.

This specialization translates from boost::tuples::cons<Indexable, ...>.

\tparam Indexable   The Indexable type.
*/
template <typename Indexable, typename Tail>
struct indexable<boost::tuples::cons<Indexable, Tail>, false>
    : indexable_boost_tuple
        <
            boost::tuples::cons<Indexable, Tail>,
            Indexable
        >
{};

}}}} // namespace boost::geometry::index::detail

#if !defined(BOOST_NO_CXX11_HDR_TUPLE) && !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)

#include <tuple>

namespace boost { namespace geometry { namespace index { namespace detail {

/*!
\brief The function object extracting Indexable from Value.

This specialization translates from std::tuple<Indexable, Args...>.
It's defined if the compiler supports tuples and variadic templates.

\tparam Indexable   The Indexable type.
*/
template <typename Indexable, typename ...Args>
struct indexable<std::tuple<Indexable, Args...>, false>
{
    typedef std::tuple<Indexable, Args...> value_type;

BOOST_MPL_ASSERT_MSG(
        (detail::is_indexable<Indexable>::value),
        NOT_VALID_INDEXABLE_TYPE,
        (Indexable)
        );

/*! \brief The type of result returned by function object. */
    typedef Indexable const& result_type;

/*!
    \brief Return indexable extracted from the value.
    
    \param v The value.
    \return The indexable.
    */
    result_type operator()(value_type const& v) const
    {
        return std::get<0>(v);
    }

/*!
    \brief Return indexable extracted from compatible type different than value_type.

\param v The value.
    \return The indexable.
    */
    template <typename I, typename ...A>
    inline result_type operator()(std::tuple<I, A...> const& v) const
    {
        BOOST_MPL_ASSERT_MSG(
            (is_referencable<I, result_type>::value),
            UNEXPECTED_TYPE,
            (std::tuple<I, A...>)
        );
        return std::get<0>(v);
    }

}}}} // namespace boost::geometry::index::detail

#endif // !defined(BOOST_NO_CXX11_HDR_TUPLE) && !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)

namespace boost { namespace geometry { namespace index {

/*!
\brief The function object extracting Indexable from Value.

It translates Value object to Indexable object. By default, it can handle Values which are Indexables,
std::pair<Indexable, T2>, boost::tuple<Indexable, ...> and std::tuple<Indexable, ...> if STD tuples
and variadic templates are supported.

\tparam Value       The Value type which may be translated directly to the Indexable.
*/
template <typename Value>
struct indexable
    : detail::indexable<Value>
{
    /*! \brief The type of result returned by function object. It should be const Indexable reference. */
    typedef typename detail::indexable<Value>::result_type result_type;

/*!
    \brief Return indexable extracted from the value.
    
    \param v The value.
    \return The indexable.
    */
    inline result_type operator()(Value const& v) const
    {
        return detail::indexable<Value>::operator()(v);
    }

/*!
    \brief Return indexable extracted from the value. Overload for types
           compatible with Value but different yet holding referencable
           Indexable, e.g. tuple containing a reference.

\param v The value.
    \return The indexable.
    */
    template <typename V>
    inline result_type operator()(V const& v) const
    {
        return detail::indexable<Value>::operator()(v);
    }
};

}}} // namespace boost::geometry::index

#endif // BOOST_GEOMETRY_INDEX_INDEXABLE_HPP

// Boost.Geometry Index // // Copyright (c) 2011-2019 Adam Wulkiewicz, Lodz, Poland. // // Use, modification and distribution is subject to the Boost Software License, // Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) #ifndef BOOST_GEOMETRY_INDEX_INDEXABLE_HPP #define BOOST_GEOMETRY_INDEX_INDEXABLE_HPP #include #include #include #include #include #include #include namespace boost { namespace geometry { namespace index { namespace detail { template struct remove_cr : boost::remove_const < typename boost::remove_reference::type > {}; template struct is_referencable : boost::is_same < typename remove_cr::type, typename remove_cr::type > {}; template inline Indexable const& indexable_prevent_any_type(V const& ) { BOOST_MPL_ASSERT_MSG( (false), UNEXPECTED_TYPE, (V) ); return Indexable(); } /*! \brief The function object extracting Indexable from Value. It translates Value object to Indexable object. The default version handles Values which are Indexables. This template is also specialized for std::pair, boost::tuple and std::tuple. \tparam Value The Value type which may be translated directly to the Indexable. \tparam IsIndexable If true, the const reference to Value is returned. */ template ::value> struct indexable { BOOST_MPL_ASSERT_MSG( (detail::is_indexable::value), NOT_VALID_INDEXABLE_TYPE, (Value) ); /*! \brief The type of result returned by function object. */ typedef Value const& result_type; /*! \brief Return indexable extracted from the value. \param v The value. \return The indexable. */ inline result_type operator()(Value const& v) const { return v; } /*! \brief Prevent reference to temporary for types convertible to Value. */ template inline result_type operator()(V const& v) const { return indexable_prevent_any_type(v); } }; /*! \brief The function object extracting Indexable from Value. This specialization translates from std::pair. \tparam Indexable The Indexable type. \tparam Second The second type. */ template struct indexable, false> { typedef std::pair value_type; BOOST_MPL_ASSERT_MSG( (detail::is_indexable::value), NOT_VALID_INDEXABLE_TYPE, (Indexable) ); /*! \brief The type of result returned by function object. */ typedef Indexable const& result_type; /*! \brief Return indexable extracted from the value. \param v The value. \return The indexable. */ inline result_type operator()(value_type const& v) const { return v.first; } /*! \brief Return indexable extracted from compatible type different than value_type. \param v The value. \return The indexable. */ template inline result_type operator()(std::pair const& v) const { BOOST_MPL_ASSERT_MSG( (is_referencable::value), UNEXPECTED_TYPE, (std::pair) ); return v.first; } /*! \brief Prevent reference to temporary for types convertible to Value. */ template inline result_type operator()(V const& v) const { return indexable_prevent_any_type(v); } }; /*! \brief The function object extracting Indexable from Value. This specialization translates from boost::tuple or boost::tuples::cons. \tparam Value The Value type. \tparam Indexable The Indexable type. */ template struct indexable_boost_tuple { typedef Value value_type; BOOST_MPL_ASSERT_MSG( (detail::is_indexable::value), NOT_VALID_INDEXABLE_TYPE, (Indexable) ); /*! \brief The type of result returned by function object. */ typedef Indexable const& result_type; /*! \brief Return indexable extracted from the value. \param v The value. \return The indexable. */ inline result_type operator()(value_type const& v) const { return boost::get<0>(v); } /*! \brief Return indexable extracted from compatible type different than value_type. \param v The value. \return The indexable. */ template inline result_type operator()(boost::tuple const& v) const { BOOST_MPL_ASSERT_MSG( (is_referencable::value), UNEXPECTED_TYPE, (boost::tuple) ); return boost::get<0>(v); } /*! \brief Return indexable extracted from compatible type different than value_type. \param v The value. \return The indexable. */ template inline result_type operator()(boost::tuples::cons const& v) const { BOOST_MPL_ASSERT_MSG( (is_referencable::value), UNEXPECTED_TYPE, (boost::tuples::cons) ); return boost::get<0>(v); } /*! \brief Prevent reference to temporary for types convertible to Value. */ template inline result_type operator()(V const& v) const { return indexable_prevent_any_type(v); } }; /*! \brief The function object extracting Indexable from Value. This specialization translates from boost::tuple. \tparam Indexable The Indexable type. */ template struct indexable, false> : indexable_boost_tuple < boost::tuple, Indexable > {}; /*! \brief The function object extracting Indexable from Value. This specialization translates from boost::tuples::cons. \tparam Indexable The Indexable type. */ template struct indexable, false> : indexable_boost_tuple < boost::tuples::cons, Indexable > {}; }}}} // namespace boost::geometry::index::detail #if !defined(BOOST_NO_CXX11_HDR_TUPLE) && !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES) #include namespace boost { namespace geometry { namespace index { namespace detail { /*! \brief The function object extracting Indexable from Value. This specialization translates from std::tuple. It's defined if the compiler supports tuples and variadic templates. \tparam Indexable The Indexable type. */ template struct indexable, false> { typedef std::tuple value_type; BOOST_MPL_ASSERT_MSG( (detail::is_indexable::value), NOT_VALID_INDEXABLE_TYPE, (Indexable) ); /*! \brief The type of result returned by function object. */ typedef Indexable const& result_type; /*! \brief Return indexable extracted from the value. \param v The value. \return The indexable. */ result_type operator()(value_type const& v) const { return std::get<0>(v); } /*! \brief Return indexable extracted from compatible type different than value_type. \param v The value. \return The indexable. */ template inline result_type operator()(std::tuple const& v) const { BOOST_MPL_ASSERT_MSG( (is_referencable::value), UNEXPECTED_TYPE, (std::tuple) ); return std::get<0>(v); } /*! \brief Prevent reference to temporary for types convertible to Value. */ template inline result_type operator()(V const& v) const { return indexable_prevent_any_type(v); } }; }}}} // namespace boost::geometry::index::detail #endif // !defined(BOOST_NO_CXX11_HDR_TUPLE) && !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES) namespace boost { namespace geometry { namespace index { /*! \brief The function object extracting Indexable from Value. It translates Value object to Indexable object. By default, it can handle Values which are Indexables, std::pair, boost::tuple and std::tuple if STD tuples and variadic templates are supported. \tparam Value The Value type which may be translated directly to the Indexable. */ template struct indexable : detail::indexable { /*! \brief The type of result returned by function object. It should be const Indexable reference. */ typedef typename detail::indexable::result_type result_type; /*! \brief Return indexable extracted from the value. \param v The value. \return The indexable. */ inline result_type operator()(Value const& v) const { return detail::indexable::operator()(v); } /*! \brief Return indexable extracted from the value. Overload for types compatible with Value but different yet holding referencable Indexable, e.g. tuple containing a reference. \param v The value. \return The indexable. */ template inline result_type operator()(V const& v) const { return detail::indexable::operator()(v); } }; }}} // namespace boost::geometry::index #endif // BOOST_GEOMETRY_INDEX_INDEXABLE_HPP