libcore/Property.cpp

   1 //
   2 //   Copyright (C) 2005, 2006, 2007, 2008, 2009, 2010 Free Software
   3 //   Foundation, Inc
   4 //
   5 // This program is free software; you can redistribute it and/or modify
   6 // it under the terms of the GNU General Public License as published by
   7 // the Free Software Foundation; either version 3 of the License, or
   8 // (at your option) any later version.
   9 //
  10 // This program is distributed in the hope that it will be useful,
  11 // but WITHOUT ANY WARRANTY; without even the implied warranty of
  12 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13 // GNU General Public License for more details.
  14 //
  15 // You should have received a copy of the GNU General Public License
  16 // along with this program; if not, write to the Free Software
  17 // Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
  18
  19 #include "Property.h"
  20
  21 #include <boost/variant.hpp>
  22 #include <boost/bind.hpp>
  23
  24 #include "VM.h"
  25 #include "as_function.h"
  26 #include "as_environment.h"
  27 #include "fn_call.h"
  28
  29 namespace gnash {
  30
  31 namespace {
  32
  33 // TODO: drop this.
  34 enum Type {
  35     TYPE_VALUE,
  36     TYPE_GETTER_SETTER
  37 };
  38
  39 /// Get the cache of a variant member.
  40 struct GetCache : boost::static_visitor<as_value>
  41 {
  42     result_type operator()(as_value& val) const {
  43         return val;
  44     }
  45     result_type operator()(GetterSetter& gs) const {
  46         return gs.getCache();
  47     }
  48 };
  49
  50 /// Set the cache of a variant member.
  51 struct SetCache : boost::static_visitor<>
  52 {
  53     result_type operator()(as_value& val, const as_value& n) const {
  54         val = n;
  55     }
  56     result_type operator()(GetterSetter& gs, const as_value& n) const {
  57         gs.setCache(n);
  58     }
  59 };
  60
  61 }
  62
  63 void
  64 GetterSetter::UserDefinedGetterSetter::markReachableResources() const
  65 {
  66         if (_getter) _getter->setReachable();
  67         if (_setter) _setter->setReachable();
  68         _underlyingValue.setReachable();
  69 }
  70
  71 as_value
  72 GetterSetter::UserDefinedGetterSetter::get(const fn_call& fn) const
  73 {
  74         ScopedLock lock(*this);
  75         if (!lock.obtainedLock()) {
  76                 return _underlyingValue;
  77         }
  78
  79         if (_getter) return _getter->call(fn);
  80
  81     // should we return underlyingValue here ?
  82         return as_value();
  83 }
  84
  85 void
  86 GetterSetter::UserDefinedGetterSetter::set(const fn_call& fn)
  87 {
  88         ScopedLock lock(*this);
  89         if (!lock.obtainedLock() || ! _setter) {
  90                 _underlyingValue = fn.arg(0);
  91                 return;
  92         }
  93
  94         _setter->call(fn);
  95 }
  96
  97 as_value
  98 Property::getValue(const as_object& this_ptr) const
  99 {
 100         switch (_bound.which())
 101         {
 102         case TYPE_VALUE:
 103             return boost::get<as_value>(_bound);
 104         case TYPE_GETTER_SETTER:
 105         {
 106             const GetterSetter* a = boost::get<const GetterSetter>(&_bound);
 107
 108             as_environment env(getVM(this_ptr));
 109             fn_call fn(const_cast<as_object*>(&this_ptr), env);
 110             if (_destructive)
 111             {
 112                 as_value ret = a->get(fn);
 113                 // The getter might have called the setter, and we
 114                 // should not override.
 115                 if (_destructive) {
 116                     _bound = ret;
 117                     _destructive = false;
 118                 }
 119                 return ret;
 120             }
 121             return a->get(fn);
 122         }
 123         }
 124     return as_value();
 125 }
 126
 127 as_value
 128 Property::getCache() const
 129 {
 130     return boost::apply_visitor(GetCache(), _bound);
 131 }
 132
 133 void
 134 Property::setValue(as_object& this_ptr, const as_value &value) const
 135 {
 136         switch (_bound.which())
 137         {
 138         case TYPE_VALUE:
 139             _bound = value;
 140             return;
 141         case TYPE_GETTER_SETTER:
 142             // Destructive are always overwritten.
 143             if (_destructive) {
 144                 _destructive = false;
 145                 _bound = value;
 146             }
 147             else {
 148                 GetterSetter* a = boost::get<GetterSetter>(&_bound);
 149
 150                 as_environment env(getVM(this_ptr));
 151
 152                 fn_call::Args args;
 153                 args += value;
 154
 155                 fn_call fn(&this_ptr, env, args);
 156
 157                 a->set(fn);
 158                 a->setCache(value);
 159             }
 160             return;
 161         }
 162 }
 163
 164 void
 165 Property::setCache(const as_value& value)
 166 {
 167     boost::apply_visitor(boost::bind(SetCache(), _1, value), _bound);
 168 }
 169
 170 } // namespace gnash