common/str_list.h

Go to the documentation of this file.

//
//      aegis - project change supervisor
//      Copyright (C) 1991-1994, 1996, 1997, 2003-2006, 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_STR_LIST_H
#define COMMON_STR_LIST_H

#include <common/str.h>

class string_list_ty
{
public:
    ~string_list_ty();

    string_list_ty();

    string_list_ty(const string_list_ty &);

    string_list_ty &operator=(const string_list_ty &);

    bool member(string_ty *arg) const;

    bool member_nocase(string_ty *arg) const;

    size_t size() const { return nstrings; }

    bool empty() const { return (nstrings == 0); }

    string_ty *operator[](size_t n) const { return string[n]; }

    string_ty *unsplit(size_t start, size_t finish, const char *sep) const;

    string_ty *unsplit(const char *sep = 0) const;

    void push_front(string_ty *arg);

    void push_front(const string_list_ty &arg);

    void push_back(string_ty *arg);

    void push_back_unique(string_ty *arg);

    void push_back(const string_list_ty &arg);

    void push_back_unique(const string_list_ty &arg);

    void split(string_ty *arg, const char *sep = 0, bool white = false);

    void remove(string_ty *arg);

    void remove(const string_list_ty &arg);

    void clear();

    string_ty *front() { return (nstrings ? string[0] : 0); }

    string_ty *back() { return (nstrings ? string[nstrings - 1] : 0); }

    void pop_front();

    void pop_back();

    bool equal(const string_list_ty &arg) const;

    bool subset(const string_list_ty &arg) const;

    void sort();

    void sort_nocase();

    void sort_version();

    string_list_ty quote_shell() const;

    bool validate() const;

    string_list_ty intersection(const string_list_ty &rhs) const;

// private:
    size_t nstrings;
    size_t nstrings_max;
    string_ty **string;
};

inline DEPRECATED int
string_list_member(const string_list_ty *slp, string_ty *s)
{
    return slp->member(s);
}

inline DEPRECATED string_ty *
wl2str(const string_list_ty *slp, int start, int finish, const char *sep)
{
    return slp->unsplit(start, finish, sep);
}

inline DEPRECATED void
str2wl(string_list_ty *slp, string_ty *arg, const char *sep, int white)
{
    slp->split(arg, sep, white);
}

inline DEPRECATED void
string_list_prepend(string_list_ty *lhs, string_ty *rhs)
{
    lhs->push_front(rhs);
}

inline DEPRECATED void
string_list_prepend_list(string_list_ty *lhs, const string_list_ty *rhs)
{
    lhs->push_front(*rhs);
}

inline DEPRECATED void
string_list_append(string_list_ty *lhs, string_ty *rhs)
{
    lhs->push_back(rhs);
}

inline DEPRECATED void
string_list_append_list(string_list_ty *lhs, const string_list_ty *rhs)
{
    lhs->push_back(*rhs);
}

inline DEPRECATED void
string_list_append_unique(string_list_ty *lhs, string_ty *rhs)
{
    lhs->push_back_unique(rhs);
}

inline DEPRECATED void
string_list_append_list_unique(string_list_ty *lhs, const string_list_ty *rhs)
{
    lhs->push_back_unique(*rhs);
}

inline DEPRECATED void
string_list_copy(string_list_ty *lhs, const string_list_ty *rhs)
{
    *lhs = *rhs;
}

inline DEPRECATED void
string_list_remove(string_list_ty *slp, string_ty *s)
{
    slp->remove(s);
}

inline DEPRECATED void
string_list_remove_list(string_list_ty *lhs, const string_list_ty *rhs)
{
    lhs->remove(*rhs);
}

inline DEPRECATED void
string_list_destructor(string_list_ty *slp)
{
    // from context, this is the right thing to do,
    // now that the real destructor does something useful.
    slp->clear();
}

inline DEPRECATED void
string_list_constructor(string_list_ty *slp)
{
    // from context, this is the right thing to do,
    // now that the real constructor does something useful.
    slp->clear();
}

inline bool
operator==(const string_list_ty &lhs, const string_list_ty &rhs)
{
    return lhs.equal(rhs);
}


inline bool
operator!=(const string_list_ty &lhs, const string_list_ty &rhs)
{
    return !lhs.equal(rhs);
}

inline DEPRECATED int
string_list_subset(const string_list_ty *lhs, const string_list_ty *rhs)
{
    return lhs->subset(*rhs);
}

inline DEPRECATED void
string_list_sort(string_list_ty *slp)
{
    slp->sort();
}

inline DEPRECATED void
string_list_quote_shell(string_list_ty *lhs, const string_list_ty *rhs)
{
    *lhs = rhs->quote_shell();
}

inline void
operator+=(string_list_ty &lhs, const string_list_ty &rhs)
{
    lhs.push_back_unique(rhs);
}

inline string_list_ty
operator+(const string_list_ty &lhs, const string_list_ty &rhs)
{
    string_list_ty result;
    result.push_back_unique(lhs);
    result.push_back_unique(rhs);
    return result;
}

inline void
operator-=(string_list_ty &lhs, const string_list_ty &rhs)
{
    lhs.remove(rhs);
}

inline string_list_ty
operator-(const string_list_ty &lhs, const string_list_ty &rhs)
{
    string_list_ty result;
    result.push_back_unique(lhs);
    result.remove(rhs);
    return result;
}

inline void
operator*=(string_list_ty &lhs, const string_list_ty &rhs)
{
    lhs = lhs.intersection(rhs);
}

inline string_list_ty
operator*(const string_list_ty &lhs, const string_list_ty &rhs)
{
    return lhs.intersection(rhs);
}

#endif // COMMON_STR_LIST_H