Helper: Configures getter and setter for one async prop
966562
function getDescriptorForAsyncProp(name) {
  return {
    configurable: false,
    enumerable: true,
    // Save the provided value for async props in a special map
    set(newValue) {
      if (typeof newValue === 'string' || newValue instanceof Promise) {
        this._asyncPropOriginalValues[name] = newValue;
      } else {
        this._asyncPropResolvedValues[name] = newValue;
      }
    },
    // Only the component's state knows the true value of async prop
    get() {
      if (this._asyncPropResolvedValues) {
        // Prop value isn't async, so just return it
        if (name in this._asyncPropResolvedValues) {
          const value = this._asyncPropResolvedValues[name];

          // Special handling - components expect null `data` prop expects to be replaced with `[]`
          if (name === 'data') {
            return value || this._asyncPropDefaultValues[name];
          }

          return value;
        }

        if (name in this._asyncPropOriginalValues) {
          // It's an async prop value: look into component state
          const state = this._component && this._component.internalState;
          if (state && state.hasAsyncProp(name)) {
            return state.getAsyncProp(name);
          }
        }
      }

      // the prop is not supplied, or
      // component not yet initialized/matched, return the component's default value for the prop
      return this._asyncPropDefaultValues[name];
    }
  };
}
677064
function set (target, key, val) {
  if (Array.isArray(target) && typeof key === 'number') {
    target.length = Math.max(target.length, key);
    target.splice(key, 1, val);
    return val
  }
  if (hasOwn(target, key)) {
    target[key] = val;
    return val
  }
  var ob = (target ).__ob__;
  if (target._isVue || (ob && ob.vmCount)) {
    process.env.NODE_ENV !== 'production' && warn(
      'Avoid adding reactive properties to a Vue instance or its root $data ' +
      'at runtime - declare it upfront in the data option.'
    );
    return val
  }
  if (!ob) {
    target[key] = val;
    return val
  }
  defineReactive$$1(ob.value, key, val);
  ob.dep.notify();
  return val
}
1022692
function makeGetterAndSetter(name, key) {
        moment.fn[name] = moment.fn[name + 's'] = function (input) {
            var utc = this._isUTC ? 'UTC' : '';
            if (input != null) {
                this._d['set' + utc + key](input);
                moment.updateOffset(this);
                return this;
            } else {
                return this._d['get' + utc + key]();
            }
        };
    }
608807
function set(app, prop, val) {
  var data = app.cache.data.project;
  if (typeof val !== 'undefined') {
    data[prop] = val;
  } else if (typeof app.cache.data[prop] !== 'undefined') {
    data[prop] = app.cache.data[prop];
  }
}
778070
function inheritFrom(target, propsInSyncWithParent) {
  var this$1 = this;

  each(Object.keys(target), function (k) {
    // some properties must be always in sync with the parent tag
    var mustSync = !isReservedName(k) && contains(propsInSyncWithParent, k);

    if (isUndefined(this$1[k]) || mustSync) {
      // track the property to keep in sync
      // so we can keep it updated
      if (!mustSync) { propsInSyncWithParent.push(k); }
      this$1[k] = target[k];
    }
  });
}
1130592
function(object, key, def) {
		if (this._isaccessor(def)) {
			return Object.defineProperty(object, key, {
				enumerable: true,
				configurable: true,
				get: def.getter || this._NOGETTER,
				set: def.setter || this._NOSETTER
			});
		} else {
			throw new TypeError("Expected getter and/or setter method");
		}
	}
1029307
function _set_property(itemsObject, name, value) {
  const nameArray = name.split(".");
  if (nameArray[1]) {
    itemsObject[nameArray[0]][nameArray[1]] = value;
  } else {
    itemsObject[name] = value;
  }
}
567417
public static void setPropertyEL(Object obj, String prop, Object value) {

	// first check for field
	Field[] fields = getFieldsIgnoreCase(obj.getClass(), prop, null);
	if (!ArrayUtil.isEmpty(fields)) {
	    try {
		fields[0].set(obj, value);
		return;
	    }
	    catch (Throwable t) {
		ExceptionUtil.rethrowIfNecessary(t);
	    }
	}

	// then check for setter
	try {
	    getSetter(obj, prop, value).invoke(obj);
	}
	catch (Throwable t) {
	    ExceptionUtil.rethrowIfNecessary(t);
	}

    }
859048
function Sync(path) {
  if (typeof path !== 'string' || arguments.length > 1) { throw new Error('Property decorators can be used for single property access') }
  return createDecorator((options, key) => {
    if (!options.computed) options.computed = {}
    options.computed[key] = sync(path)
  })
}
669572
function(prop){
        var props = {},
            len, i = 0, item;

        prop = Array.from(prop);
        len = prop.length;
        
        while(len--){
            props[prop[i++]] = void 0;
        }

        // void 0 is used because 'undefined' is a var that can be changed in some browsers
        this.set(props);

        return this;
    }
882782
function set(appName, keyValues, keyLimits, callback) {
    var config = {};

    if (!isObject(keyValues)) {
      return callback(new Error('To set a variable pass an object'));
    }

    config.values = keyValues;

    if (isObject(keyLimits)) {
      if (keyLimits.hasOwnProperty('memory')) {
        config.memory = keyLimits.memory;
      }
      if (keyLimits.hasOwnProperty('cpu')) {
        config.cpu = keyLimits.cpu;
      }
    } else {
      callback = keyLimits;
    }

    var uri = format('/%s/apps/%s/config/', deis.version, appName);
    commons.post(uri, config, function onSetResponse(err, result) {
      callback(err, result ? result.values : null);
    });
  }
369073
function simple_setters (setters) {
        // loop over the setter keys and make a mutation for each
        return Object.keys(setters).reduce(function (mutations, name) {

            // attach our new mutation to result
            return Object.assign({}, mutations, defineProperty({}, name, function (state, value) {

                // if the setter name has a dot, then resolve the
                // state path before feeding our value into it.
                if (setters[name].indexOf('.') > -1) {
                    var obj = setters[name].split('.');
                    var key = obj.pop();

                    resolveObjectPath(state, obj)[key] = value;
                }

                // otherwise, just set the state to our value
                else state[setters[name]] = value;
            }));
        }, {});
    }
72084
function forAsync(items, iter, callback) {
	var keys = Object.keys(items);
	var step = function (err, callback) {
		nextTick(function () {
			if (err) {
				return callback(err);
			}
			if (keys.length === 0) {
				return callback();
			}
			var key = keys.pop();
			iter(items[key], key, function (err) {
				step(err, callback);
			});
		});
	};
	step(null, callback);
}
1009632
def _set_property(self, val, *args):
        """"""
        if self._prop_write:
            val = self._prop_write(val)
        return self._setter(Adapter._get_property(self), val, *args)
898009
public static void callSetter(Object target, PropertyDescriptor prop, Object value) {

        Method setter = prop.getWriteMethod();

        if (setter == null) {
            return;
        }

        try {

            setter.invoke(target, new Object[]{value});
        } catch (IllegalArgumentException e) {
            throw new RuntimeException(
                    "Cannot set " + prop.getName() + ": " + e.getMessage(), e);

        } catch (IllegalAccessException e) {
            throw new RuntimeException(
                    "Cannot set " + prop.getName() + ": " + e.getMessage(), e);

        } catch (InvocationTargetException e) {
            throw new RuntimeException(
                    "Cannot set " + prop.getName() + ": " + e.getMessage(), e);
        }
    }
965599
function set_property(X, wid, prop, type, format, data, null_terminated, cb) {

    if (typeof null_terminated === 'function') {
        cb = null_terminated;
        null_terminated = undefined;
    }

    async.parallel(
        [
            function get_prop_atom(cb) {
                if (typeof prop === 'string') {
                    X.InternAtom(false, prop, cb);
                } else {
                    cb(undefined, prop);
                }
            },
            function get_type_atom(cb) {
                if (typeof type === 'string') {
                    X.InternAtom(false, type, cb);
                } else {
                    cb(undefined, type);
                }
            }
        ],
        function(err, results) {
            if (err) {
                if (cb) {
                    cb(err);
                }

                return;
            }


            _set_property(X, wid, results[0], results[1], format, data, null_terminated, cb);
        }
    );
}
816243
function (name, prop) {
		this.unsetProperty(name);
		this.properties[name] = prop;
		this.listenTo(prop, EVENT_CHANGE, this.change);
		return prop;
	}