Ticket #11636: unused-argument.patch

include/boost/polygon/detail/boolean_op.hpp

@@ -381 +381 @@
   }
 
   template <typename Unit>
-  inline void applyUnaryXOr(std::vector<std::pair<Unit, std::pair<Unit, int> > >& input) {
+  inline void applyUnaryXOr(std::vector<std::pair<Unit, std::pair<Unit, int> > >& ) {
     BooleanOp<UnaryCount, Unit> booleanXOr;
 
   }

include/boost/polygon/detail/boolean_op_45.hpp

@@ -272 +272 @@
       inline Vertex45T(const Vertex45T& vertex) : pt(vertex.pt), rise(vertex.rise), count(vertex.count) {}
       inline Vertex45T& operator=(const Vertex45T& vertex){
         pt = vertex.pt; rise = vertex.rise; count = vertex.count; return *this; }
-      inline Vertex45T(const std::pair<Point, Point>& vertex) : pt(), rise(), count() {}
-      inline Vertex45T& operator=(const std::pair<Point, Point>& vertex){ return *this; }
+      inline Vertex45T(const std::pair<Point, Point>& ) : pt(), rise(), count() {}
+      inline Vertex45T& operator=(const std::pair<Point, Point>& ){ return *this; }
       inline bool operator==(const Vertex45T& vertex) const {
         return pt == vertex.pt && rise == vertex.rise && count == vertex.count; }
       inline bool operator!=(const Vertex45T& vertex) const { return !((*this) == vertex); }
-      inline bool operator==(const std::pair<Point, Point>& vertex) const { return false; }
+      inline bool operator==(const std::pair<Point, Point>& ) const { return false; }
       inline bool operator!=(const std::pair<Point, Point>& vertex) const { return !((*this) == vertex); }
       inline bool operator<(const Vertex45T& vertex) const {
         if(pt.x() < vertex.pt.x()) return true;

include/boost/polygon/detail/polygon_45_formation.hpp

@@ -506 +506 @@
       inline bool operator==(const Vertex45CompactT& vertex) const {
         return pt == vertex.pt && count == vertex.count; }
       inline bool operator!=(const Vertex45CompactT& vertex) const { return !((*this) == vertex); }
-      inline bool operator==(const std::pair<Point, Point>& vertex) const { return false; }
+      inline bool operator==(const std::pair<Point, Point>& ) const { return false; }
       inline bool operator!=(const std::pair<Point, Point>& vertex) const { return !((*this) == vertex); }
       inline bool operator<(const Vertex45CompactT& vertex) const {
         if(pt.x() < vertex.pt.x()) return true;
@@ -2153 +2153 @@
     inline iterator end() const { return p_->getTail()->end(); }
     inline std::size_t size() const { return 0; }
     template<class iT>
-    inline PolyLine45HoleData& set(iT inputBegin, iT inputEnd) {
+    inline PolyLine45HoleData& set(iT , iT ) {
       return *this;
     }
   private:
@@ -2222 +2222 @@
     inline std::size_t size_holes() const { return 0; }
     inline std::size_t size() const { return 0; }
     template<class iT>
-    inline PolyLine45PolygonData& set(iT inputBegin, iT inputEnd) {
+    inline PolyLine45PolygonData& set(iT , iT ) {
       return *this;
     }
 
     // initialize a polygon from x,y values, it is assumed that the first is an x
     // and that the input is a well behaved polygon
     template<class iT>
-    inline PolyLine45PolygonData& set_holes(iT inputBegin, iT inputEnd) {
+    inline PolyLine45PolygonData& set_holes(iT , iT ) {
       return *this;
     }
   private:

include/boost/polygon/detail/polygon_90_set_view.hpp

@@ -200 +200 @@
     return polygon_set.orient(); }
   template <typename ltype, typename rtype, typename op_type>
   bool polygon_90_set_traits<polygon_90_set_view<ltype, rtype, op_type> >::
-  clean(const polygon_90_set_view<ltype, rtype, op_type>& polygon_set) {
+  clean(const polygon_90_set_view<ltype, rtype, op_type>& ) {
     return true; }
   template <typename ltype, typename rtype, typename op_type>
   bool polygon_90_set_traits<polygon_90_set_view<ltype, rtype, op_type> >::
-  sorted(const polygon_90_set_view<ltype, rtype, op_type>& polygon_set) {
+  sorted(const polygon_90_set_view<ltype, rtype, op_type>& ) {
     return true; }
 
   template <typename value_type, typename arg_type>

include/boost/polygon/detail/polygon_arbitrary_formation.hpp

@@ -338 +338 @@
     };
 
     template <typename unsigned_product_type>
-    static inline void unsigned_mod(unsigned_product_type& result, int& result_sign, unsigned_product_type a, int a_sign, unsigned_product_type b, int b_sign) {
+    static inline void unsigned_mod(unsigned_product_type& result, int& result_sign, unsigned_product_type a, int a_sign, unsigned_product_type b, int ) {
       result = a % b;
       result_sign = a_sign;
     }
@@ -739 +739 @@
       inline vertex_half_edge(const vertex_half_edge& vertex) : pt(vertex.pt), other_pt(vertex.other_pt), count(vertex.count) {}
       inline vertex_half_edge& operator=(const vertex_half_edge& vertex){
         pt = vertex.pt; other_pt = vertex.other_pt; count = vertex.count; return *this; }
-      inline vertex_half_edge(const std::pair<Point, Point>& vertex) : pt(), other_pt(), count() {}
-      inline vertex_half_edge& operator=(const std::pair<Point, Point>& vertex){ return *this; }
+      inline vertex_half_edge(const std::pair<Point, Point>& ) : pt(), other_pt(), count() {}
+      inline vertex_half_edge& operator=(const std::pair<Point, Point>& ){ return *this; }
       inline bool operator==(const vertex_half_edge& vertex) const {
         return pt == vertex.pt && other_pt == vertex.other_pt && count == vertex.count; }
       inline bool operator!=(const vertex_half_edge& vertex) const { return !((*this) == vertex); }
-      inline bool operator==(const std::pair<Point, Point>& vertex) const { return false; }
+      inline bool operator==(const std::pair<Point, Point>& ) const { return false; }
       inline bool operator!=(const std::pair<Point, Point>& vertex) const { return !((*this) == vertex); }
       inline bool operator<(const vertex_half_edge& vertex) const {
         if(pt.get(HORIZONTAL) < vertex.pt.get(HORIZONTAL)) return true;
@@ -1284 +1284 @@
       inline vertex_arbitrary_compact& operator=(const vertex_arbitrary_compact& vertex){
         pt = vertex.pt; count = vertex.count; return *this; }
       //inline vertex_arbitrary_compact(const std::pair<Point, Point>& vertex) {}
-      inline vertex_arbitrary_compact& operator=(const std::pair<Point, Point>& vertex){ return *this; }
+      inline vertex_arbitrary_compact& operator=(const std::pair<Point, Point>& ){ return *this; }
       inline bool operator==(const vertex_arbitrary_compact& vertex) const {
         return pt == vertex.pt && count == vertex.count; }
       inline bool operator!=(const vertex_arbitrary_compact& vertex) const { return !((*this) == vertex); }
-      inline bool operator==(const std::pair<Point, Point>& vertex) const { return false; }
+      inline bool operator==(const std::pair<Point, Point>& ) const { return false; }
       inline bool operator!=(const std::pair<Point, Point>& vertex) const { return !((*this) == vertex); }
       inline bool operator<(const vertex_arbitrary_compact& vertex) const {
         if(pt.get(HORIZONTAL) < vertex.pt.get(HORIZONTAL)) return true;
@@ -2144 +2144 @@
     //inline compact_iterator_type end_compact() const { return compact_iterator_type(end()); }
     inline std::size_t size() const { return 0; }
     template<class iT>
-    inline poly_line_arbitrary_hole_data& set(iT inputBegin, iT inputEnd) {
+    inline poly_line_arbitrary_hole_data& set(iT , iT ) {
       //assert this is not called
       return *this;
     }
     template<class iT>
-    inline poly_line_arbitrary_hole_data& set_compact(iT inputBegin, iT inputEnd) {
+    inline poly_line_arbitrary_hole_data& set_compact(iT , iT ) {
       //assert this is not called
       return *this;
     }
@@ -2220 +2220 @@
     inline std::size_t size_holes() const { return 0; }
     inline std::size_t size() const { return 0; }
     template<class iT>
-    inline poly_line_arbitrary_polygon_data& set(iT inputBegin, iT inputEnd) {
+    inline poly_line_arbitrary_polygon_data& set(iT , iT ) {
       return *this;
     }
     template<class iT>
-    inline poly_line_arbitrary_polygon_data& set_compact(iT inputBegin, iT inputEnd) {
+    inline poly_line_arbitrary_polygon_data& set_compact(iT , iT ) {
       return *this;
     }
     template<class iT>
-    inline poly_line_arbitrary_polygon_data& set_holes(iT inputBegin, iT inputEnd) {
+    inline poly_line_arbitrary_polygon_data& set_holes(iT , iT ) {
       return *this;
     }
   };

include/boost/polygon/detail/polygon_formation.hpp

@@ -617 +617 @@
     }
     inline ActiveTail<Unit>* yield() { return p_; }
     template<class iT>
-    inline PolyLineHoleData& set(iT inputBegin, iT inputEnd) {
+    inline PolyLineHoleData& set(iT , iT ) {
       return *this;
     }
     template<class iT>
-    inline PolyLineHoleData& set_compact(iT inputBegin, iT inputEnd) {
+    inline PolyLineHoleData& set_compact(iT , iT ) {
       return *this;
     }
    
@@ -677 +677 @@
     inline std::size_t size_holes() const { return 0; }
     inline std::size_t size() const { return 0; }
     template<class iT>
-    inline PolyLinePolygonWithHolesData& set(iT inputBegin, iT inputEnd) {
+    inline PolyLinePolygonWithHolesData& set(iT , iT ) {
       return *this;
     }
     template<class iT>
-    inline PolyLinePolygonWithHolesData& set_compact(iT inputBegin, iT inputEnd) {
+    inline PolyLinePolygonWithHolesData& set_compact(iT , iT ) {
       return *this;
     }
    
     // initialize a polygon from x,y values, it is assumed that the first is an x
     // and that the input is a well behaved polygon
     template<class iT>
-    inline PolyLinePolygonWithHolesData& set_holes(iT inputBegin, iT inputEnd) {
+    inline PolyLinePolygonWithHolesData& set_holes(iT , iT ) {
       return *this;
     }
   };

include/boost/polygon/detail/property_merge.hpp

@@ -509 +509 @@
   }
 
   template <typename T, typename T2>
-  inline void writeGraph(coordinate_type x, T& graph, edge_property_vector& output, T2& scanline) {
+  inline void writeGraph(coordinate_type , T& graph, edge_property_vector& output, T2& scanline) {
     if(output.empty()) return;
     edge_property* previousEdgeP = &(output[0]);
     bool firstIteration = true;

include/boost/polygon/detail/scan_arbitrary.hpp

@@ -1641 +1641 @@
 
     template <typename polygon_with_holes_type>
     void insert(const polygon_with_holes_type& polygon_with_holes_object, const property_type& property_value, bool is_hole,
-                polygon_with_holes_concept tag) {
+                polygon_with_holes_concept ) {
       insert(polygon_with_holes_object, property_value, is_hole, polygon_concept());
       for(typename polygon_with_holes_traits<polygon_with_holes_type>::iterator_holes_type itr =
             begin_holes(polygon_with_holes_object);

include/boost/polygon/polygon_90_set_data.hpp

@@ -46 +46 @@
 
     // constructor from an iterator pair over vertex data
     template <typename iT>
-    inline polygon_90_set_data(orientation_2d orient, iT input_begin, iT input_end) :
+    inline polygon_90_set_data(orientation_2d , iT input_begin, iT input_end) :
       orient_(HORIZONTAL), data_(), dirty_(false), unsorted_(false) {
       dirty_ = true;
       unsorted_ = true;
@@ -119 +119 @@
     }
 
     inline void insert(const std::pair<std::pair<point_data<coordinate_type>, point_data<coordinate_type> >, int>& edge, bool is_hole = false,
-                       orientation_2d orient = HORIZONTAL) {
+                       orientation_2d = HORIZONTAL) {
       std::pair<coordinate_type, std::pair<coordinate_type, int> > vertex;
       vertex.first = edge.first.first.x();
       vertex.second.first = edge.first.first.y();

include/boost/polygon/polygon_set_data.hpp

@@ -399 +399 @@
     }
 
     template <typename scaling_type>
-    inline polygon_set_data& scale(polygon_set_data& polygon_set,
+    inline polygon_set_data& scale(polygon_set_data& ,
                                    const scaling_type& scaling) {
       for(typename value_type::iterator itr = begin(); itr != end(); ++itr) {
         bool vb = (*itr).first.first.x() == (*itr).first.second.x();
@@ -574 +574 @@
     template <typename geometry_type>
     inline polygon_set_data&
     insert_with_resize_dispatch(const geometry_type& poly, coordinate_type resizing, bool corner_fill_arc, unsigned int num_circle_segments, bool hole,
-                               polygon_with_holes_concept tag) {
+                               polygon_with_holes_concept ) {
       insert_with_resize_dispatch(poly, resizing, corner_fill_arc, num_circle_segments, hole, polygon_concept());
       for(typename polygon_with_holes_traits<geometry_type>::iterator_holes_type itr =
             begin_holes(poly); itr != end_holes(poly);
@@ -587 +587 @@
     template <typename geometry_type>
     inline polygon_set_data&
     insert_with_resize_dispatch(const geometry_type& poly, coordinate_type resizing, bool corner_fill_arc, unsigned int num_circle_segments, bool hole,
-                          polygon_concept tag) {
+                          polygon_concept ) {
 
       if (resizing==0)
          return *this;

include/boost/polygon/polygon_traits.hpp

@@ -185 +185 @@
     template <typename iT>
     static inline T& set_compact(T& t, iT input_begin, iT input_end) {
       typedef iterator_points_to_compact<iT, typename polygon_traits<T>::point_type> iTp;
-      t.set_points(iTp(polygon_traits<T>::begin_points(t)), iTp(polygon_traits<T>::end_points(t)));
+      t.set_points(iTp(input_begin), iTp(input_end));
       return t;
     }
   };
@@ -1567 +1567 @@
     typedef const hole_type* iterator_holes_type;
     static inline iterator_holes_type begin_holes(const hole_type& t) { return &t; }
     static inline iterator_holes_type end_holes(const hole_type& t) { return &t; }
-    static inline std::size_t size_holes(const hole_type& t) { return 0; }
+    static inline std::size_t size_holes(const hole_type& ) { return 0; }
   };
 
   template <typename T>