Implemented raii::binary to a usable level and polished the raii::string family a bit better.

This commit is contained in:
rexy712
2019-09-18 14:29:57 -07:00
parent 57ed5d979f
commit 60b380f14e
13 changed files with 334 additions and 220 deletions
+101 -57
View File
@@ -64,72 +64,31 @@ namespace raii{
protected:
constexpr string_base(void) = default;
constexpr string_base(size_t len):
m_length(len){}
//Initialize without copying
constexpr string_base(char* data, size_t len):
m_length(len), m_data(data){}
//Allocate without assigning
string_base(size_t len);
//Copy ctor (do nothing)
string_base(const string_base&){}
~string_base(void) = default;
public:
virtual ~string_base(void) = default;
public:
//Copy from c string
string_base& operator=(const char* c);
//Copy from other string_base
string_base& operator=(const string_base& s);
//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 = _allocate(len+1);
_assign(tmp, t.get(), 0);
_free(m_data);
}else{
tmp = m_data;
_assign(tmp, t.get(), 0);
}
m_data = tmp;
m_data[len] = 0;
m_length = len;
return *this;
}
//Replace managed pointer. Frees existing value
void reset(char* val = nullptr);
//Stop managing stored pointer. Does not free.
char* release(void);
bool resize(size_t newsize);
//Length of string not including null terminator
constexpr size_t length(void)const{return m_length;}
//direct access to managed pointer
constexpr char* get(void){return m_data;}
constexpr const char* get(void)const{return m_data;}
operator char*(void);
operator const char*(void)const;
constexpr operator char*(void){return m_data;}
constexpr operator const char*(void)const{return m_data;}
//true if m_data is not null
operator bool(void)const;
constexpr operator bool(void)const{return m_data;}
char& operator[](size_t i);
const char& operator[](size_t i)const;
protected:
string_base& _copy_string(const char* s, size_t len);
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));
}
}
private:
virtual char* _allocate(size_t)const = 0;
virtual void _free(char*)const = 0;
virtual char* _copy(const char*, size_t)const = 0;
};
@@ -181,14 +140,43 @@ namespace raii{
Allocator::free(m_data);
}
string_intermediary& operator=(const string_intermediary&) = default;
string_intermediary& operator=(const string_intermediary& s){
string_intermediary tmp(s);
std::swap(m_data, tmp.m_data);
m_length = tmp.m_length;
return *this;
}
string_intermediary& operator=(string_intermediary&& s){
std::swap(m_data, s.m_data);
m_length = s.m_length;
return *this;
}
using string_base::operator=;
//Copy from c string
string_intermediary& operator=(const char* c){
return _copy_string(c, strlen(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());
@@ -205,15 +193,67 @@ namespace raii{
return tmp;
}
//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;
}
private:
char* _allocate(size_t len)const override final{
return reinterpret_cast<char*>(Allocator::allocate(len));
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;
}
void _free(char* ptr)const override final{
Allocator::free(ptr);
}
char* _copy(const char* ptr, size_t len)const override final{
return reinterpret_cast<char*>(Allocator::copy(ptr, len));
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));
}
}
};
@@ -338,4 +378,8 @@ decltype(auto) operator+=(Left& l, const char* r){
return l = (l + r);
}
#ifdef RAII_BINARY_HPP
#include "raii/binary_string_conv.hpp"
#endif
#endif