/* *  This file is part of the KDE libraries *  Copyright (C) 1999-2001 Harri Porten (porten@kde.org) *  Copyright (C) 2003 Apple Computer, Inc. * *  This library is free software; you can redistribute it and/or *  modify it under the terms of the GNU Library General Public *  License as published by the Free Software Foundation; either *  version 2 of the License, or (at your option) any later version. * *  This library is distributed in the hope that it will be useful, *  but WITHOUT ANY WARRANTY; without even the implied warranty of *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU *  Library General Public License for more details. * *  You should have received a copy of the GNU Library General Public License *  along with this library; see the file COPYING.LIB.  If not, write to *  the Free Software Foundation, Inc., 59 Temple Place - Suite 330, *  Boston, MA 02111-1307, USA. * */#ifndef KJS_LIST_H#define KJS_LIST_H#include "value.h"namespace KJS {    struct ListImpBase {        int size;        int refCount;	int valueRefCount;    };        class ListIterator;    /**     * @short Native list type.     *     * List is a native ECMAScript type. List values are only used for     * intermediate results of expression evaluation and cannot be stored     * as properties of objects.     *     * The list is explicitly shared. Note that while copyTail() returns a     * copy of the list the referenced objects are still shared.     */    class List {    public:        List();	List(bool needsMarking);        ~List() { deref(); }        List(const List &b) : _impBase(b._impBase), _needsMarking(false) {	    ++_impBase->refCount; 	    if (!_impBase->valueRefCount) refValues(); 	    ++_impBase->valueRefCount; 	}        List &operator=(const List &);        /**         * Append an object to the end of the list.         *         * @param val Pointer to object.         */        void append(const Value& val) { append(val.imp()); }        void append(ValueImp *val);        /**         * Remove all elements from the list.         */        void clear();        /**         * Make a copy of the list         */        List copy() const;        /**         * Make a copy of the list, omitting the first element.         */        List copyTail() const;            /**         * @return true if the list is empty. false otherwise.         */        bool isEmpty() const { return _impBase->size == 0; }        /**         * @return the current size of the list.         */        int size() const { return _impBase->size; }        /**         * @return A @ref KJS::ListIterator pointing to the first element.         */        ListIterator begin() const;        /**         * @return A @ref KJS::ListIterator pointing to the last element.         */        ListIterator end() const;                /**         * Retrieve an element at an indexed position. If you want to iterate         * trough the whole list using @ref KJS::ListIterator will be faster.         *         * @param i List index.         * @return Return the element at position i. @ref KJS::Undefined if the         * index is out of range.         */        Value at(int i) const { return Value(impAt(i)); }        /**         * Equivalent to @ref at.         */        Value operator[](int i) const { return Value(impAt(i)); }                ValueImp *impAt(int i) const;            /**         * Returns a pointer to a static instance of an empty list. Useful if a         * function has a @ref KJS::List parameter.         */        static const List &empty();        	void mark() { if (_impBase->valueRefCount == 0) markValues(); }    private:        ListImpBase *_impBase;	bool _needsMarking;                void deref() { if (!_needsMarking && --_impBase->valueRefCount == 0) derefValues(); if (--_impBase->refCount == 0) release(); }        void release();        void refValues();        void derefValues();        void markValues();    };      /**     * @short Iterator for @ref KJS::List objects.     */    class ListIterator {    public:        /**         * Construct an iterator that points to the first element of the list.         * @param l The list the iterator will operate on.         */        ListIterator(const List &l) : _list(&l), _i(0) { }        ListIterator(const List &l, int index) : _list(&l), _i(index) { }        /**         * Dereference the iterator.         * @return A pointer to the element the iterator operates on.         */        ValueImp *operator->() const { return _list->impAt(_i); }        Value operator*() const { return Value(_list->impAt(_i)); }        /**         * Prefix increment operator.         * @return The element after the increment.         */        Value operator++() { return Value(_list->impAt(++_i)); }        /**         * Postfix increment operator.         */        Value operator++(int) { return Value(_list->impAt(_i++)); }        /**         * Prefix decrement operator.         */        Value operator--() { return Value(_list->impAt(--_i)); }        /**         * Postfix decrement operator.         */        Value operator--(int) { return Value(_list->impAt(_i--)); }        /**         * Compare the iterator with another one.         * @return True if the two iterators operate on the same list element.         * False otherwise.         */        bool operator==(const ListIterator &it) const { return _i == it._i; }        /**         * Check for inequality with another iterator.         * @return True if the two iterators operate on different list elements.         */        bool operator!=(const ListIterator &it) const { return _i != it._i; }    private:        const List *_list;        int _i;    };    inline ListIterator List::begin() const { return ListIterator(*this); }    inline ListIterator List::end() const { return ListIterator(*this, size()); }     inline List &List::operator=(const List &b)    {        ListImpBase *bImpBase = b._impBase;        ++bImpBase->refCount;        deref();        _impBase = bImpBase;	if (!_needsMarking) {	    if (!_impBase->valueRefCount) {		refValues();	    }	    _impBase->valueRefCount++;	}        return *this;    } }; // namespace KJS#endif // KJS_LIST_H