OctaForge
/
libostd
1
0
Fork 1
Code Issues Pull Requests Releases Wiki Activity

remove the noexcept stuff; nothing in octastd ever throws

master
Daniel Kolesa 2015-05-20 22:05:41 +01:00
parent 25fb30b524
commit 64810e4006
9 changed files with 452 additions and 804 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

38
octa/array.h
View File

@ -23,39 +23,39 @@ namespace octa {
typedef PointerRange< T> RangeType;
typedef PointerRange<const T> ConstRangeType;
T &operator[](size_t i) noexcept { return p_buf[i]; }
const T &operator[](size_t i) const noexcept { return p_buf[i]; }
T &operator[](size_t i) { return p_buf[i]; }
const T &operator[](size_t i) const { return p_buf[i]; }
T &at(size_t i) noexcept { return p_buf[i]; }
const T &at(size_t i) const noexcept { return p_buf[i]; }
T &at(size_t i) { return p_buf[i]; }
const T &at(size_t i) const { return p_buf[i]; }
T &first() noexcept { return p_buf[0]; }
const T &first() const noexcept { return p_buf[0]; }
T &first() { return p_buf[0]; }
const T &first() const { return p_buf[0]; }
T &last() noexcept { return p_buf[N - 1]; }
const T &last() const noexcept { return p_buf[N - 1]; }
T &last() { return p_buf[N - 1]; }
const T &last() const { return p_buf[N - 1]; }
size_t length() const noexcept { return N; }
size_t length() const { return N; }
bool empty() const noexcept { return N == 0; }
bool empty() const { return N == 0; }
bool in_range(size_t idx) noexcept { return idx < N; }
bool in_range(int idx) noexcept { return idx >= 0 && idx < N; }
bool in_range(const T *ptr) noexcept {
bool in_range(size_t idx) { return idx < N; }
bool in_range(int idx) { return idx >= 0 && idx < N; }
bool in_range(const T *ptr) {
return ptr >= &p_buf[0] && ptr < &p_buf[N];
}
T *get() noexcept { return p_buf; }
const T *get() const noexcept { return p_buf; }
T *get() { return p_buf; }
const T *get() const { return p_buf; }
void swap(Array &v) noexcept(swap(declval<T &>(), declval<T &>())) {
void swap(Array &v)(swap(declval<T &>(), declval<T &>())) {
swap(p_buf, v.p_buf);
}
RangeType each() noexcept {
RangeType each() {
return PointerRange<T>(p_buf, p_buf + N);
}
ConstRangeType each() const noexcept {
ConstRangeType each() const {
return PointerRange<const T>(p_buf, p_buf + N);
}
@ -63,7 +63,7 @@ namespace octa {
};
template<typename T, size_t N>
void swap(Array<T, N> &a, Array<T, N> &b) noexcept(noexcept(a.swap(b))) {
void swap(Array<T, N> &a, Array<T, N> &b) {
a.swap(b);
}
}

379
octa/atomic.h
View File

@ -24,8 +24,8 @@ namespace octa {
template<typename T>
struct __OctaAtomicBase {
__OctaAtomicBase() noexcept {}
explicit __OctaAtomicBase(T v) noexcept: value(v) {}
__OctaAtomicBase() {}
explicit __OctaAtomicBase(T v): value(v) {}
T value;
};
@ -112,8 +112,7 @@ namespace octa {
template<typename T>
struct __OctaMsvcAtomicStore<T, 1> {
static inline void store(volatile T *dst, T src, MemoryOrder ord)
noexcept {
static inline void store(volatile T *dst, T src, MemoryOrder ord) {
if (ord == MemoryOrder::seq_cst)
InterlockedExchange8((volatile int8_t *)dst, (int8_t)src);
else *dst = src;
@ -122,8 +121,7 @@ namespace octa {
template<typename T>
struct __OctaMsvcAtomicStore<T, 2> {
static inline void store(volatile T *dst, T src, MemoryOrder ord)
noexcept {
static inline void store(volatile T *dst, T src, MemoryOrder ord) {
if (ord == MemoryOrder::seq_cst)
InterlockedExchange16((volatile int16_t *)dst, (int16_t)src);
else *dst = src;
@ -132,8 +130,7 @@ namespace octa {
template<typename T>
struct __OctaMsvcAtomicStore<T, 4> {
static inline void store(volatile T *dst, T src, MemoryOrder ord)
noexcept {
static inline void store(volatile T *dst, T src, MemoryOrder ord) {
if (ord == MemoryOrder::seq_cst)
InterlockedExchange((volatile int32_t *)dst, (int32_t)src);
else *dst = src;
@ -142,8 +139,7 @@ namespace octa {
template<typename T>
struct __OctaMsvcAtomicStore<T, 8> {
static inline void store(volatile T *dst, T src, MemoryOrder ord)
noexcept {
static inline void store(volatile T *dst, T src, MemoryOrder ord) {
if (ord == MemoryOrder::relaxed)
InterlockedExchangeNoFence64((volatile int64_t *)dst, (int64_t)src);
else
@ -168,26 +164,22 @@ namespace octa {
template<typename T>
struct __OctaMsvcAtomicLoad<T, 1> {
static inline void load(volatile T *src, T *dst)
noexcept { *dst = *src; }
static inline void load(volatile T *src, T *dst) { *dst = *src; }
};
template<typename T>
struct __OctaMsvcAtomicLoad<T, 2> {
static inline void load(volatile T *src, T *dst)
noexcept { *dst = *src; }
static inline void load(volatile T *src, T *dst) { *dst = *src; }
};
template<typename T>
struct __OctaMsvcAtomicLoad<T, 4> {
static inline void load(volatile T *src, T *dst)
noexcept { *dst = *src; }
static inline void load(volatile T *src, T *dst) { *dst = *src; }
};
template<typename T>
struct __OctaMsvcAtomicLoad<T, 8> {
static inline void load(volatile T *src, T *dst)
noexcept {
static inline void load(volatile T *src, T *dst) {
#pragma warning(push)
#pragma warning(disable:4047)
*dst = InterlockedOr64((volatile int64_t *)(src), 0);
@ -216,32 +208,28 @@ namespace octa {
template<typename T>
struct __OctaMsvcAtomicExchange<T, 1> {
static inline void exchange(volatile T *dst, T src, T *ret)
noexcept {
static inline void exchange(volatile T *dst, T src, T *ret) {
*ret = InterlockedExchange8((volatile int8_t *)dst, (int8_t)src);
}
};
template<typename T>
struct __OctaMsvcAtomicExchange<T, 2> {
static inline void exchange(volatile T *dst, T src, T *ret)
noexcept {
static inline void exchange(volatile T *dst, T src, T *ret) {
*ret = InterlockedExchange16((volatile int16_t *)dst, (int16_t)src);
}
};
template<typename T>
struct __OctaMsvcAtomicExchange<T, 4> {
static inline void exchange(volatile T *dst, T src, T *ret)
noexcept {
static inline void exchange(volatile T *dst, T src, T *ret) {
*ret = InterlockedExchange((volatile int32_t *)dst, (int32_t)src);
}
};
template<typename T>
struct __OctaMsvcAtomicExchange<T, 8> {
static inline void exchange(volatile T *dst, T src, T *ret)
noexcept {
static inline void exchange(volatile T *dst, T src, T *ret) {
*ret = InterlockedExchange64((volatile int64_t *)dst, (int64_t)src);
}
};
@ -267,8 +255,7 @@ namespace octa {
template<typename T>
struct __OctaMsvcAtomicCompareExchange<T, 1> {
static inline bool exchange(volatile T *dst, T *exp, T src)
noexcept {
static inline bool exchange(volatile T *dst, T *exp, T src) {
int8_t prev = _InterlockedCompareExchange8((volatile int8_t *)dst,
(int8_t)src, (int8_t)*exp);
if (prev == (int8_t)*exp) return true;
@ -278,8 +265,7 @@ namespace octa {
template<typename T>
struct __OctaMsvcAtomicCompareExchange<T, 2> {
static inline bool exchange(volatile T *dst, T *exp, T src)
noexcept {
static inline bool exchange(volatile T *dst, T *exp, T src) {
int16_t prev = _InterlockedCompareExchange16((volatile int16_t *)dst,
(int16_t)src, (int16_t)*exp);
if (prev == (int16_t)*exp) return true;
@ -289,8 +275,7 @@ namespace octa {
template<typename T>
struct __OctaMsvcAtomicCompareExchange<T, 4> {
static inline bool exchange(volatile T *dst, T *exp, T src)
noexcept {
static inline bool exchange(volatile T *dst, T *exp, T src) {
int32_t prev = _InterlockedCompareExchange((volatile int32_t *)dst,
(int32_t)src, (int32_t)*exp);
if (prev == (int32_t)*exp) return true;
@ -300,8 +285,7 @@ namespace octa {
template<typename T>
struct __OctaMsvcAtomicCompareExchange<T, 8> {
static inline bool exchange(volatile T *dst, T *exp, T src)
noexcept {
static inline bool exchange(volatile T *dst, T *exp, T src) {
int64_t prev = _InterlockedCompareExchange64((volatile int64_t *)dst,
(int64_t)src, (int64_t)*exp);
if (prev == (int64_t)*exp) return true;
@ -668,7 +652,7 @@ namespace octa {
#endif
#endif
template <typename T> inline T kill_dependency(T v) noexcept {
template <typename T> inline T kill_dependency(T v) {
return v;
}
@ -676,93 +660,87 @@ namespace octa {
struct __OctaAtomic {
mutable __OctaAtomicBase<T> p_a;
__OctaAtomic() noexcept = default;
__OctaAtomic() = default;
constexpr __OctaAtomic(T v) noexcept: p_a(v) {}
constexpr __OctaAtomic(T v): p_a(v) {}
__OctaAtomic(const __OctaAtomic &) = delete;
__OctaAtomic &operator=(const __OctaAtomic &) = delete;
__OctaAtomic &operator=(const __OctaAtomic &) volatile = delete;
bool is_lock_free() const volatile noexcept {
bool is_lock_free() const volatile {
return __octa_atomic_is_lock_free(sizeof(T));
}
bool is_lock_free() const noexcept {
bool is_lock_free() const {
return __octa_atomic_is_lock_free(sizeof(T));
}
void store(T v, MemoryOrder ord = MemoryOrder::seq_cst)
volatile noexcept {
void store(T v, MemoryOrder ord = MemoryOrder::seq_cst) volatile {
__octa_atomic_store(&p_a, v, ord);
}
void store(T v, MemoryOrder ord = MemoryOrder::seq_cst) noexcept {
void store(T v, MemoryOrder ord = MemoryOrder::seq_cst) {
__octa_atomic_store(&p_a, v, ord);
}
T load(MemoryOrder ord = MemoryOrder::seq_cst) const volatile noexcept {
T load(MemoryOrder ord = MemoryOrder::seq_cst) const volatile {
return __octa_atomic_load(&p_a, ord);
}
T load(MemoryOrder ord = MemoryOrder::seq_cst) const noexcept {
T load(MemoryOrder ord = MemoryOrder::seq_cst) const {
return __octa_atomic_load(&p_a, ord);
}
operator T() const volatile noexcept { return load(); }
operator T() const noexcept { return load(); }
operator T() const volatile { return load(); }
operator T() const { return load(); }
T exchange(T v, MemoryOrder ord = MemoryOrder::seq_cst)
volatile noexcept {
T exchange(T v, MemoryOrder ord = MemoryOrder::seq_cst) volatile {
return __octa_atomic_exchange(&p_a, v, ord);
}
T exchange(T v, MemoryOrder ord = MemoryOrder::seq_cst) noexcept {
T exchange(T v, MemoryOrder ord = MemoryOrder::seq_cst) {
return __octa_atomic_exchange(&p_a, v, ord);
}
bool compare_exchange_weak(T &e, T v, MemoryOrder s, MemoryOrder f)
volatile noexcept {
volatile {
return __octa_atomic_compare_exchange_weak(&p_a, &e, v, s, f);
}
bool compare_exchange_weak(T& e, T v, MemoryOrder s, MemoryOrder f)
noexcept {
bool compare_exchange_weak(T& e, T v, MemoryOrder s, MemoryOrder f) {
return __octa_atomic_compare_exchange_weak(&p_a, &e, v, s, f);
}
bool compare_exchange_strong(T& e, T v, MemoryOrder s, MemoryOrder f)
volatile noexcept {
volatile {
return __octa_atomic_compare_exchange_strong(&p_a, &e, v, s, f);
}
bool compare_exchange_strong(T& e, T v, MemoryOrder s, MemoryOrder f)
noexcept {
bool compare_exchange_strong(T& e, T v, MemoryOrder s, MemoryOrder f) {
return __octa_atomic_compare_exchange_strong(&p_a, &e, v, s, f);
}
bool compare_exchange_weak(T& e, T v, MemoryOrder ord
= MemoryOrder::seq_cst)
volatile noexcept {
volatile {
return __octa_atomic_compare_exchange_weak(&p_a, &e, v, ord, ord);
}
bool compare_exchange_weak(T& e, T v, MemoryOrder ord
= MemoryOrder::seq_cst)
noexcept {
= MemoryOrder::seq_cst) {
return __octa_atomic_compare_exchange_weak(&p_a, &e, v, ord, ord);
}
bool compare_exchange_strong(T& e, T v, MemoryOrder ord
= MemoryOrder::seq_cst)
volatile noexcept {
volatile {
return __octa_atomic_compare_exchange_strong(&p_a, &e, v, ord, ord);
}
bool compare_exchange_strong(T& e, T v, MemoryOrder ord
= MemoryOrder::seq_cst)
noexcept {
= MemoryOrder::seq_cst) {
return __octa_atomic_compare_exchange_strong(&p_a, &e, v, ord, ord);
}
};
@ -771,89 +749,84 @@ namespace octa {
struct __OctaAtomic<T, true>: __OctaAtomic<T, false> {
typedef __OctaAtomic<T, false> base_t;
__OctaAtomic() noexcept = default;
__OctaAtomic() = default;
constexpr __OctaAtomic(T v) noexcept: base_t(v) {}
constexpr __OctaAtomic(T v): base_t(v) {}
T fetch_add(T op, MemoryOrder ord = MemoryOrder::seq_cst)
volatile noexcept {
T fetch_add(T op, MemoryOrder ord = MemoryOrder::seq_cst) volatile {
return __octa_atomic_fetch_add(&this->p_a, op, ord);
}
T fetch_add(T op, MemoryOrder ord = MemoryOrder::seq_cst) noexcept {
T fetch_add(T op, MemoryOrder ord = MemoryOrder::seq_cst) {
return __octa_atomic_fetch_add(&this->p_a, op, ord);
}
T fetch_sub(T op, MemoryOrder ord = MemoryOrder::seq_cst)
volatile noexcept {
T fetch_sub(T op, MemoryOrder ord = MemoryOrder::seq_cst) volatile {
return __octa_atomic_fetch_sub(&this->p_a, op, ord);
}
T fetch_sub(T op, MemoryOrder ord = MemoryOrder::seq_cst) noexcept {
T fetch_sub(T op, MemoryOrder ord = MemoryOrder::seq_cst) {
return __octa_atomic_fetch_sub(&this->p_a, op, ord);
}
T fetch_and(T op, MemoryOrder ord = MemoryOrder::seq_cst)
volatile noexcept {
T fetch_and(T op, MemoryOrder ord = MemoryOrder::seq_cst) volatile {
return __octa_atomic_fetch_and(&this->p_a, op, ord);
}
T fetch_and(T op, MemoryOrder ord = MemoryOrder::seq_cst) noexcept {
T fetch_and(T op, MemoryOrder ord = MemoryOrder::seq_cst) {
return __octa_atomic_fetch_and(&this->p_a, op, ord);
}
T fetch_or(T op, MemoryOrder ord = MemoryOrder::seq_cst)
volatile noexcept {
T fetch_or(T op, MemoryOrder ord = MemoryOrder::seq_cst) volatile {
return __octa_atomic_fetch_or(&this->p_a, op, ord);
}
T fetch_or(T op, MemoryOrder ord = MemoryOrder::seq_cst) noexcept {
T fetch_or(T op, MemoryOrder ord = MemoryOrder::seq_cst) {
return __octa_atomic_fetch_or(&this->p_a, op, ord);
}
T fetch_xor(T op, MemoryOrder ord = MemoryOrder::seq_cst)
volatile noexcept {
T fetch_xor(T op, MemoryOrder ord = MemoryOrder::seq_cst) volatile {
return __octa_atomic_fetch_xor(&this->p_a, op, ord);
}
T fetch_xor(T op, MemoryOrder ord = MemoryOrder::seq_cst) noexcept {
T fetch_xor(T op, MemoryOrder ord = MemoryOrder::seq_cst) {
return __octa_atomic_fetch_xor(&this->p_a, op, ord);
}
T operator++(int) volatile noexcept { return fetch_add(T(1)); }
T operator++(int) noexcept { return fetch_add(T(1)); }
T operator--(int) volatile noexcept { return fetch_sub(T(1)); }
T operator--(int) noexcept { return fetch_sub(T(1)); }
T operator++( ) volatile noexcept { return fetch_add(T(1)) + T(1); }
T operator++( ) noexcept { return fetch_add(T(1)) + T(1); }
T operator--( ) volatile noexcept { return fetch_sub(T(1)) - T(1); }
T operator--( ) noexcept { return fetch_sub(T(1)) - T(1); }
T operator++(int) volatile { return fetch_add(T(1)); }
T operator++(int) { return fetch_add(T(1)); }
T operator--(int) volatile { return fetch_sub(T(1)); }
T operator--(int) { return fetch_sub(T(1)); }
T operator++( ) volatile { return fetch_add(T(1)) + T(1); }
T operator++( ) { return fetch_add(T(1)) + T(1); }
T operator--( ) volatile { return fetch_sub(T(1)) - T(1); }
T operator--( ) { return fetch_sub(T(1)) - T(1); }
T operator+=(T op) volatile noexcept { return fetch_add(op) + op; }
T operator+=(T op) noexcept { return fetch_add(op) + op; }
T operator-=(T op) volatile noexcept { return fetch_sub(op) - op; }
T operator-=(T op) noexcept { return fetch_sub(op) - op; }
T operator&=(T op) volatile noexcept { return fetch_and(op) & op; }
T operator&=(T op) noexcept { return fetch_and(op) & op; }
T operator|=(T op) volatile noexcept { return fetch_or (op) | op; }
T operator|=(T op) noexcept { return fetch_or (op) | op; }
T operator^=(T op) volatile noexcept { return fetch_xor(op) ^ op; }
T operator^=(T op) noexcept { return fetch_xor(op) ^ op; }
T operator+=(T op) volatile { return fetch_add(op) + op; }
T operator+=(T op) { return fetch_add(op) + op; }
T operator-=(T op) volatile { return fetch_sub(op) - op; }
T operator-=(T op) { return fetch_sub(op) - op; }
T operator&=(T op) volatile { return fetch_and(op) & op; }
T operator&=(T op) { return fetch_and(op) & op; }
T operator|=(T op) volatile { return fetch_or (op) | op; }
T operator|=(T op) { return fetch_or (op) | op; }
T operator^=(T op) volatile { return fetch_xor(op) ^ op; }
T operator^=(T op) { return fetch_xor(op) ^ op; }
};
template<typename T>
struct Atomic: __OctaAtomic<T> {
typedef __OctaAtomic<T> base_t;
Atomic() noexcept = default;
Atomic() = default;
constexpr Atomic(T v) noexcept: base_t(v) {}
constexpr Atomic(T v): base_t(v) {}
T operator=(T v) volatile noexcept {
T operator=(T v) volatile {
base_t::store(v); return v;
}
T operator=(T v) noexcept {
T operator=(T v) {
base_t::store(v); return v;
}
};
@ -862,163 +835,152 @@ namespace octa {
struct Atomic<T *>: __OctaAtomic<T *> {
typedef __OctaAtomic<T *> base_t;
Atomic() noexcept = default;
Atomic() = default;
constexpr Atomic(T *v) noexcept: base_t(v) {}
constexpr Atomic(T *v): base_t(v) {}
T *operator=(T *v) volatile noexcept {
T *operator=(T *v) volatile {
base_t::store(v); return v;
}
T *operator=(T *v) noexcept {
T *operator=(T *v) {
base_t::store(v); return v;
}
T *fetch_add(ptrdiff_t op, MemoryOrder ord = MemoryOrder::seq_cst)
volatile noexcept {
volatile {
return __octa_atomic_fetch_add(&this->p_a, op, ord);
}
T *fetch_add(ptrdiff_t op, MemoryOrder ord = MemoryOrder::seq_cst)
noexcept {
T *fetch_add(ptrdiff_t op, MemoryOrder ord = MemoryOrder::seq_cst) {
return __octa_atomic_fetch_add(&this->p_a, op, ord);
}
T *fetch_sub(ptrdiff_t op, MemoryOrder ord = MemoryOrder::seq_cst)
volatile noexcept {
volatile {
return __octa_atomic_fetch_sub(&this->p_a, op, ord);
}
T *fetch_sub(ptrdiff_t op, MemoryOrder ord = MemoryOrder::seq_cst)
noexcept {
T *fetch_sub(ptrdiff_t op, MemoryOrder ord = MemoryOrder::seq_cst) {
return __octa_atomic_fetch_sub(&this->p_a, op, ord);
}
T *operator++(int) volatile noexcept { return fetch_add(1); }
T *operator++(int) noexcept { return fetch_add(1); }
T *operator--(int) volatile noexcept { return fetch_sub(1); }
T *operator--(int) noexcept { return fetch_sub(1); }
T *operator++( ) volatile noexcept { return fetch_add(1) + 1; }
T *operator++( ) noexcept { return fetch_add(1) + 1; }
T *operator--( ) volatile noexcept { return fetch_sub(1) - 1; }
T *operator--( ) noexcept { return fetch_sub(1) - 1; }
T *operator++(int) volatile { return fetch_add(1); }
T *operator++(int) { return fetch_add(1); }
T *operator--(int) volatile { return fetch_sub(1); }
T *operator--(int) { return fetch_sub(1); }
T *operator++( ) volatile { return fetch_add(1) + 1; }
T *operator++( ) { return fetch_add(1) + 1; }
T *operator--( ) volatile { return fetch_sub(1) - 1; }
T *operator--( ) { return fetch_sub(1) - 1; }
T *operator+=(ptrdiff_t op) volatile noexcept { return fetch_add(op) + op; }
T *operator+=(ptrdiff_t op) noexcept { return fetch_add(op) + op; }
T *operator-=(ptrdiff_t op) volatile noexcept { return fetch_sub(op) - op; }
T *operator-=(ptrdiff_t op) noexcept { return fetch_sub(op) - op; }
T *operator+=(ptrdiff_t op) volatile { return fetch_add(op) + op; }
T *operator+=(ptrdiff_t op) { return fetch_add(op) + op; }
T *operator-=(ptrdiff_t op) volatile { return fetch_sub(op) - op; }
T *operator-=(ptrdiff_t op) { return fetch_sub(op) - op; }
};
template<typename T>
inline bool atomic_is_lock_free(const volatile Atomic<T> *a) noexcept {
inline bool atomic_is_lock_free(const volatile Atomic<T> *a) {
return a->is_lock_free();
}
template<typename T>
inline bool atomic_is_lock_free(const Atomic<T> *a) noexcept {
inline bool atomic_is_lock_free(const Atomic<T> *a) {
return a->is_lock_free();
}
template<typename T>
inline void atomic_init(volatile Atomic<T> *a, T v) noexcept {
inline void atomic_init(volatile Atomic<T> *a, T v) {
__octa_atomic_init(&a->p_a, v);
}
template<typename T>
inline void atomic_init(Atomic<T> *a, T v) noexcept {
inline void atomic_init(Atomic<T> *a, T v) {
__octa_atomic_init(&a->p_a, v);
}
template <typename T>
inline void atomic_store(volatile Atomic<T> *a, T v) noexcept {
inline void atomic_store(volatile Atomic<T> *a, T v) {
a->store(v);
}
template <typename T>
inline void atomic_store(Atomic<T> *a, T v) noexcept {
inline void atomic_store(Atomic<T> *a, T v) {
a->store(v);
}
template <typename T>
inline void atomic_store_explicit(volatile Atomic<T> *a, T v,
MemoryOrder ord)
noexcept {
MemoryOrder ord) {
a->store(v, ord);
}
template <typename T>
inline void atomic_store_explicit(Atomic<T> *a, T v, MemoryOrder ord)
noexcept {
inline void atomic_store_explicit(Atomic<T> *a, T v, MemoryOrder ord) {
a->store(v, ord);
}
template <typename T>
inline T atomic_load(const volatile Atomic<T> *a) noexcept {
inline T atomic_load(const volatile Atomic<T> *a) {
return a->load();
}
template <typename T>
inline T atomic_load(const Atomic<T> *a) noexcept {
inline T atomic_load(const Atomic<T> *a) {
return a->load();
}
template <typename T>
inline T atomic_load_explicit(const volatile Atomic<T> *a,
MemoryOrder ord)
noexcept {
MemoryOrder ord) {
return a->load(ord);
}
template <typename T>
inline T atomic_load_explicit(const Atomic<T> *a, MemoryOrder ord)
noexcept {
inline T atomic_load_explicit(const Atomic<T> *a, MemoryOrder ord) {
return a->load(ord);
}
template <typename T>
inline T atomic_exchange(volatile Atomic<T> *a, T v) noexcept {
inline T atomic_exchange(volatile Atomic<T> *a, T v) {
return a->exchange(v);
}
template <typename T>
inline T atomic_exchange(Atomic<T> *a, T v) noexcept {
inline T atomic_exchange(Atomic<T> *a, T v) {
return a->exchange(v);
}
template <typename T>
inline T atomic_exchange_explicit(volatile Atomic<T> *a, T v,
MemoryOrder ord)
noexcept {
MemoryOrder ord) {
return a->exchange(v, ord);
}
template <typename T>
inline T atomic_exchange_explicit(Atomic<T> *a, T v, MemoryOrder ord)
noexcept {
inline T atomic_exchange_explicit(Atomic<T> *a, T v, MemoryOrder ord) {
return a->exchange(v, ord);
}
template <typename T>
inline bool atomic_compare_exchange_weak(volatile Atomic<T> *a, T *e, T v)
noexcept {
inline bool atomic_compare_exchange_weak(volatile Atomic<T> *a, T *e, T v) {
return a->compare_exchange_weak(*e, v);
}
template <typename T>
inline bool atomic_compare_exchange_weak(Atomic<T> *a, T *e, T v) noexcept {
inline bool atomic_compare_exchange_weak(Atomic<T> *a, T *e, T v) {
return a->compare_exchange_weak(*e, v);
}
template <typename T>
inline bool atomic_compare_exchange_strong(volatile Atomic<T> *a, T *e, T v)
noexcept {
inline bool atomic_compare_exchange_strong(volatile Atomic<T> *a, T *e, T v) {
return a->compare_exchange_strong(*e, v);
}
template <typename T>
inline bool atomic_compare_exchange_strong(Atomic<T> *a, T *e, T v)
noexcept {
inline bool atomic_compare_exchange_strong(Atomic<T> *a, T *e, T v) {
return a->compare_exchange_strong(*e, v);
}
@ -1026,16 +988,14 @@ namespace octa {
inline bool atomic_compare_exchange_weak_explicit(volatile Atomic<T> *a,
T *e, T v,
MemoryOrder s,
MemoryOrder f)
noexcept {
MemoryOrder f) {
return a->compare_exchange_weak(*e, v, s, f);
}
template <typename T>
inline bool atomic_compare_exchange_weak_explicit(Atomic<T> *a, T *e, T v,
MemoryOrder s,
MemoryOrder f)
noexcept {
MemoryOrder f) {
return a->compare_exchange_weak(*e, v, s, f);
}
@ -1043,267 +1003,250 @@ namespace octa {
inline bool atomic_compare_exchange_strong_explicit(volatile Atomic<T> *a,
T *e, T v,
MemoryOrder s,
MemoryOrder f)
noexcept {
MemoryOrder f) {
return a->compare_exchange_strong(*e, v, s, f);
}
template <typename T>
inline bool atomic_compare_exchange_strong_explicit(Atomic<T> *a, T *e, T v,
MemoryOrder s,
MemoryOrder f)
noexcept {
MemoryOrder f) {
return a->compare_exchange_strong(*e, v, s, f);
}
template <typename T>
inline EnableIf<IsIntegral<T>::value && !IsSame<T, bool>::value, T>
atomic_fetch_add(volatile Atomic<T> *a, T op) noexcept {
atomic_fetch_add(volatile Atomic<T> *a, T op) {
return a->fetch_add(op);
}
template <typename T>
inline EnableIf<IsIntegral<T>::value && !IsSame<T, bool>::value, T>
atomic_fetch_add(Atomic<T> *a, T op) noexcept {
atomic_fetch_add(Atomic<T> *a, T op) {
return a->fetch_add(op);
}
template <typename T>
inline T *atomic_fetch_add(volatile Atomic<T *> *a, ptrdiff_t op) noexcept {
inline T *atomic_fetch_add(volatile Atomic<T *> *a, ptrdiff_t op) {
return a->fetch_add(op);
}
template <typename T>
inline T *atomic_fetch_add(Atomic<T *> *a, ptrdiff_t op) noexcept {
inline T *atomic_fetch_add(Atomic<T *> *a, ptrdiff_t op) {
return a->fetch_add(op);
}
template <typename T>
inline EnableIf<IsIntegral<T>::value && !IsSame<T, bool>::value, T>
atomic_fetch_add_explicit(volatile Atomic<T> *a, T op, MemoryOrder ord)
noexcept {
atomic_fetch_add_explicit(volatile Atomic<T> *a, T op, MemoryOrder ord) {
return a->fetch_add(op, ord);
}
template <typename T>
inline EnableIf<IsIntegral<T>::value && !IsSame<T, bool>::value, T>
atomic_fetch_add_explicit(Atomic<T> *a, T op, MemoryOrder ord) noexcept {
atomic_fetch_add_explicit(Atomic<T> *a, T op, MemoryOrder ord) {
return a->fetch_add(op, ord);
}
template <typename T>
inline T *atomic_fetch_add_explicit(volatile Atomic<T *> *a, ptrdiff_t op,
MemoryOrder ord)
noexcept {
MemoryOrder ord) {
return a->fetch_add(op, ord);
}
template <typename T>
inline T *atomic_fetch_add_explicit(Atomic<T *> *a, ptrdiff_t op,
MemoryOrder ord)
noexcept {
MemoryOrder ord) {
return a->fetch_add(op, ord);
}
template <typename T>
inline EnableIf<IsIntegral<T>::value && !IsSame<T, bool>::value, T>
atomic_fetch_sub(volatile Atomic<T> *a, T op) noexcept {
atomic_fetch_sub(volatile Atomic<T> *a, T op) {
return a->fetch_sub(op);
}
template <typename T>
inline EnableIf<IsIntegral<T>::value && !IsSame<T, bool>::value, T>
atomic_fetch_sub(Atomic<T> *a, T op) noexcept {
atomic_fetch_sub(Atomic<T> *a, T op) {
return a->fetch_sub(op);
}
template <typename T>
inline T *atomic_fetch_sub(volatile Atomic<T *> *a, ptrdiff_t op) noexcept {
inline T *atomic_fetch_sub(volatile Atomic<T *> *a, ptrdiff_t op) {
return a->fetch_sub(op);
}
template <typename T>
inline T *atomic_fetch_sub(Atomic<T *> *a, ptrdiff_t op) noexcept {
inline T *atomic_fetch_sub(Atomic<T *> *a, ptrdiff_t op) {
return a->fetch_sub(op);
}
template <typename T>
inline EnableIf<IsIntegral<T>::value && !IsSame<T, bool>::value, T>
atomic_fetch_sub_explicit(volatile Atomic<T> *a, T op, MemoryOrder ord)
noexcept {
atomic_fetch_sub_explicit(volatile Atomic<T> *a, T op, MemoryOrder ord) {
return a->fetch_sub(op, ord);
}
template <typename T>
inline EnableIf<IsIntegral<T>::value && !IsSame<T, bool>::value, T>
atomic_fetch_sub_explicit(Atomic<T> *a, T op, MemoryOrder ord) noexcept {
atomic_fetch_sub_explicit(Atomic<T> *a, T op, MemoryOrder ord) {
return a->fetch_sub(op, ord);
}
template <typename T>
inline T *atomic_fetch_sub_explicit(volatile Atomic<T *> *a, ptrdiff_t op,
MemoryOrder ord)
noexcept {
MemoryOrder ord) {
return a->fetch_sub(op, ord);
}
template <typename T>
inline T *atomic_fetch_sub_explicit(Atomic<T *> *a, ptrdiff_t op,
MemoryOrder ord)
noexcept {
MemoryOrder ord) {
return a->fetch_sub(op, ord);
}
template <typename T>
inline EnableIf<IsIntegral<T>::value && !IsSame<T, bool>::value, T>
atomic_fetch_and(volatile Atomic<T> *a, T op) noexcept {
atomic_fetch_and(volatile Atomic<T> *a, T op) {
return a->fetch_and(op);
}
template <typename T>
inline EnableIf<IsIntegral<T>::value && !IsSame<T, bool>::value, T>
atomic_fetch_and(Atomic<T> *a, T op) noexcept {
atomic_fetch_and(Atomic<T> *a, T op) {
return a->fetch_and(op);
}
template <typename T>
inline EnableIf<IsIntegral<T>::value && !IsSame<T, bool>::value, T>
atomic_fetch_and_explicit(volatile Atomic<T> *a, T op, MemoryOrder ord)
noexcept {
atomic_fetch_and_explicit(volatile Atomic<T> *a, T op, MemoryOrder ord) {
return a->fetch_and(op, ord);
}
template <typename T>
inline EnableIf<IsIntegral<T>::value && !IsSame<T, bool>::value, T>
atomic_fetch_and_explicit(Atomic<T> *a, T op, MemoryOrder ord) noexcept {
atomic_fetch_and_explicit(Atomic<T> *a, T op, MemoryOrder ord) {
return a->fetch_and(op, ord);
}
template <typename T>
inline EnableIf<IsIntegral<T>::value && !IsSame<T, bool>::value, T>
atomic_fetch_or(volatile Atomic<T> *a, T op) noexcept {
atomic_fetch_or(volatile Atomic<T> *a, T op) {
return a->fetch_or(op);
}
template <typename T>
inline EnableIf<IsIntegral<T>::value && !IsSame<T, bool>::value, T>
atomic_fetch_or(Atomic<T> *a, T op) noexcept {
atomic_fetch_or(Atomic<T> *a, T op) {
return a->fetch_or(op);
}
template <typename T>
inline EnableIf<IsIntegral<T>::value && !IsSame<T, bool>::value, T>
atomic_fetch_or_explicit(volatile Atomic<T> *a, T op, MemoryOrder ord)
noexcept {
atomic_fetch_or_explicit(volatile Atomic<T> *a, T op, MemoryOrder ord) {
return a->fetch_or(op, ord);
}
template <typename T>
inline EnableIf<IsIntegral<T>::value && !IsSame<T, bool>::value, T>
atomic_fetch_or_explicit(Atomic<T> *a, T op, MemoryOrder ord) noexcept {
atomic_fetch_or_explicit(Atomic<T> *a, T op, MemoryOrder ord) {
return a->fetch_or(op, ord);
}
template <typename T>
inline EnableIf<IsIntegral<T>::value && !IsSame<T, bool>::value, T>
atomic_fetch_xor(volatile Atomic<T> *a, T op) noexcept {
atomic_fetch_xor(volatile Atomic<T> *a, T op) {
return a->fetch_xor(op);
}
template <typename T>
inline EnableIf<IsIntegral<T>::value && !IsSame<T, bool>::value, T>
atomic_fetch_xor(Atomic<T> *a, T op) noexcept {
atomic_fetch_xor(Atomic<T> *a, T op) {
return a->fetch_xor(op);
}
template <typename T>
inline EnableIf<IsIntegral<T>::value && !IsSame<T, bool>::value, T>
atomic_fetch_xor_explicit(volatile Atomic<T> *a, T op, MemoryOrder ord)
noexcept {
atomic_fetch_xor_explicit(volatile Atomic<T> *a, T op, MemoryOrder ord) {
return a->fetch_xor(op, ord);
}
template <typename T>
inline EnableIf<IsIntegral<T>::value && !IsSame<T, bool>::value, T>
atomic_fetch_xor_explicit(Atomic<T> *a, T op, MemoryOrder ord) noexcept {
atomic_fetch_xor_explicit(Atomic<T> *a, T op, MemoryOrder ord) {
return a->fetch_xor(op, ord);
}
struct AtomicFlag {
__OctaAtomicBase<bool> p_a;
AtomicFlag() noexcept = default;
AtomicFlag() = default;
AtomicFlag(bool b) noexcept: p_a(b) {}
AtomicFlag(bool b): p_a(b) {}
AtomicFlag(const AtomicFlag &) = delete;
AtomicFlag &operator=(const AtomicFlag &) = delete;
AtomicFlag &operator=(const AtomicFlag &) volatile = delete;
bool test_and_set(MemoryOrder ord = MemoryOrder::seq_cst)
volatile noexcept {
bool test_and_set(MemoryOrder ord = MemoryOrder::seq_cst) volatile {
return __octa_atomic_exchange(&p_a, true, ord);
}
bool test_and_set(MemoryOrder ord = MemoryOrder::seq_cst) noexcept {
bool test_and_set(MemoryOrder ord = MemoryOrder::seq_cst) {
return __octa_atomic_exchange(&p_a, true, ord);
}
void clear(MemoryOrder ord = MemoryOrder::seq_cst) volatile noexcept {
void clear(MemoryOrder ord = MemoryOrder::seq_cst) volatile {
__octa_atomic_store(&p_a, false, ord);
}
void clear(MemoryOrder ord = MemoryOrder::seq_cst) noexcept {
void clear(MemoryOrder ord = MemoryOrder::seq_cst) {
__octa_atomic_store(&p_a, false, ord);
}
};
inline bool atomic_flag_test_and_set(volatile AtomicFlag *a)
noexcept {
inline bool atomic_flag_test_and_set(volatile AtomicFlag *a) {
return a->test_and_set();
}
inline bool atomic_flag_test_and_set(AtomicFlag *a) noexcept {
inline bool atomic_flag_test_and_set(AtomicFlag *a) {
return a->test_and_set();
}
inline bool atomic_flag_test_and_set_explicit(volatile AtomicFlag *a,
MemoryOrder ord)
noexcept {
MemoryOrder ord) {
return a->test_and_set(ord);
}
inline bool atomic_flag_test_and_set_explicit(AtomicFlag *a,
MemoryOrder ord)
noexcept {
MemoryOrder ord) {
return a->test_and_set(ord);
}
inline void atomic_flag_clear(volatile AtomicFlag *a) noexcept {
inline void atomic_flag_clear(volatile AtomicFlag *a) {
a->clear();
}
inline void atomic_flag_clear(AtomicFlag *a) noexcept {
inline void atomic_flag_clear(AtomicFlag *a) {
a->clear();
}
inline void atomic_flag_clear_explicit(volatile AtomicFlag *a,
MemoryOrder ord)
noexcept {
MemoryOrder ord) {
a->clear(ord);
}
inline void atomic_flag_clear_explicit(AtomicFlag *a, MemoryOrder ord)
noexcept {
inline void atomic_flag_clear_explicit(AtomicFlag *a, MemoryOrder ord) {
a->clear(ord);
}
inline void atomic_thread_fence(MemoryOrder ord) noexcept {
inline void atomic_thread_fence(MemoryOrder ord) {
__octa_atomic_thread_fence(ord);
}
inline void atomic_signal_fence(MemoryOrder ord) noexcept {
inline void atomic_signal_fence(MemoryOrder ord) {
__octa_atomic_signal_fence(ord);
}

114
octa/functional.h
View File

@ -16,9 +16,7 @@ namespace octa {
#define __OCTA_DEFINE_BINARY_OP(name, op, rettype) \
template<typename T> struct name { \
bool operator()(const T &x, const T &y) const noexcept( \
noexcept(x op y) \
) { return x op y; } \
bool operator()(const T &x, const T &y) const { return x op y; } \
typedef T FirstArgType; \
typedef T SecondArgType; \
typedef rettype ResultType; \
@ -44,13 +42,13 @@ namespace octa {
#undef __OCTA_DEFINE_BINARY_OP
template<typename T> struct LogicalNot {
bool operator()(const T &x) const noexcept(noexcept(!x)) { return !x; }
bool operator()(const T &x) const { return !x; }
typedef T ArgType;
typedef bool ResultType;
};
template<typename T> struct Negate {
bool operator()(const T &x) const noexcept(noexcept(-x)) { return -x; }
bool operator()(const T &x) const { return -x; }
typedef T ArgType;
typedef T ResultType;
};
@ -60,14 +58,10 @@ namespace octa {
typedef typename T::SecondArgType SecondArgType;
typedef bool ResultType;
explicit BinaryNegate(const T &f) noexcept(
IsNothrowCopyConstructible<T>::value
): p_fn(f) {}
explicit BinaryNegate(const T &f): p_fn(f) {}
bool operator()(const FirstArgType &x,
const SecondArgType &y) noexcept(
noexcept(p_fn(x, y))
) {
const SecondArgType &y) {
return !p_fn(x, y);
}
private:
@ -78,25 +72,19 @@ namespace octa {
typedef typename T::ArgType ArgType;
typedef bool ResultType;
explicit UnaryNegate(const T &f) noexcept(
IsNothrowCopyConstructible<T>::value
): p_fn(f) {}
bool operator()(const ArgType &x) noexcept(noexcept(p_fn(x))) {
explicit UnaryNegate(const T &f): p_fn(f) {}
bool operator()(const ArgType &x) {
return !p_fn(x);
}
private:
T p_fn;
};
template<typename T> UnaryNegate<T> not1(const T &fn) noexcept(
IsNothrowCopyConstructible<UnaryNegate<T>>::value
) {
template<typename T> UnaryNegate<T> not1(const T &fn) {
return UnaryNegate<T>(fn);
}
template<typename T> BinaryNegate<T> not2(const T &fn) noexcept(
IsNothrowCopyConstructible<BinaryNegate<T>>::value
) {
template<typename T> BinaryNegate<T> not2(const T &fn) {
return BinaryNegate<T>(fn);
}
@ -108,7 +96,7 @@ namespace octa {
typedef T ArgType;
typedef size_t ResultType;
size_t operator()(T v) const noexcept {
size_t operator()(T v) const {
return (size_t)v;
}
};
@ -145,7 +133,7 @@ namespace octa {
typedef T ArgType;
typedef size_t ResultType;
size_t operator()(T v) const noexcept {
size_t operator()(T v) const {
union { T v; size_t h; } u;
u.h = 0;
u.v = v;
@ -157,7 +145,7 @@ namespace octa {
typedef T ArgType;
typedef size_t ResultType;
size_t operator()(T v) const noexcept {
size_t operator()(T v) const {
union { T v; size_t h; } u;
u.v = v;
return u.h;
@ -168,7 +156,7 @@ namespace octa {
typedef T ArgType;
typedef size_t ResultType;
size_t operator()(T v) const noexcept {
size_t operator()(T v) const {
union { T v; struct { size_t h1, h2; }; } u;
u.v = v;
return __octa_mem_hash((const void *)&u, sizeof(u));
@ -179,7 +167,7 @@ namespace octa {
typedef T ArgType;
typedef size_t ResultType;
size_t operator()(T v) const noexcept {
size_t operator()(T v) const {
union { T v; struct { size_t h1, h2, h3; }; } u;
u.v = v;
return __octa_mem_hash((const void *)&u, sizeof(u));
@ -190,7 +178,7 @@ namespace octa {
typedef T ArgType;
typedef size_t ResultType;
size_t operator()(T v) const noexcept {
size_t operator()(T v) const {
union { T v; struct { size_t h1, h2, h3, h4; }; } u;
u.v = v;
return __octa_mem_hash((const void *)&u, sizeof(u));
@ -201,21 +189,21 @@ namespace octa {
template<> struct Hash<ullong>: __OctaScalarHash<ullong> {};
template<> struct Hash<float>: __OctaScalarHash<float> {
size_t operator()(float v) const noexcept {
size_t operator()(float v) const {
if (v == 0) return 0;
return __OctaScalarHash<float>::operator()(v);
}
};
template<> struct Hash<double>: __OctaScalarHash<double> {
size_t operator()(double v) const noexcept {
size_t operator()(double v) const {
if (v == 0) return 0;
return __OctaScalarHash<double>::operator()(v);
}
};
template<> struct Hash<ldouble>: __OctaScalarHash<ldouble> {
size_t operator()(ldouble v) const noexcept {
size_t operator()(ldouble v) const {
if (v == 0) return 0;
#ifdef __i386__
union { ldouble v; struct { size_t h1, h2, h3, h4; }; } u;
@ -239,7 +227,7 @@ namespace octa {
typedef T *ArgType;
typedef size_t ResultType;
size_t operator()(T *v) const noexcept {
size_t operator()(T *v) const {
union { T *v; size_t h; } u;
u.v = v;
return __octa_mem_hash((const void *)&u, sizeof(u));
@ -252,7 +240,7 @@ namespace octa {
struct ReferenceWrapper {
typedef T type;
ReferenceWrapper(T &v) noexcept: p_ptr(address_of(v)) {}
ReferenceWrapper(T &v): p_ptr(address_of(v)) {}
ReferenceWrapper(const ReferenceWrapper &) = default;
ReferenceWrapper(T &&) = delete;
@ -266,21 +254,21 @@ namespace octa {
};
template<typename T>
ReferenceWrapper<T> ref(T &v) noexcept {
ReferenceWrapper<T> ref(T &v) {
return ReferenceWrapper<T>(v);
}
template<typename T>
ReferenceWrapper<T> ref(ReferenceWrapper<T> v) noexcept {
ReferenceWrapper<T> ref(ReferenceWrapper<T> v) {
return ReferenceWrapper<T>(v);
}
template<typename T> void ref(const T &&) = delete;
template<typename T>
ReferenceWrapper<const T> cref(const T &v) noexcept {
ReferenceWrapper<const T> cref(const T &v) {
return ReferenceWrapper<T>(v);
}
template<typename T>
ReferenceWrapper<const T> cref(ReferenceWrapper<T> v) noexcept {
ReferenceWrapper<const T> cref(ReferenceWrapper<T> v) {
return ReferenceWrapper<T>(v);
}
template<typename T> void cref(const T &&) = delete;
@ -339,7 +327,7 @@ namespace octa {
};
template<typename R, typename T>
__OctaMemFn<R, T> mem_fn(R T:: *ptr) noexcept {
__OctaMemFn<R, T> mem_fn(R T:: *ptr) {
return __OctaMemFn<R, T>(ptr);
}
@ -357,7 +345,7 @@ namespace octa {
struct __OctaFunctorInPlace {
static constexpr bool value = sizeof(T) <= sizeof(__OctaFunctorData)
&& (alignof(__OctaFunctorData) % alignof(T)) == 0
&& octa::IsNothrowMoveConstructible<T>();
&& octa::IsMoveConstructible<T>::value;
};
template<typename T, typename E = void>
@ -371,15 +359,15 @@ namespace octa {
new (&get_ref(s)) T(forward<T>(v));
}
static void move_f(__OctaFunctorData &lhs, __OctaFunctorData &&rhs) noexcept {
static void move_f(__OctaFunctorData &lhs, __OctaFunctorData &&rhs) {
new (&get_ref(lhs)) T(move(get_ref(rhs)));
}
static void destroy_f(__OctaFunctorData &s) noexcept {
static void destroy_f(__OctaFunctorData &s) {
get_ref(s).~T();
}
static T &get_ref(const __OctaFunctorData &s) noexcept {
static T &get_ref(const __OctaFunctorData &s) {
return (T &)s;
}
};
@ -395,27 +383,27 @@ namespace octa {
new (&get_ptr_ref(s)) T *(new T(forward<T>(v)));
}
static void move_f(__OctaFunctorData &lhs, __OctaFunctorData &&rhs) noexcept {
static void move_f(__OctaFunctorData &lhs, __OctaFunctorData &&rhs) {
new (&get_ptr_ref(lhs)) T *(get_ptr_ref(rhs));
get_ptr_ref(rhs) = nullptr;
}
static void destroy_f(__OctaFunctorData &s) noexcept {
static void destroy_f(__OctaFunctorData &s) {
T *&ptr = get_ptr_ref(s);
if (!ptr) return;
delete ptr;
ptr = nullptr;
}
static T &get_ref(const __OctaFunctorData &s) noexcept {
static T &get_ref(const __OctaFunctorData &s) {
return *get_ptr_ref(s);
}
static T *&get_ptr_ref(__OctaFunctorData &s) noexcept {
static T *&get_ptr_ref(__OctaFunctorData &s) {
return (T *&)s;
}
static T *&get_ptr_ref(const __OctaFunctorData &s) noexcept {
static T *&get_ptr_ref(const __OctaFunctorData &s) {
return (T *&)s;
}
};
@ -537,22 +525,21 @@ namespace octa {
template<typename R, typename ...A>
struct Function<R(A...)>: __OctaFunction<R, A...> {
Function( ) noexcept { initialize_empty(); }
Function(nullptr_t) noexcept { initialize_empty(); }
Function( ) { initialize_empty(); }
Function(nullptr_t) { initialize_empty(); }
Function(Function &&f) noexcept {
Function(Function &&f) {
initialize_empty();
swap(f);
}
Function(const Function &f) noexcept: p_call(f.p_call) {
Function(const Function &f): p_call(f.p_call) {
f.p_stor.manager->call_copy(p_stor, f.p_stor);
}
template<typename T>
Function(T f, EnableIf<IsValidFunctor<T, R(A...)>::value, __OctaEmpty>
= __OctaEmpty())
noexcept(__OctaFunctorInPlace<T>::value) {
= __OctaEmpty()) {
if (func_is_null(f)) {
initialize_empty();
return;
@ -564,13 +551,13 @@ namespace octa {
p_stor.manager->call_destroy(p_stor);
}
Function &operator=(Function &&f) noexcept {
Function &operator=(Function &&f) {
p_stor.manager->call_destroy(p_stor);
swap(f);
return *this;
}
Function &operator=(const Function &f) noexcept {
Function &operator=(const Function &f) {
p_stor.manager->call_destroy(p_stor);
f.p_stor.manager->call_copy(p_stor, f.p_stor);
return *this;
@ -580,12 +567,11 @@ namespace octa {
return p_call(p_stor.data, forward<A>(args)...);
}
template<typename F>
void assign(F &&f) noexcept(__OctaFunctorInPlace<F>::value) {
template<typename F> void assign(F &&f) {
Function(forward<F>(f)).swap(*this);
}
void swap(Function &f) noexcept {
void swap(Function &f) {
__OctaFmStorage tmp;
f.p_stor.manager->call_move_and_destroy(tmp, move(f.p_stor));
p_stor.manager->call_move_and_destroy(f.p_stor, move(p_stor));
@ -593,7 +579,7 @@ namespace octa {
octa::swap(p_call, f.p_call);
}
operator bool() const noexcept { return p_call != nullptr; }
operator bool() const { return p_call != nullptr; }
private:
__OctaFmStorage p_stor;
@ -606,7 +592,7 @@ namespace octa {
__OctaFunctorDataManager<T>::store_f(p_stor.data, forward<T>(f));
}
void initialize_empty() noexcept {
void initialize_empty() {
typedef R(*emptyf)(A...);
p_call = nullptr;
p_stor.manager = &__octa_get_default_fm<emptyf>();
@ -632,21 +618,21 @@ namespace octa {
};
template<typename T>
void swap(Function<T> &a, Function<T> &b) noexcept {
void swap(Function<T> &a, Function<T> &b) {
a.swap(b);
}
template<typename T>
bool operator==(nullptr_t, const Function<T> &rhs) noexcept { return !rhs; }
bool operator==(nullptr_t, const Function<T> &rhs) { return !rhs; }
template<typename T>
bool operator==(const Function<T> &lhs, nullptr_t) noexcept { return !lhs; }
bool operator==(const Function<T> &lhs, nullptr_t) { return !lhs; }
template<typename T>
bool operator!=(nullptr_t, const Function<T> &rhs) noexcept { return rhs; }
bool operator!=(nullptr_t, const Function<T> &rhs) { return rhs; }
template<typename T>
bool operator!=(const Function<T> &lhs, nullptr_t) noexcept { return lhs; }
bool operator!=(const Function<T> &lhs, nullptr_t) { return lhs; }
}
#endif

10
octa/initializer_list.h
View File

@ -17,7 +17,7 @@ namespace std {
const T *p_buf;
size_t p_len;
initializer_list(const T *v, size_t n) noexcept: p_buf(v), p_len(n) {}
initializer_list(const T *v, size_t n): p_buf(v), p_len(n) {}
public:
typedef size_t SizeType;
typedef ptrdiff_t DiffType;
@ -27,13 +27,13 @@ namespace std {
typedef T *PtrType;
typedef const T *ConstPtrType;
initializer_list() noexcept: p_buf(nullptr), p_len(0) {}
initializer_list(): p_buf(nullptr), p_len(0) {}
size_t length() const noexcept { return p_len; }
size_t length() const { return p_len; }
const T *get() const noexcept { return p_buf; }
const T *get() const { return p_buf; }
octa::PointerRange<const T> range() noexcept {
octa::PointerRange<const T> range() {
return octa::PointerRange<const T>(p_buf, p_len);
}
};

129
octa/memory.h
View File

@ -15,7 +15,7 @@
namespace octa {
/* address of */
template<typename T> constexpr T *address_of(T &v) noexcept {
template<typename T> constexpr T *address_of(T &v) {
return reinterpret_cast<T *>(&const_cast<char &>
(reinterpret_cast<const volatile char &>(v)));
}
@ -156,15 +156,15 @@ namespace octa {
struct __OctaPtrTraitsPointerTo {
static T pointer_to(Conditional<IsVoid<PointerElement<T>>::value,
__OctaPtrTraitsNat, PointerElement<T>
> &r) noexcept(noexcept(T::pointer_to(r))) {
> &r) {
return T::pointer_to(r);
}
};
template<typename T>
struct __OctaPtrTraitsPointerTo<T *> {
static T pointer_to(Conditional<IsVoid<T>::value, __OctaPtrTraitsNat, T> &r)
noexcept {
static T pointer_to(Conditional<IsVoid<T>::value, __OctaPtrTraitsNat, T
> &r) {
return octa::address_of(r);
}
};
@ -172,7 +172,7 @@ namespace octa {
template<typename T>
static T pointer_to(Conditional<IsVoid<PointerElement<T>>::value,
__OctaPtrTraitsNat, PointerElement<T>
> &r) noexcept(noexcept(__OctaPtrTraitsPointerTo<T>::pointer_to(r))) {
> &r) {
return __OctaPtrTraitsPointerTo<T>::pointer_to(r);
}
@ -184,7 +184,7 @@ namespace octa {
template<typename U> DefaultDelete(const DefaultDelete<U> &) {};
void operator()(T *p) const noexcept {
void operator()(T *p) const {
delete p;
}
};
@ -195,7 +195,7 @@ namespace octa {
template<typename U> DefaultDelete(const DefaultDelete<U[]> &) {};
void operator()(T *p) const noexcept {
void operator()(T *p) const {
delete[] p;
}
template<typename U> void operator()(U *) const = delete;
@ -214,13 +214,12 @@ namespace octa {
public:
template<typename D>
__OctaBoxPair(T *ptr, D &&dltr) noexcept:
i_ptr(ptr), p_del(forward<D>(dltr)) {}
__OctaBoxPair(T *ptr, D &&dltr): i_ptr(ptr), p_del(forward<D>(dltr)) {}
U &get_deleter() noexcept { return p_del; }
const U &get_deleter() const noexcept { return p_del; }
U &get_deleter() { return p_del; }
const U &get_deleter() const { return p_del; }
void swap(__OctaBoxPair &v) noexcept {
void swap(__OctaBoxPair &v) {
octa::swap(i_ptr, v.i_ptr);
octa::swap(p_del, v.p_del);
}
@ -231,13 +230,12 @@ namespace octa {
T *i_ptr;
template<typename D>
__OctaBoxPair(T *ptr, D &&dltr) noexcept:
U(forward<D>(dltr)), i_ptr(ptr) {}
__OctaBoxPair(T *ptr, D &&dltr): U(forward<D>(dltr)), i_ptr(ptr) {}
U &get_deleter() noexcept { return *this; }
const U &get_deleter() const noexcept { return *this; }
U &get_deleter() { return *this; }
const U &get_deleter() const { return *this; }
void swap(__OctaBoxPair &v) noexcept {
void swap(__OctaBoxPair &v) {
octa::swap(i_ptr, v.i_ptr);
}
};
@ -277,40 +275,39 @@ namespace octa {
typedef const RemoveReference<D> &D_cref;
public:
constexpr Box() noexcept: p_stor(nullptr, D()) {
constexpr Box(): p_stor(nullptr, D()) {
static_assert(!IsPointer<D>::value,
"Box constructed with null fptr deleter");
}
constexpr Box(nullptr_t) noexcept: p_stor(nullptr, D()) {
constexpr Box(nullptr_t): p_stor(nullptr, D()) {
static_assert(!IsPointer<D>::value,
"Box constructed with null fptr deleter");
}
explicit Box(PtrType p) noexcept: p_stor(p, D()) {
explicit Box(PtrType p): p_stor(p, D()) {
static_assert(!IsPointer<D>::value,
"Box constructed with null fptr deleter");
}
Box(PtrType p, Conditional<IsReference<D>::value,
D, AddLvalueReference<const D>
> d) noexcept: p_stor(p, d) {}
> d): p_stor(p, d) {}
Box(PtrType p, RemoveReference<D> &&d) noexcept: p_stor(p, move(d)) {
Box(PtrType p, RemoveReference<D> &&d): p_stor(p, move(d)) {
static_assert(!IsReference<D>::value,
"rvalue deleter cannot be a ref");
}
Box(Box &&u) noexcept: p_stor(u.release(), forward<D>(u.get_deleter())) {}
Box(Box &&u): p_stor(u.release(), forward<D>(u.get_deleter())) {}
template<typename TT, typename DD>
Box(Box<TT, DD> &&u, EnableIf<!IsArray<TT>::value
&& IsConvertible<typename Box<TT, DD>::PtrType, PtrType>::value
&& IsConvertible<DD, D>::value
&& (!IsReference<D>::value || IsSame<D, DD>::value)
> = __OctaNat()) noexcept: p_stor(u.release(),
forward<DD>(u.get_deleter())) {}
> = __OctaNat()): p_stor(u.release(), forward<DD>(u.get_deleter())) {}
Box &operator=(Box &&u) noexcept {
Box &operator=(Box &&u) {
reset(u.release());
p_stor.get_deleter() = forward<D>(u.get_deleter());
return *this;
@ -321,13 +318,13 @@ namespace octa {
&& IsConvertible<typename Box<TT, DD>::PtrType, PtrType>::value
&& IsAssignable<D &, DD &&>::value,
Box &
> operator=(Box<TT, DD> &&u) noexcept {
> operator=(Box<TT, DD> &&u) {
reset(u.release());
p_stor.get_deleter() = forward<DD>(u.get_deleter());
return *this;
}
Box &operator=(nullptr_t) noexcept {
Box &operator=(nullptr_t) {
reset();
return *this;
}
@ -335,30 +332,30 @@ namespace octa {
~Box() { reset(); }
AddLvalueReference<T> operator*() const { return *p_stor.i_ptr; }
PtrType operator->() const noexcept { return p_stor.i_ptr; }
PtrType operator->() const { return p_stor.i_ptr; }
explicit operator bool() const noexcept {
explicit operator bool() const {
return p_stor.i_ptr != nullptr;
}
PtrType get() const noexcept { return p_stor.i_ptr; }
PtrType get() const { return p_stor.i_ptr; }
D_ref get_deleter() noexcept { return p_stor.get_deleter(); }
D_cref get_deleter() const noexcept { return p_stor.get_deleter(); }
D_ref get_deleter() { return p_stor.get_deleter(); }
D_cref get_deleter() const { return p_stor.get_deleter(); }
PtrType release() noexcept {
PtrType release() {
PtrType p = p_stor.i_ptr;
p_stor.i_ptr = nullptr;
return p;
}
void reset(PtrType p = nullptr) noexcept {
void reset(PtrType p = nullptr) {
PtrType tmp = p_stor.i_ptr;
p_stor.i_ptr = p;
if (tmp) p_stor.get_deleter()(tmp);
}
void swap(Box &u) noexcept {
void swap(Box &u) {
p_stor.swap(u.p_stor);
}
@ -394,18 +391,18 @@ namespace octa {
typedef const RemoveReference<D> &D_cref;
public:
constexpr Box() noexcept: p_stor(nullptr, D()) {
constexpr Box(): p_stor(nullptr, D()) {
static_assert(!IsPointer<D>::value,
"Box constructed with null fptr deleter");
}
constexpr Box(nullptr_t) noexcept: p_stor(nullptr, D()) {
constexpr Box(nullptr_t): p_stor(nullptr, D()) {
static_assert(!IsPointer<D>::value,
"Box constructed with null fptr deleter");
}
template<typename U> explicit Box(U p, EnableIf<
__OctaSameOrLessCvQualified<U, PtrType>::value, __OctaNat
> = __OctaNat()) noexcept: p_stor(p, D()) {
> = __OctaNat()): p_stor(p, D()) {
static_assert(!IsPointer<D>::value,
"Box constructed with null fptr deleter");
}
@ -413,25 +410,25 @@ namespace octa {
template<typename U> Box(U p, Conditional<IsReference<D>::value,
D, AddLvalueReference<const D>
> d, EnableIf<__OctaSameOrLessCvQualified<U, PtrType>::value, __OctaNat
> = __OctaNat()) noexcept: p_stor(p, d) {}
> = __OctaNat()): p_stor(p, d) {}
Box(nullptr_t, Conditional<IsReference<D>::value,
D, AddLvalueReference<const D>
> d) noexcept: p_stor(nullptr, d) {}
> d): p_stor(nullptr, d) {}
template<typename U> Box(U p, RemoveReference<D> &&d, EnableIf<
__OctaSameOrLessCvQualified<U, PtrType>::value, __OctaNat
> = __OctaNat()) noexcept: p_stor(p, move(d)) {
> = __OctaNat()): p_stor(p, move(d)) {
static_assert(!IsReference<D>::value,
"rvalue deleter cannot be a ref");
}
Box(nullptr_t, RemoveReference<D> &&d) noexcept: p_stor(nullptr, move(d)) {
Box(nullptr_t, RemoveReference<D> &&d): p_stor(nullptr, move(d)) {
static_assert(!IsReference<D>::value,
"rvalue deleter cannot be a ref");
}
Box(Box &&u) noexcept: p_stor(u.release(), forward<D>(u.get_deleter())) {}
Box(Box &&u): p_stor(u.release(), forward<D>(u.get_deleter())) {}
template<typename TT, typename DD>
Box(Box<TT, DD> &&u, EnableIf<IsArray<TT>::value
@ -439,9 +436,9 @@ namespace octa {
PtrType>::value
&& IsConvertible<DD, D>::value
&& (!IsReference<D>::value || IsSame<D, DD>::value)> = __OctaNat()
) noexcept: p_stor(u.release(), forward<DD>(u.get_deleter())) {}
): p_stor(u.release(), forward<DD>(u.get_deleter())) {}
Box &operator=(Box &&u) noexcept {
Box &operator=(Box &&u) {
reset(u.release());
p_stor.get_deleter() = forward<D>(u.get_deleter());
return *this;
@ -453,13 +450,13 @@ namespace octa {
PtrType>::value
&& IsAssignable<D &, DD &&>::value,
Box &
> operator=(Box<TT, DD> &&u) noexcept {
> operator=(Box<TT, DD> &&u) {
reset(u.release());
p_stor.get_deleter() = forward<DD>(u.get_deleter());
return *this;
}
Box &operator=(nullptr_t) noexcept {
Box &operator=(nullptr_t) {
reset();
return *this;
}
@ -470,16 +467,16 @@ namespace octa {
return p_stor.i_ptr[idx];
}
explicit operator bool() const noexcept {
explicit operator bool() const {
return p_stor.i_ptr != nullptr;
}
PtrType get() const noexcept { return p_stor.i_ptr; }
PtrType get() const { return p_stor.i_ptr; }
D_ref get_deleter() noexcept { return p_stor.get_deleter(); }
D_cref get_deleter() const noexcept { return p_stor.get_deleter(); }
D_ref get_deleter() { return p_stor.get_deleter(); }
D_cref get_deleter() const { return p_stor.get_deleter(); }
PtrType release() noexcept {
PtrType release() {
PtrType p = p_stor.i_ptr;
p_stor.i_ptr = nullptr;
return p;
@ -487,23 +484,23 @@ namespace octa {
template<typename U> EnableIf<
__OctaSameOrLessCvQualified<U, PtrType>::value, void
> reset(U p) noexcept {
> reset(U p) {
PtrType tmp = p_stor.i_ptr;
p_stor.i_ptr = p;
if (tmp) p_stor.get_deleter()(tmp);
}
void reset(nullptr_t) noexcept {
void reset(nullptr_t) {
PtrType tmp = p_stor.i_ptr;
p_stor.i_ptr = nullptr;
if (tmp) p_stor.get_deleter()(tmp);
}
void reset() noexcept {
void reset() {
reset(nullptr);
}
void swap(Box &u) noexcept {
void swap(Box &u) {
p_stor.swap(u.p_stor);
}
@ -567,16 +564,16 @@ namespace octa {
template<typename U> using Rebind = Allocator<U>;
PtrType address(RefType v) const noexcept {
PtrType address(RefType v) const {
return address_of(v);
};
ConstPtrType address(ConstRefType v) const noexcept {
ConstPtrType address(ConstRefType v) const {
return address_of(v);
};
SizeType max_size() const noexcept { return SizeType(~0) / sizeof(T); }
SizeType max_size() const { return SizeType(~0) / sizeof(T); }
PtrType allocate(SizeType n, Allocator<void>::ConstPtrType = nullptr) noexcept {
PtrType allocate(SizeType n, Allocator<void>::ConstPtrType = nullptr) {
return (PtrType) ::new uchar[n * sizeof(T)];
}
@ -601,13 +598,13 @@ namespace octa {
template<typename U> using Rebind = Allocator<U>;
ConstPtrType address(ConstRefType v) const noexcept {
ConstPtrType address(ConstRefType v) const {
return address_of(v);
};
SizeType max_size() const noexcept { return SizeType(~0) / sizeof(T); }
SizeType max_size() const { return SizeType(~0) / sizeof(T); }
PtrType allocate(SizeType n, Allocator<void>::ConstPtrType = nullptr) noexcept {
PtrType allocate(SizeType n, Allocator<void>::ConstPtrType = nullptr) {
return (PtrType) ::new uchar[n * sizeof(T)];
}
@ -622,12 +619,12 @@ namespace octa {
};
template<typename T, typename U>
bool operator==(const Allocator<T> &, const Allocator<U> &) noexcept {
bool operator==(const Allocator<T> &, const Allocator<U> &) {
return true;
}
template<typename T, typename U>
bool operator!=(const Allocator<T> &, const Allocator<U> &) noexcept {
bool operator!=(const Allocator<T> &, const Allocator<U> &) {
return false;
}
}

261
octa/range.h
View File

@ -26,7 +26,6 @@ namespace octa {
template<typename T>
struct __OctaRangeIterator {
/* no need to mark noexcept as it's never instantiated directly */
__OctaRangeIterator(): p_range() {}
explicit __OctaRangeIterator(const T &range): p_range(range) {}
__OctaRangeIterator &operator++() {
@ -52,14 +51,10 @@ namespace octa {
typedef V ValType;
typedef R RefType;
__OctaRangeIterator<B> begin() noexcept(
IsNothrowCopyConstructible<B>::value
) {
__OctaRangeIterator<B> begin() {
return __OctaRangeIterator<B>((const B &)*this);
}
__OctaRangeIterator<B> end() noexcept(
IsNothrowDefaultConstructible<B>::value
) {
__OctaRangeIterator<B> end() {
return __OctaRangeIterator<B>();
}
};
@ -83,106 +78,82 @@ namespace octa {
T p_range;
public:
ReverseRange() noexcept(IsNothrowDefaultConstructible<T>::value):
p_range() {}
ReverseRange(): p_range() {}
ReverseRange(const T &range) noexcept(
IsNothrowCopyConstructible<T>::value
): p_range(range) {}
ReverseRange(const T &range): p_range(range) {}
ReverseRange(const ReverseRange &it) noexcept(
IsNothrowCopyConstructible<T>::value
): p_range(it.p_range) {}
ReverseRange(const ReverseRange &it): p_range(it.p_range) {}
ReverseRange(ReverseRange &&it) noexcept(
IsNothrowMoveConstructible<T>::value
): p_range(move(it.p_range)) {}
ReverseRange(ReverseRange &&it): p_range(move(it.p_range)) {}
ReverseRange &operator=(const ReverseRange &v) noexcept(
IsNothrowCopyAssignable<T>::value
) {
ReverseRange &operator=(const ReverseRange &v) {
p_range = v.p_range;
return *this;
}
ReverseRange &operator=(ReverseRange &&v) noexcept(
IsNothrowMoveAssignable<T>::value
) {
ReverseRange &operator=(ReverseRange &&v) {
p_range = move(v.p_range);
return *this;
}
ReverseRange &operator=(const T &v) noexcept(
IsNothrowCopyAssignable<T>::value
) {
ReverseRange &operator=(const T &v) {
p_range = v;
return *this;
}
ReverseRange &operator=(T &&v) noexcept(
IsNothrowMoveAssignable<T>::value
) {
ReverseRange &operator=(T &&v) {
p_range = move(v);
return *this;
}
bool empty() const noexcept(noexcept(p_range.empty())) {
bool empty() const {
return p_range.empty();
}
r_size length() const noexcept(noexcept(p_range.length())) {
r_size length() const {
return p_range.length();
}
void pop_first() noexcept(noexcept(p_range.pop_last())) {
void pop_first() {
p_range.pop_last();
}
void pop_last() noexcept(noexcept(p_range.pop_first())) {
void pop_last() {
p_range.pop_first();
}
bool operator==(const ReverseRange &v) const noexcept(
noexcept(p_range == v.p_range)
) {
bool operator==(const ReverseRange &v) const {
return p_range == v.p_range;
}
bool operator!=(const ReverseRange &v) const noexcept(
noexcept(p_range != v.p_range)
) {
bool operator!=(const ReverseRange &v) const {
return p_range != v.p_range;
}
r_ref first() noexcept(noexcept(p_range.last())) {
r_ref first() {
return p_range.last();
}
r_ref first() const noexcept(noexcept(p_range.last())) {
r_ref first() const {
return p_range.last();
}
r_ref last() noexcept(noexcept(p_range.first())) {
r_ref last() {
return p_range.first();
}
r_ref last() const noexcept(noexcept(p_range.first())) {
r_ref last() const {
return p_range.first();
}
r_ref operator[](r_size i) noexcept(noexcept(p_range[0])) {
r_ref operator[](r_size i) {
return p_range[length() - i - 1];
}
r_ref operator[](r_size i) const noexcept(noexcept(p_range[0])) {
r_ref operator[](r_size i) const {
return p_range[length() - i - 1];
}
ReverseRange<T> slice(r_size start, r_size end) noexcept(
noexcept(ReverseRange<T>(p_range.slice(0, 0)))
&& noexcept(p_range.length())
) {
ReverseRange<T> slice(r_size start, r_size end) {
r_size len = p_range.length();
return ReverseRange<T>(p_range.slice(len - end, len - start));
}
};
template<typename T>
ReverseRange<T> make_reverse_range(const T &it) noexcept(
noexcept(ReverseRange<T>(it))
) {
ReverseRange<T> make_reverse_range(const T &it) {
return ReverseRange<T>(it);
}
@ -198,193 +169,170 @@ namespace octa {
T p_range;
public:
MoveRange() noexcept(IsNothrowDefaultConstructible<T>::value):
p_range() {}
MoveRange(): p_range() {}
MoveRange(const T &range) noexcept(
IsNothrowCopyConstructible<T>::value
): p_range(range) {}
MoveRange(const T &range): p_range(range) {}
MoveRange(const MoveRange &it) noexcept(
IsNothrowCopyConstructible<T>::value
): p_range(it.p_range) {}
MoveRange(const MoveRange &it): p_range(it.p_range) {}
MoveRange(MoveRange &&it) noexcept(
IsNothrowMoveConstructible<T>::value
): p_range(move(it.p_range)) {}
MoveRange(MoveRange &&it): p_range(move(it.p_range)) {}
MoveRange &operator=(const MoveRange &v) noexcept(
IsNothrowCopyAssignable<T>::value
) {
MoveRange &operator=(const MoveRange &v) {
p_range = v.p_range;
return *this;
}
MoveRange &operator=(MoveRange &&v) noexcept(
IsNothrowMoveAssignable<T>::value
) {
MoveRange &operator=(MoveRange &&v) {
p_range = move(v.p_range);
return *this;
}
MoveRange &operator=(const T &v) noexcept(
IsNothrowCopyAssignable<T>::value
) {
MoveRange &operator=(const T &v) {
p_range = v;
return *this;
}
MoveRange &operator=(T &&v) noexcept(
IsNothrowMoveAssignable<T>::value
) {
MoveRange &operator=(T &&v) {
p_range = move(v);
return *this;
}
bool empty() const noexcept(noexcept(p_range.empty())) {
bool empty() const {
return p_range.empty();
}
r_size length() const noexcept(noexcept(p_range.length())) {
r_size length() const {
return p_range.length();
}
void pop_first() noexcept(noexcept(p_range.pop_first())) {
void pop_first() {
p_range.pop_first();
}
void pop_last() noexcept(noexcept(p_range.pop_last())) {
void pop_last() {
p_range.pop_last();
}
bool operator==(const MoveRange &v) const noexcept(
noexcept(p_range == v.p_range)
) {
bool operator==(const MoveRange &v) const {
return p_range == v.p_range;
}
bool operator!=(const MoveRange &v) const noexcept(
noexcept(p_range != v.p_range)
) {
bool operator!=(const MoveRange &v) const {
return p_range != v.p_range;
}
r_ref first() noexcept(noexcept(p_range.first())) {
r_ref first() {
return move(p_range.first());
}
r_ref last() noexcept(noexcept(p_range.last())) {
r_ref last() {
return move(p_range.last());
}
r_ref operator[](r_size i) noexcept(noexcept(p_range[0])) {
r_ref operator[](r_size i) {
return move(p_range[i]);
}
MoveRange<T> slice(r_size start, r_size end) noexcept(
noexcept(MoveRange<T>(p_range.slice(start, end)))
) {
MoveRange<T> slice(r_size start, r_size end) {
return MoveRange<T>(p_range.slice(start, end));
}
void put(const r_val &v) noexcept(noexcept(p_range.put(v))) {
void put(const r_val &v) {
p_range.put(v);
}
void put(r_val &&v) noexcept(noexcept(p_range.put(move(v)))) {
void put(r_val &&v) {
p_range.put(move(v));
}
};
template<typename T>
MoveRange<T> make_move_range(const T &it) noexcept(
noexcept(MoveRange<T>(it))
) {
MoveRange<T> make_move_range(const T &it) {
return MoveRange<T>(it);
}
template<typename T>
struct NumberRange: InputRange<NumberRange<T>, ForwardRangeTag, T> {
NumberRange() noexcept: p_a(0), p_b(0), p_step(0) {}
NumberRange(const NumberRange &it) noexcept: p_a(it.p_a), p_b(it.p_b),
NumberRange(): p_a(0), p_b(0), p_step(0) {}
NumberRange(const NumberRange &it): p_a(it.p_a), p_b(it.p_b),
p_step(it.p_step) {}
NumberRange(T a, T b, T step = T(1)) noexcept: p_a(a), p_b(b),
NumberRange(T a, T b, T step = T(1)): p_a(a), p_b(b),
p_step(step) {}
NumberRange(T v) noexcept: p_a(0), p_b(v), p_step(1) {}
NumberRange(T v): p_a(0), p_b(v), p_step(1) {}
bool operator==(const NumberRange &v) const noexcept {
bool operator==(const NumberRange &v) const {
return p_a == v.p_a && p_b == v.p_b && p_step == v.p_step;
}
bool operator!=(const NumberRange &v) const noexcept {
bool operator!=(const NumberRange &v) const {
return p_a != v.p_a || p_b != v.p_b || p_step != v.p_step;
}
bool empty() const noexcept { return p_a * p_step >= p_b * p_step; }
void pop_first() noexcept { p_a += p_step; }
T &first() noexcept { return p_a; }
bool empty() const { return p_a * p_step >= p_b * p_step; }
void pop_first() { p_a += p_step; }
T &first() { return p_a; }
private:
T p_a, p_b, p_step;
};
template<typename T>
NumberRange<T> range(T a, T b, T step = T(1)) noexcept {
NumberRange<T> range(T a, T b, T step = T(1)) {
return NumberRange<T>(a, b, step);
}
template<typename T>
NumberRange<T> range(T v) noexcept {
NumberRange<T> range(T v) {
return NumberRange<T>(v);
}
template<typename T>
struct PointerRange: InputRange<PointerRange<T>, RandomAccessRangeTag, T> {
PointerRange() noexcept: p_beg(nullptr), p_end(nullptr) {}
PointerRange(const PointerRange &v) noexcept: p_beg(v.p_beg),
PointerRange(): p_beg(nullptr), p_end(nullptr) {}
PointerRange(const PointerRange &v): p_beg(v.p_beg),
p_end(v.p_end) {}
PointerRange(T *beg, T *end) noexcept: p_beg(beg), p_end(end) {}
PointerRange(T *beg, size_t n) noexcept: p_beg(beg), p_end(beg + n) {}
PointerRange(T *beg, T *end): p_beg(beg), p_end(end) {}
PointerRange(T *beg, size_t n): p_beg(beg), p_end(beg + n) {}
PointerRange &operator=(const PointerRange &v) noexcept {
PointerRange &operator=(const PointerRange &v) {
p_beg = v.p_beg;
p_end = v.p_end;
return *this;
}
bool operator==(const PointerRange &v) const noexcept {
bool operator==(const PointerRange &v) const {
return p_beg == v.p_beg && p_end == v.p_end;
}
bool operator!=(const PointerRange &v) const noexcept {
bool operator!=(const PointerRange &v) const {
return p_beg != v.p_beg || p_end != v.p_end;
}
/* satisfy InputRange / ForwardRange */
bool empty() const noexcept { return p_beg == nullptr; }
bool empty() const { return p_beg == nullptr; }
void pop_first() noexcept {
void pop_first() {
if (p_beg == nullptr) return;
if (++p_beg == p_end) p_beg = p_end = nullptr;
}
T &first() noexcept { return *p_beg; }
const T &first() const noexcept { return *p_beg; }
T &first() { return *p_beg; }
const T &first() const { return *p_beg; }
/* satisfy BidirectionalRange */
void pop_last() noexcept {
void pop_last() {
if (p_end-- == p_beg) { p_end = nullptr; return; }
if (p_end == p_beg) p_beg = p_end = nullptr;
}
T &last() noexcept { return *(p_end - 1); }
const T &last() const noexcept { return *(p_end - 1); }
T &last() { return *(p_end - 1); }
const T &last() const { return *(p_end - 1); }
/* satisfy RandomAccessRange */
size_t length() const noexcept { return p_end - p_beg; }
size_t length() const { return p_end - p_beg; }
PointerRange slice(size_t start, size_t end) noexcept {
PointerRange slice(size_t start, size_t end) {
return PointerRange(p_beg + start, p_beg + end);
}
T &operator[](size_t i) noexcept { return p_beg[i]; }
const T &operator[](size_t i) const noexcept { return p_beg[i]; }
T &operator[](size_t i) { return p_beg[i]; }
const T &operator[](size_t i) const { return p_beg[i]; }
/* satisfy OutputRange */
void put(const T &v) noexcept(IsNothrowCopyAssignable<T>::value) {
void put(const T &v) {
*(p_beg++) = v;
}
void put(T &&v) noexcept(IsNothrowMoveAssignable<T>::value) {
void put(T &&v) {
*(p_beg++) = move(v);
}
@ -412,85 +360,62 @@ namespace octa {
r_size p_index;
public:
EnumeratedRange() noexcept(IsNothrowDefaultConstructible<T>::value):
p_range(), p_index(0) {}
EnumeratedRange(): p_range(), p_index(0) {}
EnumeratedRange(const T &range) noexcept(
IsNothrowCopyConstructible<T>::value
): p_range(range), p_index(0) {}
EnumeratedRange(const T &range): p_range(range), p_index(0) {}
EnumeratedRange(const EnumeratedRange &it) noexcept(
IsNothrowCopyConstructible<T>::value
): p_range(it.p_range), p_index(it.p_index) {}
EnumeratedRange(const EnumeratedRange &it):
p_range(it.p_range), p_index(it.p_index) {}
EnumeratedRange(EnumeratedRange &&it) noexcept(
IsNothrowMoveConstructible<T>::value
): p_range(move(it.p_range)), p_index(it.p_index) {}
EnumeratedRange(EnumeratedRange &&it):
p_range(move(it.p_range)), p_index(it.p_index) {}
EnumeratedRange &operator=(const EnumeratedRange &v) noexcept(
IsNothrowCopyAssignable<T>::value
) {
EnumeratedRange &operator=(const EnumeratedRange &v) {
p_range = v.p_range;
p_index = v.p_index;
return *this;
}
EnumeratedRange &operator=(EnumeratedRange &&v) noexcept(
IsNothrowMoveAssignable<T>::value
) {
EnumeratedRange &operator=(EnumeratedRange &&v) {
p_range = move(v.p_range);
p_index = v.p_index;
return *this;
}
EnumeratedRange &operator=(const T &v) noexcept(
IsNothrowCopyAssignable<T>::value
) {
EnumeratedRange &operator=(const T &v) {
p_range = v;
p_index = 0;
return *this;
}
EnumeratedRange &operator=(T &&v) noexcept(
IsNothrowMoveAssignable<T>::value
) {
EnumeratedRange &operator=(T &&v) {
p_range = move(v);
p_index = 0;
return *this;
}
bool empty() const noexcept(noexcept(p_range.empty())) {
bool empty() const {
return p_range.empty();
}
void pop_first() noexcept(noexcept(p_range.pop_last())) {
void pop_first() {
++p_index; p_range.pop_first();
}
EnumeratedValue<r_ref, r_size> first() noexcept(
noexcept(p_range.first())
) {
EnumeratedValue<r_ref, r_size> first() {
return EnumeratedValue<r_ref, r_size> { p_index, p_range.first() };
}
EnumeratedValue<r_ref, r_size> first() const noexcept(
noexcept(p_range.first())
) {
EnumeratedValue<r_ref, r_size> first() const {
return EnumeratedValue<r_ref, r_size> { p_index, p_range.first() };
}
bool operator==(const EnumeratedRange &v) const noexcept(
noexcept(p_range == v.p_range)
) {
bool operator==(const EnumeratedRange &v) const {
return p_range == v.p_range;
}
bool operator!=(const EnumeratedRange &v) const noexcept(
noexcept(p_range != v.p_range)
) {
bool operator!=(const EnumeratedRange &v) const {
return p_range != v.p_range;
}
};
template<typename T>
EnumeratedRange<T> enumerate(const T &it) noexcept(
noexcept(EnumeratedRange<T>(it))
) {
EnumeratedRange<T> enumerate(const T &it) {
return EnumeratedRange<T>(it);
}
}

115
octa/type_traits.h
View File

@ -325,7 +325,7 @@ namespace octa {
decltype(__OCTA_MOVE(T(__octa_declval<A>()...))), True
>::Type __octa_is_ctible_test(T &&, A &&...);
#undef __OCTA_MOVE
//#undef __OCTA_MOVE
template<typename ...A> False __octa_is_ctible_test(__OctaAny, A &&...);
@ -578,115 +578,6 @@ namespace octa {
__has_trivial_destructor(T)
> {};
/* is nothrow constructible */
template<typename T, typename ...A>
struct IsNothrowConstructible: False {};
template<typename T>
struct IsNothrowConstructible<T>: IntegralConstant<bool,
__has_nothrow_constructor(T)
> {};
template<typename T>
struct IsNothrowConstructible<T, T &>: IntegralConstant<bool,
__has_nothrow_copy(T)
> {};
template<typename T>
struct IsNothrowConstructible<T, const T &>: IntegralConstant<bool,
__has_nothrow_copy(T)
> {};
template<typename T>
struct IsNothrowConstructible<T, T &&>: IntegralConstant<bool,
__has_nothrow_copy(T)
> {};
/* is nothrow default constructible */
template<typename T>
struct IsNothrowDefaultConstructible: IsNothrowConstructible<T> {};
/* is nothrow copy constructible */
template<typename T>
struct IsNothrowCopyConstructible: IsNothrowConstructible<T,
AddLvalueReference<const T>
> {};
/* is nothrow move constructible */
template<typename T>
struct IsNothrowMoveConstructible: IsNothrowConstructible<T,
AddRvalueReference<T>
> {};
/* is nothrow assignable */
template<typename T, typename ...A>
struct IsNothrowAssignable: False {};
template<typename T>
struct IsNothrowAssignable<T>: IntegralConstant<bool,
__has_nothrow_assign(T)
> {};
template<typename T>
struct IsNothrowAssignable<T, T &>: IntegralConstant<bool,
__has_nothrow_copy(T)
> {};
template<typename T>
struct IsNothrowAssignable<T, const T &>: IntegralConstant<bool,
__has_nothrow_copy(T)
> {};
template<typename T>
struct IsNothrowAssignable<T, T &&>: IntegralConstant<bool,
__has_nothrow_copy(T)
> {};
/* is nothrow copy assignable */
template<typename T>
struct IsNothrowCopyAssignable: IsNothrowAssignable<T,
AddLvalueReference<const T>
> {};
/* is nothrow move assignable */
template<typename T>
struct IsNothrowMoveAssignable: IsNothrowAssignable<T,
AddRvalueReference<T>
> {};
/* is nothrow destructible */
template<typename, bool> struct __OctaIsNothrowDtible;
template<typename T>
struct __OctaIsNothrowDtible<T, false>: False {};
template<typename T>
struct __OctaIsNothrowDtible<T, true>: IntegralConstant<bool,
(IsScalar<T>::value || noexcept(__octa_declval<T>().~T()))
> {};
template<typename T>
struct IsNothrowDestructible: __OctaIsNothrowDtible<T,
IsDestructible<T>::value
> {};
template<typename T, size_t N>
struct IsNothrowDestructible<T[N]>: IsNothrowDestructible<T> {};
template<typename T>
struct IsNothrowDestructible<T &>: IsNothrowDestructible<T> {};
template<typename T>
struct IsNothrowDestructible<T &&>: IsNothrowDestructible<T> {};
/* is base of */
template<typename B, typename D>
@ -1127,11 +1018,11 @@ namespace octa {
template<typename ...T> struct __OctaCommonType;
template<typename T> struct __OctaCommonType<T> {
typedef __OctaDecay<T> Type;
typedef Decay<T> Type;
};
template<typename T, typename U> struct __OctaCommonType<T, U> {
typedef __OctaDecay<decltype(true ? __octa_declval<T>()
typedef Decay<decltype(true ? __octa_declval<T>()
: __octa_declval<U>())> Type;
};

70
octa/utility.h
View File

@ -14,22 +14,19 @@ namespace octa {
/* move */
template<typename T>
static inline constexpr RemoveReference<T> &&
move(T &&v) noexcept {
static inline constexpr RemoveReference<T> &&move(T &&v) {
return static_cast<RemoveReference<T> &&>(v);
}
/* forward */
template<typename T>
static inline constexpr T &&
forward(RemoveReference<T> &v) noexcept {
static inline constexpr T &&forward(RemoveReference<T> &v) {
return static_cast<T &&>(v);
}
template<typename T>
static inline constexpr T &&
forward(RemoveReference<T> &&v) noexcept {
static inline constexpr T &&forward(RemoveReference<T> &&v) {
return static_cast<T &&>(v);
}
@ -39,18 +36,13 @@ namespace octa {
/* swap */
template<typename T> void swap(T &a, T &b) noexcept(
IsNothrowMoveConstructible<T>::value
&& IsNothrowMoveAssignable<T>::value
) {
template<typename T> void swap(T &a, T &b) {
T c(move(a));
a = move(b);
b = move(c);
}
template<typename T, size_t N> void swap(T (&a)[N], T (&b)[N]) noexcept(
noexcept(swap(*a, *b))
) {
template<typename T, size_t N> void swap(T (&a)[N], T (&b)[N]) {
for (size_t i = 0; i < N; ++i) {
swap(a[i], b[i]);
}
@ -63,64 +55,37 @@ namespace octa {
T first;
U second;
Pair() noexcept(
IsNothrowDefaultConstructible<T>::value
&& IsNothrowDefaultConstructible<U>::value
) = default;
Pair() = default;
~Pair() = default;
Pair(const Pair &) noexcept(
IsNothrowCopyConstructible<T>::value
&& IsNothrowCopyConstructible<U>::value
) = default;
Pair(Pair &&) noexcept(
IsNothrowMoveConstructible<T>::value
&& IsNothrowMoveConstructible<U>::value
) = default;
Pair(const Pair &) = default;
Pair(Pair &&) = default;
Pair(const T &x, const U &y) noexcept(
IsNothrowCopyConstructible<T>::value
&& IsNothrowCopyConstructible<U>::value
): first(x), second(y) {}
Pair(const T &x, const U &y): first(x), second(y) {}
template<typename TT, typename UU>
Pair(TT &&x, UU &&y): first(forward<TT>(x)), second(forward<UU>(y)) {}
template<typename TT, typename UU>
Pair(const Pair<TT, UU> &v) noexcept(
IsNothrowCopyConstructible<T>::value
&& IsNothrowCopyConstructible<U>::value
): first(v.first), second(v.second) {}
Pair(const Pair<TT, UU> &v): first(v.first), second(v.second) {}
template<typename TT, typename UU>
Pair(Pair<TT, UU> &&v) noexcept(
IsNothrowMoveConstructible<T>::value
&& IsNothrowMoveConstructible<U>::value
): first(move(v.first)), second(move(v.second)) {}
Pair(Pair<TT, UU> &&v): first(move(v.first)), second(move(v.second)) {}
Pair &operator=(const Pair &v) noexcept(
IsNothrowCopyAssignable<T>::value
&& IsNothrowCopyAssignable<U>::value
) {
Pair &operator=(const Pair &v) {
first = v.first;
second = v.second;
return *this;
}
template<typename TT, typename UU>
Pair &operator=(const Pair<TT, UU> &v) noexcept(
IsNothrowCopyAssignable<T>::value
&& IsNothrowCopyAssignable<U>::value
) {
Pair &operator=(const Pair<TT, UU> &v) {
first = v.first;
second = v.second;
return *this;
}
Pair &operator=(Pair &&v) noexcept(
IsNothrowMoveAssignable<T>::value
&& IsNothrowMoveAssignable<U>::value
) {
Pair &operator=(Pair &&v) {
first = move(v.first);
second = move(v.second);
return *this;
@ -133,17 +98,14 @@ namespace octa {
return *this;
}
void swap(Pair &v) noexcept(
noexcept(octa::swap(first, v.first))
&& noexcept(octa::swap(second, v.second))
) {
void swap(Pair &v) {
octa::swap(first, v.first);
octa::swap(second, v.second);
}
};
template<typename T, typename U>
void swap(Pair<T, U> &a, Pair<T, U> &b) noexcept(noexcept(a.swap(b))) {
void swap(Pair<T, U> &a, Pair<T, U> &b) {
a.swap(b);
}
}

140
octa/vector.h
View File

@ -22,11 +22,7 @@ namespace octa {
T *p_buf;
size_t p_len, p_cap;
void insert_base(size_t idx, size_t n) noexcept(
IsNothrowDestructible<T>::value
&& IsNothrowMoveConstructible<T>::value
&& IsNothrowMoveAssignable<T>::value
) {
void insert_base(size_t idx, size_t n) {
if (p_len + n > p_cap) reserve(p_len + n);
p_len += n;
for (size_t i = p_len - 1; i > idx + n - 1; --i) {
@ -47,33 +43,25 @@ namespace octa {
typedef PointerRange< T> RangeType;
typedef PointerRange<const T> ConstRangeType;
Vector() noexcept: p_buf(nullptr), p_len(0), p_cap(0) {}
Vector(): p_buf(nullptr), p_len(0), p_cap(0) {}
explicit Vector(size_t n, const T &val = T()) noexcept(
IsNothrowCopyConstructible<T>::value
): Vector() {
explicit Vector(size_t n, const T &val = T()): Vector() {
p_buf = new uchar[n * sizeof(T)];
p_len = p_cap = n;
T *cur = p_buf, *last = p_buf + n;
while (cur != last) new (cur++) T(val);
}
Vector(const Vector &v) noexcept(
IsNothrowDestructible<T>::value
&& IsNothrowCopyConstructible<T>::value
): Vector() {
Vector(const Vector &v): Vector() {
*this = v;
}
Vector(Vector &&v) noexcept: p_buf(v.p_buf), p_len(v.p_len),
p_cap(v.p_cap) {
Vector(Vector &&v): p_buf(v.p_buf), p_len(v.p_len), p_cap(v.p_cap) {
v.p_buf = nullptr;
v.p_len = v.p_cap = 0;
}
Vector(InitializerList<T> v) noexcept(
IsNothrowCopyConstructible<T>::value
): Vector() {
Vector(InitializerList<T> v): Vector() {
size_t len = v.length();
const T *ptr = v.get();
reserve(len);
@ -82,14 +70,14 @@ namespace octa {
p_len = len;
}
~Vector() noexcept(IsNothrowDestructible<T>::value) {
~Vector() {
clear();
delete[] (uchar *)p_buf;
p_buf = nullptr;
p_cap = 0;
}
void clear() noexcept(IsNothrowDestructible<T>::value) {
void clear() {
if (p_len > 0 && !octa::IsPod<T>()) {
T *cur = p_buf, *last = p_buf + p_len;
while (cur != last) (*cur++).~T();
@ -97,10 +85,7 @@ namespace octa {
p_len = 0;
}
Vector<T> &operator=(const Vector<T> &v) noexcept(
IsNothrowDestructible<T>::value
&& IsNothrowCopyConstructible<T>::value
) {
Vector<T> &operator=(const Vector<T> &v) {
if (this == &v) return *this;
clear();
reserve(v.p_cap);
@ -117,9 +102,7 @@ namespace octa {
return *this;
}
Vector<T> &operator=(Vector<T> &&v) noexcept(
IsNothrowDestructible<T>::value
) {
Vector<T> &operator=(Vector<T> &&v) {
clear();
delete[] (uchar *)p_buf;
p_len = v.p_len;
@ -128,10 +111,7 @@ namespace octa {
return *this;
}
Vector<T> &operator=(InitializerList<T> il) noexcept(
IsNothrowDestructible<T>::value &&
IsNothrowCopyConstructible<T>::value
) {
Vector<T> &operator=(InitializerList<T> il) {
clear();
size_t ilen = il.length();
reserve(ilen);
@ -147,11 +127,7 @@ namespace octa {
return *this;
}
void resize(size_t n, const T &v = T()) noexcept(
IsNothrowDestructible<T>::value
&& IsNothrowMoveConstructible<T>::value
&& IsNothrowCopyConstructible<T>::value
) {
void resize(size_t n, const T &v = T()) {
size_t len = p_len;
reserve(n);
p_len = n;
@ -166,10 +142,7 @@ namespace octa {
}
}
void reserve(size_t n) noexcept(
IsNothrowDestructible<T>::value
&& IsNothrowMoveConstructible<T>::value
) {
void reserve(size_t n) {
if (n <= p_len) {
if (n == p_len) return;
while (p_len > n) pop();
@ -198,25 +171,19 @@ namespace octa {
p_buf = tmp;
}
T &operator[](size_t i) noexcept { return p_buf[i]; }
const T &operator[](size_t i) const noexcept { return p_buf[i]; }
T &operator[](size_t i) { return p_buf[i]; }
const T &operator[](size_t i) const { return p_buf[i]; }
T &at(size_t i) noexcept { return p_buf[i]; }
const T &at(size_t i) const noexcept { return p_buf[i]; }
T &at(size_t i) { return p_buf[i]; }
const T &at(size_t i) const { return p_buf[i]; }
T &push(const T &v) noexcept(
noexcept(noexcept(reserve(0))) &&
IsNothrowCopyConstructible<T>::value
) {
T &push(const T &v) {
if (p_len == p_cap) reserve(p_len + 1);
new (&p_buf[p_len]) T(v);
return p_buf[p_len++];
}
T &push() noexcept(
noexcept(noexcept(reserve(0))) &&
IsNothrowDefaultConstructible<T>::value
) {
T &push() {
if (p_len == p_cap) reserve(p_len + 1);
new (&p_buf[p_len]) T;
return p_buf[p_len++];
@ -229,7 +196,7 @@ namespace octa {
return p_buf[p_len++];
}
void pop() noexcept(IsNothrowDestructible<T>::value) {
void pop() {
if (!octa::IsPod<T>()) {
p_buf[--p_len].~T();
} else {
@ -237,60 +204,46 @@ namespace octa {
}
}
T &first() noexcept { return p_buf[0]; }
const T &first() const noexcept { return p_buf[0]; };
T &first() { return p_buf[0]; }
const T &first() const { return p_buf[0]; };
T &last() noexcept { return p_buf[p_len - 1]; }
const T &last() const noexcept { return p_buf[p_len - 1]; }
T &last() { return p_buf[p_len - 1]; }
const T &last() const { return p_buf[p_len - 1]; }
T *get() noexcept { return p_buf; }
const T *get() const noexcept { return p_buf; }
T *get() { return p_buf; }
const T *get() const { return p_buf; }
size_t length() const noexcept { return p_len; }
size_t capacity() const noexcept { return p_cap; }
size_t length() const { return p_len; }
size_t capacity() const { return p_cap; }
bool empty() const noexcept { return (p_len == 0); }
bool empty() const { return (p_len == 0); }
bool in_range(size_t idx) noexcept { return idx < p_len; }
bool in_range(int idx) noexcept { return idx >= 0 && idx < p_len; }
bool in_range(const T *ptr) noexcept {
bool in_range(size_t idx) { return idx < p_len; }
bool in_range(int idx) { return idx >= 0 && idx < p_len; }
bool in_range(const T *ptr) {
return ptr >= p_buf && ptr < &p_buf[p_len];
}
T *disown() noexcept {
T *disown() {
T *r = p_buf;
p_buf = nullptr;
p_len = p_cap = 0;
return r;
}
T *insert(size_t idx, T &&v) noexcept(
IsNothrowDestructible<T>::value
&& IsNothrowMoveConstructible<T>::value
&& IsNothrowMoveAssignable<T>::value
) {
T *insert(size_t idx, T &&v) {
insert_base(idx, 1);
p_buf[idx] = move(v);
return &p_buf[idx];
}
T *insert(size_t idx, const T &v) noexcept(
IsNothrowDestructible<T>::value
&& IsNothrowMoveConstructible<T>::value
&& IsNothrowMoveAssignable<T>::value
&& IsNothrowCopyAssignable<T>::value
) {
T *insert(size_t idx, const T &v) {
insert_base(idx, 1);
p_buf[idx] = v;
return &p_buf[idx];
}
T *insert(size_t idx, size_t n, const T &v) noexcept(
IsNothrowDestructible<T>::value
&& IsNothrowMoveConstructible<T>::value
&& IsNothrowMoveAssignable<T>::value
&& IsNothrowCopyAssignable<T>::value
) {
T *insert(size_t idx, size_t n, const T &v) {
insert_base(idx, n);
for (size_t i = 0; i < n; ++i) {
p_buf[idx + i] = v;
@ -299,14 +252,7 @@ namespace octa {
}
template<typename U>
T *insert_range(size_t idx, U range) noexcept(
IsNothrowDestructible<T>::value
&& IsNothrowMoveConstructible<T>::value
&& IsNothrowMoveAssignable<T>::value
&& noexcept(range.first())
&& noexcept(range.pop_first())
&& noexcept((*p_buf = range.first()))
) {
T *insert_range(size_t idx, U range) {
size_t len = range.length();
insert_base(idx, len);
for (size_t i = 0; i < len; ++i) {
@ -316,20 +262,18 @@ namespace octa {
return &p_buf[idx];
}
T *insert(size_t idx, InitializerList<T> il) noexcept(
noexcept(declval<Vector<T>>().insert_range(idx, il.range()))
) {
T *insert(size_t idx, InitializerList<T> il) {
return insert_range(idx, il.range());
}
RangeType each() noexcept {
RangeType each() {
return PointerRange<T>(p_buf, p_buf + p_len);
}
ConstRangeType each() const noexcept {
ConstRangeType each() const {
return PointerRange<const T>(p_buf, p_buf + p_len);
}
void swap(Vector &v) noexcept {
void swap(Vector &v) {
swap(p_len, v.p_len);
swap(p_cap, v.p_cap);
swap(p_buf, v.p_buf);
@ -337,7 +281,7 @@ namespace octa {
};
template<typename T>
void swap(Vector<T> &a, Vector<T> &b) noexcept {
void swap(Vector<T> &a, Vector<T> &b) {
a.swap(b);
}
}