array.h

Go to the documentation of this file.

// 
//   Copyright (C) 2005, 2006, 2007, 2008 Free Software Foundation, Inc.
// 
// This program is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation; either version 3 of the License, or
// (at your option) any later version.
// 
// This program 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 General Public License for more details.
// 
// You should have received a copy of the GNU General Public License
// along with this program; if not, write to the Free Software
// Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA

#ifndef GNASH_ARRAY_H
#define GNASH_ARRAY_H

#include "as_object.h" // for inheritance

#include <deque>
#include <vector>
#include <memory> // for auto_ptr

#include <string>

// Forward declarations
namespace gnash {
        class fn_call;
        class as_value;
}

namespace gnash {

struct indexed_as_value : public as_value
{
        int vec_index;

        indexed_as_value(const as_value& val, int index)
        : as_value(val)
        {
                vec_index = index;
        }
};

class as_array_object : public as_object
{

public:

        typedef std::deque<as_value> container;

        typedef container::const_iterator const_iterator;
        typedef container::iterator iterator;

        //
        template<class V> void visitAll(V& v)
        {
                // NOTE: we copy the elements as the visitor might call arbitrary code
                //       possibly modifying the container itself.
                container copy = elements;
                for (iterator i=copy.begin(), ie=copy.end(); i!=ie; ++i)
                {
                        v.visit(*i);
                }
        }

        enum SortFlags {

                fCaseInsensitive        = (1<<0), // 1

                fDescending             = (1<<1), // 2

                fUniqueSort             = (1<<2), // 4

                fReturnIndexedArray     = (1<<3), // 8

                fNumeric                = (1<<4) // 16
        };

        as_array_object();

        as_array_object(const as_array_object& other);

        ~as_array_object();

        std::deque<indexed_as_value> get_indexed_elements();

        const_iterator begin();

        const_iterator end();

        //
        void push(const as_value& val);

        void unshift(const as_value& val);

        as_value shift();

        as_value pop();

        as_value at(unsigned int index);

        as_array_object* get_indices(std::deque<indexed_as_value> origElems);

        void reverse();

        void set_indexed(unsigned int index, const as_value &v);

        std::string join(const std::string& separator, as_environment* env) const;

        std::string toString(as_environment* env=NULL) const;

        // override from as_object
        std::string get_text_value() const
        {
                return toString();
        }

        unsigned int size() const;

        void resize(unsigned int);

        void concat(const as_array_object& other);

        //
        std::auto_ptr<as_array_object> slice(
                unsigned int start, unsigned int one_past_end);

        //
        bool removeFirst(const as_value& v);

        //
        std::auto_ptr<as_array_object> splice(unsigned start, unsigned len,
                        const std::vector<as_value>& replacement);

        template <class AVCMP>
        void sort(AVCMP avc)
        {
                // IMPORTANT NOTE
                //
                // As for ISO/IEC 14882:2003 - 23.2.2.4.29 
                // the sort algorithm relies on the assumption
                // that the comparator function implements
                // a Strict Weak Ordering operator:
                // http://www.sgi.com/tech/stl/StrictWeakOrdering.html
                //
                // Invalid comparator can lead to undefined behaviour,
                // including invalid memory access and infinite loops.
                //
                // Pragmatically, it seems that std::list::sort is
                // more robust in this reguard, so we'll sort a list
                // instead of the queue. We want to sort a copy anyway
                // to avoid the comparator changing the original container.
                //

                std::list<as_value> nelem(elements.begin(), elements.end());

                nelem.sort(avc);

                elements.assign(nelem.begin(), nelem.end());
        }

        template <class AVCMP, class AVEQ>
        as_value sort(AVCMP avc, AVEQ ave)
        {
                // IMPORTANT NOTE
                //
                // As for ISO/IEC 14882:2003 - 23.2.2.4.29 
                // the sort algorithm relies on the assumption
                // that the comparator function implements
                // a Strict Weak Ordering operator:
                // http://www.sgi.com/tech/stl/StrictWeakOrdering.html
                //
                // Invalid comparator can lead to undefined behaviour,
                // including invalid memory access and infinite loops.
                //
                // Pragmatically, it seems that std::list::sort is
                // more robust in this reguard, so we'll sort a list
                // instead of the queue. We want to sort a copy anyway
                // to avoid the comparator changing the original container.
                //

                std::list<as_value> nelem(elements.begin(), elements.end());

                nelem.sort(avc);

                if (adjacent_find(nelem.begin(), nelem.end(), ave) != nelem.end() )
                        return as_value(0);

                elements.assign(nelem.begin(), nelem.end());

                return as_value(this);
        }

        template <class AVCMP>
        as_array_object* sort_indexed(AVCMP avc)
        {
                std::deque<indexed_as_value> ielem = get_indexed_elements();
                std::sort(ielem.begin(), ielem.end(), avc);
                return get_indices(ielem);
        }

        template <class AVCMP, class AVEQ>
        as_value sort_indexed(AVCMP avc, AVEQ ave)
        {
                std::deque<indexed_as_value> ielem = get_indexed_elements();

                std::sort(ielem.begin(), ielem.end(), avc);

                if (adjacent_find(ielem.begin(), ielem.end(), ave) != ielem.end() )
                        return as_value(0);

                return get_indices(ielem);
        }

        //
        virtual bool get_member(string_table::key name, as_value* val,
                string_table::key nsname = 0);

        virtual void set_member(string_table::key name,
                const as_value& val, string_table::key nsname = 0);

        //
        virtual void enumerateNonProperties(as_environment&) const;

protected:

#ifdef GNASH_USE_GC
        //
        virtual void markReachableResources() const;
#endif // GNASH_USE_GC

private:

        container elements;

        // this function is used internally by set_member and get_member
        // it takes a string that is the member name of the array and returns -1
        // if the string does not refer to an index, or an appropriate int if the string does refer to an index
        int index_requested(string_table::key name);

};


// needed by SWFHandlers::ActionInitArray
void array_class_init(as_object& global);

// needed by SWFHandlers::ActionInitArray
as_value        array_new(const fn_call& fn);

}

#endif

---