Compiler Explorer

Source code

/*
    All rights reserved: Maysara Khalid Elshewehy [github.com/xeerx]
    Created on: 4 Apr 2022
    Commercial use of this file is prohibited without written permission
*/

#ifndef XCPP_XSTRING_H
#define XCPP_XSTRING_H
#include <string.h>                // strlen
#include <cstdlib>                 // calloc, realloc, free
#include <initializer_list>        // initializer_list
#include <stddef.h>                // size_t
#include <stdint.h>                // SIZE_MAX
#include <ostream>                 // ostream operator

// xstring macros
#define xnpos            SIZE_MAX  // max size of size_t, when error, return to it
#define _xs_extra_space_ 25        // the extra space size in heap memory

// xstring helpers
namespace x::hlpr
{
    // [INTEGER LENGTH]
    #define __sig_int_len__(t) (t int src)                   { unsigned t int len = src < 0 ? 1 : 0;  while(true) { src /= 10; if(src != 0) len ++; else return len; } }
    #define __uns_int_len__(t) (unsigned t int src)          { unsigned t int len = 0;  while(true) { src /= 10; if(src != 0) len ++; else return len; } }
    unsigned int intlen __sig_int_len__() 
    unsigned int uintlen __uns_int_len__() 
    unsigned short int sintlen __sig_int_len__(short) 
    unsigned short int usintlen __uns_int_len__(short) 
    unsigned long lintlen __sig_int_len__(long) 
    unsigned long ulintlen __uns_int_len__(long) 
    unsigned long long llintlen __sig_int_len__(long long) 
    unsigned long long ullintlen __uns_int_len__(long long)

// [INTEGER TO STRING]
    #define __sig_int_str__(s,t) (char *ref, s src, unsigned s len = 0) { if(src == 0){ ref[0] = '0'; ref[1] = '\0'; return; } if (len == 0) len = t(src) + 1; if (src < 0) { src = src * -1; ref[0] = '-'; } len--; ref[len + 1] = '\0'; while (src > 0) { ref[len] = src % 10 + '0'; src /= 10; len--; } } 
    #define __uns_int_str__(s,t) (char *ref, unsigned s src, unsigned s len = 0) { if(src == 0){ ref[0] = '0'; ref[1] = '\0'; return; } if(len == 0) len = t(src) +1; len --; ref[len+1] = '\0'; while(src >= 1) { ref[len] = src % 10 + '0'; src /= 10; len --; } }
    
    void intstr    __sig_int_str__(int,intlen) 
    void uintstr   __uns_int_str__(int ,uintlen)
  
    void sintstr   __sig_int_str__(short int,sintlen) 
    void usintstr  __uns_int_str__(short int ,usintlen)

void lintstr   __sig_int_str__(long int,lintlen)
    void ulintstr  __uns_int_str__(long int ,ulintlen)

void llintstr  __sig_int_str__(long long int,llintlen) 
    void ullintstr __uns_int_str__(long long int ,ullintlen)

// [INTEGER MACROS]
    #define __int_str_shortcut__(src,l,lfunc,sfunc)  unsigned l __len = x::hlpr::lfunc(src) +1; char * __ref = new char[__len+1]; x::hlpr::sfunc(__ref,src,__len); delete [] __ref;
    
    #define __intstr__(src)    __int_str_shortcut__(src,int,intlen,intstr)
    #define __uintstr__(src)   __int_str_shortcut__(src,int,uintlen,uintstr)

#define __sintstr__(src)   __int_str_shortcut__(src,short int,sintlen,sintstr)
    #define __usintstr__(src)  __int_str_shortcut__(src,short int,usintlen,usintstr)
    
    #define __lintstr__(src)   __int_str_shortcut__(src,long int,lintlen,lintstr)
    #define __ulintstr__(src)  __int_str_shortcut__(src,long int,ulintlen,ulintstr)

#define __llintstr__(src)  __int_str_shortcut__(src,long long int,llintlen,llintstr)
    #define __ullintstr__(src) __int_str_shortcut__(src,long long int,ullintlen,ullintstr)

// [DECIMAL LENGTH]
    #define __decimal_len__(t) (t src, unsigned short int max = 6) { unsigned int len = 0, ilen = 0, i = 0; int isrc = (int)src; if(src < 0) src *= -1; if(src > 0) { ilen = intlen(isrc); src -= isrc;}  while(i < max && (isrc - src) != 0) { src = src * 10; i++; len ++; } return len + ilen; }
    unsigned int floatlen   __decimal_len__(float)
    unsigned int doublelen  __decimal_len__(double)
    unsigned int ldoublelen __decimal_len__(long double)
    
    // [DECIMAL TO STRING]
    #define __decimal_str__(t,lfunc) (char *ref, t src, unsigned short int max = 0, bool setmax = false) { bool neg = false; if(src < 0) { src = src * -1; neg = true; } if(src == 0) { ref[0] = '0'; ref[1] = '.'; ref[2] = '0'; ref[3] = '\0'; } int numbers = src, digit = 0, numberslen = x::hlpr::intlen(numbers), index = numberslen + 1; long pow_value = 0; unsigned int flen = x::hlpr::lfunc(src); if(numberslen > 0) flen -= numberslen; if(!max) max = flen; else if(setmax) max -= numberslen; max --; x::hlpr::intstr(ref,numbers,index); ref[index] = '.'; index ++; if(numbers == src) { ref[index] = '0'; index ++; if(neg) { unsigned int bi = index; ref[bi] = '\0'; while (index >= 0) { ref[index+1] = ref[index]; index --; } ref[0] = '-'; return bi +1; } else ref[index] = '\0'; return index; }  t fraction_part  = src - numbers; t tmp1 = fraction_part,  tmp =0; for( int i= 1; i < max + 2; i++) { pow_value = 10; tmp = tmp1 * pow_value; digit = tmp; ref[index] = digit +48; tmp1 = tmp - digit; index ++; } int temp_index = index -1; while(temp_index >= 0) { if(ref[temp_index] == '0') { ref[temp_index] = '\0'; index --;  } else break; temp_index --; } temp_index = index -1; while(temp_index >= 0) { if(ref[temp_index] == ref[temp_index-1]) { ref[temp_index] = '\0'; index --;  } else break; temp_index --; } if(neg) { unsigned int bi = index; ref[bi] = '\0'; while (index >= 0) { ref[index+1] = ref[index]; index --; } ref[0] = '-'; return bi+1; } else ref[index] = '\0'; return index;}
    unsigned int  floatstr   __decimal_str__(float,floatlen)
    unsigned int  doublestr  __decimal_str__(double,doublelen)
    unsigned int  ldoublestr __decimal_str__(long double,ldoublelen)

// [DECIMAL MACROS]
    #define __decimal_str_shortcut__(src,lfunc,sfunc,max)  unsigned short int __len = x::hlpr::lfunc(src,max) +1; char * __ref = new char[__len+4];__len = x::hlpr::sfunc(__ref,src,__len,true); delete [] __ref;
    #define __floatstr__(src)   __decimal_str_shortcut__(src,floatlen,floatstr,max)
    #define __doublestr__(src)  __decimal_str_shortcut__(src,doublelen,doublestr,max)
    #define __ldoublestr__(src) __decimal_str_shortcut__(src,ldoublelen,ldoublestr,max)
}

// xstring class
namespace x
{
    // some variables used to return to error
    char xstr_null_char = '\0';

class xstring
    {
        public:
        
        // data
        char    *src  = nullptr;   // pointer to character array wich contains to value of object
        size_t   len  = 0;         // length of src, zero means empty
        size_t   siz  = 0;         // size of src in heap memory

// constructor -> default empty
        xstring         ()                                       {                                                                  }

xstring         (const char *ref, size_t rlen = 0)       { set(ref,rlen);                                                   }
        xstring         (char        ref)                        { set(ref);                                                        }

xstring         (bool        ref)                        { set(ref);                                                        }

xstring         (                   int ref)             { set(ref);                                                        }
        xstring         (unsigned           int ref)             { set(ref);                                                        }

xstring         (short              int ref)             { set(ref);                                                        }
        xstring         (unsigned short     int ref)             { set(ref);                                                        }

xstring         (long               int ref)             { set(ref);                                                        }
        xstring         (unsigned long      int ref)             { set(ref);                                                        }
        
        xstring         (long long          int ref)             { set(ref);                                                        }
        xstring         (unsigned long long int ref)             { set(ref);                                                        }

xstring         (float       ref,unsigned short max = 1) { set(ref,max);                                                    }
        xstring         (double      ref,unsigned short max = 1) { set(ref,max);                                                    }
        xstring         (long double ref,unsigned short max = 1) { set(ref,max);                                                    }

xstring         (xstring    &ref)                        { set(ref);                                                        }
        xstring         (const xstring    &ref)                  { set(ref);                                                        }

template <typename T>
        xstring         (std::initializer_list<T> ref)           { for(auto i:ref) append(i);                                       }

// set
        bool set        (const char *ref, size_t rlen);
        bool set        (char        ref)                        { char __ref[] = {ref}; return set(__ref, 1);                      }

bool set        (bool        ref)                        { return set(ref ? "1" : "0", 1);                                  }

bool set        (                   int ref)             { __intstr__     (ref) return set(__ref, __len);                   }
        bool set        (unsigned           int ref)             { __uintstr__    (ref) return set(__ref, __len);                   }

bool set        (short              int ref)             { __sintstr__    (ref) return set(__ref, __len);                   }
        bool set        (unsigned short     int ref)             { __usintstr__   (ref) return set(__ref, __len);                   }

bool set        (long               int ref)             { __lintstr__    (ref) return set(__ref, __len);                   }
        bool set        (unsigned long      int ref)             { __ulintstr__   (ref) return set(__ref, __len);                   }

bool set        (long long          int ref)             { __llintstr__   (ref) return set(__ref, __len);                   }
        bool set        (unsigned long long int ref)             { __ullintstr__  (ref) return set(__ref, __len);                   }

bool set        (float       ref,unsigned short max = 1) { __floatstr__   (ref) return set(__ref, __len);                   }
        bool set        (double      ref,unsigned short max = 1) { __doublestr__  (ref) return set(__ref, __len);                   }
        bool set        (long double ref,unsigned short max = 1) { __ldoublestr__ (ref) return set(__ref, __len);                   }
        
        bool set        (xstring    &ref)                        { if(&ref != this) return set(ref.src, ref.len); else return false;  }
        bool set        (const xstring    &ref)                  { if(&ref != this) return set(ref.src, ref.len); else return false;  }

template <typename T>
        bool set        (std::initializer_list<T> ref)           { reset(); for(auto i:ref) if(!append(i)) return false; return true; }

template <typename T> 
        bool operator = (T ref) { return set(ref); }

template <typename T> 
        bool operator = (std::initializer_list<T> ref) { return set(ref); }

// append
        bool append  (const char *ref, size_t rlen);
        bool append  (char        ref)                        { char __ref[] = {ref}; return append(__ref, 1);                      }

bool append  (bool        ref)                        { return append(ref ? "1" : "0", 1);                                  }

bool append  (                   int ref)             { __intstr__     (ref) return append(__ref, __len);                   }
        bool append  (unsigned           int ref)             { __uintstr__    (ref) return append(__ref, __len);                   }

bool append  (short              int ref)             { __sintstr__    (ref) return append(__ref, __len);                   }
        bool append  (unsigned short     int ref)             { __usintstr__   (ref) return append(__ref, __len);                   }

bool append  (long               int ref)             { __lintstr__    (ref) return append(__ref, __len);                   }
        bool append  (unsigned long      int ref)             { __ulintstr__   (ref) return append(__ref, __len);                   }

bool append  (long long          int ref)             { __llintstr__   (ref) return append(__ref, __len);                   }
        bool append  (unsigned long long int ref)             { __ullintstr__  (ref) return append(__ref, __len);                   }

bool append  (float       ref,unsigned short max = 1) { __floatstr__   (ref) return append(__ref, __len);                   }
        bool append  (double      ref,unsigned short max = 1) { __doublestr__  (ref) return append(__ref, __len);                   }
        bool append  (long double ref,unsigned short max = 1) { __ldoublestr__ (ref) return append(__ref, __len);                   }
        
        bool append  (xstring    &ref)                        { if(&ref != this) return append(ref.src, ref.len); else return false;  }
        bool append  (const xstring    &ref)                  { if(&ref != this) return append(ref.src, ref.len); else return false;  }

template <typename T>
        bool append  (std::initializer_list<T> ref)           { for(auto i:ref) if(!append(i)) return false; return true;           }

template <typename T> 
        bool operator += (T ref)                              { return append(ref);                                                 }

template <typename T> 
        bool operator += (std::initializer_list<T> ref)       { return append(ref);                                                 }
        
        // prepend
        bool prepend    (const char *ref, size_t rlen);
        bool prepend    (char        ref)                        { char __ref[] = {ref}; return prepend(__ref, 1);                  }

bool prepend    (bool        ref)                        { return prepend(ref ? "1" : "0", 1);                              }

bool prepend    (                   int ref)             { __intstr__     (ref) return prepend(__ref, __len);               }
        bool prepend    (unsigned           int ref)             { __uintstr__    (ref) return prepend(__ref, __len);               }

bool prepend    (short              int ref)             { __sintstr__    (ref) return prepend(__ref, __len);               }
        bool prepend    (unsigned short     int ref)             { __usintstr__   (ref) return prepend(__ref, __len);               }

bool prepend    (long               int ref)             { __lintstr__    (ref) return prepend(__ref, __len);               }
        bool prepend    (unsigned long      int ref)             { __ulintstr__   (ref) return prepend(__ref, __len);               }

bool prepend    (long long          int ref)             { __llintstr__   (ref) return prepend(__ref, __len);               }
        bool prepend    (unsigned long long int ref)             { __ullintstr__  (ref) return prepend(__ref, __len);               }

bool prepend    (float       ref,unsigned short max = 1) { __floatstr__   (ref) return prepend(__ref, __len);               }
        bool prepend    (double      ref,unsigned short max = 1) { __doublestr__  (ref) return prepend(__ref, __len);               }
        bool prepend    (long double ref,unsigned short max = 1) { __ldoublestr__ (ref) return prepend(__ref, __len);               }
        
        bool prepend    (xstring    &ref)                        { if(&ref != this) return prepend(ref.src, ref.len); else return false;  }
        bool prepend    (const xstring    &ref)                  { if(&ref != this) return prepend(ref.src, ref.len); else return false;  }

template <typename T>
        bool prepend    (std::initializer_list<T> ref)           { for(auto i:ref) if(!prepend(i)) return false; return true;       }

template <typename T> 
        bool operator |= (T ref)                                 { return prepend(ref);                                             }

template <typename T> 
        bool operator |= (std::initializer_list<T> ref)          { return prepend(ref);                                             }

// print
        friend std::ostream &operator<<(std::ostream &os, const xstring &s) { os << (s.src ? s.src : ""); return (os); }

// insert
        bool          insert (size_t pos, const char *ref, size_t rlen);
        bool          insert (size_t pos, char ref)              { char __ref[] = {ref}; return insert(pos,__ref, 1);               }

// compare between two strings
        bool compare(const char *ref) { return strcmp(src,ref)     == 0;                                                            }
        bool compare(xstring&    ref) { return compare(ref.src);                                                                    }
        bool compare(const xstring&    ref) { return compare(ref.src);                                                              }
        bool compare(      char  ref) { char __ref[] = {ref}; return compare(__ref);                                                }
        bool operator == (const char *ref)          { return compare(ref) == true;                                                  }
        bool operator == (xstring&    ref)          { return compare(ref) == true;                                                  }
        bool operator == (const xstring&    ref)    { return compare(ref) == true;                                                  }
        bool operator == (      char  ref)          { return compare(ref) == true;                                                  }
        
        // no need in C++ 20
        // bool operator != (const char *ref)          { return compare(ref) == false;                                                 }
        // bool operator != (xstring&    ref)          { return compare(ref) == false;                                                 }
        // bool operator != (const xstring&    ref)    { return compare(ref) == false;                                                 }
        // bool operator != (      char  ref)          { return compare(ref) == false;                                                 }

// swap value,len,size between two string objects
        void swap(xstring &ref)
        {
            char     *tmp_src  = src;
            size_t    tmp_len  = len;
            size_t    tmp_siz  = siz;
 
            src  = ref.src;
            len  = ref.len;
            siz  = ref.siz;

ref.src  = tmp_src;
            ref.len  = tmp_len;
            ref.siz  = tmp_siz;
        }

// convert src characters to lower case
        void to_lower() 
        {
            size_t i = 0;
            while(src[i] != '\0') { src[i] = std::tolower(src[i]); i++; }
        }

// convert src characters to upper case
        void to_upper() 
        {
            size_t i = 0;
            while(src[i] != '\0') { src[i] = std::toupper(src[i]); i++; }
        }

// select character by index, return xstr_null_char if not found
        char& getChar(size_t ref) 
        {
            if(ref > len) return xstr_null_char;
            return src[ref];
        } 
        char& operator[](size_t ref) { return getChar(ref); }

// select index by value, start from position, return xnpos if not found
        size_t getIndex(char ref, size_t pos = 0) 
        {
            if(pos > len) return xnpos;
            size_t counter = pos;
            while(counter < len) 
            {
                if(src[counter] == ref) return counter;
                counter ++;
            }
            return xnpos;
        }

// get last character
        char& getLast() { return src[len-1]; }
        
        // remove from value by index
        bool pop(size_t pos = 0, size_t max = 1)
        {
            if(pos >= len) return false;
            if(max > len || max == 0) max = len;

memmove(&src[pos], &src[pos + max], len - pos - 1);
            src[len - 1] = '\0';
            len --;
            return true;
        }

// remove last character using pop(len-1)
        bool pop_last() { return pop(len-1); }

// reverse characters
        void reverse()
        {
            char *tmp = new char[len];
            size_t count = len;
            size_t count_src = 0;
            while(count > 0)
            {
                tmp[count-1] = src[count_src];
                count --;
                count_src ++;
            }
            tmp[len] = '\0';
            memcpy(src,tmp,len+1);
            delete [] tmp;
        }

// check if value is empty by check if length equals zero
        bool empty() { return len == 0; }

// find first matched character in string, start from begin + pos, if failed return to xnpos
        size_t first_of(char  ref, size_t pos = 0)
        {
            if(pos >= len) return xnpos;
            while( src[pos]!=ref && pos < len) pos++;
            return pos == len ? xnpos : pos;
        }

// find last matched character in string, start from end - pos, if failed return to xnpos
        size_t last_of (char  ref, size_t pos = 0)
        {
            if(pos >= len) return xnpos;
            pos = len - pos -1; 
            while(src[pos]!=ref && pos > 0) pos--;
            if(src[pos] == ref) return pos; else return xnpos;
        }

// cut string from [start] to [end] and set to ref
        bool sub(xstring &ref, size_t start = 0, size_t end = 0)
        {
            if(start >= len) start = len -1;
            if(start == end) return false;

if(end == 0 || end >= len) end = len;
            size_t llen = end - start;
            char *res = new char[llen+1];
            size_t pos = 0;

while(start < end) 
            {
                res[pos] = src[start];
                start ++;
                pos ++;
            }
            res[pos] = '\0';
            ref.set(res, llen+1);
            delete [] res;
            return true;
        }

// free memory, set values to zero
        void reset      ()                                       { if(!siz) return; free(src); len = 0; siz = 0;                    }
        
        // destructor
        ~xstring        ()                                       { reset();                                                         }
    };
}

// xstring class functions, i will write long functions here to arrange the file and keep it beautiful
namespace x
{
    /**
     * @brief set value of xstring object
    */
    bool xstring::set        (const char *ref, size_t rlen = 0)
    {
        if(!rlen) rlen = strlen(ref);                // [increase performance] If the length is known, there is no need to recalculate it

if(siz == 0)                                 // alloc space in heap memory to store value
        {
            siz = rlen + _xs_extra_space_;           // [increase performance] extra 25 bytes space to avoid realloc in next times if space is enough
            if(siz >= xnpos - 25) { siz -= rlen + _xs_extra_space_; return false; } // check if size > max size
            src = (char*) calloc(siz, sizeof(char)); // allocate space
            if(src == nullptr) return false;         // check if space is allocated
        }

else if(siz <= rlen)                         // realloc more space to contains the new value
        {
            siz = rlen + _xs_extra_space_;     
            if(siz >= xnpos - 25) { siz -= rlen + _xs_extra_space_; return false; }
            src = (char*) realloc(src, siz * sizeof(char)); 
            if(src == nullptr) return false; 
        }

memcpy(src, ref, rlen+1);                    // copy value from ref
        len = rlen;                                  // update length
        src[len] = '\0';                             // terminate the array
        return true;
    }

/**
     * @brief add value to begin of xstring object
    */
    bool xstring::append  (const char *ref, size_t rlen = 0)
    {
        if(siz == 0) return set(ref,rlen); // if space is null, call set()
        if(!rlen) rlen = strlen(ref);

if(siz <= (len + rlen))            
        {
            siz += rlen + _xs_extra_space_;
            if(siz >= xnpos - 25) { siz -= rlen + _xs_extra_space_; return false; }
            src = (char*) realloc(src, siz * sizeof(char)); 
            if(src == nullptr) return false;
        }

memcpy(src + len, ref, rlen+1);
        len += rlen; 
        src[len] = '\0'; 
        return true;
    }

/**
     * @brief add value to end of xstring object
    */
    bool xstring::prepend (const char *ref, size_t rlen = 0)
    {
        if(siz == 0) return set(ref,rlen);
        if(!rlen) rlen = strlen(ref);

if(siz <= (len + rlen))
        {
            siz += rlen + _xs_extra_space_;
            if(siz >= xnpos - 25) { siz -= rlen + _xs_extra_space_; return false; }
            src = (char*) realloc(src, siz * sizeof(char)); if(src == nullptr) return false;
        }

memmove(src + rlen, src, len);      // move data to rlen pos
        size_t i = 0; 
        while(i < rlen)                     // loop in copy ref to begin of src
        { 
            src[i] = ref[i]; 
            ++i; 
        }
        len += rlen; 
        src[len] = '\0'; 
        return true;
    }
    
    /**
     * @brief add value to position of xstring object
    */
    bool xstring::insert (size_t pos, const char *ref, size_t rlen = 0)
    {
        if(siz == 0) return set(ref,rlen);
        if(pos > len) return false;
        if(!rlen) rlen = strlen(ref);

if(siz <= (len + rlen))
        {
            siz += rlen + _xs_extra_space_;
            if(siz >= xnpos - 25) { siz -= rlen + _xs_extra_space_; return false; }
            src = (char*) realloc(src, siz * sizeof(char)); if(src == nullptr) return false;
        }

memmove(src + rlen, src, len);
        size_t i = 0; while(true) { size_t target = pos == 0 ? (0 + i) : (pos+i); src[target] = ref[i]; if(++i >= rlen) break;; }
        len += rlen; src[len] = '\0'; return true;
    }

}

#endif

#include <iostream>
#include <string>

int main()
{
    using namespace std::literals;

std::cout << "\nStrings:\n";
    std::cout << x::xstring{"abc"} << '\n';
    std::cout << "abc"s << '\n';

std::cout << "\nIntegers:\n";
    std::cout << x::xstring{123} << '\n';
    std::cout << std::to_string(123) << '\n';

std::cout << "\nFloating point:\n";
    std::cout << x::xstring{123.456} << '\n';
    std::cout << std::to_string(123.456) << '\n';
}