lib/rcstring.h

Go to the documentation of this file.

//
// nis-util - NIS Administration Utilities
// Copyright (C) 2001, 2008, 2009, 2011, 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 2 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 LIB_RCSTRING_H
#define LIB_RCSTRING_H

#include <lib/ac/stddef.h>
#include <lib/ac/stdarg.h>
#include <lib/gcc-attr.h>

#include <vector> // for break_up method

class rcstring
{
public:
    virtual ~rcstring()
    {
        value->one_less();
    }

    rcstring()
    {
        value = string_ty::from_c("");
    }

    rcstring(const char *s)
    {
        value = string_ty::from_c(s);
    }

    rcstring(const char *s, size_t len)
    {
        value = string_ty::n_from_c(s, len);
    }

    rcstring(const rcstring &arg)
    {
        value = arg.value;
        value->one_more();
    }

    rcstring &
    operator=(const rcstring &arg)
    {
        if (this != &arg)
        {
            value->one_less();
            value = arg.value;
            value->one_more();
        }
        return *this;
    }

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

    typedef unsigned long hash_ty;

    hash_ty
    get_hash(void)
        const
    {
        return value->get_hash();
    }

    rcstring trim_right(void) const;

    static rcstring spaces(size_t n);

    bool is_printable(void) const;

    bool is_lower_case(void) const;

    bool starts_with(const rcstring &prefix) const;

    bool ends_with(const rcstring &suffix) const;

    rcstring replace(const rcstring &from, const rcstring &to, size_t ntimes)
        const;

    unsigned char front(void) const;

    unsigned char back(void) const;

    rcstring basename(void) const;

    rcstring dirname(void) const;

    rcstring identifier(void) const;

    rcstring trim(void) const;

private:
    class string_ty
    {
    public:
        string_ty(const char *);

        string_ty(const char *, size_t);

        void one_more(void);

        void one_less(void);

        const char *
        c_str(void)
            const
        {
            return text;
        }

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

        size_t
        size(void)
            const
        {
            return str_length;
        }

        rcstring::hash_ty
        get_hash(void)
            const
        {
            return str_hash;
        }

    private:
        ~string_ty();

        string_ty(); // do not use
        string_ty(const string_ty &); // do not use
        string_ty &operator=(const string_ty &); // do not use

        rcstring::hash_ty str_hash;
        string_ty *next;
        long references;
        size_t str_length;
        char *text;

        static void initialize(void);
        static void split(void);

        static string_ty *from_c(const char *);
        static string_ty *n_from_c(const char *, size_t);
        void construct(const char *, size_t);

        static string_ty **hash_table;
        static rcstring::hash_ty hash_modulus;
        static rcstring::hash_ty hash_mask;
        static rcstring::hash_ty hash_load;

        friend class rcstring;
    };

    string_ty *value;

public:
    rcstring upcase(void) const;

    rcstring downcase(void) const;

    bool
    operator==(const rcstring &rhs)
        const
    {
        return (this->value == rhs.value);
    }

    bool
    operator!=(const rcstring &rhs)
        const
    {
        return (this->value != rhs.value);
    }

    static rcstring format(const char *, ...)    ATTRIBUTE_PRINTF(1, 2);
    static rcstring vformat(const char *, va_list)  ATTRIBUTE_VPRINTF(1, 2);

    bool
    empty(void)
        const
    {
        return value->empty();
    }

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

    std::vector<rcstring> break_up(const char *sep = 0, bool ignsp = true)
        const;

    rcstring substr(size_t start, size_t len) const;

    bool to_long(long &n, int base = 10) const;

    static rcstring catenate(const rcstring &, const rcstring &);

    rcstring &
    operator+=(const rcstring &arg)
    {
        return operator=(catenate(*this, arg));
    }

    rcstring quote_c(void) const;

    rcstring quote_shell(void) const;

    char operator[](int idx) const;
};

inline rcstring
operator+(const rcstring &lhs, const rcstring &rhs)
{
    return rcstring::catenate(lhs, rhs);
}

bool operator<(const rcstring &lhs, const rcstring &rhs);
bool operator<=(const rcstring &lhs, const rcstring &rhs);
bool operator>(const rcstring &lhs, const rcstring &rhs);
bool operator>=(const rcstring &lhs, const rcstring &rhs);

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