Indicate that all prop update functions should be called in resonse to a
Law's Advisor events.

@function updateProps
@name updateProps
@instance
@memberof Law
357484
function() {
    var props = arguments.length ? toArray(arguments) : keys(this.governor.props);
    forEach(props, this.updateProp, this);
    return this;
  }
78029
function (name, func)
        {
            if (typeof(ModalDialog.events) == 'undefined') {
                ModalDialog.events = [];
            }
    
            ModalDialog.events.push([name, func]);
        }
1024062
function(prop) {
      var args = Array.prototype.slice.apply(arguments, [1]);
      if (this.setter[prop]) {
        this.setter[prop].apply(this, args);
      } else {
        this[prop] = args.join(',');
      }
    }
1270068
function updatePropertyConfiguration() {

  // Fetch extensions implementing .updatePropertyConfiguration(...) method
  var extensions = _lodash2.default.filter(this.extensions, function (extension) {
    return extension.implemented.updatePropertyConfiguration;
  });

  // Create a proxy .updatePropertyConfiguration(...) method
  this.updatePropertyConfiguration = function (propertyConfiguration) {
    // Execute all extensions' .updatePropertyConfiguration(...) method
    _lodash2.default.forEach(extensions, function (extension) {
      extension.updatePropertyConfiguration(propertyConfiguration);
    });
  };
}
13646
function (observer, property) {
        if (!property)
            property = ALL;
        var arr = this.props[property];
        if (!arr) {
            // property is not observed yet
            arr = [];
            this.props[property] = arr;
        }
        arr.push(observer);
    }
1281807
function(props, callback) {
            callback = callback || function() {};
            
            if (props.hasOwnProperty("name")) {
                throw new Error("Cannot set 'name' field in 'update'");
            }
            
            var that = this;
            var req = this.post("", props, function(err, response) {
                if (!err && !that.fetchOnUpdate) {
                    that._load(response.data.entry);
                    callback(err, that);
                }
                else if (!err && that.fetchOnUpdate) {
                    that.fetch(function() {
                        if (req.wasAborted) {
                            return; // aborted, so ignore
                        }
                        else {
                            callback.apply(null, arguments);
                        }
                    });
                }
                else {
                    callback(err, that);
                }
            });
            
            return req;
        }
720152
function setFunction(descriptor,key,set,update)
        {
          var _descriptor = descriptor,
              _descVal = _descriptor.value,
              _key = key,
              _set = set,
              _update = update,
              _action;
          return function functionSet()
          {
            if(_set(this,_key,null,null,arguments,this._stopChange))
            {
              _action = _descVal.apply(this,arguments);
            }
            if(!this._stopChange)
            {
              _update(this,_key,null,null,arguments,_action);
            }
            this._stopChange = undefined;
            return _action;
          }
        }
903750
def update(self, *args, **kwargs):
        """"""
        self._call_helper("Updating", self.real.update, *args, **kwargs)
94834
function updateAll (state, prefix, changedProperties) {
  var type = typeof changedProperties
  var docs

  if (type !== 'object' && type !== 'function') {
    return Promise.reject(new Error('Must provide object or function'))
  }

  var options = {
    include_docs: true
  }

  if (prefix) {
    options.startkey = prefix
    options.endkey = prefix + '\uffff'
  }

  return state.db.allDocs(options)

  .then(function (res) {
    docs = res.rows
      .filter(isntDesignDoc)
      .map(function (row) {
        return row.doc
      })

    docs.forEach(addTimestamps)

    if (type === 'function') {
      docs.forEach(changedProperties)
      return docs
    }

    return docs.map(function (doc) {
      assign(doc, changedProperties, {_id: doc._id, _rev: doc._rev, hoodie: doc.hoodie})
      return doc
    })
  })

  .then(bulkDocs.bind(null, state))
}
305157
function tracker(prop) {
    function _tracker(context) {
      return function(_prop, _arg) {
        context.deps[_prop] = context.deps[_prop] || [];
        if (!context.deps[_prop].reduce(function found(prev, curr) {
              return prev || (curr[0] === prop);
            }, false)) {
          context.deps[_prop].push([prop, instance]);
        }
        return context(_prop, _arg, true);
      }
    }
    var result = _tracker(instance);
    construct(result);
    result.parent = parent ? _tracker(parent) : null;
    result.root = _tracker(root || instance);
    return result;
  }
559362
function() { // add all the event listeners for every input and event type
				each(inp_change_events, function(event_type) {
					each(inps, function(inp) {
						aEL(inp, event_type, on_change);
					});
				});
			}
1119691
function() {
      inputEx.KeyValueField.superclass.initEvents.call(this);

      this.inputs[0].updatedEvt.subscribe(this.onSelectFieldChange, this, true); 
   }
512430
public void propertyChange(PropertyChangeEvent evt) {
		if (evt.getPropertyName() == HAS_ERRORS_PROPERTY)
			updateErrors();
		else if (evt.getPropertyName() == HAS_WARNINGS_PROPERTY)
			updateWarnings();
		else if (evt.getPropertyName() == HAS_INFO_PROPERTY)
			updateInfo();
	}
715862
function updateBoolean(name) {
  name = ' ' + name;
  function update(value) {
    switch (value) {
      case true:
      case 'true':
        return name;
    }
    return '';
  }
  update[UID] = true;
  return update;
}
881130
function(update, ids) {
		this._updates.push(update);
		if (update.type === edbml.Update.TYPE_HARD) {
			this._hardupdates[update.id] = true;
		} else {
			update.ids = ids || {};
		}
		return this;
	}
440840
function updatePropertyConfiguration () {

  // Fetch extensions implementing .updatePropertyConfiguration(...) method
  let extensions = _.filter(this.extensions, (extension) => {
    return extension.implemented.updatePropertyConfiguration;
  });

  // Create a proxy .updatePropertyConfiguration(...) method
  this.updatePropertyConfiguration =  (propertyConfiguration) => {
    // Execute all extensions' .updatePropertyConfiguration(...) method
    _.forEach(extensions, (extension) => {
      extension.updatePropertyConfiguration(propertyConfiguration);
    });
  };

}
214247
function appendAttrs(action, attrs, _updates, opts) {
  var updates = isTypeUpdates(this) ? this : (_updates || (new Updates()));

  if (attrs && hasKeysOnly(attrs)) {
    appendAttrsKeysOnly(action, attrs, updates, opts);
  } else if (typeof attrs === "object") {
    util.forIn(attrs, function(value, key) {
      if (value !== null && typeof value !== 'undefined')
        appendAttr(action, key, value, updates, opts);
    });
  }
  
  return updates;
}