YCPList.h

Go to the documentation of this file.

/*---------------------------------------------------------------------\
|                                                                      |
|                      __   __    ____ _____ ____                      |
|                      \ \ / /_ _/ ___|_   _|___ \                     |
|                       \ V / _` \___ \ | |   __) |                    |
|                        | | (_| |___) || |  / __/                     |
|                        |_|\__,_|____/ |_| |_____|                    |
|                                                                      |
|                               core system                            |
|                                                        (C) SuSE GmbH |
\----------------------------------------------------------------------/

   File:       YCPList.h

   Author:     Mathias Kettner <kettner@suse.de>
   Maintainer: Thomas Roelz <tom@suse.de>

/-*/
// -*- c++ -*-

#ifndef YCPList_h
#define YCPList_h


#include <iterator>
#include "YCPValue.h"


typedef vector<YCPValue> YCPValueList;
class YCPListIterator;
class YCPCodeCompare;


class YCPListRep : public YCPValueRep
{
    YCPValueList elements;

protected:

    typedef YCPValueList::iterator iterator;
    typedef YCPValueList::const_iterator const_iterator;
    typedef YCPValueList::value_type value_type;
    typedef YCPValueList::const_reference const_reference;

    friend class YCPList;

    YCPListRep();

    ~YCPListRep() {}

public:
    int size() const;

    void reserve (int size);

    bool isEmpty() const;

    void add(const YCPValue& value);

    void push_back(const YCPValue& value);

    void set(const int n, const YCPValue& value);

    void remove(const int n);

    void swap(int x, int y);

    bool contains (const YCPValue& value) const;

    void sortlist();

    void lsortlist();

    void fsortlist(const YCPCodeCompare& cmp);

    virtual const YCPElementRep* shallowCopy() const;

    YCPList functionalAdd(const YCPValue& value, bool prepend = false) const;

    YCPValue value(int n) const;

    YCPListIterator begin() const;

    YCPListIterator end() const;

    YCPOrder compare(const YCPList &v) const;

    string toString() const;

    std::ostream & toStream (std::ostream & str) const;
    std::ostream & toXml (std::ostream & str, int indent ) const;

    YCPValueType valuetype() const;

    string commaList() const;
};


class YCPListIterator
{
    friend class YCPListRep;

    YCPValueList::const_iterator position;

public:

    typedef std::bidirectional_iterator_tag iterator_category;
    typedef ptrdiff_t           difference_type;
    typedef const YCPValue      value_type;
    typedef const YCPValue*     pointer;
    typedef const YCPValue&     reference;

protected:

    YCPListIterator(YCPValueList::const_iterator position)
        : position(position) {}

public:

    reference operator*() const { return position.operator*(); }

    friend bool operator==(const YCPListIterator &x, const YCPListIterator &y) {
        return x.position == y.position;
    }

    friend bool operator!=(const YCPListIterator &x, const YCPListIterator &y) {
        return !(x == y);
    }

    void operator++() { ++position; }
    void operator++(int) { ++position; }

};


#define CONST_ELEMENT (static_cast<const YCPListRep*>(element))
#define ELEMENT (const_cast<YCPListRep*>(static_cast<const YCPListRep*>(this->writeCopy())))

class YCPList : public YCPValue
{
    DEF_COW_COMMON(List, Value);
public:

    typedef YCPListRep::iterator iterator;
    typedef YCPListRep::const_iterator const_iterator;
    typedef YCPListRep::value_type value_type;
    typedef YCPListRep::const_reference const_reference;

    YCPList() : YCPValue(new YCPListRep()) {}
    YCPList(bytecodeistream & str);

    int size() const { return CONST_ELEMENT->size (); }
    void reserve (int size) { ELEMENT->reserve (size); }
    bool isEmpty() const { return CONST_ELEMENT->isEmpty (); }
    void add(const YCPValue& value) { ELEMENT->add (value);  }
    void push_back(const YCPValue& value) { ELEMENT->push_back(value); }
    void set(const int n, const YCPValue& value) { ELEMENT->set (n, value); }
    void remove(const int n) { ELEMENT->remove (n); }
    void swap(int x, int y) { ELEMENT->swap (x, y); }
    bool contains (const YCPValue& value) const { return CONST_ELEMENT->contains (value); }
    void sortlist() { ELEMENT->sortlist (); }
    void lsortlist() { ELEMENT->lsortlist (); }
    void fsortlist(const YCPCodeCompare& cmp) { ELEMENT->fsortlist (cmp); }

    YCPList functionalAdd(const YCPValue& value, bool prepend = false) const
        { return CONST_ELEMENT->functionalAdd (value, prepend); }
    YCPValue value(int n) const { return CONST_ELEMENT->value (n); }
    YCPListIterator begin() const { return CONST_ELEMENT->begin(); }
    YCPListIterator end() const { return CONST_ELEMENT->end(); }
    string commaList() const { return CONST_ELEMENT->commaList (); }
};

#undef CONST_ELEMENT
#undef ELEMENT

#endif   // YCPList_h

---