tools/aapt2/ResourceTable.cpp - platform/frameworks/base - Gitiles

 /*
  * 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.
  */

 #include "ConfigDescription.h"
 #include "NameMangler.h"
 #include "ResourceTable.h"
 #include "ResourceValues.h"
 #include "ValueVisitor.h"

 #include "util/Comparators.h"
 #include "util/Util.h"

 #include <algorithm>
 #include <androidfw/ResourceTypes.h>
 #include <memory>
 #include <string>
 #include <tuple>

 namespace aapt {

 static bool lessThanType(const std::unique_ptr<ResourceTableType>& lhs, ResourceType rhs) {
     return lhs->type < rhs;
 }

 template <typename T>
 static bool lessThanStructWithName(const std::unique_ptr<T>& lhs,
                                    const StringPiece16& rhs) {
     return lhs->name.compare(0, lhs->name.size(), rhs.data(), rhs.size()) < 0;
 }

 ResourceTablePackage* ResourceTable::findPackage(const StringPiece16& name) {
     const auto last = packages.end();
     auto iter = std::lower_bound(packages.begin(), last, name,
                                  lessThanStructWithName<ResourceTablePackage>);
     if (iter != last && name == (*iter)->name) {
         return iter->get();
     }
     return nullptr;
 }

 ResourceTablePackage* ResourceTable::findPackageById(uint8_t id) {
     for (auto& package : packages) {
         if (package->id && package->id.value() == id) {
             return package.get();
         }
     }
     return nullptr;
 }

 ResourceTablePackage* ResourceTable::createPackage(const StringPiece16& name, Maybe<uint8_t> id) {
     ResourceTablePackage* package = findOrCreatePackage(name);
     if (id && !package->id) {
         package->id = id;
         return package;
     }

     if (id && package->id && package->id.value() != id.value()) {
         return nullptr;
     }
     return package;
 }

 ResourceTablePackage* ResourceTable::findOrCreatePackage(const StringPiece16& name) {
     const auto last = packages.end();
     auto iter = std::lower_bound(packages.begin(), last, name,
                                  lessThanStructWithName<ResourceTablePackage>);
     if (iter != last && name == (*iter)->name) {
         return iter->get();
     }

     std::unique_ptr<ResourceTablePackage> newPackage = util::make_unique<ResourceTablePackage>();
     newPackage->name = name.toString();
     return packages.emplace(iter, std::move(newPackage))->get();
 }

 ResourceTableType* ResourceTablePackage::findType(ResourceType type) {
     const auto last = types.end();
     auto iter = std::lower_bound(types.begin(), last, type, lessThanType);
     if (iter != last && (*iter)->type == type) {
         return iter->get();
     }
     return nullptr;
 }

 ResourceTableType* ResourceTablePackage::findOrCreateType(ResourceType type) {
     const auto last = types.end();
     auto iter = std::lower_bound(types.begin(), last, type, lessThanType);
     if (iter != last && (*iter)->type == type) {
         return iter->get();
     }
     return types.emplace(iter, new ResourceTableType(type))->get();
 }

 ResourceEntry* ResourceTableType::findEntry(const StringPiece16& name) {
     const auto last = entries.end();
     auto iter = std::lower_bound(entries.begin(), last, name,
                                  lessThanStructWithName<ResourceEntry>);
     if (iter != last && name == (*iter)->name) {
         return iter->get();
     }
     return nullptr;
 }

 ResourceEntry* ResourceTableType::findOrCreateEntry(const StringPiece16& name) {
     auto last = entries.end();
     auto iter = std::lower_bound(entries.begin(), last, name,
                                  lessThanStructWithName<ResourceEntry>);
     if (iter != last && name == (*iter)->name) {
         return iter->get();
     }
     return entries.emplace(iter, new ResourceEntry(name))->get();
 }

 /**
  * The default handler for collisions. A return value of -1 means keep the
  * existing value, 0 means fail, and +1 means take the incoming value.
  */
 int ResourceTable::resolveValueCollision(Value* existing, Value* incoming) {
     Attribute* existingAttr = valueCast<Attribute>(existing);
     Attribute* incomingAttr = valueCast<Attribute>(incoming);

     if (!incomingAttr) {
         if (incoming->isWeak()) {
             // We're trying to add a weak resource but a resource
             // already exists. Keep the existing.
             return -1;
         } else if (existing->isWeak()) {
             // Override the weak resource with the new strong resource.
             return 1;
         }
         // The existing and incoming values are strong, this is an error
         // if the values are not both attributes.
         return 0;
     }

     if (!existingAttr) {
         if (existing->isWeak()) {
             // The existing value is not an attribute and it is weak,
             // so take the incoming attribute value.
             return 1;
         }
         // The existing value is not an attribute and it is strong,
         // so the incoming attribute value is an error.
         return 0;
     }

     assert(incomingAttr && existingAttr);

     //
     // Attribute specific handling. At this point we know both
     // values are attributes. Since we can declare and define
     // attributes all-over, we do special handling to see
     // which definition sticks.
     //
     if (existingAttr->typeMask == incomingAttr->typeMask) {
         // The two attributes are both DECLs, but they are plain attributes
         // with the same formats.
         // Keep the strongest one.
         return existingAttr->isWeak() ? 1 : -1;
     }

     if (existingAttr->isWeak() && existingAttr->typeMask == android::ResTable_map::TYPE_ANY) {
         // Any incoming attribute is better than this.
         return 1;
     }

     if (incomingAttr->isWeak() && incomingAttr->typeMask == android::ResTable_map::TYPE_ANY) {
         // The incoming attribute may be a USE instead of a DECL.
         // Keep the existing attribute.
         return -1;
     }
     return 0;
 }

 static constexpr const char16_t* kValidNameChars = u"._-";
 static constexpr const char16_t* kValidNameMangledChars = u"._-$";

 bool ResourceTable::addResource(const ResourceNameRef& name, const ConfigDescription& config,
                                 std::unique_ptr<Value> value, IDiagnostics* diag) {
     return addResourceImpl(name, {}, config, std::move(value), kValidNameChars,
                            resolveValueCollision, diag);
 }

 bool ResourceTable::addResource(const ResourceNameRef& name, const ResourceId resId,
                                 const ConfigDescription& config, std::unique_ptr<Value> value,
                                 IDiagnostics* diag) {
     return addResourceImpl(name, resId, config, std::move(value), kValidNameChars,
                            resolveValueCollision, diag);
 }

 bool ResourceTable::addFileReference(const ResourceNameRef& name, const ConfigDescription& config,
                                      const Source& source, const StringPiece16& path,
                                      IDiagnostics* diag) {
     return addFileReference(name, config, source, path, resolveValueCollision, diag);
 }

 bool ResourceTable::addFileReference(const ResourceNameRef& name, const ConfigDescription& config,
                                      const Source& source, const StringPiece16& path,
                                      std::function<int(Value*,Value*)> conflictResolver,
                                      IDiagnostics* diag) {
     std::unique_ptr<FileReference> fileRef = util::make_unique<FileReference>(
             stringPool.makeRef(path));
     fileRef->setSource(source);
     return addResourceImpl(name, ResourceId{}, config, std::move(fileRef), kValidNameChars,
                            conflictResolver, diag);
 }

 bool ResourceTable::addResourceAllowMangled(const ResourceNameRef& name,
                                             const ConfigDescription& config,
                                             std::unique_ptr<Value> value,
                                             IDiagnostics* diag) {
     return addResourceImpl(name, ResourceId{}, config, std::move(value), kValidNameMangledChars,
                            resolveValueCollision, diag);
 }

 bool ResourceTable::addResourceAllowMangled(const ResourceNameRef& name,
                                             const ResourceId id,
                                             const ConfigDescription& config,
                                             std::unique_ptr<Value> value,
                                             IDiagnostics* diag) {
     return addResourceImpl(name, id, config, std::move(value), kValidNameMangledChars,
                            resolveValueCollision, diag);
 }

 bool ResourceTable::addResourceImpl(const ResourceNameRef& name,
                                     const ResourceId resId,
                                     const ConfigDescription& config,
                                     std::unique_ptr<Value> value,
                                     const char16_t* validChars,
                                     std::function<int(Value*,Value*)> conflictResolver,
                                     IDiagnostics* diag) {
     assert(value && "value can't be nullptr");
     assert(diag && "diagnostics can't be nullptr");

     auto badCharIter = util::findNonAlphaNumericAndNotInSet(name.entry, validChars);
     if (badCharIter != name.entry.end()) {
         diag->error(DiagMessage(value->getSource())
                     << "resource '"
                     << name
                     << "' has invalid entry name '"
                     << name.entry
                     << "'. Invalid character '"
                     << StringPiece16(badCharIter, 1)
                     << "'");
         return false;
     }

     ResourceTablePackage* package = findOrCreatePackage(name.package);
     if (resId.isValid() && package->id && package->id.value() != resId.packageId()) {
         diag->error(DiagMessage(value->getSource())
                     << "trying to add resource '"
                     << name
                     << "' with ID "
                     << resId
                     << " but package '"
                     << package->name
                     << "' already has ID "
                     << std::hex << (int) package->id.value() << std::dec);
         return false;
     }

     ResourceTableType* type = package->findOrCreateType(name.type);
     if (resId.isValid() && type->id && type->id.value() != resId.typeId()) {
         diag->error(DiagMessage(value->getSource())
                     << "trying to add resource '"
                     << name
                     << "' with ID "
                     << resId
                     << " but type '"
                     << type->type
                     << "' already has ID "
                     << std::hex << (int) type->id.value() << std::dec);
         return false;
     }

     ResourceEntry* entry = type->findOrCreateEntry(name.entry);
     if (resId.isValid() && entry->id && entry->id.value() != resId.entryId()) {
         diag->error(DiagMessage(value->getSource())
                     << "trying to add resource '"
                     << name
                     << "' with ID "
                     << resId
                     << " but resource already has ID "
                     << ResourceId(package->id.value(), type->id.value(), entry->id.value()));
         return false;
     }

     const auto endIter = entry->values.end();
     auto iter = std::lower_bound(entry->values.begin(), endIter, config, cmp::lessThanConfig);
     if (iter == endIter || iter->config != config) {
         // This resource did not exist before, add it.
         entry->values.insert(iter, ResourceConfigValue{ config, std::move(value) });
     } else {
         int collisionResult = conflictResolver(iter->value.get(), value.get());
         if (collisionResult > 0) {
             // Take the incoming value.
             iter->value = std::move(value);
         } else if (collisionResult == 0) {
             diag->error(DiagMessage(value->getSource())
                         << "duplicate value for resource '" << name << "' "
                         << "with config '" << config << "'");
             diag->error(DiagMessage(iter->value->getSource())
                         << "resource previously defined here");
             return false;
         }
     }

     if (resId.isValid()) {
         package->id = resId.packageId();
         type->id = resId.typeId();
         entry->id = resId.entryId();
     }
     return true;
 }

 bool ResourceTable::setSymbolState(const ResourceNameRef& name, const ResourceId resId,
                                    const Symbol& symbol, IDiagnostics* diag) {
     return setSymbolStateImpl(name, resId, symbol, kValidNameChars, diag);
 }

 bool ResourceTable::setSymbolStateAllowMangled(const ResourceNameRef& name,
                                                const ResourceId resId,
                                                const Symbol& symbol, IDiagnostics* diag) {
     return setSymbolStateImpl(name, resId, symbol, kValidNameMangledChars, diag);
 }

 bool ResourceTable::setSymbolStateImpl(const ResourceNameRef& name, const ResourceId resId,
                                        const Symbol& symbol, const char16_t* validChars,
                                        IDiagnostics* diag) {
     assert(diag && "diagnostics can't be nullptr");

     auto badCharIter = util::findNonAlphaNumericAndNotInSet(name.entry, validChars);
     if (badCharIter != name.entry.end()) {
         diag->error(DiagMessage(symbol.source)
                     << "resource '"
                     << name
                     << "' has invalid entry name '"
                     << name.entry
                     << "'. Invalid character '"
                     << StringPiece16(badCharIter, 1)
                     << "'");
         return false;
     }

     ResourceTablePackage* package = findOrCreatePackage(name.package);
     if (resId.isValid() && package->id && package->id.value() != resId.packageId()) {
         diag->error(DiagMessage(symbol.source)
                     << "trying to add resource '"
                     << name
                     << "' with ID "
                     << resId
                     << " but package '"
                     << package->name
                     << "' already has ID "
                     << std::hex << (int) package->id.value() << std::dec);
         return false;
     }

     ResourceTableType* type = package->findOrCreateType(name.type);
     if (resId.isValid() && type->id && type->id.value() != resId.typeId()) {
         diag->error(DiagMessage(symbol.source)
                     << "trying to add resource '"
                     << name
                     << "' with ID "
                     << resId
                     << " but type '"
                     << type->type
                     << "' already has ID "
                     << std::hex << (int) type->id.value() << std::dec);
         return false;
     }

     ResourceEntry* entry = type->findOrCreateEntry(name.entry);
     if (resId.isValid() && entry->id && entry->id.value() != resId.entryId()) {
         diag->error(DiagMessage(symbol.source)
                     << "trying to add resource '"
                     << name
                     << "' with ID "
                     << resId
                     << " but resource already has ID "
                     << ResourceId(package->id.value(), type->id.value(), entry->id.value()));
         return false;
     }

     if (resId.isValid()) {
         package->id = resId.packageId();
         type->id = resId.typeId();
         entry->id = resId.entryId();
     }

     // Only mark the type state as public, it doesn't care about being private.
     if (symbol.state == SymbolState::kPublic) {
         type->symbolStatus.state = SymbolState::kPublic;
     }

     if (symbol.state == SymbolState::kUndefined &&
             entry->symbolStatus.state != SymbolState::kUndefined) {
         // We can't undefine a symbol (remove its visibility). Ignore.
         return true;
     }

     if (symbol.state == SymbolState::kPrivate &&
             entry->symbolStatus.state == SymbolState::kPublic) {
         // We can't downgrade public to private. Ignore.
         return true;
     }

     entry->symbolStatus = std::move(symbol);
     return true;
 }

 Maybe<ResourceTable::SearchResult>
 ResourceTable::findResource(const ResourceNameRef& name) {
     ResourceTablePackage* package = findPackage(name.package);
     if (!package) {
         return {};
     }

     ResourceTableType* type = package->findType(name.type);
     if (!type) {
         return {};
     }

     ResourceEntry* entry = type->findEntry(name.entry);
     if (!entry) {
         return {};
     }
     return SearchResult{ package, type, entry };
 }

 } // namespace aapt
	/*
	* 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.
	*/

	#include "ConfigDescription.h"
	#include "NameMangler.h"
	#include "ResourceTable.h"
	#include "ResourceValues.h"
	#include "ValueVisitor.h"

	#include "util/Comparators.h"
	#include "util/Util.h"

	#include <algorithm>
	#include <androidfw/ResourceTypes.h>
	#include <memory>
	#include <string>
	#include <tuple>

	namespace aapt {

	static bool lessThanType(const std::unique_ptr<ResourceTableType>& lhs, ResourceType rhs) {
	return lhs->type < rhs;
	}

	template <typename T>
	static bool lessThanStructWithName(const std::unique_ptr<T>& lhs,
	const StringPiece16& rhs) {
	return lhs->name.compare(0, lhs->name.size(), rhs.data(), rhs.size()) < 0;
	}

	ResourceTablePackage* ResourceTable::findPackage(const StringPiece16& name) {
	const auto last = packages.end();
	auto iter = std::lower_bound(packages.begin(), last, name,
	lessThanStructWithName<ResourceTablePackage>);
	if (iter != last && name == (*iter)->name) {
	return iter->get();
	}
	return nullptr;
	}

	ResourceTablePackage* ResourceTable::findPackageById(uint8_t id) {
	for (auto& package : packages) {
	if (package->id && package->id.value() == id) {
	return package.get();
	}
	}
	return nullptr;
	}

	ResourceTablePackage* ResourceTable::createPackage(const StringPiece16& name, Maybe<uint8_t> id) {
	ResourceTablePackage* package = findOrCreatePackage(name);
	if (id && !package->id) {
	package->id = id;
	return package;
	}

	if (id && package->id && package->id.value() != id.value()) {
	return nullptr;
	}
	return package;
	}

	ResourceTablePackage* ResourceTable::findOrCreatePackage(const StringPiece16& name) {
	const auto last = packages.end();
	auto iter = std::lower_bound(packages.begin(), last, name,
	lessThanStructWithName<ResourceTablePackage>);
	if (iter != last && name == (*iter)->name) {
	return iter->get();
	}

	std::unique_ptr<ResourceTablePackage> newPackage = util::make_unique<ResourceTablePackage>();
	newPackage->name = name.toString();
	return packages.emplace(iter, std::move(newPackage))->get();
	}

	ResourceTableType* ResourceTablePackage::findType(ResourceType type) {
	const auto last = types.end();
	auto iter = std::lower_bound(types.begin(), last, type, lessThanType);
	if (iter != last && (*iter)->type == type) {
	return iter->get();
	}
	return nullptr;
	}

	ResourceTableType* ResourceTablePackage::findOrCreateType(ResourceType type) {
	const auto last = types.end();
	auto iter = std::lower_bound(types.begin(), last, type, lessThanType);
	if (iter != last && (*iter)->type == type) {
	return iter->get();
	}
	return types.emplace(iter, new ResourceTableType(type))->get();
	}

	ResourceEntry* ResourceTableType::findEntry(const StringPiece16& name) {
	const auto last = entries.end();
	auto iter = std::lower_bound(entries.begin(), last, name,
	lessThanStructWithName<ResourceEntry>);
	if (iter != last && name == (*iter)->name) {
	return iter->get();
	}
	return nullptr;
	}

	ResourceEntry* ResourceTableType::findOrCreateEntry(const StringPiece16& name) {
	auto last = entries.end();
	auto iter = std::lower_bound(entries.begin(), last, name,
	lessThanStructWithName<ResourceEntry>);
	if (iter != last && name == (*iter)->name) {
	return iter->get();
	}
	return entries.emplace(iter, new ResourceEntry(name))->get();
	}

	/**
	* The default handler for collisions. A return value of -1 means keep the
	* existing value, 0 means fail, and +1 means take the incoming value.
	*/
	int ResourceTable::resolveValueCollision(Value* existing, Value* incoming) {
	Attribute* existingAttr = valueCast<Attribute>(existing);
	Attribute* incomingAttr = valueCast<Attribute>(incoming);

	if (!incomingAttr) {
	if (incoming->isWeak()) {
	// We're trying to add a weak resource but a resource
	// already exists. Keep the existing.
	return -1;
	} else if (existing->isWeak()) {
	// Override the weak resource with the new strong resource.
	return 1;
	}
	// The existing and incoming values are strong, this is an error
	// if the values are not both attributes.
	return 0;
	}

	if (!existingAttr) {
	if (existing->isWeak()) {
	// The existing value is not an attribute and it is weak,
	// so take the incoming attribute value.
	return 1;
	}
	// The existing value is not an attribute and it is strong,
	// so the incoming attribute value is an error.
	return 0;
	}

	assert(incomingAttr && existingAttr);

	//
	// Attribute specific handling. At this point we know both
	// values are attributes. Since we can declare and define
	// attributes all-over, we do special handling to see
	// which definition sticks.
	//
	if (existingAttr->typeMask == incomingAttr->typeMask) {
	// The two attributes are both DECLs, but they are plain attributes
	// with the same formats.
	// Keep the strongest one.
	return existingAttr->isWeak() ? 1 : -1;
	}

	if (existingAttr->isWeak() && existingAttr->typeMask == android::ResTable_map::TYPE_ANY) {
	// Any incoming attribute is better than this.
	return 1;
	}

	if (incomingAttr->isWeak() && incomingAttr->typeMask == android::ResTable_map::TYPE_ANY) {
	// The incoming attribute may be a USE instead of a DECL.
	// Keep the existing attribute.
	return -1;
	}
	return 0;
	}

	static constexpr const char16_t* kValidNameChars = u"._-";
	static constexpr const char16_t* kValidNameMangledChars = u"._-$";

	bool ResourceTable::addResource(const ResourceNameRef& name, const ConfigDescription& config,
	std::unique_ptr<Value> value, IDiagnostics* diag) {
	return addResourceImpl(name, {}, config, std::move(value), kValidNameChars,
	resolveValueCollision, diag);
	}

	bool ResourceTable::addResource(const ResourceNameRef& name, const ResourceId resId,
	const ConfigDescription& config, std::unique_ptr<Value> value,
	IDiagnostics* diag) {
	return addResourceImpl(name, resId, config, std::move(value), kValidNameChars,
	resolveValueCollision, diag);
	}

	bool ResourceTable::addFileReference(const ResourceNameRef& name, const ConfigDescription& config,
	const Source& source, const StringPiece16& path,
	IDiagnostics* diag) {
	return addFileReference(name, config, source, path, resolveValueCollision, diag);
	}

	bool ResourceTable::addFileReference(const ResourceNameRef& name, const ConfigDescription& config,
	const Source& source, const StringPiece16& path,
	std::function<int(Value,Value)> conflictResolver,
	IDiagnostics* diag) {
	std::unique_ptr<FileReference> fileRef = util::make_unique<FileReference>(
	stringPool.makeRef(path));
	fileRef->setSource(source);
	return addResourceImpl(name, ResourceId{}, config, std::move(fileRef), kValidNameChars,
	conflictResolver, diag);
	}

	bool ResourceTable::addResourceAllowMangled(const ResourceNameRef& name,
	const ConfigDescription& config,
	std::unique_ptr<Value> value,
	IDiagnostics* diag) {
	return addResourceImpl(name, ResourceId{}, config, std::move(value), kValidNameMangledChars,
	resolveValueCollision, diag);
	}

	bool ResourceTable::addResourceAllowMangled(const ResourceNameRef& name,
	const ResourceId id,
	const ConfigDescription& config,
	std::unique_ptr<Value> value,
	IDiagnostics* diag) {
	return addResourceImpl(name, id, config, std::move(value), kValidNameMangledChars,
	resolveValueCollision, diag);
	}

	bool ResourceTable::addResourceImpl(const ResourceNameRef& name,
	const ResourceId resId,
	const ConfigDescription& config,
	std::unique_ptr<Value> value,
	const char16_t* validChars,
	std::function<int(Value,Value)> conflictResolver,
	IDiagnostics* diag) {
	assert(value && "value can't be nullptr");
	assert(diag && "diagnostics can't be nullptr");

	auto badCharIter = util::findNonAlphaNumericAndNotInSet(name.entry, validChars);
	if (badCharIter != name.entry.end()) {
	diag->error(DiagMessage(value->getSource())
	<< "resource '"
	<< name
	<< "' has invalid entry name '"
	<< name.entry
	<< "'. Invalid character '"
	<< StringPiece16(badCharIter, 1)
	<< "'");
	return false;
	}

	ResourceTablePackage* package = findOrCreatePackage(name.package);
	if (resId.isValid() && package->id && package->id.value() != resId.packageId()) {
	diag->error(DiagMessage(value->getSource())
	<< "trying to add resource '"
	<< name
	<< "' with ID "
	<< resId
	<< " but package '"
	<< package->name
	<< "' already has ID "
	<< std::hex << (int) package->id.value() << std::dec);
	return false;
	}

	ResourceTableType* type = package->findOrCreateType(name.type);
	if (resId.isValid() && type->id && type->id.value() != resId.typeId()) {
	diag->error(DiagMessage(value->getSource())
	<< "trying to add resource '"
	<< name
	<< "' with ID "
	<< resId
	<< " but type '"
	<< type->type
	<< "' already has ID "
	<< std::hex << (int) type->id.value() << std::dec);
	return false;
	}

	ResourceEntry* entry = type->findOrCreateEntry(name.entry);
	if (resId.isValid() && entry->id && entry->id.value() != resId.entryId()) {
	diag->error(DiagMessage(value->getSource())
	<< "trying to add resource '"
	<< name
	<< "' with ID "
	<< resId
	<< " but resource already has ID "
	<< ResourceId(package->id.value(), type->id.value(), entry->id.value()));
	return false;
	}

	const auto endIter = entry->values.end();
	auto iter = std::lower_bound(entry->values.begin(), endIter, config, cmp::lessThanConfig);
	if (iter == endIter \|\| iter->config != config) {
	// This resource did not exist before, add it.
	entry->values.insert(iter, ResourceConfigValue{ config, std::move(value) });
	} else {
	int collisionResult = conflictResolver(iter->value.get(), value.get());
	if (collisionResult > 0) {
	// Take the incoming value.
	iter->value = std::move(value);
	} else if (collisionResult == 0) {
	diag->error(DiagMessage(value->getSource())
	<< "duplicate value for resource '" << name << "' "
	<< "with config '" << config << "'");
	diag->error(DiagMessage(iter->value->getSource())
	<< "resource previously defined here");
	return false;
	}
	}

	if (resId.isValid()) {
	package->id = resId.packageId();
	type->id = resId.typeId();
	entry->id = resId.entryId();
	}
	return true;
	}

	bool ResourceTable::setSymbolState(const ResourceNameRef& name, const ResourceId resId,
	const Symbol& symbol, IDiagnostics* diag) {
	return setSymbolStateImpl(name, resId, symbol, kValidNameChars, diag);
	}

	bool ResourceTable::setSymbolStateAllowMangled(const ResourceNameRef& name,
	const ResourceId resId,
	const Symbol& symbol, IDiagnostics* diag) {
	return setSymbolStateImpl(name, resId, symbol, kValidNameMangledChars, diag);
	}

	bool ResourceTable::setSymbolStateImpl(const ResourceNameRef& name, const ResourceId resId,
	const Symbol& symbol, const char16_t* validChars,
	IDiagnostics* diag) {
	assert(diag && "diagnostics can't be nullptr");

	auto badCharIter = util::findNonAlphaNumericAndNotInSet(name.entry, validChars);
	if (badCharIter != name.entry.end()) {
	diag->error(DiagMessage(symbol.source)
	<< "resource '"
	<< name
	<< "' has invalid entry name '"
	<< name.entry
	<< "'. Invalid character '"
	<< StringPiece16(badCharIter, 1)
	<< "'");
	return false;
	}

	ResourceTablePackage* package = findOrCreatePackage(name.package);
	if (resId.isValid() && package->id && package->id.value() != resId.packageId()) {
	diag->error(DiagMessage(symbol.source)
	<< "trying to add resource '"
	<< name
	<< "' with ID "
	<< resId
	<< " but package '"
	<< package->name
	<< "' already has ID "
	<< std::hex << (int) package->id.value() << std::dec);
	return false;
	}

	ResourceTableType* type = package->findOrCreateType(name.type);
	if (resId.isValid() && type->id && type->id.value() != resId.typeId()) {
	diag->error(DiagMessage(symbol.source)
	<< "trying to add resource '"
	<< name
	<< "' with ID "
	<< resId
	<< " but type '"
	<< type->type
	<< "' already has ID "
	<< std::hex << (int) type->id.value() << std::dec);
	return false;
	}

	ResourceEntry* entry = type->findOrCreateEntry(name.entry);
	if (resId.isValid() && entry->id && entry->id.value() != resId.entryId()) {
	diag->error(DiagMessage(symbol.source)
	<< "trying to add resource '"
	<< name
	<< "' with ID "
	<< resId
	<< " but resource already has ID "
	<< ResourceId(package->id.value(), type->id.value(), entry->id.value()));
	return false;
	}

	if (resId.isValid()) {
	package->id = resId.packageId();
	type->id = resId.typeId();
	entry->id = resId.entryId();
	}

	// Only mark the type state as public, it doesn't care about being private.
	if (symbol.state == SymbolState::kPublic) {
	type->symbolStatus.state = SymbolState::kPublic;
	}

	if (symbol.state == SymbolState::kUndefined &&
	entry->symbolStatus.state != SymbolState::kUndefined) {
	// We can't undefine a symbol (remove its visibility). Ignore.
	return true;
	}

	if (symbol.state == SymbolState::kPrivate &&
	entry->symbolStatus.state == SymbolState::kPublic) {
	// We can't downgrade public to private. Ignore.
	return true;
	}

	entry->symbolStatus = std::move(symbol);
	return true;
	}

	Maybe<ResourceTable::SearchResult>
	ResourceTable::findResource(const ResourceNameRef& name) {
	ResourceTablePackage* package = findPackage(name.package);
	if (!package) {
	return {};
	}

	ResourceTableType* type = package->findType(name.type);
	if (!type) {
	return {};
	}

	ResourceEntry* entry = type->findEntry(name.entry);
	if (!entry) {
	return {};
	}
	return SearchResult{ package, type, entry };
	}

	} // namespace aapt