Indicate which property update function should be called in response to
Advisor events.

@function updateProp
@name updateProp
@instance
@memberof Law
510903
function(propName, updater) {
    var updaterName, handler;

    if(!isFunction(updater)) {
      updaterName = 'update' + propName[0].toUpperCase() + propName.slice(1);
      updater = this.governor[updaterName];
    }

    if(updater) {
      this.then(function(advisorEvent, deferred, consequenceActions, streamEvent) {
        var currVal = this.props[propName].value;
        var updaterArgs = [currVal].concat(advisorEvent, streamEvent);
        var retVal = updater.apply(this, updaterArgs);

        // Only trigger a reactive change if the value has actually changed;
        // if(!isEqual(retVal, currVal)) this.props[propName] = retVal;
        this.props[propName] = retVal

        deferred.resolve(retVal);
      });
    } else {
      throw new Error('An updater function was not specified and governor.' + updaterName + ' is not defined');
    }

    return this;
  }
1296229
function(action, data) {

    if(isUndefined(data)) {
      data = {};
    } else if(!isObject(data) && !isFunction) {
      throw new Error('Data passed to an advisor action must be in instance of Object.');
    }

    var executeAction;
    if(isFunction(data)) {
      executeAction = compose(this._askAdvisor.actions[action], data)
    } else {
      executeAction = partial(this._askAdvisor.actions[action], data);
    }

    this.then(function(advisorEvent, deferred, consequenceActions, streamEvent) {
      data.triggeringEvents = {
        advisor: advisorEvent,
        stream: streamEvent
      };
      if(isFunction(data)) {
        executeAction(advisorEvent, streamEvent);
      } else {
        if(this._waitTime) {
          setTimeout(function(){
            executeAction();
            deferred.resolve();
          }, this._waitTime);
          return;
        } else {
          executeAction();
        }
      }
      deferred.resolve();
    });

    // terminate chain
    return this;
  }
898428
function onUpdate (update) {
      var value = update[0], ts = update[1], id = update[2]
      insertBatch (id, key, ts, JSON.stringify(value), scuttlebutt)
    }
1265436
function editorUpdate() {
    if (editor.binding) {
      if ('hold' === generator.clientUpdateFragmentText(editor.binding, editor.$edit.val())) {
        editor.holding = true;
      }
    }
  }
99870
function (thisProperty, callbackArgs) {
                return function (callback) {

                    function notifyListener() {
                        if (Model.asyncEvents) {
                            setTimeout(function () {
                                callback.apply(thisProperty, callbackArgs);
                            }, 0);
                        } else {
                            callback.apply(thisProperty, callbackArgs);
                        }
                    }

                    if (Model.TRANSACTION_OPTIONS.flattenCallbacks || Model.TRANSACTION_OPTIONS.flattenCallbacksByHash) {
                        var callbackExecuted = false;
                        if (Model.TRANSACTION_OPTIONS.flattenCallbacks) {
                            if (executedCallbacks.indexOf(callback) === -1) { // Only call callback once
                                executedCallbacks.push(callback);
                                notifyListener();
                                callbackExecuted = true;
                            }
                        }
                        if (Model.TRANSACTION_OPTIONS.flattenCallbacksByHash) {
                            if (!callback.hash || callbackHashs.indexOf(callback.hash) === -1) { // Only call hash identified callback once
                                if (callback.hash) {
                                    callbackHashs.push(callback.hash);
                                }
                                if (!callbackExecuted) {
                                    notifyListener();
                                    callbackExecuted = true;
                                }
                            }
                        }
                    } else {
                        notifyListener();
                    }
                };
            }
226509
function (is_update) {
            this.no_diapason = false;
            this.coords.p_step = this.convertToPercent(this.options.step, true);

            this.target = "base";

            this.toggleInput();
            this.append();
            this.setMinMax();

            if (is_update) {
                this.force_redraw = true;
                this.calc(true);

                // callbacks called
                this.callOnUpdate();
            } else {
                this.force_redraw = true;
                this.calc(true);

                // callbacks called
                this.callOnStart();
            }

            this.updateScene();
        }
1069479
function updateObjectImpl(obj, update, isSelected) {
  if (isSelected(obj)) {
    return update(obj);
  }
  var result = obj;
  var changed = false;
  _lodash2.default.forOwn(obj, function (val, key) {
    var newval = updateValue(val, update, isSelected);
    if (newval === val) {
      return;
    }
    if (!changed) {
      result = _extends({}, obj);
      changed = true;
    }
    result[key] = newval;
  });
  return result;
}
44851
function update(form) {
      // refuse to work with invalid data
      if (!vm.clientModelDoc._id || form && !form.$valid) {
        return;
      }

      ClientModelDocService.update(vm.clientModelDoc)
        .then(updateClientModelDocSuccess)
        .catch(updateClientModelDocCatch);

      function updateClientModelDocSuccess(updatedClientModelDoc) {
        // update the display name after successful save
        vm.displayName = updatedClientModelDoc.name;
        Toast.show({text: 'ClientModelDoc ' + vm.displayName + ' updated'});
        if (form) {
          form.$setPristine();
        }
      }

      function updateClientModelDocCatch(err) {
        Toast.show({
          type: 'warn',
          text: 'Error while updating ClientModelDoc ' + vm.displayName,
          link: {state: $state.$current, params: $stateParams}
        });

        if (form && err) {
          form.setResponseErrors(err.data);
        }
      }
    }
499848
function (evt) {
            var changedProperties = evt.changedProperties;
            var localCfg = this._localDefCfg;
            var doUpdate = (changedProperties == null); // always do an update on reset
            if (changedProperties) {
                // look if the changed keys are part of this local environment
                for (var i = 0, l = changedProperties.length; i < l; i++) {
                    var propName = changedProperties[i];
                    if (propName in localCfg) {
                        doUpdate = true;
                        break;
                    }
                }
            }
            if (doUpdate) {
                evt.asyncCalls++;
                this._normAndApplyEnv(evt.callback);
            }
        }
25945
function() {

		this.Element$informInDOM();

		var input_element = this.getDOMElement();
		Firestorm.Element.addListener(input_element, "onpropertychange", this._OldIE_property_change_callback);
		Firestorm.Element.addListener(input_element, "selectionchange", this._OldIE_refresh_callback);
		Firestorm.Element.addListener(input_element, "keyup", this._OldIE_refresh_callback);
		Firestorm.Element.addListener(input_element, "keydown", this._OldIE_refresh_callback);

	}
727396
function() {
      var updateEvents = this.__parseUpdateEvents();
      _.each(updateEvents, function(parsedUpdateEvent) {
        this.stopListening(parsedUpdateEvent.idContainer, parsedUpdateEvent.eventName, this.retrieve);
      }, this);
    }
337543
function update() {
    var updateData = this._prepUpdate(this.single.update);
    var wheres = this.where();
    var returning = this.single.returning;
    return {
      sql: 'update ' + this.tableName + ' set ' + updateData.join(', ') + (wheres ? ' ' + wheres : '') + this._returning(returning),
      returning: returning
    };
  }
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;
        }
983607
function (property, callback) {
        var sum = 0
        this.each(function(e){
            if (e[property]) sum += e[property]
        })
        this.fn('sum', callback).call(this, sum)
    }
1079520
function(event, address) {
        var columnModel = this.columnModel.getColumnModel(address.columnName);
        var eventType, editOptions, handler;

        if (!columnModel) {
            return;
        }

        eventType = event.type;
        editOptions = columnModel.editOptions || {};
        handler = editOptions[getEventHandlerName(eventType)];

        if (_.isFunction(handler)) {
            handler.call(event.target, event, address);
        }
    }
1348622
function(property_name) {

		if (Lava.schema.DEBUG && property_name == null) Lava.t("firePropertyChanged: property_name is null");

		if (this._property_listeners[property_name] != null) {

			this._callListeners(this._property_listeners[property_name]);

		}

	}
902947
function(e) {
	   inputEx.StringField.superclass.onFocus.call(this,e);

	   if(this.options.typeInvite) {
         this.updateTypeInvite();
      }
	}