YCPMap.h

Go to the documentation of this file.

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

   File:       YCPMap.h

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

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

#ifndef YCPMap_h
#define YCPMap_h


#include "YCPValue.h"
#include "ycpless.h"


typedef map<YCPValue, YCPValue, ycpless> YCPValueYCPValueMap;
class YCPMapIterator;
 
class YCPMapRep : public YCPValueRep
{
    YCPValueYCPValueMap stl_map;

protected:
    friend class YCPMap;

    YCPMapRep();

    ~YCPMapRep() {}

public:
    void add(const YCPValue& key, const YCPValue& value);

    YCPMap functionalAdd(const YCPValue& key, const YCPValue& value) const;

    virtual const YCPElementRep* shallowCopy() const;

    void remove(const YCPValue& key);

    long size() const;

    YCPValue value(const YCPValue& key) const;

    YCPMapIterator begin() const;

    YCPMapIterator end() const;

    YCPOrder compare(const YCPMap &v) const;
        
    string toString() const;

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

    YCPValueType valuetype() const;
    

private:
    YCPMapIterator findKey(const YCPValue& key) const;
};

class YCPMapIterator
{
    friend class YCPMapRep;

    YCPValueYCPValueMap::const_iterator position;

protected:
    YCPMapIterator(YCPValueYCPValueMap::const_iterator position)
        : position(position) {}

public:
    YCPValue key() const { return position->first; }

    YCPValue value() const { return position->second; }

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

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

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


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

class YCPMap : public YCPValue
{
    DEF_COW_COMMON(Map, Value);
public:
    YCPMap() : YCPValue(new YCPMapRep()) {}
    YCPMap(bytecodeistream & str);

    void add(const YCPValue& key, const YCPValue& value) { ELEMENT->add (key,value); }
    YCPMap functionalAdd(const YCPValue& key, const YCPValue& value) const { return CONST_ELEMENT-> functionalAdd (key,value); }
    void remove(const YCPValue& key) { ELEMENT-> remove (key); }
    long size() const { return CONST_ELEMENT-> size (); }
    YCPValue value(const YCPValue& key) const { return CONST_ELEMENT-> value (key); }
    YCPMapIterator begin() const { return CONST_ELEMENT-> begin (); }
    YCPMapIterator end() const { return CONST_ELEMENT-> end (); }
};

#undef ELEMENT
#undef CONST_ELEMENT

#endif   // YCPMap_h

---