string_piece.h 18.2 KB
Newer Older
gejun's avatar
gejun committed
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21
// Copyright (c) 2012 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.
//
// You can use StringPiece as a function or method parameter.  A StringPiece
// parameter can receive a double-quoted string literal argument, a "const
// char*" argument, a string argument, or a StringPiece argument with no data
// copying.  Systematic use of StringPiece for arguments reduces data
// copies and strlen() calls.
//
// Prefer passing StringPieces by value:
//   void MyFunction(StringPiece arg);
// If circumstances require, you may also pass by const reference:
//   void MyFunction(const StringPiece& arg);  // not preferred
// Both of these have the same lifetime semantics.  Passing by value
// generates slightly smaller code.  For more discussion, Googlers can see
// the thread go/stringpiecebyvalue on c-users.
//
22
// StringPiece16 is similar to StringPiece but for butil::string16 instead of
gejun's avatar
gejun committed
23 24 25 26 27
// 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.
//

28 29
#ifndef BUTIL_STRINGS_STRING_PIECE_H_
#define BUTIL_STRINGS_STRING_PIECE_H_
gejun's avatar
gejun committed
30 31 32 33 34 35

#include <stddef.h>

#include <iosfwd>
#include <string>

36 37 38 39
#include "butil/base_export.h"
#include "butil/basictypes.h"
#include "butil/containers/hash_tables.h"
#include "butil/strings/string16.h"
gejun's avatar
gejun committed
40

41
namespace butil {
gejun's avatar
gejun committed
42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57

template <typename STRING_TYPE> class BasicStringPiece;
typedef BasicStringPiece<std::string> StringPiece;
typedef BasicStringPiece<string16> StringPiece16;

// internal --------------------------------------------------------------------

// Many of the StringPiece functions use different implementations for the
// 8-bit and 16-bit versions, and we don't want lots of template expansions in
// this (very common) header that will slow down compilation.
//
// So here we define overloaded functions called by the StringPiece template.
// For those that share an implementation, the two versions will expand to a
// template internal to the .cc file.
namespace internal {

58 59
BUTIL_EXPORT void CopyToString(const StringPiece& self, std::string* target);
BUTIL_EXPORT void CopyToString(const StringPiece16& self, string16* target);
gejun's avatar
gejun committed
60

61 62
BUTIL_EXPORT void AppendToString(const StringPiece& self, std::string* target);
BUTIL_EXPORT void AppendToString(const StringPiece16& self, string16* target);
gejun's avatar
gejun committed
63

64
BUTIL_EXPORT size_t copy(const StringPiece& self,
gejun's avatar
gejun committed
65 66 67
                        char* buf,
                        size_t n,
                        size_t pos);
68
BUTIL_EXPORT size_t copy(const StringPiece16& self,
gejun's avatar
gejun committed
69 70 71 72
                        char16* buf,
                        size_t n,
                        size_t pos);

73
BUTIL_EXPORT size_t find(const StringPiece& self,
gejun's avatar
gejun committed
74 75
                        const StringPiece& s,
                        size_t pos);
76
BUTIL_EXPORT size_t find(const StringPiece16& self,
gejun's avatar
gejun committed
77 78
                        const StringPiece16& s,
                        size_t pos);
79
BUTIL_EXPORT size_t find(const StringPiece& self,
gejun's avatar
gejun committed
80 81
                        char c,
                        size_t pos);
82
BUTIL_EXPORT size_t find(const StringPiece16& self,
gejun's avatar
gejun committed
83 84 85
                        char16 c,
                        size_t pos);

86
BUTIL_EXPORT size_t rfind(const StringPiece& self,
gejun's avatar
gejun committed
87 88
                         const StringPiece& s,
                         size_t pos);
89
BUTIL_EXPORT size_t rfind(const StringPiece16& self,
gejun's avatar
gejun committed
90 91
                         const StringPiece16& s,
                         size_t pos);
92
BUTIL_EXPORT size_t rfind(const StringPiece& self,
gejun's avatar
gejun committed
93 94
                         char c,
                         size_t pos);
95
BUTIL_EXPORT size_t rfind(const StringPiece16& self,
gejun's avatar
gejun committed
96 97 98
                         char16 c,
                         size_t pos);

99
BUTIL_EXPORT size_t find_first_of(const StringPiece& self,
gejun's avatar
gejun committed
100 101
                                 const StringPiece& s,
                                 size_t pos);
102
BUTIL_EXPORT size_t find_first_of(const StringPiece16& self,
gejun's avatar
gejun committed
103 104 105
                                 const StringPiece16& s,
                                 size_t pos);

106
BUTIL_EXPORT size_t find_first_not_of(const StringPiece& self,
gejun's avatar
gejun committed
107 108
                                     const StringPiece& s,
                                     size_t pos);
109
BUTIL_EXPORT size_t find_first_not_of(const StringPiece16& self,
gejun's avatar
gejun committed
110 111
                                     const StringPiece16& s,
                                     size_t pos);
112
BUTIL_EXPORT size_t find_first_not_of(const StringPiece& self,
gejun's avatar
gejun committed
113 114
                                     char c,
                                     size_t pos);
115
BUTIL_EXPORT size_t find_first_not_of(const StringPiece16& self,
gejun's avatar
gejun committed
116 117 118
                                     char16 c,
                                     size_t pos);

119
BUTIL_EXPORT size_t find_last_of(const StringPiece& self,
gejun's avatar
gejun committed
120 121
                                const StringPiece& s,
                                size_t pos);
122
BUTIL_EXPORT size_t find_last_of(const StringPiece16& self,
gejun's avatar
gejun committed
123 124
                                const StringPiece16& s,
                                size_t pos);
125
BUTIL_EXPORT size_t find_last_of(const StringPiece& self,
gejun's avatar
gejun committed
126 127
                                char c,
                                size_t pos);
128
BUTIL_EXPORT size_t find_last_of(const StringPiece16& self,
gejun's avatar
gejun committed
129 130 131
                                char16 c,
                                size_t pos);

132
BUTIL_EXPORT size_t find_last_not_of(const StringPiece& self,
gejun's avatar
gejun committed
133 134
                                    const StringPiece& s,
                                    size_t pos);
135
BUTIL_EXPORT size_t find_last_not_of(const StringPiece16& self,
gejun's avatar
gejun committed
136 137
                                    const StringPiece16& s,
                                    size_t pos);
138
BUTIL_EXPORT size_t find_last_not_of(const StringPiece16& self,
gejun's avatar
gejun committed
139 140
                                    char16 c,
                                    size_t pos);
141
BUTIL_EXPORT size_t find_last_not_of(const StringPiece& self,
gejun's avatar
gejun committed
142 143 144
                                    char c,
                                    size_t pos);

145
BUTIL_EXPORT StringPiece substr(const StringPiece& self,
gejun's avatar
gejun committed
146 147
                               size_t pos,
                               size_t n);
148
BUTIL_EXPORT StringPiece16 substr(const StringPiece16& self,
gejun's avatar
gejun committed
149 150 151 152 153 154 155 156 157 158 159 160
                                 size_t pos,
                                 size_t n);

}  // namespace internal

// BasicStringPiece ------------------------------------------------------------

// Defines the types, methods, operators, and data members common to both
// StringPiece and StringPiece16. Do not refer to this class directly, but
// rather to BasicStringPiece, StringPiece, or StringPiece16.
//
// This is templatized by string class type rather than character type, so
161
// BasicStringPiece<std::string> or BasicStringPiece<butil::string16>.
gejun's avatar
gejun committed
162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347 348 349 350 351 352 353 354 355 356 357 358 359 360 361 362 363 364 365 366 367 368 369 370 371 372 373 374 375 376
template <typename STRING_TYPE> class BasicStringPiece {
 public:
  // Standard STL container boilerplate.
  typedef size_t size_type;
  typedef typename STRING_TYPE::value_type value_type;
  typedef const value_type* pointer;
  typedef const value_type& reference;
  typedef const value_type& const_reference;
  typedef ptrdiff_t difference_type;
  typedef const value_type* const_iterator;
  typedef std::reverse_iterator<const_iterator> const_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 (likewise for char16, string16, StringPiece16).
  BasicStringPiece() : ptr_(NULL), length_(0) {}
  BasicStringPiece(const value_type* str)
      : ptr_(str),
        length_((str == NULL) ? 0 : STRING_TYPE::traits_type::length(str)) {}
  BasicStringPiece(const STRING_TYPE& str)
      : ptr_(str.data()), length_(str.size()) {}
  BasicStringPiece(const value_type* offset, size_type len)
      : ptr_(offset), length_(len) {}
  BasicStringPiece(const typename STRING_TYPE::const_iterator& begin,
                    const typename STRING_TYPE::const_iterator& end)
      : ptr_((end > begin) ? &(*begin) : NULL),
        length_((end > begin) ? (size_type)(end - begin) : 0) {}

  // 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_; }
  size_type length() const { return length_; }
  bool empty() const { return length_ == 0; }

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

  value_type 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;
  }

  // Remove heading and trailing spaces.
  void trim_spaces() {
    size_t nsp = 0;
    for (; nsp < size() && isspace(ptr_[nsp]); ++nsp) {}
    remove_prefix(nsp);
    nsp = 0;
    for (; nsp < size() && isspace(ptr_[size()-1-nsp]); ++nsp) {}
    remove_suffix(nsp);
  }       

  int compare(const BasicStringPiece<STRING_TYPE>& 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;
  }

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

  // Return the first/last character, UNDEFINED when StringPiece is empty.
  char front() const { return *ptr_; }
  char back() const { return *(ptr_ + length_ - 1); }
  // Return the first/last character, 0 when StringPiece is empty.
  char front_or_0() const { return length_ ? *ptr_ : '\0'; }
  char back_or_0() const { return length_ ? *(ptr_ + length_ - 1) : '\0'; }

  const_iterator begin() const { return ptr_; }
  const_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 value_type* p,
                        const value_type* p2,
                        size_type N) {
    return STRING_TYPE::traits_type::compare(p, p2, N);
  }

  // Sets the value of the given string target type to be the current string.
  // This saves a temporary over doing |a = b.as_string()|
  void CopyToString(STRING_TYPE* target) const {
    internal::CopyToString(*this, target);
  }

  void AppendToString(STRING_TYPE* target) const {
    internal::AppendToString(*this, target);
  }

  size_type copy(value_type* buf, size_type n, size_type pos = 0) const {
    return internal::copy(*this, buf, n, pos);
  }

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

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

  // find: Search for a character or substring at a given offset.
  size_type find(const BasicStringPiece<STRING_TYPE>& s,
                 size_type pos = 0) const {
    return internal::find(*this, s, pos);
  }
  size_type find(value_type c, size_type pos = 0) const {
    return internal::find(*this, c, pos);
  }

  // rfind: Reverse find.
  size_type rfind(const BasicStringPiece& s,
                  size_type pos = BasicStringPiece::npos) const {
    return internal::rfind(*this, s, pos);
  }
  size_type rfind(value_type c, size_type pos = BasicStringPiece::npos) const {
    return internal::rfind(*this, c, pos);
  }

  // find_first_of: Find the first occurence of one of a set of characters.
  size_type find_first_of(const BasicStringPiece& s,
                          size_type pos = 0) const {
    return internal::find_first_of(*this, s, pos);
  }
  size_type find_first_of(value_type c, size_type pos = 0) const {
    return find(c, pos);
  }

  // find_first_not_of: Find the first occurence not of a set of characters.
  size_type find_first_not_of(const BasicStringPiece& s,
                              size_type pos = 0) const {
    return internal::find_first_not_of(*this, s, pos);
  }
  size_type find_first_not_of(value_type c, size_type pos = 0) const {
    return internal::find_first_not_of(*this, c, pos);
  }

  // find_last_of: Find the last occurence of one of a set of characters.
  size_type find_last_of(const BasicStringPiece& s,
                         size_type pos = BasicStringPiece::npos) const {
    return internal::find_last_of(*this, s, pos);
  }
  size_type find_last_of(value_type c,
                         size_type pos = BasicStringPiece::npos) const {
    return rfind(c, pos);
  }

  // find_last_not_of: Find the last occurence not of a set of characters.
  size_type find_last_not_of(const BasicStringPiece& s,
                             size_type pos = BasicStringPiece::npos) const {
    return internal::find_last_not_of(*this, s, pos);
  }
  size_type find_last_not_of(value_type c,
                             size_type pos = BasicStringPiece::npos) const {
    return internal::find_last_not_of(*this, c, pos);
  }

  // substr.
  BasicStringPiece substr(size_type pos,
                          size_type n = BasicStringPiece::npos) const {
    return internal::substr(*this, pos, n);
  }

 protected:
  const value_type* ptr_;
  size_type     length_;
};

template <typename STRING_TYPE>
const typename BasicStringPiece<STRING_TYPE>::size_type
BasicStringPiece<STRING_TYPE>::npos =
    typename BasicStringPiece<STRING_TYPE>::size_type(-1);

// MSVC doesn't like complex extern templates and DLLs.
#if !defined(COMPILER_MSVC)
377 378
extern template class BUTIL_EXPORT BasicStringPiece<std::string>;
extern template class BUTIL_EXPORT BasicStringPiece<string16>;
gejun's avatar
gejun committed
379 380 381 382
#endif

// StingPiece operators --------------------------------------------------------

383
BUTIL_EXPORT bool operator==(const StringPiece& x, const StringPiece& y);
gejun's avatar
gejun committed
384 385 386 387 388 389 390 391 392 393 394 395 396 397 398 399 400 401 402 403 404 405 406 407 408 409 410 411 412 413 414 415 416 417 418 419 420 421 422 423 424 425 426 427 428 429 430 431 432 433 434 435 436 437

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);
}

// StringPiece16 operators -----------------------------------------------------

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);
}

438
BUTIL_EXPORT std::ostream& operator<<(std::ostream& o,
gejun's avatar
gejun committed
439 440 441 442 443 444 445 446 447 448
                                     const StringPiece& piece);

// [ Ease getting first/last character of std::string before C++11 ]
// return the first/last character, UNDEFINED when the string is empty.
inline char front_char(const std::string& s) { return s[0]; }
inline char back_char(const std::string& s) { return s[s.size() - 1]; }
// return the first/last character, 0 when the string is empty.
inline char front_char_or_0(const std::string& s) { return s.empty() ? '\0' : s[0]; }
inline char back_char_or_0(const std::string& s) { return s.empty() ? '\0' : s[s.size() - 1]; }

449
}  // namespace butil
gejun's avatar
gejun committed
450 451 452 453 454 455

// Hashing ---------------------------------------------------------------------

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

456
// This hash function is copied from butil/containers/hash_tables.h. We don't
gejun's avatar
gejun committed
457 458 459 460 461 462 463 464 465
// 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;                                                        \

466
namespace BUTIL_HASH_NAMESPACE {
gejun's avatar
gejun committed
467 468 469
#if defined(COMPILER_GCC)

template<>
470 471 472
struct hash<butil::StringPiece> {
  std::size_t operator()(const butil::StringPiece& sp) const {
    HASH_STRING_PIECE(butil::StringPiece, sp);
gejun's avatar
gejun committed
473 474 475
  }
};
template<>
476 477 478
struct hash<butil::StringPiece16> {
  std::size_t operator()(const butil::StringPiece16& sp16) const {
    HASH_STRING_PIECE(butil::StringPiece16, sp16);
gejun's avatar
gejun committed
479 480 481 482 483
  }
};

#elif defined(COMPILER_MSVC)

484 485
inline size_t hash_value(const butil::StringPiece& sp) {
  HASH_STRING_PIECE(butil::StringPiece, sp);
gejun's avatar
gejun committed
486
}
487 488
inline size_t hash_value(const butil::StringPiece16& sp16) {
  HASH_STRING_PIECE(butil::StringPiece16, sp16);
gejun's avatar
gejun committed
489 490 491 492
}

#endif  // COMPILER

493
}  // namespace BUTIL_HASH_NAMESPACE
gejun's avatar
gejun committed
494

495
#endif  // BUTIL_STRINGS_STRING_PIECE_H_