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
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
|
/*
* Copyright (C) 2015 The Android Open Source Project
*
* 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 AAPT_STRING_POOL_H
#define AAPT_STRING_POOL_H
#include "BigBuffer.h"
#include "ConfigDescription.h"
#include "StringPiece.h"
#include <functional>
#include <map>
#include <memory>
#include <string>
#include <vector>
namespace aapt {
struct Span {
std::u16string name;
uint32_t firstChar;
uint32_t lastChar;
};
struct StyleString {
std::u16string str;
std::vector<Span> spans;
};
class StringPool {
public:
struct Context {
uint32_t priority;
ConfigDescription config;
};
class Entry;
class Ref {
public:
Ref();
Ref(const Ref&);
~Ref();
Ref& operator=(const Ref& rhs);
const std::u16string* operator->() const;
const std::u16string& operator*() const;
size_t getIndex() const;
const Context& getContext() const;
private:
friend class StringPool;
Ref(Entry* entry);
Entry* mEntry;
};
class StyleEntry;
class StyleRef {
public:
StyleRef();
StyleRef(const StyleRef&);
~StyleRef();
StyleRef& operator=(const StyleRef& rhs);
const StyleEntry* operator->() const;
const StyleEntry& operator*() const;
size_t getIndex() const;
const Context& getContext() const;
private:
friend class StringPool;
StyleRef(StyleEntry* entry);
StyleEntry* mEntry;
};
class Entry {
public:
std::u16string value;
Context context;
size_t index;
private:
friend class StringPool;
friend class Ref;
int ref;
};
struct Span {
Ref name;
uint32_t firstChar;
uint32_t lastChar;
};
class StyleEntry {
public:
Ref str;
std::vector<Span> spans;
private:
friend class StringPool;
friend class StyleRef;
int ref;
};
using const_iterator = std::vector<std::unique_ptr<Entry>>::const_iterator;
static bool flattenUtf8(BigBuffer* out, const StringPool& pool);
static bool flattenUtf16(BigBuffer* out, const StringPool& pool);
StringPool() = default;
StringPool(const StringPool&) = delete;
/**
* Adds a string to the pool, unless it already exists. Returns
* a reference to the string in the pool.
*/
Ref makeRef(const StringPiece16& str);
/**
* Adds a string to the pool, unless it already exists, with a context
* object that can be used when sorting the string pool. Returns
* a reference to the string in the pool.
*/
Ref makeRef(const StringPiece16& str, const Context& context);
/**
* Adds a style to the string pool and returns a reference to it.
*/
StyleRef makeRef(const StyleString& str);
/**
* Adds a style to the string pool with a context object that
* can be used when sorting the string pool. Returns a reference
* to the style in the string pool.
*/
StyleRef makeRef(const StyleString& str, const Context& context);
/**
* Adds a style from another string pool. Returns a reference to the
* style in the string pool.
*/
StyleRef makeRef(const StyleRef& ref);
/**
* Moves pool into this one without coalescing strings. When this
* function returns, pool will be empty.
*/
void merge(StringPool&& pool);
/**
* Retuns the number of strings in the table.
*/
inline size_t size() const;
/**
* Reserves space for strings and styles as an optimization.
*/
void hintWillAdd(size_t stringCount, size_t styleCount);
/**
* Sorts the strings according to some comparison function.
*/
void sort(const std::function<bool(const Entry&, const Entry&)>& cmp);
/**
* Removes any strings that have no references.
*/
void prune();
private:
friend const_iterator begin(const StringPool& pool);
friend const_iterator end(const StringPool& pool);
static bool flatten(BigBuffer* out, const StringPool& pool, bool utf8);
Ref makeRefImpl(const StringPiece16& str, const Context& context, bool unique);
std::vector<std::unique_ptr<Entry>> mStrings;
std::vector<std::unique_ptr<StyleEntry>> mStyles;
std::multimap<StringPiece16, Entry*> mIndexedStrings;
};
//
// Inline implementation
//
inline size_t StringPool::size() const {
return mStrings.size();
}
inline StringPool::const_iterator begin(const StringPool& pool) {
return pool.mStrings.begin();
}
inline StringPool::const_iterator end(const StringPool& pool) {
return pool.mStrings.end();
}
} // namespace aapt
#endif // AAPT_STRING_POOL_H
|
