diff --git a/absl/utility/BUILD.bazel b/absl/utility/BUILD.bazel index 2a4a4fa0e4c..773f9496886 100644 --- a/absl/utility/BUILD.bazel +++ b/absl/utility/BUILD.bazel @@ -18,7 +18,6 @@ load( "//absl:copts/configure_copts.bzl", "ABSL_DEFAULT_COPTS", "ABSL_DEFAULT_LINKOPTS", - "ABSL_TEST_COPTS", ) package( @@ -40,23 +39,7 @@ cc_library( copts = ABSL_DEFAULT_COPTS, linkopts = ABSL_DEFAULT_LINKOPTS, deps = [ - "//absl/base:base_internal", "//absl/base:config", "//absl/meta:type_traits", ], ) - -cc_test( - name = "utility_test", - srcs = ["utility_test.cc"], - copts = ABSL_TEST_COPTS, - linkopts = ABSL_DEFAULT_LINKOPTS, - deps = [ - ":utility", - "//absl/base:core_headers", - "//absl/memory", - "//absl/strings", - "@googletest//:gtest", - "@googletest//:gtest_main", - ], -) diff --git a/absl/utility/CMakeLists.txt b/absl/utility/CMakeLists.txt index 865b758f23e..8ac87bce8df 100644 --- a/absl/utility/CMakeLists.txt +++ b/absl/utility/CMakeLists.txt @@ -22,23 +22,7 @@ absl_cc_library( COPTS ${ABSL_DEFAULT_COPTS} DEPS - absl::base_internal absl::config absl::type_traits PUBLIC ) - -absl_cc_test( - NAME - utility_test - SRCS - "utility_test.cc" - COPTS - ${ABSL_TEST_COPTS} - DEPS - absl::utility - absl::core_headers - absl::memory - absl::strings - GTest::gmock_main -) diff --git a/absl/utility/utility.h b/absl/utility/utility.h index a49030e2a2d..4637b03df15 100644 --- a/absl/utility/utility.h +++ b/absl/utility/utility.h @@ -11,21 +11,6 @@ // 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. -// -// This header file contains C++14 versions of standard header -// abstractions available within C++17, and are designed to be drop-in -// replacement for code compliant with C++14 and C++17. -// -// The following abstractions are defined: -// -// * apply == std::apply -// * exchange == std::exchange -// * make_from_tuple == std::make_from_tuple -// -// References: -// -// https://en.cppreference.com/w/cpp/utility/apply -// http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2013/n3658.html #ifndef ABSL_UTILITY_UTILITY_H_ #define ABSL_UTILITY_UTILITY_H_ @@ -36,6 +21,8 @@ #include #include "absl/base/config.h" + +// TODO(b/290784225): Include what you use cleanup required. #include "absl/meta/type_traits.h" namespace absl { @@ -45,6 +32,7 @@ ABSL_NAMESPACE_BEGIN // abstractions for platforms that had not yet provided them. Those // platforms are no longer supported. New code should simply use the // the ones from std directly. +using std::apply; using std::exchange; using std::forward; using std::in_place; @@ -56,99 +44,11 @@ using std::in_place_type_t; using std::index_sequence; using std::index_sequence_for; using std::integer_sequence; +using std::make_from_tuple; using std::make_index_sequence; using std::make_integer_sequence; using std::move; -namespace utility_internal { -// Helper method for expanding tuple into a called method. -template -auto apply_helper(Functor&& functor, Tuple&& t, index_sequence) - -> decltype(std::invoke(absl::forward(functor), - std::get(absl::forward(t))...)) { - return std::invoke(absl::forward(functor), - std::get(absl::forward(t))...); -} -} // namespace utility_internal - -// apply -// -// Invokes a Callable using elements of a tuple as its arguments. -// Each element of the tuple corresponds to an argument of the call (in order). -// Both the Callable argument and the tuple argument are perfect-forwarded. -// For member-function Callables, the first tuple element acts as the `this` -// pointer. `absl::apply` is designed to be a drop-in replacement for C++17's -// `std::apply`. Unlike C++17's `std::apply`, this is not currently `constexpr`. -// -// Example: -// -// class Foo { -// public: -// void Bar(int); -// }; -// void user_function1(int, std::string); -// void user_function2(std::unique_ptr); -// auto user_lambda = [](int, int) {}; -// -// int main() -// { -// std::tuple tuple1(42, "bar"); -// // Invokes the first user function on int, std::string. -// absl::apply(&user_function1, tuple1); -// -// std::tuple> tuple2(absl::make_unique()); -// // Invokes the user function that takes ownership of the unique -// // pointer. -// absl::apply(&user_function2, std::move(tuple2)); -// -// auto foo = absl::make_unique(); -// std::tuple tuple3(foo.get(), 42); -// // Invokes the method Bar on foo with one argument, 42. -// absl::apply(&Foo::Bar, tuple3); -// -// std::tuple tuple4(8, 9); -// // Invokes a lambda. -// absl::apply(user_lambda, tuple4); -// } -template -auto apply(Functor&& functor, Tuple&& t) - -> decltype(utility_internal::apply_helper( - absl::forward(functor), absl::forward(t), - absl::make_index_sequence::type>::value>{})) { - return utility_internal::apply_helper( - absl::forward(functor), absl::forward(t), - absl::make_index_sequence::type>::value>{}); -} - -namespace utility_internal { -template -T make_from_tuple_impl(Tuple&& tup, absl::index_sequence) { - return T(std::get(std::forward(tup))...); -} -} // namespace utility_internal - -// make_from_tuple -// -// Given the template parameter type `T` and a tuple of arguments -// `std::tuple(arg0, arg1, ..., argN)` constructs an object of type `T` as if by -// calling `T(arg0, arg1, ..., argN)`. -// -// Example: -// -// std::tuple args("hello world", 5); -// auto s = absl::make_from_tuple(args); -// assert(s == "hello"); -// -template -constexpr T make_from_tuple(Tuple&& tup) { - return utility_internal::make_from_tuple_impl( - std::forward(tup), - absl::make_index_sequence< - std::tuple_size>::value>{}); -} - ABSL_NAMESPACE_END } // namespace absl diff --git a/absl/utility/utility_test.cc b/absl/utility/utility_test.cc deleted file mode 100644 index c540b22f40c..00000000000 --- a/absl/utility/utility_test.cc +++ /dev/null @@ -1,239 +0,0 @@ -// Copyright 2022 The Abseil Authors. -// -// 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 -// -// https://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 "absl/utility/utility.h" - -#include -#include -#include -#include -#include -#include -#include - -#include "gmock/gmock.h" -#include "gtest/gtest.h" -#include "absl/base/attributes.h" -#include "absl/memory/memory.h" -#include "absl/strings/str_cat.h" - -namespace { - -using ::testing::ElementsAre; -using ::testing::Pointee; -using ::testing::StaticAssertTypeEq; - - -int Function(int a, int b) { return a - b; } - -int Sink(std::unique_ptr p) { return *p; } - -std::unique_ptr Factory(int n) { return absl::make_unique(n); } - -void NoOp() {} - -struct ConstFunctor { - int operator()(int a, int b) const { return a - b; } -}; - -struct MutableFunctor { - int operator()(int a, int b) { return a - b; } -}; - -struct EphemeralFunctor { - EphemeralFunctor() {} - EphemeralFunctor(const EphemeralFunctor&) {} - EphemeralFunctor(EphemeralFunctor&&) {} - int operator()(int a, int b) && { return a - b; } -}; - -struct OverloadedFunctor { - OverloadedFunctor() {} - OverloadedFunctor(const OverloadedFunctor&) {} - OverloadedFunctor(OverloadedFunctor&&) {} - template - std::string operator()(const Args&... args) & { - return absl::StrCat("&", args...); - } - template - std::string operator()(const Args&... args) const& { - return absl::StrCat("const&", args...); - } - template - std::string operator()(const Args&... args) && { - return absl::StrCat("&&", args...); - } -}; - -struct Class { - int Method(int a, int b) { return a - b; } - int ConstMethod(int a, int b) const { return a - b; } - - int member; -}; - -struct FlipFlop { - int ConstMethod() const { return member; } - FlipFlop operator*() const { return {-member}; } - - int member; -}; - -TEST(ApplyTest, Function) { - EXPECT_EQ(1, absl::apply(Function, std::make_tuple(3, 2))); - EXPECT_EQ(1, absl::apply(&Function, std::make_tuple(3, 2))); -} - -TEST(ApplyTest, NonCopyableArgument) { - EXPECT_EQ(42, absl::apply(Sink, std::make_tuple(absl::make_unique(42)))); -} - -TEST(ApplyTest, NonCopyableResult) { - EXPECT_THAT(absl::apply(Factory, std::make_tuple(42)), Pointee(42)); -} - -TEST(ApplyTest, VoidResult) { absl::apply(NoOp, std::tuple<>()); } - -TEST(ApplyTest, ConstFunctor) { - EXPECT_EQ(1, absl::apply(ConstFunctor(), std::make_tuple(3, 2))); -} - -TEST(ApplyTest, MutableFunctor) { - MutableFunctor f; - EXPECT_EQ(1, absl::apply(f, std::make_tuple(3, 2))); - EXPECT_EQ(1, absl::apply(MutableFunctor(), std::make_tuple(3, 2))); -} -TEST(ApplyTest, EphemeralFunctor) { - EphemeralFunctor f; - EXPECT_EQ(1, absl::apply(std::move(f), std::make_tuple(3, 2))); - EXPECT_EQ(1, absl::apply(EphemeralFunctor(), std::make_tuple(3, 2))); -} -TEST(ApplyTest, OverloadedFunctor) { - OverloadedFunctor f; - const OverloadedFunctor& cf = f; - - EXPECT_EQ("&", absl::apply(f, std::tuple<>{})); - EXPECT_EQ("& 42", absl::apply(f, std::make_tuple(" 42"))); - - EXPECT_EQ("const&", absl::apply(cf, std::tuple<>{})); - EXPECT_EQ("const& 42", absl::apply(cf, std::make_tuple(" 42"))); - - EXPECT_EQ("&&", absl::apply(std::move(f), std::tuple<>{})); - OverloadedFunctor f2; - EXPECT_EQ("&& 42", absl::apply(std::move(f2), std::make_tuple(" 42"))); -} - -TEST(ApplyTest, ReferenceWrapper) { - ConstFunctor cf; - MutableFunctor mf; - EXPECT_EQ(1, absl::apply(std::cref(cf), std::make_tuple(3, 2))); - EXPECT_EQ(1, absl::apply(std::ref(cf), std::make_tuple(3, 2))); - EXPECT_EQ(1, absl::apply(std::ref(mf), std::make_tuple(3, 2))); -} - -TEST(ApplyTest, MemberFunction) { - std::unique_ptr p(new Class); - std::unique_ptr cp(new Class); - EXPECT_EQ( - 1, absl::apply(&Class::Method, - std::tuple&, int, int>(p, 3, 2))); - EXPECT_EQ(1, absl::apply(&Class::Method, - std::tuple(p.get(), 3, 2))); - EXPECT_EQ( - 1, absl::apply(&Class::Method, std::tuple(*p, 3, 2))); - - EXPECT_EQ( - 1, absl::apply(&Class::ConstMethod, - std::tuple&, int, int>(p, 3, 2))); - EXPECT_EQ(1, absl::apply(&Class::ConstMethod, - std::tuple(p.get(), 3, 2))); - EXPECT_EQ(1, absl::apply(&Class::ConstMethod, - std::tuple(*p, 3, 2))); - - EXPECT_EQ(1, absl::apply(&Class::ConstMethod, - std::tuple&, int, int>( - cp, 3, 2))); - EXPECT_EQ(1, absl::apply(&Class::ConstMethod, - std::tuple(cp.get(), 3, 2))); - EXPECT_EQ(1, absl::apply(&Class::ConstMethod, - std::tuple(*cp, 3, 2))); - - EXPECT_EQ(1, absl::apply(&Class::Method, - std::make_tuple(absl::make_unique(), 3, 2))); - EXPECT_EQ(1, absl::apply(&Class::ConstMethod, - std::make_tuple(absl::make_unique(), 3, 2))); - EXPECT_EQ( - 1, absl::apply(&Class::ConstMethod, - std::make_tuple(absl::make_unique(), 3, 2))); -} - -TEST(ApplyTest, DataMember) { - std::unique_ptr p(new Class{42}); - std::unique_ptr cp(new Class{42}); - EXPECT_EQ( - 42, absl::apply(&Class::member, std::tuple&>(p))); - EXPECT_EQ(42, absl::apply(&Class::member, std::tuple(*p))); - EXPECT_EQ(42, absl::apply(&Class::member, std::tuple(p.get()))); - - absl::apply(&Class::member, std::tuple&>(p)) = 42; - absl::apply(&Class::member, std::tuple(p.get())) = 42; - absl::apply(&Class::member, std::tuple(*p)) = 42; - - EXPECT_EQ(42, absl::apply(&Class::member, - std::tuple&>(cp))); - EXPECT_EQ(42, absl::apply(&Class::member, std::tuple(*cp))); - EXPECT_EQ(42, - absl::apply(&Class::member, std::tuple(cp.get()))); -} - -TEST(ApplyTest, FlipFlop) { - FlipFlop obj = {42}; - // This call could resolve to (obj.*&FlipFlop::ConstMethod)() or - // ((*obj).*&FlipFlop::ConstMethod)(). We verify that it's the former. - EXPECT_EQ(42, absl::apply(&FlipFlop::ConstMethod, std::make_tuple(obj))); - EXPECT_EQ(42, absl::apply(&FlipFlop::member, std::make_tuple(obj))); -} - -TEST(MakeFromTupleTest, String) { - EXPECT_EQ( - absl::make_from_tuple(std::make_tuple("hello world", 5)), - "hello"); -} - -TEST(MakeFromTupleTest, MoveOnlyParameter) { - struct S { - S(std::unique_ptr n, std::unique_ptr m) : value(*n + *m) {} - int value = 0; - }; - auto tup = - std::make_tuple(absl::make_unique(3), absl::make_unique(4)); - auto s = absl::make_from_tuple(std::move(tup)); - EXPECT_EQ(s.value, 7); -} - -TEST(MakeFromTupleTest, NoParameters) { - struct S { - S() : value(1) {} - int value = 2; - }; - EXPECT_EQ(absl::make_from_tuple(std::make_tuple()).value, 1); -} - -TEST(MakeFromTupleTest, Pair) { - EXPECT_EQ( - (absl::make_from_tuple>(std::make_tuple(true, 17))), - std::make_pair(true, 17)); -} - -} // namespace