unicode.h

Go to the documentation of this file.

// Copyright (C) 2009-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_UNICODE_H_
#define _UCOMMON_UNICODE_H_
 
#ifndef _UCOMMON_STRING_H_
#include <ucommon/string.h>
#endif
 
#ifdef nil
#undef nil
#endif
 
namespace ucommon {
 
typedef int32_t ucs4_t;
 
typedef int16_t ucs2_t;
 
typedef void *unicode_t;
 
class __EXPORT utf8
{
protected:
    inline utf8() {};
 
    inline utf8(const utf8& copy) {};
 
public:
    static const unsigned ucsize;
 
    static const char *nil;
 
    static unsigned size(const char *codepoint);
 
    static size_t count(const char *string);
 
    static char *offset(char *string, ssize_t position);
 
    static ucs4_t codepoint(const char *encoded);
 
    static size_t chars(const unicode_t string);
 
    static size_t chars(ucs4_t character);
 
    static size_t unpack(const unicode_t string, char *text, size_t size);
 
    static size_t pack(unicode_t unicode, const char *cp, size_t len);
 
    static ucs4_t *udup(const char *string);
 
    static ucs2_t *wdup(const char *string);
 
    static const char *find(const char *string, ucs4_t character, size_t start = 0);
 
    static const char *rfind(const char *string, ucs4_t character, size_t end = (size_t)-1l);
 
    static unsigned ccount(const char *string, ucs4_t character);
 
    static ucs4_t get(const char *cp);
 
    static void put(ucs4_t character, char *buf);
};
 
class __EXPORT UString : public String, public utf8
{
protected:
    UString();
 
    UString(size_t size);
 
    UString(const unicode_t text);
 
    UString(const char *text, size_t size);
 
    UString(const unicode_t *text, const unicode_t *end);
 
    UString(const UString& existing);
 
    virtual ~UString();
 
    UString get(size_t codepoint, size_t size = 0) const;
 
    size_t get(unicode_t unicode, size_t size) const;
 
    void set(const unicode_t unicode);
 
    void add(const unicode_t unicode);
 
    ucs4_t at(int position) const;
 
    inline size_t operator()(unicode_t unicode, size_t size) const {
        return get(unicode, size);
    }
 
    UString operator()(int codepoint, size_t size) const;
 
    inline UString left(size_t size) const {
        return operator()(0, size);
    }
 
    inline UString right(size_t offset) const {
        return operator()(-((int)offset), 0);
    }
 
    inline UString copy(size_t offset, size_t size) const {
        return operator()((int)offset, size);
    }
 
    void cut(size_t offset, size_t size = 0);
 
    void paste(size_t offset, const char *text, size_t size = 0);
 
    const char *operator()(int offset) const;
 
    inline ucs4_t operator[](int position) const {
        return UString::at(position);
    }
 
    inline size_t count(void) const {
        return (size_t)utf8::count(str->text);
    }
 
    unsigned ccount(ucs4_t character) const;
 
    const char *find(ucs4_t character, size_t start = 0) const;
 
    const char *rfind(ucs4_t character, size_t end = npos) const;
};
 
class __EXPORT utf8_pointer
{
protected:
    uint8_t *text;
 
public:
    utf8_pointer();
 
    utf8_pointer(const char *string);
 
    utf8_pointer(const utf8_pointer& copy);
 
    utf8_pointer& operator ++();
 
    utf8_pointer& operator --();
 
    utf8_pointer& operator +=(long offset);
 
    utf8_pointer& operator -=(long offset);
 
    utf8_pointer operator+(long offset) const;
 
    utf8_pointer operator-(long offset) const;
 
    inline operator bool() const {
        return text != NULL;
    }
 
    inline bool operator!() const {
        return text == NULL;
    }
 
    ucs4_t operator[](long codepoint) const;
 
    utf8_pointer& operator=(const char *string);
 
    void inc(void);
 
    void dec(void);
 
    inline bool operator==(const char *string) const {
        return (const char *)text == string;
    }
 
    inline bool operator!=(const char *string) const {
        return (const char *)text != string;
    }
 
    inline  ucs4_t operator*() const {
        return utf8::codepoint((const char *)text);
    }
 
    inline char *c_str(void) const {
        return (char *)text;
    }
 
    inline operator char*() const {
        return (char *)text;
    }
 
    inline size_t len(void) const {
        return utf8::count((const char *)text);
    }
};
 
inline ucs4_t *strudup(const char *string) {
    return utf8::udup(string);
}
 
inline ucs2_t *strwdup(const char *string) {
    return utf8::wdup(string);
}
 
__EXPORT unicode_t unidup(const char *string);
 
template<>
inline void dupfree<ucs2_t*>(ucs2_t *string) {
    ::free(string);
}
 
template<>
inline void dupfree<ucs4_t*>(ucs4_t *string) {
    ::free(string);
}
 
template<>
inline void dupfree<unicode_t>(unicode_t string) {
    ::free(string);
}
 
typedef UString ustring_t;
 
typedef utf8_pointer utf8_t;
 
} // namespace ucommon
 
#endif