26.1.13 Reflect.set(target, propertyKey, V [, receiver])
778758
function set$1(target, propertyKey, V /* , receiver */) {
	  var receiver = arguments.length < 4 ? target : arguments[3];
	  var ownDesc = _objectGopd.f(_anObject(target), propertyKey);
	  var existingDescriptor, proto;
	  if (!ownDesc) {
	    if (_isObject(proto = _objectGpo(target))) {
	      return set$1(proto, propertyKey, V, receiver);
	    }
	    ownDesc = _propertyDesc(0);
	  }
	  if (_has(ownDesc, 'value')) {
	    if (ownDesc.writable === false || !_isObject(receiver)) return false;
	    if (existingDescriptor = _objectGopd.f(receiver, propertyKey)) {
	      if (existingDescriptor.get || existingDescriptor.set || existingDescriptor.writable === false) return false;
	      existingDescriptor.value = V;
	      _objectDp.f(receiver, propertyKey, existingDescriptor);
	    } else _objectDp.f(receiver, propertyKey, _propertyDesc(0, V));
	    return true;
	  }
	  return ownDesc.set === undefined ? false : (ownDesc.set.call(receiver, V), true);
	}
1060433
function(source, target, key) {
		var desc = Object.getOwnPropertyDescriptor(source, key);
		desc = this._accessor(target, key, desc);
		Object.defineProperty(target, key, desc);
		return target;
	}
751725
public static void invokeSetter(Object target, String property, Object parameter) {
        Method setter = getSetter(target, property, parameter.getClass());
        try {
            setter.invoke(target, parameter);
        } catch (IllegalAccessException e) {
            throw handleException(setter.getName(), e);
        } catch (InvocationTargetException e) {
            throw handleException(setter.getName(), e);
        }
    }
1157042
function set (target, key, value, receiver) {
  // make sure to do not pollute the raw object with observables
  if (typeof value === 'object' && value !== null) {
    value = proxyToRaw.get(value) || value
  }
  // save if the object had a descriptor for this key
  const hadKey = hasOwnProperty.call(target, key)
  // save if the value changed because of this set operation
  const oldValue = target[key]
  // execute the set operation before running any reaction
  const result = Reflect.set(target, key, value, receiver)
  // do not queue reactions if the target of the operation is not the raw receiver
  // (possible because of prototypal inheritance)
  if (target !== proxyToRaw.get(receiver)) {
    return result
  }
  // queue a reaction if it's a new property or its value changed
  if (!hadKey) {
    queueReactionsForOperation({ target, key, value, receiver, type: 'add' })
  } else if (value !== oldValue) {
    queueReactionsForOperation({
      target,
      key,
      value,
      oldValue,
      receiver,
      type: 'set'
    })
  }
  return result
}
546967
function(newValues, oldValues, paths) {
      var name, method, called = {};
      for (var i in oldValues) {
        // note: paths is of form [object, path, object, path]
        name = paths[2 * i + 1];
        method = this.observe[name];
        if (method) {
          var ov = oldValues[i], nv = newValues[i];
          // observes the value if it is an array
          this.observeArrayValue(name, nv, ov);
          if (!called[method]) {
            // only invoke change method if one of ov or nv is not (undefined | null)
            if ((ov !== undefined && ov !== null) || (nv !== undefined && nv !== null)) {
              called[method] = true;
              // TODO(sorvell): call method with the set of values it's expecting;
              // e.g. 'foo bar': 'invalidate' expects the new and old values for
              // foo and bar. Currently we give only one of these and then
              // deliver all the arguments.
              this.invokeMethod(method, [ov, nv, arguments]);
            }
          }
        }
      }
    }
1217953
function (target, src) {
	for (var key in src) {
		if (src.hasOwnProperty(key)) {
			target[key] = src[key];
		}
	}
}
513917
public static void set(PropertyKey key, Object value) {
    set(key, String.valueOf(value), Source.RUNTIME);
  }
60347
function shallowCopyTargetProperty(target, source) {
  let properties = Object.keys(target);

  for (let i = 0; i < properties.length; ++i) {
    if (source.hasOwnProperty(properties[i])) {
      target[properties[i]] = source[properties[i]];
    }
  }
}
49013
function get (target, key, receiver) {
  const result = Reflect.get(target, key, receiver)
  // do not register (observable.prop -> reaction) pairs for well known symbols
  // these symbols are frequently retrieved in low level JavaScript under the hood
  if (typeof key === 'symbol' && wellKnownSymbols.has(key)) {
    return result
  }
  // register and save (observable.prop -> runningReaction)
  registerRunningReactionForOperation({ target, key, receiver, type: 'get' })
  // if we are inside a reaction and observable.prop is an object wrap it in an observable too
  // this is needed to intercept property access on that object too (dynamic observable tree)
  const observableResult = rawToProxy.get(result)
  if (hasRunningReaction() && typeof result === 'object' && result !== null) {
    if (observableResult) {
      return observableResult
    }
    // do not violate the none-configurable none-writable prop get handler invariant
    // fall back to none reactive mode in this case, instead of letting the Proxy throw a TypeError
    const descriptor = Reflect.getOwnPropertyDescriptor(target, key)
    if (
      !descriptor ||
      !(descriptor.writable === false && descriptor.configurable === false)
    ) {
      return observable(result)
    }
  }
  // otherwise return the observable wrapper if it is already created and cached or the raw object
  return observableResult || result
}
968042
function set(Key, MaybeValue) {

        flocksLog(3, " - Flocks2 multi-set");

        if (typeof Key === "string")      { return setByKey(Key, MaybeValue); }
        else if (isArray(Key))            { return setByPath(Key, MaybeValue); }
//      else if (isNonArrayObject(Key))   { return setByObject(Key); }              // todo
        else                              { throw "Flocks2 set/1,2 key must be a string or an array"; }

    }
288626
function setProperties(target/*, source, ...*/)
	{
		var i = 1,
			max = arguments.length,
			source, prop;

		for (; i < max; ++i)
		{
			source = arguments[i];
			if (!(source instanceof Object))
				continue;

			for (prop in source)
			{
				if (source[prop] == null)
					continue;

				target[prop] = source[prop];
			}
		}

		return target;
	}
540793
def property_set sym, val
      oldvalue = instance_variable_get "@#{sym}"
      tmp = val.size == 1 ? val[0] : val
      newvalue = tmp
      if oldvalue.nil? || @_object_created.nil?
        #@#{sym} = tmp
        instance_variable_set "@#{sym}", tmp
      end
      return(self) if oldvalue.nil? || @_object_created.nil?

      if oldvalue != newvalue
        # trying to reduce calls to fire, when object is being created
        begin
          @property_changed = true
          fire_property_change("#{sym}", oldvalue, newvalue) if !oldvalue.nil?
          #@#{sym} = tmp
          instance_variable_set "@#{sym}", tmp
          #@config["#{sym}"]=@#{sym}
        rescue PropertyVetoException
          $log.warn "PropertyVetoException for #{sym}:" + oldvalue.to_s + "->  "+ newvalue.to_s
        end
      end # if old
      self
    end
1317299
protected void copyIfSet(Properties target, String key) {
		String value = this.properties.get(key);
		if (StringUtils.hasText(value)) {
			target.put(key, value);
		}
	}
1229166
public static void set(Object target, Field field, String fieldVal)
    {
        PropertyAccessor<?> accessor = PropertyAccessorFactory.getPropertyAccessor(field);
        Object value = accessor.fromString(target.getClass(), fieldVal);
        set(target, field, value);
    }
1221430
function (target, prop, receiver) {
        if (isBoxedState(target)) {
            if (prop === BOXED_GET_THIS) return target;
            if (prop === target.saveBoxedProp) return target.saveBoxed;
            if (prop === target.cancelBoxedProp) return target.cancelBoxed;
            if (prop === target.boxOptionsProp) return target.boxOptions;
            return target.getBoxed()[prop];
        }
        throw new TypeError("BoxedStateHandler: IllegalArgument expected BoxedState target");
    }
1233270
public void setProperty(String key, String val) {

	ArrayList list  = null;
	Object oldValue = null;

	oldValue = getProperty(key);

	appProps.setProperty(key, val);
	if (listeners.containsKey(key)) {
	  list = (ArrayList)listeners.get(key);
	  int len = list.size();
	  if (len > 0) {
		PropertyChangeEvent evt = new PropertyChangeEvent(this, key, oldValue, val);
          for (Object aList : list) {
              if (aList instanceof PropertyChangeListener)
                  ((PropertyChangeListener) aList).propertyChange(evt);
          }
	  }
	}

  }
1071712
public void registerPropertyExclusion( Class target, String propertyName ) {
      if( target != null && propertyName != null ) {
         Set set = (Set) exclusionMap.get( target );
         if( set == null ){
            set = new HashSet();
            exclusionMap.put(  target, set );
         }
         if( !set.contains( propertyName )){
            set.add(propertyName );
         }
      }
   }