diff options
author | Daniel Baumann <daniel.baumann@progress-linux.org> | 2024-04-19 00:47:55 +0000 |
---|---|---|
committer | Daniel Baumann <daniel.baumann@progress-linux.org> | 2024-04-19 00:47:55 +0000 |
commit | 26a029d407be480d791972afb5975cf62c9360a6 (patch) | |
tree | f435a8308119effd964b339f76abb83a57c29483 /gfx/angle/checkout/src/compiler/translator/ImmutableString.h | |
parent | Initial commit. (diff) | |
download | firefox-26a029d407be480d791972afb5975cf62c9360a6.tar.xz firefox-26a029d407be480d791972afb5975cf62c9360a6.zip |
Adding upstream version 124.0.1.upstream/124.0.1
Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>
Diffstat (limited to 'gfx/angle/checkout/src/compiler/translator/ImmutableString.h')
-rw-r--r-- | gfx/angle/checkout/src/compiler/translator/ImmutableString.h | 143 |
1 files changed, 143 insertions, 0 deletions
diff --git a/gfx/angle/checkout/src/compiler/translator/ImmutableString.h b/gfx/angle/checkout/src/compiler/translator/ImmutableString.h new file mode 100644 index 0000000000..f172708d7d --- /dev/null +++ b/gfx/angle/checkout/src/compiler/translator/ImmutableString.h @@ -0,0 +1,143 @@ +// +// Copyright 2018 The ANGLE Project Authors. All rights reserved. +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. +// +// ImmutableString.h: Wrapper for static or pool allocated char arrays, that are guaranteed to be +// valid and unchanged for the duration of the compilation. +// + +#ifndef COMPILER_TRANSLATOR_IMMUTABLESTRING_H_ +#define COMPILER_TRANSLATOR_IMMUTABLESTRING_H_ + +#include <string> + +#include "common/string_utils.h" +#include "compiler/translator/Common.h" + +namespace sh +{ + +namespace +{ +constexpr size_t constStrlen(const char *str) +{ + if (str == nullptr) + { + return 0u; + } + size_t len = 0u; + while (*(str + len) != '\0') + { + ++len; + } + return len; +} +} // namespace + +class ImmutableString +{ + public: + // The data pointer passed in must be one of: + // 1. nullptr (only valid with length 0). + // 2. a null-terminated static char array like a string literal. + // 3. a null-terminated pool allocated char array. This can't be c_str() of a local TString, + // since when a TString goes out of scope it clears its first character. + explicit constexpr ImmutableString(const char *data) : mData(data), mLength(constStrlen(data)) + {} + + constexpr ImmutableString(const char *data, size_t length) : mData(data), mLength(length) {} + + ImmutableString(const std::string &str) + : mData(AllocatePoolCharArray(str.c_str(), str.size())), mLength(str.size()) + {} + + constexpr ImmutableString(const ImmutableString &) = default; + + ImmutableString &operator=(const ImmutableString &) = default; + + constexpr const char *data() const { return mData ? mData : ""; } + constexpr size_t length() const { return mLength; } + + char operator[](size_t index) const { return data()[index]; } + + constexpr bool empty() const { return mLength == 0; } + bool beginsWith(const char *prefix) const { return angle::BeginsWith(data(), prefix); } + constexpr bool beginsWith(const ImmutableString &prefix) const + { + return mLength >= prefix.length() && memcmp(data(), prefix.data(), prefix.length()) == 0; + } + bool contains(const char *substr) const { return strstr(data(), substr) != nullptr; } + + constexpr bool operator==(const ImmutableString &b) const + { + if (mLength != b.mLength) + { + return false; + } + return memcmp(data(), b.data(), mLength) == 0; + } + constexpr bool operator!=(const ImmutableString &b) const { return !(*this == b); } + constexpr bool operator==(const char *b) const + { + if (b == nullptr) + { + return empty(); + } + return strcmp(data(), b) == 0; + } + constexpr bool operator!=(const char *b) const { return !(*this == b); } + bool operator==(const std::string &b) const + { + return mLength == b.length() && memcmp(data(), b.c_str(), mLength) == 0; + } + bool operator!=(const std::string &b) const { return !(*this == b); } + + constexpr bool operator<(const ImmutableString &b) const + { + if (mLength < b.mLength) + { + return true; + } + if (mLength > b.mLength) + { + return false; + } + return (memcmp(data(), b.data(), mLength) < 0); + } + + template <size_t hashBytes> + struct FowlerNollVoHash + { + static const size_t kFnvOffsetBasis; + static const size_t kFnvPrime; + + constexpr size_t operator()(const ImmutableString &a) const + { + const char *data = a.data(); + size_t hash = kFnvOffsetBasis; + while ((*data) != '\0') + { + hash = hash ^ (*data); + hash = hash * kFnvPrime; + ++data; + } + return hash; + } + }; + + // Perfect hash functions + uint32_t mangledNameHash() const; + uint32_t unmangledNameHash() const; + + private: + const char *mData; + size_t mLength; +}; + +constexpr ImmutableString kEmptyImmutableString(""); +} // namespace sh + +std::ostream &operator<<(std::ostream &os, const sh::ImmutableString &str); + +#endif // COMPILER_TRANSLATOR_IMMUTABLESTRING_H_ |