Sets the property value on bean definition in case value
is set properly.

@param builder the bean definition builder to be configured
@param propertyValue the property value
@param propertyName the name of the property
433233
public static void setPropertyValue(BeanDefinitionBuilder builder, String propertyValue, String propertyName) {
        if (StringUtils.hasText(propertyValue)) {
            builder.addPropertyValue(propertyName, propertyValue);
        }
    }
434309
public Datatype.Builder setValueType(TypeClass valueType) {
    this.valueType = Objects.requireNonNull(valueType);
    _unsetProperties.remove(Property.VALUE_TYPE);
    return (Datatype.Builder) this;
  }
933313
private static void setProperty( Object bean, String key, Object value, JsonConfig jsonConfig )
         throws Exception {
      PropertySetStrategy propertySetStrategy = jsonConfig.getPropertySetStrategy() != null ? jsonConfig.getPropertySetStrategy()
            : PropertySetStrategy.DEFAULT;
      propertySetStrategy.setProperty( bean, key, value, jsonConfig );
   }
803482
public void setProperty(final String property, final Object newValue) {
        if (property.startsWith("@")) {
            if (newValue instanceof String || newValue instanceof GString) {
                final Iterator iter = iterator();

                while (iter.hasNext()) {
                    final NodeChild child = (NodeChild) iter.next();

                    child.attributes().put(property.substring(1), newValue);
                }
            }
        } else {
            final GPathResult result = new NodeChildren(this, property, this.namespaceTagHints);

            if (newValue instanceof Map) {
                for (Object o : ((Map) newValue).entrySet()) {
                    final Map.Entry entry = (Map.Entry) o;
                    result.setProperty("@" + entry.getKey(), entry.getValue());
                }
            } else {
                if (newValue instanceof Closure) {
                    result.replaceNode((Closure) newValue);
                } else {
                    result.replaceBody(newValue);
                }
            }
        }
    }
240254
public void setExtProperty(String propName, String propValue) {
        if (m_extProperties == null) {
            m_extProperties = new HashMap<String, String>();
        }
        m_extProperties.put(propName, propValue);

    }
929318
public Datatype.Builder setBuilder(Type builder) {
    this.builder = Objects.requireNonNull(builder);
    _unsetProperties.remove(Property.BUILDER);
    return (Datatype.Builder) this;
  }
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);
        }
    }
47973
public function setProperty(&$object, $propertyName, $propertyValue)
    {
        $property = $this->getPropertyInstance($object, $propertyName);
        $property->setAccessible(true);
        $property->setValue($object, $propertyValue);
    }
86607
public DescriptionBuilder property(final Consumer<PropertyBuilder> builder) {
        PropertyBuilder propertyBuilder = PropertyBuilder.builder();
        builder.accept(propertyBuilder);
        replaceOrAddProperty(propertyBuilder.build());
        return this;
    }
1367447
@Override
	public void setProperty(String name, Object value) {
		if(currentBeanConfig != null) {
			if(value instanceof GString)value = value.toString();
			if(addToDeferred(currentBeanConfig, name, value)) {
				return;
			}
			else if(value instanceof Closure) {
				BeanConfiguration current = currentBeanConfig;
				try {
					Closure callable = (Closure)value;

					Class parameterType = callable.getParameterTypes()[0];
					if(parameterType.equals(Object.class)) {
						currentBeanConfig = springConfig.createSingletonBean("");
						callable.call(new Object[]{currentBeanConfig});
					}
					else {
						currentBeanConfig = springConfig.createSingletonBean(parameterType);
						callable.call(null);
					}

					value = currentBeanConfig.getBeanDefinition();
				}
				finally {
					currentBeanConfig = current;
				}
			}
            currentBeanConfig.addProperty(name, value);
		} else {
            binding.put(name,value);
        }
	}
604842
public static void setPropValue(final Object entity, final String propName, final Object propValue) {
        setPropValue(entity, propName, propValue, false);
    }
984485
@Override
    public void setPropertyValue(PropertyInfo propInfo, Object value) {
        setPropertyValue(propInfo.getId(), value);
    }
954903
@Override
    public void setProperty(String name, Object value) {
        if (currentBeanConfig != null) {
            setPropertyOnBeanConfig(name, value);
        }
    }
1013118
public void setObjectProperty(String objectType, String propertyType, String propertyValue) {
        logger.debug("objectType: " + objectType);
        logger.debug("propType: " + propertyType);
        logger.debug("property: " + propertyValue);

        if (objectType == null) {
            logger.error("Cannot add property for null object");
            return;
        }
        if (propertyType == null) {
            logger.error("Cannot add property for null property type");
            return;
        }
        if (propertyValue == null) {
            logger.warn("Will not add null property");
            return;
        }

        if (objectType.equals("Molecule")) {
            if (propertyType.equals("id")) {
                currentMolecule.setID(propertyValue);
            } else if (propertyType.equals("inchi")) {
                currentMolecule.setProperty("iupac.nist.chemical.identifier", propertyValue);
            }
        } else if (objectType.equals("PseudoAtom")) {
            if (propertyType.equals("label")) {
                if (!(currentAtom instanceof IPseudoAtom)) {
                    currentAtom = builder.newInstance(IPseudoAtom.class, currentAtom);
                }
                ((IPseudoAtom) currentAtom).setLabel(propertyValue);
            }
        } else if (objectType.equals("Atom")) {
            if (propertyType.equals("type")) {
                if (propertyValue.equals("R") && !(currentAtom instanceof IPseudoAtom)) {
                    currentAtom = builder.newInstance(IPseudoAtom.class, currentAtom);
                }
                currentAtom.setSymbol(propertyValue);
            } else if (propertyType.equals("x2")) {
                Point2d coord = currentAtom.getPoint2d();
                if (coord == null) coord = new Point2d();
                coord.x = Double.parseDouble(propertyValue);
                currentAtom.setPoint2d(coord);
            } else if (propertyType.equals("y2")) {
                Point2d coord = currentAtom.getPoint2d();
                if (coord == null) coord = new Point2d();
                coord.y = Double.parseDouble(propertyValue);
                currentAtom.setPoint2d(coord);
            } else if (propertyType.equals("x3")) {
                Point3d coord = currentAtom.getPoint3d();
                if (coord == null) coord = new Point3d();
                coord.x = Double.parseDouble(propertyValue);
                currentAtom.setPoint3d(coord);
            } else if (propertyType.equals("y3")) {
                Point3d coord = currentAtom.getPoint3d();
                if (coord == null) coord = new Point3d();
                coord.y = Double.parseDouble(propertyValue);
                currentAtom.setPoint3d(coord);
            } else if (propertyType.equals("z3")) {
                Point3d coord = currentAtom.getPoint3d();
                if (coord == null) coord = new Point3d();
                coord.z = Double.parseDouble(propertyValue);
                currentAtom.setPoint3d(coord);
            } else if (propertyType.equals("xFract")) {
                Point3d coord = currentAtom.getFractionalPoint3d();
                if (coord == null) coord = new Point3d();
                coord.x = Double.parseDouble(propertyValue);
                currentAtom.setFractionalPoint3d(coord);
            } else if (propertyType.equals("yFract")) {
                Point3d coord = currentAtom.getFractionalPoint3d();
                if (coord == null) coord = new Point3d();
                coord.y = Double.parseDouble(propertyValue);
                currentAtom.setFractionalPoint3d(coord);
            } else if (propertyType.equals("zFract")) {
                Point3d coord = currentAtom.getFractionalPoint3d();
                if (coord == null) coord = new Point3d();
                coord.z = Double.parseDouble(propertyValue);
                currentAtom.setFractionalPoint3d(coord);
            } else if (propertyType.equals("formalCharge")) {
                currentAtom.setFormalCharge(Integer.parseInt(propertyValue));
            } else if (propertyType.equals("charge") || propertyType.equals("partialCharge")) {
                currentAtom.setCharge(Double.parseDouble(propertyValue));
            } else if (propertyType.equals("hydrogenCount")) {
                currentAtom.setImplicitHydrogenCount(Integer.parseInt(propertyValue));
            } else if (propertyType.equals("dictRef")) {
                currentAtom.setProperty("org.openscience.cdk.dict", propertyValue);
            } else if (propertyType.equals("atomicNumber")) {
                currentAtom.setAtomicNumber(Integer.parseInt(propertyValue));
            } else if (propertyType.equals("massNumber")) {
                currentAtom.setMassNumber((int) Double.parseDouble(propertyValue));
            } else if (propertyType.equals("id")) {
                logger.debug("id: ", propertyValue);
                currentAtom.setID(propertyValue);
                atomEnumeration.put(propertyValue, numberOfAtoms);
            }
        } else if (objectType.equals("Bond")) {
            if (propertyType.equals("atom1")) {
                bond_a1 = Integer.parseInt(propertyValue);
            } else if (propertyType.equals("atom2")) {
                bond_a2 = Integer.parseInt(propertyValue);
            } else if (propertyType.equals("id")) {
                logger.debug("id: " + propertyValue);
                bond_id = propertyValue;
            } else if (propertyType.equals("order")) {
                try {
                    Double order = Double.parseDouble(propertyValue);
                    if (order == 1.0) {
                        bond_order = IBond.Order.SINGLE;
                    } else if (order == 2.0) {
                        bond_order = IBond.Order.DOUBLE;
                    } else if (order == 3.0) {
                        bond_order = IBond.Order.TRIPLE;
                    } else if (order == 4.0) {
                        bond_order = IBond.Order.QUADRUPLE;
                    } else {
                        bond_order = IBond.Order.SINGLE;
                    }
                } catch (Exception e) {
                    logger.error("Cannot convert to double: " + propertyValue);
                    bond_order = IBond.Order.SINGLE;
                }
            } else if (propertyType.equals("stereo")) {
                if (propertyValue.equals("H")) {
                    bond_stereo = IBond.Stereo.DOWN;
                } else if (propertyValue.equals("W")) {
                    bond_stereo = IBond.Stereo.UP;
                }
            }
        }
        logger.debug("Object property set...");
    }
1294993
protected function setProperty($entity, $propertyName, $propertyValue)
    {
        if ($this->getReflection()->hasProperty($propertyName)) {
            $property = $this->getReflection()->getProperty($propertyName);
            $property->setValue($entity, $propertyValue);
        } else {
            $entity->setVirtual($propertyName, $propertyValue);
        }
        
        return $this;
    }
59159
public void setFieldValue(Object fieldValue) {
		ReflectionUtils.callSetter(parentWrapper.getItem(), field.getName(), fieldValue);
	}
735091
@Override
    public void setValue(Object instance, String propertyName, Object value) {
        if (!isWriteIgnored(instance, propertyName)) {
            PropertyProxyUtils.getPropertyAccessor(this.conversionService, this.useDirectFieldAccess, instance).setPropertyValue(propertyName, value);
        }
    }