Property.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_PROPERTY_H
#define GNASH_PROPERTY_H

#include <boost/variant.hpp>
#include <cassert>
#include <functional>
#include <typeinfo>

#include "PropFlags.h"
#include "as_value.h"
#include "ObjectURI.h"
#include "dsodefs.h" // for DSOTEXPORT

namespace gnash {
    typedef as_value (*as_c_function_ptr)(const fn_call& fn);
    class as_function;
}

namespace gnash {

//
class GetterSetter
{
    class NativeGetterSetter;

    // The following helper structs define common operations on the 
    // Two types of GetterSetter. Some operations are applicable only to
    // one type.

    //
    template<typename Arg, typename S>
    struct GetSetVisitor : boost::static_visitor<typename S::result_type>
    {
        GetSetVisitor(const Arg& arg) : _arg(arg) {}
        template<typename T> typename S::result_type operator()(T& t) const {
            return S()(t, _arg);
        }
    private:
        const Arg& _arg;
    };

    struct Set
    {
        typedef void result_type;
        template<typename T, typename Arg>
        result_type operator()(T& t, Arg& a) const {
            t.set(a);
        }
    };
                                
    struct Get
    {
        typedef as_value result_type;
        template<typename T, typename Arg>
        result_type operator()(T& t, Arg& a) const {
            return t.get(a);
        }
    };

    //
    struct SetUnderlying : boost::static_visitor<>
    {
        template<typename T>
        result_type operator()(T& gs, const as_value& val) const {
            gs.setUnderlying(val);
        }
        result_type operator()(NativeGetterSetter&, const as_value&) const {}
    };
    
    //
    struct GetUnderlying : boost::static_visitor<as_value>
    {
        template<typename T>
        result_type operator()(const T& gs) const {
            return gs.getUnderlying();
        }
        result_type operator()(const NativeGetterSetter&) const {
            return result_type();
        }
    };
    
    struct MarkReachable : boost::static_visitor<>
    {
        template<typename T>
        result_type operator()(const T& gs) const {
            gs.markReachableResources();
        }
    };

public:

        GetterSetter(as_function* getter, as_function* setter)
                :
                _getset(UserDefinedGetterSetter(getter, setter))
        {}

        GetterSetter(as_c_function_ptr getter, as_c_function_ptr setter)
                :
                _getset(NativeGetterSetter(getter, setter))
        {}

        as_value get(fn_call& fn) const {
        GetSetVisitor<const fn_call, Get> s(fn);
        return boost::apply_visitor(s, _getset);
        }

        void set(const fn_call& fn) {
        GetSetVisitor<fn_call, Set> s(fn);
        boost::apply_visitor(s, _getset);
        }

        void setCache(const as_value& v) {
            boost::apply_visitor(
                std::bind(SetUnderlying(), std::placeholders::_1, v), _getset);
        }

        as_value getCache() const {
        return boost::apply_visitor(GetUnderlying(), _getset);
        }

        void markReachableResources() const {
        boost::apply_visitor(MarkReachable(), _getset);
        }

private:

        class UserDefinedGetterSetter
    {
        public:

                UserDefinedGetterSetter(as_function* get, as_function* set)
                        :
                        _getter(get),
                        _setter(set),
                        _underlyingValue(),
                        _beingAccessed(false)
                {}

                as_value get(const fn_call& fn) const;

                void set(const fn_call& fn);

                const as_value& getUnderlying() const { return _underlyingValue; }

                void setUnderlying(const as_value& v) { _underlyingValue = v; }

                void markReachableResources() const;

        private:

        //
                class ScopedLock : boost::noncopyable
        {
                public:

                        explicit ScopedLock(const UserDefinedGetterSetter& na)
                :
                _a(na),
                _obtainedLock(_a._beingAccessed ? false : true)
                        {
                // If we didn't obtain the lock it would be true anyway,
                // but it's probably polite to avoid touching it.
                if (_obtainedLock) _a._beingAccessed = true;
                        }

                        ~ScopedLock() { if ( _obtainedLock) _a._beingAccessed = false; }

                        //
                        bool obtainedLock() const { return _obtainedLock; }

        private:

                        const UserDefinedGetterSetter& _a;
                        bool _obtainedLock;

        };

                as_function* _getter;
                as_function* _setter;
                as_value _underlyingValue;
                mutable bool _beingAccessed;
    };

        class NativeGetterSetter 
    {
        public:

                NativeGetterSetter(as_c_function_ptr get, as_c_function_ptr set)
                        :
                        _getter(get), _setter(set) {}

                as_value get(const fn_call& fn) const {
                        return _getter(fn);
                }

                void set(const fn_call& fn) {
                        _setter(fn);
                }

        void markReachableResources() const {}

        private:
                as_c_function_ptr _getter;
                as_c_function_ptr _setter;
        };

        boost::variant<UserDefinedGetterSetter, NativeGetterSetter> _getset;

};

//
//
class Property
{

    struct SetReachable : boost::static_visitor<>
    {
        result_type operator()(const as_value& val) const {
            val.setReachable();
        }
        result_type operator()(const GetterSetter& gs) const {
            return gs.markReachableResources();
        }
    };

public:

        Property(ObjectURI uri, const as_value& value,
            PropFlags flags)
        :
        _bound(value),
                _uri(std::move(uri)),
                _flags(std::move(flags)),
        _destructive(false)
        {}

        Property(ObjectURI uri,
                as_function* getter, as_function* setter, 
                PropFlags flags, bool destroy = false)
        :
        _bound(GetterSetter(getter, setter)),
        _uri(std::move(uri)),
                _flags(std::move(flags)), 
                _destructive(destroy)
        {}

        Property(ObjectURI uri, as_c_function_ptr getter,
            as_c_function_ptr setter, PropFlags flags,
            bool destroy = false)
                :
        _bound(GetterSetter(getter, setter)),
        _uri(std::move(uri)),
                _flags(std::move(flags)),
        _destructive(destroy)
        {}

        const PropFlags& getFlags() const { return _flags; }

    void setFlags(const PropFlags& flags) const {
        _flags = flags;
    }

        //
        DSOTEXPORT as_value getValue(const as_object& this_ptr) const;

        //
        as_value getCache() const;

        //
        void setCache(const as_value& v);

        //
        bool setValue(as_object& this_ptr, const as_value &value) const;

        bool isGetterSetter() const {
        return _bound.type() == typeid(GetterSetter);
    }

        void clearVisible(int swfVersion) { _flags.clear_visible(swfVersion); }

    const ObjectURI& uri() const {
        return _uri;
    }

        void setReachable() const {
        return boost::apply_visitor(SetReachable(), _bound);
    }

private:

        // Store the various types of things that can be held.
        typedef boost::variant<as_value, GetterSetter> BoundType;

        mutable BoundType _bound;
        
    ObjectURI _uri;

        mutable PropFlags _flags;

        // If true, as soon as getValue has been invoked once, the
        // returned value becomes a fixed return (though it can be
        // overwritten if not readOnly)
        mutable bool _destructive;

};
        
inline bool
readOnly(const Property& prop) {
    return prop.getFlags().test<PropFlags::readOnly>();
}

inline bool
visible(const Property& prop, int version) {
    return prop.getFlags().get_visible(version);
}

} // namespace gnash

#endif // GNASH_PROPERTY_H