PropertyList.h

Go to the documentation of this file.

// 
//   Copyright (C) 2005, 2006, 2007, 2008, 2009, 2010, 2011, 2012
//   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_PROPERTYLIST_H
#define GNASH_PROPERTYLIST_H

#include <set> 
#include <string> // for use within map 
#include <cassert> // for inlines
#include <utility> // for std::pair
#include <boost/cstdint.hpp> 
#include <boost/multi_index_container.hpp>
#include <boost/multi_index/ordered_index.hpp>
#include <boost/multi_index/sequenced_index.hpp>
#include <boost/multi_index/key_extractors.hpp>
#include <boost/noncopyable.hpp>
#include <boost/bind.hpp>
#include <algorithm>

#include "Property.h" // for templated functions

// Forward declaration
namespace gnash {
    class as_object;
    class as_function;
    struct ObjectURI;
    class as_value;
}

namespace gnash {

class PropertyVisitor {
public:

    virtual bool accept(const ObjectURI& uri, const as_value& val) = 0;
    virtual ~PropertyVisitor() {}
};

class KeyVisitor {
public:

    virtual void operator()(const ObjectURI& uri) = 0;
    virtual ~KeyVisitor() {}
};


//
//
//
class PropertyList : boost::noncopyable
{
public:

    typedef std::set<ObjectURI, ObjectURI::LessThan> PropertyTracker;
    typedef Property value_type;

    struct CreationOrder {};

    typedef boost::multi_index::sequenced<
        boost::multi_index::tag<CreationOrder> > SequencedIndex;
    
    struct KeyExtractor
    {
        typedef const ObjectURI& result_type;
        result_type operator()(const Property& p) const {
            return p.uri();
        }
    };

    struct Case {};
    
    typedef boost::multi_index::ordered_unique<
        boost::multi_index::tag<Case>,
        KeyExtractor,
        ObjectURI::LessThan> CaseIndex;

    struct NoCase {};
    
    typedef boost::multi_index::ordered_non_unique<
        boost::multi_index::tag<NoCase>,
        KeyExtractor,
        ObjectURI::CaseLessThan> NoCaseIndex;

    typedef boost::multi_index_container<
        value_type,
        boost::multi_index::indexed_by<SequencedIndex, CaseIndex, NoCaseIndex>
        > container;

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

    //
    PropertyList(as_object& obj);

    //
    //
    //
    template <class U, class V>
    void visitValues(V& visitor, U cmp = U()) const {

        for (const_iterator it = _props.begin(), ie = _props.end();
                it != ie; ++it) {

            if (!cmp(*it)) continue;
            as_value val = it->getValue(_owner);
            if (!visitor.accept(it->uri(), val)) return;
        }
    }

    //
    void visitKeys(KeyVisitor& v, PropertyTracker& donelist) const;

    //
    bool setValue(const ObjectURI& uri, const as_value& value,
            const PropFlags& flagsIfMissing = 0);

    //
    Property* getProperty(const ObjectURI& uri) const;

    //
    std::pair<bool,bool> delProperty(const ObjectURI& uri);

    //
    //
    bool addGetterSetter(const ObjectURI& uri, as_function& getter,
        as_function* setter, const as_value& cacheVal,
        const PropFlags& flagsIfMissing = 0);

    //
    bool addGetterSetter(const ObjectURI& uri, as_c_function_ptr getter,
        as_c_function_ptr setter, const PropFlags& flagsIfMissing);

    //
    bool addDestructiveGetter(const ObjectURI& uri, as_function& getter,
        const PropFlags& flagsIfMissing = 0);

    //                          one is created.
    bool addDestructiveGetter(const ObjectURI& uri, as_c_function_ptr getter, 
        const PropFlags& flagsIfMissing = 0);

    //
    void setFlags(const ObjectURI& uri, int setTrue, int setFalse);

    //
    void setFlagsAll(int setTrue, int setFalse);

    void clear();

    size_t size() const {
        return _props.size();
    }

    //
    void dump();

    //
    void setReachable() const {
        std::for_each(_props.begin(), _props.end(),
                boost::mem_fn(&Property::setReachable));
    }

private:

    container _props;

    as_object& _owner;

};


} // namespace gnash

#endif // GNASH_PROPERTYLIST_H