2 * Copyright (C) 2015 The Android Open Source Project
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
8 * http://www.apache.org/licenses/LICENSE-2.0
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
17 #ifndef AAPT_RESOURCE_H
18 #define AAPT_RESOURCE_H
27 #include "androidfw/StringPiece.h"
28 #include "utils/JenkinsHash.h"
30 #include "ConfigDescription.h"
36 * The various types of resource types available. Corresponds
37 * to the 'type' in package:type/entry.
39 enum class ResourceType {
48 // Not really a type, but it shows up in some CTS tests and
49 // we need to continue respecting it.
71 android::StringPiece ToString(ResourceType type);
74 * Returns a pointer to a valid ResourceType, or nullptr if
75 * the string was invalid.
77 const ResourceType* ParseResourceType(const android::StringPiece& str);
80 * A resource's name. This can uniquely identify
81 * a resource in the ResourceTable.
85 ResourceType type = ResourceType::kRaw;
88 ResourceName() = default;
89 ResourceName(const android::StringPiece& p, ResourceType t, const android::StringPiece& e);
91 int compare(const ResourceName& other) const;
93 bool is_valid() const;
94 std::string ToString() const;
98 * Same as ResourceName, but uses StringPieces instead.
99 * Use this if you need to avoid copying and know that
100 * the lifetime of this object is shorter than that
101 * of the original string.
103 struct ResourceNameRef {
104 android::StringPiece package;
105 ResourceType type = ResourceType::kRaw;
106 android::StringPiece entry;
108 ResourceNameRef() = default;
109 ResourceNameRef(const ResourceNameRef&) = default;
110 ResourceNameRef(ResourceNameRef&&) = default;
111 ResourceNameRef(const ResourceName& rhs); // NOLINT(implicit)
112 ResourceNameRef(const android::StringPiece& p, ResourceType t, const android::StringPiece& e);
113 ResourceNameRef& operator=(const ResourceNameRef& rhs) = default;
114 ResourceNameRef& operator=(ResourceNameRef&& rhs) = default;
115 ResourceNameRef& operator=(const ResourceName& rhs);
117 ResourceName ToResourceName() const;
118 bool is_valid() const;
121 constexpr const uint8_t kAppPackageId = 0x7fu;
122 constexpr const uint8_t kFrameworkPackageId = 0x01u;
125 * A binary identifier representing a resource. Internally it
126 * is a 32bit integer split as follows:
130 * PP: 8 bit package identifier. 0x01 is reserved for system
131 * and 0x7f is reserved for the running app.
132 * TT: 8 bit type identifier. 0x00 is invalid.
133 * EEEE: 16 bit entry identifier.
139 ResourceId(const ResourceId& rhs);
140 ResourceId(uint32_t res_id); // NOLINT(implicit)
141 ResourceId(uint8_t p, uint8_t t, uint16_t e);
143 bool is_valid() const;
145 // Returns true if the ID is a valid ID or dynamic ID (package ID can be 0).
146 bool is_valid_dynamic() const;
148 uint8_t package_id() const;
149 uint8_t type_id() const;
150 uint16_t entry_id() const;
153 struct SourcedResourceName {
158 struct ResourceFile {
163 ConfigDescription config;
169 std::vector<SourcedResourceName> exported_symbols;
173 * Useful struct used as a key to represent a unique resource in associative
178 ConfigDescription config;
181 bool operator<(const ResourceKey& a, const ResourceKey& b);
184 * Useful struct used as a key to represent a unique resource in associative
186 * Holds a reference to the name, so that name better live longer than this key!
188 struct ResourceKeyRef {
189 ResourceNameRef name;
190 ConfigDescription config;
192 ResourceKeyRef() = default;
193 ResourceKeyRef(const ResourceNameRef& n, const ConfigDescription& c)
194 : name(n), config(c) {}
197 * Prevent taking a reference to a temporary. This is bad.
199 ResourceKeyRef(ResourceName&& n, const ConfigDescription& c) = delete;
202 bool operator<(const ResourceKeyRef& a, const ResourceKeyRef& b);
205 // ResourceId implementation.
208 inline ResourceId::ResourceId() : id(0) {}
210 inline ResourceId::ResourceId(const ResourceId& rhs) : id(rhs.id) {}
212 inline ResourceId::ResourceId(uint32_t res_id) : id(res_id) {}
214 inline ResourceId::ResourceId(uint8_t p, uint8_t t, uint16_t e)
215 : id((p << 24) | (t << 16) | e) {}
217 inline bool ResourceId::is_valid() const {
218 return (id & 0xff000000u) != 0 && (id & 0x00ff0000u) != 0;
221 inline bool ResourceId::is_valid_dynamic() const { return (id & 0x00ff0000u) != 0; }
223 inline uint8_t ResourceId::package_id() const {
224 return static_cast<uint8_t>(id >> 24);
227 inline uint8_t ResourceId::type_id() const {
228 return static_cast<uint8_t>(id >> 16);
231 inline uint16_t ResourceId::entry_id() const {
232 return static_cast<uint16_t>(id);
235 inline bool operator<(const ResourceId& lhs, const ResourceId& rhs) {
236 return lhs.id < rhs.id;
239 inline bool operator>(const ResourceId& lhs, const ResourceId& rhs) {
240 return lhs.id > rhs.id;
243 inline bool operator==(const ResourceId& lhs, const ResourceId& rhs) {
244 return lhs.id == rhs.id;
247 inline bool operator!=(const ResourceId& lhs, const ResourceId& rhs) {
248 return lhs.id != rhs.id;
251 inline ::std::ostream& operator<<(::std::ostream& out,
252 const ResourceId& res_id) {
253 std::ios_base::fmtflags old_flags = out.flags();
254 char old_fill = out.fill();
255 out << "0x" << std::internal << std::setfill('0') << std::setw(8) << std::hex
257 out.flags(old_flags);
263 // ResourceType implementation.
266 inline ::std::ostream& operator<<(::std::ostream& out,
267 const ResourceType& val) {
268 return out << ToString(val);
272 // ResourceName implementation.
275 inline ResourceName::ResourceName(const android::StringPiece& p, ResourceType t,
276 const android::StringPiece& e)
277 : package(p.to_string()), type(t), entry(e.to_string()) {}
279 inline int ResourceName::compare(const ResourceName& other) const {
280 int cmp = package.compare(other.package);
281 if (cmp != 0) return cmp;
282 cmp = static_cast<int>(type) - static_cast<int>(other.type);
283 if (cmp != 0) return cmp;
284 cmp = entry.compare(other.entry);
288 inline bool ResourceName::is_valid() const {
289 return !package.empty() && !entry.empty();
292 inline bool operator<(const ResourceName& lhs, const ResourceName& rhs) {
293 return std::tie(lhs.package, lhs.type, lhs.entry) <
294 std::tie(rhs.package, rhs.type, rhs.entry);
297 inline bool operator==(const ResourceName& lhs, const ResourceName& rhs) {
298 return std::tie(lhs.package, lhs.type, lhs.entry) ==
299 std::tie(rhs.package, rhs.type, rhs.entry);
302 inline bool operator!=(const ResourceName& lhs, const ResourceName& rhs) {
303 return std::tie(lhs.package, lhs.type, lhs.entry) !=
304 std::tie(rhs.package, rhs.type, rhs.entry);
307 inline ::std::ostream& operator<<(::std::ostream& out,
308 const ResourceName& name) {
309 if (!name.package.empty()) {
310 out << name.package << ":";
312 return out << name.type << "/" << name.entry;
315 inline std::string ResourceName::ToString() const {
316 std::stringstream stream;
322 // ResourceNameRef implementation.
325 inline ResourceNameRef::ResourceNameRef(const ResourceName& rhs)
326 : package(rhs.package), type(rhs.type), entry(rhs.entry) {}
328 inline ResourceNameRef::ResourceNameRef(const android::StringPiece& p, ResourceType t,
329 const android::StringPiece& e)
330 : package(p), type(t), entry(e) {}
332 inline ResourceNameRef& ResourceNameRef::operator=(const ResourceName& rhs) {
333 package = rhs.package;
339 inline ResourceName ResourceNameRef::ToResourceName() const {
340 return ResourceName(package, type, entry);
343 inline bool ResourceNameRef::is_valid() const {
344 return !package.empty() && !entry.empty();
347 inline bool operator<(const ResourceNameRef& lhs, const ResourceNameRef& rhs) {
348 return std::tie(lhs.package, lhs.type, lhs.entry) <
349 std::tie(rhs.package, rhs.type, rhs.entry);
352 inline bool operator==(const ResourceNameRef& lhs, const ResourceNameRef& rhs) {
353 return std::tie(lhs.package, lhs.type, lhs.entry) ==
354 std::tie(rhs.package, rhs.type, rhs.entry);
357 inline bool operator!=(const ResourceNameRef& lhs, const ResourceNameRef& rhs) {
358 return std::tie(lhs.package, lhs.type, lhs.entry) !=
359 std::tie(rhs.package, rhs.type, rhs.entry);
362 inline ::std::ostream& operator<<(::std::ostream& out,
363 const ResourceNameRef& name) {
364 if (!name.package.empty()) {
365 out << name.package << ":";
367 return out << name.type << "/" << name.entry;
370 inline bool operator<(const ResourceName& lhs, const ResourceNameRef& b) {
371 return ResourceNameRef(lhs) < b;
374 inline bool operator!=(const ResourceName& lhs, const ResourceNameRef& rhs) {
375 return ResourceNameRef(lhs) != rhs;
378 inline bool operator==(const SourcedResourceName& lhs,
379 const SourcedResourceName& rhs) {
380 return lhs.name == rhs.name && lhs.line == rhs.line;
388 struct hash<aapt::ResourceName> {
389 size_t operator()(const aapt::ResourceName& name) const {
390 android::hash_t h = 0;
391 h = android::JenkinsHashMix(h, hash<string>()(name.package));
392 h = android::JenkinsHashMix(h, static_cast<uint32_t>(name.type));
393 h = android::JenkinsHashMix(h, hash<string>()(name.entry));
394 return static_cast<size_t>(h);
400 #endif // AAPT_RESOURCE_H