Subject: [Boost-commit] svn:boost r80611 - sandbox-branches/geometry/index/boost/geometry/extensions/index
From: adam.wulkiewicz_at_[hidden]
Date: 2012-09-20 19:42:09
Author: awulkiew
Date: 2012-09-20 19:42:09 EDT (Thu, 20 Sep 2012)
New Revision: 80611
URL: http://svn.boost.org/trac/boost/changeset/80611
Log:
Added query_expr.hpp
Added:
sandbox-branches/geometry/index/boost/geometry/extensions/index/query_expr.hpp (contents, props changed)
Added: sandbox-branches/geometry/index/boost/geometry/extensions/index/query_expr.hpp
==============================================================================
--- (empty file)
+++ sandbox-branches/geometry/index/boost/geometry/extensions/index/query_expr.hpp 2012-09-20 19:42:09 EDT (Thu, 20 Sep 2012)
@@ -0,0 +1,246 @@
+// Boost.Geometry Index
+//
+// Query expression
+//
+// Copyright (c) 2011-2012 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)
+
+// TODO - CHANGE FILENAME TO query_expr.hpp
+// create separate namespace etc.
+
+#ifndef BOOST_GEOMETRY_EXTENSIONS_INDEX_QUERY_EXPR_HPP
+#define BOOST_GEOMETRY_EXTENSIONS_INDEX_QUERY_EXPR_HPP
+
+namespace boost { namespace geometry { namespace index {
+
+namespace query_expr {
+
+// predicates tags
+
+struct empty_tag {};
+struct value_tag {};
+struct covered_by_tag {};
+struct disjoint_tag {};
+struct intersects_tag {};
+struct overlaps_tag {};
+//struct touches_tag {};
+struct within_tag {};
+struct nearest_tag {};
+
+// predicates data
+
+template <typename Geometry, typename Tag>
+struct predicate
+{
+ explicit predicate(Geometry const& geometry_) : geometry(geometry_) {}
+ Geometry geometry;
+};
+
+template <typename ValuePredicate>
+struct predicate<ValuePredicate, value_tag>
+{
+ explicit predicate(ValuePredicate const& value_predicate_) : value_predicate(value_predicate_) {}
+ ValuePredicate value_predicate;
+};
+
+template <typename Dummy>
+struct predicate<Dummy, empty_tag>
+{};
+
+template <typename DistancesPredicates>
+struct predicate<DistancesPredicates, nearest_tag>
+{
+ predicate(size_t k_, DistancesPredicates const& distances_predicates_)
+ : k(k_), distances_predicates(distances_predicates_)
+ {}
+
+ size_t k;
+ DistancesPredicates distances_predicates;
+};
+
+// expression &&
+
+template <typename Left, typename Right>
+struct and_expr
+{
+ typedef Left left_type;
+ typedef Right right_type;
+
+ and_expr(Left const& left_, Right const& right_)
+ : left(left_), right(right_)
+ {}
+
+ Left const& left;
+ Right const& right;
+};
+
+// predicates_count
+
+template <typename Expr>
+struct predicates_count
+{
+ BOOST_MPL_ASSERT(
+ (false),
+ NOT_VALID_QUERY_EXPRESSION,
+ (Expr));
+};
+
+template <typename Left, typename Right>
+struct predicates_count< and_expr<Left, Right> >
+{
+ static const size_t value = predicates_count<Left>::value + predicates_count<Right>::value;
+};
+
+template <typename Data, typename Tag>
+struct predicates_count< predicate<Data, Tag> >
+{
+ static const size_t value = 1;
+};
+
+// if_v
+
+template <bool Cond, size_t V1, size_t V2>
+struct if_v
+{
+ static const size_t value = V1;
+};
+template <size_t V1, size_t V2>
+struct if_v<false, V1, V2>
+{
+ static const size_t value = V2;
+};
+
+// if_t
+
+template <bool Cond, typename T1, typename T2>
+struct if_t
+{
+ typedef T1 type;
+};
+template <typename T1, typename T2>
+struct if_t<false, T1, T2>
+{
+ typedef T2 type;
+};
+
+// if_ret
+
+template <bool Cond>
+struct if_ret
+{
+ template <typename T>
+ static inline T const& apply(T const& v) { return v; }
+};
+template <>
+struct if_ret<false>
+{
+ template <typename T>
+ void apply(T const&) {}
+};
+
+// predicate_access_impl - used by predicate_type and get_predicate()
+
+template <typename Expr, size_t I, size_t Curr = 0>
+struct predicate_access
+{
+ BOOST_MPL_ASSERT(
+ (false),
+ NOT_VALID_QUERY_EXPRESSION,
+ (Expr));
+};
+
+template <typename Left, typename Right, size_t I, size_t Curr>
+struct predicate_access<and_expr<Left, Right>, I, Curr>
+{
+ static const size_t curr = if_v<
+ I == predicate_access<Left, I, Curr>::curr,
+ predicate_access<Left, I, Curr>::curr,
+ predicate_access<Right, I, predicate_access<Left, I, Curr>::curr + 1>::curr
+ >::value;
+
+ typedef typename if_t<
+ I == predicate_access<Left, I, Curr>::curr,
+ typename predicate_access<Left, I, Curr>::type,
+ typename predicate_access<Right, I, predicate_access<Left, I, Curr>::curr + 1>::type
+ >::type type;
+
+ //TODO
+
+ /*static inline
+ typename if_t<
+ I == predicate_access<Left, I, Curr>::curr,
+ typename predicate_access<Left, I, Curr>::return_type,
+ typename predicate_access<Right, I, predicate_access<Left, I, Curr>::curr + 1>::return_type
+ >::type
+ apply(and_expr<Left, Right> const& e)
+ {
+ return if_ret<I == Curr>::apply(p);
+ }*/
+};
+
+template <typename Data, typename Tag, size_t I, size_t Curr>
+struct predicate_access<predicate<Data, Tag>, I, Curr>
+{
+ static const size_t curr = Curr;
+
+ typedef typename if_t<I == Curr, predicate<Data, Tag>, void>::type type;
+
+ typedef typename if_t<I == Curr, type const&, void>::type return_type;
+
+ static inline return_type apply(predicate<Data, Tag> const& p)
+ {
+ return if_ret<I == Curr>::apply(p);
+ }
+};
+
+// predicate_type
+
+template <typename Expr, size_t I>
+struct predicate_type
+{
+ typedef typename predicate_access<Expr, I>::type type;
+};
+
+// get_predicate
+
+template <size_t I, typename Expr>
+typename predicate_type<Expr, I>::type const&
+get_predicate(Expr const& expr)
+{
+ return predicate_access<Expr, I>::apply(expr);
+};
+
+} // namespace query_expr
+
+}}} // namespace boost::geometry::index
+
+template <typename Data1, typename Tag1, typename Data2, typename Tag2>
+boost::geometry::index::query_expr::and_expr<
+ boost::geometry::index::query_expr::predicate<Data1, Tag1>,
+ boost::geometry::index::query_expr::predicate<Data2, Tag2>
+>
+operator&&(boost::geometry::index::query_expr::predicate<Data1, Tag1> const& left,
+ boost::geometry::index::query_expr::predicate<Data2, Tag2> const& right)
+{
+ using namespace boost::geometry::index::query_expr;
+
+ return and_expr< predicate<Data1, Tag1>, predicate<Data2, Tag2> >(left, right);
+}
+
+template <typename Left, typename Right, typename Data, typename Tag>
+boost::geometry::index::query_expr::and_expr<
+ boost::geometry::index::query_expr::and_expr<Left, Right>,
+ boost::geometry::index::query_expr::predicate<Data, Tag>
+>
+operator&&(boost::geometry::index::query_expr::and_expr<Left, Right> const& left,
+ boost::geometry::index::query_expr::predicate<Data, Tag> const& right)
+{
+ using namespace boost::geometry::index::query_expr;
+
+ return and_expr< and_expr<Left, Right>, predicate<Data, Tag> >(left, right);
+}
+
+#endif // BOOST_GEOMETRY_EXTENSIONS_INDEX_QUERY_EXPR_HPP