Commit 4aa9b357 authored by Yedidya Feldblum's avatar Yedidya Feldblum Committed by Facebook Github Bot

Apply clang-format to folly/container/

Summary: [Folly] Apply `clang-format` to `folly/container/`.

Reviewed By: shixiao

Differential Revision: D9672403

fbshipit-source-id: da8e2a10eafcc8a278c002223cfeec055936d0bc
parent 062bb26d
......@@ -30,11 +30,11 @@
namespace folly {
/* using override */ using std::size;
/* using override */ using std::empty;
/* using override */ using std::data;
/* using override */ using std::empty;
/* using override */ using std::size;
}
} // namespace folly
#else
......@@ -84,6 +84,6 @@ constexpr E const* data(std::initializer_list<E> il) noexcept {
return il.begin();
}
}
} // namespace folly
#endif
......@@ -115,32 +115,28 @@ class EvictingCacheMap {
// iterator base : returns TPair on dereference
template <typename Value, typename TIterator>
class iterator_base
: public boost::iterator_adaptor<iterator_base<Value, TIterator>,
TIterator,
Value,
boost::bidirectional_traversal_tag > {
class iterator_base : public boost::iterator_adaptor<
iterator_base<Value, TIterator>,
TIterator,
Value,
boost::bidirectional_traversal_tag> {
public:
iterator_base() {
}
iterator_base() {}
explicit iterator_base(TIterator it)
: iterator_base::iterator_adaptor_(it) {
}
: iterator_base::iterator_adaptor_(it) {}
Value& dereference() const {
return this->base_reference()->pr;
}
};
// iterators
typedef iterator_base<
TPair, typename NodeList::iterator> iterator;
typedef iterator_base<
const TPair, typename NodeList::const_iterator> const_iterator;
typedef iterator_base<
TPair, typename NodeList::reverse_iterator> reverse_iterator;
typedef iterator_base<
const TPair,
typename NodeList::const_reverse_iterator> const_reverse_iterator;
typedef iterator_base<TPair, typename NodeList::iterator> iterator;
typedef iterator_base<const TPair, typename NodeList::const_iterator>
const_iterator;
typedef iterator_base<TPair, typename NodeList::reverse_iterator>
reverse_iterator;
typedef iterator_base<const TPair, typename NodeList::const_reverse_iterator>
const_reverse_iterator;
// the default map typedefs
using key_type = TKey;
......@@ -216,7 +212,7 @@ class EvictingCacheMap {
* @param key key to search for
* @return true if exists, false otherwise
*/
bool exists(const TKey& key) const {
bool exists(const TKey& key) const {
return findInIndex(key) != index_.end();
}
......@@ -315,10 +311,11 @@ class EvictingCacheMap {
* a value that already exists.
* @param pruneHook callback to use on eviction (if it occurs).
*/
void set(const TKey& key,
TValue value,
bool promote = true,
PruneHookCall pruneHook = nullptr) {
void set(
const TKey& key,
TValue value,
bool promote = true,
PruneHookCall pruneHook = nullptr) {
auto it = findInIndex(key);
if (it != index_.end()) {
it->pr.second = std::move(value);
......@@ -373,7 +370,6 @@ class EvictingCacheMap {
pruneHook_ = pruneHook;
}
/**
* Prune the minimum of pruneSize and size() from the back of the LRU.
* Will throw if pruneHook throws.
......@@ -481,12 +477,14 @@ class EvictingCacheMap {
* @param pruneHook a custom pruneHook function
* @param failSafe true if exceptions are to ignored, false by default
*/
void pruneWithFailSafeOption(std::size_t pruneSize,
PruneHookCall pruneHook, bool failSafe) {
void pruneWithFailSafeOption(
std::size_t pruneSize,
PruneHookCall pruneHook,
bool failSafe) {
auto& ph = (nullptr == pruneHook) ? pruneHook_ : pruneHook;
for (std::size_t i = 0; i < pruneSize && !lru_.empty(); i++) {
auto *node = &(*lru_.rbegin());
auto* node = &(*lru_.rbegin());
std::unique_ptr<Node> nptr(node);
lru_.erase(lru_.iterator_to(*node));
......
......@@ -140,12 +140,11 @@ FOLLY_CPP14_CONSTEXPR decltype(auto) fetch(Sequence&& sequence, Index&& index);
*
* If you need access to the iterators please write an explicit iterator loop
*/
#define FOR_EACH(i, c) \
if (bool _FE_ANON(s1_) = false) {} else \
for (auto && _FE_ANON(s2_) = (c); \
!_FE_ANON(s1_); _FE_ANON(s1_) = true) \
for (auto i = _FE_ANON(s2_).begin(); \
i != _FE_ANON(s2_).end(); ++i)
#define FOR_EACH(i, c) \
if (bool _FE_ANON(s1_) = false) { \
} else \
for (auto&& _FE_ANON(s2_) = (c); !_FE_ANON(s1_); _FE_ANON(s1_) = true) \
for (auto i = _FE_ANON(s2_).begin(); i != _FE_ANON(s2_).end(); ++i)
/*
* If you just want the element values, please use this (ranges-v3) construct:
......@@ -154,12 +153,11 @@ FOLLY_CPP14_CONSTEXPR decltype(auto) fetch(Sequence&& sequence, Index&& index);
*
* If you need access to the iterators please write an explicit iterator loop
*/
#define FOR_EACH_R(i, c) \
if (bool _FE_ANON(s1_) = false) {} else \
for (auto && _FE_ANON(s2_) = (c); \
!_FE_ANON(s1_); _FE_ANON(s1_) = true) \
for (auto i = _FE_ANON(s2_).rbegin(); \
i != _FE_ANON(s2_).rend(); ++i)
#define FOR_EACH_R(i, c) \
if (bool _FE_ANON(s1_) = false) { \
} else \
for (auto&& _FE_ANON(s2_) = (c); !_FE_ANON(s1_); _FE_ANON(s1_) = true) \
for (auto i = _FE_ANON(s2_).rbegin(); i != _FE_ANON(s2_).rend(); ++i)
/*
* If you just want the element values, please use this construct:
......@@ -169,14 +167,15 @@ FOLLY_CPP14_CONSTEXPR decltype(auto) fetch(Sequence&& sequence, Index&& index);
* If you need access to the iterators please write an explicit iterator loop
* and use a counter variable
*/
#define FOR_EACH_ENUMERATE(count, i, c) \
if (bool _FE_ANON(s1_) = false) {} else \
for (auto && FOR_EACH_state2 = (c); \
!_FE_ANON(s1_); _FE_ANON(s1_) = true) \
if (size_t _FE_ANON(n1_) = 0) {} else \
if (const size_t& count = _FE_ANON(n1_)) {} else \
for (auto i = FOR_EACH_state2.begin(); \
i != FOR_EACH_state2.end(); ++_FE_ANON(n1_), ++i)
#define FOR_EACH_ENUMERATE(count, i, c) \
if (bool _FE_ANON(s1_) = false) { \
} else \
for (auto&& FOR_EACH_state2 = (c); !_FE_ANON(s1_); _FE_ANON(s1_) = true) \
if (size_t _FE_ANON(n1_) = 0) { \
} else if (const size_t& count = _FE_ANON(n1_)) { \
} else \
for (auto i = FOR_EACH_state2.begin(); i != FOR_EACH_state2.end(); \
++_FE_ANON(n1_), ++i)
/**
* If you just want the keys, please use this (ranges-v3) construct:
*
......@@ -195,28 +194,30 @@ FOLLY_CPP14_CONSTEXPR decltype(auto) fetch(Sequence&& sequence, Index&& index);
* }
*
*/
#define FOR_EACH_KV(k, v, c) \
if (unsigned int _FE_ANON(s1_) = 0) {} else \
for (auto && _FE_ANON(s2_) = (c); \
!_FE_ANON(s1_); _FE_ANON(s1_) = 1) \
for (auto _FE_ANON(s3_) = _FE_ANON(s2_).begin(); \
_FE_ANON(s3_) != _FE_ANON(s2_).end(); \
_FE_ANON(s1_) == 2 \
? ((_FE_ANON(s1_) = 0), ++_FE_ANON(s3_)) \
: (_FE_ANON(s3_) = _FE_ANON(s2_).end())) \
for (auto &k = _FE_ANON(s3_)->first; \
!_FE_ANON(s1_); ++_FE_ANON(s1_)) \
for (auto &v = _FE_ANON(s3_)->second; \
!_FE_ANON(s1_); ++_FE_ANON(s1_))
#define FOR_EACH_KV(k, v, c) \
if (unsigned int _FE_ANON(s1_) = 0) { \
} else \
for (auto&& _FE_ANON(s2_) = (c); !_FE_ANON(s1_); _FE_ANON(s1_) = 1) \
for (auto _FE_ANON(s3_) = _FE_ANON(s2_).begin(); \
_FE_ANON(s3_) != _FE_ANON(s2_).end(); \
_FE_ANON(s1_) == 2 ? ((_FE_ANON(s1_) = 0), ++_FE_ANON(s3_)) \
: (_FE_ANON(s3_) = _FE_ANON(s2_).end())) \
for (auto& k = _FE_ANON(s3_)->first; !_FE_ANON(s1_); ++_FE_ANON(s1_)) \
for (auto& v = _FE_ANON(s3_)->second; !_FE_ANON(s1_); ++_FE_ANON(s1_))
namespace folly { namespace detail {
namespace folly {
namespace detail {
// Boost 1.48 lacks has_less, we emulate a subset of it here.
template <typename T, typename U>
class HasLess {
struct BiggerThanChar { char unused[2]; };
template <typename C, typename D> static char test(decltype(C() < D())*);
template <typename, typename> static BiggerThanChar test(...);
struct BiggerThanChar {
char unused[2];
};
template <typename C, typename D>
static char test(decltype(C() < D())*);
template <typename, typename>
static BiggerThanChar test(...);
public:
enum { value = sizeof(test<T, U>(nullptr)) == 1 };
......@@ -260,40 +261,39 @@ notThereYet(T& iter, const U& end) {
template <class T, class U>
typename std::enable_if<
(std::is_arithmetic<T>::value && std::is_arithmetic<U>::value) ||
(std::is_pointer<T>::value && std::is_pointer<U>::value),
bool>::type
(std::is_arithmetic<T>::value && std::is_arithmetic<U>::value) ||
(std::is_pointer<T>::value && std::is_pointer<U>::value),
bool>::type
notThereYet(T& iter, const U& end) {
return iter < end;
}
template <class T, class U>
typename std::enable_if<
!(
(std::is_arithmetic<T>::value && std::is_arithmetic<U>::value) ||
(std::is_pointer<T>::value && std::is_pointer<U>::value)
),
bool>::type
!((std::is_arithmetic<T>::value && std::is_arithmetic<U>::value) ||
(std::is_pointer<T>::value && std::is_pointer<U>::value)),
bool>::type
notThereYet(T& iter, const U& end) {
return iter != end;
}
#endif
/**
* downTo is similar to notThereYet, but in reverse - it helps the
* FOR_EACH_RANGE_R macro.
*/
template <class T, class U>
typename std::enable_if<HasLess<U, T>::value, bool>::type
downTo(T& iter, const U& begin) {
typename std::enable_if<HasLess<U, T>::value, bool>::type downTo(
T& iter,
const U& begin) {
return begin < iter--;
}
template <class T, class U>
typename std::enable_if<!HasLess<U, T>::value, bool>::type
downTo(T& iter, const U& begin) {
typename std::enable_if<!HasLess<U, T>::value, bool>::type downTo(
T& iter,
const U& begin) {
if (iter == begin) {
return false;
}
......@@ -310,9 +310,9 @@ downTo(T& iter, const U& begin) {
*
* for (auto& element : make_iterator_range(begin, end))
*/
#define FOR_EACH_RANGE(i, begin, end) \
for (auto i = (true ? (begin) : (end)); \
::folly::detail::notThereYet(i, (end)); \
#define FOR_EACH_RANGE(i, begin, end) \
for (auto i = (true ? (begin) : (end)); \
::folly::detail::notThereYet(i, (end)); \
++i)
/*
......
......@@ -43,9 +43,13 @@
namespace folly {
template <class InputIt1, class InputIt2, class OutputIt, class Compare>
OutputIt merge(InputIt1 first1, InputIt1 last1,
InputIt2 first2, InputIt2 last2,
OutputIt d_first, Compare comp) {
OutputIt merge(
InputIt1 first1,
InputIt1 last1,
InputIt2 first2,
InputIt2 last2,
OutputIt d_first,
Compare comp) {
for (; first1 != last1; ++d_first) {
if (first2 == last2) {
return std::copy(first1, last1, d_first);
......@@ -62,9 +66,12 @@ OutputIt merge(InputIt1 first1, InputIt1 last1,
}
template <class InputIt1, class InputIt2, class OutputIt>
OutputIt merge(InputIt1 first1, InputIt1 last1,
InputIt2 first2, InputIt2 last2,
OutputIt d_first) {
OutputIt merge(
InputIt1 first1,
InputIt1 last1,
InputIt2 first2,
InputIt2 last2,
OutputIt d_first) {
for (; first1 != last1; ++d_first) {
if (first2 == last2) {
return std::copy(first1, last1, d_first);
......
......@@ -51,7 +51,7 @@ class SparseByteSet {
static constexpr uint16_t kCapacity = 256;
// No init of byte-arrays required!
SparseByteSet() : size_(0) { }
SparseByteSet() : size_(0) {}
/***
* add(byte)
......@@ -79,8 +79,8 @@ class SparseByteSet {
}
private:
uint16_t size_; // can't use uint8_t because it would overflow if all
// possible values were inserted.
uint16_t size_; // can't use uint8_t because it would overflow if all
// possible values were inserted.
uint8_t sparse_[kCapacity];
uint8_t dense_[kCapacity];
};
......
......@@ -23,7 +23,8 @@
namespace folly {
template <class BaseIter> class BitIterator;
template <class BaseIter>
class BitIterator;
namespace bititerator_detail {
......@@ -34,7 +35,7 @@ namespace bititerator_detail {
template <class Ref, class Value>
class BitReference {
public:
BitReference(Ref r, size_t bit) : ref_(r), bit_(bit) { }
BitReference(Ref r, size_t bit) : ref_(r), bit_(bit) {}
/* implicit */ operator bool() const {
return ref_ & (one_ << bit_);
......@@ -76,15 +77,15 @@ struct BitIteratorBase {
typename std::iterator_traits<BaseIter>::value_type>::value,
"BitIterator may only be used with integral types");
typedef boost::iterator_adaptor<
BitIterator<BaseIter>, // Derived
BaseIter, // Base
bool, // Value
boost::use_default, // CategoryOrTraversal
bititerator_detail::BitReference<
typename std::iterator_traits<BaseIter>::reference,
typename std::iterator_traits<BaseIter>::value_type
>, // Reference
ssize_t> type;
BitIterator<BaseIter>, // Derived
BaseIter, // Base
bool, // Value
boost::use_default, // CategoryOrTraversal
bititerator_detail::BitReference<
typename std::iterator_traits<BaseIter>::reference,
typename std::iterator_traits<BaseIter>::value_type>, // Reference
ssize_t>
type;
};
} // namespace bititerator_detail
......
......@@ -65,13 +65,13 @@ TEST(BitIterator, Simple) {
v[0] = 0;
bi = v.begin();
*bi++ = true; // 1
*bi++ = true; // 1
*bi++ = false;
*bi++ = true; // 4
*bi++ = true; // 4
*bi++ = false;
*bi++ = false;
*bi++ = true; // 32
*++bi = true; // 128 (note pre-increment)
*bi++ = true; // 32
*++bi = true; // 128 (note pre-increment)
EXPECT_EQ(165, v[0]);
}
......
......@@ -77,7 +77,6 @@ TEST(EvictingCacheMap, SanityTest) {
EXPECT_FALSE(map.exists(1));
}
TEST(EvictingCacheMap, PruneTest) {
EvictingCacheMap<int, int> map(0);
EXPECT_EQ(0, map.size());
......@@ -309,7 +308,7 @@ TEST(EvictingCacheMap, SetClearSize) {
TEST(EvictingCacheMap, DestructorInvocationTest) {
struct SumInt {
SumInt(int val_, int* ref_) : val(val_), ref(ref_) { }
SumInt(int val_, int* ref_) : val(val_), ref(ref_) {}
~SumInt() {
*ref += val;
}
......@@ -535,7 +534,7 @@ TEST(EvictingCacheMap, FindTest) {
EXPECT_EQ(i, it->first);
EXPECT_EQ(i, it->second);
} else {
EXPECT_TRUE( map.find(i) == map.end());
EXPECT_TRUE(map.find(i) == map.end());
}
}
for (int i = nItems * 2 - 1; i >= 0; i--) {
......
......@@ -280,9 +280,11 @@ BENCHMARK(ForEachKVNoMacroAssign, iters) {
int sumKeys = 0;
std::string sumValues;
BENCHMARK_SUSPEND { setupBenchmark(iters); }
BENCHMARK_SUSPEND {
setupBenchmark(iters);
}
FOR_EACH(iter, bmMap) {
FOR_EACH (iter, bmMap) {
const int k = iter->first;
const std::string v = iter->second;
sumKeys += k;
......@@ -294,9 +296,11 @@ BENCHMARK(ForEachKVNoMacroNoAssign, iters) {
int sumKeys = 0;
std::string sumValues;
BENCHMARK_SUSPEND { setupBenchmark(iters); }
BENCHMARK_SUSPEND {
setupBenchmark(iters);
}
FOR_EACH(iter, bmMap) {
FOR_EACH (iter, bmMap) {
sumKeys += iter->first;
sumValues += iter->second;
}
......@@ -306,7 +310,9 @@ BENCHMARK(ForEachKVMacro, iters) {
int sumKeys = 0;
std::string sumValues;
BENCHMARK_SUSPEND { setupBenchmark(iters); }
BENCHMARK_SUSPEND {
setupBenchmark(iters);
}
FOR_EACH_KV (k, v, bmMap) {
sumKeys += k;
......
......@@ -323,9 +323,7 @@ TEST(ForEach, FetchTestPreferIterator) {
TEST(Foreach, ForEachRvalue) {
const char* const hello = "hello";
int n = 0;
FOR_EACH(it, std::string(hello)) {
++n;
}
FOR_EACH (it, std::string(hello)) { ++n; }
EXPECT_EQ(strlen(hello), n);
FOR_EACH_R (it, std::string(hello)) {
--n;
......@@ -337,10 +335,8 @@ TEST(Foreach, ForEachRvalue) {
TEST(Foreach, ForEachNested) {
const std::string hello = "hello";
size_t n = 0;
FOR_EACH(i, hello) {
FOR_EACH(j, hello) {
++n;
}
FOR_EACH (i, hello) {
FOR_EACH (j, hello) { ++n; }
}
auto len = hello.size();
EXPECT_EQ(len * len, n);
......@@ -421,7 +417,7 @@ TEST(Foreach, ForEachEnumerate) {
sumIter += *iter;
++numIterations;
}
EXPECT_EQ(sumAA, 3); // 0 + 1 + 2
EXPECT_EQ(sumAA, 3); // 0 + 1 + 2
EXPECT_EQ(sumIter, 9); // 1 + 3 + 5
EXPECT_EQ(numIterations, 3);
}
......@@ -443,7 +439,7 @@ TEST(Foreach, ForEachEnumerateBreak) {
break;
}
}
EXPECT_EQ(sumAA, 1); // 0 + 1
EXPECT_EQ(sumAA, 1); // 0 + 1
EXPECT_EQ(sumIter, 3); // 1 + 2
EXPECT_EQ(numIterations, 2);
}
......@@ -451,25 +447,17 @@ TEST(Foreach, ForEachEnumerateBreak) {
TEST(Foreach, ForEachRangeR) {
int sum = 0;
FOR_EACH_RANGE_R (i, 0, 0) {
sum += i;
}
FOR_EACH_RANGE_R (i, 0, 0) { sum += i; }
EXPECT_EQ(0, sum);
FOR_EACH_RANGE_R (i, 0, -1) {
sum += i;
}
FOR_EACH_RANGE_R (i, 0, -1) { sum += i; }
EXPECT_EQ(0, sum);
FOR_EACH_RANGE_R (i, 0, 5) {
sum += i;
}
FOR_EACH_RANGE_R (i, 0, 5) { sum += i; }
EXPECT_EQ(10, sum);
std::list<int> lst = { 0, 1, 2, 3, 4 };
std::list<int> lst = {0, 1, 2, 3, 4};
sum = 0;
FOR_EACH_RANGE_R (i, lst.begin(), lst.end()) {
sum += *i;
}
FOR_EACH_RANGE_R (i, lst.begin(), lst.end()) { sum += *i; }
EXPECT_EQ(10, sum);
}
......@@ -26,9 +26,7 @@ TEST(MergeTest, NonOverlapping) {
std::vector<int> b = {1, 3, 5, 7};
std::vector<int> c;
folly::merge(a.begin(), a.end(),
b.begin(), b.end(),
std::back_inserter(c));
folly::merge(a.begin(), a.end(), b.begin(), b.end(), std::back_inserter(c));
EXPECT_EQ(8, c.size());
for (size_t i = 0; i < 8; ++i) {
EXPECT_EQ(i, c[i]);
......@@ -40,9 +38,8 @@ TEST(MergeTest, OverlappingInSingleInputRange) {
std::vector<std::pair<int, int>> b = {{2, 2}, {3, 3}};
std::map<int, int> c;
folly::merge(a.begin(), a.end(),
b.begin(), b.end(),
std::inserter(c, c.begin()));
folly::merge(
a.begin(), a.end(), b.begin(), b.end(), std::inserter(c, c.begin()));
EXPECT_EQ(3, c.size());
// First value is inserted, second is not
......@@ -57,9 +54,8 @@ TEST(MergeTest, OverlappingInDifferentInputRange) {
std::vector<std::pair<int, int>> b = {{0, 2}, {3, 3}};
std::map<int, int> c;
folly::merge(a.begin(), a.end(),
b.begin(), b.end(),
std::inserter(c, c.begin()));
folly::merge(
a.begin(), a.end(), b.begin(), b.end(), std::inserter(c, c.begin()));
EXPECT_EQ(3, c.size());
// Value from a is inserted, value from b is not.
......
......@@ -45,6 +45,7 @@ class BitSetWrapper {
inline bool contains(uint8_t i) {
return rep_[i];
}
private:
bitset<256> rep_;
};
......@@ -63,6 +64,7 @@ class BoolArraySet {
inline bool contains(uint8_t i) {
return rep_[i];
}
private:
bool rep_[256];
};
......@@ -81,70 +83,66 @@ void rand_bench(int iters, size_t size_add, size_t size_contains) {
seq_contains.push_back(dist(rng));
}
braces.dismissing([&] {
while (iters--) {
Coll coll;
for (auto b : seq_add) {
coll.add(b);
}
bool q {};
for (auto b : seq_contains) {
q ^= coll.contains(b);
}
doNotOptimizeAway(q);
while (iters--) {
Coll coll;
for (auto b : seq_add) {
coll.add(b);
}
bool q{};
for (auto b : seq_contains) {
q ^= coll.contains(b);
}
doNotOptimizeAway(q);
}
});
}
void setup_rand_bench() {
vector<pair<size_t, size_t>> rand_bench_params = {
{4, 4},
{4, 16},
{4, 64},
{4, 256},
{16, 4},
{16, 16},
{16, 64},
{16, 256},
{64, 4},
{64, 16},
{64, 64},
{64, 256},
{256, 4},
{256, 16},
{256, 64},
{256, 256},
{4, 4},
{4, 16},
{4, 64},
{4, 256},
{16, 4},
{16, 16},
{16, 64},
{16, 256},
{64, 4},
{64, 16},
{64, 64},
{64, 256},
{256, 4},
{256, 16},
{256, 64},
{256, 256},
};
for (auto kvp : rand_bench_params) {
size_t size_add, size_contains;
tie(size_add, size_contains) = kvp;
addBenchmark(
__FILE__,
sformat("bitset_rand_bench({}, {})",
size_add, size_contains).c_str(),
sformat("bitset_rand_bench({}, {})", size_add, size_contains).c_str(),
[=](int iters) {
rand_bench<BitSetWrapper>(iters, size_add, size_contains);
return iters;
});
addBenchmark(
__FILE__,
sformat("%bool_array_set_rand_bench({}, {})",
size_add, size_contains).c_str(),
sformat("%bool_array_set_rand_bench({}, {})", size_add, size_contains)
.c_str(),
[=](int iters) {
rand_bench<BoolArraySet>(iters, size_add, size_contains);
return iters;
});
addBenchmark(
__FILE__,
sformat("%sparse_byte_set_rand_bench({}, {})",
size_add, size_contains).c_str(),
sformat("%sparse_byte_set_rand_bench({}, {})", size_add, size_contains)
.c_str(),
[=](int iters) {
rand_bench<SparseByteSet>(iters, size_add, size_contains);
return iters;
});
addBenchmark(
__FILE__,
"-",
[](int) { return 0; });
addBenchmark(__FILE__, "-", [](int) { return 0; });
}
}
......
Markdown is supported
0%
or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment