324 lines
11 KiB
C++
324 lines
11 KiB
C++
/**
|
|
This file is a part of rexy's general purpose library
|
|
Copyright (C) 2020 rexy712
|
|
|
|
This program is free software: you can redistribute it and/or modify
|
|
it under the terms of the GNU Affero General Public License as published by
|
|
the Free Software Foundation, either version 3 of the License, or
|
|
(at your option) any later version.
|
|
|
|
This program is distributed in the hope that it will be useful,
|
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
GNU Affero General Public License for more details.
|
|
|
|
You should have received a copy of the GNU Affero General Public License
|
|
along with this program. If not, see <http://www.gnu.org/licenses/>.
|
|
*/
|
|
|
|
#ifndef REXY_STRING_BASE_TPP
|
|
#define REXY_STRING_BASE_TPP
|
|
|
|
#include <utility> //forward, move, swap, etc
|
|
#include <cstdlib> //memcpy
|
|
#include <cstring> //strlen, strcpy
|
|
|
|
#include "cx/utility.hpp" //max
|
|
#include "detail/string_appender.hpp"
|
|
|
|
#define STOP_STRICT_ALIAS_WARNING(x) (x)
|
|
|
|
namespace rexy{
|
|
|
|
//allocate string if longer than small string capacity, copy otherwise
|
|
template<class Char, class Allocator>
|
|
void basic_string<Char,Allocator>::_copy_construct_string(const_pointer data, size_type len, size_type cap)
|
|
noexcept(noexcept(this->allocate(0)))
|
|
{
|
|
if(cap > this->get_short_capacity()){
|
|
this->set_islong_flag(true);
|
|
pointer raw = this->set_long_ptr(this->allocate(sizeof(value_type)*(cap+1)));
|
|
if(data)
|
|
memcpy(raw, data, sizeof(value_type)*len);
|
|
raw[len] = 0;
|
|
this->set_long_length(len);
|
|
this->set_long_capacity(cap);
|
|
}else{
|
|
this->set_islong_flag(false);
|
|
pointer raw = this->set_short_ptr();
|
|
if(data)
|
|
memcpy(raw, data, sizeof(value_type)*len);
|
|
raw[len] = 0;
|
|
this->set_short_length(len);
|
|
this->set_short_capacity(cap);
|
|
}
|
|
}
|
|
|
|
template<class Char, class Allocator>
|
|
constexpr basic_string<Char,Allocator>::basic_string(void)noexcept{}
|
|
template<class Char, class Allocator>
|
|
constexpr basic_string<Char,Allocator>::basic_string(rexy::steal<pointer> data)noexcept:
|
|
basic_string(data.value(), data.value() ? cx::strlen(data.value()) : 0){}
|
|
template<class Char, class Allocator>
|
|
constexpr basic_string<Char,Allocator>::basic_string(rexy::steal<pointer> data, size_type len)noexcept:
|
|
string_base<Char>(data.value(), len, len){}
|
|
template<class Char, class Allocator>
|
|
constexpr basic_string<Char,Allocator>::basic_string(rexy::steal<pointer> data, size_type len, size_type cap)noexcept:
|
|
string_base<Char>(data.value(), len, cap){}
|
|
template<class Char, class Allocator>
|
|
basic_string<Char,Allocator>::basic_string(const_pointer data, size_type len, size_type cap)
|
|
noexcept(noexcept(this->allocate(0)))
|
|
{
|
|
_copy_construct_string(data, len, cap);
|
|
}
|
|
template<class Char, class Allocator>
|
|
basic_string<Char,Allocator>::basic_string(const_pointer data, size_type len)
|
|
noexcept(noexcept(this->allocate(0))):
|
|
basic_string(data, len, len){}
|
|
template<class Char, class Allocator>
|
|
basic_string<Char,Allocator>::basic_string(const_pointer data)
|
|
noexcept(noexcept(this->allocate(0))):
|
|
basic_string(data, data ? cx::strlen(data) : 0){}
|
|
template<class Char, class Allocator>
|
|
basic_string<Char,Allocator>::basic_string(size_type cap)
|
|
noexcept(noexcept(this->allocate(0))):
|
|
basic_string(size_type{0}, cap){}
|
|
template<class Char, class Allocator>
|
|
basic_string<Char,Allocator>::basic_string(size_type len, size_type cap)
|
|
noexcept(noexcept(this->allocate(0)))
|
|
{
|
|
_copy_construct_string(nullptr, len, cap);
|
|
}
|
|
|
|
//normal copy and move ctors
|
|
template<class Char, class Allocator>
|
|
basic_string<Char,Allocator>::basic_string(const basic_string& b)
|
|
noexcept(noexcept(this->allocate(0))):
|
|
detail::hasallocator<Allocator>(b)
|
|
{
|
|
_copy_construct_string(b.get(), b.length(), b.capacity());
|
|
}
|
|
template<class Char, class Allocator>
|
|
constexpr basic_string<Char,Allocator>::basic_string(basic_string&& s)noexcept:
|
|
detail::hasallocator<Allocator>(std::move(s)),
|
|
string_base<Char>(std::move(s)){}
|
|
template<class Char, class Allocator>
|
|
basic_string<Char,Allocator>::basic_string(const string_base<Char>& b)
|
|
noexcept(noexcept(this->allocate(0)))
|
|
{
|
|
_copy_construct_string(b.get(), b.length(), b.capacity());
|
|
}
|
|
|
|
//dtor
|
|
template<class Char, class Allocator>
|
|
basic_string<Char,Allocator>::~basic_string(void)
|
|
noexcept(noexcept(this->deallocate(nullptr, 0)))
|
|
{
|
|
if(this->islong())
|
|
this->deallocate(this->get_pointer(), sizeof(value_type)*(this->get_long_capacity()+1));
|
|
}
|
|
|
|
template<class Char, class Allocator>
|
|
basic_string<Char,Allocator>& basic_string<Char,Allocator>::operator=(const basic_string& s)
|
|
noexcept(noexcept(this->allocate(0)) &&
|
|
noexcept(this->deallocate(nullptr, 0)))
|
|
{
|
|
if(s.length() < this->capacity()){
|
|
memcpy(this->get_pointer(), s.get_pointer(), sizeof(value_type)*(s.length()+1));
|
|
this->set_length(s.length());
|
|
return *this;
|
|
}
|
|
basic_string tmp(s);
|
|
return (*this = std::move(tmp));
|
|
}
|
|
template<class Char, class Allocator>
|
|
constexpr basic_string<Char,Allocator>& basic_string<Char,Allocator>::operator=(basic_string&& s)noexcept{
|
|
string_base<Char>::operator=(std::move(s));
|
|
return *this;
|
|
}
|
|
template<class Char, class Allocator>
|
|
basic_string<Char,Allocator>& basic_string<Char,Allocator>::operator=(const string_base<Char>& s)
|
|
noexcept(noexcept(this->allocate(0)) &&
|
|
noexcept(this->deallocate(nullptr,0)))
|
|
{
|
|
return (*this = basic_string(s));
|
|
}
|
|
//Copy from c string
|
|
template<class Char, class Allocator>
|
|
basic_string<Char,Allocator>& basic_string<Char,Allocator>::operator=(const_pointer c)
|
|
noexcept(noexcept(this->allocate(0)) &&
|
|
noexcept(this->deallocate(nullptr,0)))
|
|
{
|
|
return _copy_string(c, cx::strlen(c));
|
|
}
|
|
|
|
//Replace managed pointer. Frees existing value
|
|
template<class Char, class Allocator>
|
|
void basic_string<Char,Allocator>::reset(pointer val)
|
|
noexcept(noexcept(this->deallocate(nullptr,0)))
|
|
{
|
|
reset(val, val ? cx::strlen(val) : 0);
|
|
}
|
|
template<class Char, class Allocator>
|
|
void basic_string<Char,Allocator>::reset(pointer val, size_type len)
|
|
noexcept(noexcept(this->deallocate(nullptr,0)))
|
|
{
|
|
if(this->islong())
|
|
this->deallocate(this->get_long_ptr(),sizeof(value_type)*(this->get_long_capacity()+1));
|
|
this->set_islong_flag(true);
|
|
this->set_long_ptr(val);
|
|
this->set_long_length(len);
|
|
this->set_long_capacity(len);
|
|
}
|
|
template<class Char, class Allocator>
|
|
bool basic_string<Char,Allocator>::resize(size_type newsize)
|
|
noexcept(noexcept(this->allocate(0)) &&
|
|
noexcept(this->deallocate(nullptr,0)))
|
|
{
|
|
if(newsize < this->capacity())
|
|
return false;
|
|
if(!this->islong() && newsize < this->get_short_capacity())
|
|
return false;
|
|
return (*this = basic_string(this->get_pointer(), newsize));
|
|
}
|
|
template<class Char, class Allocator>
|
|
void basic_string<Char,Allocator>::append(const_pointer data, size_type len)
|
|
noexcept(noexcept(this->allocate(0)) &&
|
|
noexcept(this->deallocate(nullptr,0)))
|
|
{
|
|
size_type mylen = this->length();
|
|
size_type mycap = this->capacity();
|
|
pointer raw = this->get_pointer();
|
|
|
|
if(mylen+len <= mycap){
|
|
memcpy(raw+mylen, data, sizeof(value_type)*len);
|
|
this->set_length(mylen+len);
|
|
raw[mylen+len] = 0;
|
|
}else{
|
|
auto newsize = cx::max(mylen+len, mycap*2);
|
|
basic_string tmp(newsize);
|
|
tmp.append(raw, mylen);
|
|
tmp.append(data, len);
|
|
*this = std::move(tmp);
|
|
}
|
|
}
|
|
template<class Char, class Allocator>
|
|
void basic_string<Char,Allocator>::append(const_pointer data)
|
|
noexcept(noexcept(this->allocate(0)) &&
|
|
noexcept(this->deallocate(nullptr,0)))
|
|
{
|
|
if(data)
|
|
append(data, cx::strlen(data));
|
|
}
|
|
|
|
template<class Char, class Allocator>
|
|
auto basic_string<Char,Allocator>::release(void)noexcept(noexcept(this->allocate(0))) -> pointer{
|
|
if(this->islong()){
|
|
pointer raw = this->get_long_ptr();
|
|
this->set_islong_flag(false);
|
|
this->set_short_ptr();
|
|
this->set_short_length(0);
|
|
return raw;
|
|
}
|
|
size_type len = this->get_short_length();
|
|
pointer raw = this->get_short_ptr();
|
|
pointer retval = this->allocate(sizeof(value_type)*len+1);
|
|
memcpy(retval, raw, sizeof(value_type)*len);
|
|
retval[len] = 0;
|
|
raw[0] = 0;
|
|
this->set_short_length(0);
|
|
return retval;
|
|
}
|
|
|
|
template<class Char, class Allocator>
|
|
basic_string<Char,Allocator>& basic_string<Char,Allocator>::_copy_string(const_pointer s, size_type len)
|
|
noexcept(noexcept(this->allocate(0)) &&
|
|
noexcept(this->deallocate(nullptr,0)))
|
|
{
|
|
if(!len)
|
|
return (*this = basic_string(rexy::steal<pointer>(nullptr), 0, 0));
|
|
if(len <= this->length()){
|
|
this->set_length(len);
|
|
pointer raw = this->get_pointer();
|
|
memcpy(raw, s, sizeof(value_type)*len);
|
|
raw[len] = 0;
|
|
return *this;
|
|
}
|
|
return (*this = basic_string(s, len));
|
|
}
|
|
|
|
|
|
template<class Left, class Right>
|
|
constexpr auto string_cat_expr<Left,Right>::length(void)const noexcept -> size_type{
|
|
return this->m_l.length() + this->m_r.length();
|
|
}
|
|
template<class Left, class Right>
|
|
template<class Alloc>
|
|
string_cat_expr<Left,Right>::operator basic_string<value_type,Alloc>(void)
|
|
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<value_type,Alloc>>,decltype(*this)>::value)
|
|
{
|
|
size_type len = length();
|
|
basic_string<value_type,Alloc> ret(len);
|
|
detail::string_appender<basic_string<value_type,Alloc>> append(ret);
|
|
append(*this);
|
|
return ret;
|
|
}
|
|
|
|
|
|
template<class Char>
|
|
constexpr static_string<Char>::static_string(void)noexcept:
|
|
static_string(nullptr, 0){}
|
|
|
|
template<class Char>
|
|
constexpr static_string<Char>::static_string(const_pointer str, size_type len)noexcept{
|
|
if(!str)
|
|
this->set_long_ptr(nullptr);
|
|
else
|
|
this->set_long_ptr(const_cast<pointer>(str));
|
|
this->set_long_length(len);
|
|
this->set_long_capacity(len);
|
|
}
|
|
template<class Char>
|
|
constexpr static_string<Char>::static_string(const static_string& s)noexcept:
|
|
static_string(s.get_long_ptr(), s.get_long_length()){}
|
|
template<class Char>
|
|
constexpr static_string<Char>::static_string(static_string&& s)noexcept:
|
|
static_string(s.get_long_ptr(), s.get_long_length()){}
|
|
template<class Char>
|
|
constexpr static_string<Char>& static_string<Char>::operator=(const static_string& s)noexcept{
|
|
this->set_long_ptr(const_cast<pointer>(s.get_long_ptr()));
|
|
this->set_long_length(s.get_long_length());
|
|
this->set_long_capacity(s.get_long_capacity());
|
|
return *this;
|
|
}
|
|
template<class Char>
|
|
constexpr static_string<Char>::static_string(const_pointer c)noexcept:
|
|
static_string(c, cx::strlen(c)){}
|
|
template<class Char>
|
|
constexpr static_string<Char>& static_string<Char>::operator=(const_pointer c)noexcept{
|
|
size_type len = cx::strlen(c);
|
|
this->set_long_ptr(const_cast<pointer>(c));
|
|
this->set_long_length(len);
|
|
this->set_long_capacity(len);
|
|
return *this;
|
|
}
|
|
template<class Char>
|
|
constexpr static_string<Char>& static_string<Char>::operator=(static_string&& s)noexcept{
|
|
this->set_long_ptr(s.get_long_ptr());
|
|
this->set_long_length(s.get_long_length());
|
|
this->set_long_capacity(s.get_long_capacity());
|
|
return *this;
|
|
}
|
|
|
|
extern template class static_string<char>;
|
|
extern template class static_string<wchar_t>;
|
|
extern template class static_string<char16_t>;
|
|
extern template class static_string<char32_t>;
|
|
|
|
} //namespace rexy
|
|
|
|
#undef STOP_STRICT_ALIAS_WARNING
|
|
|
|
#endif
|