blob: 86118b5967b88590632d6d2e704a3df9ffd13199 [file] [log] [blame]
/*
* Copyright (C) 2017 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 "MatrixHal.h"
#include <algorithm>
#include "MapValueIterator.h"
namespace android {
namespace vintf {
bool MatrixHal::operator==(const MatrixHal &other) const {
if (format != other.format)
return false;
if (name != other.name)
return false;
if (versionRanges != other.versionRanges)
return false;
if (interfaces != other.interfaces)
return false;
// do not compare optional
return true;
}
bool MatrixHal::containsVersion(const Version& version) const {
for (VersionRange vRange : versionRanges) {
if (vRange.contains(version)) return true;
}
return false;
}
bool MatrixHal::forEachInstance(const std::function<bool(const MatrixInstance&)>& func) const {
for (const auto& vr : versionRanges) {
if (!forEachInstance(vr, func)) {
return false;
}
}
return true;
}
bool MatrixHal::forEachInstance(const VersionRange& vr,
const std::function<bool(const MatrixInstance&)>& func) const {
for (const auto& intf : iterateValues(interfaces)) {
bool cont =
intf.forEachInstance([&](const auto& interface, const auto& instance, bool isRegex) {
// TODO(b/73556059): Store MatrixInstance as well to avoid creating temps
FqInstance fqInstance;
if (fqInstance.setTo(getName(), vr.majorVer, vr.minMinor, interface, instance)) {
if (!func(MatrixInstance(std::move(fqInstance), VersionRange(vr), optional,
isRegex))) {
return false;
}
}
return true;
});
if (!cont) {
return false;
}
}
return true;
}
bool MatrixHal::forEachInstance(
const std::function<bool(const std::vector<VersionRange>&, const std::string&,
const std::string&, bool isRegex)>& func) const {
for (const auto& intf : iterateValues(interfaces)) {
bool cont =
intf.forEachInstance([&](const auto& interface, const auto& instance, bool isRegex) {
return func(this->versionRanges, interface, instance, isRegex);
});
if (!cont) {
return false;
}
}
return true;
}
bool MatrixHal::isCompatible(const std::set<FqInstance>& providedInstances,
const std::set<Version>& providedVersions) const {
// <version>'s are related by OR.
return std::any_of(versionRanges.begin(), versionRanges.end(), [&](const VersionRange& vr) {
return isCompatible(vr, providedInstances, providedVersions);
});
}
bool MatrixHal::isCompatible(const VersionRange& vr, const std::set<FqInstance>& providedInstances,
const std::set<Version>& providedVersions) const {
bool hasAnyInstance = false;
bool versionUnsatisfied = false;
// Look at each interface/instance, and ensure that they are in providedInstances.
forEachInstance(vr, [&](const MatrixInstance& matrixInstance) {
hasAnyInstance = true;
versionUnsatisfied |=
!std::any_of(providedInstances.begin(), providedInstances.end(),
[&](const FqInstance& providedInstance) {
return matrixInstance.isSatisfiedBy(providedInstance);
});
return !versionUnsatisfied; // if any interface/instance is unsatisfied, break
});
if (hasAnyInstance) {
return !versionUnsatisfied;
}
// In some cases (e.g. tests and native HALs), compatibility matrix doesn't specify
// any instances. Check versions only.
return std::any_of(
providedVersions.begin(), providedVersions.end(),
[&](const auto& providedVersion) { return vr.supportedBy(providedVersion); });
}
void MatrixHal::setOptional(bool o) {
this->optional = o;
}
void MatrixHal::insertVersionRanges(const std::vector<VersionRange>& other) {
for (const VersionRange& otherVr : other) {
auto existingVr = std::find_if(this->versionRanges.begin(), this->versionRanges.end(),
[&](const auto& e) { return e.overlaps(otherVr); });
if (existingVr == this->versionRanges.end()) {
this->versionRanges.push_back(otherVr);
} else {
existingVr->minMinor = std::min(existingVr->minMinor, otherVr.minMinor);
existingVr->maxMinor = std::max(existingVr->maxMinor, otherVr.maxMinor);
}
}
}
void MatrixHal::insertInstance(const std::string& interface, const std::string& instance,
bool isRegex) {
auto it = interfaces.find(interface);
if (it == interfaces.end())
it = interfaces.emplace(interface, HalInterface{interface, {}}).first;
it->second.insertInstance(instance, isRegex);
}
size_t MatrixHal::instancesCount() const {
size_t count = 0;
forEachInstance([&](const MatrixInstance&) {
++count;
return true; // continue;
});
return count;
}
bool MatrixHal::removeInstance(const std::string& interface, const std::string& instance,
bool isRegex) {
auto it = interfaces.find(interface);
if (it == interfaces.end()) return false;
bool removed = it->second.removeInstance(instance, isRegex);
if (!it->second.hasAnyInstance()) interfaces.erase(it);
return removed;
}
void MatrixHal::clearInstances() {
this->interfaces.clear();
}
} // namespace vintf
} // namespace android