mirror/Sprout
1
0
Fork 0
mirror of https://github.com/bolero-MURAKAMI/Sprout.git synced 2025-05-10 09:23:30 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions

support for C++14 constexpr: some classes

Browse source
This commit is contained in:
bolero-MURAKAMI 2013-10-30 18:15:57 +09:00
parent 478c476611
commit ff36d79afc
6 changed files with 93 additions and 83 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

22
sprout/pit/pit.hpp
View file

@ -47,31 +47,31 @@ namespace sprout {
value_type elem; value_type elem;
public: public:
pit() = default; pit() = default;
void swap(pit& other) SPROUT_CXX14_CONSTEXPR void swap(pit& other)
SPROUT_NOEXCEPT_EXPR(SPROUT_NOEXCEPT_EXPR(sprout::swap(elem, other.elem))) SPROUT_NOEXCEPT_EXPR(SPROUT_NOEXCEPT_EXPR(sprout::swap(elem, other.elem)))
{ {
sprout::swap(elem, other.elem); sprout::swap(elem, other.elem);
} }
// iterators: // iterators:
iterator begin() { SPROUT_CXX14_CONSTEXPR iterator begin() {
return iterator(elem, enumerable_size); return iterator(elem, enumerable_size);
} }
SPROUT_CONSTEXPR const_iterator begin() const { SPROUT_CONSTEXPR const_iterator begin() const {
return const_iterator(elem, enumerable_size); return const_iterator(elem, enumerable_size);
} }
iterator end() SPROUT_NOEXCEPT { SPROUT_CXX14_CONSTEXPR iterator end() SPROUT_NOEXCEPT {
return iterator(elem, 0); return iterator(elem, 0);
} }
SPROUT_CONSTEXPR const_iterator end() const SPROUT_NOEXCEPT { SPROUT_CONSTEXPR const_iterator end() const SPROUT_NOEXCEPT {
return const_iterator(elem, 0); return const_iterator(elem, 0);
} }
reverse_iterator rbegin() SPROUT_NOEXCEPT { SPROUT_CXX14_CONSTEXPR reverse_iterator rbegin() SPROUT_NOEXCEPT {
return reverse_iterator(end()); return reverse_iterator(end());
} }
SPROUT_CONSTEXPR const_reverse_iterator rbegin() const SPROUT_NOEXCEPT { SPROUT_CONSTEXPR const_reverse_iterator rbegin() const SPROUT_NOEXCEPT {
return const_reverse_iterator(end()); return const_reverse_iterator(end());
} }
reverse_iterator rend() SPROUT_NOEXCEPT { SPROUT_CXX14_CONSTEXPR reverse_iterator rend() SPROUT_NOEXCEPT {
return reverse_iterator(begin()); return reverse_iterator(begin());
} }
SPROUT_CONSTEXPR const_reverse_iterator rend() const SPROUT_NOEXCEPT { SPROUT_CONSTEXPR const_reverse_iterator rend() const SPROUT_NOEXCEPT {
@ -100,13 +100,13 @@ namespace sprout {
return enumerable_size == 0; return enumerable_size == 0;
} }
// element access: // element access:
reference operator[](size_type) { SPROUT_CXX14_CONSTEXPR reference operator[](size_type) {
return elem; return elem;
} }
SPROUT_CONSTEXPR const_reference operator[](size_type) const { SPROUT_CONSTEXPR const_reference operator[](size_type) const {
return elem; return elem;
} }
reference at(size_type i) { SPROUT_CXX14_CONSTEXPR reference at(size_type i) {
return i < size() return i < size()
? elem ? elem
: (throw std::out_of_range("pit<>: index out of range"), elem) : (throw std::out_of_range("pit<>: index out of range"), elem)
@ -118,20 +118,20 @@ namespace sprout {
: (throw std::out_of_range("pit<>: index out of range"), elem) : (throw std::out_of_range("pit<>: index out of range"), elem)
; ;
} }
reference front() { SPROUT_CXX14_CONSTEXPR reference front() {
return elem; return elem;
} }
SPROUT_CONSTEXPR const_reference front() const { SPROUT_CONSTEXPR const_reference front() const {
return elem; return elem;
} }
reference back() { SPROUT_CXX14_CONSTEXPR reference back() {
return elem; return elem;
} }
SPROUT_CONSTEXPR const_reference back() const { SPROUT_CONSTEXPR const_reference back() const {
return elem; return elem;
} }
// others: // others:
void rangecheck(size_type i) const { SPROUT_CXX14_CONSTEXPR void rangecheck(size_type i) const {
if (i >= size()) { if (i >= size()) {
throw std::out_of_range("pit<>: index out of range"); throw std::out_of_range("pit<>: index out of range");
} }
@ -144,7 +144,7 @@ namespace sprout {
// swap // swap
// //
template<typename Container> template<typename Container>
inline void inline SPROUT_CXX14_CONSTEXPR void
swap(sprout::pit<Container>& lhs, sprout::pit<Container>& rhs) swap(sprout::pit<Container>& lhs, sprout::pit<Container>& rhs)
SPROUT_NOEXCEPT_EXPR(SPROUT_NOEXCEPT_EXPR(lhs.swap(rhs))) SPROUT_NOEXCEPT_EXPR(SPROUT_NOEXCEPT_EXPR(lhs.swap(rhs)))
{ {

30
sprout/random/random_result.hpp
View file

@ -84,31 +84,31 @@ namespace sprout {
SPROUT_CONSTEXPR random_result operator()() const { SPROUT_CONSTEXPR random_result operator()() const {
return distribution_(engine_); return distribution_(engine_);
} }
result_type& result() SPROUT_NOEXCEPT { SPROUT_CXX14_CONSTEXPR result_type& result() SPROUT_NOEXCEPT {
return result_; return result_;
} }
SPROUT_CONSTEXPR result_type const& result() const SPROUT_NOEXCEPT { SPROUT_CONSTEXPR result_type const& result() const SPROUT_NOEXCEPT {
return result_; return result_;
} }
result_type& generated_value() SPROUT_NOEXCEPT { SPROUT_CXX14_CONSTEXPR result_type& generated_value() SPROUT_NOEXCEPT {
return result_; return result_;
} }
SPROUT_CONSTEXPR result_type const& generated_value() const SPROUT_NOEXCEPT { SPROUT_CONSTEXPR result_type const& generated_value() const SPROUT_NOEXCEPT {
return result_; return result_;
} }
engine_type& engine() SPROUT_NOEXCEPT { SPROUT_CXX14_CONSTEXPR engine_type& engine() SPROUT_NOEXCEPT {
return engine_; return engine_;
} }
SPROUT_CONSTEXPR engine_type const& engine() const SPROUT_NOEXCEPT { SPROUT_CONSTEXPR engine_type const& engine() const SPROUT_NOEXCEPT {
return engine_; return engine_;
} }
random_result& next_generator() SPROUT_NOEXCEPT { SPROUT_CXX14_CONSTEXPR random_result& next_generator() SPROUT_NOEXCEPT {
return *this; return *this;
} }
SPROUT_CONSTEXPR random_result const& next_generator() const SPROUT_NOEXCEPT { SPROUT_CONSTEXPR random_result const& next_generator() const SPROUT_NOEXCEPT {
return *this; return *this;
} }
distribution_type& distribution() SPROUT_NOEXCEPT { SPROUT_CXX14_CONSTEXPR distribution_type& distribution() SPROUT_NOEXCEPT {
return distribution_; return distribution_;
} }
SPROUT_CONSTEXPR distribution_type const& distribution() const SPROUT_NOEXCEPT { SPROUT_CONSTEXPR distribution_type const& distribution() const SPROUT_NOEXCEPT {
@ -126,7 +126,7 @@ namespace sprout {
SPROUT_CONSTEXPR result_type max() const SPROUT_NOEXCEPT { SPROUT_CONSTEXPR result_type max() const SPROUT_NOEXCEPT {
return distribution_.max(); return distribution_.max();
} }
void swap(random_result& other) SPROUT_CXX14_CONSTEXPR void swap(random_result& other)
SPROUT_NOEXCEPT_EXPR( SPROUT_NOEXCEPT_EXPR(
SPROUT_NOEXCEPT_EXPR(sprout::swap(result_, other.result_)) SPROUT_NOEXCEPT_EXPR(sprout::swap(result_, other.result_))
&& SPROUT_NOEXCEPT_EXPR(sprout::swap(engine_, other.engine_)) && SPROUT_NOEXCEPT_EXPR(sprout::swap(engine_, other.engine_))
@ -152,12 +152,12 @@ namespace sprout {
SPROUT_CONSTEXPR pointer operator->() const SPROUT_NOEXCEPT { SPROUT_CONSTEXPR pointer operator->() const SPROUT_NOEXCEPT {
return &result_; return &result_;
} }
random_result& operator++() { SPROUT_CXX14_CONSTEXPR random_result& operator++() {
random_result temp((*this)()); random_result temp((*this)());
temp.swap(*this); temp.swap(*this);
return *this; return *this;
} }
random_result operator++(int) { SPROUT_CXX14_CONSTEXPR random_result operator++(int) {
random_result result(*this); random_result result(*this);
++*this; ++*this;
return result; return result;
@ -215,25 +215,25 @@ namespace sprout {
SPROUT_CONSTEXPR random_result operator()() const { SPROUT_CONSTEXPR random_result operator()() const {
return engine_(); return engine_();
} }
result_type& result() SPROUT_NOEXCEPT { SPROUT_CXX14_CONSTEXPR result_type& result() SPROUT_NOEXCEPT {
return result_; return result_;
} }
SPROUT_CONSTEXPR result_type const& result() const SPROUT_NOEXCEPT { SPROUT_CONSTEXPR result_type const& result() const SPROUT_NOEXCEPT {
return result_; return result_;
} }
result_type& generated_value() SPROUT_NOEXCEPT { SPROUT_CXX14_CONSTEXPR result_type& generated_value() SPROUT_NOEXCEPT {
return result_; return result_;
} }
SPROUT_CONSTEXPR result_type const& generated_value() const SPROUT_NOEXCEPT { SPROUT_CONSTEXPR result_type const& generated_value() const SPROUT_NOEXCEPT {
return result_; return result_;
} }
engine_type& engine() SPROUT_NOEXCEPT { SPROUT_CXX14_CONSTEXPR engine_type& engine() SPROUT_NOEXCEPT {
return engine_; return engine_;
} }
SPROUT_CONSTEXPR engine_type const& engine() const SPROUT_NOEXCEPT { SPROUT_CONSTEXPR engine_type const& engine() const SPROUT_NOEXCEPT {
return engine_; return engine_;
} }
random_result& next_generator() SPROUT_NOEXCEPT { SPROUT_CXX14_CONSTEXPR random_result& next_generator() SPROUT_NOEXCEPT {
return *this; return *this;
} }
SPROUT_CONSTEXPR random_result const& next_generator() const SPROUT_NOEXCEPT { SPROUT_CONSTEXPR random_result const& next_generator() const SPROUT_NOEXCEPT {
@ -274,12 +274,12 @@ namespace sprout {
SPROUT_CONSTEXPR pointer operator->() const SPROUT_NOEXCEPT { SPROUT_CONSTEXPR pointer operator->() const SPROUT_NOEXCEPT {
return &result_; return &result_;
} }
random_result& operator++() { SPROUT_CXX14_CONSTEXPR random_result& operator++() {
random_result temp((*this)()); random_result temp((*this)());
temp.swap(*this); temp.swap(*this);
return *this; return *this;
} }
random_result operator++(int) { SPROUT_CXX14_CONSTEXPR random_result operator++(int) {
random_result result(*this); random_result result(*this);
random_result temp((*this)()); random_result temp((*this)());
temp.swap(*this); temp.swap(*this);
@ -291,7 +291,7 @@ namespace sprout {
// swap // swap
// //
template<typename Engine, typename Distribution> template<typename Engine, typename Distribution>
inline void inline SPROUT_CXX14_CONSTEXPR void
swap(sprout::random::random_result<Engine, Distribution>& lhs, sprout::random::random_result<Engine, Distribution>& rhs) swap(sprout::random::random_result<Engine, Distribution>& lhs, sprout::random::random_result<Engine, Distribution>& rhs)
SPROUT_NOEXCEPT_EXPR(SPROUT_NOEXCEPT_EXPR(lhs.swap(rhs))) SPROUT_NOEXCEPT_EXPR(SPROUT_NOEXCEPT_EXPR(lhs.swap(rhs)))
{ {

34
sprout/rational/rational.hpp
View file

@ -96,11 +96,15 @@ namespace sprout {
: base_type(n, d, normalize_g(n, d)) : base_type(n, d, normalize_g(n, d))
{} {}
rational& operator=(rational const&) = default; SPROUT_CXX14_CONSTEXPR rational& operator=(rational const& rhs) SPROUT_NOEXCEPT {
rational& operator=(param_type n) SPROUT_NOEXCEPT { rational temp(rhs);
sprout::swap(temp, *this);
return *this;
}
SPROUT_CXX14_CONSTEXPR rational& operator=(param_type n) SPROUT_NOEXCEPT {
return assign(n, 1); return assign(n, 1);
} }
rational& assign(param_type n, param_type d) { SPROUT_CXX14_CONSTEXPR rational& assign(param_type n, param_type d) {
rational temp(n, d); rational temp(n, d);
sprout::swap(temp, *this); sprout::swap(temp, *this);
return *this; return *this;
@ -113,7 +117,7 @@ namespace sprout {
return den_; return den_;
} }
rational& operator+=(rational const& rhs) { SPROUT_CXX14_CONSTEXPR rational& operator+=(rational const& rhs) {
IntType g = sprout::gcd(den_, rhs.den_); IntType g = sprout::gcd(den_, rhs.den_);
den_ /= g; den_ /= g;
num_ = num_ * (rhs.den_ / g) + rhs.num_ * den_; num_ = num_ * (rhs.den_ / g) + rhs.num_ * den_;
@ -122,7 +126,7 @@ namespace sprout {
den_ *= rhs.den_ / g; den_ *= rhs.den_ / g;
return *this; return *this;
} }
rational& operator-=(rational const& rhs) { SPROUT_CXX14_CONSTEXPR rational& operator-=(rational const& rhs) {
IntType g = sprout::gcd(den_, rhs.den_); IntType g = sprout::gcd(den_, rhs.den_);
den_ /= g; den_ /= g;
num_ = num_ * (rhs.den_ / g) - rhs.num_ * den_; num_ = num_ * (rhs.den_ / g) - rhs.num_ * den_;
@ -131,14 +135,14 @@ namespace sprout {
den_ *= rhs.den_ / g; den_ *= rhs.den_ / g;
return *this; return *this;
} }
rational& operator*=(rational const& rhs) { SPROUT_CXX14_CONSTEXPR rational& operator*=(rational const& rhs) {
IntType gcd1 = sprout::gcd(num_, rhs.den_); IntType gcd1 = sprout::gcd(num_, rhs.den_);
IntType gcd2 = sprout::gcd(rhs.num_, den_); IntType gcd2 = sprout::gcd(rhs.num_, den_);
num_ =(num_ / gcd1) * (rhs.num_ / gcd2); num_ =(num_ / gcd1) * (rhs.num_ / gcd2);
den_ =(den_ / gcd2) * (rhs.den_ / gcd1); den_ =(den_ / gcd2) * (rhs.den_ / gcd1);
return *this; return *this;
} }
rational& operator/=(rational const& rhs) { SPROUT_CXX14_CONSTEXPR rational& operator/=(rational const& rhs) {
if (rhs.num_ == IntType(0)) { if (rhs.num_ == IntType(0)) {
throw sprout::bad_rational(); throw sprout::bad_rational();
} }
@ -155,33 +159,33 @@ namespace sprout {
} }
return *this; return *this;
} }
rational& operator+=(param_type rhs) { SPROUT_CXX14_CONSTEXPR rational& operator+=(param_type rhs) {
return *this += rational(rhs); return *this += rational(rhs);
} }
rational& operator-=(param_type rhs) { SPROUT_CXX14_CONSTEXPR rational& operator-=(param_type rhs) {
return *this -= rational(rhs); return *this -= rational(rhs);
} }
rational& operator*=(param_type rhs) { SPROUT_CXX14_CONSTEXPR rational& operator*=(param_type rhs) {
return *this *= rational(rhs); return *this *= rational(rhs);
} }
rational& operator/=(param_type rhs) { SPROUT_CXX14_CONSTEXPR rational& operator/=(param_type rhs) {
return *this /= rational(rhs); return *this /= rational(rhs);
} }
rational& operator++() SPROUT_NOEXCEPT { SPROUT_CXX14_CONSTEXPR rational& operator++() SPROUT_NOEXCEPT {
num_ += den_; num_ += den_;
return *this; return *this;
} }
rational& operator--() SPROUT_NOEXCEPT { SPROUT_CXX14_CONSTEXPR rational& operator--() SPROUT_NOEXCEPT {
num_ -= den_; num_ -= den_;
return *this; return *this;
} }
rational operator++(int) SPROUT_NOEXCEPT { SPROUT_CXX14_CONSTEXPR rational operator++(int) SPROUT_NOEXCEPT {
rational result(*this); rational result(*this);
++*this; ++*this;
return result; return result;
} }
rational operator--(int) SPROUT_NOEXCEPT { SPROUT_CXX14_CONSTEXPR rational operator--(int) SPROUT_NOEXCEPT {
rational result(*this); rational result(*this);
--*this; --*this;
return result; return result;

35
sprout/sub_array/sub_array.hpp
View file

@ -243,11 +243,11 @@ namespace sprout {
) )
{} {}
void fill(const_reference value) { SPROUT_CXX14_CONSTEXPR void fill(const_reference value) {
std::fill_n(begin(), size(), value); std::fill_n(begin(), size(), value);
} }
template<typename Container2> template<typename Container2>
void swap(sub_array<Container2>& other) SPROUT_CXX14_CONSTEXPR void swap(sub_array<Container2>& other)
SPROUT_NOEXCEPT_EXPR(SPROUT_NOEXCEPT_EXPR(sprout::swap(other.array_, array_))) SPROUT_NOEXCEPT_EXPR(SPROUT_NOEXCEPT_EXPR(sprout::swap(other.array_, array_)))
{ {
sprout::swap(other.array_, array_); sprout::swap(other.array_, array_);
@ -255,13 +255,13 @@ namespace sprout {
sprout::swap(other.to_last_, to_last_); sprout::swap(other.to_last_, to_last_);
} }
// iterators: // iterators:
iterator begin() { SPROUT_CXX14_CONSTEXPR iterator begin() {
return sprout::next(sprout::begin(get_array()), to_first_); return sprout::next(sprout::begin(get_array()), to_first_);
} }
SPROUT_CONSTEXPR const_iterator begin() const { SPROUT_CONSTEXPR const_iterator begin() const {
return sprout::next(sprout::begin(get_array()), to_first_); return sprout::next(sprout::begin(get_array()), to_first_);
} }
iterator end() { SPROUT_CXX14_CONSTEXPR iterator end() {
return sprout::next(sprout::begin(get_array()), to_last_); return sprout::next(sprout::begin(get_array()), to_last_);
} }
SPROUT_CONSTEXPR const_iterator end() const { SPROUT_CONSTEXPR const_iterator end() const {
@ -284,13 +284,13 @@ namespace sprout {
return to_first_ == to_last_; return to_first_ == to_last_;
} }
// element access: // element access:
reference operator[](size_type i) { SPROUT_CXX14_CONSTEXPR reference operator[](size_type i) {
return *sprout::next(sprout::begin(get_array()), to_first_ + i); return *sprout::next(sprout::begin(get_array()), to_first_ + i);
} }
SPROUT_CONSTEXPR const_reference operator[](size_type i) const { SPROUT_CONSTEXPR const_reference operator[](size_type i) const {
return *sprout::next(sprout::begin(get_array()), to_first_ + i); return *sprout::next(sprout::begin(get_array()), to_first_ + i);
} }
reference at(size_type i) { SPROUT_CXX14_CONSTEXPR reference at(size_type i) {
return i < size() ? *sprout::next(sprout::begin(get_array()), to_first_ + i) return i < size() ? *sprout::next(sprout::begin(get_array()), to_first_ + i)
: (throw std::out_of_range("sub_array<>: index out of range"), *sprout::next(sprout::begin(get_array()), to_first_ + i)) : (throw std::out_of_range("sub_array<>: index out of range"), *sprout::next(sprout::begin(get_array()), to_first_ + i))
; ;
@ -300,20 +300,20 @@ namespace sprout {
: (throw std::out_of_range("sub_array<>: index out of range"), *sprout::next(sprout::begin(get_array()), to_first_ + i)) : (throw std::out_of_range("sub_array<>: index out of range"), *sprout::next(sprout::begin(get_array()), to_first_ + i))
; ;
} }
reference front() { SPROUT_CXX14_CONSTEXPR reference front() {
return *sprout::next(sprout::begin(get_array()), to_first_); return *sprout::next(sprout::begin(get_array()), to_first_);
} }
SPROUT_CONSTEXPR const_reference front() const { SPROUT_CONSTEXPR const_reference front() const {
return *sprout::next(sprout::begin(get_array()), to_first_); return *sprout::next(sprout::begin(get_array()), to_first_);
} }
reference back() { SPROUT_CXX14_CONSTEXPR reference back() {
return *sprout::next(sprout::begin(get_array()), to_last_ - 1); return *sprout::next(sprout::begin(get_array()), to_last_ - 1);
} }
SPROUT_CONSTEXPR const_reference back() const { SPROUT_CONSTEXPR const_reference back() const {
return *sprout::next(sprout::begin(get_array()), to_last_ - 1); return *sprout::next(sprout::begin(get_array()), to_last_ - 1);
} }
pointer data() { SPROUT_CXX14_CONSTEXPR pointer data() {
return get_array().data() + to_first_; return get_array().data() + to_first_;
} }
SPROUT_CONSTEXPR const_pointer data() const { SPROUT_CONSTEXPR const_pointer data() const {
@ -321,32 +321,35 @@ namespace sprout {
} }
// others: // others:
template<typename Container2> template<typename Container2>
sub_array& operator=(sub_array<Container2> const& rhs) { SPROUT_CXX14_CONSTEXPR sub_array& operator=(sub_array<Container2> const& rhs) {
array_ = rhs.array_; array_ = rhs.array_;
to_first_ = rhs.to_first_; to_first_ = rhs.to_first_;
to_last_ = rhs.to_last_; to_last_ = rhs.to_last_;
return *this; return *this;
} }
template<typename Container2> template<typename Container2>
sub_array& operator=(sub_array<Container2>&& rhs) { SPROUT_CXX14_CONSTEXPR sub_array& operator=(sub_array<Container2>&& rhs) {
array_ = std::move(rhs.array_); array_ = std::move(rhs.array_);
to_first_ = std::move(rhs.to_first_); to_first_ = std::move(rhs.to_first_);
to_last_ = std::move(rhs.to_last_); to_last_ = std::move(rhs.to_last_);
return *this; return *this;
} }
pointer c_array() { SPROUT_CXX14_CONSTEXPR pointer c_array() {
return data(); return data();
} }
void assign(const_reference value) { SPROUT_CONSTEXPR const_pointer c_array() const {
return data();
}
SPROUT_CXX14_CONSTEXPR void assign(const_reference value) {
fill(value); fill(value);
} }
void rangecheck(size_type i) const { SPROUT_CXX14_CONSTEXPR void rangecheck(size_type i) const {
if (i >= size()) { if (i >= size()) {
throw std::out_of_range("sub_array<>: index out of range"); throw std::out_of_range("sub_array<>: index out of range");
} }
} }
param_type get_internal() { SPROUT_CXX14_CONSTEXPR param_type get_internal() {
return impl_type::template to_param<Container>(array_); return impl_type::template to_param<Container>(array_);
} }
SPROUT_CONSTEXPR const_param_type get_internal() const { SPROUT_CONSTEXPR const_param_type get_internal() const {
@ -378,7 +381,7 @@ namespace sprout {
// swap // swap
// //
template<typename Container> template<typename Container>
inline void inline SPROUT_CXX14_CONSTEXPR void
swap(sprout::sub_array<Container>& lhs, sprout::sub_array<Container>& rhs) swap(sprout::sub_array<Container>& lhs, sprout::sub_array<Container>& rhs)
SPROUT_NOEXCEPT_EXPR(SPROUT_NOEXCEPT_EXPR(lhs.swap(rhs))) SPROUT_NOEXCEPT_EXPR(SPROUT_NOEXCEPT_EXPR(lhs.swap(rhs)))
{ {

37
sprout/uuid/uuid.hpp
View file

@ -81,47 +81,47 @@ namespace sprout {
public: public:
value_type elems[static_size]; value_type elems[static_size];
public: public:
void fill(const_reference value) { SPROUT_CXX14_CONSTEXPR void fill(const_reference value) {
std::fill_n(begin(), size(), value); std::fill_n(begin(), size(), value);
} }
void swap(uuid& other) SPROUT_NOEXCEPT { SPROUT_CXX14_CONSTEXPR void swap(uuid& other) SPROUT_NOEXCEPT {
std::swap_ranges(other.begin(), other.end(), begin()); std::swap_ranges(other.begin(), other.end(), begin());
} }
// iterators: // iterators:
#if SPROUT_USE_INDEX_ITERATOR_IMPLEMENTATION #if SPROUT_USE_INDEX_ITERATOR_IMPLEMENTATION
iterator begin() SPROUT_NOEXCEPT { SPROUT_CXX14_CONSTEXPR iterator begin() SPROUT_NOEXCEPT {
return iterator(*this, 0); return iterator(*this, 0);
} }
SPROUT_CONSTEXPR const_iterator begin() const SPROUT_NOEXCEPT { SPROUT_CONSTEXPR const_iterator begin() const SPROUT_NOEXCEPT {
return const_iterator(*this, 0); return const_iterator(*this, 0);
} }
iterator end() SPROUT_NOEXCEPT { SPROUT_CXX14_CONSTEXPR iterator end() SPROUT_NOEXCEPT {
return iterator(*this, size()); return iterator(*this, size());
} }
SPROUT_CONSTEXPR const_iterator end() const SPROUT_NOEXCEPT { SPROUT_CONSTEXPR const_iterator end() const SPROUT_NOEXCEPT {
return const_iterator(*this, size()); return const_iterator(*this, size());
} }
#else #else
iterator begin() SPROUT_NOEXCEPT { SPROUT_CXX14_CONSTEXPR iterator begin() SPROUT_NOEXCEPT {
return &elems[0]; return &elems[0];
} }
SPROUT_CONSTEXPR const_iterator begin() const SPROUT_NOEXCEPT { SPROUT_CONSTEXPR const_iterator begin() const SPROUT_NOEXCEPT {
return &elems[0]; return &elems[0];
} }
iterator end() SPROUT_NOEXCEPT { SPROUT_CXX14_CONSTEXPR iterator end() SPROUT_NOEXCEPT {
return &elems[0] + size(); return &elems[0] + size();
} }
SPROUT_CONSTEXPR const_iterator end() const SPROUT_NOEXCEPT { SPROUT_CONSTEXPR const_iterator end() const SPROUT_NOEXCEPT {
return &elems[0] + size(); return &elems[0] + size();
} }
#endif #endif
reverse_iterator rbegin() SPROUT_NOEXCEPT { SPROUT_CXX14_CONSTEXPR reverse_iterator rbegin() SPROUT_NOEXCEPT {
return reverse_iterator(end()); return reverse_iterator(end());
} }
SPROUT_CONSTEXPR const_reverse_iterator rbegin() const SPROUT_NOEXCEPT { SPROUT_CONSTEXPR const_reverse_iterator rbegin() const SPROUT_NOEXCEPT {
return const_reverse_iterator(end()); return const_reverse_iterator(end());
} }
reverse_iterator rend() SPROUT_NOEXCEPT { SPROUT_CXX14_CONSTEXPR reverse_iterator rend() SPROUT_NOEXCEPT {
return reverse_iterator(begin()); return reverse_iterator(begin());
} }
SPROUT_CONSTEXPR const_reverse_iterator rend() const SPROUT_NOEXCEPT { SPROUT_CONSTEXPR const_reverse_iterator rend() const SPROUT_NOEXCEPT {
@ -159,13 +159,13 @@ namespace sprout {
return size() == 0; return size() == 0;
} }
// element access: // element access:
reference operator[](size_type i) { SPROUT_CXX14_CONSTEXPR reference operator[](size_type i) {
return elems[i]; return elems[i];
} }
SPROUT_CONSTEXPR const_reference operator[](size_type i) const { SPROUT_CONSTEXPR const_reference operator[](size_type i) const {
return elems[i]; return elems[i];
} }
reference at(size_type i) { SPROUT_CXX14_CONSTEXPR reference at(size_type i) {
return i < size() return i < size()
? elems[i] ? elems[i]
: (throw std::out_of_range("uuid: index out of range"), elems[i]) : (throw std::out_of_range("uuid: index out of range"), elems[i])
@ -177,20 +177,20 @@ namespace sprout {
: (throw std::out_of_range("uuid: index out of range"), elems[i]) : (throw std::out_of_range("uuid: index out of range"), elems[i])
; ;
} }
reference front() { SPROUT_CXX14_CONSTEXPR reference front() {
return elems[0]; return elems[0];
} }
SPROUT_CONSTEXPR const_reference front() const { SPROUT_CONSTEXPR const_reference front() const {
return elems[0]; return elems[0];
} }
reference back() { SPROUT_CXX14_CONSTEXPR reference back() {
return elems[size() - 1]; return elems[size() - 1];
} }
SPROUT_CONSTEXPR const_reference back() const { SPROUT_CONSTEXPR const_reference back() const {
return elems[size() - 1]; return elems[size() - 1];
} }
pointer data() SPROUT_NOEXCEPT { SPROUT_CXX14_CONSTEXPR pointer data() SPROUT_NOEXCEPT {
return &elems[0]; return &elems[0];
} }
SPROUT_CONSTEXPR const_pointer data() const SPROUT_NOEXCEPT { SPROUT_CONSTEXPR const_pointer data() const SPROUT_NOEXCEPT {
@ -198,13 +198,16 @@ namespace sprout {
} }
// others: // others:
pointer c_array() SPROUT_NOEXCEPT { SPROUT_CXX14_CONSTEXPR pointer c_array() SPROUT_NOEXCEPT {
return &elems[0]; return &elems[0];
} }
void assign(const_reference value) { SPROUT_CONSTEXPR const_pointer c_array() SPROUT_NOEXCEPT {
return &elems[0];
}
SPROUT_CXX14_CONSTEXPR void assign(const_reference value) {
fill(value); fill(value);
} }
void rangecheck(size_type i) const { SPROUT_CXX14_CONSTEXPR void rangecheck(size_type i) const {
if (i >= size()) { if (i >= size()) {
throw std::out_of_range("uuid: index out of range"); throw std::out_of_range("uuid: index out of range");
} }
@ -267,7 +270,7 @@ namespace sprout {
// //
// swap // swap
// //
inline void inline SPROUT_CXX14_CONSTEXPR void
swap(sprout::uuids::uuid& lhs, sprout::uuids::uuid& rhs) swap(sprout::uuids::uuid& lhs, sprout::uuids::uuid& rhs)
SPROUT_NOEXCEPT_EXPR(SPROUT_NOEXCEPT_EXPR(lhs.swap(rhs))) SPROUT_NOEXCEPT_EXPR(SPROUT_NOEXCEPT_EXPR(lhs.swap(rhs)))
{ {

18
sprout/variant/variant.hpp
View file

@ -63,7 +63,7 @@ namespace sprout {
static_assert(Index::value < sizeof...(Types), "variant<>: invalid operand"); static_assert(Index::value < sizeof...(Types), "variant<>: invalid operand");
} }
public: public:
void swap(variant_impl& other) SPROUT_CXX14_CONSTEXPR void swap(variant_impl& other)
SPROUT_NOEXCEPT_EXPR(SPROUT_NOEXCEPT_EXPR(sprout::swap(tuple_, other.tuple_))) SPROUT_NOEXCEPT_EXPR(SPROUT_NOEXCEPT_EXPR(sprout::swap(tuple_, other.tuple_)))
{ {
sprout::swap(tuple_, other.tuple_); sprout::swap(tuple_, other.tuple_);
@ -238,23 +238,23 @@ namespace sprout {
) )
{} {}
// modifiers // modifiers
void swap(variant& other) SPROUT_CXX14_CONSTEXPR void swap(variant& other)
SPROUT_NOEXCEPT_EXPR(SPROUT_NOEXCEPT_EXPR(std::declval<impl_type&>().swap(other))) SPROUT_NOEXCEPT_EXPR(SPROUT_NOEXCEPT_EXPR(std::declval<impl_type&>().swap(other)))
{ {
impl_type::swap(other); impl_type::swap(other);
} }
variant& operator=(variant const& rhs) { SPROUT_CXX14_CONSTEXPR variant& operator=(variant const& rhs) {
static_cast<impl_type&>(*this) = rhs; static_cast<impl_type&>(*this) = rhs;
return *this; return *this;
} }
variant& operator=(variant&& rhs) SPROUT_CXX14_CONSTEXPR variant& operator=(variant&& rhs)
SPROUT_NOEXCEPT_EXPR(std::is_nothrow_move_assignable<impl_type>::value) SPROUT_NOEXCEPT_EXPR(std::is_nothrow_move_assignable<impl_type>::value)
{ {
static_cast<impl_type&>(*this) = sprout::move(rhs); static_cast<impl_type&>(*this) = sprout::move(rhs);
return *this; return *this;
} }
template<typename T> template<typename T>
variant& operator=(T&& rhs) { SPROUT_CXX14_CONSTEXPR variant& operator=(T&& rhs) {
static_cast<impl_type&>(*this) = variant(sprout::forward<T>(rhs)); static_cast<impl_type&>(*this) = variant(sprout::forward<T>(rhs));
return *this; return *this;
} }
@ -302,7 +302,7 @@ namespace sprout {
; ;
} }
template<std::size_t I> template<std::size_t I>
typename std::enable_if< SPROUT_CXX14_CONSTEXPR typename std::enable_if<
I != sizeof...(Types), I != sizeof...(Types),
typename sprout::tuples::tuple_element<I, tuple_type>::type& typename sprout::tuples::tuple_element<I, tuple_type>::type&
>::type get_at() { >::type get_at() {
@ -318,7 +318,7 @@ namespace sprout {
return get_at<sprout::types::find_index<tuple_type, U>::value>(); return get_at<sprout::types::find_index<tuple_type, U>::value>();
} }
template<typename U> template<typename U>
typename std::enable_if< SPROUT_CXX14_CONSTEXPR typename std::enable_if<
sprout::types::find_index<tuple_type, U>::value != sizeof...(Types), sprout::types::find_index<tuple_type, U>::value != sizeof...(Types),
U& U&
>::type get() { >::type get() {
@ -334,7 +334,7 @@ namespace sprout {
; ;
} }
template<typename Visitor> template<typename Visitor>
typename visitor_result<typename std::remove_reference<Visitor>::type, variant>::type SPROUT_CXX14_CONSTEXPR typename visitor_result<typename std::remove_reference<Visitor>::type, variant>::type
apply_visitor(Visitor&& visitor) { apply_visitor(Visitor&& visitor) {
typedef typename visitor_result<typename std::remove_reference<Visitor>::type, variant>::type result_type; typedef typename visitor_result<typename std::remove_reference<Visitor>::type, variant>::type result_type;
return SPROUT_ASSERT(0 <= which_ && sprout::math::less(which_, sizeof...(Types))), return SPROUT_ASSERT(0 <= which_ && sprout::math::less(which_, sizeof...(Types))),
@ -347,7 +347,7 @@ namespace sprout {
// swap // swap
// //
template<typename... Types> template<typename... Types>
inline void inline SPROUT_CXX14_CONSTEXPR void
swap(sprout::variant<Types...>& lhs, sprout::variant<Types...>& rhs) swap(sprout::variant<Types...>& lhs, sprout::variant<Types...>& rhs)
SPROUT_NOEXCEPT_EXPR(SPROUT_NOEXCEPT_EXPR(lhs.swap(rhs))) SPROUT_NOEXCEPT_EXPR(SPROUT_NOEXCEPT_EXPR(lhs.swap(rhs)))
{ {