Konsta
123 lines
3.9 KiB
C++
123 lines
3.9 KiB
C++
/*
|
|
* Copyright (C) 2022 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.
|
|
*/
|
|
|
|
#pragma once
|
|
|
|
#include <algorithm>
|
|
#include <map>
|
|
#include <set>
|
|
#include <vector>
|
|
|
|
namespace aidl::android::hardware::audio::core {
|
|
|
|
// Return whether all the elements in the vector are unique.
|
|
template <typename T>
|
|
bool all_unique(const std::vector<T>& v) {
|
|
return std::set<T>(v.begin(), v.end()).size() == v.size();
|
|
}
|
|
|
|
// Erase all the specified elements from a map.
|
|
template <typename C, typename V>
|
|
auto erase_all(C& c, const V& keys) {
|
|
auto oldSize = c.size();
|
|
for (auto& k : keys) {
|
|
c.erase(k);
|
|
}
|
|
return oldSize - c.size();
|
|
}
|
|
|
|
// Erase all the elements in the container that satisfy the provided predicate.
|
|
template <typename C, typename P>
|
|
auto erase_if(C& c, P pred) {
|
|
auto oldSize = c.size();
|
|
for (auto it = c.begin(); it != c.end();) {
|
|
if (pred(*it)) {
|
|
it = c.erase(it);
|
|
} else {
|
|
++it;
|
|
}
|
|
}
|
|
return oldSize - c.size();
|
|
}
|
|
|
|
// Erase all the elements in the map that have specified values.
|
|
template <typename C, typename V>
|
|
auto erase_all_values(C& c, const V& values) {
|
|
return erase_if(c, [values](const auto& pair) { return values.count(pair.second) != 0; });
|
|
}
|
|
|
|
// Return non-zero count of elements for any of the provided keys.
|
|
template <typename M, typename V>
|
|
size_t count_any(const M& m, const V& keys) {
|
|
for (auto& k : keys) {
|
|
if (size_t c = m.count(k); c != 0) return c;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
// Assuming that M is a map whose values have an 'id' field,
|
|
// find an element with the specified id.
|
|
template <typename M>
|
|
auto findById(M& m, int32_t id) {
|
|
return std::find_if(m.begin(), m.end(), [&](const auto& p) { return p.second.id == id; });
|
|
}
|
|
|
|
// Assuming that the vector contains elements with an 'id' field,
|
|
// find an element with the specified id.
|
|
template <typename T>
|
|
auto findById(std::vector<T>& v, int32_t id) {
|
|
return std::find_if(v.begin(), v.end(), [&](const auto& e) { return e.id == id; });
|
|
}
|
|
|
|
// Return elements from the vector that have specified ids, also
|
|
// optionally return which ids were not found.
|
|
template <typename T>
|
|
std::vector<T*> selectByIds(std::vector<T>& v, const std::vector<int32_t>& ids,
|
|
std::vector<int32_t>* missingIds = nullptr) {
|
|
std::vector<T*> result;
|
|
std::set<int32_t> idsSet(ids.begin(), ids.end());
|
|
for (size_t i = 0; i < v.size(); ++i) {
|
|
T& e = v[i];
|
|
if (idsSet.count(e.id) != 0) {
|
|
result.push_back(&v[i]);
|
|
idsSet.erase(e.id);
|
|
}
|
|
}
|
|
if (missingIds) {
|
|
*missingIds = std::vector(idsSet.begin(), idsSet.end());
|
|
}
|
|
return result;
|
|
}
|
|
|
|
// Assuming that M is a map whose keys' type is K and values' type is V,
|
|
// return the corresponding value of the given key from the map or default
|
|
// value if the key is not found.
|
|
template <typename M, typename K, typename V>
|
|
auto findValueOrDefault(const M& m, const K& key, V defaultValue) {
|
|
auto it = m.find(key);
|
|
return it == m.end() ? defaultValue : it->second;
|
|
}
|
|
|
|
// Assuming that M is a map whose keys' type is K, return the given key if it
|
|
// is found from the map or default value.
|
|
template <typename M, typename K>
|
|
auto findKeyOrDefault(const M& m, const K& key, K defaultValue) {
|
|
auto it = m.find(key);
|
|
return it == m.end() ? defaultValue : key;
|
|
}
|
|
|
|
} // namespace aidl::android::hardware::audio::core
|