The setter follows the rules of the getter. First search
          for property variable, then logical custom getter/setter pair
          methods
547803
def get_setter(cls, prop_name,  # @NoSelf
                   user_setter=None, setter_takes_name=False,
                   user_getter=None, getter_takes_name=False):
        """"""

        _inner_setter = ObservablePropertyMeta.get_setter(cls, prop_name,
                                            user_setter, setter_takes_name,
                                            user_getter, getter_takes_name)

        def _setter(self, val):
            self._prop_lock.acquire()
            _inner_setter(self, val)
            self._prop_lock.release()
        return _setter
634210
function(property, name, weight, callback) {
            if (_.isUndefined(callback)) {
                callback = weight;
                weight   = 0;
            }
            if (_.isArray(callback)) {
                weight   = callback[0];
                callback = callback[1];
            }
            else if (!_.isFunction(callback)) {
                throw new Error('Setter callback must be a function!');
            }
            if (!(property in this.__setters)) {
                this.__setters[property] = {};
            }
            this.__setters[property][name] = [weight, callback];

            return this;
        }
1218741
private Object getPropertyTypeValue(Class propertyType, Object value) {
        if (propertyType.equals(String.class)) {
            return value.toString();
        } else if (propertyType.equals(Boolean.class) || propertyType.equals(Boolean.TYPE)) {
            Boolean arg = null;
            if (value instanceof Boolean) {
                arg = (Boolean) value;
            } else {
                arg = Boolean.parseBoolean(value.toString());
            }
            return arg;
        } else if (propertyType.equals(Short.class) || propertyType.equals(Short.TYPE)) {
            Short arg = null;
            if (value instanceof Short) {
                arg = (Short) value;
            } else {
                arg = Short.parseShort(value.toString());
            }
            return arg;
        } else if (propertyType.equals(Integer.class) || propertyType.equals(Integer.TYPE)) {
            Integer arg = null;
            if (value instanceof Integer) {
                arg = (Integer) value;
            } else {
                arg = Integer.parseInt(value.toString());
            }
            return arg;
        } else if (propertyType.equals(Long.class) || propertyType.equals(Long.TYPE)) {
            Long arg = null;
            if (value instanceof Long) {
                arg = (Long) value;
            } else {
                arg = Long.parseLong(value.toString());
            }
            return arg;
        } else if (propertyType.equals(Float.class) || propertyType.equals(Float.TYPE)) {
            Float arg = null;
            if (value instanceof Float) {
                arg = (Float) value;
            } else {
                arg = Float.parseFloat(value.toString());
            }
            return arg;
        } else if (propertyType.equals(Double.class) || propertyType.equals(Double.TYPE)) {
            Double arg = null;
            if (value instanceof Double) {
                arg = (Double) value;
            } else {
                arg = Double.parseDouble(value.toString());
            }
            return arg;
        } else { // Object
            return value;
        }
    }
664662
function defineProp(obj, prop, getter) {
  if (Object.defineProperty) {
    Object.defineProperty(obj, prop, { get: getter });
  }
}
955178
@SuppressWarnings("unchecked")
    private void fixGetSet(HashMap<String, HashMap> propertyTable) {

        if (propertyTable == null) {
            return;
        }

        for (Map.Entry<String, HashMap> entry : propertyTable.entrySet()) {
            HashMap<String, Object> table = entry.getValue();
            ArrayList<Method> getters = (ArrayList<Method>) table.get(STR_GETTERS);
            ArrayList<Method> setters = (ArrayList<Method>) table.get(STR_SETTERS);

            Method normalGetter = null;
            Method normalSetter = null;

            Class<?> normalPropType = null;

            if (getters == null) {
                getters = new ArrayList<>();
            }

            if (setters == null) {
                setters = new ArrayList<>();
            }

            // retrieve getters
            Class<?>[] paramTypes;
            String methodName;
            for (Method getter : getters) {
                paramTypes = getter.getParameterTypes();
                methodName = getter.getName();
                // checks if it's a normal getter
                if (paramTypes == null || paramTypes.length == 0) {
                    // normal getter found
                    if (normalGetter == null || methodName.startsWith(PREFIX_IS)) {
                        normalGetter = getter;
                    }
                }
            }

            // retrieve normal setter
            if (normalGetter != null) {
                // Now we will try to look for normal setter of the same type.
                Class<?> propertyType = normalGetter.getReturnType();

                for (Method setter : setters) {
                    if (setter.getParameterTypes().length == 1
                        && propertyType.equals(setter.getParameterTypes()[0])) {
                        normalSetter = setter;
                        break;
                    }
                }
            } else {
                // Normal getter wasn't defined. Let's look for the last
                // defined setter

                for (Method setter : setters) {
                    if (setter.getParameterTypes().length == 1) {
                        normalSetter = setter;
                    }
                }
            }

            // determine property type
            if (normalGetter != null) {
                normalPropType = normalGetter.getReturnType();
            } else if (normalSetter != null) {
                normalPropType = normalSetter.getParameterTypes()[0];
            }

            // RULES
            // These rules were created after performing extensive black-box
            // testing of RI

            // RULE1
            // Both normal getter and setter of the same type were defined;
            // no indexed getter/setter *PAIR* of the other type defined
            if (normalGetter != null && normalSetter != null) {
                table.put(STR_NORMAL, STR_VALID);
                table.put(STR_NORMAL + PREFIX_GET, normalGetter);
                table.put(STR_NORMAL + PREFIX_SET, normalSetter);
                table.put(STR_NORMAL + STR_PROPERTY_TYPE, normalPropType);
                continue;
            }

            // RULE2
            // normal getter and/or setter was defined; no indexed
            // getters & setters defined
            if ((normalGetter != null || normalSetter != null)) {
                table.put(STR_NORMAL, STR_VALID);
                table.put(STR_NORMAL + PREFIX_GET, normalGetter);
                table.put(STR_NORMAL + PREFIX_SET, normalSetter);
                table.put(STR_NORMAL + STR_PROPERTY_TYPE, normalPropType);
                continue;
            }

            // default rule - invalid property
            table.put(STR_NORMAL, STR_INVALID);
        }
    }
1357342
function (localConfig, propertyName, propertyObject) {
    var presetCheck = defaultConfig.presets[propertyName][propertyObject];
    if (presetCheck) return $.extend(true, {}, presetCheck, localConfig);
    return localConfig
  }
18861
protected function set_field() {

		$properties = get_class_vars( __CLASS__ );

		// Some things must run before the others.
		$this->set_option_type();
		$this->set_settings();

		// Sanitize the properties, skipping the ones that have already run above.
		foreach ( $properties as $property => $value ) {
			if ( in_array( $property, [ 'option_name', 'option_type', 'settings' ], true ) ) {
				continue;
			}
			if ( method_exists( $this, 'set_' . $property ) ) {
				$method_name = 'set_' . $property;
				$this->$method_name();
			}
		}

		// Get all arguments with their values.
		$args = get_object_vars( $this );
		foreach ( array_keys( $args ) as $key ) {
			$args[ $key ] = $this->$key;
		}

		// Add the field to the static $fields variable properly indexed.
		Kirki::$fields[ $this->settings ] = $args;

	}
1224705
function makeSetter(name, typeChecker) {

  /**
   * Binding a setter method to the Cursor class and having the following
   * definition.
   *
   * Note: this is not really possible to make those setters variadic because
   * it would create an impossible polymorphism with path.
   *
   * @todo: perform value validation elsewhere so that tree.update can
   * beneficiate from it.
   *
   * Arity (1):
   * @param  {mixed} value - New value to set at cursor's path.
   *
   * Arity (2):
   * @param  {path}  path  - Subpath to update starting from cursor's.
   * @param  {mixed} value - New value to set.
   *
   * @return {mixed}       - Data at path.
   */
  Cursor.prototype[name] = function(path, value) {

    // We should warn the user if he applies to many arguments to the function
    if (arguments.length > 2)
      throw makeError(`Baobab.Cursor.${name}: too many arguments.`);

    // Handling arities
    if (arguments.length === 1 && !INTRANSITIVE_SETTERS[name]) {
      value = path;
      path = [];
    }

    // Coerce path
    path = coercePath(path);

    // Checking the path's validity
    if (!type.path(path))
      throw makeError(`Baobab.Cursor.${name}: invalid path.`, {path});

    // Checking the value's validity
    if (typeChecker && !typeChecker(value))
      throw makeError(`Baobab.Cursor.${name}: invalid value.`, {path, value});

    // Checking the solvability of the cursor's dynamic path
    if (!this.solvedPath)
      throw makeError(
        `Baobab.Cursor.${name}: the dynamic path of the cursor cannot be solved.`,
        {path: this.path}
      );

    const fullPath = this.solvedPath.concat(path);

    // Filing the update to the tree
    return this.tree.update(
      fullPath,
      {
        type: name,
        value
      }
    );
  };
}
1175856
public static Method getSetterMethod(Class<?> clazz, String propertyName, Class<?> parameterType) {
		String setterMethodName = SETTER_PREFIX + StringUtils.capitalize(propertyName);
		return getMethod(clazz, setterMethodName, parameterType);
	}
495377
public void setProperty(String property, Object newValue) {
        /** @todo we should check if we have the property with the metaClass instead of try/catch  */
        try {
            super.setProperty(property, newValue);
        }
        catch (MissingPropertyException e) {
            setVariable(property, newValue);
        }
    }
4277
function defineProperty(obj, prop, getter) {
  Object.defineProperty(obj, prop, {
    configurable: true,
    enumerable: true,
    get: getter
  });
}
325859
function makeGetterSetter(name) {
        xkcd[name] = function (value) {
            if (arguments.length === 0) {
                return config[name];
            }
            config[name] = value;
            return xkcd;
        };
    }
625330
private static Object filterPropertyMethod(Object methodOrList, boolean isGetter, boolean booleanGetter) {
        // Method has been optimized to reach a target of 325 bytecode size, making it JIT'able
        Object ret = null;

        if (methodOrList instanceof MetaMethod) {
            MetaMethod element = (MetaMethod)methodOrList;
            int parameterCount = element.getParameterTypes().length;
            if (!isGetter &&
                    //(element.getReturnType() == Void.class || element.getReturnType() == Void.TYPE) &&
                    parameterCount == 1) {
                ret = element;
            }
            Class returnType = element.getReturnType();
            if (isGetter &&
                    !(returnType == Void.class || returnType == Void.TYPE) &&
                    (!booleanGetter || returnType == Boolean.class || returnType == Boolean.TYPE) &&
                    parameterCount == 0) {
                ret = element;
            }
        }
        if (methodOrList instanceof FastArray) {
            FastArray methods = (FastArray) methodOrList;
            final int len = methods.size();
            final Object[] data = methods.getArray();
            for (int i = 0; i != len; ++i) {
                MetaMethod element = (MetaMethod) data[i];
                int parameterCount = element.getParameterTypes().length;
                if (!isGetter &&
                        //(element.getReturnType() == Void.class || element.getReturnType() == Void.TYPE) &&
                        parameterCount == 1) {
                    ret = addElementToList(ret, element);
                }
                Class returnType = element.getReturnType();
                if (isGetter &&
                        !(returnType == Void.class || returnType == Void.TYPE) &&
                        parameterCount == 0) {
                    ret = addElementToList(ret, element);
                }
            }
        }

        if (ret == null
                || (ret instanceof MetaMethod)
                || !isGetter) {
            return ret;
        }

        // we found multiple matching methods
        // this is a problem, because we can use only one
        // if it is a getter, then use the most general return
        // type to decide which method to use. If it is a setter
        // we use the type of the first parameter
        MetaMethod method = null;
        int distance = -1;
        for (final Object o : ((List) ret)) {
            MetaMethod element = (MetaMethod) o;
            int localDistance = distanceToObject(element.getReturnType());
            //TODO: maybe implement the case localDistance==distance
            if (distance == -1 || distance > localDistance) {
                distance = localDistance;
                method = element;
            }
        }
        return method;
    }
356352
function (scope, key, getter) {
      var value = null, args = Array.prototype.slice.call(arguments);
      var params = (args.length > 3) ? args.slice(3) : [];

      Object.defineProperty(scope, key, {
        get: function () {
          if (value === null) value = getter.apply(scope, params);
          return value;
        }
      });
    }
1036504
boolean setValue( Object object, String propertyName, Object value )
	{
		Clazz<?> s = ClassInfo.Clazz( object.getClass() );

		if( Property.class == getPropertyType( s, propertyName ) )
		{
			Property<Object> property = getPropertyImpl( object, propertyName );
			if( property != null )
			{
				property.setValue( value );
				return true;
			}

			return false;
		}

		return setPropertyImpl( s, object, propertyName, value );
	}
1035088
private Method findSetter(Method []methods, String getterName, Class< ? > arg) {
        String setterName = "set" + getterName.substring(INT_VALUE);
	    
        for (int i = 0; i < methods.length; i++) {
            Method method = methods[i];

            if (!method.getName().equals(setterName)) {
                continue;
            }
            
            if (!method.getReturnType().equals(void.class)) {
                continue;
            }

            Class< ? > []params = method.getParameterTypes();

            if (params.length == 1 && params[0].equals(arg)) {
                return method;
            }
        }
        return 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;
            }));
        }, {});
    }