/src/bloaty/third_party/abseil-cpp/absl/functional/overload.h

Source
// Copyright 2023 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.
//
// -----------------------------------------------------------------------------
// File: overload.h
// -----------------------------------------------------------------------------
//
// `absl::Overload` is a functor that provides overloads based on the functors
// with which it is created. This can, for example, be used to locally define an
// anonymous visitor type for `std::visit` inside a function using lambdas.
//
// Before using this function, consider whether named function overloads would
// be a better design.
//
// Example:
//
//     std::variant<std::string, int32_t, int64_t> v(int32_t{1});
//     const size_t result =
//         std::visit(absl::Overload{
//                        [](const std::string& s) { return s.size(); },
//                        [](const auto& s) { return sizeof(s); },
//                    },
//                    v);
//     assert(result == 4);
//

#ifndef ABSL_FUNCTIONAL_OVERLOAD_H_
#define ABSL_FUNCTIONAL_OVERLOAD_H_

#include "absl/base/config.h"
#include "absl/meta/type_traits.h"

namespace absl {
ABSL_NAMESPACE_BEGIN

template <typename... T>
struct Overload final : T... {
  using T::operator()...;

  // For historical reasons we want to support use that looks like a function
  // call:
  //
  //     absl::Overload(lambda_1, lambda_2)
  //
  // This works automatically in C++20 because we have support for parenthesized
  // aggregate initialization. Before then we must provide a constructor that
  // makes this work.
  //
  constexpr explicit Overload(T... ts) : T(std::move(ts))... {}
};

// Before C++20, which added support for CTAD for aggregate types, we must also
// teach the compiler how to deduce the template arguments for Overload.
//
template <typename... T>
Overload(T...) -> Overload<T...>;

ABSL_NAMESPACE_END
}  // namespace absl

#endif  // ABSL_FUNCTIONAL_OVERLOAD_H_

Coverage Report

Created: 2026-03-31 06:32

Line	Count	Source
1		// Copyright 2023 The Abseil Authors.
2		//
3		// Licensed under the Apache License, Version 2.0 (the "License");
4		// you may not use this file except in compliance with the License.
5		// You may obtain a copy of the License at
6		//
7		// https://www.apache.org/licenses/LICENSE-2.0
8		//
9		// Unless required by applicable law or agreed to in writing, software
10		// distributed under the License is distributed on an "AS IS" BASIS,
11		// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12		// See the License for the specific language governing permissions and
13		// limitations under the License.
14		//
15		// -----------------------------------------------------------------------------
16		// File: overload.h
17		// -----------------------------------------------------------------------------
18		//
19		// `absl::Overload` is a functor that provides overloads based on the functors
20		// with which it is created. This can, for example, be used to locally define an
21		// anonymous visitor type for `std::visit` inside a function using lambdas.
22		//
23		// Before using this function, consider whether named function overloads would
24		// be a better design.
25		//
26		// Example:
27		//
28		// std::variant<std::string, int32_t, int64_t> v(int32_t{1});
29		// const size_t result =
30		// std::visit(absl::Overload{
31		// [](const std::string& s) { return s.size(); },
32		// [](const auto& s) { return sizeof(s); },
33		// },
34		// v);
35		// assert(result == 4);
36		//
37
38		#ifndef ABSL_FUNCTIONAL_OVERLOAD_H_
39		#define ABSL_FUNCTIONAL_OVERLOAD_H_