Set simple property
358425
function(obj, name, value) {
  Object.defineProperty(obj, name, {
    enumerable: true,
    get: function() {
      return value;
    }
  });
}
1108133
function() {

            var that = this;
            var propertiesParams = that.__getPropertiesParam();

            _.each(propertiesParams, function(params, property) {

                var value = that.__getPropertyValue(property);

                if (_.isUndefined(value) && 'default' in params) {

                    var defaultValue = params.default;

                    if (_.isFunction(defaultValue)) {
                        defaultValue = defaultValue.call(that);
                    }

                    if (defaultValue) {
                        if ((_.isSimpleObject(defaultValue)) || _.isArray(defaultValue)) {
                            defaultValue = _.clone(defaultValue)
                        }
                    }

                    that.__setPropertyValue(property, defaultValue, false);
                }
            });
        }
627761
def _set(self, obj, value):
        """"""
        if value not in self.lenum:
            raise ValueError("Not a valid value: %s" % value)

        type(obj).__dict__[self.propname].__set__(obj, value)
1282034
def set(key, value = nil)
      if key.is_a?(Hash)
        properties.merge!(key)
      else
        properties[key] = value
      end
    end
404033
public static void set(Object obj, String property, Object value) throws Throwable {
        getSetterMethod(obj.getClass(), property).invoke(obj, value);
    }
1279915
def set(self, name, value=True):
        ""
        setattr(self, name.lower(), value)
711997
def set_rule(self, name, properties):
        
        self._rule_attrs.append(name)
        setattr(self, name, properties)
343319
function Property (initValue) {
		if (arguments.length) {
			this.set(initValue);
		}
		else {
			this.set(this.defaultValue);
		}
		ok.Data.apply(this, arguments);
	}
166555
function(object, defaultValue, property) {
        if (!_.isUndefined(defaultValue)) {
            object.__setPropertyParam(property, 'default', defaultValue);
        }
    }
591676
function setReadOnly( obj, prop, value ) {
	Object.defineProperty( obj, prop, {
		'value': value,
		'configurable': false,
		'writable': false,
		'enumerable': true
	});
}
777467
function set (obj, key, val) {
	  if (Array.isArray(obj)) {
	    obj.splice(key, 1, val);
	    return val
	  }
	  if (hasOwn(obj, key)) {
	    obj[key] = val;
	    return
	  }
	  var ob = obj.__ob__;
	  if (obj._isVue || (ob && ob.vmCount)) {
	    "development" !== 'production' && warn(
	      'Avoid adding reactive properties to a Vue instance or its root $data ' +
	      'at runtime - declare it upfront in the data option.'
	    );
	    return
	  }
	  if (!ob) {
	    obj[key] = val;
	    return
	  }
	  defineReactive$$1(ob.value, key, val);
	  ob.dep.notify();
	  return val
	}
788772
function setPropertyByPath(obj, propString, value) {

    var propNames = propString.split('.');
    var propLength = propNames.length - 1;
    var tmpObj = obj;

    for (var i = 0; i <= propLength; i++) {
        tmpObj = tmpObj[propNames[i]] = i !== propLength ? {} : value;
    }
    return obj;
}
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);
        }
    );
}
1366089
def _set_property(self, val, *args):
        """"""
        val = UserClassAdapter._set_property(self, val, *args)
        if val:
            Adapter._set_property(self, val, *args)
        return val
543568
def set_on_level(self, val):
        """"""
        on_cmd = self._create_set_property_msg("_on_level", 0x06,
                                               val)
        self._send_method(on_cmd, self._property_set)
        self._send_method(on_cmd, self._on_message_received)
342190
private static void setSimpleValue(Object obj, Property property, Object value) {
        if (property == null) {
            throw new IllegalArgumentException("Cannot set a new value to a property with a 'null' propertyName.");
        }

        property.set(obj, value);
    }
1344186
def set_property(key, value):
    
    def decorate_func(func):
        setattr(func, key, value)
        if func.__doc__ and key == "fctype":
            func.__doc__ = func.__doc__ + "\n\n    *This function is of type: " + value + "*\n"
        return func
    return decorate_func