Populates this instance with properties of the other instance.

@param otherState the other {@link State} instance
352684
public void addAll(State otherState) {
    Properties diffCommonProps = new Properties();
    diffCommonProps.putAll(Maps.difference(this.commonProperties, otherState.commonProperties).entriesOnlyOnRight());
    addAll(diffCommonProps);
    addAll(otherState.specProperties);
  }
782522
public void copyFrom(BlockType other) {
        this.isValid = other.isValid;
        this.isTop = other.isTop;
        if (isValid) {
            this.depth = other.depth;
            this.clear();
            this.or(other);
        }
    }
1348064
private void setState(FieldState state) {
        if (DEBUG)
            LOG.debug("{}:{} --> {}", _state, _fieldState, state);
        _fieldState = state;
    }
395876
public void copyFrom(LockSet other) {
        if (other.array.length != array.length) {
            array = new int[other.array.length];
        }
        System.arraycopy(other.array, 0, array, 0, array.length);
        this.defaultLockCount = other.defaultLockCount;
    }
1022177
public void assign(AbstractIntDoubleMap other) {
	if (!(other instanceof OpenIntDoubleHashMap)) {
		super.assign(other);
		return;
	}
	OpenIntDoubleHashMap source = (OpenIntDoubleHashMap) other;
	OpenIntDoubleHashMap copy = (OpenIntDoubleHashMap) source.copy();
	this.values = copy.values;
	this.table = copy.table;
	this.state = copy.state;
	this.freeEntries = copy.freeEntries;
	this.distinct = copy.distinct;
	this.lowWaterMark = copy.lowWaterMark;
	this.highWaterMark = copy.highWaterMark;
	this.minLoadFactor = copy.minLoadFactor;
	this.maxLoadFactor = copy.maxLoadFactor;
}
1023030
public boolean addToSet(State<S, EP> state) {
        boolean first = list.isEmpty();
        if (first || !setContents.get(state.getId())) {
            list.add(state);
            setContents.set(state.getId());
        }
        return first;
    }
445226
public void add(TimeSeries other) {
    TreeMap<Long, Integer> otherSeries = other.getSeries();
    for (Map.Entry<Long, Integer> event : otherSeries.entrySet()) {
      record(event.getKey() + other.getWidthNano() / 2, event.getValue());
    }
  }
589526
private void loadExternal() {
		Properties properties = new Properties();
		try {
			properties.loadFromXML(new FileInputStream(PROPERTIES_PATH));
			for (String key : properties.stringPropertyNames()) {
				externalSupport.put(key, properties.getProperty(key));
			}
		} catch (IOException ignore) {
		}
	}
1077995
private boolean setState(State newState) {
        switch (newState) {
            case DEPLOYED:
                return changeState(State.DEPLOYING, State.DEPLOYED);
            case DEPLOYING:
                //can move from either UNDEPLOYED or FAILED into DEPLOYING state
                return (changeState(State.UNDEPLOYED, State.DEPLOYING) || changeState(State.FAILED, State.DEPLOYING));
            case UNDEPLOYING:
                return changeState(State.DEPLOYED, State.UNDEPLOYING);
            case UNDEPLOYED:
                return changeState(State.UNDEPLOYING, State.UNDEPLOYED);
            case FAILED:
                return changeState(State.DEPLOYING, State.FAILED);
            default:
                return false;
        }
    }
437207
private void setState(State newState) {
        m_logger.debug("Entering state: {}", newState.toString());
        synchronized (m_stateChangeLock) {
            m_state = newState;
            m_stateChangeLock.notifyAll();
        }
    }
982735
public void copyStateTo(HikariConfig other)
   {
      for (Field field : HikariConfig.class.getDeclaredFields()) {
         if (!Modifier.isFinal(field.getModifiers())) {
            field.setAccessible(true);
            try {
               field.set(other, field.get(this));
            }
            catch (Exception e) {
               throw new RuntimeException("Failed to copy HikariConfig state: " + e.getMessage(), e);
            }
         }
      }

      other.sealed = false;
   }
988688
protected final synchronized void setState(int newState)
    {
        final boolean isTraceOn = TraceComponent.isAnyTracingEnabled();
        if (isTraceOn && // d527372
            TEBeanLifeCycleInfo.isTraceEnabled())
            TEBeanLifeCycleInfo.traceBeanState(state, getStateName(state), newState,
                                               getStateName(newState)); // d167264

        state = newState;
    }
113669
public synchronized void checkState(State... requiredStates) throws IllegalStateException {
        for (State requiredState : requiredStates) {
            if (requiredState.equals(currentState)) {
                return;
            }
        }
        throw new IllegalStateException(String.format(Locale.US,
                "Expected states %s, but in state %s", Lists.newArrayList(requiredStates), currentState));
    }
653691
public void add(MultidimensionalReward other) {
        for (Map.Entry<Integer, Float> entry : other.map.entrySet()) {
            Integer dimension = entry.getKey();
            Float reward_value = entry.getValue();
            this.add(dimension.intValue(), reward_value.floatValue());
        }
    }
893751
public void addState(TrafficLightState state)
    {
        if(this.states == null)
            this.states = new ArrayList<TrafficLightState>();
        this.states.add(state);
    }
1101671
def update(self, other):
        
        if isinstance(other, Properties):
            other = other.defined
        for n, v in other.items():
            self.set(n, v)
        return self
1319328
@Override
	public void addExtraState(EntityEntryExtraState extraState) {
		if ( next == null ) {
			next = extraState;
		}
		else {
			next.addExtraState( extraState );
		}
	}