cstr.h

Go to the documentation of this file.

 
#pragma once
#include <stdio.h>
#include <b8/type.h>
#include <cstddef>
#include <cstring>
#include <string>
#include <charconv>
 
extern  size_t  cstr_strlen( const char* sz_ );
extern  int     cstr_strcmp(const char *s1, const char *s2);
template <unsigned int TBYTES>
class cstr{
  char  _buff[ TBYTES ];
 
  void  _set( u32 idx_ , const char* sz ){
    u32 nn=idx_;
    if( sz ){
      for( ; nn<=TBYTES-2 ; ++nn,++sz){
        if( 0 == *sz ) break;
        _buff[ nn ] = *sz;
      }
    }
    _buff[ nn ] = 0x00;
  }
 
public:
  const char* c_str() const {
    return _buff;
  }
 
  const char* data() const {
    return _buff;
  }
 
  void  clear() {
    _buff[0] = 0x00;
  }
 
  void push_back( char cc ){
    char buff[2]={cc,0x00};
    _set(size(),buff);
  }
 
  void pop_back(){
    if(empty()) return;
    const size_t idx =  size()-1;
    _buff[ idx ] = 0x00;
  }
 
  cstr& operator = (const char* sz) {
    _set( 0, sz );
    return *this;
  }
 
  cstr& operator = (const std::string& str) {
    _set( 0, str.c_str() );
    return *this;
  }
 
  cstr& operator += (char ch) {
    char sz[2];
    sz[0]=ch;
    sz[1]=0x00;
    _set(size(),sz);
    return *this;
  }
 
  cstr& operator += (const char* sz) {
    if( nullptr == sz ) return *this;
    _set(size(),sz);
    return *this;
  }
 
  cstr& operator += (const cstr& str ) {
    _set(size(),str.c_str());
    return *this;
  }
 
  cstr operator+(const cstr& s) const {
    cstr ret = *this;
    ret += s;
    return ret;
  }
 
  bool operator == ( const cstr& s ) const {
    return cstr_strcmp( this->c_str(), s.c_str()) == 0;
  }
 
  char at( u32 pos ) const {
    if( pos < size()){
      return _buff[pos];
    }
    return 0x00;
  }
 
  size_t size() const{
    return cstr_strlen( _buff );
  }
 
  bool  empty() const{
    return  0 == size() ? true : false;
  }
  cstr( const char* sz ){ _set(0, sz ); }
  cstr(){ _set(0,""); }
};
 
using str8  = cstr<8>;
using str16 = cstr<16>;
using str32 = cstr<32>;
using str64 = cstr<64>;
 
struct cmp_str {
   bool operator()(const str8& a, const str8& b) const {
      return cstr_strcmp(a.c_str(), b.c_str()) < 0;
   }
   bool operator()(const str16& a, const str16& b) const {
      return cstr_strcmp(a.c_str(), b.c_str()) < 0;
   }
   bool operator()(const str32& a, const str32& b) const {
      return cstr_strcmp(a.c_str(), b.c_str()) < 0;
   }
   bool operator()(const str64& a, const str64& b) const {
      return cstr_strcmp(a.c_str(), b.c_str()) < 0;
   }
};
 
inline  std::string tostr( const str8 & x_ ){ return x_.c_str(); }
inline  std::string tostr( const str16& x_ ){ return x_.c_str(); }
inline  std::string tostr( const str32& x_ ){ return x_.c_str(); }
inline  std::string tostr( const str64& x_ ){ return x_.c_str(); }
 
template<typename String, typename T>
std::from_chars_result from_chars(const String& str, T& value) {
    return std::from_chars(str.data(), str.data() + str.size(), value);
}