YCPElement.h

Go to the documentation of this file.

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

   File:       YCPElement.h

   Author:     Mathias Kettner <kettner@suse.de>
   Maintainer: Klaus Kaempf <kkaempf@suse.de>

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

#ifndef YCPElement_h
#define YCPElement_h

// MemUsage.h defines/undefines D_MEMUSAGE
#include <y2util/MemUsage.h>

// include only forward declarations of iostream
#include <iosfwd>
#include <string>
#include <vector>
#include <map>

using std::string;
using std::vector;
using std::map;
using std::pair;

#include "toString.h"

// forward declarations

class YCPElement;
class YCPValue;
class YCPVoid;
class YCPBoolean;
class YCPInteger;
class YCPFloat;
class YCPString;
class YCPByteblock;
class YCPPath;
class YCPSymbol;
class YCPLocale;
class YCPList;
class YCPTerm;
class YCPMap;
class YCPBuiltin;
class YCPCode;
class YCPEntry;
class YCPReference;
class YCPExternal;


#define DEF_OPS(name)                                           \
public:                                                         \
    const YCP##name##Rep *operator ->() const {                 \
        return static_cast<const YCP##name##Rep *>(element); }  \
    YCP##name##Rep *operator ->() {                             \
        return const_cast<YCP##name##Rep *>(                    \
               static_cast<const YCP##name##Rep *>(element)); } \
private:                                                        \
    int operator !() const;                                     \
    int operator ==(const YCPElement &) const;


#ifdef D_MEMUSAGE
#define DEF_MEMSIZE(name)                                       \
    virtual size_t mem_size () const { return sizeof (YCP##name); }
#else
#define DEF_MEMSIZE(name)
#endif

#define DEF_COMMON(name, base)                                  \
    DEF_OPS(name)                                               \
    friend class YCP##base##Rep;                                \
public:                                                         \
    DEF_MEMSIZE(name)                                           \
    YCP##name(const YCPNull &n) : YCP##base(n) {}               \
protected:                                                      \
    YCP##name (const YCP##name##Rep *x) : YCP##base(x) {}


#define DEF_COW_OPS(name)                                       \
public:                                                         \
    const YCP##name *operator ->() const {                      \
        return static_cast<const YCP##name *>(this); }          \
    YCP##name *operator ->() {                                  \
        return const_cast<YCP##name *>(                         \
               static_cast<const YCP##name *>(this)); }         \
private:                                                        \
    int operator !() const;                                     \
    int operator ==(const YCPElement &) const;

#define DEF_COW_COMMON(name, base)                              \
    friend class YCP##base##Rep;                                \
    DEF_COW_OPS(name)                                           \
public:                                                         \
    YCP##name(const YCPNull &n) : YCP##base(n) {}               \
protected:                                                      \
    YCP##name (const YCP##name##Rep *x) : YCP##base(x) {}       \
public:                                                         \
    YCPOrder compare(const YCP##name x) const {                 \
        return (static_cast<const YCP##name##Rep*>(element))->compare(x);                               \
    }                                                           \
    string toString () const { return element->toString (); }   \
    std::ostream & toStream (std::ostream & str ) const {       \
        return element->toStream (str);                         \
    }                                                           \
    std::ostream & toXml (std::ostream & str, int indent ) const {      \
        return element->toXml( str, indent );                           \
    }                                                           \
    YCPValueType valuetype () const { return (static_cast<const YCP##name##Rep*>(element))->valuetype (); }


class YCPNull {};

/***
 * <h2>The YCP Datastructures</h2>
 *
 * <p>YCP is both a scripting language and a communication protocol.
 * A YCP value is a data structure. It has currently two possible
 * representations. One ist an ASCII representation, the other is
 * a representation a network of C++ objects. The class framework
 * for this object representation is laid in this library. Furthermore
 * It contains the @ref Parser, that transforms an ASCII representation
 * of YCP values into the object-representation.
 *
 * <h2>YCP Data management</h2>
 *
 * <p>YCP data are managed via "smart pointers". This means that an application
 * instantiates an object from a class in a conventional way but does not get
 * the object itself. The result is a wrapper object that "points" to the real
 * object which is automatically created on instantiation. This real object
 * (the representation of the actual data) holds a reference counter and
 * therefore "knows" who is using it. After all references to this object have
 * diminished (e.g. auto variables get out of scope) the real object is
 * automatically destroyed. This way it is neither necessary nor allowed
 * to "new" or "delete" YCP data objects. Furthermore all members of the
 * object must be accessed using pointer notation.
 *
 * <p>So all YCP data objects do exist in two flavours:
 * <ul>
 * <li>Class name without "Rep" is the usable object, e.g. @ref YCPInteger.</li>
 * <li>Class name with "Rep" is the real Object, e.g. @ref YCPIntegerRep.</li>
 * </ul>
 *
 * <p>Important: Applications <i>never</i> use "Rep" classes directly!
 *
 * <p>Example:
 * <pre>
 * {
 *    YCPInteger a (18);         // here a YCPIntegerRep is created automatically
 *    YCPInteger b = a;          // b points to the same YCPIntegerRep as a
 *
 *    cout << b->toString ();    // use pointer notation to access members
 *    cout << b->value () - 18;  // a and b out of scope, last reference lost, YCPIntegerRep is destroyed automatically
 * }
 * </pre>
 */

class YCPElementRep
#ifdef D_MEMUSAGE
 : public MemUsage
#endif
{
    YCPElementRep& operator=(const YCPElementRep&);

    YCPElementRep(const YCPElementRep&);

    mutable int reference_counter;

protected:

    friend class YCPElement;

    YCPElementRep();

    virtual ~YCPElementRep();

public:
    YCPValue asValue() const;

    virtual string toString() const = 0;

    virtual std::ostream & toStream (std::ostream & str) const = 0;
    virtual std::ostream & toXml (std::ostream & str, int indent ) const = 0;
    
    virtual const YCPElementRep* shallowCopy() const { return this; }

private:
    void destroy() const;

    const YCPElementRep *clone() const;
};

class YCPElement
#ifdef D_MEMUSAGE
 : public MemUsage
#endif
{
    DEF_OPS(Element);
protected:
    const YCPElementRep *element;
    
    const YCPElementRep *writeCopy() { 
        if (element->reference_counter == 1 ) return element;
        
        const YCPElementRep* old = element;
        element = element->shallowCopy ();
        element->clone ();
        old->destroy ();
        return element;
    }

public:
    YCPElement();
    YCPElement(const YCPNull&);
    YCPElement(const YCPElementRep *e);
    YCPElement(const YCPElement &e);
    ~YCPElement();
    const YCPElement& operator=(const YCPElement& e);
    bool isNull() const { return element == 0; }
    bool refersToSameElementAs(const YCPElement& e) const { return element == e.element; }    
};

#endif   // YCPElement_h