blob: c71e249d71f26bbfb27cf9ac11f1fbd22b136bc5 [file] [log] [blame]
/*
* 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_RESOURCE_H
#define AAPT_RESOURCE_H
#include "ConfigDescription.h"
#include "Source.h"
#include "util/StringPiece.h"
#include <iomanip>
#include <limits>
#include <string>
#include <tuple>
#include <vector>
namespace aapt {
/**
* The various types of resource types available. Corresponds
* to the 'type' in package:type/entry.
*/
enum class ResourceType {
kAnim,
kAnimator,
kArray,
kAttr,
kAttrPrivate,
kBool,
kColor,
kDimen,
kDrawable,
kFraction,
kId,
kInteger,
kInterpolator,
kLayout,
kMenu,
kMipmap,
kPlurals,
kRaw,
kString,
kStyle,
kStyleable,
kTransition,
kXml,
};
StringPiece16 toString(ResourceType type);
/**
* Returns a pointer to a valid ResourceType, or nullptr if
* the string was invalid.
*/
const ResourceType* parseResourceType(const StringPiece16& str);
/**
* A resource's name. This can uniquely identify
* a resource in the ResourceTable.
*/
struct ResourceName {
std::u16string package;
ResourceType type;
std::u16string entry;
ResourceName() = default;
ResourceName(const StringPiece16& p, ResourceType t, const StringPiece16& e);
bool isValid() const;
bool operator<(const ResourceName& rhs) const;
bool operator==(const ResourceName& rhs) const;
bool operator!=(const ResourceName& rhs) const;
std::u16string toString() const;
};
/**
* Same as ResourceName, but uses StringPieces instead.
* Use this if you need to avoid copying and know that
* the lifetime of this object is shorter than that
* of the original string.
*/
struct ResourceNameRef {
StringPiece16 package;
ResourceType type;
StringPiece16 entry;
ResourceNameRef() = default;
ResourceNameRef(const ResourceNameRef&) = default;
ResourceNameRef(ResourceNameRef&&) = default;
ResourceNameRef(const ResourceName& rhs);
ResourceNameRef(const StringPiece16& p, ResourceType t, const StringPiece16& e);
ResourceNameRef& operator=(const ResourceNameRef& rhs) = default;
ResourceNameRef& operator=(ResourceNameRef&& rhs) = default;
ResourceNameRef& operator=(const ResourceName& rhs);
ResourceName toResourceName() const;
bool isValid() const;
bool operator<(const ResourceNameRef& rhs) const;
bool operator==(const ResourceNameRef& rhs) const;
bool operator!=(const ResourceNameRef& rhs) const;
};
/**
* A binary identifier representing a resource. Internally it
* is a 32bit integer split as follows:
*
* 0xPPTTEEEE
*
* PP: 8 bit package identifier. 0x01 is reserved for system
* and 0x7f is reserved for the running app.
* TT: 8 bit type identifier. 0x00 is invalid.
* EEEE: 16 bit entry identifier.
*/
struct ResourceId {
uint32_t id;
ResourceId();
ResourceId(const ResourceId& rhs);
ResourceId(uint32_t resId);
ResourceId(uint8_t p, uint8_t t, uint16_t e);
bool isValid() const;
uint8_t packageId() const;
uint8_t typeId() const;
uint16_t entryId() const;
bool operator<(const ResourceId& rhs) const;
bool operator==(const ResourceId& rhs) const;
};
struct SourcedResourceName {
ResourceName name;
size_t line;
inline bool operator==(const SourcedResourceName& rhs) const {
return name == rhs.name && line == rhs.line;
}
};
struct ResourceFile {
// Name
ResourceName name;
// Configuration
ConfigDescription config;
// Source
Source source;
// Exported symbols
std::vector<SourcedResourceName> exportedSymbols;
};
/**
* Useful struct used as a key to represent a unique resource in associative containers.
*/
struct ResourceKey {
ResourceName name;
ConfigDescription config;
};
bool operator<(const ResourceKey& a, const ResourceKey& b);
/**
* Useful struct used as a key to represent a unique resource in associative containers.
* Holds a reference to the name, so that name better live longer than this key!
*/
struct ResourceKeyRef {
ResourceNameRef name;
ConfigDescription config;
ResourceKeyRef() = default;
ResourceKeyRef(const ResourceNameRef& n, const ConfigDescription& c) : name(n), config(c) {
}
/**
* Prevent taking a reference to a temporary. This is bad.
*/
ResourceKeyRef(ResourceName&& n, const ConfigDescription& c) = delete;
};
bool operator<(const ResourceKeyRef& a, const ResourceKeyRef& b);
//
// ResourceId implementation.
//
inline ResourceId::ResourceId() : id(0) {
}
inline ResourceId::ResourceId(const ResourceId& rhs) : id(rhs.id) {
}
inline ResourceId::ResourceId(uint32_t resId) : id(resId) {
}
inline ResourceId::ResourceId(uint8_t p, uint8_t t, uint16_t e) : id((p << 24) | (t << 16) | e) {
}
inline bool ResourceId::isValid() const {
return (id & 0xff000000u) != 0 && (id & 0x00ff0000u) != 0;
}
inline uint8_t ResourceId::packageId() const {
return static_cast<uint8_t>(id >> 24);
}
inline uint8_t ResourceId::typeId() const {
return static_cast<uint8_t>(id >> 16);
}
inline uint16_t ResourceId::entryId() const {
return static_cast<uint16_t>(id);
}
inline bool ResourceId::operator<(const ResourceId& rhs) const {
return id < rhs.id;
}
inline bool ResourceId::operator==(const ResourceId& rhs) const {
return id == rhs.id;
}
inline ::std::ostream& operator<<(::std::ostream& out,
const ResourceId& resId) {
std::ios_base::fmtflags oldFlags = out.flags();
char oldFill = out.fill();
out << "0x" << std::internal << std::setfill('0') << std::setw(8)
<< std::hex << resId.id;
out.flags(oldFlags);
out.fill(oldFill);
return out;
}
//
// ResourceType implementation.
//
inline ::std::ostream& operator<<(::std::ostream& out, const ResourceType& val) {
return out << toString(val);
}
//
// ResourceName implementation.
//
inline ResourceName::ResourceName(const StringPiece16& p, ResourceType t, const StringPiece16& e) :
package(p.toString()), type(t), entry(e.toString()) {
}
inline bool ResourceName::isValid() const {
return !package.empty() && !entry.empty();
}
inline bool ResourceName::operator<(const ResourceName& rhs) const {
return std::tie(package, type, entry)
< std::tie(rhs.package, rhs.type, rhs.entry);
}
inline bool operator<(const ResourceName& lhs, const ResourceNameRef& b) {
return ResourceNameRef(lhs) < b;
}
inline bool ResourceName::operator==(const ResourceName& rhs) const {
return std::tie(package, type, entry)
== std::tie(rhs.package, rhs.type, rhs.entry);
}
inline bool ResourceName::operator!=(const ResourceName& rhs) const {
return std::tie(package, type, entry)
!= std::tie(rhs.package, rhs.type, rhs.entry);
}
inline bool operator!=(const ResourceName& lhs, const ResourceNameRef& rhs) {
return ResourceNameRef(lhs) != rhs;
}
inline std::u16string ResourceName::toString() const {
std::u16string result;
if (!package.empty()) {
result = package + u":";
}
return result + aapt::toString(type).toString() + u"/" + entry;
}
inline ::std::ostream& operator<<(::std::ostream& out, const ResourceName& name) {
if (!name.package.empty()) {
out << name.package << ":";
}
return out << name.type << "/" << name.entry;
}
//
// ResourceNameRef implementation.
//
inline ResourceNameRef::ResourceNameRef(const ResourceName& rhs) :
package(rhs.package), type(rhs.type), entry(rhs.entry) {
}
inline ResourceNameRef::ResourceNameRef(const StringPiece16& p, ResourceType t,
const StringPiece16& e) :
package(p), type(t), entry(e) {
}
inline ResourceNameRef& ResourceNameRef::operator=(const ResourceName& rhs) {
package = rhs.package;
type = rhs.type;
entry = rhs.entry;
return *this;
}
inline ResourceName ResourceNameRef::toResourceName() const {
return { package.toString(), type, entry.toString() };
}
inline bool ResourceNameRef::isValid() const {
return !package.empty() && !entry.empty();
}
inline bool ResourceNameRef::operator<(const ResourceNameRef& rhs) const {
return std::tie(package, type, entry)
< std::tie(rhs.package, rhs.type, rhs.entry);
}
inline bool ResourceNameRef::operator==(const ResourceNameRef& rhs) const {
return std::tie(package, type, entry)
== std::tie(rhs.package, rhs.type, rhs.entry);
}
inline bool ResourceNameRef::operator!=(const ResourceNameRef& rhs) const {
return std::tie(package, type, entry)
!= std::tie(rhs.package, rhs.type, rhs.entry);
}
inline ::std::ostream& operator<<(::std::ostream& out, const ResourceNameRef& name) {
if (!name.package.empty()) {
out << name.package << ":";
}
return out << name.type << "/" << name.entry;
}
} // namespace aapt
#endif // AAPT_RESOURCE_H