Merge changes I9b36d834,I3141992c (a45a7991) · Commits · e / os / android_frameworks_native

include/ftl/concat.h

0 → 100644

+84 −0

Original line number	Diff line number	Diff line
		/*
		* Copyright 2021 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 <ftl/details/concat.h>

		namespace android::ftl {

		// Lightweight (not allocating nor sprintf-based) concatenation.
		//
		// std::string_view name = "Volume";
		// ftl::Concat string(ftl::truncated<3>(name), ": ", -3, " dB");
		//
		// assert(string.str() == "Vol: -3 dB");
		// assert(string.c_str()[string.size()] == '\0');
		//
		template <std::size_t, typename... Ts>
		struct Concat;

		template <std::size_t N, typename T, typename... Ts>
		struct Concat<N, T, Ts...> : Concat<N + details::StaticString<T>::N, Ts...> {
		explicit constexpr Concat(T v, Ts... args) { append(v, args...); }

		protected:
		constexpr Concat() = default;

		constexpr void append(T v, Ts... args) {
		using Str = details::StaticString<T>;
		const Str str(v);

		// TODO: Replace with constexpr std::copy in C++20.
		for (auto it = str.view.begin(); it != str.view.end();) {
		this->end_++ = it++;
		}

		using Base = Concat<N + Str::N, Ts...>;
		this->Base::append(args...);
		}
		};

		template <std::size_t N>
		struct Concat<N> {
		static constexpr std::size_t max_size() { return N; }
		constexpr std::size_t size() const { return end_ - buffer_; }

		constexpr const char* c_str() const { return buffer_; }

		constexpr std::string_view str() const {
		// TODO: Replace with {buffer_, end_} in C++20.
		return {buffer_, size()};
		}

		protected:
		constexpr Concat() : end_(buffer_) {}
		constexpr void append() { *end_ = '\0'; }

		char buffer_[N + 1];
		char* end_;
		};

		// Deduction guide.
		template <typename... Ts>
		Concat(Ts&&...) -> Concat<0, Ts...>;

		template <std::size_t N>
		constexpr auto truncated(std::string_view v) {
		return details::Truncated<N>{v};
		}

		} // namespace android::ftl

services/surfaceflinger/Scheduler/SchedulerUtils.cpp→include/ftl/details/concat.h

+62 −0

Original line number	Diff line number	Diff line
		/*
		* Copyright 2018 The Android Open Source Project
		* Copyright 2021 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.
		@@ -14,26 +14,49 @@
		* limitations under the License.
		*/

		#include "SchedulerUtils.h"
		#pragma once

		#include <cinttypes>
		#include <numeric>
		#include <unordered_map>
		#include <vector>
		#include <functional>
		#include <string_view>

		namespace android {
		namespace scheduler {
		#include <ftl/string.h>

		int64_t calculate_median(std::vector<int64_t>* v) {
		if (!v \|\| v->empty()) {
		return 0;
		}
		namespace android::ftl::details {

		size_t n = v->size() / 2;
		nth_element(v->begin(), v->begin() + static_cast<long>(n), v->end());
		return v->at(n);
		}
		template <typename T, typename = void>
		struct StaticString;

		} // namespace scheduler
		} // namespace android
		template <typename T>
		struct StaticString<T, std::enable_if_t<std::is_integral_v<T>>> {
		static constexpr std::size_t N = to_chars_length_v<T>;

		explicit StaticString(T v) : view(to_chars(buffer, v)) {}

		to_chars_buffer_t<T> buffer;
		const std::string_view view;
		};

		template <std::size_t M>
		struct StaticString<const char (&)[M], void> {
		static constexpr std::size_t N = M - 1;

		explicit constexpr StaticString(const char (&str)[M]) : view(str, N) {}

		const std::string_view view;
		};

		template <std::size_t N>
		struct Truncated {
		std::string_view view;
		};

		template <std::size_t M>
		struct StaticString<Truncated<M>, void> {
		static constexpr std::size_t N = M;

		explicit constexpr StaticString(Truncated<M> str) : view(str.view.substr(0, N)) {}

		const std::string_view view;
		};

		} // namespace android::ftl::details

libs/ftl/Android.bp

+1 −0

Original line number	Diff line number	Diff line
		@@ -16,6 +16,7 @@ cc_test {
		srcs: [
		"Flags_test.cpp",
		"cast_test.cpp",
		"concat_test.cpp",
		"enum_test.cpp",
		"future_test.cpp",
		"small_map_test.cpp",

libs/ftl/concat_test.cpp

0 → 100644

+55 −0

Original line number	Diff line number	Diff line
		/*
		* Copyright 2021 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/concat.h>
		#include <gtest/gtest.h>

		namespace android::test {

		// Keep in sync with example usage in header file.
		TEST(Concat, Example) {
		std::string_view name = "Volume";
		ftl::Concat string(ftl::truncated<3>(name), ": ", -3, " dB");

		EXPECT_EQ(string.str(), "Vol: -3 dB");
		EXPECT_EQ(string.c_str()[string.size()], '\0');
		}

		namespace {

		static_assert(ftl::Concat{"foo"}.str() == "foo");
		static_assert(ftl::Concat{ftl::truncated<3>("foobar")}.str() == "foo");

		constexpr ftl::Concat kConcat{"po", "trz", "ebie"};

		static_assert(kConcat.size() == 9);
		static_assert(kConcat.max_size() == 9);
		static_assert(kConcat.str() == "potrzebie");
		static_assert(kConcat.str() == std::string_view(kConcat.c_str()));

		constexpr auto concat() {
		return ftl::Concat{ftl::truncated<1>("v???"), ftl::truncated<2>("ee??"),
		ftl::truncated<3>("ble?"), ftl::truncated<4>("fetz"),
		ftl::truncated<90>("er")};
		}

		static_assert(concat().size() == 12);
		static_assert(concat().max_size() == 100);
		static_assert(concat().str() == "veeblefetzer");
		static_assert(concat().str() == std::string_view(concat().c_str()));

		} // namespace
		} // namespace android::test

services/surfaceflinger/Android.bp

+0 −1

Original line number	Diff line number	Diff line
		@@ -189,7 +189,6 @@ filegroup {
		"Scheduler/MessageQueue.cpp",
		"Scheduler/RefreshRateConfigs.cpp",
		"Scheduler/Scheduler.cpp",
		"Scheduler/SchedulerUtils.cpp",
		"Scheduler/Timer.cpp",
		"Scheduler/VSyncDispatchTimerQueue.cpp",
		"Scheduler/VSyncPredictor.cpp",