YCPList.h

Go to the documentation of this file.

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

   File:        YCPList.h

   Authors:     Mathias Kettner <kettner@suse.de>
                Arvin Schnell <aschnell@suse.de>
   Maintainer:  Thomas Roelz <tom@suse.de>

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

#ifndef YCPList_h
#define YCPList_h


#include "YCPValue.h"


class YCPCodeCompare;


class YCPListRep : public YCPValueRep
{
private:

    typedef vector<YCPValue> YCPValueList;

    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;

    const_iterator begin() const;

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


#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); }
    const_iterator begin() const { return CONST_ELEMENT->begin(); }
    const_iterator end() const { return CONST_ELEMENT->end(); }
    string commaList() const { return CONST_ELEMENT->commaList (); }
};

#undef CONST_ELEMENT
#undef ELEMENT

#endif   // YCPList_h