base/string_piece.h - chromium/src - Git at Google

 // 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
 // to include this .h file in other files rather than forward-declaring
 // StringPiece as would be appropriate for most other Google classes.
 //
 // Systematic usage of StringPiece is encouraged as it will reduce unnecessary
 // conversions from "const char*" to "string" and back again.
 //
 // StringPiece16 is similar to StringPiece but for base::string16 instead of
 // std::string. We do not define as large of a subset of the STL functions
 // from basic_string as in StringPiece, but this can be changed if these
 // functions (find, find_first_of, etc.) are found to be useful in this context.
 //

 #ifndef BASE_STRING_PIECE_H_
 #define BASE_STRING_PIECE_H_
 #pragma once

 #include <string>

 #include "base/base_export.h"
 #include "base/basictypes.h"
 #include "base/hash_tables.h"
 #include "base/string16.h"

 namespace base {

 class BASE_EXPORT StringPiece {
  public:
   // standard STL container boilerplate
   typedef size_t size_type;
   typedef char value_type;
   typedef const char* pointer;
   typedef const char& reference;
   typedef const char& const_reference;
   typedef ptrdiff_t difference_type;
   typedef const char* const_iterator;
   typedef const char* iterator;
   typedef std::reverse_iterator<const_iterator> const_reverse_iterator;
   typedef std::reverse_iterator<iterator> reverse_iterator;

   static const size_type npos;

  public:
   // We provide non-explicit singleton constructors so users can pass
   // in a "const char*" or a "string" wherever a "StringPiece" is
   // expected.
   StringPiece() : ptr_(NULL), length_(0) { }
   StringPiece(const char* str)
     : ptr_(str), length_((str == NULL) ? 0 : strlen(str)) { }
   StringPiece(const std::string& str)
     : ptr_(str.data()), length_(str.size()) { }
   StringPiece(const char* 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 char* data() const { return ptr_; }
   size_type size() const { return length_; }
   size_type length() const { return length_; }
   bool empty() const { return length_ == 0; }

   void clear() {
     ptr_ = NULL;
     length_ = 0;
   }
   void set(const char* data, size_type len) {
     ptr_ = data;
     length_ = len;
   }
   void set(const char* str) {
     ptr_ = str;
     length_ = str ? strlen(str) : 0;
   }
   void set(const void* data, size_type len) {
     ptr_ = reinterpret_cast<const char*>(data);
     length_ = len;
   }

   char operator[](size_type i) const { return ptr_[i]; }

   void remove_prefix(size_type n) {
     ptr_ += n;
     length_ -= n;
   }

   void remove_suffix(size_type n) {
     length_ -= n;
   }

   int compare(const StringPiece& x) const {
     int r = wordmemcmp(
         ptr_, x.ptr_, (length_ < x.length_ ? length_ : x.length_));
     if (r == 0) {
       if (length_ < x.length_) r = -1;
       else if (length_ > x.length_) r = +1;
     }
     return r;
   }

   std::string as_string() const {
     // std::string doesn't like to take a NULL pointer even with a 0 size.
     return std::string(!empty() ? data() : "", size());
   }

   void CopyToString(std::string* target) const;
   void AppendToString(std::string* target) const;

   // Does "this" start with "x"
   bool starts_with(const StringPiece& x) const {
     return ((length_ >= x.length_) &&
             (wordmemcmp(ptr_, x.ptr_, x.length_) == 0));
   }

   // Does "this" end with "x"
   bool ends_with(const StringPiece& x) const {
     return ((length_ >= x.length_) &&
             (wordmemcmp(ptr_ + (length_-x.length_), x.ptr_, x.length_) == 0));
   }

   iterator begin() const { return ptr_; }
   iterator end() const { return ptr_ + length_; }
   const_reverse_iterator rbegin() const {
     return const_reverse_iterator(ptr_ + length_);
   }
   const_reverse_iterator rend() const {
     return const_reverse_iterator(ptr_);
   }

   size_type max_size() const { return length_; }
   size_type capacity() const { return length_; }

   size_type copy(char* buf, size_type n, size_type pos = 0) const;

   size_type find(const StringPiece& s, size_type pos = 0) const;
   size_type find(char c, size_type pos = 0) const;
   size_type rfind(const StringPiece& s, size_type pos = npos) const;
   size_type rfind(char c, size_type pos = npos) const;

   size_type find_first_of(const StringPiece& s, size_type pos = 0) const;
   size_type find_first_of(char c, size_type pos = 0) const {
     return find(c, pos);
   }
   size_type find_first_not_of(const StringPiece& s, size_type pos = 0) const;
   size_type find_first_not_of(char c, size_type pos = 0) const;
   size_type find_last_of(const StringPiece& s, size_type pos = npos) const;
   size_type find_last_of(char c, size_type pos = npos) const {
     return rfind(c, pos);
   }
   size_type find_last_not_of(const StringPiece& s, size_type pos = npos) const;
   size_type find_last_not_of(char c, size_type pos = npos) const;

   StringPiece substr(size_type pos, size_type n = npos) const;

   static int wordmemcmp(const char* p, const char* p2, size_type N) {
     return memcmp(p, p2, N);
   }

  private:
   const char*   ptr_;
   size_type     length_;
 };

 class BASE_EXPORT StringPiece16 {
  public:
   // standard STL container boilerplate
   typedef size_t size_type;
   typedef char16 value_type;
   typedef const char16* pointer;
   typedef const char16& reference;
   typedef const char16& const_reference;
   typedef ptrdiff_t difference_type;
   typedef const char16* const_iterator;
   typedef const char16* iterator;
   typedef std::reverse_iterator<const_iterator> const_reverse_iterator;
   typedef std::reverse_iterator<iterator> reverse_iterator;

  public:
   // We provide non-explicit singleton constructors so users can pass
   // in a "const char16*" or a "string16" wherever a "StringPiece16" is
   // expected.
   StringPiece16() : ptr_(NULL), length_(0) { }
   StringPiece16(const char16* str)
       : ptr_(str),
         length_((str == NULL) ? 0 : string16::traits_type::length(str)) { }
   StringPiece16(const string16& str)
       : ptr_(str.data()), length_(str.size()) { }
   StringPiece16(const char16* 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 char16* data() const { return ptr_; }
   size_type size() const { return length_; }
   size_type length() const { return length_; }
   bool empty() const { return length_ == 0; }

   void clear() {
     ptr_ = NULL;
     length_ = 0;
   }
   void set(const char16* data, size_type len) {
     ptr_ = data;
     length_ = len;
   }
   void set(const char16* str) {
     ptr_ = str;
     length_ = str ? string16::traits_type::length(str) : 0;
   }

   char16 operator[](size_type i) const { return ptr_[i]; }

   string16 as_string16() const {
     // StringPiece claims that this is bad when data() is NULL, but unittesting
     // seems to say otherwise.
     return string16(data(), size());
   }

   iterator begin() const { return ptr_; }
   iterator end() const { return ptr_ + length_; }
   const_reverse_iterator rbegin() const {
     return const_reverse_iterator(ptr_ + length_);
   }
   const_reverse_iterator rend() const {
     return const_reverse_iterator(ptr_);
   }

   size_type max_size() const { return length_; }
   size_type capacity() const { return length_; }

   static int wordmemcmp(const char16* p, const char16* p2, size_type N) {
     return string16::traits_type::compare(p, p2, N);
   }

  private:
   const char16*   ptr_;
   size_type       length_;
 };

 BASE_EXPORT bool operator==(const StringPiece& x, const StringPiece& y);

 inline bool operator!=(const StringPiece& x, const StringPiece& y) {
   return !(x == y);
 }

 inline bool operator<(const StringPiece& x, const StringPiece& y) {
   const int r = StringPiece::wordmemcmp(
       x.data(), y.data(), (x.size() < y.size() ? x.size() : y.size()));
   return ((r < 0) || ((r == 0) && (x.size() < y.size())));
 }

 inline bool operator>(const StringPiece& x, const StringPiece& y) {
   return y < x;
 }

 inline bool operator<=(const StringPiece& x, const StringPiece& y) {
   return !(x > y);
 }

 inline bool operator>=(const StringPiece& x, const StringPiece& y) {
   return !(x < y);
 }

 inline bool operator==(const StringPiece16& x, const StringPiece16& y) {
   if (x.size() != y.size())
     return false;

   return StringPiece16::wordmemcmp(x.data(), y.data(), x.size()) == 0;
 }

 inline bool operator!=(const StringPiece16& x, const StringPiece16& y) {
   return !(x == y);
 }

 inline bool operator<(const StringPiece16& x, const StringPiece16& y) {
   const int r = StringPiece16::wordmemcmp(
       x.data(), y.data(), (x.size() < y.size() ? x.size() : y.size()));
   return ((r < 0) || ((r == 0) && (x.size() < y.size())));
 }

 inline bool operator>(const StringPiece16& x, const StringPiece16& y) {
   return y < x;
 }

 inline bool operator<=(const StringPiece16& x, const StringPiece16& y) {
   return !(x > y);
 }

 inline bool operator>=(const StringPiece16& x, const StringPiece16& y) {
   return !(x < y);
 }

 }  // namespace base

 // We provide appropriate hash functions so StringPiece and StringPiece16 can
 // be used as keys in hash sets and maps.

 // This hash function is copied from base/hash_tables.h. We don't use the
 // ones already defined for string and string16 directly because it would
 // require the string constructors to be called, which we don't want.
 #define HASH_STRING_PIECE(StringPieceType, string_piece)                \
   std::size_t result = 0;                                               \
   for (StringPieceType::const_iterator i = string_piece.begin();        \
        i != string_piece.end(); ++i)                                    \
     result = (result * 131) + *i;                                       \
   return result;                                                        \

 namespace BASE_HASH_NAMESPACE {
 #if defined(COMPILER_GCC)

 template<>
 struct hash<base::StringPiece> {
   std::size_t operator()(const base::StringPiece& sp) const {
     HASH_STRING_PIECE(base::StringPiece, sp);
   }
 };
 template<>
 struct hash<base::StringPiece16> {
   std::size_t operator()(const base::StringPiece16& sp16) const {
     HASH_STRING_PIECE(base::StringPiece16, sp16);
   }
 };

 #elif defined(COMPILER_MSVC)

 inline size_t hash_value(const base::StringPiece& sp) {
   HASH_STRING_PIECE(base::StringPiece, sp);
 }
 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_
	// 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
	// to include this .h file in other files rather than forward-declaring
	// StringPiece as would be appropriate for most other Google classes.
	//
	// Systematic usage of StringPiece is encouraged as it will reduce unnecessary
	// conversions from "const char*" to "string" and back again.
	//
	// StringPiece16 is similar to StringPiece but for base::string16 instead of
	// std::string. We do not define as large of a subset of the STL functions
	// from basic_string as in StringPiece, but this can be changed if these
	// functions (find, find_first_of, etc.) are found to be useful in this context.
	//

	#ifndef BASE_STRING_PIECE_H_
	#define BASE_STRING_PIECE_H_
	#pragma once

	#include <string>

	#include "base/base_export.h"
	#include "base/basictypes.h"
	#include "base/hash_tables.h"
	#include "base/string16.h"

	namespace base {

	class BASE_EXPORT StringPiece {
	public:
	// standard STL container boilerplate
	typedef size_t size_type;
	typedef char value_type;
	typedef const char* pointer;
	typedef const char& reference;
	typedef const char& const_reference;
	typedef ptrdiff_t difference_type;
	typedef const char* const_iterator;
	typedef const char* iterator;
	typedef std::reverse_iterator<const_iterator> const_reverse_iterator;
	typedef std::reverse_iterator<iterator> reverse_iterator;

	static const size_type npos;

	public:
	// We provide non-explicit singleton constructors so users can pass
	// in a "const char*" or a "string" wherever a "StringPiece" is
	// expected.
	StringPiece() : ptr_(NULL), length_(0) { }
	StringPiece(const char* str)
	: ptr_(str), length_((str == NULL) ? 0 : strlen(str)) { }
	StringPiece(const std::string& str)
	: ptr_(str.data()), length_(str.size()) { }
	StringPiece(const char* 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 char* data() const { return ptr_; }
	size_type size() const { return length_; }
	size_type length() const { return length_; }
	bool empty() const { return length_ == 0; }

	void clear() {
	ptr_ = NULL;
	length_ = 0;
	}
	void set(const char* data, size_type len) {
	ptr_ = data;
	length_ = len;
	}
	void set(const char* str) {
	ptr_ = str;
	length_ = str ? strlen(str) : 0;
	}
	void set(const void* data, size_type len) {
	ptr_ = reinterpret_cast<const char*>(data);
	length_ = len;
	}

	char operator[](size_type i) const { return ptr_[i]; }

	void remove_prefix(size_type n) {
	ptr_ += n;
	length_ -= n;
	}

	void remove_suffix(size_type n) {
	length_ -= n;
	}

	int compare(const StringPiece& x) const {
	int r = wordmemcmp(
	ptr_, x.ptr_, (length_ < x.length_ ? length_ : x.length_));
	if (r == 0) {
	if (length_ < x.length_) r = -1;
	else if (length_ > x.length_) r = +1;
	}
	return r;
	}

	std::string as_string() const {
	// std::string doesn't like to take a NULL pointer even with a 0 size.
	return std::string(!empty() ? data() : "", size());
	}

	void CopyToString(std::string* target) const;
	void AppendToString(std::string* target) const;

	// Does "this" start with "x"
	bool starts_with(const StringPiece& x) const {
	return ((length_ >= x.length_) &&
	(wordmemcmp(ptr_, x.ptr_, x.length_) == 0));
	}

	// Does "this" end with "x"
	bool ends_with(const StringPiece& x) const {
	return ((length_ >= x.length_) &&
	(wordmemcmp(ptr_ + (length_-x.length_), x.ptr_, x.length_) == 0));
	}

	iterator begin() const { return ptr_; }
	iterator end() const { return ptr_ + length_; }
	const_reverse_iterator rbegin() const {
	return const_reverse_iterator(ptr_ + length_);
	}
	const_reverse_iterator rend() const {
	return const_reverse_iterator(ptr_);
	}

	size_type max_size() const { return length_; }
	size_type capacity() const { return length_; }

	size_type copy(char* buf, size_type n, size_type pos = 0) const;

	size_type find(const StringPiece& s, size_type pos = 0) const;
	size_type find(char c, size_type pos = 0) const;
	size_type rfind(const StringPiece& s, size_type pos = npos) const;
	size_type rfind(char c, size_type pos = npos) const;

	size_type find_first_of(const StringPiece& s, size_type pos = 0) const;
	size_type find_first_of(char c, size_type pos = 0) const {
	return find(c, pos);
	}
	size_type find_first_not_of(const StringPiece& s, size_type pos = 0) const;
	size_type find_first_not_of(char c, size_type pos = 0) const;
	size_type find_last_of(const StringPiece& s, size_type pos = npos) const;
	size_type find_last_of(char c, size_type pos = npos) const {
	return rfind(c, pos);
	}
	size_type find_last_not_of(const StringPiece& s, size_type pos = npos) const;
	size_type find_last_not_of(char c, size_type pos = npos) const;

	StringPiece substr(size_type pos, size_type n = npos) const;

	static int wordmemcmp(const char* p, const char* p2, size_type N) {
	return memcmp(p, p2, N);
	}

	private:
	const char* ptr_;
	size_type length_;
	};

	class BASE_EXPORT StringPiece16 {
	public:
	// standard STL container boilerplate
	typedef size_t size_type;
	typedef char16 value_type;
	typedef const char16* pointer;
	typedef const char16& reference;
	typedef const char16& const_reference;
	typedef ptrdiff_t difference_type;
	typedef const char16* const_iterator;
	typedef const char16* iterator;
	typedef std::reverse_iterator<const_iterator> const_reverse_iterator;
	typedef std::reverse_iterator<iterator> reverse_iterator;

	public:
	// We provide non-explicit singleton constructors so users can pass
	// in a "const char16*" or a "string16" wherever a "StringPiece16" is
	// expected.
	StringPiece16() : ptr_(NULL), length_(0) { }
	StringPiece16(const char16* str)
	: ptr_(str),
	length_((str == NULL) ? 0 : string16::traits_type::length(str)) { }
	StringPiece16(const string16& str)
	: ptr_(str.data()), length_(str.size()) { }
	StringPiece16(const char16* 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 char16* data() const { return ptr_; }
	size_type size() const { return length_; }
	size_type length() const { return length_; }
	bool empty() const { return length_ == 0; }

	void clear() {
	ptr_ = NULL;
	length_ = 0;
	}
	void set(const char16* data, size_type len) {
	ptr_ = data;
	length_ = len;
	}
	void set(const char16* str) {
	ptr_ = str;
	length_ = str ? string16::traits_type::length(str) : 0;
	}

	char16 operator[](size_type i) const { return ptr_[i]; }

	string16 as_string16() const {
	// StringPiece claims that this is bad when data() is NULL, but unittesting
	// seems to say otherwise.
	return string16(data(), size());
	}

	iterator begin() const { return ptr_; }
	iterator end() const { return ptr_ + length_; }
	const_reverse_iterator rbegin() const {
	return const_reverse_iterator(ptr_ + length_);
	}
	const_reverse_iterator rend() const {
	return const_reverse_iterator(ptr_);
	}

	size_type max_size() const { return length_; }
	size_type capacity() const { return length_; }

	static int wordmemcmp(const char16* p, const char16* p2, size_type N) {
	return string16::traits_type::compare(p, p2, N);
	}

	private:
	const char16* ptr_;
	size_type length_;
	};

	BASE_EXPORT bool operator==(const StringPiece& x, const StringPiece& y);

	inline bool operator!=(const StringPiece& x, const StringPiece& y) {
	return !(x == y);
	}

	inline bool operator<(const StringPiece& x, const StringPiece& y) {
	const int r = StringPiece::wordmemcmp(
	x.data(), y.data(), (x.size() < y.size() ? x.size() : y.size()));
	return ((r < 0) \|\| ((r == 0) && (x.size() < y.size())));
	}

	inline bool operator>(const StringPiece& x, const StringPiece& y) {
	return y < x;
	}

	inline bool operator<=(const StringPiece& x, const StringPiece& y) {
	return !(x > y);
	}

	inline bool operator>=(const StringPiece& x, const StringPiece& y) {
	return !(x < y);
	}

	inline bool operator==(const StringPiece16& x, const StringPiece16& y) {
	if (x.size() != y.size())
	return false;

	return StringPiece16::wordmemcmp(x.data(), y.data(), x.size()) == 0;
	}

	inline bool operator!=(const StringPiece16& x, const StringPiece16& y) {
	return !(x == y);
	}

	inline bool operator<(const StringPiece16& x, const StringPiece16& y) {
	const int r = StringPiece16::wordmemcmp(
	x.data(), y.data(), (x.size() < y.size() ? x.size() : y.size()));
	return ((r < 0) \|\| ((r == 0) && (x.size() < y.size())));
	}

	inline bool operator>(const StringPiece16& x, const StringPiece16& y) {
	return y < x;
	}

	inline bool operator<=(const StringPiece16& x, const StringPiece16& y) {
	return !(x > y);
	}

	inline bool operator>=(const StringPiece16& x, const StringPiece16& y) {
	return !(x < y);
	}

	} // namespace base

	// We provide appropriate hash functions so StringPiece and StringPiece16 can
	// be used as keys in hash sets and maps.

	// This hash function is copied from base/hash_tables.h. We don't use the
	// ones already defined for string and string16 directly because it would
	// require the string constructors to be called, which we don't want.
	#define HASH_STRING_PIECE(StringPieceType, string_piece) \
	std::size_t result = 0; \
	for (StringPieceType::const_iterator i = string_piece.begin(); \
	i != string_piece.end(); ++i) \
	result = (result * 131) + *i; \
	return result; \

	namespace BASE_HASH_NAMESPACE {
	#if defined(COMPILER_GCC)

	template<>
	struct hash<base::StringPiece> {
	std::size_t operator()(const base::StringPiece& sp) const {
	HASH_STRING_PIECE(base::StringPiece, sp);
	}
	};
	template<>
	struct hash<base::StringPiece16> {
	std::size_t operator()(const base::StringPiece16& sp16) const {
	HASH_STRING_PIECE(base::StringPiece16, sp16);
	}
	};

	#elif defined(COMPILER_MSVC)

	inline size_t hash_value(const base::StringPiece& sp) {
	HASH_STRING_PIECE(base::StringPiece, sp);
	}
	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_