Ustring.cc

/* 
 * File:   Unicode.cc
 * 
 * Copyright 2014 Heinrich Schuchardt <xypron.glpk@gmx.de>
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 * 
 *   http://www.apache.org/licenses/LICENSE-2.0
 * 
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

#include "Ustring.h"
#include <iostream>

int Ustring::getchar(std::istream *ifs) {
    int ret = ifs->get();
    if (!ifs->good()) {
        Ustring::Eof eof;
        throw eof;
    }
    return ret;
}

Ustring::Ustring() {
}

Ustring::Ustring(std::istream *ifs) {
    try {
        int i;
        i = getchar(ifs);

        for (;;) {
            Uchar u;

            if (0 == (i & 0x80)) {
                u = i;
            } else if (0xC0 == (i & 0xE0)) {
                u = i & 0x1F;

                // Get next 6 bits
                i = getchar(ifs);
                if (0x80 != (i & 0xC0)) {
                    throw invalid;
                }
                i &= 0x3F;
                u <<= 6;
                u += i;
            } else if (0xE0 == (i & 0xF0)) {
                u = i & 0x0F;

                // Get next 6 bits
                i = getchar(ifs);
                if (0x80 != (i & 0xC0)) {
                    throw invalid;
                }
                i &= 0x3F;
                u <<= 6;
                u += i;
                // Get next 6 bits
                i = getchar(ifs);
                if (0x80 != (i & 0xC0)) {
                    throw invalid;
                }
                i &= 0x3F;
                u <<= 6;
                u += i;
            } else if (0xF0 == (i & 0xF8)) {
                u = i & 0x07;

                // Get next 6 bits
                i = getchar(ifs);
                if (0x80 != (i & 0xC0)) {
                    throw invalid;
                }
                i &= 0x3F;
                u <<= 6;
                u += i;
                // Get next 6 bits
                i = getchar(ifs);
                if (0x80 != (i & 0xC0)) {
                    throw invalid;
                }
                i &= 0x3F;
                u <<= 6;
                u += i;
                // Get next 6 bits
                i = getchar(ifs);
                if (0x80 != (i & 0xC0)) {
                    throw invalid;
                }
                i &= 0x3F;
                u <<= 6;
                u += i;
            } else {
                throw invalid;
            }
            // Append unicode character if it is not a byte order mark.
            switch (u) {
                case BYTE_ORDER_MARK:
                    break;
                default:
                    s.push_back(u);
            }
            // Get next byte.
            i = getchar(ifs);
        }
    } catch (const Invalid &e) {
        std::cerr << "Ustring::Ustring(std::istream): "
                "Stream is not valid utf8" << std::endl;
        throw e;
    } catch (const Eof &e) {
    }
}

Ustring::Ustring(const Ustring &orig) {
    for (std::vector<Uchar>::const_iterator it = orig.s.begin();
            it != orig.s.end(); ++it) {
        s.push_back(*it);
    }
}

Ustring::~Ustring() {
}

std::vector<Uchar>::const_iterator Ustring::begin() {
    return s.begin();
};

std::vector<Uchar>::const_iterator Ustring::end() {
    return s.end();
};

int Ustring::length() {
    return s.size();
};

const bool Ustring::operator==(const char *right) const {
    int i;
    for (i = 0; right[i]; ++i) {
        if (i >= s.size()) {
            return false;
        }
        if (s[i] != right[i]) {
            return false;
        }
    }
    if (i < s.size()) {
        return false;
    }
    return true;
}

Ustring* Ustring::operator+=(const Uchar &right) {
    if (right < 0x1FFFFFu) {
        s.push_back(right);
    } else {
        throw invalid;
    }
    return this;
}

Ustring* Ustring::operator+=(const char *right) {
    for (const char *pos = right; *pos; ++pos) {
        if (*pos >= 0 && *pos <= 127) {
            s.push_back((Uchar) * pos);
        } else {
            throw invalid;
        }
    }
    return this;
}

std::string* Ustring::operator>>(std::string &str) {
    for (int i = 0; i < s.size(); ++i) {
        Uchar u = s[i];
        char c[5];
        if (u < 0x80) {
            c[0] = u & 0x7F;
            c[1] = 0;
            str.append(c);
        } else if (u < 0x800) {
            c[1] = 0x80 | (u & 0x3F);
            u >>= 6;
            c[0] = 0xC0 | (u & 0x1F);
            c[2] = 0;
            str.append(c);
        } else if (u < 0x10000) {
            c[2] = 0x80 | (u & 0x3F);
            u >>= 6;
            c[1] = 0x80 | (u & 0x3F);
            u >>= 6;
            c[0] = 0xE0 | (u & 0x0F);
            c[3] = 0;
            str.append(c);
        } else if (u < 0x200000) {
            c[3] = 0x80 | (u & 0x3F);
            u >>= 6;
            c[2] = 0x80 | (u & 0x3F);
            u >>= 6;
            c[1] = 0x80 | (u & 0x3F);
            u >>= 6;
            c[0] = 0xF0 | (u & 0x07);
            c[4] = 0;
            str.append(c);
        } else {
            throw invalid;
        }
    }
    return &str;
}

const bool Ustring::operator<(const Ustring &right) const {
    int i;
    for (i = 0;; ++i) {
        Uchar c;
        try {
            c = right.charAt(i);
        } catch (const Invalid &e) {
            break;
        }
        if (i >= s.size()) {
            // Right string is longer.
            return true;
        }
        if (s[i] < c) {
            // Left character is less then right character.
            return true;
        }
    }
    // Both strings are equal or left string is longer.
    return false;
}

const Uchar & Ustring::charAt(int pos) const {
    if (pos < 0 || pos >= s.size()) {
        throw invalid;
    } else {
        return s[pos];
    }
}