YCPMap.h

Go to the documentation of this file.

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

   File:        YCPMap.h

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

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

#ifndef YCPMap_h
#define YCPMap_h


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


// Only for backwards compatibility. See mail from aschnell on yast-devel on
// 2009-01-07. http://lists.opensuse.org/yast-devel/2009-01/msg00016.html
typedef map<YCPValue, YCPValue, ycp_less> YCPValueYCPValueMap;
class YCPMapIterator;
 

class YCPMapRep : public YCPValueRep
{
private:

    YCPValueYCPValueMap stl_map;

protected:

    typedef YCPValueYCPValueMap::iterator iterator;
    typedef YCPValueYCPValueMap::const_iterator const_iterator;
    typedef YCPValueYCPValueMap::value_type value_type;
    typedef YCPValueYCPValueMap::const_reference const_reference;
    typedef YCPValueYCPValueMap::key_compare key_compare;

    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);

    bool isEmpty() const;

    long size() const;

    bool hasKey(const YCPValue& key) 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;
};


// Only for backwards compatibility. See mail from aschnell on yast-devel on
// 2009-01-07. http://lists.opensuse.org/yast-devel/2009-01/msg00016.html
struct YCPMapIterator : public YCPValueYCPValueMap::const_iterator
{
    YCPMapIterator(YCPValueYCPValueMap::const_iterator it)
        : YCPValueYCPValueMap::const_iterator(it) {}

    YCPValue key() const __attribute__ ((deprecated)) { return (*this)->first; }
    YCPValue value() const __attribute__ ((deprecated)) { return (*this)->second; }
};


#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:

    typedef YCPMapRep::iterator iterator;
    typedef YCPMapRep::const_iterator const_iterator;
    typedef YCPMapRep::value_type value_type;
    typedef YCPMapRep::const_reference const_reference;
    typedef YCPMapRep::key_compare key_compare;

    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); }
    bool isEmpty() const { return CONST_ELEMENT->isEmpty(); }
    long size() const { return CONST_ELEMENT-> size (); }
    bool hasKey(const YCPValue& key) const { return CONST_ELEMENT->hasKey(key); }
    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