JDBtracker/libostd
1
0
Fork 0
forked from OctaForge/libostd
Code Issues Pull requests Releases Wiki Activity

put EnableIf in template type params where possible

Browse source
This commit is contained in:
q66 2015-06-29 21:56:13 +01:00
parent 2f16288671
commit d8d8ea7151
6 changed files with 47 additions and 69 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

14
octa/functional.hh
View file

@ -700,10 +700,9 @@ struct Function<R(Args...)>: octa::detail::FunctionBase<R, Args...> {
f.p_stor.manager->call_copyf(p_stor, f.p_stor); f.p_stor.manager->call_copyf(p_stor, f.p_stor);
} }
template<typename T> template<typename T, typename = octa::EnableIf<
Function(T f, EnableIf< octa::detail::IsValidFunctor<T, R(Args...)>::value
octa::detail::IsValidFunctor<T, R(Args...)>::value, bool >> Function(T f) {
> = true) {
if (func_is_null(f)) { if (func_is_null(f)) {
init_empty(); init_empty();
return; return;
@ -747,10 +746,9 @@ struct Function<R(Args...)>: octa::detail::FunctionBase<R, Args...> {
initialize(f, AA(a)); initialize(f, AA(a));
} }
template<typename A, typename T> template<typename A, typename T, typename = octa::EnableIf<
Function(octa::AllocatorArg, const A &a, T f, EnableIf< octa::detail::IsValidFunctor<T, R(Args...)>::value
octa::detail::IsValidFunctor<T, R(Args...)>::value, bool >> Function(octa::AllocatorArg, const A &a, T f) {
> = true) {
if (func_is_null(f)) { if (func_is_null(f)) {
init_empty(); init_empty();
return; return;

21
octa/map.hh
View file

@ -88,14 +88,11 @@ namespace detail {
MapImpl(MapImpl &&m): Base(octa::move(m)) {} MapImpl(MapImpl &&m): Base(octa::move(m)) {}
MapImpl(MapImpl &&m, const A &alloc): Base(octa::move(m), alloc) {} MapImpl(MapImpl &&m, const A &alloc): Base(octa::move(m), alloc) {}
template<typename R> template<typename R, typename = octa::EnableIf<
MapImpl(R range, octa::Size size = 0, const H &hf = H(), octa::IsInputRange<R>::value &&
const C &eqf = C(), const A &alloc = A(), octa::IsConvertible<RangeReference<R>, Value>::value
octa::EnableIf< >> MapImpl(R range, octa::Size size = 0, const H &hf = H(),
octa::IsInputRange<R>::value && const C &eqf = C(), const A &alloc = A()
octa::IsConvertible<RangeReference<R>, Value>::value,
bool
> = true
): Base(size ? size : octa::detail::estimate_hrsize(range), ): Base(size ? size : octa::detail::estimate_hrsize(range),
hf, eqf, alloc) { hf, eqf, alloc) {
for (; !range.empty(); range.pop_front()) for (; !range.empty(); range.pop_front())
@ -132,12 +129,10 @@ namespace detail {
return *this; return *this;
} }
template<typename R> template<typename R, typename = octa::EnableIf<
octa::EnableIf<
octa::IsInputRange<R>::value && octa::IsInputRange<R>::value &&
octa::IsConvertible<RangeReference<R>, Value>::value, octa::IsConvertible<RangeReference<R>, Value>::value
MapImpl & >> MapImpl &operator=(R range) {
> operator=(R range) {
Base::assign_range(range); Base::assign_range(range);
return *this; return *this;
} }

14
octa/range.hh
View file

@ -250,9 +250,9 @@ public:
RangeHalf(const T &range): p_range(range) {} RangeHalf(const T &range): p_range(range) {}
template<typename U> RangeHalf(const RangeHalf<U> &half, template<typename U, typename = octa::EnableIf<
octa::EnableIf<octa::IsConvertible<U, T>::value, bool> = true octa::IsConvertible<U, T>::value
): p_range(half.p_range) {} >> RangeHalf(const RangeHalf<U> &half): p_range(half.p_range) {}
RangeHalf(RangeHalf &&half): p_range(octa::move(half.p_range)) {} RangeHalf(RangeHalf &&half): p_range(octa::move(half.p_range)) {}
@ -749,10 +749,10 @@ struct PointerRange: InputRange<PointerRange<T>, FiniteRandomAccessRangeTag, T>
PointerRange(T *beg, T *end): p_beg(beg), p_end(end) {} PointerRange(T *beg, T *end): p_beg(beg), p_end(end) {}
PointerRange(T *beg, octa::Size n): p_beg(beg), p_end(beg + n) {} PointerRange(T *beg, octa::Size n): p_beg(beg), p_end(beg + n) {}
template<typename U> template<typename U, typename = octa::EnableIf<
PointerRange(const PointerRange<U> &v, octa::EnableIf< octa::IsConvertible<U *, T *>::value
octa::IsConvertible<U *, T *>::value, bool >> PointerRange(const PointerRange<U> &v):
> = true): p_beg(&v[0]), p_end(&v[v.size()]) {} p_beg(&v[0]), p_end(&v[v.size()]) {}
PointerRange &operator=(const PointerRange &v) { PointerRange &operator=(const PointerRange &v) {
p_beg = v.p_beg; p_beg = v.p_beg;

21
octa/set.hh
View file

@ -74,14 +74,11 @@ namespace detail {
SetImpl(SetImpl &&m): Base(octa::move(m)) {} SetImpl(SetImpl &&m): Base(octa::move(m)) {}
SetImpl(SetImpl &&m, const A &alloc): Base(octa::move(m), alloc) {} SetImpl(SetImpl &&m, const A &alloc): Base(octa::move(m), alloc) {}
template<typename R> template<typename R, typename = octa::EnableIf<
SetImpl(R range, octa::Size size = 0, const H &hf = H(), octa::IsInputRange<R>::value &&
const C &eqf = C(), const A &alloc = A(), octa::IsConvertible<RangeReference<R>, Value>::value
octa::EnableIf< >> SetImpl(R range, octa::Size size = 0, const H &hf = H(),
octa::IsInputRange<R>::value && const C &eqf = C(), const A &alloc = A()
octa::IsConvertible<RangeReference<R>, Value>::value,
bool
> = true
): Base(size ? size : octa::detail::estimate_hrsize(range), ): Base(size ? size : octa::detail::estimate_hrsize(range),
hf, eqf, alloc) { hf, eqf, alloc) {
for (; !range.empty(); range.pop_front()) for (; !range.empty(); range.pop_front())
@ -118,12 +115,10 @@ namespace detail {
return *this; return *this;
} }
template<typename R> template<typename R, typename = octa::EnableIf<
octa::EnableIf<
octa::IsInputRange<R>::value && octa::IsInputRange<R>::value &&
octa::IsConvertible<RangeReference<R>, Value>::value, octa::IsConvertible<RangeReference<R>, Value>::value
SetImpl & >> SetImpl &operator=(R range) {
> operator=(R range) {
Base::assign_range(range); Base::assign_range(range);
return *this; return *this;
} }

27
octa/string.hh
View file

@ -30,10 +30,10 @@ struct StringRangeBase: InputRange<
StringRangeBase(const StringBase<T> &s): p_beg(s.data()), StringRangeBase(const StringBase<T> &s): p_beg(s.data()),
p_end(s.data() + s.size()) {} p_end(s.data() + s.size()) {}
template<typename U> template<typename U, typename = octa::EnableIf<
StringRangeBase(const StringRangeBase<U> &v, octa::EnableIf< octa::IsConvertible<U *, T *>::value
octa::IsConvertible<U *, T *>::value, bool >> StringRangeBase(const StringRangeBase<U> &v):
> = true): p_beg(&v[0]), p_end(&v[v.size()]) {} p_beg(&v[0]), p_end(&v[v.size()]) {}
StringRangeBase &operator=(const StringRangeBase &v) { StringRangeBase &operator=(const StringRangeBase &v) {
p_beg = v.p_beg; p_end = v.p_end; return *this; p_beg = v.p_beg; p_end = v.p_end; return *this;
@ -177,13 +177,10 @@ public:
StringBase(const Value *v, Size n, const A &a = A()): StringBase(const Value *v, Size n, const A &a = A()):
p_buf(ConstRange(v, n), a) {} p_buf(ConstRange(v, n), a) {}
template<typename R> StringBase(R range, const A &a = A(), template<typename R, typename = octa::EnableIf<
octa::EnableIf< octa::IsInputRange<R>::value &&
octa::IsInputRange<R>::value && octa::IsConvertible<RangeReference<R>, Value>::value
octa::IsConvertible<RangeReference<R>, Value>::value, >> StringBase(R range, const A &a = A()): p_buf(range, a) {
bool
> = true
): p_buf(range, a) {
terminate(); terminate();
} }
@ -201,12 +198,10 @@ public:
p_buf = ConstRange(v, strlen(v) + 1); p_buf = ConstRange(v, strlen(v) + 1);
return *this; return *this;
} }
template<typename R> template<typename R, typename = octa::EnableIf<
octa::EnableIf<
octa::IsInputRange<R>::value && octa::IsInputRange<R>::value &&
octa::IsConvertible<RangeReference<R>, Value>::value, octa::IsConvertible<RangeReference<R>, Value>::value
StringBase & >> StringBase &operator=(const R &r) {
> operator=(const R &r) {
p_buf = r; p_buf = r;
terminate(); terminate();
return *this; return *this;

19
octa/vector.hh
View file

@ -161,13 +161,10 @@ public:
Vector(InitializerList<T> v, const A &a = A()): Vector(InitializerList<T> v, const A &a = A()):
Vector(v.begin(), v.size(), a) {} Vector(v.begin(), v.size(), a) {}
template<typename R> Vector(R range, const A &a = A(), template<typename R, typename = octa::EnableIf<
octa::EnableIf< octa::IsInputRange<R>::value &&
octa::IsInputRange<R>::value && octa::IsConvertible<RangeReference<R>, Value>::value
octa::IsConvertible<RangeReference<R>, Value>::value, >> Vector(R range, const A &a = A()): Vector(a) {
bool
> = true
): Vector(a) {
ctor_from_range(range); ctor_from_range(range);
} }
@ -231,12 +228,10 @@ public:
return *this; return *this;
} }
template<typename R> template<typename R, typename = octa::EnableIf<
octa::EnableIf<
octa::IsInputRange<R>::value && octa::IsInputRange<R>::value &&
octa::IsConvertible<RangeReference<R>, Value>::value, octa::IsConvertible<RangeReference<R>, Value>::value
Vector & >> Vector &operator=(R range) {
> operator=(R range) {
clear(); clear();
ctor_from_range(range); ctor_from_range(range);
return *this; return *this;