Add iterator range constructors to StringPiece.

base/string_piece.h

 // Copyright (c) 2011 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.
 // Copied from strings/stringpiece.h with modifications
 //
 // A string-like object that points to a sized piece of memory.
 //
 // Functions or methods may use const StringPiece& parameters to accept either
 // a "const char*" or a "string" value that will be implicitly converted to
 // a StringPiece.  The implicit conversion means that it is often appropriate
@@ skipping 47 matching lines @@
   // We provide non-explicit singleton constructors so users can pass
   // in a "const char*" or a "string" wherever a "StringPiece" is
   // expected (likewise for char16, string16, StringPiece16).
   StringPieceDetail() : ptr_(NULL), length_(0) {}
   StringPieceDetail(const value_type* str)
       : ptr_(str),
       length_((str == NULL) ? 0 : STRING_TYPE::traits_type::length(str)) {}
   StringPieceDetail(const STRING_TYPE& str)
       : ptr_(str.data()),
         length_(str.size()) {}
+  StringPieceDetail(const typename STRING_TYPE::const_iterator& begin,
+                    const typename STRING_TYPE::const_iterator& end)
+      : ptr_(begin == end ? NULL : &*begin),
+        length_(end - begin) {}
+  StringPieceDetail(const typename STRING_TYPE::iterator& begin,
+                    const typename STRING_TYPE::iterator& end)
+      : ptr_(begin == end ? NULL : &*begin),
+        length_(end - begin) {}
   StringPieceDetail(const value_type* offset, size_type len)
       : ptr_(offset),
         length_(len) {}
 
   // data() may return a pointer to a buffer with embedded NULs, and the
   // returned buffer may or may not be null terminated.  Therefore it is
   // typically a mistake to pass data() to a routine that expects a NUL
   // terminated string.
   const value_type* data() const { return ptr_; }
   size_type size() const { return length_; }
@@ skipping 83 matching lines @@
   typedef typename internal::StringPieceDetail<STRING_TYPE>::value_type
       value_type;
   typedef typename internal::StringPieceDetail<STRING_TYPE>::size_type
       size_type;
 
   BasicStringPiece() {}
   BasicStringPiece(const value_type*str)
       : internal::StringPieceDetail<STRING_TYPE>(str) {}
   BasicStringPiece(const STRING_TYPE& str)
       : internal::StringPieceDetail<STRING_TYPE>(str) {}
+  BasicStringPiece(const typename STRING_TYPE::const_iterator& begin,
+                   const typename STRING_TYPE::const_iterator& end)
+      : internal::StringPieceDetail<STRING_TYPE>(begin, end) {}
+  BasicStringPiece(const typename STRING_TYPE::iterator& begin,
+                   const typename STRING_TYPE::iterator& end)
+      : internal::StringPieceDetail<STRING_TYPE>(begin, end) {}
   BasicStringPiece(const value_type* offset, size_type len)
       : internal::StringPieceDetail<STRING_TYPE>(offset, len) {}
 };
 
 // Specializes BasicStringPiece for std::string to add a few operations that
 // are not needed for string16.
 template <> class BASE_EXPORT BasicStringPiece<std::string> :
     public internal::StringPieceDetail<std::string> {
  public:
   BasicStringPiece() {}
   BasicStringPiece(const char* str)
       : internal::StringPieceDetail<std::string>(str) {}
   BasicStringPiece(const std::string& str)
       : internal::StringPieceDetail<std::string>(str) {}
+  BasicStringPiece(const std::string::const_iterator& begin,
+                   const std::string::const_iterator& end)
+      : internal::StringPieceDetail<std::string>(begin, end) {}
+  BasicStringPiece(const std::string::iterator& begin,
+                   const std::string::iterator& end)
+      : internal::StringPieceDetail<std::string>(begin, end) {}
   BasicStringPiece(const char* offset, size_type len)
       : internal::StringPieceDetail<std::string>(offset, len) {}
 
   // Prevent the following overload of set() from hiding the definitions in the
   // base class.
   using internal::StringPieceDetail<std::string>::set;
 
   void set(const void* data, size_type len) {
     ptr_ = reinterpret_cast<const value_type*>(data);
     length_ = len;
@@ skipping 139 matching lines @@
 }
 inline size_t hash_value(const base::StringPiece16& sp16) {
   HASH_STRING_PIECE(base::StringPiece16, sp16);
 }
 
 #endif  // COMPILER
 
 }  // namespace BASE_HASH_NAMESPACE
 
 #endif  // BASE_STRING_PIECE_H_