docs: public void setProperty (String key, String value) {
      if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) SibTr.entry(tc, "setProperty","key="+key+",value="+value);
  
      try
      {
        if (key.equals("sib.processor.searchResultsPoolSize"))
        {
          _searchResultsPoolSize = Integer.parseInt(value);
          com.ibm.ws.sib.utils.Runtime.changedPropertyValue(key, value);
        }
        else if (key.equals("sib.processor.anycastLockBatchTimeout"))
        {
          _anycast_lock_batch_timeout = Long.parseLong(value);
          com.ibm.ws.sib.utils.Runtime.changedPropertyValue(key, value);
        }
        else if (key.equals("sib.processor.anycastLockBatchSize"))
        {
          _anycast_lock_batch_size = Integer.parseInt(value);
          com.ibm.ws.sib.utils.Runtime.changedPropertyValue(key, value);
        }
        else if (key.equals("sib.processor.anycastBatchTimeout"))
        {
          _anycast_batch_timeout = Long.parseLong(value);
          com.ibm.ws.sib.utils.Runtime.changedPropertyValue(key, value);
        }
        else if (key.equals("sib.processor.anycastBatchSize"))
        {
          _anycast_batch_size = Integer.parseInt(value);
          com.ibm.ws.sib.utils.Runtime.changedPropertyValue(key, value);
        }
        else if (key.equals("sib.processor.maxThreadPoolSize"))
        {
          _max_consumer_threadpool_size = Integer.parseInt(value);
          com.ibm.ws.sib.utils.Runtime.changedPropertyValue(key, value);
        }
        else if (key.equals("sib.processor.maxSystemThreadPoolSize"))
        {
          _max_system_threadpool_size = Integer.parseInt(value);
          com.ibm.ws.sib.utils.Runtime.changedPropertyValue(key, value);
        }
        else if(key.equals("sib.processor.maxReconstituteThreadpoolSize"))
        {
          _max_reconstitute_threadpool_size = Integer.parseInt(value);
          com.ibm.ws.sib.utils.Runtime.changedPropertyValue(key, value);
        }
        else if (key.equals("sib.processor.browseExpiryTimeout"))
        {
          _browse_expiry_timeout = Integer.parseInt(value);
          com.ibm.ws.sib.utils.Runtime.changedPropertyValue(key, value);
        }
        else if (key.equals("sib.processor.browseLivenessTimeout"))
        {
          _browse_liveness_timeout = Integer.parseInt(value);
          com.ibm.ws.sib.utils.Runtime.changedPropertyValue(key, value);
        }
        else if (key.equals("sib.processor.browseGetTimeout"))
        {
          _browse_get_timeout = Integer.parseInt(value);
          com.ibm.ws.sib.utils.Runtime.changedPropertyValue(key, value);
        }
        else if (key.equals("sib.processor.initRepetitionInterval"))
        {
          _init_repetition_interval = Integer.parseInt(value);
          com.ibm.ws.sib.utils.Runtime.changedPropertyValue(key, value);
        }
        else if (key.equals("sib.processor.resetRepetitionInterval"))
        {
          _reset_repetition_interval = Integer.parseInt(value);
          com.ibm.ws.sib.utils.Runtime.changedPropertyValue(key, value);
        }
        else if (key.equals("sib.processor.decisionExpectedRepetitionInterval"))
        {
          _decision_expected_repetition_interval = Integer.parseInt(value);
          com.ibm.ws.sib.utils.Runtime.changedPropertyValue(key, value);
        }
        else if (key.equals("sib.processor.senderInactivityTimeout"))
        {
          _sender_inactivity_timeout = Integer.parseInt(value);
          com.ibm.ws.sib.utils.Runtime.changedPropertyValue(key, value);
        }
        else if (key.equals("sib.processor.eagerGetRequestInterval"))
        {
          _eager_get_request_interval = Integer.parseInt(value);
          com.ibm.ws.sib.utils.Runtime.changedPropertyValue(key, value);
        }
        else if (key.equals("sib.processor.slowed_get_request_interval"))
        {
          _slowed_get_request_interval = Integer.parseInt(value);
          com.ibm.ws.sib.utils.Runtime.changedPropertyValue(key, value);
        }
        else if (key.equals("sib.processor.acceptInitialThreshold"))
        {
          _accept_initial_threshold = Long.parseLong(value);
          com.ibm.ws.sib.utils.Runtime.changedPropertyValue(key, value);
        }
        else if (key.equals("sib.processor.acceptRepetitionInterval"))
        {
          _accept_repetition_interval = Integer.parseInt(value);
          com.ibm.ws.sib.utils.Runtime.changedPropertyValue(key, value);
        }
        else if (key.equals("sib.processor.rejectRepetitionInterval"))
        {
          _reject_repetition_interval = Integer.parseInt(value);
          com.ibm.ws.sib.utils.Runtime.changedPropertyValue(key, value);
        }
        else if (key.equals("sib.processor.createStreamRepetitionInterval"))
        {
          _create_stream_repetition_interval = Integer.parseInt(value);
          com.ibm.ws.sib.utils.Runtime.changedPropertyValue(key, value);
        }
        else if (key.equals("sib.processor.initRoundTripTime"))
        {
          _init_round_trip_time = Integer.parseInt(value);
          com.ibm.ws.sib.utils.Runtime.changedPropertyValue(key, value);
        }
        else if (key.equals("sib.processor.unlockedRejectInterval"))
        {
          _unlocked_reject_interval = Integer.parseInt(value);
          com.ibm.ws.sib.utils.Runtime.changedPropertyValue(key, value);
        }
        else if (key.equals("sib.processor.maxPrefetchWindow"))
        {
          _max_prefetch_window = Integer.parseInt(value);
          com.ibm.ws.sib.utils.Runtime.changedPropertyValue(key, value);
        }
        else if (key.equals("sib.processor.idleTimeout"))
        {
          _ck_idle_timeout = Integer.parseInt(value);
          com.ibm.ws.sib.utils.Runtime.changedPropertyValue(key, value);
        }
        else if (key.equals("sib.processor.messageWaitTimeGranularity"))
        {
          _message_wait_time_granularity = Integer.parseInt(value);
          com.ibm.ws.sib.utils.Runtime.changedPropertyValue(key, value);
        }
        // Multicast Properties
        else if (key.equals("multicastEnabled"))
        {
          _multicastEnabled = Boolean.valueOf(value).booleanValue();
          com.ibm.ws.sib.utils.Runtime.changedPropertyValue(key, value);
        }
        else if (key.equals("multicastInterface"))
        {
          _multicastInterfaceAddress = value;
          com.ibm.ws.sib.utils.Runtime.changedPropertyValue(key, value);
        }
        else if (key.equals("multicastPort"))
        {
          _multicastPort = Integer.parseInt(value);
          com.ibm.ws.sib.utils.Runtime.changedPropertyValue(key, value);
        }
        else if (key.equals("multicastPacketSize"))
        {
          _multicastPacketSize = Integer.parseInt(value);
          com.ibm.ws.sib.utils.Runtime.changedPropertyValue(key, value);
        }
        else if (key.equals("multicastTTL"))
        {
          _multicastTTL = Integer.parseInt(value);
          com.ibm.ws.sib.utils.Runtime.changedPropertyValue(key, value);
        }
        else if (key.equals("multicastGroupAddress"))
        {
          _multicastGroupAddress = value;
          com.ibm.ws.sib.utils.Runtime.changedPropertyValue(key, value);
        }
        else if (key.equals("multicastUseReliableRMM"))
        {
          _multicastUseReliableRMM = Boolean.valueOf(value).booleanValue();;
          com.ibm.ws.sib.utils.Runtime.changedPropertyValue(key, value);
        }
        else if (key.equals("sib.processor.targetBatchTimeout"))
        {
          _target_batch_timeout = Long.parseLong(value);
          com.ibm.ws.sib.utils.Runtime.changedPropertyValue(key, value);
        }
        else if (key.equals("sib.processor.targetBatchSize"))
        {
          _target_batch_size = Integer.parseInt(value);
          com.ibm.ws.sib.utils.Runtime.changedPropertyValue(key, value);
        }
        else if (key.equals("sib.processor.sourceBatchTimeout"))
        {
          _source_batch_timeout = Long.parseLong(value);
          com.ibm.ws.sib.utils.Runtime.changedPropertyValue(key, value);
        }
        else if (key.equals("sib.processor.sourceBatchSize"))
        {
          _source_batch_size = Integer.parseInt(value);
          com.ibm.ws.sib.utils.Runtime.changedPropertyValue(key, value);
        }
        else if (key.equals("sib.processor.roundTripTimeLowLimit"))
        {
          _round_trip_time_low_limit = Integer.parseInt(value);
          com.ibm.ws.sib.utils.Runtime.changedPropertyValue(key, value);
        }
        else if (key.equals("sib.processor.remoteConsumerInactivityTimeout"))
        {
          _remote_consumer_cardinality_inactivity_interval = Integer.parseInt(value);
          com.ibm.ws.sib.utils.Runtime.changedPropertyValue(key, value);
        }
        else if (key.equals("sib.processor.remoteConsumerTransmitterInactivityTimeout"))
        {
          _sender_inactivity_timeout = Integer.parseInt(value);
          com.ibm.ws.sib.utils.Runtime.changedPropertyValue(key, value);
        }
        else if (key.equals("sib.processor.blockedRetryTimeout"))
        {
          _blocked_retry_timeout = Long.parseLong(value);
          com.ibm.ws.sib.utils.Runtime.changedPropertyValue(key, value);
        }
        else if (key.equals("sib.processor.pendingRetryTimeout"))
        {
          long pendingRetryTimeout = Long.parseLong(value);
          // Change from the default value as long as its greater than 0.
          if(pendingRetryTimeout > 0) 
          {
            _pending_retry_timeout = pendingRetryTimeout;
             com.ibm.ws.sib.utils.Runtime.changedPropertyValue(key, value);
          }
        }    
        else if (key.equals("sib.processor.protocolSendWindow"))
        {
          _definedSendWindow = Integer.parseInt(value);
          com.ibm.ws.sib.utils.Runtime.changedPropertyValue(key, value);
        }
        else if (key.equals("sib.processor.remoteTopicSpaceHighExcess"))
        {
          double remoteQueueHighExcess = Double.parseDouble(value);
          if(remoteQueueHighExcess>=0){
            _remote_queue_high_percentage_excess = remoteQueueHighExcess;
            com.ibm.ws.sib.utils.Runtime.changedPropertyValue(key, value);
          }
        }
        else if (key.equals("sib.processor.destLowUnsetPercentageDecrease"))
        {
          double destQueueLowDecrease = Double.parseDouble(value);
          if(destQueueLowDecrease>=0 && destQueueLowDecrease<1){
            _dest_low_unset_percentage_decrease = destQueueLowDecrease;
            com.ibm.ws.sib.utils.Runtime.changedPropertyValue(key, value);
          }
        }
  
        
        else if (key.equals("sib.processor.maxForwardRoutingPathDepth"))
        {
          _max_frp_depth = Integer.parseInt(value);
          com.ibm.ws.sib.utils.Runtime.changedPropertyValue(key, value);
        }
        else if (key.equals("sib.processor.messageCacheTimeout"))
        {
          _message_reference_expiry_value = Long.parseLong(value);
          com.ibm.ws.sib.utils.Runtime.changedPropertyValue(key, value);
        }
        else if (key.equals("sib.processor.forcePEV"))
        {
          _force_pev = Boolean.parseBoolean(value);
          com.ibm.ws.sib.utils.Runtime.changedPropertyValue(key, value);
        }
        else if (key.equals("sib.processor.minPrefetchSsize"))
        {
          _min_prefetch_size = Double.parseDouble(value);
          com.ibm.ws.sib.utils.Runtime.changedPropertyValue(key, value);
        }
        else if (key.equals("sib.processor.maxIntervalForPrefetch"))
        {
          _max_interval_for_prefetch = Integer.parseInt(value);
          com.ibm.ws.sib.utils.Runtime.changedPropertyValue(key, value);
        }
        else if (key.equals("sib.processor.roundTripTimeHighLimit"))
        {
          _round_trip_time_high_limit = Long.parseLong(value);
          com.ibm.ws.sib.utils.Runtime.changedPropertyValue(key, value);
        }
        else if (key.equals("sib.processor.infiniteTimeout"))
        {
          _infinite_timeout = Long.parseLong(value);
          com.ibm.ws.sib.utils.Runtime.changedPropertyValue(key, value);
        }
        else if (key.equals("sib.processor.unknownPrevTick"))
        {
          _unknown_prev_tick = Long.parseLong(value);
          com.ibm.ws.sib.utils.Runtime.changedPropertyValue(key, value);
        }
        else if (key.equals("sib.processor.anycastRequestFlushRepetitionInterval"))
        {
          _request_flush_repetition_interval = Long.parseLong(value);
          com.ibm.ws.sib.utils.Runtime.changedPropertyValue(key, value);
        }
        else if (key.equals("sib.processor.anycastRequestFlushSlowRepetitionInterval"))
        {
          _request_flush_slow_repetition_interval = Long.parseLong(value);
          com.ibm.ws.sib.utils.Runtime.changedPropertyValue(key, value);
        }
        else if (key.equals("sib.processor.gatheringLocalPercentage"))
        {
          _gathering_local_weighting = Integer.parseInt(value);
          com.ibm.ws.sib.utils.Runtime.changedPropertyValue(key, value);
        }
        else if (key.equals("sib.processor.gatheringReattachInterval"))
        {
          _gathering_reattach_interval = Long.parseLong(value);
          com.ibm.ws.sib.utils.Runtime.changedPropertyValue(key, value);
        }
        // blockedCommittingMessageInterval defines the period of time (in milliseconds)
        // that a transaction can remain in 'committing' state (the period after a
        // prepare and before a commit or rollback) before a warning is issued identifying
        // the transaction that appears to be blocked.
        // The default is a period of one minute, a value of zero disables the warnings.
        // If the message remains in this state a repeat message will be issued at most 
        // every 5 minutes (not configurable) after the first report.
        else if (key.equals("sib.processor.blockedCommittingMessageInterval"))
        {
          BLOCKED_STREAM_INTERVAL = Integer.parseInt(value);
          com.ibm.ws.sib.utils.Runtime.changedPropertyValue(key, value);
          
          // Now we've changed the reporting interval we re-calculate the check interval,
          // we modify the check interval so that the report interval is a multiple of
          // the check interval. We do this by allowing the check interval to vary by
          // +-50% of the GDConfig.BLOCKED_STREAM_HEALTH_CHECK_INTERVAL value (10 seconds).
          if(BLOCKED_STREAM_INTERVAL > (GDConfig.BLOCKED_STREAM_HEALTH_CHECK_INTERVAL))
          {
            BLOCKED_STREAM_RATIO = Math.round(BLOCKED_STREAM_INTERVAL /
                                              (float)GDConfig.BLOCKED_STREAM_HEALTH_CHECK_INTERVAL);
            BLOCKED_STREAM_CHECK_INTERVAL = (BLOCKED_STREAM_INTERVAL / BLOCKED_STREAM_RATIO);
          }
          else
          {
            BLOCKED_STREAM_CHECK_INTERVAL = BLOCKED_STREAM_INTERVAL;
            BLOCKED_STREAM_RATIO = 1;
          }
        }
        // Enabling logDepthThresholdEvents with result in notification events for
        // destinations or links being written to the output log of the Application Server
        // even when JMX event notification is not enabled.
        // Possible setting are:
        //    links - Log high/low transitions for any link transmission streams
        //            (SIB or WMQ)
        //    on    - Log high/low transitions for any message points, remote message points
        //            or links (SIB or WMQ) (default value)
        //    off   - No high/log events written to the log
        else if (key.equals("sib.processor.logDepthThresholdEvents"))
        {
          if(value.compareToIgnoreCase("links") == 0)
          {
            OUTPUT_LINK_THRESHOLD_EVENTS_TO_LOG = true; 
            OUTPUT_DESTINATION_THRESHOLD_EVENTS_TO_LOG = false; 
            com.ibm.ws.sib.utils.Runtime.changedPropertyValue(key, value);
          }
          else if(value.compareToIgnoreCase("on") == 0)
          {
            OUTPUT_LINK_THRESHOLD_EVENTS_TO_LOG = true; 
            OUTPUT_DESTINATION_THRESHOLD_EVENTS_TO_LOG = true; 
            com.ibm.ws.sib.utils.Runtime.changedPropertyValue(key, value);
          }
          else if(value.compareToIgnoreCase("off") == 0)
          {
            OUTPUT_LINK_THRESHOLD_EVENTS_TO_LOG = false; 
            OUTPUT_DESTINATION_THRESHOLD_EVENTS_TO_LOG = false; 
            com.ibm.ws.sib.utils.Runtime.changedPropertyValue(key, value);
          }
        }
        // (510343)
        // Write a log message for every message point, remote message point or link for
        // every increment of the defined message depth.
        // For example, if set to 1000 a message will be written every time the message
        // depth of a queue point reaches a multiple of 1000 (including zero if 1000 was
        // previously reached), so an expected sequence may be: 1000, 2000, 1000, 0, 1000, ...
  
        // A value of zero or less does not enable messages to be logged (although
        // individual message points, remote message points, links can be enabled using
        // the next property, sib.processor.logMessageDepthIntervals.XXX).
        
        // The default setting is zero (disabled)
        else if (key.equals("sib.processor.logAllMessageDepthIntervals"))
        {
          LOG_ALL_MESSAGE_DEPTH_INTERVALS = Integer.parseInt(value);
          com.ibm.ws.sib.utils.Runtime.changedPropertyValue(key, value);
        }
        // (510343)
        // sib.processor.logMessageDepthIntervals.XXX, where XXX is a destination/foreign bus
        // name, enables/disables message depth log messages to be output to the application server
        // log every increment of the defined message depth (as defined by
        // sib.processor.logAllMessageDepthIntervals but for individual destinations/foreign buses).
        
        // To monitor messages being transmitted from this ME via a link (SIB or WMQ) the
        // name of the DIRECT foreign bus should be used here.
        
        // Set to zero to explicitly disable logging for a particular destination/foreign bus
        
        // The setting of sib.processor.logAllMessageDepthIntervals applies to all destination/
        // foreign buses that have not been explicitly configured using this property.
        else if (key.startsWith("sib.processor.logMessageDepthIntervals."))
        {
          String destName = key.substring("sib.processor.logMessageDepthIntervals.".length());
          _logMessageDepthIntervals.put(destName, new Long(value));
          com.ibm.ws.sib.utils.Runtime.changedPropertyValue(key, value);
        }
        // (510343)
        // Write a log record if a gap remains in the arriving message stream from another
        // messaging engine or bus after approximately this time (in seconds).
        
        // A value of zero or less disables this logging (disabled by default)
        else if (key.equals("sib.processor.logUnresolvedGapsInTransmissionStreams"))
        {
          NACK_LOG_INTERVAL = Integer.parseInt(value);
          com.ibm.ws.sib.utils.Runtime.changedPropertyValue(key, value);
        }
        // (510343)
        // It's acceptable to recieve the odd repeated value, for example a message
        // is sent from the source slightly out of order with subsequent messages
        // due to it's transaction taking longer to complete than others). So we (the
        // target) see a gap appear, nack the gap (after a few milliseconds) then the
        // message arrives anyway so we add it to the stream. Then the source receives
        // the nack and re-sends the message. When that arrives at us we just ignore it
        // becuase we already have it.
        // You'd expect this to happen occasionally but if it happens too often, especially after
        // an initial re-start period, it will add unnecessary traffic, reducing performance.
        // There are a couple of reasons this can occur:
        //  1) the initial nack is sent too fast to allow for slightly out of order
        //     streams. This is set by sib.processor.transmissionStreamGapEagerness (defaults to
        //     200 msecs)
        //  2) The end-to-end transmission time of messages is excessively long, so
        //     once a gap is introduced (by the sender overloading the socket) the gap
        //     is nacked multiple times. This is due to the nack repetition timer (NRT)
        //     popping multiple times before the re-sent message (from the first nack) is
        //     actually recieved and the NRT cancelled. This end-to-end delay has been seen due
        //     to excessive buffering of inbound messages in the Comms layer before being
        //     processed by us. This buffer in Comms can be configured using
        //     com.ibm.ws.sib.jfapchanel.RL_DISPATCHER_MAXQUEUESIZE. The excessive buffering
        //     is still only a symptom of the socket being overloaded with work, the thing
        //     sending all the messages needs to back off (although this is to be expected when
        //     a connection/ME is restarted)
  
        // This property will result in a warning message being logged if the percentage of re-sent
        // messages over other messages for any particular destination or link exceeds the setting in
        // the defined message interval (see sib.processor.repeatedMessageInterval for definition of
        // the interval).
        
        // Valid settings are 0-100, where 0 disables the checking and 100 represents 100%
        // resent messages. The default is set to 0 (disabled).
        
        // Once a warning is issued for a particulat destination or link it will not be re-issued
        // within 5 minutes even if the percentage of re-sent messages exceeds this setting during
        // that time.
        else if (key.equals("sib.processor.repeatedMessagePercentage"))
        {
          REPEATED_VALUE_PERCENTAGE = Integer.parseInt(value);
          com.ibm.ws.sib.utils.Runtime.changedPropertyValue(key, value);
        }
        // (510343)
        // Define the sample size of incoming messages that the sib.processor.repeatedMessagePercentage
        // check is applied to.
        
        // For example, a percentage of 25 and an interval of 2000 would require at least 500 resent
        // messages to be received in a sample of 2000 incoming messages to produce a warning message.
        
        // The default interval is 2000 (although the default percentage is zero, so checking is disabled).
        else if (key.equals("sib.processor.repeatedMessageInterval"))
        {
          REPEATED_VALUE_INTERVAL = Integer.parseInt(value);
          com.ibm.ws.sib.utils.Runtime.changedPropertyValue(key, value);
        }
        // (510343)
        // If a target stream receives a message and detects that it hasn't yet received the previous
        // message(s) it will send a NACK to the sending ME after this period, re-requesting this
        // message. This is intended to resolve gaps introduced when messages are dropped from the
        // connection (e.g. when an ME-ME connection is recycled, or when the Comms buffers are exhausted).
        
        // Due to threading and differences in the time it takes to complete the commit of a transaction
        // (this is NOT related to the time between sending a message and committing the transaction
        // though), it is legitimate to recieve messages out of order on a stream. This is why the delay
        // between detecting a gap and NACKing it exists.
        
        // However, if the NACKing is too eager it will result in messages that haven't been dropped but
        // are just a 'little slow' being NACKed, this results in multiple copies of the same message
        // being sent. This is inefficient and should be tuned out of the system.
        
        // WARNING: The longer the delay, the longer it will take to fill genuine gaps in the stream, possibly
        // degrading performance.
        
        // The default delay is 200 milliseconds
        else if (key.equals("sib.processor.transmissionStreamGapEagerness"))
        {
          GD_GAP_CURIOSITY_THRESHOLD = Integer.parseInt(value);
          com.ibm.ws.sib.utils.Runtime.changedPropertyValue(key, value);
        }
        // (F001731)
        // If a destination has been enabled to report warnings when a consumer has been blocked
        // on its maxActiveMessages setting for a configured period of time (using the destination context
        // property of 'MsgBlockWarningInterval'), this custom property sets the frequency that the
        // warning is re-issued while the block still exists (in seconds).
  
        // The default period is 300 seconds (5 minutes)
        else if (key.equals("sib.processor.msgBlockWarningRepeatInterval"))
        {
          MSG_BLOCK_WARNING_REPEAT_INTERVAL = Integer.parseInt(value);
          com.ibm.ws.sib.utils.Runtime.changedPropertyValue(key, value);
        }
      }
      catch(Exception e)
      {
        // No FFDC code needed
        
        // We've had a problem setting a custom property, probably due to an invalid value
        // (e.g. trying to fit a long into an int).
        
        // TODO This shouldn't be an 'internal error', as it's probably user error, but we're
        // at a stage where we can't add new warning messages, so this'll have to do for now.
  
        // Log to console
        SibTr.error(
          tc,
          "INTERNAL_MESSAGING_ERROR_CWSIP0008",
          new Object[] {
              "com.ibm.ws.sib.processor.impl.CustomProperties.setProperty",
              "1:944:1.8.1.16",
              "(Key: " + key + " Value: " + value + ")",
              e});
      }
      
      if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) SibTr.exit(tc, "setProperty");
    }