/* (non-Javadoc)
@see javax.jms.Message#setIntProperty(java.lang.String, int)
970999
@Override
	public final void setIntProperty(String name, int value) throws JMSException
    {
        setProperty(name,Integer.valueOf(value));
    }
821016
@Override
    public final void setObjectProperty(String name, Object value) {
        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
            SibTr.entry(this, tc, "setObjectProperty", new Object[] { name, value });

        /* If the property is either JMSXUserID or JMSXAppID, we set it into the */
        /* message regardless of whether it is null. We know the value is a */
        /* String as the JMS API layer has vetted it. Moved code under d325186.1 */
        if (SIProperties.JMSXAppID.equals(name)) {
            setJmsxAppId((String) value);
        }
        else if (SIProperties.JMSXUserID.equals(name)) {
            setUserid((String) value);
        }
        /* Ditto for JMS_IBM_ArmCorrelator & JMS_TOG_ARM_Correlator */
        else if (SIProperties.JMS_IBM_ArmCorrelator.equals(name)) {
            setARMCorrelator((String) value);
        }
        else if (SIProperties.JMS_TOG_ARM_Correlator.equals(name)) {
            setARMCorrelator((String) value);
        }

        /* else, if the value is not null, set the Property */
        else if (value != null) {
            setNonNullProperty(name, value);
        }

        /* Otherwise, remove it */
        else {

            /* Maelstrom's transportVersion has its own field - the rest are in the */
            /* JmsPropertyMap */
            if (!name.startsWith(JMS_PREFIX)) {
                if (name.equals(MfpConstants.PRP_TRANSVER)) {
                    clearTransportVersion();
                }
                else {
                    if (mayHaveJmsUserProperties()) {
                        getJmsUserPropertyMap().remove(name);
                    }
                }
            }
            else {
                if (name.startsWith(JMS_IBM_MQMD_PREFIX)) {
                    deleteMQMDProperty(name);
                }
                else {
                    if (mayHaveMappedJmsSystemProperties()) {
                        getJmsSystemPropertyMap().remove(name); // 234893
                    }
                    // JMS_IBM_Character_Set and JMS_IBM_Encoding need to be cleared in the
                    // message itself too.                                          d395685
                    if (name.equals(SIProperties.JMS_IBM_Character_Set)) {
                        setCcsid(null);
                    }
                    else if (name.equals(SIProperties.JMS_IBM_Encoding)) {
                        setEncoding(null);
                    }
                }
            }
        }

        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
            SibTr.exit(this, tc, "setObjectProperty");
    }
675677
public
  void setProperty(PropertyDescriptor prop, String name, String value)
    throws PropertySetterException {
    Method setter = prop.getWriteMethod();
    if (setter == null) {
      throw new PropertySetterException("No setter for property ["+name+"].");
    }
    Class[] paramTypes = setter.getParameterTypes();
    if (paramTypes.length != 1) {
      throw new PropertySetterException("#params for setter != 1");
    }

    Object arg;
    try {
      arg = convertArg(value, paramTypes[0]);
    } catch (Throwable t) {
      throw new PropertySetterException("Conversion to type ["+paramTypes[0]+
					"] failed. Reason: "+t);
    }
    if (arg == null) {
      throw new PropertySetterException(
          "Conversion to type ["+paramTypes[0]+"] failed.");
    }
    LogLog.debug("Setting property [" + name + "] to [" +arg+"].");
    try {
      setter.invoke(obj, new Object[]  { arg });
    } catch (IllegalAccessException ex) {
      throw new PropertySetterException(ex);
    } catch (InvocationTargetException ex) {
        if (ex.getTargetException() instanceof InterruptedException
                || ex.getTargetException() instanceof InterruptedIOException) {
            Thread.currentThread().interrupt();
        }
        throw new PropertySetterException(ex);
    } catch (RuntimeException ex) {
      throw new PropertySetterException(ex);
    }
  }
691439
@Override
	public final void setDoubleProperty(String name, double value) throws JMSException
    {
        setProperty(name,new Double(value));
    }
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;
    }
563106
public static int getIntProperty(final MessageResources msg,
                                   final String pname,
                                   final int def) throws Throwable {
    String p = msg.getMessage(pname);
    if (p == null) {
      return def;
    }

    return Integer.valueOf(p);
  }
815211
static public void setPropertiesInSMC(SessionManagerConfig smc, Map<String, Object> xtpProperties) {
        final String methodName = "setPropertiesInSMC";
        final String invalidPropFoundMessage = "SessionContext.invalidPropertyFound";
        final String invalidCloneSeparatorMessage = "SessionContext.invalidCloneSeparator";
        String strProp = null;
        Boolean booleanProp;
        Integer integerProp = null;

        boolean baseServerLevelConfig = smc.isUsingWebContainerSM();

        setDefaultConfiguration(smc, xtpProperties);

        // id length - has upper case D for system property...maintain for
        // compatibility
        final String propIdLengthForSys = "HttpSessionIDLength";
        final String propIdLength = "idLength";
        int idLength = -1;

        Object propIdLengthValue = xtpProperties.get(propIdLength);
        if (propIdLengthValue instanceof Integer) {
            integerProp = (Integer) propIdLengthValue;
        } else {
            strProp = (String) propIdLengthValue;
            if (strProp == null) {
                strProp = getSystemProperty(propIdLength);
                // look for different case on system property
                if (strProp == null) {
                    strProp = getSystemProperty(propIdLengthForSys);
                }
            }
        }

        if (integerProp != null || strProp != null) {
            try {
                if (integerProp != null) {
                    idLength = integerProp.intValue();
                } else {
                    idLength = Integer.parseInt(strProp);
                }
                if ((idLength < 8) || (idLength > 128)) {
                    if (idLength < 8)
                        idLength = 8;
                    if (idLength > 128)
                        idLength = 128;
                    LoggingUtil.SESSION_LOGGER_CORE.logp(Level.WARNING, methodClassName, methodName, "SessionContext.valueOutOfRange", new Object[] { propIdLength, strProp,
                                                                                                                                                     new Integer(idLength) });
                }
                if (shouldSetAndDoLogging(propIdLength, true, baseServerLevelConfig, xtpProperties, new Integer(idLength), new Integer(SessionManagerConfig.getSessionIDLength()),
                                          false)) {
                    SessionManagerConfig.setSessionIDLength(idLength);
                }
            } catch (NumberFormatException nfe) {
                LoggingUtil.SESSION_LOGGER_CORE.logp(Level.WARNING, methodClassName, methodName, invalidPropFoundMessage, new Object[] { propIdLength, strProp });
            }
        }

        // id reuse - reuse incoming id even if its not in use by another webapp
        final String propIdReuse = "HttpSessionIdReuse";
        strProp = getStringProperty(propIdReuse, xtpProperties);
        if (strProp != null) {
            booleanProp = Boolean.valueOf(strProp);
            if (shouldSetAndDoLogging(propIdReuse, true, baseServerLevelConfig, xtpProperties, booleanProp, Boolean.valueOf(SessionManagerConfig.isIdReuse()), false)) {
                SessionManagerConfig.setIdReuse(booleanProp.booleanValue());
            }
        }

        // track gc
        final String propTrackGC = "HttpSessionTrackGC";
        strProp = getStringProperty(propTrackGC, xtpProperties);
        if (strProp != null) {
            booleanProp = Boolean.valueOf(strProp);
            if (shouldSetAndDoLogging(propTrackGC, false, baseServerLevelConfig, xtpProperties, booleanProp, null, false)) {
                smc.setTrackGCCount(booleanProp.booleanValue());
            }
        }

        // reaper poll interval - override how often inval thread runs
        final String propReaperPollInt = "HttpSessionReaperPollInterval";
        strProp = getStringProperty(propReaperPollInt, xtpProperties);
        long longProp = -1;
        try {
            if (strProp != null) {
                if (shouldSetAndDoLogging(propReaperPollInt, false, baseServerLevelConfig, xtpProperties, strProp, null, false)) {
                    longProp = new Long(strProp).longValue();
                    smc.setReaperPollInterval(longProp);
                }
            }
        } catch (NumberFormatException nfe) {
            LoggingUtil.SESSION_LOGGER_CORE.logp(Level.SEVERE, methodClassName, methodName, invalidPropFoundMessage, new Object[] { propReaperPollInt, strProp });
        }

        // use invalidated id - default to true for better performance
        final String propUseRecentInvalId = "UseInvalidatedId";
        strProp = getStringProperty(propUseRecentInvalId, xtpProperties);
        if (strProp != null) {
            booleanProp = Boolean.valueOf(strProp);
            if (shouldSetAndDoLogging(propUseRecentInvalId, false, baseServerLevelConfig, xtpProperties, booleanProp, null, false)) {
                smc.setCheckRecentlyInvalidList(booleanProp.booleanValue());
            }
        }

        // debug session crossover
        final String propDebugSessCross = "DebugSessionCrossover";
        strProp = getStringProperty(propDebugSessCross, xtpProperties);
        if (strProp != null) {
            booleanProp = Boolean.valueOf(strProp);
            if (shouldSetAndDoLogging(propDebugSessCross, false, baseServerLevelConfig, xtpProperties, booleanProp, null, false)) {
                smc.setDebugSessionCrossover(booleanProp.booleanValue());
                if (baseServerLevelConfig || xtpProperties.get(propDebugSessCross) != null) {
                    if (booleanProp.booleanValue() == true) {
                        LoggingUtil.SESSION_LOGGER_CORE.logp(Level.INFO, methodClassName, methodName, "SessionContext.DebugCrossoverEnabled");
                    }
                }
            }
        }

        // url rewrite identifier
        final String propSessRewrite = "SessionRewriteIdentifier";
        strProp = getStringProperty(propSessRewrite, xtpProperties);
        if (strProp != null) {
            if (shouldSetAndDoLogging(propSessRewrite, false, baseServerLevelConfig, xtpProperties, strProp, null, false)) {
                smc.setSessUrlRewritePrefix(";" + strProp + "=");
            }
        }

        // clone id
        final String propHttpSessionCloneId = "HttpSessionCloneId";
        strProp = getStringProperty(propHttpSessionCloneId, xtpProperties);
        if (strProp != null) {
            if (shouldSetAndDoLogging(propHttpSessionCloneId, true, baseServerLevelConfig, xtpProperties, strProp, SessionManagerConfig.getCloneId(),
                                      strProp.equals(SessionManagerConfig.getCloneId()))) {
                SessionManagerConfig.setCloneId(strProp);
                SessionManagerConfig.setCloneIdPropertySet(true);
            }
        }

        // no additional session info - eliminates cache and clone on base server
        final String propNoAddSessInfo = "NoAdditionalSessionInfo";
        strProp = getStringProperty(propNoAddSessInfo, xtpProperties);
        if (strProp != null) {
            booleanProp = Boolean.valueOf(strProp);
            if (shouldSetAndDoLogging(propNoAddSessInfo, true, baseServerLevelConfig, xtpProperties, booleanProp, Boolean.valueOf(SessionManagerConfig.isTurnOffCacheId()), false)) {
                SessionManagerConfig.setTurnOffCacheId(booleanProp.booleanValue());
                SessionManagerConfig.setTurnOffCloneId(booleanProp.booleanValue());
                if (smc.isUsingMemory()) {
                    SessionManagerConfig.setCacheIdLength(0);
                }
            }
        }

        // session id max length (including all clones)
        final String propSessIdMax = "SessionIdentifierMaxLength";
        strProp = getStringProperty(propSessIdMax, xtpProperties);
        if (strProp != null) {
            try {
                int maxLength = Integer.parseInt(strProp);
                if (shouldSetAndDoLogging(propSessIdMax, true, baseServerLevelConfig, xtpProperties, new Integer(maxLength),
                                          new Integer(SessionManagerConfig.getMaxSessionIdentifierLength()), false)) {
                    SessionManagerConfig.setMaxSessionIdentifierLength(maxLength);
                }
            } catch (NumberFormatException nfe) {
                LoggingUtil.SESSION_LOGGER_CORE.logp(Level.WARNING, methodClassName, methodName, invalidPropFoundMessage, new Object[] { propSessIdMax, strProp });
            }
        }

        // clone separator change
        final String propCloneSepChange = "CloneSeparatorChange";
        strProp = getStringProperty(propCloneSepChange, xtpProperties);
        if (strProp != null) {
            booleanProp = Boolean.valueOf(strProp);
            if (shouldSetAndDoLogging(propCloneSepChange, true, baseServerLevelConfig, xtpProperties, booleanProp,
                                      Boolean.valueOf('+' == SessionManagerConfig.getCloneSeparator()),
                                      false)) {
                if (booleanProp.booleanValue()) {
                    SessionManagerConfig.setCloneSeparator('+');
                }
            }
        }

        // PM02068 Property for changing CloneSeparator.  
        final String propCloneSeparator = "CloneSeparator";
        strProp = getStringProperty(propCloneSeparator, xtpProperties);
        if (strProp != null) {
            // Must be exactly one char, and cannot be space
            if ((strProp.length() == 1) && (strProp.trim().length() == 1)) {
                if (shouldSetAndDoLogging(propCloneSeparator, true, baseServerLevelConfig, xtpProperties, strProp, null, false)) {
                    char charProp = strProp.charAt(0);
                    SessionManagerConfig.setCloneSeparator(charProp);
                }
            } else {
                LoggingUtil.SESSION_LOGGER_CORE.logp(Level.WARNING, methodClassName, methodName, invalidCloneSeparatorMessage,
                                                     new Object[] { strProp });
            }
        }

        // no affinity switch back - stick to new server after failover
        final String propNoAffSwitch = "NoAffinitySwitchBack";
        strProp = getStringProperty(propNoAffSwitch, xtpProperties);
        if (strProp != null) {
            booleanProp = Boolean.valueOf(strProp);
            if (shouldSetAndDoLogging(propNoAffSwitch, true, baseServerLevelConfig, xtpProperties, booleanProp, Boolean.valueOf(SessionManagerConfig.isNoAffinitySwitchBack()),
                                      false)) {
                SessionManagerConfig.setNoAffinitySwitchBack(booleanProp.booleanValue());
            }
        }

        // use oracle BLOB, rather than long raw, for medium db column
        final String propUseOracleBlob = "UseOracleBLOB";
        strProp = getStringProperty(propUseOracleBlob, xtpProperties);
        if (strProp != null) {
            booleanProp = Boolean.valueOf(strProp);
            if (shouldSetAndDoLogging(propUseOracleBlob, false, baseServerLevelConfig, xtpProperties, booleanProp, null, false)) {
                smc.setUseOracleBlob(booleanProp.booleanValue());
            }
        }

        // START: PM37139 Users who set this property to true should have already created their own index, so we skip index creation
        final String propSessionTableSkipIndexCreation = "SessionTableSkipIndexCreation";
        strProp = getStringProperty(propSessionTableSkipIndexCreation, xtpProperties);
        if (strProp != null) {
            booleanProp = Boolean.valueOf(strProp);
            if (shouldSetAndDoLogging(propSessionTableSkipIndexCreation, false, baseServerLevelConfig, xtpProperties, booleanProp, null, false)) {
                smc.setSessionTableSkipIndexCreation(booleanProp.booleanValue());
            }
        }
        // END: PM37139

        // START: PM57590
        final String propCheckSessionNewOnIsValidRequest = "CheckSessionNewOnIsValidRequest";
        strProp = getStringProperty(propCheckSessionNewOnIsValidRequest, xtpProperties);
        if (strProp != null) {
            booleanProp = Boolean.valueOf(strProp);
            if (shouldSetAndDoLogging(propCheckSessionNewOnIsValidRequest, false, baseServerLevelConfig, xtpProperties, booleanProp, null, false)) {
                smc.setCheckSessionNewOnIsValidRequest(booleanProp.booleanValue());
            }
        }
        // END: PM57590     

        // if the data source has a non default schema name, then we need to mark it as so
        final String propUsingCurrentSchemaCustomProperty = "UsingCustomSchemaName";
        strProp = getStringProperty(propUsingCurrentSchemaCustomProperty, xtpProperties);
        if (strProp != null) {
            booleanProp = Boolean.valueOf(strProp);
            if (shouldSetAndDoLogging(propUsingCurrentSchemaCustomProperty, false, baseServerLevelConfig, xtpProperties, booleanProp, null, false)) {
                smc.setUsingCustomSchemaName(booleanProp.booleanValue());
            }
        }

        // hide session values (in trace output)
        final String propHideSessVals = "HideSessionValues";
        strProp = getStringProperty(propHideSessVals, xtpProperties);
        if (strProp != null) {
            booleanProp = Boolean.valueOf(strProp);
            if (shouldSetAndDoLogging(propHideSessVals, true, baseServerLevelConfig, xtpProperties, booleanProp, Boolean.valueOf(SessionManagerConfig.isHideSessionValues()), false)) {
                SessionManagerConfig.setHideSessionValues(booleanProp.booleanValue());
                SessionManagerConfig.setHideSessionValuesPropertySet(true);
            }
        }

        // do remote invalidations - forces inval even if scheduled session inval
        // (twice a day) is enabled
        final String propDoRemoteInval = "DoRemoteInvalidations";
        strProp = getStringProperty(propDoRemoteInval, xtpProperties);
        if (strProp != null) {
            booleanProp = Boolean.valueOf(strProp);
            if (shouldSetAndDoLogging(propDoRemoteInval, true, baseServerLevelConfig, xtpProperties, booleanProp, Boolean.valueOf(SessionManagerConfig.isDoRemoteInvalidations()),
                                      false)) {
                SessionManagerConfig.setDoRemoteInvalidations(booleanProp.booleanValue());
            }
        }
        // session table name
        final String propSessTable = "SessionTableName";
        strProp = getStringProperty(propSessTable, xtpProperties);
        if (strProp != null) {
            if (shouldSetAndDoLogging(propSessTable, false, baseServerLevelConfig, xtpProperties, strProp, null, false)) {
                smc.setTableNameValue(strProp);
            }
        }

        // zOS Base Server Replication
        final String propZosBaseServerReplication = "HttpSessionEnableUnmanagedServerReplication";
        strProp = getStringProperty(propZosBaseServerReplication, xtpProperties);
        if (strProp != null) {
            booleanProp = Boolean.valueOf(strProp);
            if (shouldSetAndDoLogging(propZosBaseServerReplication, false, baseServerLevelConfig, xtpProperties, booleanProp, null, false)) {
                smc.setZosBaseServerReplicationEnabled(booleanProp.booleanValue());
            }
        }

        // servlet 21 compatibility -- aka global sessions
        final String propServlet21SessionCompat = "Servlet21SessionCompatibility";
        strProp = getStringProperty(propServlet21SessionCompat, xtpProperties);
        if (strProp != null) {
            booleanProp = Boolean.valueOf(strProp);
            if (shouldSetAndDoLogging(propServlet21SessionCompat, true, baseServerLevelConfig, xtpProperties, booleanProp,
                                      Boolean.valueOf(SessionManagerConfig.getServlet21SessionCompatibility()), false)) {
                SessionManagerConfig.setServlet21SessionCompatibility(booleanProp.booleanValue());
            }
        }

        // always encode the url even if cookies enabled is set
        final String propAlwaysEncode = "AlwaysEncodeURL";
        strProp = getStringProperty(propAlwaysEncode, xtpProperties);
        if (strProp != null) {
            booleanProp = Boolean.valueOf(strProp);
            if (shouldSetAndDoLogging(propAlwaysEncode, true, baseServerLevelConfig, xtpProperties, booleanProp, Boolean.valueOf(SessionManagerConfig.isAlwaysEncodeURL()), false)) {
                SessionManagerConfig.setAlwaysEncodeURL(booleanProp.booleanValue());
            }
        }
        
        // START: PM81933 Check session cookie name on EncodeURL method
        final String propCheckSessionCookieNameOnEncodeURL = "CheckSessionCookieNameOnEncodeURL";
        strProp = getStringProperty(propCheckSessionCookieNameOnEncodeURL, xtpProperties);
        if (strProp != null) {
            booleanProp = Boolean.valueOf(strProp);
            if (shouldSetAndDoLogging(propCheckSessionCookieNameOnEncodeURL, true, baseServerLevelConfig, xtpProperties, booleanProp, Boolean.valueOf(SessionManagerConfig.checkSessionCookieNameOnEncodeURL()), false)) {
                SessionManagerConfig.setCheckSessionCookieNameOnEncodeURL(booleanProp.booleanValue());
            }
        }
        // END: PM81933        

        // Optimizes the Version Increments if the in-memory session is the same as
        // the one stored on the backend. This property only applies to non-EOS
        // writes since we will always do this for EOS.
        final String propOptimizeCacheIdIncrements = "OptimizeCacheIdIncrements";
        strProp = getStringProperty(propOptimizeCacheIdIncrements, xtpProperties);
        if (strProp != null) {
            booleanProp = Boolean.valueOf(strProp);
            if (shouldSetAndDoLogging(propOptimizeCacheIdIncrements, false, baseServerLevelConfig, xtpProperties, booleanProp, null, false)) {
                smc.setOptimizeCacheIdIncrements(booleanProp.booleanValue());
            }
        }

        // only checks the cache vs the backend for updating the lastAccessedTime
        // during the preInvoke metho
        final String propOnlyCheckInCacheDuringPreInvoke = "OnlyCheckInCacheDuringPreInvoke";
        strProp = getStringProperty(propOnlyCheckInCacheDuringPreInvoke, xtpProperties);
        if (strProp != null) {
            booleanProp = Boolean.valueOf(strProp);
            if (shouldSetAndDoLogging(propOnlyCheckInCacheDuringPreInvoke, false, baseServerLevelConfig, xtpProperties, booleanProp, null, false)) {
                smc.setOnlyCheckInCacheDuringPreInvoke(booleanProp.booleanValue());
            }
        }

        // can be used to disable hot failover by setting to false - default is true
        final String propEnableHotFailover = "EnableHotFailover";
        strProp = getStringProperty(propEnableHotFailover, xtpProperties);
        if (strProp != null) {
            booleanProp = Boolean.valueOf(strProp);
            if (shouldSetAndDoLogging(propEnableHotFailover, true, baseServerLevelConfig, xtpProperties, booleanProp, Boolean.valueOf(SessionManagerConfig.isEnableHotFailover()),
                                      false)) {
                SessionManagerConfig.setEnableHotFailover(booleanProp.booleanValue());
            }
        }

        // PK38538 Begin
        final String propForceSessionInvalidationMultiple = "ForceSessionInvalidationMultiple";
        strProp = getStringProperty(propForceSessionInvalidationMultiple, xtpProperties);
        if (strProp != null) {
            try {
                int invalMult = new Integer(strProp).intValue();
                if (shouldSetAndDoLogging(propForceSessionInvalidationMultiple, false, baseServerLevelConfig, xtpProperties, new Integer(invalMult), null, false)) {
                    smc.setForceSessionInvalidationMultiple(invalMult);
                }
            } catch (NumberFormatException nfe) {
                LoggingUtil.SESSION_LOGGER_CORE.logp(Level.WARNING, methodClassName, methodName, invalidPropFoundMessage, new Object[] { propForceSessionInvalidationMultiple,
                                                                                                                                        strProp });
            }
        } // PK38538 End
        
        //PI73188 Start
        final String propModifyActiveCountOnInvalidatedSession = "ModifyActiveCountOnInvalidatedSession";
        strProp = getStringProperty(propModifyActiveCountOnInvalidatedSession, xtpProperties);
        if (strProp != null) {
            booleanProp = Boolean.valueOf(strProp);
            if (shouldSetAndDoLogging(propModifyActiveCountOnInvalidatedSession, true, baseServerLevelConfig, xtpProperties, booleanProp, null, false)) {
                smc.setModifyActiveCountOnInvalidatedSession(booleanProp.booleanValue());
            }
        }
        //PI73188 End
        
        
        final String propPersistSessionAfterPassivation = "PersistSessionAfterPassivation";
        strProp = getStringProperty(propPersistSessionAfterPassivation, xtpProperties);
        if (strProp != null) {
            booleanProp = Boolean.valueOf(strProp);
            if (shouldSetAndDoLogging(propPersistSessionAfterPassivation, false, baseServerLevelConfig, xtpProperties, booleanProp, null, false)) {
                smc.setPersistSessionAfterPassivation(booleanProp.booleanValue());
            }
        }

        final String propUsingApplicationSessionsAndInvalidateAll = "UsingApplicationSessionsAndInvalidateAll";
        strProp = getStringProperty(propUsingApplicationSessionsAndInvalidateAll, xtpProperties);
        if (strProp != null) {
            booleanProp = Boolean.valueOf(strProp);
            if (shouldSetAndDoLogging(propUsingApplicationSessionsAndInvalidateAll, true, baseServerLevelConfig, xtpProperties, booleanProp,
                                      Boolean.valueOf(SessionManagerConfig.getUsingApplicationSessionsAndInvalidateAll()), false)) {
                SessionManagerConfig.setUsingApplicationSessionsAndInvalidateAll(booleanProp.booleanValue());
            }
        }

        final String propUsingApplicationSessionsAlwaysRetrieve = "UsingApplicationSessionsAlwaysRetrieve";
        strProp = getStringProperty(propUsingApplicationSessionsAlwaysRetrieve, xtpProperties);
        if (strProp != null) {
            booleanProp = Boolean.valueOf(strProp);
            if (shouldSetAndDoLogging(propUsingApplicationSessionsAlwaysRetrieve, true, baseServerLevelConfig, xtpProperties, booleanProp,
                                      Boolean.valueOf(SessionManagerConfig.getUsingApplicationSessionsAlwaysRetrieve()), false)) {
                SessionManagerConfig.setUsingApplicationSessionsAlwaysRetrieve(booleanProp.booleanValue());
            }
        }

        // clone id
        final String propSIPCookieName = "SIPCookieName";
        strProp = getStringProperty(propSIPCookieName, xtpProperties);
        if (strProp != null) {
            if (shouldSetAndDoLogging(propSIPCookieName, true, baseServerLevelConfig, xtpProperties, strProp, SessionManagerConfig.getSipSessionCookieName(),
                                      strProp.equals(SessionManagerConfig.getSipSessionCookieName()))) {
                SessionManagerConfig.setSipSessionCookieName(strProp);
            }
        }
        
        //Property that allows the thread scheduler to be changed
        final String newScheduler= "UseSeparateSessionInvalidatorThreadPool";
        strProp = getStringProperty(newScheduler, xtpProperties);
        if(strProp != null){
            booleanProp=Boolean.valueOf(strProp);
            if (shouldSetAndDoLogging(newScheduler, false, baseServerLevelConfig, xtpProperties, booleanProp, null, false)) {
                smc.setUseSeparateSessionInvalidatorThreadPool(booleanProp.booleanValue());
            }
        }        

        //PM74718 Property to control how long to delay the start of the invalidation alarm.
        final String invalidatorAlarmDelay = "DelayInvalidationAlarmDuringServerStartup";
        strProp = getStringProperty(invalidatorAlarmDelay, xtpProperties);
        if (strProp != null) {
            try {
                Integer delayProp = Integer.valueOf(strProp);
                if (shouldSetAndDoLogging(invalidatorAlarmDelay, false, baseServerLevelConfig, xtpProperties, delayProp, null, false)) {
                    smc.setDelayForInvalidationAlarmDuringServerStartup(delayProp.intValue());
                }
            } catch (NumberFormatException nfe) {
                LoggingUtil.SESSION_LOGGER_CORE.logp(Level.WARNING, methodClassName, methodName, invalidPropFoundMessage,new Object[] {invalidatorAlarmDelay, strProp});
            }
        }

        // PK80439 Property for preventing session ids longer than the permissible length getting created
        final String propForceSessionIdLengthCheck = "ForceSessionIdLengthCheck";
        strProp = getStringProperty(propForceSessionIdLengthCheck, xtpProperties);
        if (strProp != null) {
            booleanProp = Boolean.valueOf(strProp);
            if (shouldSetAndDoLogging(propForceSessionIdLengthCheck, false, baseServerLevelConfig, xtpProperties, booleanProp, null, false)) {
                smc.setForceSessionIdLengthCheck(booleanProp.booleanValue());
            }
        }
        // PK80439 End

        // PM04304 Property for ignoring case while comparing session owner and authorized user
        final String securityUserIgnoreCase = "SecurityUserIgnoreCase";
        strProp = getStringProperty(securityUserIgnoreCase, xtpProperties);
        if (strProp != null) {
            booleanProp = Boolean.valueOf(strProp);
            if (shouldSetAndDoLogging(securityUserIgnoreCase, false, baseServerLevelConfig, xtpProperties, booleanProp, null, false)) {
                smc.setSecurityUserIgnoreCase(booleanProp.booleanValue());
            }
        }

        //712446
        final String throwSecurityExceptionOnGetSessionFalse = "ThrowSecurityExceptionOnGetSessionFalse";
        strProp = getStringProperty(throwSecurityExceptionOnGetSessionFalse, xtpProperties);
        if (strProp != null) {
            booleanProp = Boolean.valueOf(strProp);
            if (shouldSetAndDoLogging(throwSecurityExceptionOnGetSessionFalse, false, baseServerLevelConfig, xtpProperties, booleanProp, null, false)) {
                smc.setThrowSecurityExceptionOnGetSessionFalse(booleanProp.booleanValue());
            }
        }

        final String invalidateOnUnauthorizedSessionRequestException = "InvalidateOnUnauthorizedSessionRequestException";
        strProp = getStringProperty(invalidateOnUnauthorizedSessionRequestException, xtpProperties);
        if (strProp != null) {
            booleanProp = Boolean.valueOf(strProp);
            if (shouldSetAndDoLogging(invalidateOnUnauthorizedSessionRequestException, false, baseServerLevelConfig, xtpProperties, booleanProp, null, false))
                smc.setInvalidateOnUnauthorizedSessionRequestException(booleanProp.booleanValue());
        }
        
        
        // PI18177 We will check incoming cloneIds against this string, needs HttpSessionCloneId to be set to take effect
        final String expectedCloneIds = "ExpectedCloneIds";
        strProp = getStringProperty(expectedCloneIds, xtpProperties);
        if (strProp != null) {
            if (shouldSetAndDoLogging(expectedCloneIds, true, baseServerLevelConfig, xtpProperties, strProp, null, false)) {
                SessionManagerConfig.setExpectedCloneIds(strProp);
                SessionManagerConfig.setExpectedCloneIdsPropertySet(true);
            }
        }
        
        // Feature 68570 Begin
        final String propConnectionRetryCount = "ConnectionRetryCount";
        strProp = getStringProperty(propConnectionRetryCount, xtpProperties);
        if (strProp != null) {
            try {
                int retryCount = new Integer(strProp).intValue();
                if (shouldSetAndDoLogging(propConnectionRetryCount, false, baseServerLevelConfig, xtpProperties, new Integer(retryCount), null, false)) {
                    smc.setConnectionRetryCount(retryCount);
                }
            } catch (NumberFormatException nfe) {
                LoggingUtil.SESSION_LOGGER_CORE.logp(Level.WARNING, methodClassName, methodName, invalidPropFoundMessage, new Object[] { propConnectionRetryCount,
                                                                                                                                        strProp });
            }
        } // Feature 68570 End

    }
7704
protected void setIntegerProperty(UIComponent component, String propName,
            ValueExpression value)
    {
        UIComponentELTagUtils.setIntegerProperty(component, propName, value);
    }
835089
@Override
	public final void setObjectProperty(String name, Object value) throws JMSException
    {
        if (value == null)
            throw new MessageFormatException("A property value cannot be null");
            
        // Check type
        if (!(value instanceof Boolean ||
              value instanceof Byte ||
              value instanceof Short ||
              value instanceof Integer ||
              value instanceof Long ||
              value instanceof Float ||
              value instanceof Double ||
              value instanceof String))
            throw new MessageFormatException("Unsupported property value type : "+value.getClass().getName());
        
        setProperty(name,value);
    }
36110
@Override
  public int getIntProperty(final String name) throws OptionsException {
    String val = getStringProperty(name);

    try {
      return Integer.valueOf(val).intValue();
    } catch (Throwable t) {
      throw new OptionsException("org.bedework.calenv.bad.option.value");
    }
  }
553536
public static int getIntFromProperty(final String propertyName) {
        try {
            return Integer.parseInt(properties.getProperty(propertyName));
        } catch (NumberFormatException e) {
            log.error("NumberFormatException caught during reading property from properties file: "
                    + e.getMessage());
            return 0;
        }
    }
387162
public void setIntIfNotNull(@NotNull final String key, @Nullable final Integer value) {
        if (null != value) {
            setInt(key, value);
        }
    }
97019
@Override
	public final void setShortProperty(String name, short value) throws JMSException
    {
        setProperty(name,Short.valueOf(value));
    }
673163
public void setInt(Enum<?> key, int value)
    {
        if (key == null)
        {
            return;
        }

        setInt(key.name(), value);
    }
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");
    }
404268
public void setCountProperty(String property) {
        if (propertyMap.containsKey(property)) {
            this.countColumn = propertyMap.get(property).getColumn();
        }
    }
336520
public void setInt(String name, int value) throws UnsupportedEncodingException {
    if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) SibTr.entry(this, tc, "setInt", Integer.valueOf(value));
    getBodyMap().put(name, Integer.valueOf(value));
    if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) SibTr.exit(this, tc, "setInt");
  }