ceph/src/boost/boost/polygon/detail/polygon_45_set_view.hpp

   1 /*
   2   Copyright 2008 Intel Corporation
   3
   4   Use, modification and distribution are subject to the Boost Software License,
   5   Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
   6   http://www.boost.org/LICENSE_1_0.txt).
   7 */
   8 #ifndef BOOST_POLYGON_POLYGON_45_SET_VIEW_HPP
   9 #define BOOST_POLYGON_POLYGON_45_SET_VIEW_HPP
  10 namespace boost { namespace polygon{
  11
  12   template <typename ltype, typename rtype, int op_type>
  13   class polygon_45_set_view;
  14
  15   template <typename ltype, typename rtype, int op_type>
  16   struct polygon_45_set_traits<polygon_45_set_view<ltype, rtype, op_type> > {
  17     typedef typename polygon_45_set_view<ltype, rtype, op_type>::coordinate_type coordinate_type;
  18     typedef typename polygon_45_set_view<ltype, rtype, op_type>::iterator_type iterator_type;
  19     typedef typename polygon_45_set_view<ltype, rtype, op_type>::operator_arg_type operator_arg_type;
  20
  21     static inline iterator_type begin(const polygon_45_set_view<ltype, rtype, op_type>& polygon_45_set);
  22     static inline iterator_type end(const polygon_45_set_view<ltype, rtype, op_type>& polygon_45_set);
  23
  24     template <typename input_iterator_type>
  25     static inline void set(polygon_45_set_view<ltype, rtype, op_type>& polygon_45_set,
  26                            input_iterator_type input_begin, input_iterator_type input_end);
  27
  28     static inline bool clean(const polygon_45_set_view<ltype, rtype, op_type>& polygon_45_set);
  29
  30   };
  31
  32   template <typename value_type, typename ltype, typename rtype, int op_type>
  33   struct compute_45_set_value {
  34     static
  35     void value(value_type& output_, const ltype& lvalue_, const rtype& rvalue_) {
  36       output_.set(polygon_45_set_traits<ltype>::begin(lvalue_),
  37                   polygon_45_set_traits<ltype>::end(lvalue_));
  38       value_type rinput_;
  39       rinput_.set(polygon_45_set_traits<rtype>::begin(rvalue_),
  40                   polygon_45_set_traits<rtype>::end(rvalue_));
  41 #ifdef BOOST_POLYGON_MSVC
  42 #pragma warning (push)
  43 #pragma warning (disable: 4127)
  44 #endif
  45       if(op_type == 0)
  46         output_ |= rinput_;
  47       else if(op_type == 1)
  48         output_ &= rinput_;
  49       else if(op_type == 2)
  50         output_ ^= rinput_;
  51       else
  52         output_ -= rinput_;
  53 #ifdef BOOST_POLYGON_MSVC
  54 #pragma warning (pop)
  55 #endif
  56     }
  57   };
  58
  59   template <typename value_type, typename ltype, typename rcoord, int op_type>
  60   struct compute_45_set_value<value_type, ltype, polygon_45_set_data<rcoord>, op_type> {
  61     static
  62     void value(value_type& output_, const ltype& lvalue_, const polygon_45_set_data<rcoord>& rvalue_) {
  63       output_.set(polygon_45_set_traits<ltype>::begin(lvalue_),
  64                   polygon_45_set_traits<ltype>::end(lvalue_));
  65 #ifdef BOOST_POLYGON_MSVC
  66 #pragma warning (push)
  67 #pragma warning (disable: 4127)
  68 #endif
  69       if(op_type == 0)
  70         output_ |= rvalue_;
  71       else if(op_type == 1)
  72         output_ &= rvalue_;
  73       else if(op_type == 2)
  74         output_ ^= rvalue_;
  75       else
  76         output_ -= rvalue_;
  77 #ifdef BOOST_POLYGON_MSVC
  78 #pragma warning (pop)
  79 #endif
  80     }
  81   };
  82
  83   template <typename ltype, typename rtype, int op_type>
  84   class polygon_45_set_view {
  85   public:
  86     typedef typename polygon_45_set_traits<ltype>::coordinate_type coordinate_type;
  87     typedef polygon_45_set_data<coordinate_type> value_type;
  88     typedef typename value_type::iterator_type iterator_type;
  89     typedef polygon_45_set_view operator_arg_type;
  90   private:
  91     const ltype& lvalue_;
  92     const rtype& rvalue_;
  93     mutable value_type output_;
  94     mutable bool evaluated_;
  95
  96     polygon_45_set_view& operator=(const polygon_45_set_view&);
  97   public:
  98     polygon_45_set_view(const ltype& lvalue,
  99                         const rtype& rvalue ) :
 100       lvalue_(lvalue), rvalue_(rvalue), output_(), evaluated_(false) {}
 101
 102     // get iterator to begin vertex data
 103   public:
 104     const value_type& value() const {
 105       if(!evaluated_) {
 106         evaluated_ = true;
 107         compute_45_set_value<value_type, ltype, rtype, op_type>::value(output_, lvalue_, rvalue_);
 108       }
 109       return output_;
 110     }
 111   public:
 112     iterator_type begin() const { return value().begin(); }
 113     iterator_type end() const { return value().end(); }
 114
 115     bool dirty() const { return value().dirty(); } //result of a boolean is clean
 116     bool sorted() const { return value().sorted(); } //result of a boolean is sorted
 117
 118     //     template <typename input_iterator_type>
 119     //     void set(input_iterator_type input_begin, input_iterator_type input_end,
 120     //              orientation_2d orient) const {
 121     //       orient_ = orient;
 122     //       output_.clear();
 123     //       output_.insert(output_.end(), input_begin, input_end);
 124     //       polygon_sort(output_.begin(), output_.end());
 125     //     }
 126   };
 127
 128   template <typename ltype, typename rtype, int op_type>
 129   typename polygon_45_set_traits<polygon_45_set_view<ltype, rtype, op_type> >::iterator_type
 130   polygon_45_set_traits<polygon_45_set_view<ltype, rtype, op_type> >::
 131   begin(const polygon_45_set_view<ltype, rtype, op_type>& polygon_45_set) {
 132     return polygon_45_set.begin();
 133   }
 134   template <typename ltype, typename rtype, int op_type>
 135   typename polygon_45_set_traits<polygon_45_set_view<ltype, rtype, op_type> >::iterator_type
 136   polygon_45_set_traits<polygon_45_set_view<ltype, rtype, op_type> >::
 137   end(const polygon_45_set_view<ltype, rtype, op_type>& polygon_45_set) {
 138     return polygon_45_set.end();
 139   }
 140   template <typename ltype, typename rtype, int op_type>
 141   bool polygon_45_set_traits<polygon_45_set_view<ltype, rtype, op_type> >::
 142   clean(const polygon_45_set_view<ltype, rtype, op_type>& polygon_45_set) {
 143     return polygon_45_set.value().clean(); }
 144
 145   template <typename geometry_type_1, typename geometry_type_2, int op_type>
 146   geometry_type_1& self_assignment_boolean_op_45(geometry_type_1& lvalue_, const geometry_type_2& rvalue_) {
 147     typedef geometry_type_1 ltype;
 148     typedef geometry_type_2 rtype;
 149     typedef typename polygon_45_set_traits<ltype>::coordinate_type coordinate_type;
 150     typedef polygon_45_set_data<coordinate_type> value_type;
 151     value_type output_;
 152     value_type rinput_;
 153     output_.set(polygon_45_set_traits<ltype>::begin(lvalue_),
 154                 polygon_45_set_traits<ltype>::end(lvalue_));
 155     rinput_.set(polygon_45_set_traits<rtype>::begin(rvalue_),
 156                 polygon_45_set_traits<rtype>::end(rvalue_));
 157 #ifdef BOOST_POLYGON_MSVC
 158 #pragma warning (push)
 159 #pragma warning (disable: 4127)
 160 #endif
 161     if(op_type == 0)
 162       output_ |= rinput_;
 163     else if(op_type == 1)
 164       output_ &= rinput_;
 165     else if(op_type == 2)
 166       output_ ^= rinput_;
 167     else
 168       output_ -= rinput_;
 169 #ifdef BOOST_POLYGON_MSVC
 170 #pragma warning (pop)
 171 #endif
 172     polygon_45_set_mutable_traits<geometry_type_1>::set(lvalue_, output_.begin(), output_.end());
 173     return lvalue_;
 174   }
 175
 176   template <typename concept_type>
 177   struct fracture_holes_option_by_type {
 178     static const bool value = true;
 179   };
 180   template <>
 181   struct fracture_holes_option_by_type<polygon_45_with_holes_concept> {
 182     static const bool value = false;
 183   };
 184   template <>
 185   struct fracture_holes_option_by_type<polygon_with_holes_concept> {
 186     static const bool value = false;
 187   };
 188
 189   template <typename ltype, typename rtype, int op_type>
 190   struct geometry_concept<polygon_45_set_view<ltype, rtype, op_type> > { typedef polygon_45_set_concept type; };
 191
 192   namespace operators {
 193   struct y_ps45_b : gtl_yes {};
 194
 195   template <typename geometry_type_1, typename geometry_type_2>
 196   typename enable_if< typename gtl_and_4< y_ps45_b,
 197     typename is_polygon_45_or_90_set_type<geometry_type_1>::type,
 198     typename is_polygon_45_or_90_set_type<geometry_type_2>::type,
 199     typename is_either_polygon_45_set_type<geometry_type_1, geometry_type_2>::type>::type,
 200                        polygon_45_set_view<geometry_type_1, geometry_type_2, 0> >::type
 201   operator|(const geometry_type_1& lvalue, const geometry_type_2& rvalue) {
 202     return polygon_45_set_view<geometry_type_1, geometry_type_2, 0>
 203       (lvalue, rvalue);
 204   }
 205
 206   struct y_ps45_p : gtl_yes {};
 207
 208   template <typename geometry_type_1, typename geometry_type_2>
 209   typename enable_if< typename gtl_and_4< y_ps45_p,
 210     typename gtl_if<typename is_polygon_45_or_90_set_type<geometry_type_1>::type>::type,
 211     typename gtl_if<typename is_polygon_45_or_90_set_type<geometry_type_2>::type>::type,
 212     typename gtl_if<typename is_either_polygon_45_set_type<geometry_type_1, geometry_type_2>::type>::type>::type,
 213   polygon_45_set_view<geometry_type_1, geometry_type_2, 0> >::type
 214   operator+(const geometry_type_1& lvalue, const geometry_type_2& rvalue) {
 215     return polygon_45_set_view<geometry_type_1, geometry_type_2, 0>
 216       (lvalue, rvalue);
 217   }
 218
 219   struct y_ps45_s : gtl_yes {};
 220
 221   template <typename geometry_type_1, typename geometry_type_2>
 222   typename enable_if< typename gtl_and_4< y_ps45_s, typename is_polygon_45_or_90_set_type<geometry_type_1>::type,
 223                                            typename is_polygon_45_or_90_set_type<geometry_type_2>::type,
 224                                            typename is_either_polygon_45_set_type<geometry_type_1, geometry_type_2>::type>::type,
 225                        polygon_45_set_view<geometry_type_1, geometry_type_2, 1> >::type
 226   operator*(const geometry_type_1& lvalue, const geometry_type_2& rvalue) {
 227     return polygon_45_set_view<geometry_type_1, geometry_type_2, 1>
 228       (lvalue, rvalue);
 229   }
 230
 231   struct y_ps45_a : gtl_yes {};
 232
 233   template <typename geometry_type_1, typename geometry_type_2>
 234   typename enable_if< typename gtl_and_4< y_ps45_a, typename is_polygon_45_or_90_set_type<geometry_type_1>::type,
 235                                            typename is_polygon_45_or_90_set_type<geometry_type_2>::type,
 236                                            typename is_either_polygon_45_set_type<geometry_type_1, geometry_type_2>::type>::type,
 237                        polygon_45_set_view<geometry_type_1, geometry_type_2, 1> >::type
 238   operator&(const geometry_type_1& lvalue, const geometry_type_2& rvalue) {
 239     return polygon_45_set_view<geometry_type_1, geometry_type_2, 1>
 240       (lvalue, rvalue);
 241   }
 242
 243   struct y_ps45_x : gtl_yes {};
 244
 245   template <typename geometry_type_1, typename geometry_type_2>
 246   typename enable_if< typename gtl_and_4< y_ps45_x, typename is_polygon_45_or_90_set_type<geometry_type_1>::type,
 247                                            typename is_polygon_45_or_90_set_type<geometry_type_2>::type,
 248                                            typename is_either_polygon_45_set_type<geometry_type_1, geometry_type_2>::type>::type,
 249                        polygon_45_set_view<geometry_type_1, geometry_type_2, 2> >::type
 250   operator^(const geometry_type_1& lvalue, const geometry_type_2& rvalue) {
 251     return polygon_45_set_view<geometry_type_1, geometry_type_2, 2>
 252       (lvalue, rvalue);
 253   }
 254
 255   struct y_ps45_m : gtl_yes {};
 256
 257   template <typename geometry_type_1, typename geometry_type_2>
 258   typename enable_if< typename gtl_and_4< y_ps45_m,
 259     typename gtl_if<typename is_polygon_45_or_90_set_type<geometry_type_1>::type>::type,
 260     typename gtl_if<typename is_polygon_45_or_90_set_type<geometry_type_2>::type>::type,
 261     typename gtl_if<typename is_either_polygon_45_set_type<geometry_type_1, geometry_type_2>::type>::type>::type,
 262   polygon_45_set_view<geometry_type_1, geometry_type_2, 3> >::type
 263   operator-(const geometry_type_1& lvalue, const geometry_type_2& rvalue) {
 264     return polygon_45_set_view<geometry_type_1, geometry_type_2, 3>
 265       (lvalue, rvalue);
 266   }
 267
 268   struct y_ps45_pe : gtl_yes {};
 269
 270   template <typename geometry_type_1, typename geometry_type_2>
 271   typename enable_if< typename gtl_and_4<y_ps45_pe, typename is_mutable_polygon_45_set_type<geometry_type_1>::type, gtl_yes,
 272                                          typename is_polygon_45_or_90_set_type<geometry_type_2>::type>::type,
 273                        geometry_type_1>::type &
 274   operator+=(geometry_type_1& lvalue, const geometry_type_2& rvalue) {
 275     return self_assignment_boolean_op_45<geometry_type_1, geometry_type_2, 0>(lvalue, rvalue);
 276   }
 277
 278   struct y_ps45_be : gtl_yes {};
 279
 280   template <typename geometry_type_1, typename geometry_type_2>
 281   typename enable_if< typename gtl_and_3<y_ps45_be, typename is_mutable_polygon_45_set_type<geometry_type_1>::type,
 282                                          typename is_polygon_45_or_90_set_type<geometry_type_2>::type>::type,
 283                        geometry_type_1>::type &
 284   operator|=(geometry_type_1& lvalue, const geometry_type_2& rvalue) {
 285     return self_assignment_boolean_op_45<geometry_type_1, geometry_type_2, 0>(lvalue, rvalue);
 286   }
 287
 288   struct y_ps45_se : gtl_yes {};
 289
 290   template <typename geometry_type_1, typename geometry_type_2>
 291   typename enable_if< typename gtl_and_3< y_ps45_se,
 292     typename is_mutable_polygon_45_set_type<geometry_type_1>::type,
 293     typename is_polygon_45_or_90_set_type<geometry_type_2>::type>::type,
 294                        geometry_type_1>::type &
 295   operator*=(geometry_type_1& lvalue, const geometry_type_2& rvalue) {
 296     return self_assignment_boolean_op_45<geometry_type_1, geometry_type_2, 1>(lvalue, rvalue);
 297   }
 298
 299   struct y_ps45_ae : gtl_yes {};
 300
 301   template <typename geometry_type_1, typename geometry_type_2>
 302   typename enable_if< typename gtl_and_3<y_ps45_ae, typename is_mutable_polygon_45_set_type<geometry_type_1>::type,
 303                                          typename is_polygon_45_or_90_set_type<geometry_type_2>::type>::type,
 304                        geometry_type_1>::type &
 305   operator&=(geometry_type_1& lvalue, const geometry_type_2& rvalue) {
 306     return self_assignment_boolean_op_45<geometry_type_1, geometry_type_2, 1>(lvalue, rvalue);
 307   }
 308
 309   struct y_ps45_xe : gtl_yes {};
 310
 311   template <typename geometry_type_1, typename geometry_type_2>
 312   typename enable_if<
 313     typename gtl_and_3<y_ps45_xe, typename is_mutable_polygon_45_set_type<geometry_type_1>::type,
 314                       typename is_polygon_45_or_90_set_type<geometry_type_2>::type>::type,
 315     geometry_type_1>::type &
 316   operator^=(geometry_type_1& lvalue, const geometry_type_2& rvalue) {
 317     return self_assignment_boolean_op_45<geometry_type_1, geometry_type_2, 2>(lvalue, rvalue);
 318   }
 319
 320   struct y_ps45_me : gtl_yes {};
 321
 322   template <typename geometry_type_1, typename geometry_type_2>
 323   typename enable_if< typename gtl_and_3<y_ps45_me, typename is_mutable_polygon_45_set_type<geometry_type_1>::type,
 324                                          typename is_polygon_45_or_90_set_type<geometry_type_2>::type>::type,
 325                        geometry_type_1>::type &
 326   operator-=(geometry_type_1& lvalue, const geometry_type_2& rvalue) {
 327     return self_assignment_boolean_op_45<geometry_type_1, geometry_type_2, 3>(lvalue, rvalue);
 328   }
 329
 330   struct y_ps45_rpe : gtl_yes {};
 331
 332   template <typename geometry_type_1, typename coordinate_type_1>
 333   typename enable_if< typename gtl_and_3< y_ps45_rpe, typename is_mutable_polygon_45_set_type<geometry_type_1>::type,
 334                                          typename gtl_same_type<typename geometry_concept<coordinate_type_1>::type,
 335                                                                 coordinate_concept>::type>::type,
 336                        geometry_type_1>::type &
 337   operator+=(geometry_type_1& lvalue, coordinate_type_1 rvalue) {
 338     return resize(lvalue, rvalue);
 339   }
 340
 341   struct y_ps45_rme : gtl_yes {};
 342
 343   template <typename geometry_type_1, typename coordinate_type_1>
 344   typename enable_if< typename gtl_and_3<y_ps45_rme, typename gtl_if<typename is_mutable_polygon_45_set_type<geometry_type_1>::type>::type,
 345                                          typename gtl_same_type<typename geometry_concept<coordinate_type_1>::type,
 346                                                                 coordinate_concept>::type>::type,
 347                        geometry_type_1>::type &
 348   operator-=(geometry_type_1& lvalue, coordinate_type_1 rvalue) {
 349     return resize(lvalue, -rvalue);
 350   }
 351
 352   struct y_ps45_rp : gtl_yes {};
 353
 354   template <typename geometry_type_1, typename coordinate_type_1>
 355   typename enable_if< typename gtl_and_3<y_ps45_rp, typename gtl_if<typename is_mutable_polygon_45_set_type<geometry_type_1>::type>::type,
 356                                         typename gtl_same_type<typename geometry_concept<coordinate_type_1>::type,
 357                                                                coordinate_concept>::type>
 358   ::type, geometry_type_1>::type
 359   operator+(const geometry_type_1& lvalue, coordinate_type_1 rvalue) {
 360     geometry_type_1 retval(lvalue);
 361     retval += rvalue;
 362     return retval;
 363   }
 364
 365   struct y_ps45_rm : gtl_yes {};
 366
 367   template <typename geometry_type_1, typename coordinate_type_1>
 368   typename enable_if< typename gtl_and_3<y_ps45_rm, typename gtl_if<typename is_mutable_polygon_45_set_type<geometry_type_1>::type>::type,
 369                                         typename gtl_same_type<typename geometry_concept<coordinate_type_1>::type,
 370                                                                coordinate_concept>::type>
 371   ::type, geometry_type_1>::type
 372   operator-(const geometry_type_1& lvalue, coordinate_type_1 rvalue) {
 373     geometry_type_1 retval(lvalue);
 374     retval -= rvalue;
 375     return retval;
 376   }
 377   }
 378 }
 379 }
 380 #endif