1 /* <!-- copyright */
2 /*
3 * aria2 - The high speed download utility
4 *
5 * Copyright (C) 2006 Tatsuhiro Tsujikawa
6 *
7 * This program is free software; you can redistribute it and/or modify
8 * it under the terms of the GNU General Public License as published by
9 * the Free Software Foundation; either version 2 of the License, or
10 * (at your option) any later version.
11 *
12 * This program is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 * GNU General Public License for more details.
16 *
17 * You should have received a copy of the GNU General Public License
18 * along with this program; if not, write to the Free Software
19 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
20 *
21 * In addition, as a special exception, the copyright holders give
22 * permission to link the code of portions of this program with the
23 * OpenSSL library under certain conditions as described in each
24 * individual source file, and distribute linked combinations
25 * including the two.
26 * You must obey the GNU General Public License in all respects
27 * for all of the code used other than OpenSSL. If you modify
28 * file(s) with this exception, you may extend this exception to your
29 * version of the file(s), but you are not obligated to do so. If you
30 * do not wish to do so, delete this exception statement from your
31 * version. If you delete this exception statement from all source
32 * files in the program, then also delete it here.
33 */
34 /* copyright --> */
35 #ifndef D_ARRAY_FUN_H
36 #define D_ARRAY_FUN_H
37
38 #include "common.h"
39
40 #include <cstdlib>
41 #include <functional>
42
43 namespace aria2 {
44
arraySize(T (&)[N])45 template <typename T, size_t N> constexpr size_t arraySize(T (&)[N])
46 {
47 return N;
48 }
49
50 template <typename T, size_t N> class array_wrapper {
51 private:
52 T array_[N];
53
54 public:
55 array_wrapper() = default;
56
57 operator T*() { return array_; }
58
59 operator const T*() const { return array_; }
60
size()61 size_t size() const { return N; }
62 };
63
64 // Expression Template for array
65
66 namespace expr {
67
68 template <typename L, typename R, typename Op> struct BinExpr {
69 typedef typename Op::result_type value_type;
70
BinExprBinExpr71 BinExpr(L lhs, R rhs, Op op)
72 : lhs(std::move(lhs)), rhs(std::move(rhs)), op(std::move(op))
73 {
74 }
75
76 value_type operator[](size_t i) const { return op(lhs[i], rhs[i]); }
77
78 L lhs;
79 R rhs;
80 Op op;
81 };
82
83 template <typename L, typename R,
84 typename Op = std::bit_and<typename L::value_type>>
85 BinExpr<L, R, Op> operator&(L lhs, R rhs)
86 {
87 return BinExpr<L, R, Op>(std::forward<L>(lhs), std::forward<R>(rhs), Op());
88 }
89
90 template <typename L, typename R,
91 typename Op = std::bit_or<typename L::value_type>>
92 BinExpr<L, R, Op> operator|(L lhs, R rhs)
93 {
94 return BinExpr<L, R, Op>(std::forward<L>(lhs), std::forward<R>(rhs), Op());
95 }
96
97 template <typename Arg, typename Op> struct UnExpr {
98 typedef typename Op::result_type value_type;
99
UnExprUnExpr100 UnExpr(Arg arg, Op op) : arg(std::move(arg)), op(std::move(op)) {}
101
102 value_type operator[](size_t i) const { return op(arg[i]); }
103
104 Arg arg;
105 Op op;
106 };
107
108 template <typename T> struct bit_neg : std::function<T(T)> {
operatorbit_neg109 T operator()(T t) const { return ~t; }
110 };
111
112 template <typename Arg, typename Op = bit_neg<typename Arg::value_type>>
113 UnExpr<Arg, Op> operator~(Arg arg)
114 {
115 return UnExpr<Arg, Op>(std::forward<Arg>(arg), Op());
116 }
117
118 template <typename T> struct Array {
119 typedef T value_type;
120
ArrayArray121 Array(T* t) : t(t) {}
122
123 T operator[](size_t i) const { return t[i]; }
124
125 T* t;
126 };
127
array(T * t)128 template <typename T> Array<T> array(T* t) { return Array<T>(t); }
129
130 } // namespace expr
131
132 } // namespace aria2
133
134 #endif // D_ARRAY_FUN_H
135