rexy712/rexylib
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Merge remote-tracking branch 'refs/remotes/origin/master'

Browse Source
This commit is contained in:
rexy712 2022-06-11 08:47:50 -07:00
commit 35b64db13c
8 changed files with 87 additions and 106 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

9
include/rexy/allocator.hpp
View File

@ -38,6 +38,8 @@
#include "rexy.hpp"
#include "compat/standard.hpp"
#include <type_traits> //declval
namespace rexy{
template<class T>
@ -170,6 +172,13 @@ namespace rexy{
return false;
}
template<REXY_ALLOCATOR_CONCEPT T>
struct is_nothrow_allocator{
static constexpr bool value = noexcept(std::declval<T>().allocate(0)) && noexcept(std::declval<T>().deallocate(nullptr, 0));
};
template<REXY_ALLOCATOR_CONCEPT T>
static constexpr bool is_nothrow_allocator_v = is_nothrow_allocator<T>::value;
}
#endif

18
include/rexy/detail/hasallocator.hpp
View File

@ -31,17 +31,17 @@ namespace rexy::detail{
{
Alloc m_alloc;
REXY_CPP20_CONSTEXPR auto allocate(typename Alloc::size_type bytes)noexcept(noexcept(m_alloc.allocate(0))){
REXY_CPP20_CONSTEXPR auto allocate(typename Alloc::size_type bytes)noexcept(is_nothrow_allocator_v<Alloc>){
return m_alloc.allocate(bytes);
}
REXY_CPP20_CONSTEXPR void deallocate(typename Alloc::pointer p, typename Alloc::size_type bytes)noexcept(noexcept(m_alloc.deallocate(nullptr,0))){
REXY_CPP20_CONSTEXPR void deallocate(typename Alloc::pointer p, typename Alloc::size_type bytes)noexcept(is_nothrow_allocator_v<Alloc>){
m_alloc.deallocate(p, bytes);
}
Alloc& allocator(void){
constexpr Alloc& allocator(void){
return m_alloc;
}
const Alloc& allocator(void)const{
constexpr const Alloc& allocator(void)const{
return m_alloc;
}
};
@ -52,21 +52,21 @@ namespace rexy::detail{
[[no_unique_address]]
Alloc m_alloc;
REXY_CPP20_CONSTEXPR auto allocate(typename Alloc::size_type bytes)noexcept(noexcept(m_alloc.allocate(0))){
REXY_CPP20_CONSTEXPR auto allocate(typename Alloc::size_type bytes)noexcept(is_nothrow_allocator_v<Alloc>){
return m_alloc.allocate(bytes);
}
REXY_CPP20_CONSTEXPR void deallocate(typename Alloc::pointer p, typename Alloc::size_type bytes)noexcept(noexcept(m_alloc.deallocate(nullptr,0))){
REXY_CPP20_CONSTEXPR void deallocate(typename Alloc::pointer p, typename Alloc::size_type bytes)noexcept(is_nothrow_allocator_v<Alloc>){
m_alloc.deallocate(p, bytes);
}
Alloc& allocator(void){
constexpr Alloc& allocator(void){
return m_alloc;
}
const Alloc& allocator(void)const{
constexpr const Alloc& allocator(void)const{
return m_alloc;
}
};
#endif
#endif //no_unique_address
}
#endif

1
include/rexy/string.hpp
View File

@ -27,6 +27,7 @@ namespace rexy{
//new allocated string
using string = basic_string<char,allocator<char>>;
using wstring = basic_string<wchar_t,allocator<wchar_t>>;
#ifndef LIBREXY_HEADER_ONLY
extern template class basic_string<char,allocator<char>>;

61
include/rexy/string_base.hpp
View File

@ -33,6 +33,7 @@
#include "expression.hpp"
#include "detail/string_appender.hpp"
#include "detail/hasallocator.hpp"
#include "allocator.hpp"
#include "rexy.hpp"
#include "compat/standard.hpp"
@ -241,7 +242,7 @@ namespace rexy{
//Supplies all functions that string_base can't implement
template<class Char, REXY_ALLOCATOR_CONCEPT Alloc>
template<class Char, REXY_ALLOCATOR_CONCEPT Alloc = rexy::allocator<Char>>
class basic_string : protected detail::hasallocator<Alloc>, public string_base<Char>
{
public:
@ -260,74 +261,64 @@ namespace rexy{
private:
REXY_CPP20_CONSTEXPR void _copy_construct_string(const_pointer data, size_type len, size_type cap)
noexcept(noexcept(this->allocate(0)));
noexcept(is_nothrow_allocator_v<Alloc>);
REXY_CPP20_CONSTEXPR basic_string& _copy_string(const_pointer s, size_type len)
noexcept(noexcept(this->allocate(0)) &&
noexcept(this->deallocate(nullptr,0)));
noexcept(is_nothrow_allocator_v<Alloc>);
public:
constexpr basic_string(void)noexcept;
constexpr basic_string(rexy::steal<pointer> data, size_type len)noexcept;
constexpr basic_string(rexy::steal<pointer> data, size_type len, size_type cap)noexcept;
constexpr basic_string(rexy::steal<pointer> data)noexcept;
REXY_CPP20_CONSTEXPR basic_string(const_pointer data, size_type len)noexcept(noexcept(this->allocate(0)));
REXY_CPP20_CONSTEXPR basic_string(const_pointer data, size_type len, size_type cap)noexcept(noexcept(this->allocate(0)));
REXY_CPP20_CONSTEXPR basic_string(const_pointer data)noexcept(noexcept(this->allocate(0)));
REXY_CPP20_CONSTEXPR explicit basic_string(size_type len)noexcept(noexcept(this->allocate(0)));
REXY_CPP20_CONSTEXPR basic_string(size_type len, size_type cap)noexcept(noexcept(this->allocate(0)));
REXY_CPP20_CONSTEXPR basic_string(const_pointer data, size_type len)noexcept(is_nothrow_allocator_v<Alloc>);
REXY_CPP20_CONSTEXPR basic_string(const_pointer data, size_type len, size_type cap)noexcept(is_nothrow_allocator_v<Alloc>);
REXY_CPP20_CONSTEXPR basic_string(const_pointer data)noexcept(is_nothrow_allocator_v<Alloc>);
REXY_CPP20_CONSTEXPR explicit basic_string(size_type len)noexcept(is_nothrow_allocator_v<Alloc>);
REXY_CPP20_CONSTEXPR basic_string(size_type len, size_type cap)noexcept(is_nothrow_allocator_v<Alloc>);
template<class InputIt>
REXY_CPP20_CONSTEXPR basic_string(InputIt start, InputIt fin)noexcept(noexcept(this->allocate(0)));
REXY_CPP20_CONSTEXPR basic_string(const basic_string_view<Char>& sv)noexcept(noexcept(this->allocate(0)));
REXY_CPP20_CONSTEXPR basic_string(InputIt start, InputIt fin)noexcept(is_nothrow_allocator_v<Alloc>);
REXY_CPP20_CONSTEXPR basic_string(const basic_string_view<Char>& sv)noexcept(is_nothrow_allocator_v<Alloc>);
//normal copy and move ctors
REXY_CPP20_CONSTEXPR basic_string(const basic_string& b)noexcept(noexcept(this->allocate(0)));
REXY_CPP20_CONSTEXPR basic_string(const basic_string& b)noexcept(is_nothrow_allocator_v<Alloc>);
constexpr basic_string(basic_string&& s)noexcept;
REXY_CPP20_CONSTEXPR basic_string(const string_base<Char>&)noexcept(noexcept(this->allocate(0)));
REXY_CPP20_CONSTEXPR basic_string(const string_base<Char>&)noexcept(is_nothrow_allocator_v<Alloc>);
//dtor
REXY_CPP20_CONSTEXPR ~basic_string(void)noexcept(noexcept(this->deallocate(nullptr, 0)));
REXY_CPP20_CONSTEXPR ~basic_string(void)noexcept(is_nothrow_allocator_v<Alloc>);
REXY_CPP20_CONSTEXPR basic_string& operator=(const basic_string& s)
noexcept(noexcept(this->allocate(0)) &&
noexcept(this->deallocate(nullptr,0)));
noexcept(is_nothrow_allocator_v<Alloc>);
constexpr basic_string& operator=(basic_string&& s)noexcept;
REXY_CPP20_CONSTEXPR basic_string& operator=(const string_base<Char>& s)
noexcept(noexcept(this->allocate(0)) &&
noexcept(this->deallocate(nullptr,0)));
noexcept(is_nothrow_allocator_v<Alloc>);
REXY_CPP20_CONSTEXPR basic_string& operator=(const basic_string_view<Char>& sv)
noexcept(noexcept(this->allocate(0)) &&
noexcept(this->deallocate(nullptr,0)));
noexcept(is_nothrow_allocator_v<Alloc>);
//Copy from c string
REXY_CPP20_CONSTEXPR basic_string& operator=(const_pointer c)
noexcept(noexcept(this->allocate(0)) &&
noexcept(this->deallocate(nullptr,0)));
noexcept(is_nothrow_allocator_v<Alloc>);
//Replace managed pointer. Frees existing value
REXY_CPP20_CONSTEXPR void reset(pointer val = nullptr)noexcept(noexcept(this->deallocate(nullptr,0)));
REXY_CPP20_CONSTEXPR void reset(pointer val, size_type len)noexcept(noexcept(this->deallocate(nullptr,0)));
REXY_CPP20_CONSTEXPR void reset(pointer val = nullptr)noexcept(is_nothrow_allocator_v<Alloc>);
REXY_CPP20_CONSTEXPR void reset(pointer val, size_type len)noexcept(is_nothrow_allocator_v<Alloc>);
REXY_CPP20_CONSTEXPR bool resize(size_type newsize)
noexcept(noexcept(this->allocate(0)) &&
noexcept(this->deallocate(nullptr,0)));
noexcept(is_nothrow_allocator_v<Alloc>);
REXY_CPP20_CONSTEXPR void push_back(value_type data)
noexcept(noexcept(this->allocate(0)) &&
noexcept(this->deallocate(nullptr,0)));
noexcept(is_nothrow_allocator_v<Alloc>);
REXY_CPP20_CONSTEXPR void append(const_pointer data, size_type len)
noexcept(noexcept(this->allocate(0)) &&
noexcept(this->deallocate(nullptr,0)));
noexcept(is_nothrow_allocator_v<Alloc>);
REXY_CPP20_CONSTEXPR void append(const_pointer data)
noexcept(noexcept(this->allocate(0)) &&
noexcept(this->deallocate(nullptr,0)));
noexcept(is_nothrow_allocator_v<Alloc>);
template<class InputIt>
REXY_CPP20_CONSTEXPR void append(InputIt start, InputIt fin)
noexcept(noexcept(this->allocate(0)) &&
noexcept(this->deallocate(nullptr,0)));
noexcept(is_nothrow_allocator_v<Alloc>);
template<REXY_ALLOCATOR_CONCEPT A = allocator_type>
REXY_CPP20_CONSTEXPR basic_string<value_type,A> substring(size_type start, size_type end)const;
REXY_CPP20_CONSTEXPR pointer release(void)noexcept(noexcept(this->allocate(0)));
REXY_CPP20_CONSTEXPR pointer release(void)noexcept(is_nothrow_allocator_v<Alloc>);
using detail::hasallocator<Alloc>::allocator;
constexpr basic_string_view<value_type> create_view(void)const noexcept;

58
include/rexy/string_base.tpp
View File

@ -82,7 +82,7 @@ namespace rexy{
//allocate string if longer than small string capacity, copy otherwise
template<class Char, REXY_ALLOCATOR_CONCEPT Alloc>
REXY_CPP20_CONSTEXPR void basic_string<Char,Alloc>::_copy_construct_string(const_pointer data, size_type len, size_type cap)
noexcept(noexcept(this->allocate(0)))
noexcept(is_nothrow_allocator_v<Alloc>)
{
if(cap > this->get_short_capacity()){
this->set_islong_flag(true);
@ -116,31 +116,31 @@ namespace rexy{
string_base<Char>(data.value(), len, cap){}
template<class Char, REXY_ALLOCATOR_CONCEPT Alloc>
REXY_CPP20_CONSTEXPR basic_string<Char,Alloc>::basic_string(const_pointer data, size_type len, size_type cap)
noexcept(noexcept(this->allocate(0)))
noexcept(is_nothrow_allocator_v<Alloc>)
{
_copy_construct_string(data, len, cap);
}
template<class Char, REXY_ALLOCATOR_CONCEPT Alloc>
REXY_CPP20_CONSTEXPR basic_string<Char,Alloc>::basic_string(const_pointer data, size_type len)
noexcept(noexcept(this->allocate(0))):
noexcept(is_nothrow_allocator_v<Alloc>):
basic_string(data, len, len){}
template<class Char, REXY_ALLOCATOR_CONCEPT Alloc>
REXY_CPP20_CONSTEXPR basic_string<Char,Alloc>::basic_string(const_pointer data)
noexcept(noexcept(this->allocate(0))):
noexcept(is_nothrow_allocator_v<Alloc>):
basic_string(data, data ? strlen(data) : 0){}
template<class Char, REXY_ALLOCATOR_CONCEPT Alloc>
REXY_CPP20_CONSTEXPR basic_string<Char,Alloc>::basic_string(size_type cap)
noexcept(noexcept(this->allocate(0))):
noexcept(is_nothrow_allocator_v<Alloc>):
basic_string(size_type{0}, cap){}
template<class Char, REXY_ALLOCATOR_CONCEPT Alloc>
REXY_CPP20_CONSTEXPR basic_string<Char,Alloc>::basic_string(size_type len, size_type cap)
noexcept(noexcept(this->allocate(0)))
noexcept(is_nothrow_allocator_v<Alloc>)
{
_copy_construct_string(nullptr, len, cap);
}
template<class Char, REXY_ALLOCATOR_CONCEPT Alloc>
REXY_CPP20_CONSTEXPR basic_string<Char,Alloc>::basic_string(const basic_string_view<Char>& sv)
noexcept(noexcept(this->allocate(0)))
noexcept(is_nothrow_allocator_v<Alloc>)
{
_copy_construct_string(sv.c_str(), sv.length(), sv.length());
}
@ -148,7 +148,7 @@ namespace rexy{
template<class Char, REXY_ALLOCATOR_CONCEPT Alloc>
template<class InputIt>
REXY_CPP20_CONSTEXPR basic_string<Char,Alloc>::basic_string(InputIt start, InputIt fin)
noexcept(noexcept(this->allocate(0))):
noexcept(is_nothrow_allocator_v<Alloc>):
basic_string(nullptr, size_type{fin - start})
{
auto raw = this->get_pointer();
@ -161,7 +161,7 @@ namespace rexy{
//normal copy and move ctors
template<class Char, REXY_ALLOCATOR_CONCEPT Alloc>
REXY_CPP20_CONSTEXPR basic_string<Char,Alloc>::basic_string(const basic_string& b)
noexcept(noexcept(this->allocate(0))):
noexcept(is_nothrow_allocator_v<Alloc>):
detail::hasallocator<Alloc>(b)
{
_copy_construct_string(b.get(), b.length(), b.capacity());
@ -172,7 +172,7 @@ namespace rexy{
string_base<Char>(std::move(s)){}
template<class Char, REXY_ALLOCATOR_CONCEPT Alloc>
REXY_CPP20_CONSTEXPR basic_string<Char,Alloc>::basic_string(const string_base<Char>& b)
noexcept(noexcept(this->allocate(0)))
noexcept(is_nothrow_allocator_v<Alloc>)
{
_copy_construct_string(b.get(), b.length(), b.capacity());
}
@ -180,7 +180,7 @@ namespace rexy{
//dtor
template<class Char, REXY_ALLOCATOR_CONCEPT Alloc>
REXY_CPP20_CONSTEXPR basic_string<Char,Alloc>::~basic_string(void)
noexcept(noexcept(this->deallocate(nullptr, 0)))
noexcept(is_nothrow_allocator_v<Alloc>)
{
if(this->islong()){
this->deallocate(this->get_pointer(), sizeof(value_type)*(this->get_long_capacity()+1));
@ -189,8 +189,7 @@ namespace rexy{
template<class Char, REXY_ALLOCATOR_CONCEPT Alloc>
REXY_CPP20_CONSTEXPR basic_string<Char,Alloc>& basic_string<Char,Alloc>::operator=(const basic_string& s)
noexcept(noexcept(this->allocate(0)) &&
noexcept(this->deallocate(nullptr, 0)))
noexcept(is_nothrow_allocator_v<Alloc>)
{
if(s.length() < this->capacity()){
memcpy(this->get_pointer(), s.get_pointer(), sizeof(value_type)*(s.length()+1));
@ -207,24 +206,21 @@ namespace rexy{
}
template<class Char, REXY_ALLOCATOR_CONCEPT Alloc>
REXY_CPP20_CONSTEXPR basic_string<Char,Alloc>& basic_string<Char,Alloc>::operator=(const string_base<Char>& s)
noexcept(noexcept(this->allocate(0)) &&
noexcept(this->deallocate(nullptr,0)))
noexcept(is_nothrow_allocator_v<Alloc>)
{
return (*this = basic_string(s));
}
//Copy from c string
template<class Char, REXY_ALLOCATOR_CONCEPT Alloc>
REXY_CPP20_CONSTEXPR basic_string<Char,Alloc>& basic_string<Char,Alloc>::operator=(const basic_string_view<Char>& sv)
noexcept(noexcept(this->allocate(0)) &&
noexcept(this->deallocate(nullptr,0)))
noexcept(is_nothrow_allocator_v<Alloc>)
{
return _copy_string(sv.c_str(), sv.length());
}
template<class Char, REXY_ALLOCATOR_CONCEPT Alloc>
REXY_CPP20_CONSTEXPR basic_string<Char,Alloc>& basic_string<Char,Alloc>::operator=(const_pointer c)
noexcept(noexcept(this->allocate(0)) &&
noexcept(this->deallocate(nullptr,0)))
noexcept(is_nothrow_allocator_v<Alloc>)
{
return _copy_string(c, strlen(c));
}
@ -232,13 +228,13 @@ namespace rexy{
//Replace managed pointer. Frees existing value
template<class Char, REXY_ALLOCATOR_CONCEPT Alloc>
REXY_CPP20_CONSTEXPR void basic_string<Char,Alloc>::reset(pointer val)
noexcept(noexcept(this->deallocate(nullptr,0)))
noexcept(is_nothrow_allocator_v<Alloc>)
{
reset(val, val ? strlen(val) : 0);
}
template<class Char, REXY_ALLOCATOR_CONCEPT Alloc>
REXY_CPP20_CONSTEXPR void basic_string<Char,Alloc>::reset(pointer val, size_type len)
noexcept(noexcept(this->deallocate(nullptr,0)))
noexcept(is_nothrow_allocator_v<Alloc>)
{
if(this->islong())
this->deallocate(this->get_long_ptr(),sizeof(value_type)*(this->get_long_capacity()+1));
@ -249,8 +245,7 @@ namespace rexy{
}
template<class Char, REXY_ALLOCATOR_CONCEPT Alloc>
REXY_CPP20_CONSTEXPR bool basic_string<Char,Alloc>::resize(size_type newsize)
noexcept(noexcept(this->allocate(0)) &&
noexcept(this->deallocate(nullptr,0)))
noexcept(is_nothrow_allocator_v<Alloc>)
{
if(newsize < this->capacity())
return false;
@ -261,16 +256,14 @@ namespace rexy{
template<class Char, REXY_ALLOCATOR_CONCEPT Alloc>
REXY_CPP20_CONSTEXPR void basic_string<Char,Alloc>::push_back(value_type data)
noexcept(noexcept(this->allocate(0)) &&
noexcept(this->deallocate(nullptr,0)))
noexcept(is_nothrow_allocator_v<Alloc>)
{
append(&data, 1);
}
template<class Char, REXY_ALLOCATOR_CONCEPT Alloc>
REXY_CPP20_CONSTEXPR void basic_string<Char,Alloc>::append(const_pointer data, size_type len)
noexcept(noexcept(this->allocate(0)) &&
noexcept(this->deallocate(nullptr,0)))
noexcept(is_nothrow_allocator_v<Alloc>)
{
size_type mylen = this->length();
size_type mycap = this->capacity();
@ -290,8 +283,7 @@ namespace rexy{
}
template<class Char, REXY_ALLOCATOR_CONCEPT Alloc>
REXY_CPP20_CONSTEXPR void basic_string<Char,Alloc>::append(const_pointer data)
noexcept(noexcept(this->allocate(0)) &&
noexcept(this->deallocate(nullptr,0)))
noexcept(is_nothrow_allocator_v<Alloc>)
{
if(data)
append(data, strlen(data));
@ -299,8 +291,7 @@ namespace rexy{
template<class Char, REXY_ALLOCATOR_CONCEPT Alloc>
template<class InputIt>
REXY_CPP20_CONSTEXPR void basic_string<Char,Alloc>::append(InputIt start, InputIt fin)
noexcept(noexcept(this->allocate(0)) &&
noexcept(this->deallocate(nullptr,0)))
noexcept(is_nothrow_allocator_v<Alloc>)
{
size_type append_len = fin - start;
@ -334,7 +325,7 @@ namespace rexy{
return tmp;
}
template<class Char, REXY_ALLOCATOR_CONCEPT Alloc>
REXY_CPP20_CONSTEXPR auto basic_string<Char,Alloc>::release(void)noexcept(noexcept(this->allocate(0))) -> pointer{
REXY_CPP20_CONSTEXPR auto basic_string<Char,Alloc>::release(void)noexcept(is_nothrow_allocator_v<Alloc>) -> pointer{
if(this->islong()){
pointer raw = this->get_long_ptr();
this->set_islong_flag(false);
@ -363,8 +354,7 @@ namespace rexy{
template<class Char, REXY_ALLOCATOR_CONCEPT Alloc>
REXY_CPP20_CONSTEXPR basic_string<Char,Alloc>& basic_string<Char,Alloc>::_copy_string(const_pointer s, size_type len)
noexcept(noexcept(this->allocate(0)) &&
noexcept(this->deallocate(nullptr,0)))
noexcept(is_nothrow_allocator_v<Alloc>)
{
if(!s || !len)
return (*this = basic_string(rexy::steal<pointer>(nullptr), 0, 0));

20
include/rexy/string_view.hpp
View File

@ -41,7 +41,7 @@ namespace rexy{
using const_pointer = const value_type*;
using reference = value_type&;
using const_reference = const value_type&;
using iterator = pointer;
using iterator = const_pointer;
using const_iterator = const_pointer;
using reverse_iterator = std::reverse_iterator<iterator>;
using const_reverse_iterator = std::reverse_iterator<const_iterator>;
@ -53,31 +53,38 @@ namespace rexy{
size_type m_length = 0;
public:
constexpr basic_string_view(void)noexcept;
constexpr basic_string_view(void)noexcept = default;
constexpr basic_string_view(const_pointer str, size_type len)noexcept;
constexpr basic_string_view(const_pointer c)noexcept;
constexpr basic_string_view(const basic_string_view& s)noexcept;
constexpr basic_string_view(const basic_string_view& s)noexcept = default;
constexpr basic_string_view(const string_base<Char>& s)noexcept;
constexpr basic_string_view(basic_string_view&& s)noexcept;
constexpr basic_string_view(basic_string_view&& s)noexcept = default;
template<class InIter>
constexpr basic_string_view(InIter start, InIter fin)noexcept;
REXY_CPP20_CONSTEXPR ~basic_string_view(void)noexcept = default;
constexpr basic_string_view& operator=(const_pointer c)noexcept;
constexpr basic_string_view& operator=(const basic_string_view& s)noexcept;
constexpr basic_string_view& operator=(basic_string_view&&)noexcept;
constexpr basic_string_view& operator=(const basic_string_view& s)noexcept = default;
constexpr basic_string_view& operator=(basic_string_view&&)noexcept = default;
//Length of string not including null terminator
constexpr size_type length(void)const noexcept{return m_length;}
constexpr size_type size(void)const noexcept{return m_length;}
constexpr bool empty(void)const noexcept{return m_length == 0;}
//direct access to managed pointer
constexpr const_pointer c_str(void)const noexcept{return m_data;}
constexpr const_pointer data(void)const noexcept{return m_data;}
constexpr const_pointer get(void)const noexcept{return m_data;}
constexpr operator const_pointer(void)const noexcept{return m_data;}
//true if m_data is not empty
constexpr bool valid(void)const noexcept{return m_length > 0;}
constexpr const_reference operator[](size_type i)const noexcept{return m_data[i];}
constexpr const_reference at(size_type i)const noexcept{return m_data[i];}
constexpr const_reference front(size_type i)const noexcept{return m_data[0];}
constexpr const_reference back(size_type i)const noexcept{return m_data[m_length-1];}
constexpr const_iterator it_at(size_type i)const noexcept{return m_data + i;}
constexpr const_iterator search(const basic_string_view& s)const;
constexpr const_iterator search(const_pointer c)const;
@ -115,6 +122,7 @@ namespace rexy{
basic_string_view(const T*, size_t) -> basic_string_view<T>;
using string_view = basic_string_view<char>;
using wstring_view = basic_string_view<wchar_t>;
#ifndef LIBREXY_HEADER_ONLY
extern template class basic_string_view<char>;

22
include/rexy/string_view.tpp
View File

@ -25,33 +25,17 @@
namespace rexy{
template<class Char>
constexpr basic_string_view<Char>::basic_string_view(void)noexcept:
basic_string_view(nullptr, 0){}
template<class Char>
constexpr basic_string_view<Char>::basic_string_view(const_pointer str, size_type len)noexcept:
m_data(str), m_length(len){}
template<class Char>
constexpr basic_string_view<Char>::basic_string_view(const basic_string_view& s)noexcept:
m_data(s.m_data), m_length(s.m_length){}
template<class Char>
constexpr basic_string_view<Char>::basic_string_view(const string_base<Char>& s)noexcept:
m_data(s.c_str()), m_length(s.length()){}
template<class Char>
constexpr basic_string_view<Char>::basic_string_view(basic_string_view&& s)noexcept:
m_data(s.m_data), m_length(s.m_length){}
template<class Char>
template<class InIter>
constexpr basic_string_view<Char>::basic_string_view(InIter start, InIter fin)noexcept:
basic_string_view(compat::to_address(start), fin - start){}
template<class Char>
constexpr basic_string_view<Char>& basic_string_view<Char>::operator=(const basic_string_view& s)noexcept{
m_data = s.m_data;
m_length = s.m_length;
return *this;
}
template<class Char>
constexpr basic_string_view<Char>::basic_string_view(const_pointer c)noexcept:
basic_string_view(c, strlen(c)){}
@ -61,12 +45,6 @@ namespace rexy{
m_length = strlen(c);
return *this;
}
template<class Char>
constexpr basic_string_view<Char>& basic_string_view<Char>::operator=(basic_string_view&& s)noexcept{
m_data = s.m_data;
m_length = s.m_length;
return *this;
}
template<class Char>
constexpr auto basic_string_view<Char>::search(const basic_string_view& s)const -> const_iterator{

4
include/rexy/utility.hpp
View File

@ -145,6 +145,10 @@ namespace rexy{
ld[i] = rd[i];
}
}
template<class T>
constexpr T abs(const T& val){
return val > 0 ? val : -val;
}
}
#endif //__cpp_lib_is_constant_evaluated