fix warnings

corsika/detail/framework/random/random_iterator/detail/tbb/iterators.h

@@ -29,238 +29,290 @@
 
 namespace random_iterator_tbb {
 
+  template <typename Type>
+  class constant_iterator {
 
-template <typename Type>
-class constant_iterator {
-
-public:
+  public:
     typedef typename std::size_t difference_type;
     typedef Type value_type;
     typedef const Type* pointer;
     typedef const Type& reference;
     typedef std::random_access_iterator_tag iterator_category;
 
-    constant_iterator() : my_value() {}
-    explicit constant_iterator(Type init) : my_value(init) {}
+    constant_iterator()
+        : my_value() {}
+    explicit constant_iterator(Type init)
+        : my_value(init) {}
 
     inline reference operator*() const { return my_value; }
-    inline value_type operator[](difference_type i) const { return my_value; }
+    inline value_type operator[](difference_type) const { return my_value; }
 
-    inline difference_type operator-(const constant_iterator<Type>& it) const { return 0; }
+    inline difference_type operator-(const constant_iterator<Type>&) const { return 0; }
 
-    inline constant_iterator<Type>& operator+=(difference_type forward)  const { return *this; }
-    inline constant_iterator<Type>& operator-=(difference_type backward) const { return *this; }
+    inline constant_iterator<Type>& operator+=(difference_type) const { return *this; }
+    inline constant_iterator<Type>& operator-=(difference_type) const { return *this; }
     inline constant_iterator<Type>& operator++() const { return *this; }
     inline constant_iterator<Type>& operator--() const { return *this; }
 
-    inline constant_iterator<Type> operator++(int) { return constant_iterator<Type>(my_value); }
-
-    inline constant_iterator<Type> operator--(int) { return constant_iterator<Type>(my_value); }
-
-    inline constant_iterator<Type> operator-(difference_type backward) const { return constant_iterator<Type>(my_value); }
-    inline constant_iterator<Type> operator+(difference_type forward) const { return constant_iterator<Type>(my_value); }
-    friend constant_iterator<Type> operator+(difference_type forward, const constant_iterator<Type> it) { return constant_iterator<Type>(*it); }
-
-    inline bool operator==(const constant_iterator<Type>& it) const { return  (my_value - *it) == 0; }
-    inline bool operator!=(const constant_iterator<Type>& it) const { return !(my_value == *it); }
+    inline constant_iterator<Type> operator++(int) {
+      return constant_iterator<Type>(my_value);
+    }
 
-private:
-   const value_type my_value;
-};
+    inline constant_iterator<Type> operator--(int) {
+      return constant_iterator<Type>(my_value);
+    }
 
+    inline constant_iterator<Type> operator-(difference_type) const {
+      return constant_iterator<Type>(my_value);
+    }
+    inline constant_iterator<Type> operator+(difference_type) const {
+      return constant_iterator<Type>(my_value);
+    }
+    friend constant_iterator<Type> operator+(difference_type,
+                                             const constant_iterator<Type> it) {
+      return constant_iterator<Type>(*it);
+    }
 
-template <typename IntType>
-class counting_iterator {
-	__RANDOM_ITERATOR_TBB_STATIC_ASSERT(std::numeric_limits<IntType>::is_integer, "Cannot instantiate counting_iterator with a non-integer type");
-public:
-	typedef typename std::make_signed<IntType>::type difference_type;
-	typedef IntType value_type;
-	typedef const IntType* pointer;
-	typedef const IntType& reference;
-	typedef std::random_access_iterator_tag iterator_category;
+    inline bool operator==(const constant_iterator<Type>& it) const {
+      return (my_value - *it) == 0;
+    }
+    inline bool operator!=(const constant_iterator<Type>& it) const {
+      return !(my_value == *it);
+    }
 
-	counting_iterator() : my_counter() {}
-	explicit counting_iterator(IntType init) : my_counter(init) {}
+  private:
+    const value_type my_value;
+  };
+
+  template <typename IntType>
+  class counting_iterator {
+    __RANDOM_ITERATOR_TBB_STATIC_ASSERT(
+        std::numeric_limits<IntType>::is_integer,
+        "Cannot instantiate counting_iterator with a non-integer type");
+
+  public:
+    typedef typename std::make_signed<IntType>::type difference_type;
+    typedef IntType value_type;
+    typedef const IntType* pointer;
+    typedef const IntType& reference;
+    typedef std::random_access_iterator_tag iterator_category;
 
-	inline reference operator*() const { return my_counter; }
-	inline value_type operator[](difference_type i) const { return *(*this + i); }
+    counting_iterator()
+        : my_counter() {}
+    explicit counting_iterator(IntType init)
+        : my_counter(init) {}
 
-	inline difference_type operator-(const counting_iterator& it) const { return my_counter - it.my_counter; }
+    inline reference operator*() const { return my_counter; }
+    inline value_type operator[](difference_type i) const { return *(*this + i); }
 
-	inline counting_iterator& operator+=(difference_type forward) { my_counter += forward; return *this; }
-	inline counting_iterator& operator-=(difference_type backward) { return *this += -backward; }
-	inline counting_iterator& operator++() { return *this += 1; }
-	inline counting_iterator& operator--() { return *this -= 1; }
+    inline difference_type operator-(const counting_iterator& it) const {
+      return my_counter - it.my_counter;
+    }
 
-	inline counting_iterator operator++(int) {
-		counting_iterator it(*this);
-		++(*this);
-		return it;
-	}
-	inline counting_iterator operator--(int) {
-		counting_iterator it(*this);
-		--(*this);
-		return it;
-	}
+    inline counting_iterator& operator+=(difference_type forward) {
+      my_counter += forward;
+      return *this;
+    }
+    inline counting_iterator& operator-=(difference_type backward) {
+      return *this += -backward;
+    }
+    inline counting_iterator& operator++() { return *this += 1; }
+    inline counting_iterator& operator--() { return *this -= 1; }
 
-	inline counting_iterator operator-(difference_type backward) const { return counting_iterator(my_counter - backward); }
-	inline  counting_iterator operator+(difference_type forward) const { return counting_iterator(my_counter + forward); }
-	friend counting_iterator operator+(difference_type forward, const counting_iterator it) { return it + forward; }
+    inline counting_iterator operator++(int) {
+      counting_iterator it(*this);
+      ++(*this);
+      return it;
+    }
+    inline counting_iterator operator--(int) {
+      counting_iterator it(*this);
+      --(*this);
+      return it;
+    }
 
-	inline bool operator==(const counting_iterator& it) const { return *this - it == 0; }
-	inline bool operator!=(const counting_iterator& it) const { return !(*this == it); }
-	inline bool operator<(const counting_iterator& it) const {return *this - it < 0; }
-	inline bool operator>(const counting_iterator& it) const { return it < *this; }
-	inline bool operator<=(const counting_iterator& it) const { return !(*this > it); }
-	inline bool operator>=(const counting_iterator& it) const { return !(*this < it); }
+    inline counting_iterator operator-(difference_type backward) const {
+      return counting_iterator(my_counter - backward);
+    }
+    inline counting_iterator operator+(difference_type forward) const {
+      return counting_iterator(my_counter + forward);
+    }
+    friend counting_iterator operator+(difference_type forward,
+                                       const counting_iterator it) {
+      return it + forward;
+    }
 
-private:
-	IntType my_counter;
-};
-} //namespace random_iterator_tbb
+    inline bool operator==(const counting_iterator& it) const { return *this - it == 0; }
+    inline bool operator!=(const counting_iterator& it) const { return !(*this == it); }
+    inline bool operator<(const counting_iterator& it) const { return *this - it < 0; }
+    inline bool operator>(const counting_iterator& it) const { return it < *this; }
+    inline bool operator<=(const counting_iterator& it) const { return !(*this > it); }
+    inline bool operator>=(const counting_iterator& it) const { return !(*this < it); }
 
+  private:
+    IntType my_counter;
+  };
+} // namespace random_iterator_tbb
 
 #include <tuple>
 
 #include "internal/_template_helpers.h" // index_sequence, make_index_sequence
 
 namespace random_iterator_tbb {
-namespace internal {
-
-template<size_t N>
-struct tuple_util {
-    template<typename TupleType, typename DifferenceType>
-    static void increment(TupleType& it, DifferenceType forward) {
-        std::get<N-1>(it) += forward;
-        tuple_util<N-1>::increment(it, forward);
-    }
-    template<typename TupleType, typename DifferenceType>
-    static bool check_sync(const TupleType& it1, const TupleType& it2, DifferenceType val) {
-        if(std::get<N-1>(it1) - std::get<N-1>(it2) != val)
-            return false;
-        return tuple_util<N-1>::check_sync(it1, it2, val);
-    }
-};
-
-template<>
-struct tuple_util<0> {
-    template<typename TupleType, typename DifferenceType>
-    static void increment(TupleType&, DifferenceType) {}
-    template<typename TupleType, typename DifferenceType>
-    static bool check_sync(const TupleType&, const TupleType&, DifferenceType) { return true;}
-};
-
-template <typename TupleReturnType>
-struct make_references {
-    template <typename TupleType, std::size_t... Is>
-    TupleReturnType operator()(const TupleType& t, random_iterator_tbb::internal::index_sequence<Is...>) {
-        return std::tie( *std::get<Is>(t)... );
-    }
-};
-
-// A simple wrapper over a tuple of references.
-// The class is designed to hold a temporary tuple of reference
-// after dereferencing a zip_iterator; in particular, it is needed
-// to swap these rvalue tuples. Any other usage is not supported.
-template<typename... T>
-struct tuplewrapper : public std::tuple<typename std::enable_if<std::is_reference<T>::value, T&&>::type...> {
-    // In the context of this class, T is a reference, so T&& is a "forwarding reference"
-    typedef std::tuple<T&&...> base_type;
-    // Construct from the result of std::tie
-    tuplewrapper(const base_type& in) : base_type(in) {}
+  namespace internal {
+
+    template <size_t N>
+    struct tuple_util {
+      template <typename TupleType, typename DifferenceType>
+      static void increment(TupleType& it, DifferenceType forward) {
+        std::get<N - 1>(it) += forward;
+        tuple_util<N - 1>::increment(it, forward);
+      }
+      template <typename TupleType, typename DifferenceType>
+      static bool check_sync(const TupleType& it1, const TupleType& it2,
+                             DifferenceType val) {
+        if (std::get<N - 1>(it1) - std::get<N - 1>(it2) != val) return false;
+        return tuple_util<N - 1>::check_sync(it1, it2, val);
+      }
+    };
+
+    template <>
+    struct tuple_util<0> {
+      template <typename TupleType, typename DifferenceType>
+      static void increment(TupleType&, DifferenceType) {}
+      template <typename TupleType, typename DifferenceType>
+      static bool check_sync(const TupleType&, const TupleType&, DifferenceType) {
+        return true;
+      }
+    };
+
+    template <typename TupleReturnType>
+    struct make_references {
+      template <typename TupleType, std::size_t... Is>
+      TupleReturnType operator()(const TupleType& t,
+                                 random_iterator_tbb::internal::index_sequence<Is...>) {
+        return std::tie(*std::get<Is>(t)...);
+      }
+    };
+
+    // A simple wrapper over a tuple of references.
+    // The class is designed to hold a temporary tuple of reference
+    // after dereferencing a zip_iterator; in particular, it is needed
+    // to swap these rvalue tuples. Any other usage is not supported.
+    template <typename... T>
+    struct tuplewrapper
+        : public std::tuple<
+              typename std::enable_if<std::is_reference<T>::value, T&&>::type...> {
+      // In the context of this class, T is a reference, so T&& is a "forwarding
+      // reference"
+      typedef std::tuple<T&&...> base_type;
+      // Construct from the result of std::tie
+      tuplewrapper(const base_type& in)
+          : base_type(in) {}
 #if __INTEL_COMPILER
-    // ICC cannot generate copy ctor & assignment
-    tuplewrapper(const tuplewrapper& rhs) : base_type(rhs) {}
-    tuplewrapper& operator=(const tuplewrapper& rhs) {
+      // ICC cannot generate copy ctor & assignment
+      tuplewrapper(const tuplewrapper& rhs)
+          : base_type(rhs) {}
+      tuplewrapper& operator=(const tuplewrapper& rhs) {
         *this = base_type(rhs);
         return *this;
-    }
+      }
 #endif
-    // Assign any tuple convertible to std::tuple<T&&...>: *it = a_tuple;
-    template<typename... U>
-    tuplewrapper& operator=(const std::tuple<U...>& other) {
+      // Assign any tuple convertible to std::tuple<T&&...>: *it = a_tuple;
+      template <typename... U>
+      tuplewrapper& operator=(const std::tuple<U...>& other) {
         base_type::operator=(other);
         return *this;
-    }
+      }
 #if _LIBCPP_VERSION
-    // (Necessary for libc++ tuples) Convert to a tuple of values: v = *it;
-    operator std::tuple<typename std::remove_reference<T>::type...>() { return base_type(*this); }
+      // (Necessary for libc++ tuples) Convert to a tuple of values: v = *it;
+      operator std::tuple<typename std::remove_reference<T>::type...>() {
+        return base_type(*this);
+      }
 #endif
-    // Swap rvalue tuples: swap(*it1,*it2);
-    friend void swap(tuplewrapper&& a, tuplewrapper&& b) {
-        std::swap<T&&...>(a,b);
-    }
-};
+      // Swap rvalue tuples: swap(*it1,*it2);
+      friend void swap(tuplewrapper&& a, tuplewrapper&& b) { std::swap<T&&...>(a, b); }
+    };
 
-} //namespace internal
+  } // namespace internal
 
-template <typename... Types>
-class zip_iterator {
-    __RANDOM_ITERATOR_TBB_STATIC_ASSERT(sizeof...(Types)>0, "Cannot instantiate zip_iterator with empty template parameter pack");
+  template <typename... Types>
+  class zip_iterator {
+    __RANDOM_ITERATOR_TBB_STATIC_ASSERT(
+        sizeof...(Types) > 0,
+        "Cannot instantiate zip_iterator with empty template parameter pack");
     static const std::size_t num_types = sizeof...(Types);
     typedef std::tuple<Types...> it_types;
-public:
+
+  public:
     typedef typename std::make_signed<std::size_t>::type difference_type;
     typedef std::tuple<typename std::iterator_traits<Types>::value_type...> value_type;
 #if __INTEL_COMPILER && __INTEL_COMPILER < 1800 && _MSC_VER
     typedef std::tuple<typename std::iterator_traits<Types>::reference...> reference;
 #else
-    typedef random_iterator_tbb::internal::tuplewrapper<typename std::iterator_traits<Types>::reference...> reference;
+    typedef random_iterator_tbb::internal::tuplewrapper<
+        typename std::iterator_traits<Types>::reference...>
+        reference;
 #endif
     typedef std::tuple<typename std::iterator_traits<Types>::pointer...> pointer;
     typedef std::random_access_iterator_tag iterator_category;
 
-    zip_iterator() : my_it() {}
-    explicit zip_iterator(Types... args) : my_it(std::make_tuple(args...)) {}
-    zip_iterator(const zip_iterator& input) : my_it(input.my_it) {}
+    zip_iterator()
+        : my_it() {}
+    explicit zip_iterator(Types... args)
+        : my_it(std::make_tuple(args...)) {}
+    zip_iterator(const zip_iterator& input)
+        : my_it(input.my_it) {}
     zip_iterator& operator=(const zip_iterator& input) {
-        my_it = input.my_it;
-        return *this;
+      my_it = input.my_it;
+      return *this;
     }
 
     reference operator*() const {
-        return random_iterator_tbb::internal::make_references<reference>()(my_it, random_iterator_tbb::internal::make_index_sequence<num_types>());
+      return random_iterator_tbb::internal::make_references<reference>()(
+          my_it, random_iterator_tbb::internal::make_index_sequence<num_types>());
     }
     reference operator[](difference_type i) const { return *(*this + i); }
 
     difference_type operator-(const zip_iterator& it) const {
-        __RANDOM_ITERATOR_TBB_ASSERT(internal::tuple_util<num_types>::check_sync(my_it, it.my_it, std::get<0>(my_it) - std::get<0>(it.my_it)),
-                     "Components of zip_iterator are not synchronous");
-        return std::get<0>(my_it) - std::get<0>(it.my_it);
+      __RANDOM_ITERATOR_TBB_ASSERT(
+          internal::tuple_util<num_types>::check_sync(
+              my_it, it.my_it, std::get<0>(my_it) - std::get<0>(it.my_it)),
+          "Components of zip_iterator are not synchronous");
+      return std::get<0>(my_it) - std::get<0>(it.my_it);
     }
 
     zip_iterator& operator+=(difference_type forward) {
-        internal::tuple_util<num_types>::increment(my_it, forward);
-        return *this;
+      internal::tuple_util<num_types>::increment(my_it, forward);
+      return *this;
     }
     zip_iterator& operator-=(difference_type backward) { return *this += -backward; }
     zip_iterator& operator++() { return *this += 1; }
     zip_iterator& operator--() { return *this -= 1; }
 
     zip_iterator operator++(int) {
-        zip_iterator it(*this);
-        ++(*this);
-        return it;
+      zip_iterator it(*this);
+      ++(*this);
+      return it;
     }
     zip_iterator operator--(int) {
-        zip_iterator it(*this);
-        --(*this);
-        return it;
+      zip_iterator it(*this);
+      --(*this);
+      return it;
     }
 
     zip_iterator operator-(difference_type backward) const {
-        zip_iterator it(*this);
-        return it -= backward;
+      zip_iterator it(*this);
+      return it -= backward;
     }
     zip_iterator operator+(difference_type forward) const {
-        zip_iterator it(*this);
-        return it += forward;
+      zip_iterator it(*this);
+      return it += forward;
     }
-    friend zip_iterator operator+(difference_type forward, const zip_iterator& it) { return it + forward; }
-
-    bool operator==(const zip_iterator& it) const {
-        return *this - it == 0;
+    friend zip_iterator operator+(difference_type forward, const zip_iterator& it) {
+      return it + forward;
     }
+
+    bool operator==(const zip_iterator& it) const { return *this - it == 0; }
     it_types base() const { return my_it; }
 
     bool operator!=(const zip_iterator& it) const { return !(*this == it); }
@@ -268,78 +320,86 @@ public:
     bool operator>(const zip_iterator& it) const { return it < *this; }
     bool operator<=(const zip_iterator& it) const { return !(*this > it); }
     bool operator>=(const zip_iterator& it) const { return !(*this < it); }
-private:
+
+  private:
     it_types my_it;
-};
+  };
 
-template<typename... T>
-zip_iterator<T...> make_zip_iterator(T... args) { return zip_iterator<T...>(args...); }
+  template <typename... T>
+  zip_iterator<T...> make_zip_iterator(T... args) {
+    return zip_iterator<T...>(args...);
+  }
 
-template <typename UnaryFunc, typename Iter>
-class transform_iterator {
-public:
+  template <typename UnaryFunc, typename Iter>
+  class transform_iterator {
+  public:
     typedef typename std::iterator_traits<Iter>::value_type value_type;
     typedef typename std::iterator_traits<Iter>::difference_type difference_type;
 #if __RANDOM_ITERATOR_TBB_CPP17_INVOKE_RESULT_PRESENT
-    typedef typename std::invoke_result<UnaryFunc, typename std::iterator_traits<Iter>::reference>::type reference;
+    typedef typename std::invoke_result<
+        UnaryFunc, typename std::iterator_traits<Iter>::reference>::type reference;
 #else
-    typedef typename std::result_of<UnaryFunc(typename std::iterator_traits<Iter>::reference)>::type reference;
+    typedef typename std::result_of<UnaryFunc(
+        typename std::iterator_traits<Iter>::reference)>::type reference;
 #endif
     typedef typename std::iterator_traits<Iter>::pointer pointer;
     typedef typename std::random_access_iterator_tag iterator_category;
 
-    transform_iterator(Iter it, UnaryFunc unary_func) : my_it(it), my_unary_func(unary_func) {
-        __RANDOM_ITERATOR_TBB_STATIC_ASSERT((std::is_same<typename std::iterator_traits<Iter>::iterator_category,
-                             std::random_access_iterator_tag>::value), "Random access iterator required.");
+    transform_iterator(Iter it, UnaryFunc unary_func)
+        : my_it(it)
+        , my_unary_func(unary_func) {
+      __RANDOM_ITERATOR_TBB_STATIC_ASSERT(
+          (std::is_same<typename std::iterator_traits<Iter>::iterator_category,
+                        std::random_access_iterator_tag>::value),
+          "Random access iterator required.");
     }
-    transform_iterator(const transform_iterator& input) : my_it(input.my_it), my_unary_func(input.my_unary_func) { }
+    transform_iterator(const transform_iterator& input)
+        : my_it(input.my_it)
+        , my_unary_func(input.my_unary_func) {}
     transform_iterator& operator=(const transform_iterator& input) {
-        my_it = input.my_it;
-        return *this;
-    }
-    reference operator*() const {
-        return my_unary_func(*my_it);
-    }
-    reference operator[](difference_type i) const {
-        return *(*this + i);
+      my_it = input.my_it;
+      return *this;
     }
+    reference operator*() const { return my_unary_func(*my_it); }
+    reference operator[](difference_type i) const { return *(*this + i); }
     transform_iterator& operator++() {
-        ++my_it;
-        return *this;
+      ++my_it;
+      return *this;
     }
     transform_iterator& operator--() {
-        --my_it;
-        return *this;
+      --my_it;
+      return *this;
     }
     transform_iterator operator++(int) {
-        transform_iterator it(*this);
-        ++(*this);
-        return it;
+      transform_iterator it(*this);
+      ++(*this);
+      return it;
     }
     transform_iterator operator--(int) {
-        transform_iterator it(*this);
-        --(*this);
-        return it;
+      transform_iterator it(*this);
+      --(*this);
+      return it;
     }
     transform_iterator operator+(difference_type forward) const {
-        return { my_it + forward, my_unary_func };
+      return {my_it + forward, my_unary_func};
     }
     transform_iterator operator-(difference_type backward) const {
-        return { my_it - backward, my_unary_func };
+      return {my_it - backward, my_unary_func};
     }
     transform_iterator& operator+=(difference_type forward) {
-        my_it += forward;
-        return *this;
+      my_it += forward;
+      return *this;
     }
     transform_iterator& operator-=(difference_type backward) {
-        my_it -= backward;
-        return *this;
+      my_it -= backward;
+      return *this;
     }
-    friend transform_iterator operator+(difference_type forward, const transform_iterator& it) {
-        return it + forward;
+    friend transform_iterator operator+(difference_type forward,
+                                        const transform_iterator& it) {
+      return it + forward;
     }
     difference_type operator-(const transform_iterator& it) const {
-        return my_it - it.my_it;
+      return my_it - it.my_it;
     }
     bool operator==(const transform_iterator& it) const { return *this - it == 0; }
     bool operator!=(const transform_iterator& it) const { return !(*this == it); }
@@ -349,17 +409,19 @@ public:
     bool operator>=(const transform_iterator& it) const { return !(*this < it); }
 
     Iter base() const { return my_it; }
-private:
+
+  private:
     Iter my_it;
     const UnaryFunc my_unary_func;
-};
+  };
 
-template<typename UnaryFunc, typename Iter>
-transform_iterator<UnaryFunc, Iter> make_transform_iterator(Iter it, UnaryFunc unary_func) {
+  template <typename UnaryFunc, typename Iter>
+  transform_iterator<UnaryFunc, Iter> make_transform_iterator(Iter it,
+                                                              UnaryFunc unary_func) {
     return transform_iterator<UnaryFunc, Iter>(it, unary_func);
-}
+  }
 
-} //namespace random_iterator_tbb
+} // namespace random_iterator_tbb
 
 #endif //__RANDOM_ITERATOR_TBB_CPP11_PRESENT