Skip to content

Commit 880807f

Browse files
kimlainekimlaine
committed
Switched to using a custom implementation of void_t; changed some helper struct names to be capitalized camel case.
1 parent e0dbb55 commit 880807f

3 files changed

Lines changed: 49 additions & 36 deletions

File tree

‎CHANGES.md‎

Lines changed: 6 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -1,5 +1,11 @@
11
# List of Changes
22

3+
## Version 3.5.4
4+
5+
### Bug fixes
6+
7+
- `std::void_t` was introduced only in C++17; switched to using a custom implementation [(Issue 180)](https://github.com/microsoft/SEAL/issues/180).
8+
39
## Version 3.5.3
410

511
### Bug fixes

‎native/src/seal/util/common.h‎

Lines changed: 17 additions & 10 deletions
Original file line numberDiff line numberDiff line change
@@ -16,37 +16,44 @@ namespace seal
1616
{
1717
namespace util
1818
{
19+
template <typename... Ts>
20+
struct VoidType
21+
{
22+
using type = void;
23+
};
24+
25+
template <typename... Ts>
26+
using seal_void_t = typename VoidType<Ts...>::type;
27+
1928
template <typename T, typename...>
20-
struct is_uint64
29+
struct IsUInt64
2130
: std::conditional<
2231
std::is_integral<T>::value && std::is_unsigned<T>::value && (sizeof(T) == sizeof(std::uint64_t)),
2332
std::true_type, std::false_type>::type
2433
{};
2534

2635
template <typename T, typename U, typename... Rest>
27-
struct is_uint64<T, U, Rest...>
28-
: std::conditional<
29-
is_uint64<T>::value && is_uint64<U, Rest...>::value, std::true_type, std::false_type>::type
36+
struct IsUInt64<T, U, Rest...>
37+
: std::conditional<IsUInt64<T>::value && IsUInt64<U, Rest...>::value, std::true_type, std::false_type>::type
3038
{};
3139

3240
template <typename T, typename... Rest>
33-
constexpr bool is_uint64_v = is_uint64<T, Rest...>::value;
41+
constexpr bool is_uint64_v = IsUInt64<T, Rest...>::value;
3442

3543
template <typename T, typename...>
36-
struct is_uint32
44+
struct IsUInt32
3745
: std::conditional<
3846
std::is_integral<T>::value && std::is_unsigned<T>::value && (sizeof(T) == sizeof(std::uint32_t)),
3947
std::true_type, std::false_type>::type
4048
{};
4149

4250
template <typename T, typename U, typename... Rest>
43-
struct is_uint32<T, U, Rest...>
44-
: std::conditional<
45-
is_uint32<T>::value && is_uint32<U, Rest...>::value, std::true_type, std::false_type>::type
51+
struct IsUInt32<T, U, Rest...>
52+
: std::conditional<IsUInt32<T>::value && IsUInt32<U, Rest...>::value, std::true_type, std::false_type>::type
4653
{};
4754

4855
template <typename T, typename... Rest>
49-
constexpr bool is_uint32_v = is_uint32<T, Rest...>::value;
56+
constexpr bool is_uint32_v = IsUInt32<T, Rest...>::value;
5057

5158
template <
5259
typename T, typename S, typename = std::enable_if_t<std::is_integral<T>::value>,

‎native/src/seal/util/iterator.h‎

Lines changed: 26 additions & 26 deletions
Original file line numberDiff line numberDiff line change
@@ -320,78 +320,78 @@ namespace seal
320320
namespace iterator_internal
321321
{
322322
template <typename Enable, typename... Ts>
323-
struct iter_type;
323+
struct IterType;
324324

325325
template <typename T>
326-
struct iter_type<std::enable_if_t<std::is_arithmetic<T>::value>, T>
326+
struct IterType<std::enable_if_t<std::is_arithmetic<T>::value>, T>
327327
{
328328
using type = SeqIter<T, void>;
329329
};
330330

331331
template <typename T>
332-
struct iter_type<
332+
struct IterType<
333333
std::enable_if_t<std::is_base_of<SEALIterBase, std::decay_t<T>>::value && !std::is_pointer<T>::value>,
334334
T>
335335
{
336336
using type = std::decay_t<T>;
337337
};
338338

339339
template <>
340-
struct iter_type<void, Ciphertext &>
340+
struct IterType<void, Ciphertext &>
341341
{
342342
using type = PolyIter;
343343
};
344344

345345
template <>
346-
struct iter_type<void, const Ciphertext &>
346+
struct IterType<void, const Ciphertext &>
347347
{
348348
using type = ConstPolyIter;
349349
};
350350

351351
template <typename T>
352-
struct iter_type<void, const T *>
352+
struct IterType<void, const T *>
353353
{
354354
using type = PtrIter<const T *>;
355355
};
356356

357357
template <typename T>
358-
struct iter_type<void, T *>
358+
struct IterType<void, T *>
359359
{
360360
using type = PtrIter<T *>;
361361
};
362362

363363
template <typename T>
364-
struct iter_type<void, const T *&>
364+
struct IterType<void, const T *&>
365365
{
366366
using type = PtrIter<const T *>;
367367
};
368368

369369
template <typename T>
370-
struct iter_type<void, T *&>
370+
struct IterType<void, T *&>
371371
{
372372
using type = PtrIter<T *>;
373373
};
374374

375375
template <typename T>
376-
struct iter_type<void, std::vector<T> &>
376+
struct IterType<void, std::vector<T> &>
377377
{
378378
using type = PtrIter<T *>;
379379
};
380380

381381
template <typename T>
382-
struct iter_type<void, const std::vector<T> &>
382+
struct IterType<void, const std::vector<T> &>
383383
{
384384
using type = PtrIter<const T *>;
385385
};
386386

387387
template <typename T>
388-
struct iter_type<void, Pointer<T> &>
388+
struct IterType<void, Pointer<T> &>
389389
{
390390
using type = PtrIter<T *>;
391391
};
392392

393393
template <typename T>
394-
struct iter_type<void, ConstPointer<T> &>
394+
struct IterType<void, ConstPointer<T> &>
395395
{
396396
using type = PtrIter<const T *>;
397397
};
@@ -1589,7 +1589,7 @@ namespace seal
15891589
{
15901590
using type = IterTuple<SEALIter1, SEALIter2>;
15911591
};
1592-
}
1592+
} // namespace iterator_internal
15931593

15941594
template <typename SEALIter, typename... Rest>
15951595
class IterTuple<SEALIter, Rest...> : public SEALIterBase
@@ -1965,17 +1965,17 @@ namespace seal
19651965
struct GetHelperStruct
19661966
{
19671967
template <typename SEALIter, typename... Rest>
1968-
static auto apply(const IterTuple<SEALIter, Rest...> &it)
1968+
static auto Apply(const IterTuple<SEALIter, Rest...> &it)
19691969
{
1970-
return GetHelperStruct<N - 1>::apply(it.rest());
1970+
return GetHelperStruct<N - 1>::Apply(it.rest());
19711971
}
19721972
};
19731973

19741974
template <>
19751975
struct GetHelperStruct<0>
19761976
{
19771977
template <typename SEALIter, typename... Rest>
1978-
static auto apply(const IterTuple<SEALIter, Rest...> &it)
1978+
static auto Apply(const IterTuple<SEALIter, Rest...> &it)
19791979
{
19801980
return it.first();
19811981
}
@@ -1985,18 +1985,18 @@ namespace seal
19851985
auto get(const IterTuple<SEALIters...> &it)
19861986
{
19871987
static_assert(N < sizeof...(SEALIters), "IterTuple index out of range");
1988-
return iterator_internal::GetHelperStruct<N>::apply(it);
1988+
return iterator_internal::GetHelperStruct<N>::Apply(it);
19891989
}
19901990

19911991
template <typename T, typename... Rest>
1992-
struct iter_type<
1993-
std::void_t<
1994-
std::enable_if_t<(sizeof...(Rest) > 0)>, typename iter_type<void, T>::type,
1995-
typename iter_type<void, Rest...>::type>,
1992+
struct IterType<
1993+
seal_void_t<
1994+
std::enable_if_t<(sizeof...(Rest) > 0)>, typename IterType<void, T>::type,
1995+
typename IterType<void, Rest...>::type>,
19961996
T, Rest...>
19971997
{
19981998
using type = typename extend_iter_tuple<
1999-
typename iter_type<void, T>::type, typename iter_type<void, Rest...>::type>::type;
1999+
typename IterType<void, T>::type, typename IterType<void, Rest...>::type>::type;
20002000
};
20012001
} // namespace iterator_internal
20022002

@@ -2014,16 +2014,16 @@ namespace seal
20142014
}
20152015

20162016
template <typename... Ts>
2017-
SEAL_NODISCARD inline auto iter(Ts &&... ts) -> typename iterator_internal::iter_type<void, Ts...>::type
2017+
SEAL_NODISCARD inline auto iter(Ts &&... ts) -> typename iterator_internal::IterType<void, Ts...>::type
20182018
{
20192019
return { std::forward<Ts>(ts)... };
20202020
}
20212021

20222022
template <typename... Ts>
20232023
SEAL_NODISCARD inline auto reverse_iter(Ts &&... ts)
2024-
-> ReverseIter<typename iterator_internal::iter_type<void, Ts...>::type>
2024+
-> ReverseIter<typename iterator_internal::IterType<void, Ts...>::type>
20252025
{
2026-
return typename iterator_internal::iter_type<void, Ts...>::type(std::forward<Ts>(ts)...);
2026+
return typename iterator_internal::IterType<void, Ts...>::type(std::forward<Ts>(ts)...);
20272027
}
20282028
} // namespace util
20292029
} // namespace seal

0 commit comments

Comments
 (0)