AAPT2: Separate out the various steps
An early refactor. Some ideas became clearer as
development continued. Now the various phases are much
clearer and more easily reusable.
Also added a ton of tests!
Change-Id: Ic8f0a70c8222370352e63533b329c40457c0903e
diff --git a/tools/aapt2/process/SymbolTable.h b/tools/aapt2/process/SymbolTable.h
new file mode 100644
index 0000000..22096ed
--- /dev/null
+++ b/tools/aapt2/process/SymbolTable.h
@@ -0,0 +1,152 @@
+/*
+ * 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_PROCESS_SYMBOLTABLE_H
+#define AAPT_PROCESS_SYMBOLTABLE_H
+
+#include "Resource.h"
+#include "ResourceTable.h"
+#include "ResourceValues.h"
+#include "util/Util.h"
+
+#include <utils/JenkinsHash.h>
+#include <utils/LruCache.h>
+
+#include <androidfw/AssetManager.h>
+#include <algorithm>
+#include <map>
+#include <memory>
+#include <vector>
+
+namespace aapt {
+
+struct ISymbolTable {
+ virtual ~ISymbolTable() = default;
+
+ struct Symbol {
+ ResourceId id;
+ std::unique_ptr<Attribute> attribute;
+ bool isPublic;
+ };
+
+ /**
+ * Never hold on to the result between calls to findByName or findById. The results
+ * are typically stored in a cache which may evict entries.
+ */
+ virtual const Symbol* findByName(const ResourceName& name) = 0;
+ virtual const Symbol* findById(ResourceId id) = 0;
+};
+
+inline android::hash_t hash_type(const ResourceName& name) {
+ std::hash<std::u16string> strHash;
+ android::hash_t hash = 0;
+ hash = android::JenkinsHashMix(hash, strHash(name.package));
+ hash = android::JenkinsHashMix(hash, (uint32_t) name.type);
+ hash = android::JenkinsHashMix(hash, strHash(name.entry));
+ return hash;
+}
+
+inline android::hash_t hash_type(const ResourceId& id) {
+ return android::hash_type(id.id);
+}
+
+/**
+ * Presents a ResourceTable as an ISymbolTable, caching results.
+ * Instances of this class must outlive the encompassed ResourceTable.
+ * Since symbols are cached, the ResourceTable should not change during the
+ * lifetime of this SymbolTableWrapper.
+ *
+ * If a resource in the ResourceTable does not have a ResourceID assigned to it,
+ * it is ignored.
+ *
+ * Lookups by ID are ignored.
+ */
+class SymbolTableWrapper : public ISymbolTable {
+private:
+ ResourceTable* mTable;
+
+ // We use shared_ptr because unique_ptr is not supported and
+ // we need automatic deletion.
+ android::LruCache<ResourceName, std::shared_ptr<Symbol>> mCache;
+
+public:
+ SymbolTableWrapper(ResourceTable* table) : mTable(table), mCache(200) {
+ }
+
+ const Symbol* findByName(const ResourceName& name) override;
+
+ // Unsupported, all queries to ResourceTable should be done by name.
+ const Symbol* findById(ResourceId id) override {
+ return {};
+ }
+};
+
+class AssetManagerSymbolTableBuilder {
+private:
+ struct AssetManagerSymbolTable : public ISymbolTable {
+ std::vector<std::unique_ptr<android::AssetManager>> mAssets;
+
+ // We use shared_ptr because unique_ptr is not supported and
+ // we need automatic deletion.
+ android::LruCache<ResourceName, std::shared_ptr<Symbol>> mCache;
+ android::LruCache<ResourceId, std::shared_ptr<Symbol>> mIdCache;
+
+ AssetManagerSymbolTable() : mCache(200), mIdCache(200) {
+ }
+
+ const Symbol* findByName(const ResourceName& name) override;
+ const Symbol* findById(ResourceId id) override;
+ };
+
+ std::unique_ptr<AssetManagerSymbolTable> mSymbolTable =
+ util::make_unique<AssetManagerSymbolTable>();
+
+public:
+ AssetManagerSymbolTableBuilder& add(std::unique_ptr<android::AssetManager> assetManager) {
+ mSymbolTable->mAssets.push_back(std::move(assetManager));
+ return *this;
+ }
+
+ std::unique_ptr<ISymbolTable> build() {
+ return std::move(mSymbolTable);
+ }
+};
+
+class JoinedSymbolTableBuilder {
+private:
+ struct JoinedSymbolTable : public ISymbolTable {
+ std::vector<std::unique_ptr<ISymbolTable>> mSymbolTables;
+
+ const Symbol* findByName(const ResourceName& name) override;
+ const Symbol* findById(ResourceId id) override;
+ };
+
+ std::unique_ptr<JoinedSymbolTable> mSymbolTable = util::make_unique<JoinedSymbolTable>();
+
+public:
+ JoinedSymbolTableBuilder& addSymbolTable(std::unique_ptr<ISymbolTable> table) {
+ mSymbolTable->mSymbolTables.push_back(std::move(table));
+ return *this;
+ }
+
+ std::unique_ptr<ISymbolTable> build() {
+ return std::move(mSymbolTable);
+ }
+};
+
+} // namespace aapt
+
+#endif /* AAPT_PROCESS_SYMBOLTABLE_H */
