/*
(non-Javadoc)

@see com.ibm.ws.sib.admin.JsEngineComponent#setCustomProperty(java.lang.String, java.lang.String)
502784
@Override
    public void setCustomProperty(String key, String value)
    {
        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
            SibTr.entry(this, tc, "setCustomProperty", new Object[] { "Key=" + key, "Value=" + value });

        _customProperties.put(key, value);

        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
            SibTr.exit(this, tc, "setCustomProperty");
    }
1197465
@Override
    public void set(String propName, Object value) {
        if (propName.equals(PROP_PRINCIPAL_NAME)) {
            setPrincipalName(((String) value));
        }
        if (propName.equals(PROP_PASSWORD)) {
            setPassword(((byte[]) value));
        }
        if (propName.equals(PROP_REALM)) {
            setRealm(((String) value));
        }
        if (propName.equals(PROP_CERTIFICATE)) {
            getCertificate().add(((byte[]) value));
        }
        super.set(propName, value);
    }
903862
@Override
    protected void setProperty(final String _name,
                               final String _value)
        throws CacheReloadException
    {
        if ("AskUser".equals(_name)) {
            askUser = "true".equalsIgnoreCase(_value);
        } else if ("DefaultSelected".equals(_name)) {
            defaultSelected = "true".equalsIgnoreCase(_value);
        } else if ("HRef".equals(_name)) {
            reference = _value;
        } else if ("Label".equals(_name)) {
            label = _value;
        } else if ("Submit".equals(_name)) {
            submit = "true".equalsIgnoreCase(_value);
        } else if ("SubmitSelectedRows".equals(_name)) {
            submitSelectedRows = Integer.parseInt(_value);
        } else if ("Target".equals(_name)) {
            if ("content".equals(_value)) {
                target = AbstractCommand.Target.CONTENT;
            } else if ("hidden".equals(_value)) {
                target = AbstractCommand.Target.HIDDEN;
            } else if ("popup".equals(_value)) {
                target = AbstractCommand.Target.POPUP;
            } else if ("modal".equals(_value)) {
                target = AbstractCommand.Target.MODAL;
            }
        } else if ("TargetBottomHeight".equals(_name)) {
            targetBottomHeight = Integer.parseInt(_value);
        } else if ("TargetCmdRevise".equals(_name)) {
            targetCmdRevise = "TRUE".equalsIgnoreCase(_value);
        } else if ("TargetConnectAttribute".equals(_name)) {
            final Attribute attr = Attribute.get(_value);
            targetConnectAttributeId = attr == null ? 0 : attr.getId();
        } else if ("TargetCreateType".equals(_name)) {
            final Type type = Type.get(_value);
            targetCreateTypeId = type == null ? 0 : type.getId();
        } else if (_name != null && _name.startsWith("TargetCreateClassifications")) {
            setTargetCreateClassifications(_value);
        } else if ("TargetDefaultMenu".equals(_name)) {
            targetDefaultMenu = "none".equalsIgnoreCase(_value);
        } else if ("TargetMode".equals(_name)) {
            if ("create".equals(_value)) {
                targetMode = TargetMode.CREATE;
            } else if ("edit".equals(_value)) {
                targetMode = TargetMode.EDIT;
            } else if ("connect".equals(_value)) {
                targetMode = TargetMode.CONNECT;
            } else if ("search".equals(_value)) {
                targetMode = TargetMode.SEARCH;
            } else if ("view".equals(_value)) {
                targetMode = TargetMode.VIEW;
            }
        } else if ("TargetShowCheckBoxes".equals(_name)) {
            targetShowCheckBoxes = "true".equalsIgnoreCase(_value);
        } else if ("TargetTableSortKey".equals(_name)) {
            targetTableSortKey = _value;
            targetTableSortDirection = AbstractCommand.SortDirection.ASCENDING;
        } else if ("TargetTableSortDirection".equals(_name)) {
            if (AbstractCommand.SortDirection.DESCENDING.value.equals(_value)) {
                targetTableSortDirection = AbstractCommand.SortDirection.DESCENDING;
            } else {
                targetTableSortDirection = AbstractCommand.SortDirection.ASCENDING;
            }
        } else if ("TargetTitle".equals(_name)) {
            targetTitle = _value;
        } else if ("TargetShowFile".equals(_name)) {
            targetShowFile = "true".equalsIgnoreCase(_value);
        } else if ("NoUpdateAfterCOMMAND".equals(_name)) {
            noUpdateAfterCmd = "true".equalsIgnoreCase(_value);
        } else if ("TargetStructurBrowserField".equals(_name)) {
            targetStructurBrowserField = _value.trim();
        } else if ("WindowHeight".equals(_name)) {
            windowHeight = Integer.parseInt(_value);
        } else if ("WindowWidth".equals(_name)) {
            windowWidth = Integer.parseInt(_value);
        } else {
            super.setProperty(_name, _value);
        }
    }
240254
public void setExtProperty(String propName, String propValue) {
        if (m_extProperties == null) {
            m_extProperties = new HashMap<String, String>();
        }
        m_extProperties.put(propName, propValue);

    }
1300183
public void setProperty(String strParam, String strValue)
    {
        if (strValue != null)
            m_properties.put(strParam, strValue);
        else
            m_properties.remove(strParam);
    }
1137216
synchronized void setProperty(final String name, final String value) {
        Hashtable<String, String> properties = new Hashtable<String, String>(this.properties);
        properties.put(name, value);

        this.properties = properties;
    }
327892
public static void setCustomProperties(Map<String, Object> d) {
        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) {
            Tr.entry(tc, "setCustomProperties");
        }

        String ky;
        String propertyKey;

        // For comparison purposes we need the mixed case key strings coming from metatype.xml and server.xml to be in lower case.
        Set<String> newKeySet = new HashSet<String>();                                                
        for (String key:d.keySet()) {                                                                 
            newKeySet.add(key.toLowerCase());                                                         
        }                                                                                             

        // go through each entry that is in the set of keys that we are getting from metatype.xml and server.xml
        for (Map.Entry<String, Object> entry : d.entrySet()) {
            ky = entry.getKey();
            Object value = entry.getValue();
        
            // using the lower case value of short or long name that was configured
            // see if the string maps to one of the short names in our table.
            // if it matches then get the long name back.  otherwise keep the name as is.
            propertyKey = getStringKey(ky.toLowerCase());
            
            if (!ky.equalsIgnoreCase(propertyKey)) {
                // found in map - check existence of fully qualified prop as well
                // if we mapped to a new long name, see if it is already in the passed in data because
                // configured long names have priority, and if it is in the table elsewhere, then don't use
                // this mapped short name value, because the long name was set in server.xml
                if (newKeySet.contains(propertyKey)) {                                           
                    continue;
                }
            }
            
            // store all values as lower case, so as to read them later in a consistent fashion
            propertyKey =  propertyKey.toLowerCase();
            
            if (value instanceof String) {
                if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) {
                    Tr.debug(tc, "Key: " + propertyKey + "  type: String  value: " + value);
                }
                customProps.setProperty(propertyKey, (String) value);

            } else if (value instanceof Boolean) {
                if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) {
                    Tr.debug(tc, "Key: " + propertyKey + "  type: Boolean  value: " + ((Boolean) value).toString());
                }
                customProps.setProperty(propertyKey, ((Boolean) value).toString());

            } else if (value instanceof Integer) {
                if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) {
                    Tr.debug(tc, "Key: " + propertyKey + "  type: Integer  value: " + ((Integer) value).toString());
                }
                customProps.setProperty(propertyKey, ((Integer) value).toString());
            } else {
                // don't update, not a custom property we care about here
                if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) {
                    Tr.debug(tc, "Key not processed due to type, Key: " + propertyKey);
                }
            }
        }

        setCustomPropertyVariables(); //Need to update all the variables.

        setCustomizedDefaultValues(); //Customize default value depending on servlet level, initial size....etc..

        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) {
            Tr.exit(tc, "setCustomProperties");
        }

    }
1307208
public void setProperty(final String propertyName, final List<String> values) {
        Preconditions.checkNotNull(propertyName);
        if (values == null) {
            properties.put(propertyName, null);
            return;
        }
        properties.put(propertyName, values);
    }
1189392
public void addProperty( String property)
    {
    String candidate = StringUtils.trimToNull( property);
    if( candidate != null)
      {
      properties_.add( property);
      }
    }
504894
@Override
  public void setSystemProperty(String propertyName, String value) {
    if (Strings.isNullOrEmpty(propertyName)) {
      throw new IllegalArgumentException("Property name can't be empty.");
    }

    execute(
        "-selendroid-setAndroidOsSystemProperty",
        ImmutableMap.of(
            "propertyName", propertyName,
            "value", value));
  }
1001304
public void setProperty(P property, Object newValue) throws PropertyException{
		setProperty(property, newValue, false);
	}
570633
@Nonnull
  public CSSDeclaration setProperty (@Nonnull @Nonempty final String sProperty)
  {
    ValueEnforcer.notEmpty (sProperty, "Property");
    m_sProperty = _unifyProperty (sProperty);
    return this;
  }
405209
@Override
    public boolean setProperty(String name, Object value)
    {
        /* Note: can not call local method, since it'll return false for
         * recognized but non-mutable properties
         */
        return mConfig.setProperty(name, value);
    }
1043921
public void setAbstract(final String description) {
        if (description == null && this.description == null) {
            return;
        } else if (description == null) {
            removeChild(this.description);
            this.description = null;
        } else if (this.description == null) {
            this.description = new KeyValueNode<String>(CommonConstants.CS_ABSTRACT_TITLE, description);
            appendChild(this.description, false);
        } else {
            this.description.setValue(description);
        }
    }
842943
public void setProperty(final String property, final Object newValue) {
        this.delegate.setProperty(this.wrapped, property, newValue);
    }
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);
		}
	}
69184
@Override
    public void set(String propName, Object value) {
        if (propName.equals("cn")) {
            setCn(((String) value));
        }
        super.set(propName, value);
    }