diff options
Diffstat (limited to 'third_party/wasm2c/src/string-view.h')
| -rw-r--r-- | third_party/wasm2c/src/string-view.h | 347 |
1 files changed, 347 insertions, 0 deletions
diff --git a/third_party/wasm2c/src/string-view.h b/third_party/wasm2c/src/string-view.h new file mode 100644 index 0000000000..534e675c73 --- /dev/null +++ b/third_party/wasm2c/src/string-view.h @@ -0,0 +1,347 @@ +/* + * Copyright 2017 WebAssembly Community Group participants + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef WABT_STRING_VIEW_H_ +#define WABT_STRING_VIEW_H_ + +#include <cassert> +#include <functional> +#include <iterator> +#include <ostream> +#include <string> + +#include "src/hash-util.h" + +namespace wabt { + +// This is a simplified implemention of C++17's basic_string_view template. +// +// Missing features: +// * Not a template +// * No allocator support +// * Some functions are not implemented +// * Asserts instead of exceptions +// * Some functions are not constexpr because we don't compile in C++17 mode + +class string_view { + public: + typedef std::char_traits<char> traits_type; + typedef char value_type; + typedef char* pointer; + typedef const char* const_pointer; + typedef char& reference; + typedef const char& const_reference; + typedef const char* const_iterator; + typedef const_iterator iterator; + typedef std::reverse_iterator<const_iterator> const_reverse_iterator; + typedef const_reverse_iterator reverse_iterator; + typedef std::size_t size_type; + typedef std::ptrdiff_t difference_type; + static const size_type npos = size_type(-1); + + // construction and assignment + constexpr string_view() noexcept; + constexpr string_view(const string_view&) noexcept = default; + string_view& operator=(const string_view&) noexcept = default; + string_view(const std::string& str) noexcept; + /*constexpr*/ string_view(const char* str); + constexpr string_view(const char* str, size_type len); + + // iterator support + constexpr const_iterator begin() const noexcept; + constexpr const_iterator end() const noexcept; + constexpr const_iterator cbegin() const noexcept; + constexpr const_iterator cend() const noexcept; + const_reverse_iterator rbegin() const noexcept; + const_reverse_iterator rend() const noexcept; + const_reverse_iterator crbegin() const noexcept; + const_reverse_iterator crend() const noexcept; + + // capacity + constexpr size_type size() const noexcept; + constexpr size_type length() const noexcept; + constexpr size_type max_size() const noexcept; + constexpr bool empty() const noexcept; + + // element access + constexpr const_reference operator[](size_type pos) const; + /*constexpr*/ const_reference at(size_type pos) const; + /*constexpr*/ const_reference front() const; + /*constexpr*/ const_reference back() const; + constexpr const_pointer data() const noexcept; + + // modifiers + /*constexpr*/ void remove_prefix(size_type n); + /*constexpr*/ void remove_suffix(size_type n); + /*constexpr*/ void swap(string_view& s) noexcept; + + // string operations + explicit operator std::string() const; + std::string to_string() const; + size_type copy(char* s, size_type n, size_type pos = 0) const; + /*constexpr*/ string_view substr(size_type pos = 0, size_type n = npos) const; + /*constexpr*/ int compare(string_view s) const noexcept; + /*constexpr*/ int compare(size_type pos1, size_type n1, string_view s) const; + /*constexpr*/ int compare(size_type pos1, + size_type n1, + string_view s, + size_type pos2, + size_type n2) const; + /*constexpr*/ int compare(const char* s) const; + /*constexpr*/ int compare(size_type pos1, size_type n1, const char* s) const; + /*constexpr*/ int compare(size_type pos1, + size_type n1, + const char* s, + size_type n2) const; + /*constexpr*/ size_type find(string_view s, size_type pos = 0) const noexcept; + /*constexpr*/ size_type find(char c, size_type pos = 0) const noexcept; + /*constexpr*/ size_type find(const char* s, size_type pos, size_type n) const; + /*constexpr*/ size_type find(const char* s, size_type pos = 0) const; + /*constexpr*/ size_type rfind(string_view s, size_type pos = npos) const + noexcept; + /*constexpr*/ size_type rfind(char c, size_type pos = npos) const noexcept; + /*constexpr*/ size_type rfind(const char* s, + size_type pos, + size_type n) const; + /*constexpr*/ size_type rfind(const char* s, size_type pos = npos) const; + /*constexpr*/ size_type find_first_of(string_view s, size_type pos = 0) const + noexcept; + /*constexpr*/ size_type find_first_of(char c, size_type pos = 0) const + noexcept; + /*constexpr*/ size_type find_first_of(const char* s, + size_type pos, + size_type n) const; + /*constexpr*/ size_type find_first_of(const char* s, size_type pos = 0) const; + /*constexpr*/ size_type find_last_of(string_view s, + size_type pos = npos) const noexcept; + /*constexpr*/ size_type find_last_of(char c, size_type pos = npos) const + noexcept; + /*constexpr*/ size_type find_last_of(const char* s, + size_type pos, + size_type n) const; + /*constexpr*/ size_type find_last_of(const char* s, + size_type pos = npos) const; + +// TODO(binji): These are defined by C++17 basic_string_view but not +// implemented here. +#if 0 + constexpr size_type find_first_not_of(string_view s, size_type pos = 0) const + noexcept; + constexpr size_type find_first_not_of(char c, size_type pos = 0) const + noexcept; + constexpr size_type find_first_not_of(const char* s, + size_type pos, + size_type n) const; + constexpr size_type find_first_not_of(const char* s, size_type pos = 0) const; + constexpr size_type find_last_not_of(string_view s, + size_type pos = npos) const noexcept; + constexpr size_type find_last_not_of(char c, size_type pos = npos) const + noexcept; + constexpr size_type find_last_not_of(const char* s, + size_type pos, + size_type n) const; + constexpr size_type find_last_not_of(const char* s, + size_type pos = npos) const; +#endif + + private: + const char* data_; + size_type size_; +}; + +// non-member comparison functions +inline bool operator==(string_view x, string_view y) noexcept { + return x.compare(y) == 0; +} + +inline bool operator!=(string_view x, string_view y) noexcept { + return x.compare(y) != 0; +} + +inline bool operator<(string_view x, string_view y) noexcept { + return x.compare(y) < 0; +} + +inline bool operator>(string_view x, string_view y) noexcept { + return x.compare(y) > 0; +} + +inline bool operator<=(string_view x, string_view y) noexcept { + return x.compare(y) <= 0; +} + +inline bool operator>=(string_view x, string_view y) noexcept { + return x.compare(y) >= 0; +} + +// non-member append. +inline std::string& operator+=(std::string& x, string_view y) { + x.append(y.data(), y.size()); + return x; +} + +inline std::string operator+(string_view x, string_view y) { + std::string s; + s.reserve(x.size() + y.size()); + s.append(x.data(), x.size()); + s.append(y.data(), y.size()); + return s; +} + +inline std::string operator+(const std::string& x, string_view y) { + return string_view(x) + y; +} + +inline std::string operator+(string_view x, const std::string& y) { + return x + string_view(y); +} + +inline std::string operator+(const char* x, string_view y) { + return string_view(x) + y; +} + +inline std::string operator+(string_view x, const char* y) { + return x + string_view(y); +} + +inline void cat_concatenate(std::string&) {} + +template<typename T, typename ...Ts> +void cat_concatenate(std::string& s, const T& t, const Ts&... args) { + s += t; + cat_concatenate(s, args...); +} + +inline size_t cat_compute_size() { return 0; } + +template<typename T, typename ...Ts> +size_t cat_compute_size(const T& t, const Ts&... args) { + return string_view(t).size() + cat_compute_size(args...); +} + +// Is able to concatenate any combination of string/string_view/char* +template<typename ...Ts> std::string cat(const Ts&... args) { + std::string s; + s.reserve(cat_compute_size(args...)); + cat_concatenate(s, args...); + return s; +} + +inline constexpr string_view::string_view() noexcept + : data_(nullptr), size_(0) {} + +inline string_view::string_view(const std::string& str) noexcept + : data_(str.data()), size_(str.size()) {} + +inline string_view::string_view(const char* str) + : data_(str), size_(traits_type::length(str)) {} + +inline constexpr string_view::string_view(const char* str, size_type len) + : data_(str), size_(len) {} + +inline constexpr string_view::const_iterator string_view::begin() const + noexcept { + return data_; +} + +inline constexpr string_view::const_iterator string_view::end() const noexcept { + return data_ + size_; +} + +inline constexpr string_view::const_iterator string_view::cbegin() const + noexcept { + return data_; +} + +inline constexpr string_view::const_iterator string_view::cend() const + noexcept { + return data_ + size_; +} + +inline string_view::const_reverse_iterator string_view::rbegin() const + noexcept { + return const_reverse_iterator(end()); +} + +inline string_view::const_reverse_iterator string_view::rend() const noexcept { + return const_reverse_iterator(begin()); +} + +inline string_view::const_reverse_iterator string_view::crbegin() const + noexcept { + return const_reverse_iterator(cend()); +} + +inline string_view::const_reverse_iterator string_view::crend() const noexcept { + return const_reverse_iterator(cbegin()); +} + +constexpr inline string_view::size_type string_view::size() const noexcept { + return size_; +} + +constexpr inline string_view::size_type string_view::length() const noexcept { + return size_; +} + +constexpr inline bool string_view::empty() const noexcept { + return size_ == 0; +} + +constexpr inline string_view::const_reference string_view::operator[]( + size_type pos) const { + return data_[pos]; +} + +inline string_view::const_reference string_view::at(size_type pos) const { + assert(pos < size_); + return data_[pos]; +} + +inline string_view::const_reference string_view::front() const { + assert(!empty()); + return *data_; +} + +inline string_view::const_reference string_view::back() const { + assert(!empty()); + return data_[size_ - 1]; +} + +constexpr inline string_view::const_pointer string_view::data() const noexcept { + return data_; +} + +inline std::ostream& operator<<(std::ostream& os, string_view sv) { + os.write(sv.data(), sv.size()); + return os; +} + +} // namespace wabt + +namespace std { + +// hash support +template <> +struct hash<::wabt::string_view> { + ::wabt::hash_code operator()(const ::wabt::string_view& sv) { + return ::wabt::HashRange(sv.begin(), sv.end()); + } +}; + +} // namespace std + +#endif // WABT_STRING_VIEW_H_ |