/home/archives/aegis/branch.4/branch.25/delta28933.505/common/wstring.h

Go to the documentation of this file.

//
//      aegis - project change supervisor
//      Copyright (C) 2004-2008, 2012 Peter Miller
//
//      This program is free software; you can redistribute it and/or modify
//      it under the terms of the GNU General Public License as published by
//      the Free Software Foundation; either version 3 of the License, or
//      (at your option) any later version.
//
//      This program 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 General Public License for more details.
//
//      You should have received a copy of the GNU General Public License
//      along with this program. If not, see
//      <http://www.gnu.org/licenses/>.
//

#ifndef COMMON_WSTRING_H
#define COMMON_WSTRING_H

#include <common/wstr.h>

class nstring; // forward

class wstring
{
public:
    ~wstring();

    wstring() :
        ref(get_empty_ref())
    {
    }

    explicit
    wstring(const char *arg) :
        ref(arg ? wstr_from_c(arg) : get_empty_ref())
    {
    }

    explicit
    wstring(const wchar_t *arg) :
        ref(arg ? wstr_from_wc(arg) : get_empty_ref())
    {
    }

    wstring(const char *data, size_t len) :
        ref(wstr_n_from_c(data, len))
    {
    }

    wstring(const wchar_t *data, size_t len) :
        ref(wstr_n_from_wc(data, len))
    {
    }

    wstring(wstring_ty *arg) :
        ref(arg ? wstr_copy(arg) : get_empty_ref())
    {
    }

    wstring(string_ty *arg);

    wstring(const nstring &arg);

    wstring(const wstring &arg) :
        ref(wstr_copy(arg.ref))
    {
    }

    wstring &
    operator=(const wstring &arg)
    {
        if (this != &arg)
        {
            wstr_free(ref);
            ref = wstr_copy(arg.ref);
        }
        return *this;
    }

    void clear();

    const wchar_t *
    c_str()
        const
    {
        return ref->wstr_text;
    }

    nstring to_nstring() const;

    bool
    empty()
        const
    {
        return (ref->wstr_length == 0);
    }

    size_t
    size()
        const
    {
        return ref->wstr_length;
    }

    size_t
    length()
        const
    {
        return ref->wstr_length;
    }

    wstring
    catenate(const wstring &arg)
        const
    {
        return wstring(wstr_catenate(ref, arg.ref));
    }

    wstring
    operator+(const wstring &arg)
        const
    {
        return wstring(wstr_catenate(ref, arg.ref));
    }

    wstring &
    operator+=(const wstring &arg)
    {
        if (!arg.empty())
        {
            wstring_ty *s = wstr_catenate(ref, arg.ref);
            wstr_free(ref);
            ref = s;
        }
        return *this;
    }

    wstring
    cat_three(const wstring &str2, const wstring &str3)
        const
    {
        return wstring(wstr_cat_three(ref, str2.ref, str3.ref));
    }

    wstring
    upcase()
        const
    {
        return wstring(wstr_to_upper(ref));
    }

    wstring
    downcase()
        const
    {
        return wstring(wstr_to_lower(ref));
    }

    wstring
    capitalize()
        const
    {
        return wstring(wstr_capitalize(ref));
    }

    bool
    equal(const wstring &arg)
        const
    {
        return (ref == arg.ref);
    }

    bool
    operator==(const wstring &arg)
        const
    {
        return (ref == arg.ref);
    }

    bool
    operator!=(const wstring &arg)
        const
    {
        return (ref != arg.ref);
    }

    wstring_ty *
    get_ref()
        const
    {
        return ref;
    }

    wstring
    identifier()
        const
    {
        return wstr_to_ident(get_ref());
    }

    char
    operator[](size_t n)
        const
    {
        return (n < size() ? ref->wstr_text[n] : L'\0');
    }

    int
    column_width()
        const
    {
        return wstr_column_width(ref);
    }

private:
    wstring_ty *ref;

    static wstring_ty *
    get_empty_ref()
    {
        return wstr_from_c("");
    }
};

inline wstring
operator+(const char *lhs, const wstring &rhs)
{
    return wstring(lhs).catenate(rhs);
}

inline wstring
operator+(const wstring &lhs, const char *rhs)
{
    return lhs.catenate(wstring(rhs));
}

#endif // COMMON_WSTRING_H
// vim: set ts=8 sw=4 et :