Implemented raii::binary to a usable level and polished the raii::string family a bit better.
This commit is contained in:
+101
-57
@@ -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
|
||||
|
||||
Reference in New Issue
Block a user