1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
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_
|
