This method should be called by all setter methods if they alter the state
information of this destination. Doing so will cause the string encoded version
of this destination to be recreated when necessary.
516487
private void clearCachedEncodings() {

        cachedEncodedString = null;
        cachedPartialEncodedString = null;

        for (int i = 0; i < cachedEncoding.length; i++)
            cachedEncoding[i] = null;
    }
848985
final void setEncoding(Object value) {
        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
            SibTr.entry(this, tc, "setEncoding", value);

        // If the value is null or unsuitable, then clear the field
        if ((value == null) || !(value instanceof Integer)) {
            jmo.getPayloadPart().setField(JsPayloadAccess.ENCODING, JsPayloadAccess.IS_ENCODING_EMPTY);
        }
        // If it does exist and is an Integer, then we just store it
        else {
            jmo.getPayloadPart().setField(JsPayloadAccess.ENCODING_DATA, value);
        }

        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
            SibTr.exit(this, tc, "setEncoding");
    }
1326073
public int setState(boolean bState, boolean bDisplayOption, int iMoveMode)
    {
        if (m_strTargetValue != null)
        {
            String fieldString = this.getString();
            if (m_boolMaskValue.booleanValue())
            {
                int index = fieldString.indexOf(m_strTargetValue);
                if (bState == m_bTrueIfMatch)
                {   // Add target string to field!
                    if (index == -1) // Is the target value in the field string?
                    {   // No, Add it!
                        fieldString = m_strTargetValue + fieldString;        // Add the field to the string
                    }
                }
                else
                {   // Take target field out of field
                    if (index != -1)    // Is the target value in the field string
                    {   // Yes, Take it out!
                        fieldString = fieldString.substring(0, index) + fieldString.substring(index+1);   // Strip the field to the string
                    }
                }
            }
            else
                fieldString = m_strTargetValue; // Set to the value
            return this.setString(fieldString, bDisplayOption, iMoveMode);
        }
        else if (m_fldTargetValue != null)
        {
            if (bState == m_bTrueIfMatch)
            	return ((BaseField)this.getField()).moveFieldToThis(m_fldTargetValue, bDisplayOption, iMoveMode);
            else
                return ((BaseField)this.getField()).setString(null);	// Unchecked = clear it.
        }
        else    // Target = null
        {
            if (bState == m_bTrueIfMatch)
                return ((BaseField)this.getField()).setString(null);
            else
                return DBConstants.NORMAL_RETURN; //?
        }
    }
306258
public void setState(TransferState state) {
        synchronized (this) {
            this.state = state;
        }
        for ( TransferStateChangeListener listener : stateChangeListeners ) {
            listener.transferStateChanged(this, state);
        }
    }
691895
@Modified
    protected synchronized void modified(Map<String, Object> cfwConfiguration) {

        if (null == cfwConfiguration) {
            return;
        }

        if (TraceComponent.isAnyTracingEnabled() && tc.isEventEnabled()) {
            Tr.event(this, tc, "Processing config", cfwConfiguration);
        }

        this.chfw.updateConfig(cfwConfiguration);
    }
1148371
@Override
    public void setDestination(Destination destination) {
        if (TraceComponent.isAnyTracingEnabled() && TRACE.isDebugEnabled()) {
            SibTr.debug(this, TRACE, "setDestination", destination);
        }
        _destination = destination;
    }
923453
public int setData(Object state, boolean bDisplayOption, int iMoveMode)
    {       // Must be overidden
        m_bSetData = true;  // Make sure getNextConverter is called correctly (if it is called).
        int iErrorCode = super.setData(state, bDisplayOption, iMoveMode);
        m_bSetData = false;
        return iErrorCode;
    }
317968
@Override
    protected void write(EncodingState encodingState, String str, int off, int len) throws IOException {
        target.write(str, off, len);
    }
861919
public void setFrom(final String from) {
    if (null == from) {
      this.from = null;
    } else {
      if (Strings.contains(from.toLowerCase(), "from")) {
        this.from = from;
      } else {
        this.from = " from " + from;
      }
    }
  }
1038063
private StringInfo getOrCreateStringInfo(String string) {
    StringInfo info = stringInfoMap.get(string);
    if (info == null) {
      info = new StringInfo(stringInfoMap.size());
      stringInfoMap.put(string, info);
    }
    return info;
  }
806568
private final void setto(String s) {
        int l = s.length(); 
        int o = j+1;
        for (int i = 0; i < l; i++)
            sb.setCharAt(o+i, s.charAt(i));
        k = j+l;
    }
988205
public boolean shouldEncode(Encoder encoderToApply, EncodingState encodingState) {
        return ignoreEncodingState || (encoderToApply != null
                && (encodingState == null || shouldEncodeWith(encoderToApply, encodingState)));
    }
1178162
private boolean lookupSwitchOnString() {
        if (stack.getStackDepth() > 1) {
            OpcodeStack.Item item = stack.getStackItem(1);
            String stringRef = (String) item.getUserValue();

            if (stringRef == null) {
                return false;
            }

            if (!lookupSwitches.isEmpty()) {
                LookupDetails details = lookupSwitches.get(lookupSwitches.size() - 1);
                return stringRef.equals(details.getStringReference());
            }
        }

        return true;
    }
612359
public void setDestination(String destination)
  {
    if (tc.isEntryEnabled())
      SibTr.entry(tc, "setDestination", destination);

    this.destination = destination;

    if (tc.isEntryEnabled())
      SibTr.exit(tc, "setDestination");
  }
1102080
public void updateLocalizationDefinition(
                                             LocalizationDefinition newLocalizationDefinition)
    {
        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
            SibTr.entry(tc, "updateLocalizationDefinition", newLocalizationDefinition);

        // If null is passed as the new localization definition, treat that
        // as a no-op.
        if (null != newLocalizationDefinition)
        {
            boolean isDestLimitsChanged = false;
            boolean isSendAllowedChanged = false;
            boolean isAlterationTimeChanged = false;
            boolean isNameChanged = false;

            // If the previous definition we had was null, then every attribute is
            // changing, as it's being set for the 1st time.
            if (null == _lastLocalizationDefinitionSetByAdmin)
            {
                isDestLimitsChanged = true;
                isSendAllowedChanged = true;
                isAlterationTimeChanged = true;
                isNameChanged = true;
            }
            else
            {
                // Check to see if the max messages property has changed.
                if ((_lastLocalizationDefinitionSetByAdmin.getDestinationHighMsgs() !=
                    newLocalizationDefinition.getDestinationHighMsgs())
                    || (_lastLocalizationDefinitionSetByAdmin.getDestinationLowMsgs() !=
                    newLocalizationDefinition.getDestinationLowMsgs()))
                {
                    isDestLimitsChanged = true;
                }

                // Check to see if put inhibited changed or not.
                if (_lastLocalizationDefinitionSetByAdmin.isSendAllowed() != newLocalizationDefinition.isSendAllowed())
                {
                    isSendAllowedChanged = true;
                }

                // Check to see if the alteration time has changed.
                if (_lastLocalizationDefinitionSetByAdmin.getAlterationTime() != newLocalizationDefinition.getAlterationTime())
                {
                    isAlterationTimeChanged = true;
                }

                // Check to see if the name has changed or not.
                String oldName = _lastLocalizationDefinitionSetByAdmin.getName();
                String newName = newLocalizationDefinition.getName();
                if ((null == newName && oldName != null)
                    || (null != newName && oldName == null))
                {
                    isNameChanged = true;
                }
            }

            // Take a snap-shot so we can compare the settings we've got with the
            // ones admin gives us next time.
            this._lastLocalizationDefinitionSetByAdmin =
                            newLocalizationDefinition;

            if (isDestLimitsChanged)
            {
                setDestLimits(newLocalizationDefinition.getDestinationHighMsgs(),
                              newLocalizationDefinition.getDestinationLowMsgs());
            }
            if (isSendAllowedChanged)
            {
                setSendAllowed(newLocalizationDefinition.isSendAllowed());
            }
            if (isAlterationTimeChanged)
            {
                setAlterationTime(newLocalizationDefinition.getAlterationTime());
            }
            if (isNameChanged)
            {
                setName(newLocalizationDefinition.getName());
            }

        }

        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
            SibTr.exit(tc, "updateLocalizationDefinition");
    }
302170
private void updateStateForChar(State state, int index, Collection<State> result) {
    char ch = (char) (text[index] & 0xFF);
    boolean charInCurrentTable = CHAR_MAP[state.getMode()][ch] > 0;
    State stateNoBinary = null;
    for (int mode = 0; mode <= MODE_PUNCT; mode++) {
      int charInMode = CHAR_MAP[mode][ch];
      if (charInMode > 0) {
        if (stateNoBinary == null) {
          // Only create stateNoBinary the first time it's required.
          stateNoBinary = state.endBinaryShift(index);
        }
        // Try generating the character by latching to its mode
        if (!charInCurrentTable || mode == state.getMode() || mode == MODE_DIGIT) {
          // If the character is in the current table, we don't want to latch to
          // any other mode except possibly digit (which uses only 4 bits).  Any
          // other latch would be equally successful *after* this character, and
          // so wouldn't save any bits.
          State latchState = stateNoBinary.latchAndAppend(mode, charInMode);
          result.add(latchState);
        }
        // Try generating the character by switching to its mode.
        if (!charInCurrentTable && SHIFT_TABLE[state.getMode()][mode] >= 0) {
          // It never makes sense to temporarily shift to another mode if the
          // character exists in the current mode.  That can never save bits.
          State shiftState = stateNoBinary.shiftAndAppend(mode, charInMode);
          result.add(shiftState);
        }
      }
    }
    if (state.getBinaryShiftByteCount() > 0 || CHAR_MAP[state.getMode()][ch] == 0) {
      // It's never worthwhile to go into binary shift mode if you're not already
      // in binary shift mode, and the character exists in your current mode.
      // That can never save bits over just outputting the char in the current mode.
      State binaryState = state.addBinaryShiftChar(index);
      result.add(binaryState);
    }
  }
1348064
private void setState(FieldState state) {
        if (DEBUG)
            LOG.debug("{}:{} --> {}", _state, _fieldState, state);
        _fieldState = state;
    }