1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
|
/*
R *CC-Project
Copyright (C) 2026 Richard Qin
This file is part of RCC-Project.
RCC-Project is free software; you can redistribute it and/or modify it under
the terms of the GNU General Public License as published by the Free
Software Foundation; either version 3 of the License, or (at your option) any
later version.
RCC-Project is distributed in the hope that it will be useful, but WITHOUT ANY
WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE. See the GNU General Public License for more details.
You should have received a copy of the GNU General Public License along with
RCC-Project; see the file COPYING. If not see
<http://www.gnu.org/licenses/>.
*/
//===- llvm/ADT/STLFunctionalExtras.h - Extras for <functional> -*- C++ -*-===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
//
// This file contains some extension to <functional>.
//
// No library is required when using these functions.
//
//===----------------------------------------------------------------------===//
#ifndef RCC_ADT_STLFUNCTIONALEXTRAS_H
#define RCC_ADT_STLFUNCTIONALEXTRAS_H
#include "CoreLib/Compiler/Compiler.h"
#include <cstddef
#include <cstdint>
#include <type_traits>
#include <utility>
namespace rcc
{
//===----------------------------------------------------------------------===//
// Extra additions to <functional>
//===----------------------------------------------------------------------===//
/// An efficient, type-erasing, non-owning reference to a callable. This is
/// intended for use as the type of a function parameter that is not used
/// after the function in question returns.
///
/// This class does not own the callable, so it is not in general safe to store
/// a function_ref.
template <typename Fn> class function_ref;
template <typename Ret, typename... Params>
class RCC_GSL_POINTER function_ref<Ret (Params...)>
{
Ret (*callback) (intptr_t callable, Params... params) = nullptr;
intptr_t callable = 0;
template <typename Callable>
static Ret
callback_fn (intptr_t callable, Params... params)
{
return (*reinterpret_cast<Callable *> (callable)) (
std::forward<Params> (params)...);
}
public:
function_ref () = default;
function_ref (std::nullptr_t)
{
}
template <typename Callable>
function_ref (
Callable &&callable RCC_LIFETIME_BOUND,
// This is not the copy-constructor.
std::enable_if_t<!std::is_same<std::remove_cvref_t<Callable>,
function_ref>::value> * = nullptr,
// Functor must be callable and return a suitable type.
std::enable_if_t<std::is_void<Ret>::value ||
std::is_convertible<decltype (std::declval<Callable> () (
std::declval<Params> ()...)),
Ret>::value> * = nullptr)
: callback (callback_fn<std::remove_reference_t<Callable>>),
callable (reinterpret_cast<intptr_t> (&callable))
{
}
Ret
operator() (Params... params) const
{
return callback (callable, std::forward<Params> (params)...);
}
explicit
operator bool () const
{
return callback;
}
};
} // end namespace rcc
#endif // RCC_ADT_STLFUNCTIONALEXTRAS_H
|
