Merge changes I5581cd9c,Id6357fa0 (800859ad) · Commits · e / os / android_frameworks_native

include/ftl/details/match.h

0 → 100644

+59 −0

Original line number	Diff line number	Diff line
		/*
		* Copyright 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 <type_traits>
		#include <variant>

		namespace android::ftl::details {

		template <typename... Ms>
		struct Matcher : Ms... {
		using Ms::operator()...;
		};

		// Deduction guide.
		template <typename... Ms>
		Matcher(Ms...) -> Matcher<Ms...>;

		template <typename Matcher, typename... Ts>
		constexpr bool is_exhaustive_match_v = (std::is_invocable_v<Matcher, Ts> && ...);

		template <typename...>
		struct Match;

		template <typename T, typename U, typename... Ts>
		struct Match<T, U, Ts...> {
		template <typename Variant, typename Matcher>
		static decltype(auto) match(Variant& variant, const Matcher& matcher) {
		if (auto* const ptr = std::get_if<T>(&variant)) {
		return matcher(*ptr);
		} else {
		return Match<U, Ts...>::match(variant, matcher);
		}
		}
		};

		template <typename T>
		struct Match<T> {
		template <typename Variant, typename Matcher>
		static decltype(auto) match(Variant& variant, const Matcher& matcher) {
		return matcher(std::get<T>(variant));
		}
		};

		} // namespace android::ftl::details

include/ftl/match.h

0 → 100644

+62 −0

Original line number	Diff line number	Diff line
		/*
		* Copyright 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 <utility>
		#include <variant>

		#include <ftl/details/match.h>

		namespace android::ftl {

		// Concise alternative to std::visit that compiles to branches rather than a dispatch table. For
		// std::variant<T0, ..., TN> where N is small, this is slightly faster since the branches can be
		// inlined unlike the function pointers.
		//
		// using namespace std::chrono;
		// std::variant<seconds, minutes, hours> duration = 119min;
		//
		// // Mutable match.
		// ftl::match(duration, [](auto& d) { ++d; });
		//
		// // Immutable match. Exhaustive due to minutes being convertible to seconds.
		// assert("2 hours"s ==
		// ftl::match(duration,
		// [](const seconds& s) {
		// const auto h = duration_cast<hours>(s);
		// return std::to_string(h.count()) + " hours"s;
		// },
		// [](const hours& h) { return std::to_string(h.count() / 24) + " days"s; }));
		//
		template <typename... Ts, typename... Ms>
		decltype(auto) match(std::variant<Ts...>& variant, Ms&&... matchers) {
		const auto matcher = details::Matcher{std::forward<Ms>(matchers)...};
		static_assert(details::is_exhaustive_match_v<decltype(matcher), Ts&...>, "Non-exhaustive match");

		return details::Match<Ts...>::match(variant, matcher);
		}

		template <typename... Ts, typename... Ms>
		decltype(auto) match(const std::variant<Ts...>& variant, Ms&&... matchers) {
		const auto matcher = details::Matcher{std::forward<Ms>(matchers)...};
		static_assert(details::is_exhaustive_match_v<decltype(matcher), const Ts&...>,
		"Non-exhaustive match");

		return details::Match<Ts...>::match(variant, matcher);
		}

		} // namespace android::ftl

libs/ftl/Android.bp

+1 −0

Original line number	Diff line number	Diff line
		@@ -21,6 +21,7 @@ cc_test {
		"fake_guard_test.cpp",
		"flags_test.cpp",
		"future_test.cpp",
		"match_test.cpp",
		"optional_test.cpp",
		"small_map_test.cpp",
		"small_vector_test.cpp",

libs/ftl/match_test.cpp

0 → 100644

+48 −0

Original line number	Diff line number	Diff line
		/*
		* Copyright 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.
		*/

		#include <ftl/match.h>
		#include <gtest/gtest.h>

		#include <chrono>
		#include <string>
		#include <variant>

		namespace android::test {

		// Keep in sync with example usage in header file.
		TEST(Match, Example) {
		using namespace std::chrono;
		using namespace std::chrono_literals;
		using namespace std::string_literals;

		std::variant<seconds, minutes, hours> duration = 119min;

		// Mutable match.
		ftl::match(duration, [](auto& d) { ++d; });

		// Immutable match. Exhaustive due to minutes being convertible to seconds.
		EXPECT_EQ("2 hours"s,
		ftl::match(
		duration,
		[](const seconds& s) {
		const auto h = duration_cast<hours>(s);
		return std::to_string(h.count()) + " hours"s;
		},
		[](const hours& h) { return std::to_string(h.count() / 24) + " days"s; }));
		}

		} // namespace android::test

libs/ui/DeviceProductInfo.cpp

+24 −25

Original line number	Diff line number	Diff line
		@@ -14,44 +14,43 @@
		* limitations under the License.
		*/

		#include <ftl/match.h>
		#include <ui/DeviceProductInfo.h>

		#include <android-base/stringprintf.h>
		#include <utils/Log.h>

		#define RETURN_IF_ERROR(op) \
		if (const status_t status = (op); status != OK) return status;

		namespace android {

		std::string to_string(const DeviceProductInfo& info) {
		using base::StringAppendF;

		void DeviceProductInfo::dump(std::string& result) const {
		StringAppendF(&result, "{name=\"%s\", ", name.c_str());
		StringAppendF(&result, "manufacturerPnpId=%s, ", manufacturerPnpId.data());
		StringAppendF(&result, "productId=%s, ", productId.c_str());

		if (const auto* model = std::get_if<ModelYear>(&manufactureOrModelDate)) {
		StringAppendF(&result, "modelYear=%u, ", model->year);
		} else if (const auto* manufactureWeekAndYear =
		std::get_if<ManufactureWeekAndYear>(&manufactureOrModelDate)) {
		StringAppendF(&result, "manufactureWeek=%u, ", manufactureWeekAndYear->week);
		StringAppendF(&result, "manufactureYear=%d, ", manufactureWeekAndYear->year);
		} else if (const auto* manufactureYear =
		std::get_if<ManufactureYear>(&manufactureOrModelDate)) {
		StringAppendF(&result, "manufactureYear=%d, ", manufactureYear->year);
		} else {
		ALOGE("Unknown alternative for variant DeviceProductInfo::ManufactureOrModelDate");
		}
		std::string result;
		StringAppendF(&result, "{name=\"%s\", ", info.name.c_str());
		StringAppendF(&result, "manufacturerPnpId=%s, ", info.manufacturerPnpId.data());
		StringAppendF(&result, "productId=%s, ", info.productId.c_str());

		ftl::match(
		info.manufactureOrModelDate,
		[&](DeviceProductInfo::ModelYear model) {
		StringAppendF(&result, "modelYear=%u, ", model.year);
		},
		[&](DeviceProductInfo::ManufactureWeekAndYear manufacture) {
		StringAppendF(&result, "manufactureWeek=%u, ", manufacture.week);
		StringAppendF(&result, "manufactureYear=%d, ", manufacture.year);
		},
		[&](DeviceProductInfo::ManufactureYear manufacture) {
		StringAppendF(&result, "manufactureYear=%d, ", manufacture.year);
		});

		result.append("relativeAddress=[");
		for (size_t i = 0; i < relativeAddress.size(); i++) {
		for (size_t i = 0; i < info.relativeAddress.size(); i++) {
		if (i != 0) {
		result.append(", ");
		}
		StringAppendF(&result, "%u", relativeAddress[i]);
		StringAppendF(&result, "%u", info.relativeAddress[i]);
		}
		result.append("]}");
		return result;
		}

		} // namespace android