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

Generisize string types

Browse Source
This commit is contained in:
rexy712 2020-08-01 01:28:29 -07:00
parent 55c908686f
commit f7b0822dd2
11 changed files with 260 additions and 164 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
include/rexy/cx/static_string_hash.hpp
View File

@ -24,8 +24,8 @@
namespace rexy::cx{ namespace rexy::cx{
template<> template<class Char>
struct hash<rexy::static_string> : public string_hash<rexy::static_string>{}; struct hash<rexy::static_string<Char>> : public string_hash<rexy::static_string<Char>>{};
} }

8
include/rexy/cx/string.hpp
View File

@ -69,7 +69,7 @@ namespace rexy::cx{
} }
} }
constexpr string(const rexy::static_string& str)noexcept: constexpr string(const rexy::static_string<char>& str)noexcept:
m_length(str.length()) m_length(str.length())
{ {
for(size_t i = 0;i < m_length;++i){ for(size_t i = 0;i < m_length;++i){
@ -153,7 +153,7 @@ namespace rexy::cx{
constexpr void append(const string& s)noexcept{ constexpr void append(const string& s)noexcept{
append(s.get(), s.length()); append(s.get(), s.length());
} }
constexpr void append(const rexy::static_string& s)noexcept{ constexpr void append(const rexy::static_string<char>& s)noexcept{
append(s.get(), s.length()); append(s.get(), s.length());
} }
}; };
@ -179,11 +179,11 @@ namespace rexy::cx{
} }
template<class Str1, std::enable_if_t<detail::is_cx_string<Str1>::value,int> = 0> template<class Str1, std::enable_if_t<detail::is_cx_string<Str1>::value,int> = 0>
constexpr auto operator+(Str1&& l, const char* r)noexcept{ constexpr auto operator+(Str1&& l, const char* r)noexcept{
return string_cat_expr(std::forward<Str1>(l), rexy::static_string(r)); return string_cat_expr(std::forward<Str1>(l), rexy::static_string<char>(r));
} }
template<class Str1, std::enable_if_t<detail::is_cx_string<Str1>::value,int> = 0> template<class Str1, std::enable_if_t<detail::is_cx_string<Str1>::value,int> = 0>
constexpr auto operator+(const char* l, Str1&& r)noexcept{ constexpr auto operator+(const char* l, Str1&& r)noexcept{
return string_cat_expr(rexy::static_string(l), std::forward<Str1>(r)); return string_cat_expr(rexy::static_string<char>(l), std::forward<Str1>(r));
} }
} }

15
include/rexy/cx/utility.hpp
View File

@ -85,6 +85,21 @@ namespace rexy::cx{
for(;c[i];++i); for(;c[i];++i);
return i; return i;
} }
constexpr size_t strlen(const wchar_t* c)noexcept{
size_t i = 0;
for(;c[i];++i);
return i;
}
constexpr size_t strlen(const char16_t* c)noexcept{
size_t i = 0;
for(;c[i];++i);
return i;
}
constexpr size_t strlen(const char32_t* c)noexcept{
size_t i = 0;
for(;c[i];++i);
return i;
}
constexpr int strcmp(const char* l, const char* r)noexcept{ constexpr int strcmp(const char* l, const char* r)noexcept{
using uchar = unsigned char; using uchar = unsigned char;
for(;*l == *r && *l;++l, ++r); for(;*l == *r && *l;++l, ++r);

4
include/rexy/detail/binary_string_conv.hpp
View File

@ -37,7 +37,7 @@ namespace rexy{
return Str(rexy::steal(b.release()), b.size()); return Str(rexy::steal(b.release()), b.size());
} }
template<class Bin, detail::enable_if_binary<Bin> = 0> template<class Bin, detail::enable_if_binary<Bin> = 0>
auto string_to_binary(const string_base& s) auto string_to_binary(const string_base<char>& s)
noexcept(std::is_nothrow_constructible<Bin, decltype(s.length())>::value && noexcept(std::is_nothrow_constructible<Bin, decltype(s.length())>::value &&
noexcept(std::decay_t<Bin>::allocator_type::allocate(0))) noexcept(std::decay_t<Bin>::allocator_type::allocate(0)))
{ {
@ -46,7 +46,7 @@ namespace rexy{
return b; return b;
} }
template<class Al, class Bin, detail::enable_if_binary<Bin> = 0, std::enable_if_t<std::is_same<std::decay_t<Al>,typename Bin::allocator_type>::value,int> = 0> template<class Al, class Bin, detail::enable_if_binary<Bin> = 0, std::enable_if_t<std::is_same<std::decay_t<Al>,typename Bin::allocator_type>::value,int> = 0>
auto string_to_binary(basic_string<Al>&& s)noexcept{ auto string_to_binary(basic_string<char,Al>&& s)noexcept{
return Bin(rexy::steal(s.release()), s.length()); return Bin(rexy::steal(s.release()), s.length());
} }

16
include/rexy/detail/default_allocator.hpp
View File

@ -22,6 +22,7 @@
#include <cstdlib> //size_t #include <cstdlib> //size_t
#include <type_traits> //true_type, false_type #include <type_traits> //true_type, false_type
#include <new> #include <new>
#include <limits> //numeric_limits
namespace rexy{ namespace rexy{
@ -61,7 +62,7 @@ namespace rexy{
~default_allocator(void) = default; ~default_allocator(void) = default;
pointer allocate(size_type n){ pointer allocate(size_type n){
size_type bytes = has_overflow(n) ? size_type{-1} : n*sizeof(T); size_type bytes = has_overflow(n) ? std::numeric_limits<size_type>::max() : n*sizeof(T);
if constexpr(alignof(T) <= __STDCPP_DEFAULT_NEW_ALIGNMENT__){ if constexpr(alignof(T) <= __STDCPP_DEFAULT_NEW_ALIGNMENT__){
return reinterpret_cast<pointer>(::operator new(bytes)); return reinterpret_cast<pointer>(::operator new(bytes));
}else{ }else{
@ -69,15 +70,24 @@ namespace rexy{
} }
} }
void deallocate(pointer p, size_type n){ void deallocate(pointer p, size_type n){
size_type bytes = has_overflow(n) ? size_type{-1} : n*sizeof(T); #if defined(__clang__) && !defined(__cpp_sized_deallocation)
//clang does not enable ::operator delete(void* ptr, std::size_t sz) by default for some reason
if constexpr(alignof(T) <= __STDCPP_DEFAULT_NEW_ALIGNMENT__){
::operator delete(p);
}else{
::operator delete(p, static_cast<std::align_val_t>(alignof(T)));
}
#else
size_type bytes = has_overflow(n) ? std::numeric_limits<size_type>::max() : n*sizeof(T);
if constexpr(alignof(T) <= __STDCPP_DEFAULT_NEW_ALIGNMENT__){ if constexpr(alignof(T) <= __STDCPP_DEFAULT_NEW_ALIGNMENT__){
::operator delete(p, bytes); ::operator delete(p, bytes);
}else{ }else{
::operator delete(p, bytes, static_cast<std::align_val_t>(alignof(T))); ::operator delete(p, bytes, static_cast<std::align_val_t>(alignof(T)));
} }
#endif
} }
constexpr size_type max_size(void)const{ constexpr size_type max_size(void)const{
return size_type{-1}/sizeof(T); return std::numeric_limits<size_type>::max()/sizeof(T);
} }
}; };
template<class T, class U> template<class T, class U>

2
include/rexy/filerd.hpp
View File

@ -66,7 +66,7 @@ namespace rexy{
rexy::binary read_bin(size_t bytes)noexcept(std::is_nothrow_constructible<rexy::binary, rexy::steal<char*>, size_t, size_t>::value); rexy::binary read_bin(size_t bytes)noexcept(std::is_nothrow_constructible<rexy::binary, rexy::steal<char*>, size_t, size_t>::value);
size_t write(const char* c, size_t bytes)noexcept; size_t write(const char* c, size_t bytes)noexcept;
size_t write(const rexy::string_base&)noexcept; size_t write(const rexy::string_base<char>& s)noexcept;
}; };
} }

4
include/rexy/string.hpp
View File

@ -25,9 +25,9 @@
namespace rexy{ namespace rexy{
//new allocated string //new allocated string
using string = basic_string<detail::default_allocator<char>>; using string = basic_string<char,detail::default_allocator<char>>;
extern template class basic_string<detail::default_allocator<char>>; extern template class basic_string<char,detail::default_allocator<char>>;
} }

169
include/rexy/string_base.hpp
View File

@ -21,7 +21,7 @@
#include <type_traits> //is_same, integral_contant, enable_if, etc #include <type_traits> //is_same, integral_contant, enable_if, etc
#include <utility> //forward #include <utility> //forward
#include <cstdlib> //size_t #include <cstddef> //size_t,ptrdiff
#include <cstring> //strlen #include <cstring> //strlen
#include "steal.hpp" #include "steal.hpp"
@ -34,21 +34,33 @@
namespace rexy{ namespace rexy{
//Base of all RAII strings. Its use is allowing passing of rexy strings to functions without knowing the exact type //Base of all RAII strings. Its use is allowing passing of rexy strings to functions without knowing the exact type
template<class Char>
class string_base class string_base
{ {
public:
using value_type = Char;
using size_type = size_t;
using difference_type = ptrdiff_t;
using pointer = value_type*;
using const_pointer = const value_type*;
using reference = value_type&;
using const_reference = const value_type&;
using iterator = pointer;
using const_iterator = const_pointer;
protected: protected:
size_t m_length = 0; //length of string not including null terminator size_type m_length = 0; //length of string not including null terminator
size_t m_cap = 0; //size of current buffer not including null terminator size_type m_cap = 0; //size of current buffer not including null terminator
char* m_data = nullptr; pointer m_data = nullptr;
protected: protected:
constexpr string_base(void)noexcept = default; constexpr string_base(void)noexcept = default;
constexpr string_base(size_t len)noexcept: constexpr string_base(size_type len)noexcept:
m_cap(len){} m_cap(len){}
//Initialize without copying //Initialize without copying
constexpr string_base(char* data, size_t len)noexcept: constexpr string_base(pointer data, size_type len)noexcept:
m_cap(len), m_data(data){} m_cap(len), m_data(data){}
constexpr string_base(char* data, size_t len, size_t cap)noexcept: constexpr string_base(pointer data, size_type len, size_type cap)noexcept:
m_length(len), m_cap(cap), m_data(data){} m_length(len), m_cap(cap), m_data(data){}
//Copy ctor (do nothing) //Copy ctor (do nothing)
constexpr string_base(const string_base&)noexcept{} constexpr string_base(const string_base&)noexcept{}
@ -56,53 +68,68 @@ namespace rexy{
public: public:
//Stop managing stored pointer. Does not free. //Stop managing stored pointer. Does not free.
constexpr char* release(void)noexcept{return cx::exchange(m_data, nullptr);} constexpr pointer release(void)noexcept{return cx::exchange(m_data, nullptr);}
//Length of string not including null terminator //Length of string not including null terminator
constexpr size_t length(void)const noexcept{return m_length;} constexpr size_type length(void)const noexcept{return m_length;}
constexpr size_t capacity(void)const noexcept{return m_cap;} constexpr size_type capacity(void)const noexcept{return m_cap;}
//direct access to managed pointer //direct access to managed pointer
constexpr char* c_str(void)noexcept{return m_data;} constexpr pointer c_str(void)noexcept{return m_data;}
constexpr const char* c_str(void)const noexcept{return m_data;} constexpr const_pointer c_str(void)const noexcept{return m_data;}
constexpr char* get(void)noexcept{return m_data;} constexpr pointer get(void)noexcept{return m_data;}
constexpr const char* get(void)const noexcept{return m_data;} constexpr const_pointer get(void)const noexcept{return m_data;}
constexpr operator char*(void)noexcept{return m_data;} constexpr operator pointer(void)noexcept{return m_data;}
constexpr operator const char*(void)const noexcept{return m_data;} constexpr operator const_pointer(void)const noexcept{return m_data;}
//true if m_data is not null //true if m_data is not null
constexpr bool valid(void)const noexcept{return m_data;} constexpr bool valid(void)const noexcept{return m_data;}
constexpr char& operator[](size_t i)noexcept{return m_data[i];} constexpr reference operator[](size_type i)noexcept{return m_data[i];}
constexpr const char& operator[](size_t i)const noexcept{return m_data[i];} constexpr const_reference operator[](size_type i)const noexcept{return m_data[i];}
}; };
//Supplies all functions that string_base can't implement //Supplies all functions that string_base can't implement
template<class Allocator> template<class Char, class Allocator>
class basic_string : protected detail::hasallocator<Allocator>, public string_base class basic_string : protected detail::hasallocator<Allocator>, public string_base<Char>
{ {
public: public:
using value_type = typename string_base<Char>::value_type;
using size_type = typename string_base<Char>::size_type;
using difference_type = typename string_base<Char>::difference_type;
using pointer = typename string_base<Char>::pointer;
using const_pointer = typename string_base<Char>::const_pointer;
using reference = typename string_base<Char>::reference;
using const_reference = typename string_base<Char>::const_reference;
using iterator = typename string_base<Char>::iterator;
using const_iterator = typename string_base<Char>::const_iterator;
using allocator_type = Allocator; using allocator_type = Allocator;
protected:
using string_base<Char>::m_data;
using string_base<Char>::m_length;
using string_base<Char>::m_cap;
private: private:
basic_string& _copy_string(const char* s, size_t len) basic_string& _copy_string(const_pointer s, size_type len)
noexcept(noexcept(this->allocate(0)) && noexcept(noexcept(this->allocate(0)) &&
noexcept(this->deallocate(nullptr,0))); noexcept(this->deallocate(nullptr,0)));
public: public:
constexpr basic_string(void)noexcept; constexpr basic_string(void)noexcept;
constexpr basic_string(rexy::steal<char*> data, size_t len)noexcept; constexpr basic_string(rexy::steal<pointer> data, size_type len)noexcept;
constexpr basic_string(rexy::steal<char*> data, size_t len, size_t cap)noexcept; constexpr basic_string(rexy::steal<pointer> data, size_type len, size_type cap)noexcept;
constexpr basic_string(rexy::steal<char*> data)noexcept; constexpr basic_string(rexy::steal<pointer> data)noexcept;
basic_string(const char* data, size_t len)noexcept(noexcept(this->allocate(data,len))); basic_string(const_pointer data, size_type len)noexcept(noexcept(this->allocate(0)));
basic_string(const char* data)noexcept(noexcept(this->allocate(data, m_cap))); basic_string(const_pointer data)noexcept(noexcept(this->allocate(0)));
explicit basic_string(size_t len)noexcept(noexcept(this->allocate(len))); explicit basic_string(size_type len)noexcept(noexcept(this->allocate(0)));
basic_string(size_t len, size_t cap)noexcept(noexcept(this->allocate(len))); basic_string(size_type len, size_type cap)noexcept(noexcept(this->allocate(0)));
//normal copy and move ctors //normal copy and move ctors
basic_string(const basic_string& b)noexcept(noexcept(this->allocate(b.m_data, b.m_length))); basic_string(const basic_string& b)noexcept(noexcept(this->allocate(0)));
constexpr basic_string(basic_string&& s)noexcept(noexcept(cx::exchange(s.m_data, nullptr))); constexpr basic_string(basic_string&& s)noexcept(noexcept(cx::exchange(s.m_data, nullptr)));
basic_string(const string_base& b)noexcept(noexcept(this->allocate(b.get(), b.length()))); template<class C>
basic_string(const string_base<C>& b)noexcept(noexcept(this->allocate(0)));
//dtor //dtor
~basic_string(void)noexcept(noexcept(this->deallocate(nullptr, 0))); ~basic_string(void)noexcept(noexcept(this->deallocate(nullptr, 0)));
@ -113,28 +140,30 @@ namespace rexy{
constexpr basic_string& operator=(basic_string&& s)noexcept; constexpr basic_string& operator=(basic_string&& s)noexcept;
//Copy from c string //Copy from c string
basic_string& operator=(const char* c) basic_string& operator=(const_pointer c)
noexcept(noexcept(this->allocate(0)) && noexcept(noexcept(this->allocate(0)) &&
noexcept(this->deallocate(nullptr,0))); noexcept(this->deallocate(nullptr,0)));
//Copy from other string_base //Copy from other string_base
basic_string& operator=(const string_base& s) template<class C>
basic_string& operator=(const string_base<C>& s)
noexcept(noexcept(this->allocate(0)) && noexcept(noexcept(this->allocate(0)) &&
noexcept(this->deallocate(nullptr,0))); noexcept(this->deallocate(nullptr,0)));
//Replace managed pointer. Frees existing value //Replace managed pointer. Frees existing value
void reset(char* val = nullptr)noexcept(noexcept(this->deallocate(m_data))); void reset(pointer val = nullptr)noexcept(noexcept(this->deallocate(nullptr,0)));
void reset(char* val, size_t len)noexcept(noexcept(this->deallocate(m_data))); void reset(pointer val, size_type len)noexcept(noexcept(this->deallocate(nullptr,0)));
bool resize(size_t newsize) bool resize(size_type newsize)
noexcept(noexcept(this->allocate(0)) && noexcept(noexcept(this->allocate(0)) &&
noexcept(this->deallocate(nullptr,0))); noexcept(this->deallocate(nullptr,0)));
void append(const char* data, size_t len) void append(const_pointer data, size_type len)
noexcept(noexcept(this->allocate(0)) && noexcept(noexcept(this->allocate(0)) &&
noexcept(this->deallocate(nullptr,0))); noexcept(this->deallocate(nullptr,0)));
void append(const char* data) void append(const_pointer data)
noexcept(noexcept(this->allocate(0)) && noexcept(noexcept(this->allocate(0)) &&
noexcept(this->deallocate(nullptr,0))); noexcept(this->deallocate(nullptr,0)));
void append(const string_base& s) template<class C>
void append(const string_base<C>& s)
noexcept(noexcept(this->allocate(0)) && noexcept(noexcept(this->allocate(0)) &&
noexcept(this->deallocate(nullptr,0))); noexcept(this->deallocate(nullptr,0)));
@ -145,32 +174,64 @@ namespace rexy{
template<class Left, class Right> template<class Left, class Right>
class string_cat_expr : public rexy::binary_expression<Left,Right> class string_cat_expr : public rexy::binary_expression<Left,Right>
{ {
static_assert(std::is_same<typename std::decay_t<Left>::value_type,typename std::decay_t<Right>::value_type>::value);
private:
using left_t = std::decay_t<Left>;
using right_t = std::decay_t<Right>;
public:
using value_type = typename left_t::value_type;
using size_type = decltype(typename left_t::size_type{0} + typename right_t::size_type{0});
using difference_type = decltype(typename left_t::difference_type{0} - typename right_t::difference_type{0});
using pointer = value_type*;
using const_pointer = const value_type*;
using reference = value_type&;
using const_reference = const value_type&;
using iterator = value_type*;
using const_iterator = const value_type*;
public: public:
using binary_expression<Left,Right>::binary_expression; using binary_expression<Left,Right>::binary_expression;
constexpr string_cat_expr(const string_cat_expr&) = default; constexpr string_cat_expr(const string_cat_expr&) = default;
constexpr string_cat_expr(string_cat_expr&&) = default; constexpr string_cat_expr(string_cat_expr&&) = default;
constexpr size_t length(void)const noexcept; constexpr size_type length(void)const noexcept;
template<class Alloc> template<class Alloc>
operator basic_string<Alloc>(void) operator basic_string<value_type,Alloc>(void)
noexcept(std::is_nothrow_constructible<basic_string<Alloc>, size_t>::value && noexcept(std::is_nothrow_constructible<basic_string<value_type,Alloc>, typename basic_string<value_type,Alloc>::size_type>::value &&
std::is_nothrow_invocable<detail::string_appender<basic_string<Alloc>>,decltype(*this)>::value); std::is_nothrow_invocable<detail::string_appender<basic_string<value_type,Alloc>>,decltype(*this)>::value);
}; };
template<class Left, class Right> template<class Left, class Right>
string_cat_expr(Left&&,Right&&) -> string_cat_expr<Left&&,Right&&>; string_cat_expr(Left&&,Right&&) -> string_cat_expr<Left&&,Right&&>;
class static_string : public string_base template<class Char>
class static_string : public string_base<Char>
{ {
public:
using value_type = typename string_base<Char>::value_type;
using size_type = typename string_base<Char>::size_type;
using difference_type = typename string_base<Char>::difference_type;
using pointer = typename string_base<Char>::pointer;
using const_pointer = typename string_base<Char>::const_pointer;
using reference = typename string_base<Char>::reference;
using const_reference = typename string_base<Char>::const_reference;
using iterator = typename string_base<Char>::iterator;
using const_iterator = typename string_base<Char>::const_iterator;
protected:
using string_base<Char>::m_data;
using string_base<Char>::m_length;
using string_base<Char>::m_cap;
public: public:
constexpr static_string(void)noexcept = default; constexpr static_string(void)noexcept = default;
constexpr static_string(const char* str, size_t len)noexcept; constexpr static_string(const_pointer str, size_type len)noexcept;
constexpr static_string(const char* c)noexcept; constexpr static_string(const_pointer c)noexcept;
constexpr static_string(const static_string& s)noexcept; constexpr static_string(const static_string& s)noexcept;
constexpr static_string(static_string&& s)noexcept; constexpr static_string(static_string&& s)noexcept;
~static_string(void)noexcept = default; ~static_string(void)noexcept = default;
constexpr static_string& operator=(const char* c)noexcept; constexpr static_string& operator=(const_pointer c)noexcept;
constexpr static_string& operator=(const static_string& s)noexcept; constexpr static_string& operator=(const static_string& s)noexcept;
constexpr static_string& operator=(static_string&&)noexcept; constexpr static_string& operator=(static_string&&)noexcept;
}; };
@ -178,11 +239,11 @@ namespace rexy{
template<class T> template<class T>
struct is_string{ struct is_string{
static constexpr bool value = rexy::is_type<T,string_base>::value || rexy::is_template_type<T,string_cat_expr>::value; static constexpr bool value = rexy::is_template_derived_type<T,string_base>::value || rexy::is_template_type<T,string_cat_expr>::value;
}; };
template<class T> template<class T>
struct is_concrete_string{ struct is_concrete_string{
static constexpr bool value = rexy::is_type<T,string_base>::value; static constexpr bool value = rexy::is_template_derived_type<T,string_base>::value;
}; };
namespace detail{ namespace detail{
@ -213,16 +274,16 @@ namespace rexy{
} }
template<class Right, detail::enable_if_string<Right> = 0> template<class Right, detail::enable_if_string<Right> = 0>
constexpr auto operator+(const char* left, Right&& right) constexpr auto operator+(const char* left, Right&& right)
noexcept(noexcept(::new (nullptr) string_cat_expr(rexy::static_string(left), std::forward<Right>(right)))) noexcept(noexcept(::new (nullptr) string_cat_expr(rexy::static_string<char>(left), std::forward<Right>(right))))
{ {
return string_cat_expr(rexy::static_string(left), std::forward<Right>(right)); return string_cat_expr(rexy::static_string<char>(left), std::forward<Right>(right));
} }
template<class Left, detail::enable_if_string<Left> = 0> template<class Left, detail::enable_if_string<Left> = 0>
constexpr auto operator+(Left&& left, const char* right) constexpr auto operator+(Left&& left, const char* right)
noexcept(noexcept(::new (nullptr) string_cat_expr(std::forward<Left>(left), rexy::static_string(right)))) noexcept(noexcept(::new (nullptr) string_cat_expr(std::forward<Left>(left), rexy::static_string<char>(right))))
{ {
return rexy::string_cat_expr(std::forward<Left>(left), rexy::static_string(right)); return rexy::string_cat_expr(std::forward<Left>(left), rexy::static_string<char>(right));
} }
template<class Left, class Right, detail::enable_if_concrete_string<Left> = 0, detail::enable_if_string<Right> = 0> template<class Left, class Right, detail::enable_if_concrete_string<Left> = 0, detail::enable_if_string<Right> = 0>
@ -242,8 +303,8 @@ namespace rexy{
#include "string_base.tpp" #include "string_base.tpp"
namespace{ namespace{
constexpr inline rexy::static_string operator"" _ss(const char* str, size_t len)noexcept{ constexpr inline rexy::static_string<char> operator"" _ss(const char* str, size_t len)noexcept{
return rexy::static_string(str, len); return rexy::static_string<char>(str, len);
} }
} }

198
include/rexy/string_base.tpp
View File

@ -30,121 +30,123 @@
namespace rexy{ namespace rexy{
template<class Allocator> template<class Char, class Allocator>
constexpr basic_string<Allocator>::basic_string(void)noexcept{} constexpr basic_string<Char,Allocator>::basic_string(void)noexcept{}
template<class Allocator> template<class Char, class Allocator>
constexpr basic_string<Allocator>::basic_string(rexy::steal<char*> data)noexcept: constexpr basic_string<Char,Allocator>::basic_string(rexy::steal<pointer> data)noexcept:
string_base(data.value() ? cx::strlen(data.value()) : 0) string_base<Char>(data.value() ? cx::strlen(data.value()) : 0)
{ {
m_data = data.value(); m_data = data.value();
m_length = m_cap; m_length = m_cap;
} }
template<class Allocator> template<class Char, class Allocator>
constexpr basic_string<Allocator>::basic_string(rexy::steal<char*> data, size_t len)noexcept: constexpr basic_string<Char,Allocator>::basic_string(rexy::steal<pointer> data, size_type len)noexcept:
string_base(data.value(), len, len){} string_base<Char>(data.value(), len, len){}
template<class Allocator> template<class Char, class Allocator>
constexpr basic_string<Allocator>::basic_string(rexy::steal<char*> data, size_t len, size_t cap)noexcept: constexpr basic_string<Char,Allocator>::basic_string(rexy::steal<pointer> data, size_type len, size_type cap)noexcept:
string_base(data.value(), len, cap){} string_base<Char>(data.value(), len, cap){}
template<class Allocator> template<class Char, class Allocator>
basic_string<Allocator>::basic_string(const char* data, size_t len) basic_string<Char,Allocator>::basic_string(const_pointer data, size_type len)
noexcept(noexcept(this->allocate(0))): noexcept(noexcept(this->allocate(0))):
string_base(len ? this->allocate(len+1) : nullptr, len, len) string_base<Char>(len ? this->allocate(sizeof(Char)*(len+1)) : nullptr, len, len)
{ {
if(len){ if(len){
memcpy(m_data, data, len); memcpy(m_data, data, len*sizeof(Char));
m_data[len] = 0; m_data[len] = 0;
} }
} }
template<class Allocator> template<class Char, class Allocator>
basic_string<Allocator>::basic_string(const char* data) basic_string<Char,Allocator>::basic_string(const_pointer data)
noexcept(noexcept(this->allocate(0))): noexcept(noexcept(this->allocate(0))):
string_base(data ? strlen(data) : 0) string_base<Char>(data ? cx::strlen(data) : 0)
{ {
if(m_cap){ if(m_cap){
m_data = this->allocate(m_cap+1); m_data = this->allocate(sizeof(Char)*(m_cap+1));
memcpy(m_data, data, m_cap); memcpy(m_data, data, sizeof(Char)*m_cap);
m_length = m_cap; m_length = m_cap;
} }
} }
template<class Allocator> template<class Char, class Allocator>
basic_string<Allocator>::basic_string(size_t len) basic_string<Char,Allocator>::basic_string(size_type len)
noexcept(noexcept(this->allocate(0))): noexcept(noexcept(this->allocate(0))):
string_base(len ? this->allocate(len+1) : nullptr, len) string_base<Char>(len ? this->allocate(sizeof(Char)*(len+1)) : nullptr, len)
{ {
if(len) if(len)
m_data[len] = 0; m_data[len] = 0;
} }
template<class Allocator> template<class Char, class Allocator>
basic_string<Allocator>::basic_string(size_t len, size_t cap) basic_string<Char,Allocator>::basic_string(size_type len, size_type cap)
noexcept(noexcept(this->allocate(len))): noexcept(noexcept(this->allocate(0))):
string_base(len ? this->allocate(len+1) : nullptr, len, cap) string_base<Char>(len ? this->allocate(sizeof(Char)*(len+1)) : nullptr, len, cap)
{ {
if(len) if(len)
m_data[len] = 0; m_data[len] = 0;
} }
//normal copy and move ctors //normal copy and move ctors
template<class Allocator> template<class Char, class Allocator>
basic_string<Allocator>::basic_string(const basic_string& b) basic_string<Char,Allocator>::basic_string(const basic_string& b)
noexcept(noexcept(this->allocate(0))): noexcept(noexcept(this->allocate(0))):
string_base(b.m_length ? this->allocate(b.m_length+1) : nullptr, b.m_length, b.m_length) string_base<Char>(b.m_length ? this->allocate(sizeof(Char)*(b.m_length+1)) : nullptr, b.m_length, b.m_length)
{ {
if(b.m_length) if(b.m_length)
memcpy(m_data, b.m_data, b.m_length+1); memcpy(m_data, b.m_data, sizeof(Char)*(b.m_length+1));
} }
template<class Allocator> template<class Char, class Allocator>
constexpr basic_string<Allocator>::basic_string(basic_string&& s) constexpr basic_string<Char,Allocator>::basic_string(basic_string&& s)
noexcept(noexcept(cx::exchange(s.m_data, nullptr))): noexcept(noexcept(cx::exchange(s.m_data, nullptr))):
string_base(cx::exchange(s.m_data, nullptr), s.m_length, s.m_cap){} string_base<Char>(cx::exchange(s.m_data, nullptr), s.m_length, s.m_cap){}
template<class Allocator> template<class Char, class Allocator>
basic_string<Allocator>::basic_string(const string_base& b) template<class C>
noexcept(noexcept(this->allocate(b.length()))): basic_string<Char,Allocator>::basic_string(const string_base<C>& b)
string_base(b.length() ? this->allocate(b.length()+1) : nullptr, b.length(), b.length()) noexcept(noexcept(this->allocate(0))):
string_base<Char>(b.length() ? this->allocate(sizeof(Char)*(b.length()+1)) : nullptr, b.length(), b.length())
{ {
if(b.length()) if(b.length())
memcpy(m_data, b.get(), b.length()+1); memcpy(m_data, b.get(), sizeof(Char)*(b.length()+1));
} }
//dtor //dtor
template<class Allocator> template<class Char, class Allocator>
basic_string<Allocator>::~basic_string(void) basic_string<Char,Allocator>::~basic_string(void)
noexcept(noexcept(this->deallocate(nullptr, 0))) noexcept(noexcept(this->deallocate(nullptr, 0)))
{ {
this->deallocate(m_data, m_cap+1); this->deallocate(m_data, sizeof(Char)*(m_cap+1));
} }
template<class Allocator> template<class Char, class Allocator>
basic_string<Allocator>& basic_string<Allocator>::operator=(const basic_string& s) basic_string<Char,Allocator>& basic_string<Char,Allocator>::operator=(const basic_string& s)
noexcept(noexcept(this->allocate(0)) && noexcept(noexcept(this->allocate(0)) &&
noexcept(this->deallocate(nullptr, 0))) noexcept(this->deallocate(nullptr, 0)))
{ {
if(s.m_length < m_cap){ if(s.m_length < m_cap){
memcpy(m_data, s.m_data, s.m_length+1); memcpy(m_data, s.m_data, sizeof(Char)*(s.m_length+1));
m_length = s.m_length; m_length = s.m_length;
return *this; return *this;
} }
basic_string tmp(s); basic_string tmp(s);
return (*this = std::move(tmp)); return (*this = std::move(tmp));
} }
template<class Allocator> template<class Char, class Allocator>
constexpr basic_string<Allocator>& basic_string<Allocator>::operator=(basic_string&& s)noexcept{ constexpr basic_string<Char,Allocator>& basic_string<Char,Allocator>::operator=(basic_string&& s)noexcept{
cx::swap(m_data, s.m_data); cx::swap(m_data, s.m_data);
m_length = s.m_length; m_length = s.m_length;
m_cap = s.m_cap; m_cap = s.m_cap;
return *this; return *this;
} }
//Copy from c string //Copy from c string
template<class Allocator> template<class Char, class Allocator>
basic_string<Allocator>& basic_string<Allocator>::operator=(const char* c) basic_string<Char,Allocator>& basic_string<Char,Allocator>::operator=(const_pointer c)
noexcept(noexcept(this->allocate(0)) && noexcept(noexcept(this->allocate(0)) &&
noexcept(this->deallocate(nullptr,0))) noexcept(this->deallocate(nullptr,0)))
{ {
return _copy_string(c, strlen(c)); return _copy_string(c, cx::strlen(c));
} }
//Copy from other string_base //Copy from other string_base
template<class Allocator> template<class Char, class Allocator>
basic_string<Allocator>& basic_string<Allocator>::operator=(const string_base& s) template<class C>
basic_string<Char,Allocator>& basic_string<Char,Allocator>::operator=(const string_base<C>& s)
noexcept(noexcept(this->allocate(0)) && noexcept(noexcept(this->allocate(0)) &&
noexcept(this->deallocate(nullptr,0))) noexcept(this->deallocate(nullptr,0)))
{ {
@ -152,26 +154,26 @@ namespace rexy{
} }
//Replace managed pointer. Frees existing value //Replace managed pointer. Frees existing value
template<class Allocator> template<class Char, class Allocator>
void basic_string<Allocator>::reset(char* val) void basic_string<Char,Allocator>::reset(pointer val)
noexcept(noexcept(this->deallocate(m_data,0))) noexcept(noexcept(this->deallocate(nullptr,0)))
{ {
this->deallocate(m_data,m_cap+1); this->deallocate(m_data,sizeof(Char)*(m_cap+1));
m_data = val; m_data = val;
m_length = val ? strlen(val) : 0; m_length = val ? cx::strlen(val) : 0;
m_cap = m_length; m_cap = m_length;
} }
template<class Allocator> template<class Char, class Allocator>
void basic_string<Allocator>::reset(char* val, size_t len) void basic_string<Char,Allocator>::reset(pointer val, size_type len)
noexcept(noexcept(this->deallocate(m_data,0))) noexcept(noexcept(this->deallocate(nullptr,0)))
{ {
this->deallocate(m_data,m_cap+1); this->deallocate(m_data,sizeof(Char)*(m_cap+1));
m_data = val; m_data = val;
m_length = len; m_length = len;
m_cap = len; m_cap = len;
} }
template<class Allocator> template<class Char, class Allocator>
bool basic_string<Allocator>::resize(size_t newsize) bool basic_string<Char,Allocator>::resize(size_type newsize)
noexcept(noexcept(this->allocate(0)) && noexcept(noexcept(this->allocate(0)) &&
noexcept(this->deallocate(nullptr,0))) noexcept(this->deallocate(nullptr,0)))
{ {
@ -179,18 +181,18 @@ namespace rexy{
return false; return false;
return (*this = basic_string(m_data, newsize)); return (*this = basic_string(m_data, newsize));
} }
template<class Allocator> template<class Char, class Allocator>
void basic_string<Allocator>::append(const char* data, size_t len) void basic_string<Char,Allocator>::append(const_pointer data, size_type len)
noexcept(noexcept(this->allocate(0)) && noexcept(noexcept(this->allocate(0)) &&
noexcept(this->deallocate(nullptr,0))) noexcept(this->deallocate(nullptr,0)))
{ {
if(len+m_length <= m_cap){ if(len+m_length <= m_cap){
memcpy(m_data+m_length, data, len); memcpy(m_data+m_length, data, sizeof(Char)*len);
m_length += len; m_length += len;
m_data[m_length] = 0; m_data[m_length] = 0;
}else if(!m_data){ }else if(!m_data){
*this = basic_string(len, len); *this = basic_string(len, len);
memcpy(m_data, data, len); memcpy(m_data, data, sizeof(Char)*len);
m_data[len] = 0; m_data[len] = 0;
}else{ }else{
auto newsize = cx::max(m_length+len, m_cap*2); auto newsize = cx::max(m_length+len, m_cap*2);
@ -200,32 +202,33 @@ namespace rexy{
*this = std::move(tmp); *this = std::move(tmp);
} }
} }
template<class Allocator> template<class Char, class Allocator>
void basic_string<Allocator>::append(const char* data) void basic_string<Char,Allocator>::append(const_pointer data)
noexcept(noexcept(this->allocate(0)) && noexcept(noexcept(this->allocate(0)) &&
noexcept(this->deallocate(nullptr,0))) noexcept(this->deallocate(nullptr,0)))
{ {
if(data) if(data)
append(data, strlen(data)); append(data, cx::strlen(data));
} }
template<class Allocator> template<class Char, class Allocator>
void basic_string<Allocator>::append(const string_base& s) template<class C>
void basic_string<Char,Allocator>::append(const string_base<C>& s)
noexcept(noexcept(this->allocate(0)) && noexcept(noexcept(this->allocate(0)) &&
noexcept(this->deallocate(nullptr,0))) noexcept(this->deallocate(nullptr,0)))
{ {
append(s.get(), s.length()); append(s.get(), s.length());
} }
template<class Allocator> template<class Char, class Allocator>
basic_string<Allocator>& basic_string<Allocator>::_copy_string(const char* s, size_t len) basic_string<Char,Allocator>& basic_string<Char,Allocator>::_copy_string(const_pointer s, size_type len)
noexcept(noexcept(this->allocate(0)) && noexcept(noexcept(this->allocate(0)) &&
noexcept(this->deallocate(nullptr,0))) noexcept(this->deallocate(nullptr,0)))
{ {
if(!len) if(!len)
return (*this = basic_string(rexy::steal<char*>(nullptr), 0, 0)); return (*this = basic_string(rexy::steal<pointer>(nullptr), 0, 0));
if(len <= m_length){ if(len <= m_length){
m_length = len; m_length = len;
memcpy(m_data, s, len); memcpy(m_data, s, sizeof(Char)*len);
m_data[len] = 0; m_data[len] = 0;
return *this; return *this;
} }
@ -234,44 +237,51 @@ namespace rexy{
template<class Left, class Right> template<class Left, class Right>
constexpr size_t string_cat_expr<Left,Right>::length(void)const noexcept{ constexpr auto string_cat_expr<Left,Right>::length(void)const noexcept -> size_type{
return this->m_l.length() + this->m_r.length(); return this->m_l.length() + this->m_r.length();
} }
template<class Left, class Right> template<class Left, class Right>
template<class Alloc> template<class Alloc>
string_cat_expr<Left,Right>::operator basic_string<Alloc>(void) string_cat_expr<Left,Right>::operator basic_string<value_type,Alloc>(void)
noexcept(std::is_nothrow_constructible<basic_string<Alloc>, size_t>::value && noexcept(std::is_nothrow_constructible<basic_string<value_type,Alloc>, typename basic_string<value_type,Alloc>::size_type>::value &&
std::is_nothrow_invocable<detail::string_appender<basic_string<Alloc>>,decltype(*this)>::value) std::is_nothrow_invocable<detail::string_appender<basic_string<value_type,Alloc>>,decltype(*this)>::value)
{ {
size_t len = length(); size_type len = length();
basic_string<Alloc> ret(len); basic_string<value_type,Alloc> ret(len);
detail::string_appender<basic_string<Alloc>> append(ret); detail::string_appender<basic_string<value_type,Alloc>> append(ret);
append(*this); append(*this);
return ret; return ret;
} }
constexpr static_string::static_string(const char* str, size_t len)noexcept: template<class Char>
string_base(const_cast<char*>(str), len, len){} constexpr static_string<Char>::static_string(const_pointer str, size_type len)noexcept:
constexpr static_string::static_string(const static_string& s)noexcept: string_base<Char>(const_cast<pointer>(str), len, len){}
string_base(s.m_data, s.m_length, s.m_length){} template<class Char>
constexpr static_string::static_string(static_string&& s)noexcept: constexpr static_string<Char>::static_string(const static_string& s)noexcept:
string_base(s.m_data, s.m_length, s.m_length){} string_base<Char>(s.m_data, s.m_length, s.m_length){}
constexpr static_string& static_string::operator=(const static_string& s)noexcept{ template<class Char>
constexpr static_string<Char>::static_string(static_string&& s)noexcept:
string_base<Char>(s.m_data, s.m_length, s.m_length){}
template<class Char>
constexpr static_string<Char>& static_string<Char>::operator=(const static_string& s)noexcept{
m_data = s.m_data; m_data = s.m_data;
m_length = s.m_length; m_length = s.m_length;
m_cap = s.m_cap; m_cap = s.m_cap;
return *this; return *this;
} }
constexpr static_string::static_string(const char* c)noexcept: template<class Char>
constexpr static_string<Char>::static_string(const_pointer c)noexcept:
static_string(c, cx::strlen(c)){} static_string(c, cx::strlen(c)){}
constexpr static_string& static_string::operator=(const char* c)noexcept{ template<class Char>
m_data = const_cast<char*>(c); constexpr static_string<Char>& static_string<Char>::operator=(const_pointer c)noexcept{
m_data = const_cast<pointer>(c);
m_length = cx::strlen(c); m_length = cx::strlen(c);
m_cap = m_length; m_cap = m_length;
return *this; return *this;
} }
constexpr static_string& static_string::operator=(static_string&& s)noexcept{ template<class Char>
constexpr static_string<Char>& static_string<Char>::operator=(static_string&& s)noexcept{
m_data = s.m_data; m_data = s.m_data;
m_length = s.m_length; m_length = s.m_length;
m_cap = s.m_cap; m_cap = s.m_cap;

2
src/filerd.cpp
View File

@ -106,7 +106,7 @@ namespace rexy{
size_t filerd::write(const char* c, size_t bytes)noexcept{ size_t filerd::write(const char* c, size_t bytes)noexcept{
return fwrite(c, 1, bytes, m_fp); return fwrite(c, 1, bytes, m_fp);
} }
size_t filerd::write(const rexy::string_base& c)noexcept{ size_t filerd::write(const rexy::string_base<char>& c)noexcept{
return write(c.get(), c.length()); return write(c.get(), c.length());
} }

2
src/string.cpp
View File

@ -21,6 +21,6 @@
namespace rexy{ namespace rexy{
template class basic_string<detail::default_allocator<char>>; template class basic_string<char,detail::default_allocator<char>>;
} }