diff options
author | Daniel Baumann <daniel.baumann@progress-linux.org> | 2024-04-07 17:32:43 +0000 |
---|---|---|
committer | Daniel Baumann <daniel.baumann@progress-linux.org> | 2024-04-07 17:32:43 +0000 |
commit | 6bf0a5cb5034a7e684dcc3500e841785237ce2dd (patch) | |
tree | a68f146d7fa01f0134297619fbe7e33db084e0aa /security/sandbox/chromium/base/tuple.h | |
parent | Initial commit. (diff) | |
download | thunderbird-upstream.tar.xz thunderbird-upstream.zip |
Adding upstream version 1:115.7.0.upstream/1%115.7.0upstream
Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>
Diffstat (limited to 'security/sandbox/chromium/base/tuple.h')
-rw-r--r-- | security/sandbox/chromium/base/tuple.h | 112 |
1 files changed, 112 insertions, 0 deletions
diff --git a/security/sandbox/chromium/base/tuple.h b/security/sandbox/chromium/base/tuple.h new file mode 100644 index 0000000000..58681d515a --- /dev/null +++ b/security/sandbox/chromium/base/tuple.h @@ -0,0 +1,112 @@ +// Copyright (c) 2011 The Chromium Authors. All rights reserved. +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. + +// Use std::tuple as tuple type. This file contains helper functions for +// working with std::tuples. +// The functions DispatchToMethod and DispatchToFunction take a function pointer +// or instance and method pointer, and unpack a tuple into arguments to the +// call. +// +// Example usage: +// // These two methods of creating a Tuple are identical. +// std::tuple<int, const char*> tuple_a(1, "wee"); +// std::tuple<int, const char*> tuple_b = std::make_tuple(1, "wee"); +// +// void SomeFunc(int a, const char* b) { } +// DispatchToFunction(&SomeFunc, tuple_a); // SomeFunc(1, "wee") +// DispatchToFunction( +// &SomeFunc, std::make_tuple(10, "foo")); // SomeFunc(10, "foo") +// +// struct { void SomeMeth(int a, int b, int c) { } } foo; +// DispatchToMethod(&foo, &Foo::SomeMeth, std::make_tuple(1, 2, 3)); +// // foo->SomeMeth(1, 2, 3); + +#ifndef BASE_TUPLE_H_ +#define BASE_TUPLE_H_ + +#include <stddef.h> +#include <tuple> +#include <utility> + +#include "build/build_config.h" + +namespace base { + +// Dispatchers ---------------------------------------------------------------- +// +// Helper functions that call the given method on an object, with the unpacked +// tuple arguments. Notice that they all have the same number of arguments, +// so you need only write: +// DispatchToMethod(object, &Object::method, args); +// This is very useful for templated dispatchers, since they don't need to know +// what type |args| is. + +// Non-Static Dispatchers with no out params. + +template <typename ObjT, typename Method, typename Tuple, size_t... Ns> +inline void DispatchToMethodImpl(const ObjT& obj, + Method method, + Tuple&& args, + std::index_sequence<Ns...>) { + (obj->*method)(std::get<Ns>(std::forward<Tuple>(args))...); +} + +template <typename ObjT, typename Method, typename Tuple> +inline void DispatchToMethod(const ObjT& obj, + Method method, + Tuple&& args) { + constexpr size_t size = std::tuple_size<std::decay_t<Tuple>>::value; + DispatchToMethodImpl(obj, method, std::forward<Tuple>(args), + std::make_index_sequence<size>()); +} + +// Static Dispatchers with no out params. + +template <typename Function, typename Tuple, size_t... Ns> +inline void DispatchToFunctionImpl(Function function, + Tuple&& args, + std::index_sequence<Ns...>) { + (*function)(std::get<Ns>(std::forward<Tuple>(args))...); +} + +template <typename Function, typename Tuple> +inline void DispatchToFunction(Function function, Tuple&& args) { + constexpr size_t size = std::tuple_size<std::decay_t<Tuple>>::value; + DispatchToFunctionImpl(function, std::forward<Tuple>(args), + std::make_index_sequence<size>()); +} + +// Dispatchers with out parameters. + +template <typename ObjT, + typename Method, + typename InTuple, + typename OutTuple, + size_t... InNs, + size_t... OutNs> +inline void DispatchToMethodImpl(const ObjT& obj, + Method method, + InTuple&& in, + OutTuple* out, + std::index_sequence<InNs...>, + std::index_sequence<OutNs...>) { + (obj->*method)(std::get<InNs>(std::forward<InTuple>(in))..., + &std::get<OutNs>(*out)...); +} + +template <typename ObjT, typename Method, typename InTuple, typename OutTuple> +inline void DispatchToMethod(const ObjT& obj, + Method method, + InTuple&& in, + OutTuple* out) { + constexpr size_t in_size = std::tuple_size<std::decay_t<InTuple>>::value; + constexpr size_t out_size = std::tuple_size<OutTuple>::value; + DispatchToMethodImpl(obj, method, std::forward<InTuple>(in), out, + std::make_index_sequence<in_size>(), + std::make_index_sequence<out_size>()); +} + +} // namespace base + +#endif // BASE_TUPLE_H_ |