Sets property value, even if private.
<br/>
Swallows JaversException.MISSING_PROPERTY

@param target invocation target
@param value value to be set
438727
public void set(Object target, Object value) {
        try {
            member.setEvenIfPrivate(target, value);
        } catch (JaversException e) {
            if (e.getCode() == JaversExceptionCode.MISSING_PROPERTY) {
                return; //swallowed
            }
            throw e;
        }
    }
765394
@Override
    public void setProperty(String name, Object value) throws SAXNotRecognizedException, SAXNotSupportedException{
        if(!_setProperty(name, value))
            throw new SAXNotRecognizedException(name);
    }
542500
private static void setValue(Object obj, String propertyPattern, Object value, ObjectWrapper options) {
        if (propertyPattern == null) {
            throw new IllegalArgumentException("Cannot set a new value to a property with a 'null' propertyPattern.");
        }

        if (obj == null) {
            // NullPointerException as it is throwed only when traversing a null object (ex: "foo.null.bar")
            throw new NullPointerException("Cannot set the value of '" + propertyPattern + "' to a 'null' object.");
        }

        // '.' position if positive, '[' inverse position if negative
        int position = indexOfDotOrSquare(propertyPattern);

        // (propertyPattern.contains("."))
        if (position > 0) {
            String leftPattern = propertyPattern.substring(0, position);
            String rightPattern = propertyPattern.substring(position + 1, propertyPattern.length());
            Object leftValue = getValue(obj, leftPattern, options);

            if (leftValue == null) {
                Property leftProperty = getPropertyOrThrow(Bean.forClass(obj.getClass()), leftPattern);

                if (options.isAutoInstancing) {
                    try {
                        leftValue = leftProperty.getType().newInstance();
                    } catch (Exception e) {
                        throw new ReflectionException("The value of " + leftProperty + " was 'null' in the object "
                                                              + obj.getClass().getName() + ". An attempt to invoke its 'no-args constructor'" +
                                                              " was made, but an error occurs.", e);
                    }

                    leftProperty.set(obj, leftValue);
                }
            }

            setValue(leftValue, rightPattern, value, options);
            // if (propertyPattern.contains("["))
        } else if (position < 0) {
            int squarePosition = -position;

            String leftPattern = propertyPattern.substring(0, squarePosition);
            String indexOrKey = propertyPattern.substring(squarePosition + 1, propertyPattern.length() - 1);// removes ']'
            Property leftProperty = getPropertyOrThrow(Bean.forClass(obj.getClass()), leftPattern);

            if (leftProperty.getType().isAssignableFrom(Map.class)) {
                setMappedValue(obj, leftProperty, indexOrKey, value, options);
            } else {
                try {
                    setIndexedValue(obj, leftProperty, Integer.parseInt(indexOrKey), value, options);
                } catch (NumberFormatException e) {
                    throw new IllegalArgumentException("The pattern '" + indexOrKey + "' for the indexed "
                                                               + leftProperty + " is invalid. Cannot parse the string to a valid integer index.");
                }
            }
        } else {
            setSimpleValue(obj, getPropertyOrThrow(Bean.forClass(obj.getClass()), propertyPattern), value);
        }
    }
1187793
public void setProperty(String key, String value)
  {
    if(key.equals(OutputKeys.METHOD))
    {
      setMethodDefaults(value);
    }
    
    if (key.startsWith(OutputPropertiesFactory.S_BUILTIN_OLD_EXTENSIONS_UNIVERSAL))
      key = OutputPropertiesFactory.S_BUILTIN_EXTENSIONS_UNIVERSAL
         + key.substring(OutputPropertiesFactory.S_BUILTIN_OLD_EXTENSIONS_UNIVERSAL_LEN);
    
    m_properties.put(key, value);
  }
533854
@Override
	public void setProperty(String property, Object value) {
		if (property.equals(PROPERTY_LOCATION)) {
			location = String.valueOf(value);
		} else {
			throw new KriptonRuntimeException("unsupported property: " + property);
		}
	}
1337331
public void setTarget(Map<String, Object> target) {
        removeEntriesStartingWith(TARGET);
        eventMap.putAll(target);
    }
545038
public static String setOrAppend(final String target, final String value, final boolean withSpace) {
        if (target == null) {
            return value;
        }if(value == null) {
            return target;
        } else {
            if (withSpace && !target.endsWith(STRING_BLANK)) {
                return target + STRING_BLANK + value;
            } else {
                return target + value;
            }
        }
    }
1255851
@SuppressWarnings("unchecked")
    public void setProperty(Object obj, Object key, Object value) {
        if (isMap(obj))
            ((Map) obj).put(key.toString(), value);
        else {
            throw new JsonPathException("setProperty operation cannot be used with " + obj!=null?obj.getClass().getName():"null");
        }
    }
777022
@Override
    public void set(String propName, Object value) {
        if (propName.equals("checkPoint")) {
            getCheckPoint().add(((com.ibm.wsspi.security.wim.model.CheckPointType) value));
        }
        super.set(propName, value);
    }
319329
public void executeSetValue(Object pvObject, Object pvArgs) throws IllegalArgumentException, IllegalAccessException, InvocationTargetException {
		AccessController.doPrivileged(new AccessiblePrivilegedAction(accessibleObject));
		if (propertyType == PROPERTY_TYPE_METHOD) {
			((Method) accessibleObject).invoke(pvObject, new Object[] { pvArgs });	
		} else {
			((Field) accessibleObject).set(pvObject, pvArgs);
		}
	}
1205868
public void set( String name, Object value )
        throws EvalError
    {
        // map null to Primtive.NULL coming in...
        if ( value == null )
            value = Primitive.NULL;

        CallStack callstack = new CallStack();
        try {
            if ( Name.isCompound( name ) )
            {
                LHS lhs = globalNameSpace.getNameResolver( name ).toLHS(
                    callstack, this );
                lhs.assign( value, false );
            } else // optimization for common case
                globalNameSpace.setVariable( name, value, false );
        } catch ( UtilEvalError e ) {
            throw e.toEvalError( SimpleNode.JAVACODE, callstack );
        }
    }
966322
@Override
    public void setTarget(String target) {

        if (TraceComponent.isAnyTracingEnabled() && TRACE.isDebugEnabled()) {
            SibTr.debug(this, TRACE, "setTarget", target);
        }
        _target = 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);
        }
    }
1151109
public static void setLocalProperty(final String key, final String value) {
        if (null == key) {
            LOGGER.log(Level.WARN, "local.props can not set null key");

            return;
        }
        if (null == value) {
            LOGGER.log(Level.WARN, "local.props can not set null value");

            return;
        }

        localProps.setProperty(key, value);
    }
822939
public void set(Object obj, String name, Object value) {
        try {
            PropertyUtils.setNestedProperty(obj, name, value);
        } catch (Exception e) {
            error(e);
        }
    }
349776
public void setStringValue(String property, String value) {
		try {
			if (jsMBean != null) {
				setProperty(jsMBean, property, value);
			}
			if (cssMBean != null) {
				setProperty(cssMBean, property, value);
			}
			if (binaryMBean != null) {
				setProperty(binaryMBean, property, value);
			}
		} catch (IllegalAccessException | InvocationTargetException | NoSuchMethodException e) {
			throw new JmxConfigException("Exception while setting the string value", e);
		}
	}
385560
public void setValueFor(Field target, Object value) {
        if(value == null && target.getType().isPrimitive()) {
            throw new ND4JIllegalStateException("Unable to set primitive field " + target + " of type " + target.getClass()
                    + " using null value!");
        }

        if(value != null) {
            value = ensureProperType(target, value);
        }

        if(isConfigProperties()){
            String propertyName = configFieldName();
            if(propertyName == null)
                propertyName = "config";
            Field f = null;
            Class<?> currClass = getClass();
            try{
                f = currClass.getDeclaredField(propertyName);
            } catch (NoSuchFieldException e){
                //OK, try superclass
            }
            while(f == null && currClass.getSuperclass() != null){
                currClass = currClass.getSuperclass();
                try{
                    f = currClass.getDeclaredField(propertyName);
                } catch (NoSuchFieldException e){
                    //OK, try superclass
                }
            }

            if(f == null){
                throw new IllegalStateException("Could not find field \"" + propertyName + "\" for class " + getClass().getName());
            }

            try {
                f.setAccessible(true);
                Object o = f.get(this);
                if(o == null){
                    //Null config class - try to create one...
                    Class<?> c = f.getType();
                    try {
                        o = c.newInstance();
                    } catch (InstantiationException e){
                        throw new RuntimeException("Error creating new instance of configuration object type " + c.getName(), e);
                    }
                    f.set(this, o);
                }
                target.set(o, value);
            } catch (IllegalAccessException e){
                throw new RuntimeException("Error setting configuration field \"" + propertyName + "\" for config field \"" + propertyName
                    + "\" on class " + getClass().getName());
            }

        } else {
            try {
                target.set(this,value);
            } catch (IllegalAccessException e) {
                throw new RuntimeException("Error setting property for function " + getClass().getName(), e);
            }
        }
    }