common/nstring.h

Go to the documentation of this file.

//
//      aegis - project change supervisor
//      Copyright (C) 2004-2008 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_NSTRING_H
#define COMMON_NSTRING_H

#include <common/str.h>

class nstring_list; // forward

class nstring
{
public:
    ~nstring()
    {
        str_free(ref);
        ref = 0;
    }

    nstring() :
        ref(get_empty_ref())
    {
    }

    nstring(const char *arg) :
        ref(arg ? str_from_c(arg) : get_empty_ref())
    {
    }

    nstring(const char *data, size_t len) :
        ref(str_n_from_c(data, len))
    {
    }

    explicit
    nstring(string_ty *arg) :
        ref(arg ? str_copy(arg) : get_empty_ref())
    {
    }

    nstring(const nstring &arg) :
        ref(str_copy(arg.ref))
    {
    }

    nstring &
    operator=(const nstring &arg)
    {
        if (this != &arg)
        {
            str_free(ref);
            ref = (arg.ref ? str_copy(arg.ref) : get_empty_ref());
        }
        return *this;
    }

    const char *
    c_str()
        const
    {
        return ref->str_text;
    }

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

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

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

    nstring
    catenate(const nstring &arg)
        const
    {
        string_ty *tmp = str_catenate(ref, arg.ref);
        nstring result(tmp);
        str_free(tmp);
        return result;
    }

    nstring
    operator+(const nstring &arg)
        const
    {
        string_ty *tmp = str_catenate(ref, arg.ref);
        nstring result(tmp);
        str_free(tmp);
        return result;
    }

    nstring &
    operator+=(const nstring &arg)
    {
        if (!arg.empty())
        {
            string_ty *s = str_catenate(ref, arg.ref);
            str_free(ref);
            ref = s;
        }
        return *this;
    }

    nstring cat_three(const nstring &str2, const nstring &str3) const;

    operator bool() const;

    bool operator!() const;

    nstring upcase() const;

    nstring downcase() const;

    nstring capitalize() const;

    nstring field(char sep, int nth) const;

    static nstring format(const char *fmt, ...)               ATTR_PRINTF(1, 2);

    static nstring vformat(const char *fmt, va_list ap);

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

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

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

    bool operator<(const nstring &arg) const;

    bool operator<=(const nstring &arg) const;

    bool operator>(const nstring &arg) const;

    bool operator>=(const nstring &arg) const;

    nstring quote_c() const;

    nstring quote_shell() const;

    nstring trim() const;

    nstring trim_lines() const;

    nstring trim_extension() const;

    nstring get_extension() const;

    nstring snip() const;

    bool
    valid()
        const
    {
        return str_validate(ref);
    }

    string_ty *
    get_ref()
        const
    {
        return ref;
    }

    bool starts_with(const nstring &prefix) const;

    bool ends_with(const nstring &suffix) const;

    bool ends_with_nocase(const nstring &suffix) const;

    bool gmatch(const char *pattern) const;

    bool gmatch(const nstring &pattern) const;

    bool gmatch(const nstring_list &pattern) const;

    nstring identifier() const;

    nstring replace(const nstring &lhs, const nstring &rhs, int maximum = -1)
        const;

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

    void clear();

    nstring url_quote() const;

    nstring url_unquote() const;

    nstring html_quote(bool para = false) const;

    nstring html_unquote() const;

    long to_long() const;

    nstring substring(long start, long nbytes) const;

    nstring dirname() const;

    nstring first_dirname() const;

    nstring basename(const nstring &suffix = "") const;

    str_hash_ty get_hash() const { return ref->str_hash; }

private:
    string_ty *ref;

    static string_ty *get_empty_ref();
};

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

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

#endif // COMMON_NSTRING_H

---