See {@link #addConstructState(Constructs, ConstructState, Optional)}. This method uses no infix.
964542
public void addConstructState(Constructs construct, ConstructState constructState) {
    addConstructState(construct, constructState, Optional.<String>absent());
  }
688671
public HalResource addState(ObjectNode state) {
    state.fields().forEachRemaining(entry -> model.set(entry.getKey(), entry.getValue()));
    return this;
  }
153366
public void addState(String name, String code)
    {
    	states.add(new State(this, name, code));
    }
469249
private void addNonExcactActions(Construction construction,
	    ParserActionSet set, Map<Construction, ParserActionSet> actions) {
	set.addActions(actions.get(new Terminal(construction.getName(), null)));
    }
89131
public static void add() {

        String current = System.getProperties().getProperty(HANDLER_PKGS, "");
        if (current.length() > 0) {
            if (current.contains(PKG)) {
                return;
            }
            current = current + "|";
        }
        System.getProperties().put(HANDLER_PKGS, current + PKG);

    }
325021
protected final void setState(final int newState)
	{
		if (closing < 2) {
			//  detect and ignore order of arrival inversion for tunneling.ack/cEMI.con
			if (internalState == OK && newState == ClientConnection.CEMI_CON_PENDING)
				return;
			internalState = newState;
			if (updateState)
				state = newState;
		}
		else
			state = internalState = CLOSED;
	}
960539
def add_state(self, state_name, initial_state, batch_size=None):
    
    state_shape = initial_state.get_shape().as_list()
    full_shape = [batch_size] + state_shape
    if not batch_size:
      # TODO(): -1 is now reserved for unknown, so this should be
      # updated, but that requires coordination with the binary and is
      # checkpoint incompatible.
      # TODO(eiderman): When we make the above breaking change, we should make
      # the C++ client use the initial state instead of passing in zeros.
      shape_proto = self._as_shape_proto([0] + state_shape)
      batch_size = 1
    else:
      shape_proto = self._as_shape_proto([batch_size] + state_shape)

    # Add a constant tensor of zeros. At training time, this will initialize
    # the state with the initial_state - at inference time,
    # this node is replaced by a feed.
    tiles = [batch_size] + ([1] * len(initial_state.get_shape()))
    feed_op = tf.placeholder_with_default(
        tf.tile(
            tf.expand_dims(initial_state, [0]), tiles),
        shape=full_shape,
        name='%s_feed' % state_name)
    s = {'feed_op': feed_op,
         'feed_type': initial_state.dtype,
         'feed_shape': shape_proto}
    self._states[state_name] = s
1045598
public void addState() {
        DiffHistoryDataState nextState = new DiffHistoryDataState(stateEngine, typeDiffInstructions);

        if(currentDataState != null)
            newHistoricalState(currentDataState, nextState);

        currentDataState = nextState;
    }
125214
void addToSubBlock(State<S, L> state) {
        if (currSubBlock == null) {
            throw new IllegalStateException("No current sub block");
        }
        currSubBlock.referencedAdd(state);
        elementsInSubBlocks++;
    }
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;
    }
126751
protected void addConstructors(ClassFile proxyClassType, List<DeferredBytecode> initialValueBytecode) {
        try {
            if (getBeanType().isInterface()) {
                ConstructorUtils.addDefaultConstructor(proxyClassType, initialValueBytecode, !useConstructedFlag());
            } else {
                boolean constructorFound = false;
                for (Constructor<?> constructor : AccessController.doPrivileged(new GetDeclaredConstructorsAction(getBeanType()))) {
                    if ((constructor.getModifiers() & Modifier.PRIVATE) == 0) {
                        constructorFound = true;
                        String[] exceptions = new String[constructor.getExceptionTypes().length];
                        for (int i = 0; i < exceptions.length; ++i) {
                            exceptions[i] = constructor.getExceptionTypes()[i].getName();
                        }
                        ConstructorUtils.addConstructor(BytecodeUtils.VOID_CLASS_DESCRIPTOR, DescriptorUtils.parameterDescriptors(constructor.getParameterTypes()), exceptions, proxyClassType, initialValueBytecode, !useConstructedFlag());
                    }
                }
                if (!constructorFound) {
                    // the bean only has private constructors, we need to generate
                    // two fake constructors that call each other
                    addConstructorsForBeanWithPrivateConstructors(proxyClassType);
                }
            }
        } catch (Exception e) {
            throw new WeldException(e);
        }
    }
93387
public void put(Var var, int state) {
        if (state < 0 || state >= var.getNumStates()) {
            throw new IllegalArgumentException("Invalid state idx " + state + " for var " + var);
        }
        config.put(var, state);
        vars.add(var);
    }
422355
public final void postConstruct() {
        Assert.equals(2, this.tileSize.length, "tileSize must have exactly 2 elements to the array.  Was: " +
                Arrays.toString(this.tileSize));
        Assert.equals(2, this.topLeftCorner.length,
                      "topLeftCorner must have exactly 2 elements to the array.  Was: " +
                              Arrays.toString(this.topLeftCorner));
        Assert.equals(2, this.matrixSize.length,
                      "matrixSize must have exactly 2 elements to the array.  Was: " +
                              Arrays.toString(this.matrixSize));
    }
1010117
public void addMasterState(MasterState state) {
		checkNotNull(state);

		synchronized (lock) {
			if (!discarded) {
				masterState.add(state);
			}
		}
	}
543455
private function doDestruct()
    {
        if ($this->initializer && null === $this->info['error']) {
            ($this->initializer)($this);
            $this->initializer = null;
            $this->checkStatusCode();
        }
    }
1153030
@Override
    protected void updateState(final String name, final InstallationModificationImpl modification, final InstallationModificationImpl.InstallationState state) {
        final PatchableTarget.TargetInfo identityInfo = modification.getModifiedState();
        this.identity = new Identity() {
            @Override
            public String getVersion() {
                return modification.getVersion();
            }

            @Override
            public String getName() {
                return name;
            }

            @Override
            public TargetInfo loadTargetInfo() throws IOException {
                return identityInfo;
            }

            @Override
            public DirectoryStructure getDirectoryStructure() {
                return modification.getDirectoryStructure();
            }
        };

        this.allPatches = Collections.unmodifiableList(modification.getAllPatches());
        this.layers.clear();
        for (final Map.Entry<String, MutableTargetImpl> entry : state.getLayers().entrySet()) {
            final String layerName = entry.getKey();
            final MutableTargetImpl target = entry.getValue();
            putLayer(layerName, new LayerInfo(layerName, target.getModifiedState(), target.getDirectoryStructure()));
        }
        this.addOns.clear();
        for (final Map.Entry<String, MutableTargetImpl> entry : state.getAddOns().entrySet()) {
            final String addOnName = entry.getKey();
            final MutableTargetImpl target = entry.getValue();
            putAddOn(addOnName, new LayerInfo(addOnName, target.getModifiedState(), target.getDirectoryStructure()));
        }
    }
434809
def add_state(self, state, storage_load=False):
        
        state_id = super(BarrierConcurrencyState, self).add_state(state)
        if not storage_load and not self.__init_running and not state.state_id == UNIQUE_DECIDER_STATE_ID:
            # the transitions must only be created for the initial add_state call and not during each load procedure
            for o_id, o in list(state.outcomes.items()):
                if not o_id == -1 and not o_id == -2:
                    self.add_transition(state.state_id, o_id, self.states[UNIQUE_DECIDER_STATE_ID].state_id, None)
        return state_id