list.h

/*****************************************************************************
 * list.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_LIST_H
#define INC_SOFU_LIST_H

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

namespace Sofu
{
    class Value;
    class Composite;

    class List : public Object
    {
        private:
            vector<Object*> elems;
        public:
            List(void);
            List(const List& cpy);
            ~List(void);

            class iterator;

            iterator begin(void);
            iterator end(void);
        
            unsigned int size(void);
            Object*& at(int pos);
            Value* value(int pos);
            List* list(int pos);
            Composite* composite(int pos);
            
            void push_back(Object* obj);            
            
            class iterator
            {
                private:
                    friend class List;
                    vector<Object*>::iterator itor;
                    iterator(vector<Object*>::iterator iitor);
                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) const;
                    iterator operator-(int steps) const;
                    iterator& operator+=(int steps);
                    iterator& operator-=(int steps);
                    iterator& operator++(void);
                    iterator& operator--(void);
                    
                    Object* operator*(void);
                    Value* value(void);
                    List* list(void);
                    Composite* composite(void);
            };
    };

    struct Exc_WrongListElemType : public Exc
    {
        int elemNum;
        string assumedType;
    
        Exc_WrongListElemType(const string& iassumedType)
        : elemNum(-1), assumedType(iassumedType)
        {
            ostringstream oss;
            oss << "Tried to treat a list element as a "
                << assumedType << ", which it is not.";
            message = oss.str();
        }
        
        Exc_WrongListElemType(int ielemNum, const string& iassumedType)
        : elemNum(ielemNum), assumedType(iassumedType)
        {
            ostringstream oss;
            oss << "Tried to treat list element number " << elemNum << " as a "
                << assumedType << ", which it is not.";
            message = oss.str();
        }
        
    };
}

#endif // INC_LIST_H

---