BString.h

Go to the documentation of this file.

/*******************************************************************************
 *  BString.h   BString Handling
 *  T.Barnaby,  BEAM Ltd, 29/10/91
 *  Copyright (c) 2022 All Right Reserved, Beam Ltd, https://www.beam.ltd.uk
 *  For license see LICENSE.txt at the root of the beamlib source tree.
 *******************************************************************************
 */
#ifndef BSTRING_H
#define BSTRING_H   1
 
#include    <BTypes.h>
#include    <BRefData.h>
#include    <BList.h>
#include    <BArray.h>
#include    <iostream>
 
class BError;
 
class BString {
public:
            BString();
            BString(const BString& string);
            BString(const char* str);
            BString(const char* str, unsigned int len);
            BString(char ch);
            BString(BInt v);
            BString(BUInt v);
            BString(BUInt64 v);
            BString(double v);
 
            ~BString();
 
    static      BString convert(char ch);           
    static      BString convert(BInt value);            
    static      BString convert(BUInt value);           
    static      BString convert(double value, int eFormat = 0); 
    static      BString convert(BUInt64 value);         
    static      BString convertHex(BInt value);         
    static      BString convertHex(BUInt value);        
 
    BString     copy() const;                       
    
    int     len() const;                        
    const char* retStr() const;                     
    const char* str() const;                        
    char*       retStrDup() const;                  
    int     retInt() const;                     
    unsigned int    retUInt() const;                    
    double      retDouble() const;                  
    BFloat64    retFloat64() const;                 
 
    int     compare(const BString& string) const;           
    int     compareWild(const BString& string) const;       
    int     compareWildExpression(const BString& string) const; 
    int     compareRegex(const BString& pattern, int ignoreCase = 0) const;     
    BString&    truncate(int len);                  
    BString&    pad(int len);                       
    void        clear();                        
    
    BString&    toUpper();                      
    BString&    toLower();                      
    BString     lowerFirst();                       
    void        removeNL();                     
    BString     justify(int leftMargin, int width);         
    BString     fixedLen(int length, int rightJustify = 0);     
    BString     firstLine();                        
    BString     translateChar(char ch, BString replace = " ");      
    BString     reverse() const;                    
    
    BString     subString(int start, int len) const;            
    int     del(int start, int len);                
    int     insert(int start, BString str);             
    int     append(const BString& str);             
    BString     add(const BString& str) const;              
    BString&    printf(const char* fmt, ...) ;              
 
    int     find(char ch) const;                    
    int     find(BString str) const;                
    int     findReverse(char ch) const;             
    
    BString     csvEncode() const;                  
    BString&    csvDecode(const BString str);               
    
    BString     base64Encode() const;                   
    BError      base64Decode(BString& str) const;           
    
 
    BList<BString>  getTokenList(BString separators);           
    BList<BString>  getTokenList(char separator);               
    BString     removeSeparators(BString separators);           
    BString     pullToken(BString terminators);             
    BString     pullSeparators(BString separators);         
    BString     pullWord();                     
    BString     pullLine();                     
    BList<BString>  split(char splitChar);                  
 
    // Filename operations
    BString     dirname();                      
    BString     filename();                     
    BString     basename();                     
    BString     extension();                        
    BString     extensionFull();                    
    
    // Misc functions
    BUInt32     hash() const;                       
    char&       get(int pos);                       
    const char& get(int pos) const;                 
    
    /* Operator functions */
    BString&    operator=(const BString& string);
    char&       operator[](int pos);
    
    int     operator==(const BString& s) const{
                return (compare(s) == 0);
            }
    int     operator==(const char* s) const{
                return (compare(s) == 0);
            }
    int     operator>(const BString& s) const{
                return (compare(s) > 0);
            }
    int     operator>(const char* s) const{
                return (compare(s) > 0);
            }
    int     operator<(const BString& s) const{
                return (compare(s) < 0);
            }
    int     operator<(const char* s) const{
                return (compare(s) < 0);
            }
    int     operator>=(const BString& s) const{
                return (compare(s) >= 0);
            }
    int     operator<=(const BString& s) const{
                return (compare(s) <= 0);
            }
    int     operator!=(const BString& s) const{
                return (compare(s) != 0);
            }
    int     operator!=(const char* s) const{
                return (compare(s) != 0);
            }
    BString     operator+(const BString& s) const {
                return add(s);
            }
    BString     operator+(const char* s) const {
                return add(s);
            }
    BString     operator+=(const BString& s){
                *this = add(s);
                return *this;
            }
    BString     operator+=(const char* s){
                *this = add(s);
                return *this;
            }
            
    /* Special operators */
    BString     operator+(char ch) const {
                return add(convert(ch));
            }
    BString     operator+(BInt i) const {
                return add(convert(i));
            }
    BString     operator+(BUInt i) const {
                return add(convert(i));
            }
    BString     operator+(BUInt64 i) const {
                return add(convert(i));
            }
            operator const char* () const {
                return retStr();
            }
#ifdef QSTRING_H
    // QT support
            BString(const QString& str){
#if QT_VERSION >= 0x040000
                init(str.toLatin1());
#else
                init(str);
#endif
            }
#ifndef ZAP
            operator QString (){        // QString support
                return QString(retStr());
            }
#endif
#endif
 
    // For backwards compatibility
    BString     field(int field) const;         
    char**      fields();               
 
protected:
    BRefData*   ostr;                   
 
private:
    void        init(const char* str);
    int     inString(int pos) const;
    int     isSpace(char ch) const;
};
 
// std::Stream Functions
std::ostream& operator<<(std::ostream& o, BString& s);
std::istream& operator>>(std::istream& i, BString& s);
 
// List and array functions
typedef BList<BString>  BStringList;
typedef BArray<BString> BStringArray;
 
int bstringListinList(BStringList& l, BString s);
 
BString blistToString(const BStringList& list);         
BStringList bstringToList(BString str, int stripSpaces = 0);    
BStringList charToList(const char** str);
 
BString barrayToString(const BStringArray& list);       
BStringArray bstringToArray(BString str, int stripSpaces = 0);  
BStringArray charToArray(const char** str);
 
// String conversion functions
void toBString(BString& v, BString& s);
void toBString(BStringList& v, BString& s);
void toBString(BInt32& v, BString& s);
void toBString(BUInt32& v, BString& s);
void toBString(BUInt64& v, BString& s);
void toBString(BFloat64& v, BString& s);
void fromBString(BString& s, BString& v);
void fromBString(BString& s, BStringList& v);
void fromBString(BString& s, BInt32& v);
void fromBString(BString& s, BUInt32& v);
void fromBString(BString& s, BUInt64& v);
void fromBString(BString& s, BFloat64& v);
 
// CString functions
inline char from_hex(char ch){
    return isdigit(ch) ? ch - '0' : tolower(ch) - 'a' + 10;
}
 
inline char to_hex(char code){
    static char hex[] = "0123456789abcdef";
    return hex[code & 15];
}
 
char* bstrncpy(char* dest, const char* src, size_t n);
char* bstrtrim(char* str);
const char* intToString(char* str, BUInt strLen, int value, int base = 10);
const char* int64ToString(char* str, BUInt strLen, BInt64 value, int base = 10);
const char* floatToString(char *str, BUInt strLen, BFloat32 f, BUInt precision);
 
#endif