Overhaul string_cat_expr -> string_intermediary conversion. No longer need to convert fat_strings.cpp to c style string allocation
This commit is contained in:
+82
-226
@@ -19,12 +19,9 @@
|
||||
#ifndef RAII_STRING_BASE_HPP
|
||||
#define RAII_STRING_BASE_HPP
|
||||
|
||||
#include <cstddef> //size_t
|
||||
#include <cstring> //strlen, strcpy
|
||||
#include <cstdlib> //memcpy
|
||||
#include <type_traits> //is_same, integral_contant, enable_if, etc
|
||||
#include <utility> //forward
|
||||
#include <tuple>
|
||||
#include <cstdlib> //size_t
|
||||
|
||||
namespace raii{
|
||||
|
||||
@@ -51,6 +48,20 @@ namespace raii{
|
||||
struct is_tuple{
|
||||
static constexpr bool value = std::is_same<std::true_type,decltype(is_tuple_helper(std::declval<T>()))>::value;
|
||||
};
|
||||
|
||||
//check for member function 'length'
|
||||
template<class T>
|
||||
struct has_len{
|
||||
template<class U, class V>
|
||||
struct check;
|
||||
|
||||
template<class U>
|
||||
static std::true_type test(check<U,decltype(&U::length)>*);
|
||||
template<class U>
|
||||
static std::false_type test(...);
|
||||
|
||||
static constexpr bool value = std::is_same<std::true_type,decltype(test<T>(0))>::value;
|
||||
};
|
||||
}
|
||||
|
||||
|
||||
@@ -92,7 +103,6 @@ namespace raii{
|
||||
};
|
||||
|
||||
|
||||
|
||||
//Supplies all functions that string_base can't implement
|
||||
template<class Allocator>
|
||||
class string_intermediary : public string_base
|
||||
@@ -102,183 +112,39 @@ namespace raii{
|
||||
|
||||
public:
|
||||
string_intermediary(void) = default;
|
||||
string_intermediary(char* data, size_t len):
|
||||
string_base(data, len){}
|
||||
string_intermediary(const char* data, size_t len):
|
||||
string_base(reinterpret_cast<char*>(len ? Allocator::copy(data, len+1) : nullptr), len){}
|
||||
string_intermediary(const char* data):
|
||||
string_base(data ? strlen(data) : 0)
|
||||
{
|
||||
if(m_length)
|
||||
m_data = reinterpret_cast<char*>(Allocator::copy(data, m_length+1));
|
||||
}
|
||||
string_intermediary(size_t len):
|
||||
string_base(reinterpret_cast<char*>(len ? Allocator::allocate(len+1) : nullptr), len){}
|
||||
string_intermediary(char* data, size_t len);
|
||||
string_intermediary(const char* data, size_t len);
|
||||
string_intermediary(const char* data);
|
||||
string_intermediary(size_t len);
|
||||
|
||||
//normal copy and move ctors
|
||||
string_intermediary(const string_intermediary& b):
|
||||
string_base(reinterpret_cast<char*>(b.m_length ? Allocator::copy(b.m_data, b.m_length+1) : nullptr), b.m_length){}
|
||||
string_intermediary(string_intermediary&& s):
|
||||
string_base(std::exchange(s.m_data, nullptr), s.m_length){}
|
||||
string_intermediary(const string_intermediary& b);
|
||||
string_intermediary(string_intermediary&& s);
|
||||
|
||||
string_intermediary(const string_base& b):
|
||||
string_base(reinterpret_cast<char*>(b.length() ? Allocator::copy(b.get(), b.length()+1) : nullptr), b.length()){}
|
||||
|
||||
//copy from string expression
|
||||
template<class T, typename std::enable_if<detail::is_string<T>::value && !detail::is_concrete_string<T>::value,void>::type* = nullptr>
|
||||
string_intermediary(T&& t){
|
||||
size_t len = t.length();
|
||||
if(!len){
|
||||
return;
|
||||
}
|
||||
char* tmp = reinterpret_cast<char*>(Allocator::allocate(len+1));
|
||||
_assign(tmp, t.get(), 0);
|
||||
m_data = tmp;
|
||||
m_data[len] = 0;
|
||||
m_length = len;
|
||||
}
|
||||
string_intermediary(const string_base& b);
|
||||
|
||||
//dtor
|
||||
~string_intermediary(void){
|
||||
Allocator::free(m_data);
|
||||
}
|
||||
~string_intermediary(void);
|
||||
|
||||
string_intermediary& operator=(const string_intermediary& s){
|
||||
string_intermediary tmp(s);
|
||||
return (*this = std::move(tmp));
|
||||
}
|
||||
string_intermediary& operator=(string_intermediary&& s){
|
||||
std::swap(m_data, s.m_data);
|
||||
m_length = s.m_length;
|
||||
return *this;
|
||||
}
|
||||
string_intermediary& operator=(const string_intermediary& s);
|
||||
string_intermediary& operator=(string_intermediary&& s);
|
||||
//Copy from c string
|
||||
string_intermediary& operator=(const char* c){
|
||||
return _copy_string(c, strlen(c));
|
||||
}
|
||||
string_intermediary& operator=(const char* c);
|
||||
//Copy from other string_base
|
||||
string_intermediary& operator=(const string_base& s){
|
||||
return _copy_string(s.get(), s.length());
|
||||
}
|
||||
//Move from other string base
|
||||
template<class T, typename std::enable_if<detail::is_string<T>::value && !detail::is_concrete_string<T>::value,void>::type* = nullptr>
|
||||
string_base& operator=(T&& t){
|
||||
size_t len = t.length();
|
||||
char* tmp;
|
||||
if(len > m_length){
|
||||
tmp = reinterpret_cast<char*>(Allocator::allocate(len+1));
|
||||
_assign(tmp, t.get(), 0);
|
||||
Allocator::free(m_data);
|
||||
}else{
|
||||
tmp = m_data;
|
||||
_assign(tmp, t.get(), 0);
|
||||
}
|
||||
m_data = tmp;
|
||||
m_data[len] = 0;
|
||||
m_length = len;
|
||||
return *this;
|
||||
}
|
||||
|
||||
string_intermediary operator+(const string_base& s)const{
|
||||
string_intermediary tmp(reinterpret_cast<char*>(Allocator::allocate(m_length + s.length() + 1)), m_length+s.length());
|
||||
memcpy(tmp.get(), m_data, m_length);
|
||||
strcpy(tmp.get()+m_length, s.get());
|
||||
return tmp;
|
||||
}
|
||||
|
||||
string_intermediary operator+(const char* c)const{
|
||||
size_t len = strlen(c);
|
||||
string_intermediary tmp(reinterpret_cast<char*>(Allocator::allocate(m_length + len + 1)), m_length+len);
|
||||
memcpy(tmp.get(), m_data, m_length);
|
||||
strcpy(tmp.get()+m_length, c);
|
||||
return tmp;
|
||||
}
|
||||
|
||||
string_intermediary& operator=(const string_base& s);
|
||||
|
||||
//Replace managed pointer. Frees existing value
|
||||
void reset(char* val = nullptr){
|
||||
Allocator::free(m_data);
|
||||
m_data = val;
|
||||
m_length = val ? strlen(val) : 0;
|
||||
}
|
||||
void reset(char* val, size_t len){
|
||||
Allocator::free(m_data);
|
||||
m_data = val;
|
||||
m_length = len;
|
||||
}
|
||||
bool resize(size_t newsize){
|
||||
if(newsize < m_length)
|
||||
return false;
|
||||
string_intermediary tmp(newsize);
|
||||
memcpy(tmp.get(), m_data, m_length);
|
||||
tmp[m_length] = 0;
|
||||
*this = std::move(tmp);
|
||||
return true;
|
||||
}
|
||||
void append(const char* data, size_t len){
|
||||
string_intermediary tmp(m_length + len);
|
||||
memcpy(tmp.m_data, m_data, m_length);
|
||||
memcpy(tmp.m_data+m_length, data, len);
|
||||
tmp[m_length+len] = 0;
|
||||
*this = std::move(tmp);
|
||||
}
|
||||
void append(const char* data){
|
||||
*this += data;
|
||||
}
|
||||
void append(const string_expr& s){
|
||||
*this += s;
|
||||
}
|
||||
void reset(char* val = nullptr);
|
||||
void reset(char* val, size_t len);
|
||||
bool resize(size_t newsize);
|
||||
void append(const char* data, size_t len);
|
||||
void append(const char* data);
|
||||
void append(const string_base& s);
|
||||
|
||||
private:
|
||||
string_intermediary& _copy_string(const char* s, size_t len){
|
||||
if(!len){
|
||||
Allocator::free(m_data);
|
||||
m_length = 0;
|
||||
return *this;
|
||||
}
|
||||
if(len <= m_length){
|
||||
strcpy(m_data, s);
|
||||
}else{
|
||||
Allocator::free(m_data);
|
||||
m_data = reinterpret_cast<char*>(Allocator::copy(s, len+1));
|
||||
if(!m_data){
|
||||
m_length = 0;
|
||||
return *this;
|
||||
}
|
||||
}
|
||||
m_length = len;
|
||||
return *this;
|
||||
}
|
||||
template<class Tup, size_t I = 0>
|
||||
static void _assign(char* dest, Tup&& t, size_t offset){
|
||||
memcpy(dest+offset, std::get<I>(t), std::get<I+1>(t));
|
||||
if constexpr(I+2 < std::tuple_size<Tup>::value){
|
||||
_assign<Tup,I+2>(dest, std::forward<Tup>(t), offset+std::get<I+1>(t));
|
||||
}
|
||||
}
|
||||
string_intermediary& _copy_string(const char* s, size_t len);
|
||||
};
|
||||
|
||||
|
||||
|
||||
//check for member function 'length'
|
||||
namespace detail{
|
||||
template<class T>
|
||||
struct has_len{
|
||||
template<class U, class V>
|
||||
struct check;
|
||||
|
||||
template<class U>
|
||||
static std::true_type test(check<U,decltype(&U::length)>*);
|
||||
template<class U>
|
||||
static std::false_type test(...);
|
||||
|
||||
static constexpr bool value = std::is_same<std::true_type,decltype(test<T>(0))>::value;
|
||||
};
|
||||
|
||||
}
|
||||
|
||||
|
||||
|
||||
//Like an expression template but not really
|
||||
template<class Left, class Right>
|
||||
class string_cat_expr : public string_expr
|
||||
@@ -289,66 +155,56 @@ namespace raii{
|
||||
|
||||
public:
|
||||
template<class T, class U>
|
||||
constexpr string_cat_expr(T&& l, U&& r):
|
||||
m_l(std::forward<T>(l)),
|
||||
m_r(std::forward<U>(r)){}
|
||||
constexpr string_cat_expr(const string_cat_expr& s):
|
||||
m_l(std::forward<Left>(s.m_l)),
|
||||
m_r(std::forward<Right>(s.m_r)){}
|
||||
constexpr string_cat_expr(string_cat_expr&& s):
|
||||
m_l(std::forward<Left>(s.m_l)),
|
||||
m_r(std::forward<Right>(s.m_r)){}
|
||||
constexpr string_cat_expr(T&& l, U&& r);
|
||||
constexpr string_cat_expr(const string_cat_expr& s);
|
||||
constexpr string_cat_expr(string_cat_expr&& s);
|
||||
|
||||
constexpr size_t length(void)const{
|
||||
return _llen() + _rlen();
|
||||
}
|
||||
constexpr auto get(void){
|
||||
return std::tuple_cat(_lget(), _rget());
|
||||
}
|
||||
constexpr size_t length(void)const;
|
||||
template<class Alloc>
|
||||
operator string_intermediary<Alloc>(void);
|
||||
constexpr const Left& left(void)const;
|
||||
constexpr const Right& right(void)const;
|
||||
};
|
||||
|
||||
template<class Targ>
|
||||
struct appender
|
||||
{
|
||||
private:
|
||||
constexpr auto _lget(void){
|
||||
if constexpr(detail::is_string<Left>::value){
|
||||
if constexpr(detail::is_tuple<decltype(m_l.get())>::value){
|
||||
//string_cat_expr
|
||||
return m_l.get();
|
||||
}else{
|
||||
//string_base
|
||||
return std::make_tuple(m_l.get(), m_l.length());
|
||||
}
|
||||
}else{
|
||||
//c string
|
||||
return std::make_tuple(m_l, strlen(m_l));
|
||||
}
|
||||
}
|
||||
constexpr auto _rget(void){
|
||||
if constexpr(detail::is_string<Right>::value){
|
||||
if constexpr(detail::is_tuple<decltype(m_r.get())>::value){
|
||||
return m_r.get();
|
||||
}else{
|
||||
return std::make_tuple(m_r.get(), m_r.length());
|
||||
}
|
||||
}else{
|
||||
return std::make_tuple(m_r, strlen(m_r));
|
||||
}
|
||||
}
|
||||
constexpr size_t _llen(void)const{
|
||||
if constexpr(detail::has_len<typename std::remove_reference<Left>::type>::value){
|
||||
return m_l.length();
|
||||
}else{
|
||||
return strlen(m_l);
|
||||
}
|
||||
}
|
||||
constexpr size_t _rlen(void)const{
|
||||
if constexpr(detail::has_len<typename std::remove_reference<Right>::type>::value){
|
||||
return m_r.length();
|
||||
}else{
|
||||
return strlen(m_r);
|
||||
}
|
||||
}
|
||||
Targ& m_targ;
|
||||
size_t m_pos = 0;
|
||||
public:
|
||||
appender(Targ& t);
|
||||
template<class L, class R>
|
||||
void operator()(const string_cat_expr<L,R>& str);
|
||||
void operator()(const string_base& str);
|
||||
};
|
||||
|
||||
class static_string : public string_base
|
||||
{
|
||||
public:
|
||||
constexpr static_string(void) = default;
|
||||
template<size_t N>
|
||||
constexpr static_string(const char(&str)[N]);
|
||||
constexpr static_string(const char* str, size_t len);
|
||||
static_string(const char* c);
|
||||
constexpr static_string(const static_string& s);
|
||||
constexpr static_string(static_string&& s);
|
||||
~static_string(void) = default;
|
||||
|
||||
static_string& operator=(const char* c);
|
||||
static_string& operator=(const static_string& s);
|
||||
static_string& operator=(static_string&&) = delete;
|
||||
};
|
||||
|
||||
}
|
||||
|
||||
#include "raii/string_base.tpp"
|
||||
|
||||
namespace{
|
||||
constexpr inline raii::static_string operator"" _ss(const char* str, size_t len){
|
||||
return raii::static_string(str, len);
|
||||
}
|
||||
}
|
||||
template<class Str1, class Str2, typename std::enable_if<raii::detail::is_concrete_string<Str1>::value&&raii::detail::is_concrete_string<Str2>::value,void>::type* = nullptr>
|
||||
bool operator==(Str1&& left, Str2&& right){
|
||||
return left && right && left.length() == right.length() && !strcmp(left.get(), right.get());
|
||||
@@ -360,20 +216,20 @@ bool operator!=(Str1&& left, Str2&& right){
|
||||
|
||||
template<class Right, typename std::enable_if<raii::detail::is_string<Right>::value && std::is_rvalue_reference<Right&&>::value,void>::type* = nullptr>
|
||||
constexpr auto operator+(const char* left, Right&& right){
|
||||
return raii::string_cat_expr<const char*,typename std::remove_reference<Right>::type>(left, std::move(right));
|
||||
return raii::string_cat_expr<raii::static_string,typename std::remove_reference<Right>::type>(raii::static_string(left), std::move(right));
|
||||
}
|
||||
template<class Right, typename std::enable_if<raii::detail::is_string<Right>::value && !std::is_rvalue_reference<Right&&>::value,void>::type* = nullptr>
|
||||
constexpr auto operator+(const char* left, Right&& right){
|
||||
return raii::string_cat_expr<const char*,decltype(std::forward<Right>(right))>(left, std::forward<Right>(right));
|
||||
return raii::string_cat_expr<raii::static_string,decltype(std::forward<Right>(right))>(raii::static_string(left), std::forward<Right>(right));
|
||||
}
|
||||
|
||||
template<class Left, typename std::enable_if<raii::detail::is_string<Left>::value && std::is_rvalue_reference<Left&&>::value,void>::type* = nullptr>
|
||||
constexpr auto operator+(Left&& left, const char* right){
|
||||
return raii::string_cat_expr<typename std::remove_reference<Left>::type,const char*>(std::move(left), right);
|
||||
return raii::string_cat_expr<typename std::remove_reference<Left>::type,raii::static_string>(std::move(left), raii::static_string(right));
|
||||
}
|
||||
template<class Left, typename std::enable_if<raii::detail::is_string<Left>::value && !std::is_rvalue_reference<Left&&>::value,void>::type* = nullptr>
|
||||
constexpr auto operator+(Left&& left, const char* right){
|
||||
return raii::string_cat_expr<decltype(std::forward<Left>(left)),const char*>(std::forward<Left>(left), right);
|
||||
return raii::string_cat_expr<decltype(std::forward<Left>(left)),raii::static_string>(std::forward<Left>(left), raii::static_string(right));
|
||||
}
|
||||
|
||||
template<class Left,
|
||||
|
||||
Reference in New Issue
Block a user