composite.h

/*****************************************************************************
 * composite.h
 * Last Change: 2003-12-27
 * Copyright (c) 2003 Sebastian "randomZ" Beschke
 ****************
 * This file is part of the libsofu project, a parser library for an all-purpose
 * ASCII file format. More information can be found on the project web site
 * at http://sofu.sourceforge.net/ .
 *
 * libsofu is published under the terms of the MIT license, which basically means
 * "Do with it whatever you want". For more information, see the license.txt
 * file that should be enclosed with libsofu distributions. A copy of the license
 * is (at the time of this writing) also available at
 * http://www.opensource.org/licenses/mit-license.php .
 *****************************************************************************/

#ifndef INC_SOFU_COMPOSITE_H
#define INC_SOFU_COMPOSITE_H

#include "main.h"
#include "object.h"

namespace Sofu
{
    class Value;
    class List;

    class Composite : public Object
    {
        private:
            map<string, Object*> properties;
        public:
            Composite(void);
            Composite(const Composite& cpy);
            ~Composite(void);
            
            Object*& operator[](const string& propname);
            Object* object(const string& propname);
            Value* value(const string& propname);
            List* list(const string& propname);
            Composite* composite(const string& propname);
            
            void set(const string& propname, Object* ivalue);
            
            class iterator;
            iterator begin(void);
            iterator end(void);
            
            class iterator
            {
                private:
                    friend class Composite;
                    map<string, Object*>::iterator itor;
                    iterator(map<string, Object*>::iterator iitor, Composite* icomp);
                    Composite* comp;
                public:
                    iterator(void);
                    ~iterator(void);
                    
                    iterator& operator=(iterator& rhs);
                    
                    bool operator==(const iterator& rhs) const;
                    bool operator!=(const iterator& rhs) const;
                    
                    iterator& operator+=(int steps);
                    iterator& operator-=(int steps);
                    iterator& operator++(void);
                    iterator& operator--(void);
                    
                    pair<string, Object*> operator*(void);
                    Object* object(void);
                    Value* value(void);
                    List* list(void);
                    Composite* composite(void);
                    
                    string name(void);
                    void set(Object* ivalue);
            };
    };
    
    struct Exc_WrongPropertyType : public Exc
    {
        string propertyName;
        string assumedType;
    
        Exc_WrongPropertyType(const string& ipropertyName,
            const string& iassumedType)
        : Exc(string("Tried to treat property ") + ipropertyName
            + string(" as a ") + iassumedType + string(", which it is not.")),
          propertyName(ipropertyName), assumedType(iassumedType)
        { }
    };
    
    struct Exc_UnassignedIterator : public Exc
    {
        Exc_UnassignedIterator(void)
        : Exc("Tried to use an iterator which is currently not assigned to"
            "point to something")
        { }
    };
}

#endif // INC_COMPOSITE_H

---