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

Go to the documentation of this file.

//
// aegis - project change supervisor
// Copyright (C) 2004-2010, 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_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;
    }

    // ----------  A  ------------------------------------------------------
    // ----------  B  ------------------------------------------------------

    unsigned char back(void) const;

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

    // ----------  C  ------------------------------------------------------

    nstring capitalize(void) const;

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

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

    void clear(void);

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

    // ----------  D  ------------------------------------------------------

    nstring dirname(void) const;

    nstring downcase(void) const;

    // ----------  E  ------------------------------------------------------

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

    bool ends_with(const nstring &suffix) const;

    bool ends_with_nocase(const nstring &suffix) const;

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

    // ----------  F  ------------------------------------------------------

    nstring field(char sep, int nth) const;

    nstring first_dirname(void) const;

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

    unsigned char front(void) const { return ref->str_text[0]; }

    // ----------  G  ------------------------------------------------------

    nstring get_extension(void) const;

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

    string_ty *
    get_ref(void)
        const
    {
        return ref;
    }

    string_ty *
    get_ref_copy(void)
        const
    {
        return str_copy(ref);
    }

    bool gmatch(const char *pattern) const;

    bool gmatch(const nstring &pattern) const;

    bool gmatch(const nstring_list &pattern) const;

    // ----------  H  ------------------------------------------------------

    nstring html_quote(bool para = false) const;

    nstring html_unquote(void) const;

    // ----------  I  ------------------------------------------------------

    nstring identifier(void) const;

    // ----------  J  ------------------------------------------------------
    // ----------  K  ------------------------------------------------------
    // ----------  L  ------------------------------------------------------

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

    int len_printable(int maxlen) const;

    // ----------  M  ------------------------------------------------------
    // ----------  N  ------------------------------------------------------
    // ----------  O  ------------------------------------------------------

    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;
    }

    operator bool() const;

    bool operator!() const;

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

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

    bool operator<(const nstring &rhs) const;

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

    bool operator>(const nstring &rhs) const;

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

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

    // ----------  P  ------------------------------------------------------
    // ----------  Q  ------------------------------------------------------

    nstring quote_c(void) const;

    nstring quote_shell(void) const;

    nstring quote_cook(void) const;

    // ----------  R  ------------------------------------------------------

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

    // ----------  S  ------------------------------------------------------

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

    nstring snip(void) const;

    bool starts_with(const nstring &prefix) const;

    nstring substr(long start, long nbytes) const;

    // ----------  T  ------------------------------------------------------

    long to_long(void) const;

    nstring trim(void) const;

    nstring trim_extension(void) const;

    nstring trim_first_directory(void) const;

    nstring trim_lines(void) const;

    nstring trim_right(void) const;

    // ----------  U  ------------------------------------------------------

    nstring upcase(void) const;

    nstring url_quote(void) const;

    nstring url_unquote(void) const;

    // ----------  V  ------------------------------------------------------

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

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

    // ----------  W  ------------------------------------------------------
    // ----------  X  ------------------------------------------------------
    // ----------  Y  ------------------------------------------------------
    // ----------  Z  ------------------------------------------------------

private:
    string_ty *ref;

    static string_ty *get_empty_ref(void);
};

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));
}

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