1 // 2 // 3 // Copyright 2015 gRPC authors. 4 // 5 // Licensed under the Apache License, Version 2.0 (the "License"); 6 // you may not use this file except in compliance with the License. 7 // You may obtain a copy of the License at 8 // 9 // http://www.apache.org/licenses/LICENSE-2.0 10 // 11 // Unless required by applicable law or agreed to in writing, software 12 // distributed under the License is distributed on an "AS IS" BASIS, 13 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 14 // See the License for the specific language governing permissions and 15 // limitations under the License. 16 // 17 // 18 19 #ifndef GRPCPP_SUPPORT_STRING_REF_H 20 #define GRPCPP_SUPPORT_STRING_REF_H 21 22 #include <grpcpp/support/config.h> 23 #include <string.h> 24 25 #include <algorithm> 26 #include <iosfwd> 27 #include <iostream> 28 #include <iterator> 29 30 namespace grpc { 31 32 /// This class is a non owning reference to a string. 33 /// 34 /// It should be a strict subset of the upcoming std::string_ref. 35 /// 36 /// \see http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2012/n3442.html 37 /// 38 /// The constexpr is dropped or replaced with const for legacy compiler 39 /// compatibility. 40 class string_ref { 41 public: 42 /// types 43 typedef const char* const_iterator; 44 typedef std::reverse_iterator<const_iterator> const_reverse_iterator; 45 46 /// constants 47 const static size_t npos; 48 49 /// construct/copy. string_ref()50 string_ref() : data_(nullptr), length_(0) {} string_ref(const string_ref & other)51 string_ref(const string_ref& other) 52 : data_(other.data_), length_(other.length_) {} 53 // NOLINTNEXTLINE(bugprone-unhandled-self-assignment) 54 string_ref& operator=(const string_ref& rhs) { 55 data_ = rhs.data_; 56 length_ = rhs.length_; 57 return *this; 58 } 59 60 // NOLINTNEXTLINE(google-explicit-constructor) string_ref(const char * s)61 string_ref(const char* s) : data_(s), length_(strlen(s)) {} string_ref(const char * s,size_t l)62 string_ref(const char* s, size_t l) : data_(s), length_(l) {} 63 // NOLINTNEXTLINE(google-explicit-constructor) string_ref(const std::string & s)64 string_ref(const std::string& s) : data_(s.data()), length_(s.length()) {} 65 66 /// iterators begin()67 const_iterator begin() const { return data_; } end()68 const_iterator end() const { return data_ + length_; } cbegin()69 const_iterator cbegin() const { return data_; } cend()70 const_iterator cend() const { return data_ + length_; } rbegin()71 const_reverse_iterator rbegin() const { 72 return const_reverse_iterator(end()); 73 } rend()74 const_reverse_iterator rend() const { 75 return const_reverse_iterator(begin()); 76 } crbegin()77 const_reverse_iterator crbegin() const { 78 return const_reverse_iterator(end()); 79 } crend()80 const_reverse_iterator crend() const { 81 return const_reverse_iterator(begin()); 82 } 83 84 /// capacity size()85 size_t size() const { return length_; } length()86 size_t length() const { return length_; } max_size()87 size_t max_size() const { return length_; } empty()88 bool empty() const { return length_ == 0; } 89 90 /// element access data()91 const char* data() const { return data_; } 92 93 /// string operations compare(string_ref x)94 int compare(string_ref x) const { 95 size_t min_size = length_ < x.length_ ? length_ : x.length_; 96 int r = memcmp(data_, x.data_, min_size); 97 if (r < 0) return -1; 98 if (r > 0) return 1; 99 if (length_ < x.length_) return -1; 100 if (length_ > x.length_) return 1; 101 return 0; 102 } 103 starts_with(string_ref x)104 bool starts_with(string_ref x) const { 105 return length_ >= x.length_ && (memcmp(data_, x.data_, x.length_) == 0); 106 } 107 ends_with(string_ref x)108 bool ends_with(string_ref x) const { 109 return length_ >= x.length_ && 110 (memcmp(data_ + (length_ - x.length_), x.data_, x.length_) == 0); 111 } 112 find(string_ref s)113 size_t find(string_ref s) const { 114 auto it = std::search(cbegin(), cend(), s.cbegin(), s.cend()); 115 return it == cend() ? npos : std::distance(cbegin(), it); 116 } 117 find(char c)118 size_t find(char c) const { 119 auto it = std::find(cbegin(), cend(), c); 120 return it == cend() ? npos : std::distance(cbegin(), it); 121 } 122 123 string_ref substr(size_t pos, size_t n = npos) const { 124 if (pos > length_) pos = length_; 125 if (n > (length_ - pos)) n = length_ - pos; 126 return string_ref(data_ + pos, n); 127 } 128 129 private: 130 const char* data_; 131 size_t length_; 132 }; 133 134 /// Comparison operators 135 inline bool operator==(string_ref x, string_ref y) { return x.compare(y) == 0; } 136 inline bool operator!=(string_ref x, string_ref y) { return x.compare(y) != 0; } 137 inline bool operator<(string_ref x, string_ref y) { return x.compare(y) < 0; } 138 inline bool operator<=(string_ref x, string_ref y) { return x.compare(y) <= 0; } 139 inline bool operator>(string_ref x, string_ref y) { return x.compare(y) > 0; } 140 inline bool operator>=(string_ref x, string_ref y) { return x.compare(y) >= 0; } 141 142 inline std::ostream& operator<<(std::ostream& out, const string_ref& string) { 143 return out << std::string(string.begin(), string.end()); 144 } 145 146 } // namespace grpc 147 148 #endif // GRPCPP_SUPPORT_STRING_REF_H 149