mirror/Sprout
1
0
Fork 0
mirror of https://github.com/bolero-MURAKAMI/Sprout.git synced 2024-12-23 21:25:49 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions

add first, second free-function

Browse source 
add string::find
This commit is contained in:
bolero-MURAKAMI 2012-10-08 14:14:59 +09:00
parent 5ce2cb023c
commit 35f08fe242
13 changed files with 611 additions and 383 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

32
libs/string/test/string.cpp
View file

@ -131,10 +131,14 @@ namespace testspr {
TESTSPR_ASSERT(s[0] == 'A');
}
// compare
TESTSPR_BOTH_ASSERT(str1.compare(cstr) == 0);
TESTSPR_BOTH_ASSERT(str1.compare("zzzz") < 0);
TESTSPR_BOTH_ASSERT(str1.compare("aaaa") > 0);
// find
TESTSPR_BOTH_ASSERT(str1.find(str2) == decltype(str1)::npos);
TESTSPR_BOTH_ASSERT(str1.find(to_string("1234")) == 6);
TESTSPR_BOTH_ASSERT(str1.find(str2.c_str()) == decltype(str1)::npos);
TESTSPR_BOTH_ASSERT(str1.find("1234") == 6);
TESTSPR_BOTH_ASSERT(str1.find(str2.c_str(), 0, 4) == decltype(str1)::npos);
TESTSPR_BOTH_ASSERT(str1.find("12341234", 0, 4) == 6);
TESTSPR_BOTH_ASSERT(str1.find('1') == 6);
// substr
{
@ -150,6 +154,26 @@ namespace testspr {
TESTSPR_BOTH_ASSERT(str3 == "foobar");
}
// compare
TESTSPR_BOTH_ASSERT(str1.compare(str1) == 0);
TESTSPR_BOTH_ASSERT(str1.compare(to_string("zzzz")) < 0);
TESTSPR_BOTH_ASSERT(str2.compare(to_string("aaaa")) > 0);
TESTSPR_BOTH_ASSERT(str1.compare(0, 3, to_string("foo")) == 0);
TESTSPR_BOTH_ASSERT(str1.compare(0, 3, to_string("zzzz")) < 0);
TESTSPR_BOTH_ASSERT(str2.compare(0, 3, to_string("aaaa")) > 0);
TESTSPR_BOTH_ASSERT(str1.compare(0, 3, to_string("foo"), 0, 3) == 0);
TESTSPR_BOTH_ASSERT(str1.compare(0, 3, to_string("zzzz"), 0, 3) < 0);
TESTSPR_BOTH_ASSERT(str2.compare(0, 3, to_string("aaaa"), 0, 3) > 0);
TESTSPR_BOTH_ASSERT(str1.compare(str1.c_str()) == 0);
TESTSPR_BOTH_ASSERT(str1.compare("zzzz") < 0);
TESTSPR_BOTH_ASSERT(str1.compare("aaaa") > 0);
TESTSPR_BOTH_ASSERT(str1.compare(0, 3, "foo") == 0);
TESTSPR_BOTH_ASSERT(str1.compare(0, 3, "zzzz") < 0);
TESTSPR_BOTH_ASSERT(str1.compare(0, 3, "aaaa") > 0);
TESTSPR_BOTH_ASSERT(str1.compare(0, 3, "foo", 3) == 0);
TESTSPR_BOTH_ASSERT(str1.compare(0, 3, "zzzz", 3) < 0);
TESTSPR_BOTH_ASSERT(str1.compare(0, 3, "aaaa", 3) > 0);
// operator==
TESTSPR_BOTH_ASSERT(!(str1 == str2));

26
sprout/array/array.hpp
View file

@ -17,19 +17,6 @@
#endif
namespace sprout {
namespace detail {
template<sprout::index_t Index, typename T>
inline SPROUT_CONSTEXPR T const&
array_dummy_get(T const& value) {
return value;
}
template<typename Array, typename T, sprout::index_t... Indexes>
inline SPROUT_CONSTEXPR Array
array_fill_impl(T const& value, sprout::index_tuple<Indexes...>) {
return Array{{array_dummy_get<Indexes>(value)...}};
}
} // namespace detail
//
// array
//
@ -54,6 +41,17 @@ namespace sprout {
typedef sprout::reverse_iterator<const_iterator> const_reverse_iterator;
public:
SPROUT_STATIC_CONSTEXPR size_type static_size = N;
private:
template<sprout::index_t Index>
static SPROUT_CONSTEXPR value_type const&
dummy_get(value_type const& value) {
return value;
}
template<sprout::index_t... Indexes>
static SPROUT_CONSTEXPR array
fill_impl(value_type const& value, sprout::index_tuple<Indexes...>) {
return array{{dummy_get<Indexes>(value)...}};
}
public:
value_type elems[static_size ? static_size : 1];
public:
@ -61,7 +59,7 @@ namespace sprout {
std::fill_n(begin(), size(), value);
}
SPROUT_CONSTEXPR array fill(const_reference value) const {
return sprout::detail::array_fill_impl<array>(value, sprout::index_n<0, N>::make());
return fill_impl(value, sprout::index_n<0, N>::make());
}
void swap(array<T, N>& other)
SPROUT_NOEXCEPT_EXPR(SPROUT_NOEXCEPT_EXPR(std::swap(std::declval<T&>(), std::declval<T&>())))

8
sprout/io.hpp
View file

@ -726,9 +726,6 @@ namespace sprout {
return holder.value();
}
//
// output
//
namespace detail {
template<typename Elem, typename Iterator, std::size_t K, typename... Args>
inline SPROUT_CONSTEXPR Elem
@ -741,7 +738,9 @@ namespace sprout {
)
;
}
} // namespace detail
namespace detail {
template<typename Elem, std::size_t N, sprout::index_t... Indexes, std::size_t K, typename... Args>
inline SPROUT_CONSTEXPR sprout::basic_string<Elem, N>
output_impl_1(sprout::index_tuple<Indexes...>, sprout::array<std::size_t, K> const& sizes, Args const&... args) {
@ -777,6 +776,9 @@ namespace sprout {
);
}
} // namespace detail
//
// output
//
template<std::size_t N, typename Elem, typename Expression>
inline SPROUT_CONSTEXPR sprout::basic_string<Elem, N>
output(Expression const& expr) {

26
sprout/string/char_traits.hpp
View file

@ -105,7 +105,7 @@ namespace sprout {
}
template<typename ConstIterator>
static SPROUT_CONSTEXPR ConstIterator find(ConstIterator s, std::size_t n, char_type const& a) {
return !n ? nullptr
return !n ? s + 1
: eq(*s, a) ? s
: find(s + 1, n - 1, a)
;
@ -125,6 +125,30 @@ namespace sprout {
std::fill(s, s + n, a);
return s;
}
#endif
};
//
// char_traits_helper
//
template<typename Traits>
class char_traits_helper {
public:
typedef Traits traits_type;
typedef typename traits_type::char_type char_type;
typedef typename traits_type::int_type int_type;
typedef typename traits_type::off_type off_type;
typedef typename traits_type::pos_type pos_type;
typedef typename traits_type::state_type state_type;
public:
static SPROUT_CONSTEXPR bool is_found(char_type const* found, char_type const* last) {
return found;
}
#if SPROUT_USE_INDEX_ITERATOR_IMPLEMENTATION
template<typename ConstIterator>
static SPROUT_CONSTEXPR bool is_found(ConstIterator found, ConstIterator last) {
return found != last;
}
#endif
};
} // namespace sprout

303
sprout/string/string.hpp
View file

@ -43,10 +43,35 @@ namespace sprout {
typedef sprout::reverse_iterator<iterator> reverse_iterator;
typedef sprout::reverse_iterator<const_iterator> const_reverse_iterator;
typedef Traits traits_type;
typedef sprout::char_traits_helper<traits_type> traits_helper_type;
public:
SPROUT_STATIC_CONSTEXPR size_type npos = -1;
SPROUT_STATIC_CONSTEXPR size_type static_size = N;
private:
template<typename ConstIterator>
static SPROUT_CONSTEXPR size_type
find_impl_2(const_iterator data, size_type len, ConstIterator s, size_type pos, size_type n) {
return pos <= len - n
? traits_type::eq(data[pos], *s) && traits_type::compare(data + (pos + 1), s + 1, n - 1) == 0
? pos
: find_impl_2(data, len, s, pos + 1, n)
: npos
;
}
template<typename ConstIterator>
static SPROUT_CONSTEXPR size_type
find_impl_1(const_iterator data, size_type len, ConstIterator s, size_type pos, size_type n) {
return n == 0 ? (pos <= len ? pos : npos)
: n <= len ? find_impl_2(data, len, s, pos, n)
: npos
;
}
static SPROUT_CONSTEXPR size_type
find_c_impl(const_iterator p, const_iterator first, const_iterator last) {
return traits_helper_type::is_found(p, last) ? p - first
: npos
;
}
static SPROUT_CONSTEXPR int
compare_impl_2(int compared, size_type n1, size_type n2) {
return compared != 0 ? compared
@ -55,66 +80,32 @@ namespace sprout {
: 0
;
}
static SPROUT_CONSTEXPR int
compare_impl_1(value_type const* dest, size_type pos1, size_type n1, value_type const* s, size_type n2) {
return compare_impl_2(
traits_type::compare(dest + pos1, s, NS_SSCRISK_CEL_OR_SPROUT::min(n1, n2)),
n1,
n2
);
}
template<sprout::index_t... Indexes>
static SPROUT_CONSTEXPR basic_string<T, N, Traits>
from_c_str_impl(value_type const* s, size_type n, sprout::index_tuple<Indexes...>) {
return sprout::basic_string<T, N, Traits>{{(Indexes < n ? s[Indexes] : T())...}, n};
}
#if SPROUT_USE_INDEX_ITERATOR_IMPLEMENTATION
template<typename ConstIterator>
static SPROUT_CONSTEXPR typename std::enable_if<
sprout::is_index_iterator<ConstIterator>::value,
int
>::type
compare_impl_1(value_type const* dest, size_type pos1, size_type n1, ConstIterator s, size_type n2) {
return compare_impl_2(
traits_type::compare(dest + pos1, s, NS_SSCRISK_CEL_OR_SPROUT::min(n1, n2)),
n1,
n2
);
}
static SPROUT_CONSTEXPR int
compare_impl_1(const_iterator dest, size_type pos1, size_type n1, value_type const* s, size_type n2) {
return compare_impl_2(
traits_type::compare(dest + pos1, s, NS_SSCRISK_CEL_OR_SPROUT::min(n1, n2)),
n1,
n2
);
}
template<typename ConstIterator>
static SPROUT_CONSTEXPR typename std::enable_if<
sprout::is_index_iterator<ConstIterator>::value,
int
>::type
compare_impl_1(const_iterator dest, size_type pos1, size_type n1, ConstIterator s, size_type n2) {
return compare_impl_2(
traits_type::compare(dest + pos1, s, NS_SSCRISK_CEL_OR_SPROUT::min(n1, n2)),
n1,
n2
n1, n2
);
}
#endif
template<sprout::index_t... Indexes>
static SPROUT_CONSTEXPR basic_string
from_c_str_impl(value_type const* s, size_type n, sprout::index_tuple<Indexes...>) {
return basic_string{{(Indexes < n ? s[Indexes] : T())...}, n};
}
template<std::size_t M, sprout::index_t... Indexes>
static SPROUT_CONSTEXPR basic_string<T, sizeof...(Indexes), Traits>
implicit_conversion_impl(T const(& elems)[M], size_type len, sprout::index_tuple<Indexes...>) {
return sprout::basic_string<T, sizeof...(Indexes), Traits>{{(Indexes < M - 1 ? elems[Indexes] : T())...}, len};
}
public:
static SPROUT_CONSTEXPR basic_string<T, N, Traits> from_c_str(value_type const* s, size_type n) {
static SPROUT_CONSTEXPR basic_string from_c_str(value_type const* s, size_type n) {
return !(N < n)
? from_c_str_impl(s, n, sprout::index_range<0, N>::make())
: throw std::out_of_range("basic_string<>: index out of range")
;
}
static SPROUT_CONSTEXPR basic_string<T, N, Traits> from_c_str(value_type const* s) {
static SPROUT_CONSTEXPR basic_string from_c_str(value_type const* s) {
return from_c_str(s, traits_type::length(s));
}
public:
@ -123,87 +114,112 @@ namespace sprout {
public:
// construct/copy/destroy:
template<std::size_t N2>
basic_string<T, N, Traits>& operator=(basic_string<T, N2, Traits> const& rhs) {
basic_string&
operator=(basic_string<T, N2, Traits> const& rhs) {
return assign(rhs);
}
basic_string<T, N, Traits>& operator=(value_type const* rhs) {
basic_string&
operator=(value_type const* rhs) {
return assign(rhs);
}
basic_string<T, N, Traits>& operator=(value_type rhs) {
basic_string&
operator=(value_type rhs) {
return assign(1, rhs);
}
// iterators:
#if SPROUT_USE_INDEX_ITERATOR_IMPLEMENTATION
iterator begin() SPROUT_NOEXCEPT {
iterator
begin() SPROUT_NOEXCEPT {
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);
}
iterator end() SPROUT_NOEXCEPT {
iterator
end() SPROUT_NOEXCEPT {
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());
}
#else
iterator begin() SPROUT_NOEXCEPT {
iterator
begin() SPROUT_NOEXCEPT {
return &elems[0];
}
SPROUT_CONSTEXPR const_iterator begin() const SPROUT_NOEXCEPT {
SPROUT_CONSTEXPR const_iterator
begin() const SPROUT_NOEXCEPT {
return &elems[0];
}
iterator end() SPROUT_NOEXCEPT {
iterator end()
SPROUT_NOEXCEPT {
return &elems[0] + size();
}
SPROUT_CONSTEXPR const_iterator end() const SPROUT_NOEXCEPT {
SPROUT_CONSTEXPR const_iterator
end() const SPROUT_NOEXCEPT {
return &elems[0] + size();
}
#endif
reverse_iterator rbegin() SPROUT_NOEXCEPT {
reverse_iterator
rbegin() SPROUT_NOEXCEPT {
return const_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());
}
reverse_iterator rend() SPROUT_NOEXCEPT {
reverse_iterator
rend() SPROUT_NOEXCEPT {
return const_reverse_iterator(begin());
}
SPROUT_CONSTEXPR const_reverse_iterator rend() const SPROUT_NOEXCEPT {
SPROUT_CONSTEXPR const_reverse_iterator
rend() const SPROUT_NOEXCEPT {
return const_reverse_iterator(begin());
}
#if SPROUT_USE_INDEX_ITERATOR_IMPLEMENTATION
SPROUT_CONSTEXPR const_iterator cbegin() const SPROUT_NOEXCEPT {
SPROUT_CONSTEXPR const_iterator
cbegin() const SPROUT_NOEXCEPT {
return const_iterator(*this, 0);
}
SPROUT_CONSTEXPR const_iterator cend() const SPROUT_NOEXCEPT {
SPROUT_CONSTEXPR const_iterator
cend() const SPROUT_NOEXCEPT {
return const_iterator(*this, size());
}
#else
SPROUT_CONSTEXPR const_iterator cbegin() const SPROUT_NOEXCEPT {
SPROUT_CONSTEXPR const_iterator
cbegin() const SPROUT_NOEXCEPT {
return &elems[0];
}
SPROUT_CONSTEXPR const_iterator cend() const SPROUT_NOEXCEPT {
SPROUT_CONSTEXPR const_iterator
cend() const SPROUT_NOEXCEPT {
return &elems[0] + size();
}
#endif
SPROUT_CONSTEXPR const_reverse_iterator crbegin() const SPROUT_NOEXCEPT {
SPROUT_CONSTEXPR const_reverse_iterator
crbegin() const SPROUT_NOEXCEPT {
return const_reverse_iterator(end());
}
SPROUT_CONSTEXPR const_reverse_iterator crend() const SPROUT_NOEXCEPT {
SPROUT_CONSTEXPR const_reverse_iterator
crend() const SPROUT_NOEXCEPT {
return const_reverse_iterator(begin());
}
// capacity:
SPROUT_CONSTEXPR size_type size() const SPROUT_NOEXCEPT {
SPROUT_CONSTEXPR size_type
size() const SPROUT_NOEXCEPT {
return len;
}
SPROUT_CONSTEXPR size_type length() const SPROUT_NOEXCEPT {
SPROUT_CONSTEXPR size_type
length() const SPROUT_NOEXCEPT {
return size();
}
SPROUT_CONSTEXPR size_type max_size() const SPROUT_NOEXCEPT {
SPROUT_CONSTEXPR size_type
max_size() const SPROUT_NOEXCEPT {
return static_size;
}
void resize(size_type n, value_type c) {
void
resize(size_type n, value_type c) {
maxcheck(n);
if (n > size()) {
traits_type::assign(end(), n - size(), c);
@ -211,60 +227,74 @@ namespace sprout {
traits_type::assign(begin() + n, max_size() - n, value_type());
len = n;
}
void resize(size_type n) {
void
resize(size_type n) {
resize(n, value_type());
}
void clear() {
void
clear() {
traits_type::assign(begin(), max_size(), value_type());
len = 0;
}
SPROUT_CONSTEXPR bool empty() const SPROUT_NOEXCEPT {
SPROUT_CONSTEXPR bool
empty() const SPROUT_NOEXCEPT {
return size() == 0;
}
// element access:
reference operator[](size_type i) {
reference
operator[](size_type 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];
}
reference at(size_type i) {
reference
at(size_type i) {
return i < size()
? elems[i]
: (throw std::out_of_range("basic_string<>: index out of range"), elems[i])
;
}
SPROUT_CONSTEXPR const_reference at(size_type i) const {
SPROUT_CONSTEXPR const_reference
at(size_type i) const {
return i < size()
? elems[i]
: (throw std::out_of_range("basic_string<>: index out of range"), elems[i])
;
}
reference front() {
reference
front() {
return elems[0];
}
SPROUT_CONSTEXPR const_reference front() const {
SPROUT_CONSTEXPR const_reference
front() const {
return elems[0];
}
reference back() {
reference
back() {
return elems[size() - 1];
}
SPROUT_CONSTEXPR const_reference back() const {
SPROUT_CONSTEXPR const_reference
back() const {
return elems[size() - 1];
}
// modifiers:
template<std::size_t N2>
basic_string<T, N, Traits>& assign(basic_string<T, N2, Traits> const& str) {
basic_string&
assign(basic_string<T, N2, Traits> const& str) {
return assign(str.begin(), str.size());
}
template<std::size_t N2>
basic_string<T, N, Traits>& assign(basic_string<T, N2, Traits> const& str, size_type pos, size_type n) {
basic_string&
assign(basic_string<T, N2, Traits> const& str, size_type pos, size_type n) {
if (str.size() < pos + n) {
throw std::out_of_range("basic_string<>: index out of range");
}
return assign(str.begin() + pos, n);
}
basic_string<T, N, Traits>& assign(value_type const* s, size_type n) {
basic_string&
assign(value_type const* s, size_type n) {
maxcheck(n);
for (size_type i = 0; i < n; ++i) {
traits_type::assign(elems[i], s[i]);
@ -275,10 +305,12 @@ namespace sprout {
len = n;
return *this;
}
basic_string<T, N, Traits>& assign(value_type const* s) {
basic_string&
assign(value_type const* s) {
return assign(s, traits_type::length(s));
}
basic_string<T, N, Traits>& assign(size_type n, value_type c) {
basic_string&
assign(size_type n, value_type c) {
maxcheck(n);
traits_type::assign(begin(), n, c);
traits_type::assign(begin() + n, max_size() - n, value_type());
@ -286,7 +318,8 @@ namespace sprout {
return *this;
}
template<typename Iterator>
basic_string<T, N, Traits>& assign(Iterator first, Iterator last) {
basic_string&
assign(Iterator first, Iterator last) {
size_type n = 0;
for (; n < max_size() || first != last; ++n, ++first) {
traits_type::assign(elems[n], *first);
@ -297,23 +330,47 @@ namespace sprout {
len = n;
return *this;
}
void swap(basic_string<T, N, Traits>& other)
void
swap(basic_string& other)
SPROUT_NOEXCEPT_EXPR(SPROUT_NOEXCEPT_EXPR(std::swap(std::declval<T&>(), std::declval<T&>())))
{
std::swap_ranges(other.begin(), other.begin() + other.max_size(), begin());
sprout::swap(len, other.len);
}
// string operations:
SPROUT_CONSTEXPR const_pointer c_str() const SPROUT_NOEXCEPT {
SPROUT_CONSTEXPR const_pointer
c_str() const SPROUT_NOEXCEPT {
return &elems[0];
}
pointer data() SPROUT_NOEXCEPT {
pointer
data() SPROUT_NOEXCEPT {
return &elems[0];
}
SPROUT_CONSTEXPR const_pointer data() const SPROUT_NOEXCEPT {
SPROUT_CONSTEXPR const_pointer
data() const SPROUT_NOEXCEPT {
return &elems[0];
}
SPROUT_CONSTEXPR basic_string<T, N, Traits> substr(size_type pos = 0, size_type n = npos) const {
template<std::size_t N2>
SPROUT_CONSTEXPR size_type
find(basic_string<T, N2, Traits> const& str, size_type pos = 0) const SPROUT_NOEXCEPT {
return find_impl_1(begin(), len, str.begin(), pos, str.size());
}
SPROUT_CONSTEXPR size_type
find(value_type const* s, size_type pos, size_type n) const {
return find_impl_1(begin(), len, s, pos, n);
}
SPROUT_CONSTEXPR size_type
find(value_type const* s, size_type pos = 0) const {
return find(s, pos, traits_type::length(s));
}
SPROUT_CONSTEXPR size_type
find(value_type c, size_type pos = 0) const {
return pos < len ? find_c_impl(traits_type::find(begin() + pos, len - pos, c), begin(), end())
: npos
;
}
SPROUT_CONSTEXPR basic_string
substr(size_type pos = 0, size_type n = npos) const {
return !(size() < pos)
? n == npos
? substr(pos, size() - pos)
@ -322,27 +379,33 @@ namespace sprout {
;
}
template<std::size_t N2>
SPROUT_CONSTEXPR int compare(basic_string<T, N2, Traits> const& str) const {
SPROUT_CONSTEXPR int
compare(basic_string<T, N2, Traits> const& str) const {
return compare(0, size(), str.begin(), str.size());
}
SPROUT_CONSTEXPR int compare(value_type const* s) const {
SPROUT_CONSTEXPR int
compare(value_type const* s) const {
return compare(0, size(), s, traits_type::length(s));
}
template<std::size_t N2>
SPROUT_CONSTEXPR int compare(size_type pos1, size_type n1, basic_string<T, N2, Traits> const& str) const {
SPROUT_CONSTEXPR int
compare(size_type pos1, size_type n1, basic_string<T, N2, Traits> const& str) const {
return compare(pos1, n1, str, 0, npos);
}
SPROUT_CONSTEXPR int compare(size_type pos1, size_type n1, value_type const* s) const {
SPROUT_CONSTEXPR int
compare(size_type pos1, size_type n1, value_type const* s) const {
return compare(pos1, n1, s, traits_type::length(s));
}
template<std::size_t N2>
SPROUT_CONSTEXPR int compare(size_type pos1, size_type n1, basic_string<T, N2, Traits> const& str, size_type pos2, size_type n2) const {
SPROUT_CONSTEXPR int
compare(size_type pos1, size_type n1, basic_string<T, N2, Traits> const& str, size_type pos2, size_type n2) const {
return !(str.size() < pos2)
? compare(pos1, n1, str.begin() + pos2, NS_SSCRISK_CEL_OR_SPROUT::min(n2, str.size() - pos2))
: throw std::out_of_range("basic_string<>: index out of range")
;
}
SPROUT_CONSTEXPR int compare(size_type pos1, size_type n1, value_type const* s, size_type n2) const {
SPROUT_CONSTEXPR int
compare(size_type pos1, size_type n1, value_type const* s, size_type n2) const {
return !(size() < pos1)
? compare_impl_1(begin(), pos1, NS_SSCRISK_CEL_OR_SPROUT::min(n1, size() - pos1), s, n2)
: throw std::out_of_range("basic_string<>: index out of range")
@ -357,15 +420,18 @@ namespace sprout {
sprout::index_range<0, N2>::make()
);
}
pointer c_array() SPROUT_NOEXCEPT {
pointer
c_array() SPROUT_NOEXCEPT {
return &elems[0];
}
void rangecheck(size_type i) const {
void
rangecheck(size_type i) const {
if (i >= size()) {
throw std::out_of_range("basic_string<>: index out of range");
}
}
void maxcheck(size_type n) const {
void
maxcheck(size_type n) const {
if (n > max_size()) {
throw std::out_of_range("basic_string<>: index out of range");
}
@ -374,8 +440,9 @@ namespace sprout {
template<typename ConstIterator>
typename std::enable_if<
sprout::is_index_iterator<ConstIterator>::value,
basic_string<T, N, Traits>&
>::type assign(ConstIterator s, size_type n) {
basic_string&
>::type
assign(ConstIterator s, size_type n) {
maxcheck(n);
for (size_type i = 0; i < n; ++i) {
traits_type::assign(elems[i], s[i]);
@ -389,36 +456,58 @@ namespace sprout {
template<typename ConstIterator>
typename std::enable_if<
sprout::is_index_iterator<ConstIterator>::value,
basic_string<T, N, Traits>&
>::type assign(ConstIterator s) {
basic_string&
>::type
assign(ConstIterator s) {
return assign(s, traits_type::length(s));
}
template<typename ConstIterator>
typename std::enable_if<
sprout::is_index_iterator<ConstIterator>::value,
basic_string<T, N, Traits>&
>::type operator=(ConstIterator rhs) {
basic_string&
>::type
operator=(ConstIterator rhs) {
return assign(rhs);
}
template<typename ConstIterator>
SPROUT_CONSTEXPR typename std::enable_if<
sprout::is_index_iterator<ConstIterator>::value,
size_type
>::type
find(ConstIterator s, size_type pos, size_type n) const {
return find_impl_1(begin(), len, s, pos, n);
}
template<typename ConstIterator>
SPROUT_CONSTEXPR typename std::enable_if<
sprout::is_index_iterator<ConstIterator>::value,
size_type
>::type
find(ConstIterator s, size_type pos = 0) const {
return find(s, pos, traits_type::length(s));
}
template<typename ConstIterator>
SPROUT_CONSTEXPR typename std::enable_if<
sprout::is_index_iterator<ConstIterator>::value,
int
>::type compare(ConstIterator s) const {
>::type
compare(ConstIterator s) const {
return compare(0, size(), s, traits_type::length(s));
}
template<typename ConstIterator>
SPROUT_CONSTEXPR typename std::enable_if<
sprout::is_index_iterator<ConstIterator>::value,
int
>::type compare(size_type pos1, size_type n1, ConstIterator s) const {
>::type
compare(size_type pos1, size_type n1, ConstIterator s) const {
return compare(pos1, n1, s, traits_type::length(s));
}
template<typename ConstIterator>
SPROUT_CONSTEXPR typename std::enable_if<
sprout::is_index_iterator<ConstIterator>::value,
int
>::type compare(size_type pos1, size_type n1, ConstIterator s, size_type n2) const {
>::type
compare(size_type pos1, size_type n1, ConstIterator s, size_type n2) const {
return !(size() < pos1)
? compare_impl_1(begin(), pos1, NS_SSCRISK_CEL_OR_SPROUT::min(n1, size() - pos1), s, n2)
: throw std::out_of_range("basic_string<>: index out of range")

259
sprout/utility/pair.hpp
View file

@ -1,260 +1,11 @@
#ifndef SPROUT_UTILITY_PAIR_HPP
#define SPROUT_UTILITY_PAIR_HPP
#include <utility>
#include <type_traits>
#include <sprout/config.hpp>
#include <sprout/index_tuple.hpp>
#include <sprout/utility/forward.hpp>
#include <sprout/utility/move.hpp>
#include <sprout/utility/swap.hpp>
#include <sprout/tuple/tuple.hpp>
#include <sprout/functional/ref.hpp>
namespace sprout {
// Copyright (C) 2011 RiSK (sscrisk)
//
// pair
//
template <typename T1, typename T2>
struct pair {
public:
typedef T1 first_type;
typedef T2 second_type;
public:
T1 first;
T2 second;
private:
template <typename... Args1, typename... Args2, sprout::index_t... Indexes1, sprout::index_t... Indexes2>
SPROUT_CONSTEXPR pair(
sprout::tuples::tuple<Args1...> first_args,
sprout::tuples::tuple<Args2...> second_args,
sprout::index_tuple<Indexes1...>,
sprout::index_tuple<Indexes2...>
)
: first(sprout::tuples::get<Indexes1>(first_args)...)
, second(sprout::tuples::get<Indexes2>(second_args)...)
{}
public:
pair(pair const&) = default;
pair(pair&&) = default;
SPROUT_CONSTEXPR pair()
: first()
, second()
{}
SPROUT_CONSTEXPR pair(T1 const& x, T2 const& y)
: first(x)
, second(y)
{}
template<typename U, typename V>
SPROUT_CONSTEXPR pair(U&& x, V&& y)
: first(sprout::forward<U>(x))
, second(sprout::forward<V>(y))
{}
template<typename U, typename V>
SPROUT_CONSTEXPR pair(sprout::pair<U, V> const& p)
: first(p.first)
, second(p.second)
{}
template<typename U, typename V>
SPROUT_CONSTEXPR pair(sprout::pair<U, V>&& p)
: first(sprout::forward<U>(p.first))
, second(sprout::forward<V>(p.second))
{}
#if SPROUT_USE_DELEGATING_CONSTRUCTORS
template <typename... Args1, typename... Args2>
SPROUT_CONSTEXPR pair(
sprout::tuples::tuple<Args1...> first_args,
sprout::tuples::tuple<Args2...> second_args
)
: pair(
first_args,
second_args,
sprout::index_range<0, sizeof...(Args1)>::make(),
sprout::index_range<0, sizeof...(Args2)>::make()
)
{}
#else // #if SPROUT_USE_DELEGATING_CONSTRUCTORS
template <typename... Args1, typename... Args2>
SPROUT_CONSTEXPR pair(
sprout::tuples::tuple<Args1...> first_args,
sprout::tuples::tuple<Args2...> second_args
);
#endif // #if SPROUT_USE_DELEGATING_CONSTRUCTORS
pair& operator=(pair const& p) = default;
template<typename U, typename V>
pair& operator=(sprout::pair<U, V> const& p) {
first = p.first;
second = p.second;
return *this;
}
pair& operator=(pair&& p)
SPROUT_NOEXCEPT_EXPR(std::is_nothrow_move_assignable<T1>::value && std::is_nothrow_move_assignable<T2>::value)
{
first = sprout::forward<T1>(p.first);
second = std::forward<T2>(p.second);
return *this;
}
template<typename U, typename V>
pair& operator=(sprout::pair<U, V>&& p) {
first = std::forward<U>(p.first);
second = std::forward<V>(p.second);
return *this;
}
void swap(pair& p)
SPROUT_NOEXCEPT_EXPR(
SPROUT_NOEXCEPT_EXPR(swap(first, p.first))
&& SPROUT_NOEXCEPT_EXPR(swap(second, p.second))
)
{
sprout::swap(first, p.first);
sprout::swap(second, p.second);
}
};
template<class T1, class T2>
inline SPROUT_CONSTEXPR bool
operator==(sprout::pair<T1, T2> const& x, sprout::pair<T1, T2> const& y) {
return x.first == y.first && x.second == y.second;
}
template<class T1, class T2>
inline SPROUT_CONSTEXPR bool
operator!=(sprout::pair<T1, T2> const& x, sprout::pair<T1, T2> const& y) {
return !(x == y);
}
template<class T1, class T2>
inline SPROUT_CONSTEXPR bool
operator<(sprout::pair<T1, T2> const& x, sprout::pair<T1, T2> const& y) {
return x.first < y.first || (!(y.first < x.first) && x.second < y.second);
}
template<class T1, class T2>
inline SPROUT_CONSTEXPR bool
operator>(sprout::pair<T1, T2> const& x, sprout::pair<T1, T2> const& y) {
return y < x;
}
template<class T1, class T2>
inline SPROUT_CONSTEXPR bool
operator<=(sprout::pair<T1, T2> const& x, sprout::pair<T1, T2> const& y) {
return !(y < x);
}
template<class T1, class T2>
inline SPROUT_CONSTEXPR bool
operator>=(sprout::pair<T1, T2> const& x, sprout::pair<T1, T2> const& y) {
return !(x < y);
}
//
// swap
//
template<class T1, class T2>
inline void
swap(sprout::pair<T1, T2>& lhs, sprout::pair<T1, T2>& rhs)
SPROUT_NOEXCEPT_EXPR(SPROUT_NOEXCEPT_EXPR(lhs.swap(rhs)))
{
lhs.swap(rhs);
}
//
// make_pair
//
template<typename T1, typename T2>
inline SPROUT_CONSTEXPR sprout::pair<
typename sprout::strip_reference<typename std::decay<T1>::type>::type,
typename sprout::strip_reference<typename std::decay<T2>::type>::type
>
make_pair(T1&& x, T2&& y) {
return sprout::pair<
typename sprout::strip_reference<typename std::decay<T1>::type>::type,
typename sprout::strip_reference<typename std::decay<T2>::type>::type
>(
sprout::forward<T1>(x),
sprout::forward<T2>(y)
);
}
} // namespace sprout
namespace sprout {
namespace tuples {
namespace detail {
template<std::size_t I, typename T>
struct tuple_element_impl;
template<typename T1, typename T2>
struct tuple_element_impl<0, sprout::pair<T1, T2> > {
public:
typedef T1 type;
};
template<typename T1, typename T2>
struct tuple_element_impl<1, sprout::pair<T1, T2> > {
public:
typedef T2 type;
};
template<std::size_t I, typename T>
struct get_impl;
template<typename T1, typename T2>
struct get_impl<0, sprout::pair<T1, T2> > {
public:
SPROUT_CONSTEXPR T1& operator()(sprout::pair<T1, T2>& t) const {
return t.first;
}
SPROUT_CONSTEXPR T1 const& operator()(sprout::pair<T1, T2> const& t) const {
return t.first;
}
};
template<typename T1, typename T2>
struct get_impl<1, sprout::pair<T1, T2> > {
public:
SPROUT_CONSTEXPR T2& operator()(sprout::pair<T1, T2>& t) const {
return t.second;
}
SPROUT_CONSTEXPR T2 const& operator()(sprout::pair<T1, T2> const& t) const {
return t.second;
}
};
} // namespace detail
} // namespace tuples
} // namespace sprout
namespace std {
//
// tuple_size
//
template<typename T1, typename T2>
struct tuple_size<sprout::pair<T1, T2> >
: public std::integral_constant<std::size_t, 2>
{};
//
// tuple_element
//
template<std::size_t I, typename T1, typename T2>
struct tuple_element<I, sprout::pair<T1, T2> >
: public sprout::tuples::detail::tuple_element_impl<I, sprout::pair<T1, T2> >
{};
} // namespace std
namespace sprout {
//
// tuple_get
//
template<std::size_t I, typename T1, typename T2>
inline SPROUT_CONSTEXPR typename sprout::tuples::tuple_element<I, sprout::pair<T1, T2> >::type&
tuple_get(sprout::pair<T1, T2>& t) SPROUT_NOEXCEPT {
static_assert(I < 2, "tuple_get: index out of range");
return sprout::tuples::detail::get_impl<I, sprout::pair<T1, T2> >()(t);
}
template<std::size_t I, typename T1, typename T2>
inline SPROUT_CONSTEXPR typename sprout::tuples::tuple_element<I, sprout::pair<T1, T2> >::type const&
tuple_get(sprout::pair<T1, T2> const& t) SPROUT_NOEXCEPT {
static_assert(I < 2, "tuple_get: index out of range");
return sprout::tuples::detail::get_impl<I, sprout::pair<T1, T2> >()(t);
}
template<std::size_t I, typename T1, typename T2>
inline SPROUT_CONSTEXPR typename sprout::tuples::tuple_element<I, sprout::pair<T1, T2> >::type&&
tuple_get(sprout::pair<T1, T2>&& t) SPROUT_NOEXCEPT {
return sprout::move(sprout::tuples::get<I>(t));
}
} // namespace sprout
#include <sprout/utility/pair/pair.hpp>
#include <sprout/utility/pair/comparison.hpp>
#include <sprout/utility/pair/tuple.hpp>
#include <sprout/utility/pair/make_pair.hpp>
#include <sprout/utility/pair/access.hpp>
#endif // #ifndef SPROUT_UTILITY_PAIR_HPP

8
sprout/utility/pair/access.hpp Normal file
View file

@ -0,0 +1,8 @@
#ifndef SPROUT_UTILITY_PAIR_ACCESS_HPP
#define SPROUT_UTILITY_PAIR_ACCESS_HPP
#include <sprout/config.hpp>
#include <sprout/utility/pair/first.hpp>
#include <sprout/utility/pair/second.hpp>
#endif // #ifndef SPROUT_UTILITY_PAIR_ACCESS_HPP

40
sprout/utility/pair/comparison.hpp Normal file
View file

@ -0,0 +1,40 @@
#ifndef SPROUT_UTILITY_PAIR_COMPARISON_HPP
#define SPROUT_UTILITY_PAIR_COMPARISON_HPP
#include <sprout/config.hpp>
#include <sprout/utility/pair/pair.hpp>
namespace sprout {
template<class T1, class T2>
inline SPROUT_CONSTEXPR bool
operator==(sprout::pair<T1, T2> const& x, sprout::pair<T1, T2> const& y) {
return x.first == y.first && x.second == y.second;
}
template<class T1, class T2>
inline SPROUT_CONSTEXPR bool
operator!=(sprout::pair<T1, T2> const& x, sprout::pair<T1, T2> const& y) {
return !(x == y);
}
template<class T1, class T2>
inline SPROUT_CONSTEXPR bool
operator<(sprout::pair<T1, T2> const& x, sprout::pair<T1, T2> const& y) {
return x.first < y.first || (!(y.first < x.first) && x.second < y.second);
}
template<class T1, class T2>
inline SPROUT_CONSTEXPR bool
operator>(sprout::pair<T1, T2> const& x, sprout::pair<T1, T2> const& y) {
return y < x;
}
template<class T1, class T2>
inline SPROUT_CONSTEXPR bool
operator<=(sprout::pair<T1, T2> const& x, sprout::pair<T1, T2> const& y) {
return !(y < x);
}
template<class T1, class T2>
inline SPROUT_CONSTEXPR bool
operator>=(sprout::pair<T1, T2> const& x, sprout::pair<T1, T2> const& y) {
return !(x < y);
}
} // namespace sprout
#endif // #ifndef SPROUT_UTILITY_PAIR_COMPARISON_HPP

22
sprout/utility/pair/first.hpp Normal file
View file

@ -0,0 +1,22 @@
#ifndef SPROUT_UTILITY_PAIR_FIRST_HPP
#define SPROUT_UTILITY_PAIR_FIRST_HPP
#include <sprout/config.hpp>
#include <sprout/tuple/tuple/get.hpp>
#include <sprout/utility/forward.hpp>
namespace sprout {
//
// first
//
template<typename T>
inline SPROUT_CONSTEXPR auto
first(T&& t)
SPROUT_NOEXCEPT_EXPR(SPROUT_NOEXCEPT_EXPR(sprout::tuples::get<0>(sprout::forward<T>(t))))
-> decltype(sprout::tuples::get<0>(sprout::forward<T>(t)))
{
return sprout::tuples::get<0>(sprout::forward<T>(t));
}
} // namespace sprout
#endif // #ifndef SPROUT_UTILITY_PAIR_FIRST_HPP

29
sprout/utility/pair/make_pair.hpp Normal file
View file

@ -0,0 +1,29 @@
#ifndef SPROUT_UTILITY_PAIR_MAKE_PAIR_HPP
#define SPROUT_UTILITY_PAIR_MAKE_PAIR_HPP
#include <sprout/config.hpp>
#include <sprout/utility/forward.hpp>
#include <sprout/utility/pair/pair.hpp>
#include <sprout/functional/ref.hpp>
namespace sprout {
//
// make_pair
//
template<typename T1, typename T2>
inline SPROUT_CONSTEXPR sprout::pair<
typename sprout::strip_reference<typename std::decay<T1>::type>::type,
typename sprout::strip_reference<typename std::decay<T2>::type>::type
>
make_pair(T1&& x, T2&& y) {
return sprout::pair<
typename sprout::strip_reference<typename std::decay<T1>::type>::type,
typename sprout::strip_reference<typename std::decay<T2>::type>::type
>(
sprout::forward<T1>(x),
sprout::forward<T2>(y)
);
}
} // namespace sprout
#endif // #ifndef SPROUT_UTILITY_PAIR_MAKE_PAIR_HPP

126
sprout/utility/pair/pair.hpp Normal file
View file

@ -0,0 +1,126 @@
#ifndef SPROUT_UTILITY_PAIR_PAIR_HPP
#define SPROUT_UTILITY_PAIR_PAIR_HPP
#include <utility>
#include <type_traits>
#include <sprout/config.hpp>
#include <sprout/index_tuple.hpp>
#include <sprout/utility/forward.hpp>
#include <sprout/utility/swap.hpp>
#include <sprout/tuple/tuple.hpp>
namespace sprout {
// Copyright (C) 2011 RiSK (sscrisk)
//
// pair
//
template <typename T1, typename T2>
struct pair {
public:
typedef T1 first_type;
typedef T2 second_type;
public:
T1 first;
T2 second;
private:
template <typename... Args1, typename... Args2, sprout::index_t... Indexes1, sprout::index_t... Indexes2>
SPROUT_CONSTEXPR pair(
sprout::tuples::tuple<Args1...> first_args,
sprout::tuples::tuple<Args2...> second_args,
sprout::index_tuple<Indexes1...>,
sprout::index_tuple<Indexes2...>
)
: first(sprout::tuples::get<Indexes1>(first_args)...)
, second(sprout::tuples::get<Indexes2>(second_args)...)
{}
public:
pair(pair const&) = default;
pair(pair&&) = default;
SPROUT_CONSTEXPR pair()
: first()
, second()
{}
SPROUT_CONSTEXPR pair(T1 const& x, T2 const& y)
: first(x)
, second(y)
{}
template<typename U, typename V>
SPROUT_CONSTEXPR pair(U&& x, V&& y)
: first(sprout::forward<U>(x))
, second(sprout::forward<V>(y))
{}
template<typename U, typename V>
SPROUT_CONSTEXPR pair(sprout::pair<U, V> const& p)
: first(p.first)
, second(p.second)
{}
template<typename U, typename V>
SPROUT_CONSTEXPR pair(sprout::pair<U, V>&& p)
: first(sprout::forward<U>(p.first))
, second(sprout::forward<V>(p.second))
{}
#if SPROUT_USE_DELEGATING_CONSTRUCTORS
template <typename... Args1, typename... Args2>
SPROUT_CONSTEXPR pair(
sprout::tuples::tuple<Args1...> first_args,
sprout::tuples::tuple<Args2...> second_args
)
: pair(
first_args,
second_args,
sprout::index_range<0, sizeof...(Args1)>::make(),
sprout::index_range<0, sizeof...(Args2)>::make()
)
{}
#else // #if SPROUT_USE_DELEGATING_CONSTRUCTORS
template <typename... Args1, typename... Args2>
SPROUT_CONSTEXPR pair(
sprout::tuples::tuple<Args1...> first_args,
sprout::tuples::tuple<Args2...> second_args
);
#endif // #if SPROUT_USE_DELEGATING_CONSTRUCTORS
pair& operator=(pair const& p) = default;
template<typename U, typename V>
pair& operator=(sprout::pair<U, V> const& p) {
first = p.first;
second = p.second;
return *this;
}
pair& operator=(pair&& p)
SPROUT_NOEXCEPT_EXPR(std::is_nothrow_move_assignable<T1>::value && std::is_nothrow_move_assignable<T2>::value)
{
first = sprout::forward<T1>(p.first);
second = std::forward<T2>(p.second);
return *this;
}
template<typename U, typename V>
pair& operator=(sprout::pair<U, V>&& p) {
first = std::forward<U>(p.first);
second = std::forward<V>(p.second);
return *this;
}
void swap(pair& p)
SPROUT_NOEXCEPT_EXPR(
SPROUT_NOEXCEPT_EXPR(swap(first, p.first))
&& SPROUT_NOEXCEPT_EXPR(swap(second, p.second))
)
{
sprout::swap(first, p.first);
sprout::swap(second, p.second);
}
};
//
// swap
//
template<class T1, class T2>
inline void
swap(sprout::pair<T1, T2>& lhs, sprout::pair<T1, T2>& rhs)
SPROUT_NOEXCEPT_EXPR(SPROUT_NOEXCEPT_EXPR(lhs.swap(rhs)))
{
lhs.swap(rhs);
}
} // namespace sprout
#endif // #ifndef SPROUT_UTILITY_PAIR_PAIR_HPP

22
sprout/utility/pair/second.hpp Normal file
View file

@ -0,0 +1,22 @@
#ifndef SPROUT_UTILITY_PAIR_SECOND_HPP
#define SPROUT_UTILITY_PAIR_SECOND_HPP
#include <sprout/config.hpp>
#include <sprout/tuple/tuple/get.hpp>
#include <sprout/utility/forward.hpp>
namespace sprout {
//
// second
//
template<typename T>
inline SPROUT_CONSTEXPR auto
second(T&& t)
SPROUT_NOEXCEPT_EXPR(SPROUT_NOEXCEPT_EXPR(sprout::tuples::get<1>(sprout::forward<T>(t))))
-> decltype(sprout::tuples::get<1>(sprout::forward<T>(t)))
{
return sprout::tuples::get<1>(sprout::forward<T>(t));
}
} // namespace sprout
#endif // #ifndef SPROUT_UTILITY_PAIR_SECOND_HPP

93
sprout/utility/pair/tuple.hpp Normal file
View file

@ -0,0 +1,93 @@
#ifndef SPROUT_UTILITY_PAIR_TUPLE_HPP
#define SPROUT_UTILITY_PAIR_TUPLE_HPP
#include <cstddef>
#include <type_traits>
#include <sprout/config.hpp>
#include <sprout/utility/pair/pair.hpp>
#include <sprout/utility/move.hpp>
namespace sprout {
namespace tuples {
namespace detail {
template<std::size_t I, typename T>
struct tuple_element_impl;
template<typename T1, typename T2>
struct tuple_element_impl<0, sprout::pair<T1, T2> > {
public:
typedef T1 type;
};
template<typename T1, typename T2>
struct tuple_element_impl<1, sprout::pair<T1, T2> > {
public:
typedef T2 type;
};
template<std::size_t I, typename T>
struct get_impl;
template<typename T1, typename T2>
struct get_impl<0, sprout::pair<T1, T2> > {
public:
SPROUT_CONSTEXPR T1& operator()(sprout::pair<T1, T2>& t) const {
return t.first;
}
SPROUT_CONSTEXPR T1 const& operator()(sprout::pair<T1, T2> const& t) const {
return t.first;
}
};
template<typename T1, typename T2>
struct get_impl<1, sprout::pair<T1, T2> > {
public:
SPROUT_CONSTEXPR T2& operator()(sprout::pair<T1, T2>& t) const {
return t.second;
}
SPROUT_CONSTEXPR T2 const& operator()(sprout::pair<T1, T2> const& t) const {
return t.second;
}
};
} // namespace detail
} // namespace tuples
} // namespace sprout
namespace std {
//
// tuple_size
//
template<typename T1, typename T2>
struct tuple_size<sprout::pair<T1, T2> >
: public std::integral_constant<std::size_t, 2>
{};
//
// tuple_element
//
template<std::size_t I, typename T1, typename T2>
struct tuple_element<I, sprout::pair<T1, T2> >
: public sprout::tuples::detail::tuple_element_impl<I, sprout::pair<T1, T2> >
{};
} // namespace std
namespace sprout {
//
// tuple_get
//
template<std::size_t I, typename T1, typename T2>
inline SPROUT_CONSTEXPR typename sprout::tuples::tuple_element<I, sprout::pair<T1, T2> >::type&
tuple_get(sprout::pair<T1, T2>& t) SPROUT_NOEXCEPT {
static_assert(I < 2, "tuple_get: index out of range");
return sprout::tuples::detail::get_impl<I, sprout::pair<T1, T2> >()(t);
}
template<std::size_t I, typename T1, typename T2>
inline SPROUT_CONSTEXPR typename sprout::tuples::tuple_element<I, sprout::pair<T1, T2> >::type const&
tuple_get(sprout::pair<T1, T2> const& t) SPROUT_NOEXCEPT {
static_assert(I < 2, "tuple_get: index out of range");
return sprout::tuples::detail::get_impl<I, sprout::pair<T1, T2> >()(t);
}
template<std::size_t I, typename T1, typename T2>
inline SPROUT_CONSTEXPR typename sprout::tuples::tuple_element<I, sprout::pair<T1, T2> >::type&&
tuple_get(sprout::pair<T1, T2>&& t) SPROUT_NOEXCEPT {
return sprout::move(sprout::tuples::get<I>(t));
}
} // namespace sprout
#endif // #ifndef SPROUT_UTILITY_PAIR_TUPLE_HPP