Reformat with clang-format

test/helpers/input_iterator.hpp

@@ -10,156 +10,164 @@
 #include <boost/iterator/iterator_traits.hpp>
 #include <iterator>
 
-namespace test
+namespace test {
+template <class Iterator> struct proxy
 {
-    template <class Iterator>
-    struct proxy
-    {
-        typedef BOOST_DEDUCED_TYPENAME Iterator::value_type value_type;
+    typedef BOOST_DEDUCED_TYPENAME Iterator::value_type value_type;
 
-        explicit proxy(value_type const& v) : v_(v) {}
-        proxy(proxy const& x) : v_(x.v_) {}
-        operator value_type const&() const { return v_; }
-        
-        value_type v_;
-    private:
-        proxy& operator=(proxy const&);
-    };
+    explicit proxy(value_type const& v) : v_(v) {}
+    proxy(proxy const& x) : v_(x.v_) {}
+    operator value_type const&() const { return v_; }
 
-    template <class Iterator>
-    struct input_iterator_adaptor
-        : public std::iterator<
-            std::input_iterator_tag,
-            BOOST_DEDUCED_TYPENAME boost::iterator_value<Iterator>::type,
-            std::ptrdiff_t,
-            BOOST_DEDUCED_TYPENAME boost::iterator_pointer<Iterator>::type,
-            proxy<Iterator>
-        >
-    {
-        typedef BOOST_DEDUCED_TYPENAME boost::iterator_value<Iterator>::type
-            value_type;
-    
-        input_iterator_adaptor()
-            : base_() {}
-        explicit input_iterator_adaptor(Iterator& it)
-            : base_(&it) {}
-        proxy<Iterator> operator*() const {
-            return proxy<Iterator>(**base_);
-        }
-        value_type* operator->() const {
-            return &**base_;
-        }
-        input_iterator_adaptor& operator++() {
-            ++*base_; return *this;
-        }
-        //input_iterator_adaptor operator++(int) {
-        //}
-        bool operator==(input_iterator_adaptor const& x) const {
-            return *base_ == *x.base_;
-        }
-        bool operator!=(input_iterator_adaptor const& x) const {
-            return *base_ != *x.base_;
-        }
-    private:
-        Iterator* base_;
-    };
+    value_type v_;
 
-    template <class Iterator>
-    input_iterator_adaptor<Iterator> input_iterator(Iterator& it)
+  private:
+    proxy& operator=(proxy const&);
+};
+
+template <class Iterator>
+struct input_iterator_adaptor
+    : public std::iterator<std::input_iterator_tag,
+          BOOST_DEDUCED_TYPENAME boost::iterator_value<Iterator>::type,
+          std::ptrdiff_t,
+          BOOST_DEDUCED_TYPENAME boost::iterator_pointer<Iterator>::type,
+          proxy<Iterator> >
+{
+    typedef BOOST_DEDUCED_TYPENAME boost::iterator_value<Iterator>::type
+        value_type;
+
+    input_iterator_adaptor() : base_() {}
+    explicit input_iterator_adaptor(Iterator& it) : base_(&it) {}
+    proxy<Iterator> operator*() const { return proxy<Iterator>(**base_); }
+    value_type* operator->() const { return &**base_; }
+    input_iterator_adaptor& operator++()
     {
-        return input_iterator_adaptor<Iterator>(it);
+        ++*base_;
+        return *this;
+    }
+    // input_iterator_adaptor operator++(int) {
+    //}
+    bool operator==(input_iterator_adaptor const& x) const
+    {
+        return *base_ == *x.base_;
+    }
+    bool operator!=(input_iterator_adaptor const& x) const
+    {
+        return *base_ != *x.base_;
     }
 
-    template <class Iterator>
-    struct copy_iterator_adaptor
-        : public std::iterator<
-            BOOST_DEDUCED_TYPENAME boost::iterator_category<Iterator>::type,
-            BOOST_DEDUCED_TYPENAME boost::iterator_value<Iterator>::type,
-            BOOST_DEDUCED_TYPENAME boost::iterator_difference<Iterator>::type,
-            BOOST_DEDUCED_TYPENAME boost::iterator_pointer<Iterator>::type,
-            proxy<Iterator>
-        >
-    {
-        typedef BOOST_DEDUCED_TYPENAME boost::iterator_value<Iterator>::type
-            value_type;
-        typedef BOOST_DEDUCED_TYPENAME boost::iterator_difference<Iterator>::type
-            difference_type;
-    
-        copy_iterator_adaptor()
-            : base_() {}
-        explicit copy_iterator_adaptor(Iterator const& it)
-            : base_(it) {}
-        value_type operator*() const {
-            return *base_;
-        }
-        value_type* operator->() const {
-            return &*base_;
-        }
-        value_type operator[](difference_type d) {
-            return base_[d];
-        }
-        copy_iterator_adaptor& operator++() {
-            ++base_; return *this;
-        }
-        copy_iterator_adaptor operator++(int) {
-            copy_iterator_adaptor tmp(*this); ++base_; return tmp;
-        }
-        copy_iterator_adaptor& operator--() {
-            --base_; return *this;
-        }
-        copy_iterator_adaptor operator--(int) {
-            copy_iterator_adaptor tmp(*this); --base_; return tmp;
-        }
-        copy_iterator_adaptor operator+=(difference_type x) {
-            base_ += x;
-            return *this;
-        }
-        copy_iterator_adaptor operator-=(difference_type x) {
-            base_ -= x;
-            return *this;
-        }
-        copy_iterator_adaptor operator+(difference_type n) {
-            return copy_iterator_adaptor(base_+n);
-        }
-        copy_iterator_adaptor operator-(difference_type n) {
-            return copy_iterator_adaptor(base_-n);
-        }
-        friend copy_iterator_adaptor operator+(
-                difference_type n, copy_iterator_adaptor x) {
-            return x+n;
-        }
-        difference_type operator-(copy_iterator_adaptor const& other) {
-            return base_-other.base_;
-        }
-        bool operator==(copy_iterator_adaptor const& x) const {
-            return base_ == x.base_;
-        }
-        bool operator!=(copy_iterator_adaptor const& x) const {
-            return base_ != x.base_;
-        }
-        bool operator<(copy_iterator_adaptor const& x) const {
-            return base_ < x.base_;
-        }
-        bool operator>(copy_iterator_adaptor const& x) const {
-            return base_ > x.base_;
-        }
-        bool operator<=(copy_iterator_adaptor const& x) const {
-            return base_ <= x.base_;
-        }
-        bool operator>=(copy_iterator_adaptor const& x) const {
-            return base_ >= x.base_;
-        }
-    private:
-        Iterator base_;
-    };
+  private:
+    Iterator* base_;
+};
 
-    template <class Iterator>
-    copy_iterator_adaptor<Iterator> copy_iterator(Iterator const& it)
+template <class Iterator>
+input_iterator_adaptor<Iterator> input_iterator(Iterator& it)
+{
+    return input_iterator_adaptor<Iterator>(it);
+}
+
+template <class Iterator>
+struct copy_iterator_adaptor
+    : public std::iterator<
+          BOOST_DEDUCED_TYPENAME boost::iterator_category<Iterator>::type,
+          BOOST_DEDUCED_TYPENAME boost::iterator_value<Iterator>::type,
+          BOOST_DEDUCED_TYPENAME boost::iterator_difference<Iterator>::type,
+          BOOST_DEDUCED_TYPENAME boost::iterator_pointer<Iterator>::type,
+          proxy<Iterator> >
+{
+    typedef BOOST_DEDUCED_TYPENAME boost::iterator_value<Iterator>::type
+        value_type;
+    typedef BOOST_DEDUCED_TYPENAME boost::iterator_difference<Iterator>::type
+        difference_type;
+
+    copy_iterator_adaptor() : base_() {}
+    explicit copy_iterator_adaptor(Iterator const& it) : base_(it) {}
+    value_type operator*() const { return *base_; }
+    value_type* operator->() const { return &*base_; }
+    value_type operator[](difference_type d) { return base_[d]; }
+    copy_iterator_adaptor& operator++()
     {
-        return copy_iterator_adaptor<Iterator>(it);
+        ++base_;
+        return *this;
+    }
+    copy_iterator_adaptor operator++(int)
+    {
+        copy_iterator_adaptor tmp(*this);
+        ++base_;
+        return tmp;
+    }
+    copy_iterator_adaptor& operator--()
+    {
+        --base_;
+        return *this;
+    }
+    copy_iterator_adaptor operator--(int)
+    {
+        copy_iterator_adaptor tmp(*this);
+        --base_;
+        return tmp;
+    }
+    copy_iterator_adaptor operator+=(difference_type x)
+    {
+        base_ += x;
+        return *this;
+    }
+    copy_iterator_adaptor operator-=(difference_type x)
+    {
+        base_ -= x;
+        return *this;
+    }
+    copy_iterator_adaptor operator+(difference_type n)
+    {
+        return copy_iterator_adaptor(base_ + n);
+    }
+    copy_iterator_adaptor operator-(difference_type n)
+    {
+        return copy_iterator_adaptor(base_ - n);
+    }
+    friend copy_iterator_adaptor operator+(
+        difference_type n, copy_iterator_adaptor x)
+    {
+        return x + n;
+    }
+    difference_type operator-(copy_iterator_adaptor const& other)
+    {
+        return base_ - other.base_;
+    }
+    bool operator==(copy_iterator_adaptor const& x) const
+    {
+        return base_ == x.base_;
+    }
+    bool operator!=(copy_iterator_adaptor const& x) const
+    {
+        return base_ != x.base_;
+    }
+    bool operator<(copy_iterator_adaptor const& x) const
+    {
+        return base_ < x.base_;
+    }
+    bool operator>(copy_iterator_adaptor const& x) const
+    {
+        return base_ > x.base_;
+    }
+    bool operator<=(copy_iterator_adaptor const& x) const
+    {
+        return base_ <= x.base_;
+    }
+    bool operator>=(copy_iterator_adaptor const& x) const
+    {
+        return base_ >= x.base_;
     }
 
+  private:
+    Iterator base_;
+};
+
+template <class Iterator>
+copy_iterator_adaptor<Iterator> copy_iterator(Iterator const& it)
+{
+    return copy_iterator_adaptor<Iterator>(it);
+}
 }
 
 #endif
-