string.h

Go to the documentation of this file.

// Copyright (C) 2006-2014 David Sugar, Tycho Softworks.
// Copyright (C) 2015 Cherokees of Idaho.
//
// This file is part of GNU uCommon C++.
//
// GNU uCommon C++ is free software: you can redistribute it and/or modify
// it under the terms of the GNU Lesser General Public License as published
// by the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// GNU uCommon C++ is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU Lesser General Public License for more details.
//
// You should have received a copy of the GNU Lesser General Public License
// along with GNU uCommon C++.  If not, see <http://www.gnu.org/licenses/>.
 
#ifndef _UCOMMON_STRING_H_
#define _UCOMMON_STRING_H_
 
#ifndef _UCOMMON_CPR_H_
#include <ucommon/cpr.h>
#endif
 
#ifndef _UCOMMON_GENERICS_H_
#include <ucommon/generics.h>
#endif
 
#ifndef _UCOMMON_PROTOCOLS_H_
#include <ucommon/protocols.h>
#endif
 
#ifndef _UCOMMON_OBJECT_H_
#include <ucommon/object.h>
#endif
 
#include <stdio.h>
#include <string.h>
#include <stdarg.h>
 
#ifdef  HAVE_DIRENT_H
#include <dirent.h>
#endif
 
#define PGP_B64_WIDTH   64
#define MIME_B64_WIDTH  76
 
namespace ucommon {
 
class __EXPORT String : public __PROTOCOL ObjectProtocol
{
protected:
public:
    enum {
        SENSITIVE = 0x00,
        INSENSITIVE = 0x01
    };
 
    class __EXPORT regex
    {
    private:
        void *object;
        void *results;
        size_t count;
 
        __DELETE_COPY(regex);
 
    public:
        regex(const char *pattern, size_t size = 1);
        regex(size_t size = 1);
        ~regex();
 
        size_t offset(unsigned member);
        size_t size(unsigned member);
 
        inline size_t members(void) const {
            return count;
        }
 
        bool match(const char *text, unsigned flags = 0);
 
        regex& operator=(const char *string);
 
        bool operator*=(const char *string);
 
        operator bool() const {
            return object != NULL;
        }
 
        bool operator!() const {
            return object == NULL;
        }
    };
 
    class __EXPORT cstring : public CountedObject
    {
    private:
        __DELETE_COPY(cstring);
 
    protected:
        virtual void dealloc(void) __OVERRIDE;
 
    public:
#pragma pack(1)
        size_t max;  
        size_t len;  
        char text[1];   
#pragma pack()
 
        cstring(size_t size);
 
        void clear(size_t offset);
 
        void set(size_t offset, const char *text, size_t size);
 
        void set(const char *text);
 
        void add(const char *text);
 
        void add(char character);
 
        void fix(void);
 
        void inc(size_t number);
 
        void dec(size_t number);
    };
 
protected:
    cstring *str;  
    cstring *create(size_t size) const;
 
public:
    virtual int compare(const char *string) const;
 
protected:
    bool equal(const char *string) const;
 
    virtual void retain(void) __OVERRIDE;
 
    virtual void release(void) __OVERRIDE;
 
    virtual cstring *c_copy(void) const;
 
    virtual void cow(size_t size = 0);
 
    size_t getStringSize(void) const;
 
public:
    const static size_t npos = ((size_t)-1);
    const static char eos = '\0';
 
    String();
 
    String(size_t size);
 
    String(size_t size, const char *format, ...);
 
 
    String(const char *text);
 
    String(const char *text, size_t size);
 
    String(const char *text, const char *end);
 
    String(const String& existing);
 
    virtual ~String();
 
    String get(size_t offset, size_t size = 0) const;
 
    int scanf(const char *format, ...) __SCANF(2, 3);
 
    int vscanf(const char *format, va_list args) __SCANF(2, 0);
 
    size_t printf(const char *format, ...) __PRINTF(2, 3);
 
    size_t vprintf(const char *format, va_list args) __PRINTF(2, 0);
 
    char *data(void);
 
    inline char *c_mem() {
        return data();
    }
 
    const char *c_str(void) const;
 
    virtual bool resize(size_t size);
 
    void set(const char *text);
 
    void set(size_t offset, const char *text, size_t size = 0);
 
    void set(const char *text, char overflow, size_t offset, size_t size = 0);
 
    void rset(const char *text, char overflow, size_t offset, size_t size = 0);
 
    void add(const char *text);
 
    void add(char character);
 
    void trim(const char *list);
 
    inline void trim(size_t count = 1) {
        operator+=(count);
    }
 
    void chop(const char *list);
 
    inline void chop(size_t count = 1) {
        operator-=(count);
    }
 
    void strip(const char *list);
 
    bool unquote(const char *quote);
 
    void cut(size_t offset, size_t size = 0);
 
    void paste(size_t offset, const char *text, size_t size = 0);
 
    void clear(size_t offset);
 
    void clear(void);
 
    void upper(void);
 
    void lower(void);
 
    void erase(void);
 
    size_t ccount(const char *list) const;
 
    size_t count(void) const;
 
    size_t size(void) const;
 
    size_t offset(const char *pointer) const;
 
    char at(int position) const;
 
    const char *begin(void) const;
 
    const char *end(void) const;
 
    const char *skip(const char *list, size_t offset = 0) const;
 
    const char *rskip(const char *list, size_t offset = npos) const;
 
    const char *search(const char *string, unsigned instance = 0, unsigned flags = 0) const;
 
    const char *search(regex& expr, unsigned instance = 0, unsigned flags = 0) const;
 
    unsigned replace(const char *string, const char *text = NULL, unsigned flags = 0);
 
    unsigned replace(regex& expr, const char *text = NULL, unsigned flags = 0);
 
    const char *find(const char *list, size_t offset = 0) const;
 
    const char *rfind(const char *list, size_t offset = npos) const;
 
    void split(const char *pointer);
 
    void split(size_t offset);
 
    void fill(size_t size, char fill);
 
    void rsplit(const char *pointer);
 
    void rsplit(size_t offset);
 
    const char *chr(char character) const;
 
    const char *rchr(char character) const;
 
    size_t len(void) const;
 
    inline operator const char *() const {
        return c_str();
    }
 
    inline const char *operator*() const {
        return c_str();
    }
 
    bool full(void) const;
 
    String operator()(int offset, size_t size) const;
 
    inline String left(size_t size) const {
        return operator()(0, size);
    }
 
    inline String right(size_t offset) const {
        return operator()(-((int)offset), 0);
    }
 
    inline String copy(size_t offset, size_t size) const {
        return operator()((int)offset, size);
    }
 
    const char *operator()(int offset) const;
 
    const char operator[](int offset) const;
 
    bool operator!() const;
 
    operator bool() const;
 
    String& operator^=(const String& object);
 
    String& operator|=(const char *text);
 
    String& operator&=(const char *text);
 
    String& operator+=(const char *text);
 
    String& operator^=(const char *text);
 
    const String operator+(const char *text) const;
 
    String& operator|(const char *text);
 
    String& operator&(const char *text);
 
    String& operator=(const String& object);
 
    bool operator*=(const char *substring);
 
    bool operator*=(regex& expr);
 
    String& operator=(const char *text);
 
    String& operator++(void);
 
    String& operator+=(size_t number);
 
    String& operator--(void);
 
    String& operator-=(size_t number);
 
    String& operator*=(size_t number);
 
    bool operator==(const char *text) const;
 
    bool operator!=(const char *text) const;
 
    bool operator<(const char *text) const;
 
    bool operator<=(const char *text) const;
 
    bool operator>(const char *text) const;
 
    bool operator>=(const char *text) const;
 
    inline String& operator<<(const char *text) {
        add(text); return *this;
    }
 
    inline String& operator<<(char code) {
        add(code); return *this;
    }
 
    String &operator%(short& value);
 
    String &operator%(unsigned short& value);
 
    String &operator%(long& value);
 
    String &operator%(unsigned long& value);
 
    String &operator%(double& value);
 
    String &operator%(const char *text);
 
    static void swap(String& object1, String& object2);
 
    static void fix(String& object);
 
    static bool check(const char *string, size_t maximum, size_t minimum = 0);
 
    static void erase(char *text);
 
    static void lower(char *text);
 
    static void upper(char *text);
 
    static char *token(char *text, char **last, const char *list, const char *quote = NULL, const char *end = NULL);
 
    static char *skip(char *text, const char *list);
 
    static char *rskip(char *text, const char *list);
 
    static char *unquote(char *text, const char *quote);
 
    static char *rset(char *buffer, size_t size, const char *text);
 
    static char *set(char *buffer, size_t size, const char *text);
 
    static char *set(char *buffer, size_t size, const char *text, size_t max);
 
    static char *add(char *buffer, size_t size, const char *text);
 
    static char *add(char *buffer, size_t size, const char *text, size_t max);
 
    static const char *ifind(const char *text, const char *key, const char *optional);
 
    static const char *find(const char *text, const char *key, const char *optional);
 
    static size_t count(const char *text);
 
    static int compare(const char *text1, const char *text2);
 
    inline static int collate(const char *text1, const char *text2) {
        return compare(text1, text2);
    }
 
    static bool equal(const char *text1, const char *text2);
 
    static int compare(const char *text1, const char *text2, size_t size);
 
    static bool equal(const char *text1, const char *text2, size_t size);
 
    static bool eq_case(const char *text1, const char *text2);
    
    static bool eq_case(const char *text1, const char *text2, size_t size);
 
    static char *trim(char *text, const char *list);
 
    static char *chop(char *text, const char *list);
 
    static char *strip(char *text, const char *list);
 
    static char *fill(char *text, size_t size, char character);
 
    static unsigned ccount(const char *text, const char *list);
 
    static char *find(char *text, const char *list);
 
    static size_t seek(char *text, const char *list);
 
    static char *rfind(char *text, const char *list);
 
    static char *dup(const char *text);
 
    static char *left(const char *text, size_t size);
 
    static const char *pos(const char *text, ssize_t offset);
 
    inline static char *right(const char *text, size_t size) {
        return dup(pos(text, -(ssize_t)size));
    }
 
    inline static char *copy(const char *text, size_t offset, size_t len) {
        return left(pos(text, (ssize_t)offset), len);
    }
 
    static void cut(char *text, size_t offset, size_t len);
 
    static void paste(char *text, size_t max, size_t offset, const char *data, size_t len = 0);
 
    inline char *token(char **last, const char *list, const char *quote = NULL, const char *end = NULL) {
        return token(data(), last, list, quote, end);
    }
 
    inline double tod(char **pointer = NULL) {
        return strtod(data(), pointer);
    }
 
    inline long tol(char **pointer = NULL) {
        return strtol(data(), pointer, 0);
    }
 
    inline static double tod(const char *text, char **pointer = NULL) {
        return strtod(text, pointer);
    }
 
    inline static long tol(const char *text, char **pointer = NULL) {
        return strtol(text, pointer, 0);
    }
 
    static String b64(const uint8_t *binary, size_t size);
 
    static size_t b64size(size_t size);
 
    static size_t b64encode(char *string, const uint8_t *binary, size_t size, size_t width = 0);
 
    static size_t b64decode(uint8_t *binary, const char *string, size_t size, bool ws = false);
 
    static size_t b64count(const char *str, bool ws = false);
 
    static uint32_t crc24(uint8_t *binary, size_t size);
 
    static uint16_t crc16(uint8_t *binary, size_t size);
 
    static String hex(const uint8_t *binary, size_t size);
 
    static size_t hexdump(const uint8_t *binary, char *string, const char *format);
 
    static size_t hexpack(uint8_t *binary, const char *string, const char *format);
 
    static size_t hex2bin(const char *string, uint8_t *binary, size_t maxsize, bool wsflag = false);
 
    static size_t hexsize(const char *format);
 
    static size_t hexcount(const char *str, bool ws = false);
};
 
class __EXPORT memstring : public String
{
public:
    const static size_t header = sizeof(String::cstring);
 
private:
    bool resize(size_t size) __FINAL;
    void cow(size_t adj = 0) __FINAL;
    void release(void) __FINAL;
 
protected:
    cstring *c_copy(void) const __OVERRIDE;
 
public:
    inline void operator=(String& object) {
        set(object.c_str());
    }
 
    inline void operator=(const char *text) {
        set(text);
    }
 
    memstring(void *memory, size_t size);
 
    ~memstring();
 
    static memstring *create(size_t size);
 
    static memstring *create(MemoryProtocol *pager, size_t size);
};
 
template<size_t S>
class charbuf
{
private:
    char buffer[S];
 
public:
    inline charbuf() {
        buffer[0] = 0;
    }
 
    inline charbuf(const char *text) {
        String::set(buffer, S, text);
    }
 
    inline charbuf(const charbuf& copy) {
        String::set(buffer, S, copy.buffer);
    }
 
    inline void operator=(const char *text) {
        String::set(buffer, S, text);
    }
 
    inline void operator+=(const char *text) {
        String::add(buffer, S, text);
    }
 
    inline operator bool() const {
        return buffer[0];
    }
 
    inline bool operator!() const {
        return buffer[0] == 0;
    }
 
    inline operator char *() {
        return buffer;
    }
 
    inline char *operator*() {
        return buffer;
    }
 
    inline char& operator[](size_t offset) const {
        if(offset >= S)
            __THROW_RANGE("charbuf offset"); 
        return buffer[offset];
    }
 
    inline char *operator()(size_t offset) {
        if(offset >= S)
            __THROW_RANGE("charbuf range");
        return buffer + offset;
    }
 
    inline size_t size(void) const {
        return S;
    }
 
    inline size_t len(void) const {
        return strlen(buffer);
    }
};
 
typedef String string_t;
 
typedef String::regex stringex_t;
 
template<size_t S>
class stringbuf : public memstring
{
private:
    char buffer[sizeof(cstring) + S];
 
public:
    inline stringbuf() : memstring(buffer, S) {}
 
    inline stringbuf(const char *text) : memstring(buffer, S) {
        set(text);
    }
 
    inline void operator=(const char *text) {
        set(text);
    }
 
    inline void operator=(String& object) {
        set(object.c_str());
    }
};
 
inline bool eq(char const *s1, char const *s2) {
    return String::equal(s1, s2);
}
 
inline bool ne(char const *s1, char const *s2) {
    return !String::equal(s1, s2);
}
 
inline bool eq(char const *s1, char const *s2, size_t size) {
    return String::equal(s1, s2, size);
}
 
inline bool ne(char const *s1, char const *s2, size_t size) {
    return !String::equal(s1, s2, size);
}
 
inline bool eq(String &s1, const char *s2) {
    return s1.compare(s2) == 0;
}
 
inline bool ne(String &s1, String &s2) {
    return s1.compare(s2) != 0;
}
 
inline bool lt(String &s1, const char *s2) {
    return s1.compare(s2) < 0;
}
 
inline bool gt(String &s1, const char *s2) {
    return s1.compare(s2) > 0;
}
 
inline bool le(String &s1, const char *s2) {
    return s1.compare(s2) <= 0;
}
 
inline bool ge(String &s1, const char *s2) {
    return s1.compare(s2) >= 0;
}
 
inline bool eq_case(char const *s1, char const *s2)
    {return String::eq_case(s1, s2);}
 
inline bool ne_case(char const *s1, char const *s2)
    {return !String::eq_case(s1, s2);}
 
inline bool eq_case(char const *s1, char const *s2, size_t size) {
    return String::eq_case(s1, s2, size);
}
 
inline String str(const char *string) {
    return (String)string;
}
 
inline String str(String& string) {
    return (String)string;
}
 
inline String str(short value) {
    String temp(16, "%hd", value); return temp;
}
 
inline String str(unsigned short value) {
    String temp(16, "%hu", value); return temp;
}
 
inline String str(long value) {
    String temp(32, "%ld", value); return temp;
}
 
inline String str(unsigned long value) {
    String temp(32, "%lu", value); return temp;
}
 
inline String str(double value) {
    String temp(40, "%f", value); return temp;
}
 
template<>
inline void swap<string_t>(string_t& s1, string_t& s2) {
    String::swap(s1, s2);
}
 
class __EXPORT strdup_t
{
private:
    char *data;
 
public:
    inline strdup_t() {
        data = NULL;
    }
 
    inline strdup_t(char *str) {
        data = str;
    }
 
    inline ~strdup_t() {
        if(data) 
            ::free(data);
    }
 
    inline strdup_t& operator=(char *str) {
        if(data) 
            ::free(data); 
        data = str; 
        return *this;
    }
 
    inline operator bool() const {
        return data != nullptr;
    }
 
    inline bool operator!() const {
        return data == nullptr;
    }
 
    inline operator char*() const {
        return data;
    }
 
    inline const char *c_str(void) const {
        return data;
    }
 
    inline const char *operator*() const {
        return data;
    }
 
    inline char& operator[](int size) {
        return data[size];
    }
 
    inline char *operator+(size_t size) {
        return data + size;
    }
};
 
} // namespace ucommon
 
#endif