SymbolTable.h revision cacb28f2d60858106e2819cc7d95a65e8bda890b 
1/*
2 * Copyright (C) 2015 The Android Open Source Project
3 *
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
7 *
8 *      http://www.apache.org/licenses/LICENSE-2.0
9 *
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.
15 */
16
17#ifndef AAPT_PROCESS_SYMBOLTABLE_H
18#define AAPT_PROCESS_SYMBOLTABLE_H
19
20#include "Resource.h"
21#include "ResourceTable.h"
22#include "ResourceValues.h"
23#include "util/Util.h"
24
25#include <utils/JenkinsHash.h>
26#include <utils/LruCache.h>
27
28#include <android-base/macros.h>
29#include <androidfw/AssetManager.h>
30#include <algorithm>
31#include <memory>
32#include <vector>
33
34namespace aapt {
35
36inline android::hash_t hash_type(const ResourceName& name) {
37  std::hash<std::string> strHash;
38  android::hash_t hash = 0;
39  hash = android::JenkinsHashMix(hash, (uint32_t)strHash(name.package));
40  hash = android::JenkinsHashMix(hash, (uint32_t)name.type);
41  hash = android::JenkinsHashMix(hash, (uint32_t)strHash(name.entry));
42  return hash;
43}
44
45inline android::hash_t hash_type(const ResourceId& id) {
46  return android::hash_type(id.id);
47}
48
49class ISymbolSource;
50
51class SymbolTable {
52 public:
53  struct Symbol {
54    Symbol() : Symbol(Maybe<ResourceId>{}) {}
55
56    explicit Symbol(const Maybe<ResourceId>& i) : Symbol(i, nullptr) {}
57
58    Symbol(const Maybe<ResourceId>& i, const std::shared_ptr<Attribute>& attr)
59        : Symbol(i, attr, false) {}
60
61    Symbol(const Maybe<ResourceId>& i, const std::shared_ptr<Attribute>& attr,
62           bool pub)
63        : id(i), attribute(attr), isPublic(pub) {}
64
65    Symbol(const Symbol&) = default;
66    Symbol(Symbol&&) = default;
67    Symbol& operator=(const Symbol&) = default;
68    Symbol& operator=(Symbol&&) = default;
69
70    Maybe<ResourceId> id;
71    std::shared_ptr<Attribute> attribute;
72    bool isPublic = false;
73  };
74
75  SymbolTable() : mCache(200), mIdCache(200) {}
76
77  void appendSource(std::unique_ptr<ISymbolSource> source);
78  void prependSource(std::unique_ptr<ISymbolSource> source);
79
80  /**
81   * Never hold on to the result between calls to findByName or findById. The
82   * results
83   * are typically stored in a cache which may evict entries.
84   */
85  const Symbol* findByName(const ResourceName& name);
86  const Symbol* findById(const ResourceId& id);
87
88  /**
89   * Let's the ISymbolSource decide whether looking up by name or ID is faster,
90   * if both
91   * are available.
92   */
93  const Symbol* findByReference(const Reference& ref);
94
95 private:
96  std::vector<std::unique_ptr<ISymbolSource>> mSources;
97
98  // We use shared_ptr because unique_ptr is not supported and
99  // we need automatic deletion.
100  android::LruCache<ResourceName, std::shared_ptr<Symbol>> mCache;
101  android::LruCache<ResourceId, std::shared_ptr<Symbol>> mIdCache;
102
103  DISALLOW_COPY_AND_ASSIGN(SymbolTable);
104};
105
106/**
107 * An interface that a symbol source implements in order to surface symbol
108 * information
109 * to the symbol table.
110 */
111class ISymbolSource {
112 public:
113  virtual ~ISymbolSource() = default;
114
115  virtual std::unique_ptr<SymbolTable::Symbol> findByName(
116      const ResourceName& name) = 0;
117  virtual std::unique_ptr<SymbolTable::Symbol> findById(ResourceId id) = 0;
118
119  /**
120   * Default implementation tries the name if it exists, else the ID.
121   */
122  virtual std::unique_ptr<SymbolTable::Symbol> findByReference(
123      const Reference& ref) {
124    if (ref.name) {
125      return findByName(ref.name.value());
126    } else if (ref.id) {
127      return findById(ref.id.value());
128    }
129    return {};
130  }
131};
132
133/**
134 * Exposes the resources in a ResourceTable as symbols for SymbolTable.
135 * Instances of this class must outlive the encompassed ResourceTable.
136 * Lookups by ID are ignored.
137 */
138class ResourceTableSymbolSource : public ISymbolSource {
139 public:
140  explicit ResourceTableSymbolSource(ResourceTable* table) : mTable(table) {}
141
142  std::unique_ptr<SymbolTable::Symbol> findByName(
143      const ResourceName& name) override;
144
145  std::unique_ptr<SymbolTable::Symbol> findById(ResourceId id) override {
146    return {};
147  }
148
149 private:
150  ResourceTable* mTable;
151
152  DISALLOW_COPY_AND_ASSIGN(ResourceTableSymbolSource);
153};
154
155class AssetManagerSymbolSource : public ISymbolSource {
156 public:
157  AssetManagerSymbolSource() = default;
158
159  bool addAssetPath(const StringPiece& path);
160
161  std::unique_ptr<SymbolTable::Symbol> findByName(
162      const ResourceName& name) override;
163  std::unique_ptr<SymbolTable::Symbol> findById(ResourceId id) override;
164  std::unique_ptr<SymbolTable::Symbol> findByReference(
165      const Reference& ref) override;
166
167 private:
168  android::AssetManager mAssets;
169
170  DISALLOW_COPY_AND_ASSIGN(AssetManagerSymbolSource);
171};
172
173}  // namespace aapt
174
175#endif /* AAPT_PROCESS_SYMBOLTABLE_H */
176