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_IMPL_CODEGEN_STRING_REF_H 20 #define GRPCPP_IMPL_CODEGEN_STRING_REF_H 21 22 #include <string.h> 23 24 #include <algorithm> 25 #include <iosfwd> 26 #include <iostream> 27 #include <iterator> 28 29 #include <grpcpp/impl/codegen/config.h> 30 31 namespace grpc { 32 33 /// This class is a non owning reference to a string. 34 /// 35 /// It should be a strict subset of the upcoming std::string_ref. 36 /// 37 /// \see http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2012/n3442.html 38 /// 39 /// The constexpr is dropped or replaced with const for legacy compiler 40 /// compatibility. 41 class string_ref { 42 public: 43 /// types 44 typedef const char* const_iterator; 45 typedef std::reverse_iterator<const_iterator> const_reverse_iterator; 46 47 /// constants 48 const static size_t npos; 49 50 /// construct/copy. string_ref()51 string_ref() : data_(nullptr), length_(0) {} string_ref(const string_ref & other)52 string_ref(const string_ref& other) 53 : data_(other.data_), length_(other.length_) {} 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_IMPL_CODEGEN_STRING_REF_H 149