diff --git a/octa/array.h b/octa/array.h index e5490df..f490876 100644 --- a/octa/array.h +++ b/octa/array.h @@ -23,39 +23,39 @@ namespace octa { typedef PointerRange< T> RangeType; typedef PointerRange 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(), declval())) { + void swap(Array &v)(swap(declval(), declval())) { swap(p_buf, v.p_buf); } - RangeType each() noexcept { + RangeType each() { return PointerRange(p_buf, p_buf + N); } - ConstRangeType each() const noexcept { + ConstRangeType each() const { return PointerRange(p_buf, p_buf + N); } @@ -63,7 +63,7 @@ namespace octa { }; template - void swap(Array &a, Array &b) noexcept(noexcept(a.swap(b))) { + void swap(Array &a, Array &b) { a.swap(b); } } diff --git a/octa/atomic.h b/octa/atomic.h index 5870960..d561730 100644 --- a/octa/atomic.h +++ b/octa/atomic.h @@ -24,8 +24,8 @@ namespace octa { template 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 struct __OctaMsvcAtomicStore { - 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 struct __OctaMsvcAtomicStore { - 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 struct __OctaMsvcAtomicStore { - 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 struct __OctaMsvcAtomicStore { - 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 struct __OctaMsvcAtomicLoad { - static inline void load(volatile T *src, T *dst) - noexcept { *dst = *src; } + static inline void load(volatile T *src, T *dst) { *dst = *src; } }; template struct __OctaMsvcAtomicLoad { - static inline void load(volatile T *src, T *dst) - noexcept { *dst = *src; } + static inline void load(volatile T *src, T *dst) { *dst = *src; } }; template struct __OctaMsvcAtomicLoad { - static inline void load(volatile T *src, T *dst) - noexcept { *dst = *src; } + static inline void load(volatile T *src, T *dst) { *dst = *src; } }; template struct __OctaMsvcAtomicLoad { - 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 struct __OctaMsvcAtomicExchange { - 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 struct __OctaMsvcAtomicExchange { - 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 struct __OctaMsvcAtomicExchange { - 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 struct __OctaMsvcAtomicExchange { - 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 struct __OctaMsvcAtomicCompareExchange { - 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 struct __OctaMsvcAtomicCompareExchange { - 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 struct __OctaMsvcAtomicCompareExchange { - 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 struct __OctaMsvcAtomicCompareExchange { - 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 inline T kill_dependency(T v) noexcept { + template inline T kill_dependency(T v) { return v; } @@ -676,93 +660,87 @@ namespace octa { struct __OctaAtomic { mutable __OctaAtomicBase 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: __OctaAtomic { typedef __OctaAtomic 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 struct Atomic: __OctaAtomic { typedef __OctaAtomic 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: __OctaAtomic { typedef __OctaAtomic 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 - inline bool atomic_is_lock_free(const volatile Atomic *a) noexcept { + inline bool atomic_is_lock_free(const volatile Atomic *a) { return a->is_lock_free(); } template - inline bool atomic_is_lock_free(const Atomic *a) noexcept { + inline bool atomic_is_lock_free(const Atomic *a) { return a->is_lock_free(); } template - inline void atomic_init(volatile Atomic *a, T v) noexcept { + inline void atomic_init(volatile Atomic *a, T v) { __octa_atomic_init(&a->p_a, v); } template - inline void atomic_init(Atomic *a, T v) noexcept { + inline void atomic_init(Atomic *a, T v) { __octa_atomic_init(&a->p_a, v); } template - inline void atomic_store(volatile Atomic *a, T v) noexcept { + inline void atomic_store(volatile Atomic *a, T v) { a->store(v); } template - inline void atomic_store(Atomic *a, T v) noexcept { + inline void atomic_store(Atomic *a, T v) { a->store(v); } template inline void atomic_store_explicit(volatile Atomic *a, T v, - MemoryOrder ord) - noexcept { + MemoryOrder ord) { a->store(v, ord); } template - inline void atomic_store_explicit(Atomic *a, T v, MemoryOrder ord) - noexcept { + inline void atomic_store_explicit(Atomic *a, T v, MemoryOrder ord) { a->store(v, ord); } template - inline T atomic_load(const volatile Atomic *a) noexcept { + inline T atomic_load(const volatile Atomic *a) { return a->load(); } template - inline T atomic_load(const Atomic *a) noexcept { + inline T atomic_load(const Atomic *a) { return a->load(); } template inline T atomic_load_explicit(const volatile Atomic *a, - MemoryOrder ord) - noexcept { + MemoryOrder ord) { return a->load(ord); } template - inline T atomic_load_explicit(const Atomic *a, MemoryOrder ord) - noexcept { + inline T atomic_load_explicit(const Atomic *a, MemoryOrder ord) { return a->load(ord); } template - inline T atomic_exchange(volatile Atomic *a, T v) noexcept { + inline T atomic_exchange(volatile Atomic *a, T v) { return a->exchange(v); } template - inline T atomic_exchange(Atomic *a, T v) noexcept { + inline T atomic_exchange(Atomic *a, T v) { return a->exchange(v); } template inline T atomic_exchange_explicit(volatile Atomic *a, T v, - MemoryOrder ord) - noexcept { + MemoryOrder ord) { return a->exchange(v, ord); } template - inline T atomic_exchange_explicit(Atomic *a, T v, MemoryOrder ord) - noexcept { + inline T atomic_exchange_explicit(Atomic *a, T v, MemoryOrder ord) { return a->exchange(v, ord); } template - inline bool atomic_compare_exchange_weak(volatile Atomic *a, T *e, T v) - noexcept { + inline bool atomic_compare_exchange_weak(volatile Atomic *a, T *e, T v) { return a->compare_exchange_weak(*e, v); } template - inline bool atomic_compare_exchange_weak(Atomic *a, T *e, T v) noexcept { + inline bool atomic_compare_exchange_weak(Atomic *a, T *e, T v) { return a->compare_exchange_weak(*e, v); } template - inline bool atomic_compare_exchange_strong(volatile Atomic *a, T *e, T v) - noexcept { + inline bool atomic_compare_exchange_strong(volatile Atomic *a, T *e, T v) { return a->compare_exchange_strong(*e, v); } template - inline bool atomic_compare_exchange_strong(Atomic *a, T *e, T v) - noexcept { + inline bool atomic_compare_exchange_strong(Atomic *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 *a, T *e, T v, MemoryOrder s, - MemoryOrder f) - noexcept { + MemoryOrder f) { return a->compare_exchange_weak(*e, v, s, f); } template inline bool atomic_compare_exchange_weak_explicit(Atomic *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 *a, T *e, T v, MemoryOrder s, - MemoryOrder f) - noexcept { + MemoryOrder f) { return a->compare_exchange_strong(*e, v, s, f); } template inline bool atomic_compare_exchange_strong_explicit(Atomic *a, T *e, T v, MemoryOrder s, - MemoryOrder f) - noexcept { + MemoryOrder f) { return a->compare_exchange_strong(*e, v, s, f); } template inline EnableIf::value && !IsSame::value, T> - atomic_fetch_add(volatile Atomic *a, T op) noexcept { + atomic_fetch_add(volatile Atomic *a, T op) { return a->fetch_add(op); } template inline EnableIf::value && !IsSame::value, T> - atomic_fetch_add(Atomic *a, T op) noexcept { + atomic_fetch_add(Atomic *a, T op) { return a->fetch_add(op); } template - inline T *atomic_fetch_add(volatile Atomic *a, ptrdiff_t op) noexcept { + inline T *atomic_fetch_add(volatile Atomic *a, ptrdiff_t op) { return a->fetch_add(op); } template - inline T *atomic_fetch_add(Atomic *a, ptrdiff_t op) noexcept { + inline T *atomic_fetch_add(Atomic *a, ptrdiff_t op) { return a->fetch_add(op); } template inline EnableIf::value && !IsSame::value, T> - atomic_fetch_add_explicit(volatile Atomic *a, T op, MemoryOrder ord) - noexcept { + atomic_fetch_add_explicit(volatile Atomic *a, T op, MemoryOrder ord) { return a->fetch_add(op, ord); } template inline EnableIf::value && !IsSame::value, T> - atomic_fetch_add_explicit(Atomic *a, T op, MemoryOrder ord) noexcept { + atomic_fetch_add_explicit(Atomic *a, T op, MemoryOrder ord) { return a->fetch_add(op, ord); } template inline T *atomic_fetch_add_explicit(volatile Atomic *a, ptrdiff_t op, - MemoryOrder ord) - noexcept { + MemoryOrder ord) { return a->fetch_add(op, ord); } template inline T *atomic_fetch_add_explicit(Atomic *a, ptrdiff_t op, - MemoryOrder ord) - noexcept { + MemoryOrder ord) { return a->fetch_add(op, ord); } template inline EnableIf::value && !IsSame::value, T> - atomic_fetch_sub(volatile Atomic *a, T op) noexcept { + atomic_fetch_sub(volatile Atomic *a, T op) { return a->fetch_sub(op); } template inline EnableIf::value && !IsSame::value, T> - atomic_fetch_sub(Atomic *a, T op) noexcept { + atomic_fetch_sub(Atomic *a, T op) { return a->fetch_sub(op); } template - inline T *atomic_fetch_sub(volatile Atomic *a, ptrdiff_t op) noexcept { + inline T *atomic_fetch_sub(volatile Atomic *a, ptrdiff_t op) { return a->fetch_sub(op); } template - inline T *atomic_fetch_sub(Atomic *a, ptrdiff_t op) noexcept { + inline T *atomic_fetch_sub(Atomic *a, ptrdiff_t op) { return a->fetch_sub(op); } template inline EnableIf::value && !IsSame::value, T> - atomic_fetch_sub_explicit(volatile Atomic *a, T op, MemoryOrder ord) - noexcept { + atomic_fetch_sub_explicit(volatile Atomic *a, T op, MemoryOrder ord) { return a->fetch_sub(op, ord); } template inline EnableIf::value && !IsSame::value, T> - atomic_fetch_sub_explicit(Atomic *a, T op, MemoryOrder ord) noexcept { + atomic_fetch_sub_explicit(Atomic *a, T op, MemoryOrder ord) { return a->fetch_sub(op, ord); } template inline T *atomic_fetch_sub_explicit(volatile Atomic *a, ptrdiff_t op, - MemoryOrder ord) - noexcept { + MemoryOrder ord) { return a->fetch_sub(op, ord); } template inline T *atomic_fetch_sub_explicit(Atomic *a, ptrdiff_t op, - MemoryOrder ord) - noexcept { + MemoryOrder ord) { return a->fetch_sub(op, ord); } template inline EnableIf::value && !IsSame::value, T> - atomic_fetch_and(volatile Atomic *a, T op) noexcept { + atomic_fetch_and(volatile Atomic *a, T op) { return a->fetch_and(op); } template inline EnableIf::value && !IsSame::value, T> - atomic_fetch_and(Atomic *a, T op) noexcept { + atomic_fetch_and(Atomic *a, T op) { return a->fetch_and(op); } template inline EnableIf::value && !IsSame::value, T> - atomic_fetch_and_explicit(volatile Atomic *a, T op, MemoryOrder ord) - noexcept { + atomic_fetch_and_explicit(volatile Atomic *a, T op, MemoryOrder ord) { return a->fetch_and(op, ord); } template inline EnableIf::value && !IsSame::value, T> - atomic_fetch_and_explicit(Atomic *a, T op, MemoryOrder ord) noexcept { + atomic_fetch_and_explicit(Atomic *a, T op, MemoryOrder ord) { return a->fetch_and(op, ord); } template inline EnableIf::value && !IsSame::value, T> - atomic_fetch_or(volatile Atomic *a, T op) noexcept { + atomic_fetch_or(volatile Atomic *a, T op) { return a->fetch_or(op); } template inline EnableIf::value && !IsSame::value, T> - atomic_fetch_or(Atomic *a, T op) noexcept { + atomic_fetch_or(Atomic *a, T op) { return a->fetch_or(op); } template inline EnableIf::value && !IsSame::value, T> - atomic_fetch_or_explicit(volatile Atomic *a, T op, MemoryOrder ord) - noexcept { + atomic_fetch_or_explicit(volatile Atomic *a, T op, MemoryOrder ord) { return a->fetch_or(op, ord); } template inline EnableIf::value && !IsSame::value, T> - atomic_fetch_or_explicit(Atomic *a, T op, MemoryOrder ord) noexcept { + atomic_fetch_or_explicit(Atomic *a, T op, MemoryOrder ord) { return a->fetch_or(op, ord); } template inline EnableIf::value && !IsSame::value, T> - atomic_fetch_xor(volatile Atomic *a, T op) noexcept { + atomic_fetch_xor(volatile Atomic *a, T op) { return a->fetch_xor(op); } template inline EnableIf::value && !IsSame::value, T> - atomic_fetch_xor(Atomic *a, T op) noexcept { + atomic_fetch_xor(Atomic *a, T op) { return a->fetch_xor(op); } template inline EnableIf::value && !IsSame::value, T> - atomic_fetch_xor_explicit(volatile Atomic *a, T op, MemoryOrder ord) - noexcept { + atomic_fetch_xor_explicit(volatile Atomic *a, T op, MemoryOrder ord) { return a->fetch_xor(op, ord); } template inline EnableIf::value && !IsSame::value, T> - atomic_fetch_xor_explicit(Atomic *a, T op, MemoryOrder ord) noexcept { + atomic_fetch_xor_explicit(Atomic *a, T op, MemoryOrder ord) { return a->fetch_xor(op, ord); } struct AtomicFlag { __OctaAtomicBase 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); } diff --git a/octa/functional.h b/octa/functional.h index 44df855..7c8a92c 100644 --- a/octa/functional.h +++ b/octa/functional.h @@ -16,9 +16,7 @@ namespace octa { #define __OCTA_DEFINE_BINARY_OP(name, op, rettype) \ template 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 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 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::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::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 UnaryNegate not1(const T &fn) noexcept( - IsNothrowCopyConstructible>::value - ) { + template UnaryNegate not1(const T &fn) { return UnaryNegate(fn); } - template BinaryNegate not2(const T &fn) noexcept( - IsNothrowCopyConstructible>::value - ) { + template BinaryNegate not2(const T &fn) { return BinaryNegate(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: __OctaScalarHash {}; template<> struct Hash: __OctaScalarHash { - size_t operator()(float v) const noexcept { + size_t operator()(float v) const { if (v == 0) return 0; return __OctaScalarHash::operator()(v); } }; template<> struct Hash: __OctaScalarHash { - size_t operator()(double v) const noexcept { + size_t operator()(double v) const { if (v == 0) return 0; return __OctaScalarHash::operator()(v); } }; template<> struct Hash: __OctaScalarHash { - 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 - ReferenceWrapper ref(T &v) noexcept { + ReferenceWrapper ref(T &v) { return ReferenceWrapper(v); } template - ReferenceWrapper ref(ReferenceWrapper v) noexcept { + ReferenceWrapper ref(ReferenceWrapper v) { return ReferenceWrapper(v); } template void ref(const T &&) = delete; template - ReferenceWrapper cref(const T &v) noexcept { + ReferenceWrapper cref(const T &v) { return ReferenceWrapper(v); } template - ReferenceWrapper cref(ReferenceWrapper v) noexcept { + ReferenceWrapper cref(ReferenceWrapper v) { return ReferenceWrapper(v); } template void cref(const T &&) = delete; @@ -339,7 +327,7 @@ namespace octa { }; template - __OctaMemFn mem_fn(R T:: *ptr) noexcept { + __OctaMemFn mem_fn(R T:: *ptr) { return __OctaMemFn(ptr); } @@ -357,7 +345,7 @@ namespace octa { struct __OctaFunctorInPlace { static constexpr bool value = sizeof(T) <= sizeof(__OctaFunctorData) && (alignof(__OctaFunctorData) % alignof(T)) == 0 - && octa::IsNothrowMoveConstructible(); + && octa::IsMoveConstructible::value; }; template @@ -371,15 +359,15 @@ namespace octa { new (&get_ref(s)) T(forward(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(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 struct Function: __OctaFunction { - 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 Function(T f, EnableIf::value, __OctaEmpty> - = __OctaEmpty()) - noexcept(__OctaFunctorInPlace::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(args)...); } - template - void assign(F &&f) noexcept(__OctaFunctorInPlace::value) { + template void assign(F &&f) { Function(forward(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::store_f(p_stor.data, forward(f)); } - void initialize_empty() noexcept { + void initialize_empty() { typedef R(*emptyf)(A...); p_call = nullptr; p_stor.manager = &__octa_get_default_fm(); @@ -632,21 +618,21 @@ namespace octa { }; template - void swap(Function &a, Function &b) noexcept { + void swap(Function &a, Function &b) { a.swap(b); } template - bool operator==(nullptr_t, const Function &rhs) noexcept { return !rhs; } + bool operator==(nullptr_t, const Function &rhs) { return !rhs; } template - bool operator==(const Function &lhs, nullptr_t) noexcept { return !lhs; } + bool operator==(const Function &lhs, nullptr_t) { return !lhs; } template - bool operator!=(nullptr_t, const Function &rhs) noexcept { return rhs; } + bool operator!=(nullptr_t, const Function &rhs) { return rhs; } template - bool operator!=(const Function &lhs, nullptr_t) noexcept { return lhs; } + bool operator!=(const Function &lhs, nullptr_t) { return lhs; } } #endif \ No newline at end of file diff --git a/octa/initializer_list.h b/octa/initializer_list.h index 9f6022a..cd559c8 100644 --- a/octa/initializer_list.h +++ b/octa/initializer_list.h @@ -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 range() noexcept { + octa::PointerRange range() { return octa::PointerRange(p_buf, p_len); } }; diff --git a/octa/memory.h b/octa/memory.h index f9b7357..1f9c818 100644 --- a/octa/memory.h +++ b/octa/memory.h @@ -15,7 +15,7 @@ namespace octa { /* address of */ - template constexpr T *address_of(T &v) noexcept { + template constexpr T *address_of(T &v) { return reinterpret_cast(&const_cast (reinterpret_cast(v))); } @@ -156,15 +156,15 @@ namespace octa { struct __OctaPtrTraitsPointerTo { static T pointer_to(Conditional>::value, __OctaPtrTraitsNat, PointerElement - > &r) noexcept(noexcept(T::pointer_to(r))) { + > &r) { return T::pointer_to(r); } }; template struct __OctaPtrTraitsPointerTo { - static T pointer_to(Conditional::value, __OctaPtrTraitsNat, T> &r) - noexcept { + static T pointer_to(Conditional::value, __OctaPtrTraitsNat, T + > &r) { return octa::address_of(r); } }; @@ -172,7 +172,7 @@ namespace octa { template static T pointer_to(Conditional>::value, __OctaPtrTraitsNat, PointerElement - > &r) noexcept(noexcept(__OctaPtrTraitsPointerTo::pointer_to(r))) { + > &r) { return __OctaPtrTraitsPointerTo::pointer_to(r); } @@ -184,7 +184,7 @@ namespace octa { template DefaultDelete(const DefaultDelete &) {}; - void operator()(T *p) const noexcept { + void operator()(T *p) const { delete p; } }; @@ -195,7 +195,7 @@ namespace octa { template DefaultDelete(const DefaultDelete &) {}; - void operator()(T *p) const noexcept { + void operator()(T *p) const { delete[] p; } template void operator()(U *) const = delete; @@ -214,13 +214,12 @@ namespace octa { public: template - __OctaBoxPair(T *ptr, D &&dltr) noexcept: - i_ptr(ptr), p_del(forward(dltr)) {} + __OctaBoxPair(T *ptr, D &&dltr): i_ptr(ptr), p_del(forward(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 - __OctaBoxPair(T *ptr, D &&dltr) noexcept: - U(forward(dltr)), i_ptr(ptr) {} + __OctaBoxPair(T *ptr, D &&dltr): U(forward(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_cref; public: - constexpr Box() noexcept: p_stor(nullptr, D()) { + constexpr Box(): p_stor(nullptr, D()) { static_assert(!IsPointer::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::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::value, "Box constructed with null fptr deleter"); } Box(PtrType p, Conditional::value, D, AddLvalueReference - > d) noexcept: p_stor(p, d) {} + > d): p_stor(p, d) {} - Box(PtrType p, RemoveReference &&d) noexcept: p_stor(p, move(d)) { + Box(PtrType p, RemoveReference &&d): p_stor(p, move(d)) { static_assert(!IsReference::value, "rvalue deleter cannot be a ref"); } - Box(Box &&u) noexcept: p_stor(u.release(), forward(u.get_deleter())) {} + Box(Box &&u): p_stor(u.release(), forward(u.get_deleter())) {} template Box(Box &&u, EnableIf::value && IsConvertible::PtrType, PtrType>::value && IsConvertible::value && (!IsReference::value || IsSame::value) - > = __OctaNat()) noexcept: p_stor(u.release(), - forward
(u.get_deleter())) {} + > = __OctaNat()): p_stor(u.release(), forward
(u.get_deleter())) {} - Box &operator=(Box &&u) noexcept { + Box &operator=(Box &&u) { reset(u.release()); p_stor.get_deleter() = forward(u.get_deleter()); return *this; @@ -321,13 +318,13 @@ namespace octa { && IsConvertible::PtrType, PtrType>::value && IsAssignable::value, Box & - > operator=(Box &&u) noexcept { + > operator=(Box &&u) { reset(u.release()); p_stor.get_deleter() = forward
(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 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_cref; public: - constexpr Box() noexcept: p_stor(nullptr, D()) { + constexpr Box(): p_stor(nullptr, D()) { static_assert(!IsPointer::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::value, "Box constructed with null fptr deleter"); } template explicit Box(U p, EnableIf< __OctaSameOrLessCvQualified::value, __OctaNat - > = __OctaNat()) noexcept: p_stor(p, D()) { + > = __OctaNat()): p_stor(p, D()) { static_assert(!IsPointer::value, "Box constructed with null fptr deleter"); } @@ -413,25 +410,25 @@ namespace octa { template Box(U p, Conditional::value, D, AddLvalueReference > d, EnableIf<__OctaSameOrLessCvQualified::value, __OctaNat - > = __OctaNat()) noexcept: p_stor(p, d) {} + > = __OctaNat()): p_stor(p, d) {} Box(nullptr_t, Conditional::value, D, AddLvalueReference - > d) noexcept: p_stor(nullptr, d) {} + > d): p_stor(nullptr, d) {} template Box(U p, RemoveReference &&d, EnableIf< __OctaSameOrLessCvQualified::value, __OctaNat - > = __OctaNat()) noexcept: p_stor(p, move(d)) { + > = __OctaNat()): p_stor(p, move(d)) { static_assert(!IsReference::value, "rvalue deleter cannot be a ref"); } - Box(nullptr_t, RemoveReference &&d) noexcept: p_stor(nullptr, move(d)) { + Box(nullptr_t, RemoveReference &&d): p_stor(nullptr, move(d)) { static_assert(!IsReference::value, "rvalue deleter cannot be a ref"); } - Box(Box &&u) noexcept: p_stor(u.release(), forward(u.get_deleter())) {} + Box(Box &&u): p_stor(u.release(), forward(u.get_deleter())) {} template Box(Box &&u, EnableIf::value @@ -439,9 +436,9 @@ namespace octa { PtrType>::value && IsConvertible::value && (!IsReference::value || IsSame::value)> = __OctaNat() - ) noexcept: p_stor(u.release(), forward
(u.get_deleter())) {} + ): p_stor(u.release(), forward
(u.get_deleter())) {} - Box &operator=(Box &&u) noexcept { + Box &operator=(Box &&u) { reset(u.release()); p_stor.get_deleter() = forward(u.get_deleter()); return *this; @@ -453,13 +450,13 @@ namespace octa { PtrType>::value && IsAssignable::value, Box & - > operator=(Box &&u) noexcept { + > operator=(Box &&u) { reset(u.release()); p_stor.get_deleter() = forward
(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 EnableIf< __OctaSameOrLessCvQualified::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 using Rebind = Allocator; - 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::ConstPtrType = nullptr) noexcept { + PtrType allocate(SizeType n, Allocator::ConstPtrType = nullptr) { return (PtrType) ::new uchar[n * sizeof(T)]; } @@ -601,13 +598,13 @@ namespace octa { template using Rebind = Allocator; - 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::ConstPtrType = nullptr) noexcept { + PtrType allocate(SizeType n, Allocator::ConstPtrType = nullptr) { return (PtrType) ::new uchar[n * sizeof(T)]; } @@ -622,12 +619,12 @@ namespace octa { }; template - bool operator==(const Allocator &, const Allocator &) noexcept { + bool operator==(const Allocator &, const Allocator &) { return true; } template - bool operator!=(const Allocator &, const Allocator &) noexcept { + bool operator!=(const Allocator &, const Allocator &) { return false; } } diff --git a/octa/range.h b/octa/range.h index f5399e4..0b56efc 100644 --- a/octa/range.h +++ b/octa/range.h @@ -26,7 +26,6 @@ namespace octa { template 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 begin() noexcept( - IsNothrowCopyConstructible::value - ) { + __OctaRangeIterator begin() { return __OctaRangeIterator((const B &)*this); } - __OctaRangeIterator end() noexcept( - IsNothrowDefaultConstructible::value - ) { + __OctaRangeIterator end() { return __OctaRangeIterator(); } }; @@ -83,106 +78,82 @@ namespace octa { T p_range; public: - ReverseRange() noexcept(IsNothrowDefaultConstructible::value): - p_range() {} + ReverseRange(): p_range() {} - ReverseRange(const T &range) noexcept( - IsNothrowCopyConstructible::value - ): p_range(range) {} + ReverseRange(const T &range): p_range(range) {} - ReverseRange(const ReverseRange &it) noexcept( - IsNothrowCopyConstructible::value - ): p_range(it.p_range) {} + ReverseRange(const ReverseRange &it): p_range(it.p_range) {} - ReverseRange(ReverseRange &&it) noexcept( - IsNothrowMoveConstructible::value - ): p_range(move(it.p_range)) {} + ReverseRange(ReverseRange &&it): p_range(move(it.p_range)) {} - ReverseRange &operator=(const ReverseRange &v) noexcept( - IsNothrowCopyAssignable::value - ) { + ReverseRange &operator=(const ReverseRange &v) { p_range = v.p_range; return *this; } - ReverseRange &operator=(ReverseRange &&v) noexcept( - IsNothrowMoveAssignable::value - ) { + ReverseRange &operator=(ReverseRange &&v) { p_range = move(v.p_range); return *this; } - ReverseRange &operator=(const T &v) noexcept( - IsNothrowCopyAssignable::value - ) { + ReverseRange &operator=(const T &v) { p_range = v; return *this; } - ReverseRange &operator=(T &&v) noexcept( - IsNothrowMoveAssignable::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 slice(r_size start, r_size end) noexcept( - noexcept(ReverseRange(p_range.slice(0, 0))) - && noexcept(p_range.length()) - ) { + ReverseRange slice(r_size start, r_size end) { r_size len = p_range.length(); return ReverseRange(p_range.slice(len - end, len - start)); } }; template - ReverseRange make_reverse_range(const T &it) noexcept( - noexcept(ReverseRange(it)) - ) { + ReverseRange make_reverse_range(const T &it) { return ReverseRange(it); } @@ -198,193 +169,170 @@ namespace octa { T p_range; public: - MoveRange() noexcept(IsNothrowDefaultConstructible::value): - p_range() {} + MoveRange(): p_range() {} - MoveRange(const T &range) noexcept( - IsNothrowCopyConstructible::value - ): p_range(range) {} + MoveRange(const T &range): p_range(range) {} - MoveRange(const MoveRange &it) noexcept( - IsNothrowCopyConstructible::value - ): p_range(it.p_range) {} + MoveRange(const MoveRange &it): p_range(it.p_range) {} - MoveRange(MoveRange &&it) noexcept( - IsNothrowMoveConstructible::value - ): p_range(move(it.p_range)) {} + MoveRange(MoveRange &&it): p_range(move(it.p_range)) {} - MoveRange &operator=(const MoveRange &v) noexcept( - IsNothrowCopyAssignable::value - ) { + MoveRange &operator=(const MoveRange &v) { p_range = v.p_range; return *this; } - MoveRange &operator=(MoveRange &&v) noexcept( - IsNothrowMoveAssignable::value - ) { + MoveRange &operator=(MoveRange &&v) { p_range = move(v.p_range); return *this; } - MoveRange &operator=(const T &v) noexcept( - IsNothrowCopyAssignable::value - ) { + MoveRange &operator=(const T &v) { p_range = v; return *this; } - MoveRange &operator=(T &&v) noexcept( - IsNothrowMoveAssignable::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 slice(r_size start, r_size end) noexcept( - noexcept(MoveRange(p_range.slice(start, end))) - ) { + MoveRange slice(r_size start, r_size end) { return MoveRange(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 - MoveRange make_move_range(const T &it) noexcept( - noexcept(MoveRange(it)) - ) { + MoveRange make_move_range(const T &it) { return MoveRange(it); } template struct NumberRange: InputRange, 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 - NumberRange range(T a, T b, T step = T(1)) noexcept { + NumberRange range(T a, T b, T step = T(1)) { return NumberRange(a, b, step); } template - NumberRange range(T v) noexcept { + NumberRange range(T v) { return NumberRange(v); } template struct PointerRange: InputRange, 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::value) { + void put(const T &v) { *(p_beg++) = v; } - void put(T &&v) noexcept(IsNothrowMoveAssignable::value) { + void put(T &&v) { *(p_beg++) = move(v); } @@ -412,85 +360,62 @@ namespace octa { r_size p_index; public: - EnumeratedRange() noexcept(IsNothrowDefaultConstructible::value): - p_range(), p_index(0) {} + EnumeratedRange(): p_range(), p_index(0) {} - EnumeratedRange(const T &range) noexcept( - IsNothrowCopyConstructible::value - ): p_range(range), p_index(0) {} + EnumeratedRange(const T &range): p_range(range), p_index(0) {} - EnumeratedRange(const EnumeratedRange &it) noexcept( - IsNothrowCopyConstructible::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::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::value - ) { + EnumeratedRange &operator=(const EnumeratedRange &v) { p_range = v.p_range; p_index = v.p_index; return *this; } - EnumeratedRange &operator=(EnumeratedRange &&v) noexcept( - IsNothrowMoveAssignable::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::value - ) { + EnumeratedRange &operator=(const T &v) { p_range = v; p_index = 0; return *this; } - EnumeratedRange &operator=(T &&v) noexcept( - IsNothrowMoveAssignable::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 first() noexcept( - noexcept(p_range.first()) - ) { + EnumeratedValue first() { return EnumeratedValue { p_index, p_range.first() }; } - EnumeratedValue first() const noexcept( - noexcept(p_range.first()) - ) { + EnumeratedValue first() const { return EnumeratedValue { 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 - EnumeratedRange enumerate(const T &it) noexcept( - noexcept(EnumeratedRange(it)) - ) { + EnumeratedRange enumerate(const T &it) { return EnumeratedRange(it); } } diff --git a/octa/type_traits.h b/octa/type_traits.h index 1316815..487656b 100644 --- a/octa/type_traits.h +++ b/octa/type_traits.h @@ -325,7 +325,7 @@ namespace octa { decltype(__OCTA_MOVE(T(__octa_declval()...))), True >::Type __octa_is_ctible_test(T &&, A &&...); -#undef __OCTA_MOVE +//#undef __OCTA_MOVE template False __octa_is_ctible_test(__OctaAny, A &&...); @@ -578,115 +578,6 @@ namespace octa { __has_trivial_destructor(T) > {}; - /* is nothrow constructible */ - - template - struct IsNothrowConstructible: False {}; - - template - struct IsNothrowConstructible: IntegralConstant {}; - - template - struct IsNothrowConstructible: IntegralConstant {}; - - template - struct IsNothrowConstructible: IntegralConstant {}; - - template - struct IsNothrowConstructible: IntegralConstant {}; - - /* is nothrow default constructible */ - - template - struct IsNothrowDefaultConstructible: IsNothrowConstructible {}; - - /* is nothrow copy constructible */ - - template - struct IsNothrowCopyConstructible: IsNothrowConstructible - > {}; - - /* is nothrow move constructible */ - - template - struct IsNothrowMoveConstructible: IsNothrowConstructible - > {}; - - /* is nothrow assignable */ - - template - struct IsNothrowAssignable: False {}; - - template - struct IsNothrowAssignable: IntegralConstant {}; - - template - struct IsNothrowAssignable: IntegralConstant {}; - - template - struct IsNothrowAssignable: IntegralConstant {}; - - template - struct IsNothrowAssignable: IntegralConstant {}; - - /* is nothrow copy assignable */ - - template - struct IsNothrowCopyAssignable: IsNothrowAssignable - > {}; - - /* is nothrow move assignable */ - - template - struct IsNothrowMoveAssignable: IsNothrowAssignable - > {}; - - /* is nothrow destructible */ - - template struct __OctaIsNothrowDtible; - - template - struct __OctaIsNothrowDtible: False {}; - - template - struct __OctaIsNothrowDtible: IntegralConstant::value || noexcept(__octa_declval().~T())) - > {}; - - template - struct IsNothrowDestructible: __OctaIsNothrowDtible::value - > {}; - - template - struct IsNothrowDestructible: IsNothrowDestructible {}; - - template - struct IsNothrowDestructible: IsNothrowDestructible {}; - - template - struct IsNothrowDestructible: IsNothrowDestructible {}; - /* is base of */ template @@ -1127,11 +1018,11 @@ namespace octa { template struct __OctaCommonType; template struct __OctaCommonType { - typedef __OctaDecay Type; + typedef Decay Type; }; template struct __OctaCommonType { - typedef __OctaDecay() + typedef Decay() : __octa_declval())> Type; }; diff --git a/octa/utility.h b/octa/utility.h index ea299ed..de78ecb 100644 --- a/octa/utility.h +++ b/octa/utility.h @@ -14,22 +14,19 @@ namespace octa { /* move */ template - static inline constexpr RemoveReference && - move(T &&v) noexcept { + static inline constexpr RemoveReference &&move(T &&v) { return static_cast &&>(v); } /* forward */ template - static inline constexpr T && - forward(RemoveReference &v) noexcept { + static inline constexpr T &&forward(RemoveReference &v) { return static_cast(v); } template - static inline constexpr T && - forward(RemoveReference &&v) noexcept { + static inline constexpr T &&forward(RemoveReference &&v) { return static_cast(v); } @@ -39,18 +36,13 @@ namespace octa { /* swap */ - template void swap(T &a, T &b) noexcept( - IsNothrowMoveConstructible::value - && IsNothrowMoveAssignable::value - ) { + template void swap(T &a, T &b) { T c(move(a)); a = move(b); b = move(c); } - template void swap(T (&a)[N], T (&b)[N]) noexcept( - noexcept(swap(*a, *b)) - ) { + template 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::value - && IsNothrowDefaultConstructible::value - ) = default; + Pair() = default; ~Pair() = default; - Pair(const Pair &) noexcept( - IsNothrowCopyConstructible::value - && IsNothrowCopyConstructible::value - ) = default; - Pair(Pair &&) noexcept( - IsNothrowMoveConstructible::value - && IsNothrowMoveConstructible::value - ) = default; + Pair(const Pair &) = default; + Pair(Pair &&) = default; - Pair(const T &x, const U &y) noexcept( - IsNothrowCopyConstructible::value - && IsNothrowCopyConstructible::value - ): first(x), second(y) {} + Pair(const T &x, const U &y): first(x), second(y) {} template Pair(TT &&x, UU &&y): first(forward(x)), second(forward(y)) {} template - Pair(const Pair &v) noexcept( - IsNothrowCopyConstructible::value - && IsNothrowCopyConstructible::value - ): first(v.first), second(v.second) {} + Pair(const Pair &v): first(v.first), second(v.second) {} template - Pair(Pair &&v) noexcept( - IsNothrowMoveConstructible::value - && IsNothrowMoveConstructible::value - ): first(move(v.first)), second(move(v.second)) {} + Pair(Pair &&v): first(move(v.first)), second(move(v.second)) {} - Pair &operator=(const Pair &v) noexcept( - IsNothrowCopyAssignable::value - && IsNothrowCopyAssignable::value - ) { + Pair &operator=(const Pair &v) { first = v.first; second = v.second; return *this; } template - Pair &operator=(const Pair &v) noexcept( - IsNothrowCopyAssignable::value - && IsNothrowCopyAssignable::value - ) { + Pair &operator=(const Pair &v) { first = v.first; second = v.second; return *this; } - Pair &operator=(Pair &&v) noexcept( - IsNothrowMoveAssignable::value - && IsNothrowMoveAssignable::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 - void swap(Pair &a, Pair &b) noexcept(noexcept(a.swap(b))) { + void swap(Pair &a, Pair &b) { a.swap(b); } } diff --git a/octa/vector.h b/octa/vector.h index f403add..c40b363 100644 --- a/octa/vector.h +++ b/octa/vector.h @@ -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::value - && IsNothrowMoveConstructible::value - && IsNothrowMoveAssignable::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 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::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::value - && IsNothrowCopyConstructible::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 v) noexcept( - IsNothrowCopyConstructible::value - ): Vector() { + Vector(InitializerList 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::value) { + ~Vector() { clear(); delete[] (uchar *)p_buf; p_buf = nullptr; p_cap = 0; } - void clear() noexcept(IsNothrowDestructible::value) { + void clear() { if (p_len > 0 && !octa::IsPod()) { T *cur = p_buf, *last = p_buf + p_len; while (cur != last) (*cur++).~T(); @@ -97,10 +85,7 @@ namespace octa { p_len = 0; } - Vector &operator=(const Vector &v) noexcept( - IsNothrowDestructible::value - && IsNothrowCopyConstructible::value - ) { + Vector &operator=(const Vector &v) { if (this == &v) return *this; clear(); reserve(v.p_cap); @@ -117,9 +102,7 @@ namespace octa { return *this; } - Vector &operator=(Vector &&v) noexcept( - IsNothrowDestructible::value - ) { + Vector &operator=(Vector &&v) { clear(); delete[] (uchar *)p_buf; p_len = v.p_len; @@ -128,10 +111,7 @@ namespace octa { return *this; } - Vector &operator=(InitializerList il) noexcept( - IsNothrowDestructible::value && - IsNothrowCopyConstructible::value - ) { + Vector &operator=(InitializerList 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::value - && IsNothrowMoveConstructible::value - && IsNothrowCopyConstructible::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::value - && IsNothrowMoveConstructible::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::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::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::value) { + void pop() { if (!octa::IsPod()) { 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::value - && IsNothrowMoveConstructible::value - && IsNothrowMoveAssignable::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::value - && IsNothrowMoveConstructible::value - && IsNothrowMoveAssignable::value - && IsNothrowCopyAssignable::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::value - && IsNothrowMoveConstructible::value - && IsNothrowMoveAssignable::value - && IsNothrowCopyAssignable::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 - T *insert_range(size_t idx, U range) noexcept( - IsNothrowDestructible::value - && IsNothrowMoveConstructible::value - && IsNothrowMoveAssignable::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 il) noexcept( - noexcept(declval>().insert_range(idx, il.range())) - ) { + T *insert(size_t idx, InitializerList il) { return insert_range(idx, il.range()); } - RangeType each() noexcept { + RangeType each() { return PointerRange(p_buf, p_buf + p_len); } - ConstRangeType each() const noexcept { + ConstRangeType each() const { return PointerRange(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 - void swap(Vector &a, Vector &b) noexcept { + void swap(Vector &a, Vector &b) { a.swap(b); } }