FTL: Add std::variant matcher (f2fdb56c) · 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