Clean-up inline members of nested classes (net/)

net/tools/flip_server/balsa_headers.h

 // Copyright (c) 2009 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #ifndef NET_TOOLS_FLIP_SERVER_BALSA_HEADERS_H_
 #define NET_TOOLS_FLIP_SERVER_BALSA_HEADERS_H_
 
 #include <algorithm>
 #include <iosfwd>
 #include <iterator>
@@ skipping 288 matching lines @@
     typedef StringPiecePair value_type;
     typedef value_type& reference;
     typedef value_type* pointer;
 
     typedef std::forward_iterator_tag iterator_category;
     typedef ptrdiff_t difference_type;
 
     typedef iterator_base self;
 
     // default constructor.
-    iterator_base() : headers_(NULL), idx_(0) { }
+    iterator_base();
 
     // copy constructor.
-    iterator_base(const iterator_base& it)
-      : headers_(it.headers_),
-        idx_(it.idx_) {}
+    iterator_base(const iterator_base& it);
 
     reference operator*() const {
       return Lookup(idx_);
     }
 
     pointer operator->() const {
       return &(this->operator*());
     }
 
     bool operator==(const self& it) const {
@@ skipping 21 matching lines @@
     }
 
     // This mainly exists so that we can have interesting output for
     // unittesting. The EXPECT_EQ, EXPECT_NE functions require that
     // operator<< work for the classes it sees.  It would be better if there
     // was an additional traits-like system for the gUnit output... but oh
     // well.
     std::ostream& operator<<(std::ostream& os) const;
 
    protected:
-    iterator_base(const BalsaHeaders* headers, HeaderLines::size_type index) :
-        headers_(headers),
-        idx_(index) {}
+    iterator_base(const BalsaHeaders* headers, HeaderLines::size_type index);
 
     void increment() {
       const HeaderLines& header_lines = headers_->header_lines_;
       const HeaderLines::size_type header_lines_size = header_lines.size();
       const HeaderLines::size_type original_idx = idx_;
       do {
         ++idx_;
       } while (idx_ < header_lines_size && header_lines[idx_].skip == true);
       // The condition below exists so that ++(end() - 1) == end(), even
       // if there are only 'skip == true' elements between the end() iterator
@@ skipping 49 matching lines @@
     typedef iterator_base::reference reference;
     typedef iterator_base::pointer pointer;
     using iterator_base::headers_;
     using iterator_base::idx_;
 
     reverse_iterator_base() : iterator_base() {}
 
     // This constructor is no explicit purposely.
     reverse_iterator_base(const iterator_base& it) :  // NOLINT
         iterator_base(it) {
     }

[mmenke, 2012/08/09 15:13:35]

Should these constructors be de-inlined?

[hans, 2012/08/09 15:35:42]

The plugin doesn't think it's complex enough.

 
     self& operator=(const iterator_base& it) {
       idx_ = it.idx_;
       headers_ = it.headers_;
       return *this;
     }
 
     self& operator=(const reverse_iterator_base& it) {
       idx_ = it.idx_;
       headers_ = it.headers_;
       return *this;
     }
 
     reference operator*() const {
       return Lookup(idx_ - 1);
     }
 
     pointer operator->() const {
       return &(this->operator*());
     }
 
     reverse_iterator_base(const reverse_iterator_base& it) :
         iterator_base(it) { }

[mmenke, 2012/08/09 15:13:35]

Another inline constructor.

[hans, 2012/08/09 15:35:42]

Ditto.

 
    protected:
     void increment() {
       --idx_;
       iterator_base::decrement();
       ++idx_;
     }
 
     void decrement() {
       ++idx_;
       iterator_base::increment();
       --idx_;
     }
 
     reverse_iterator_base(const BalsaHeaders* headers,
                           HeaderLines::size_type index) :
         iterator_base(headers, index) {}

[mmenke, 2012/08/09 15:13:35]

Another inline constructor.

[hans, 2012/08/09 15:35:42]

Ditto.

   };
 
  public:
   class const_header_lines_iterator : public iterator_base {
     friend class BalsaHeaders;
    public:
     typedef const_header_lines_iterator self;
     const_header_lines_iterator() : iterator_base() {}
 
     const_header_lines_iterator(const const_header_lines_iterator& it) :
         iterator_base(it.headers_, it.idx_) {}

[mmenke, 2012/08/09 15:13:35]

Two more inline constructors.

[hans, 2012/08/09 15:35:42]

Ditto.

 
     self& operator++() {
       iterator_base::increment();
       return *this;
     }
 
     self& operator--() {
       iterator_base::decrement();
       return *this;
     }
    protected:
     const_header_lines_iterator(const BalsaHeaders* headers,
                                 HeaderLines::size_type index) :
         iterator_base(headers, index) {}

[mmenke, 2012/08/09 15:13:35]

Another inline constructor.

[hans, 2012/08/09 15:35:42]

Ditto.

   };
 
   class const_reverse_header_lines_iterator : public reverse_iterator_base {
    public:
     typedef const_reverse_header_lines_iterator self;
     const_reverse_header_lines_iterator() : reverse_iterator_base() {}
 
     const_reverse_header_lines_iterator(
       const const_header_lines_iterator& it) :
         reverse_iterator_base(it.headers_, it.idx_) {}
 
     const_reverse_header_lines_iterator(
       const const_reverse_header_lines_iterator& it) :
         reverse_iterator_base(it.headers_, it.idx_) {}
 
     const_header_lines_iterator base() {
       return const_header_lines_iterator(headers_, idx_);
     }

[mmenke, 2012/08/09 15:13:35]

Four more inline constructors.  Not going to bother commenting on the rest in
this file.

[hans, 2012/08/09 15:35:42]

Ditto.

 
     self& operator++() {
       reverse_iterator_base::increment();
       return *this;
     }
 
     self& operator--() {
       reverse_iterator_base::decrement();
       return *this;
     }
    protected:
     const_reverse_header_lines_iterator(const BalsaHeaders* headers,
                                         HeaderLines::size_type index) :
         reverse_iterator_base(headers, index) {}
 
     friend class BalsaHeaders;
   };
 
   // An iterator that only stops at lines with a particular key.
   // See also GetIteratorForKey.
   //
   // Check against header_lines_key_end() to determine when iteration is
   // finished. header_lines_end() will also work.
   class const_header_lines_key_iterator : public iterator_base {
     friend class BalsaHeaders;
    public:
     typedef const_header_lines_key_iterator self;
+    const_header_lines_key_iterator(const const_header_lines_key_iterator&);
 
     self& operator++() {
       do {
         iterator_base::increment();
       } while (!AtEnd() &&
                !StringPieceUtils::EqualIgnoreCase(key_, (**this).first));
       return *this;
     }
 
     void operator++(int ignore) {
       ++(*this);
     }
 
     // Only forward-iteration makes sense, so no operator-- defined.
 
    private:
     const_header_lines_key_iterator(const BalsaHeaders* headers,
                                     HeaderLines::size_type index,
-                                    const base::StringPiece& key)
-        : iterator_base(headers, index),
-          key_(key) {
-    }
+                                    const base::StringPiece& key);
 
     // Should only be used for creating an end iterator.
     const_header_lines_key_iterator(const BalsaHeaders* headers,
-                                    HeaderLines::size_type index)
-        : iterator_base(headers, index) {
-    }
+                                    HeaderLines::size_type index);
 
     bool AtEnd() const {
       return *this >= headers_->header_lines_end();
     }
 
     base::StringPiece key_;
   };
 
   // TODO(fenix): Revisit the amount of bytes initially allocated to the second
   // block of the balsa_buffer_. It may make sense to pre-allocate some amount
@@ skipping 559 matching lines @@
   size_t end_of_firstline_idx_;
 
   bool transfer_encoding_is_chunked_;
 
   HeaderLines header_lines_;
 };
 
 }  // namespace net
 
 #endif  // NET_TOOLS_FLIP_SERVER_BALSA_HEADERS_H_