分岐情報追加

@param start 開始位置（文字index）
@param end 終了位置（文字index）
@param state カバレッジ状態
10227
public void appendBranchState(int start, int end, BranchCoverageState state) {
		this.passed.put(new Range(start, end), state);
	}
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;
    }
1157316
@SuppressWarnings("WeakerAccess") // Public API
    public static void interpolate(State out, State start, State end, float factor) {
        interpolate(out, start, start.getX(), start.getY(), end, end.getX(), end.getY(), factor);
    }
630797
@SuppressWarnings("rawtypes")
	public Set zrevrange(Object key, long start, long end) {
		Jedis jedis = getJedis();
		try {
			Set<byte[]> data = jedis.zrevrange(keyToBytes(key), start, end);
			Set<Object> result = new LinkedHashSet<Object>();	// 有序集合必须 LinkedHashSet
			valueSetFromBytesSet(data, result);
			return result;
		}
		finally {close(jedis);}
	}
551843
StringBuilder subBuf(int start, int end) {
		if (start > end) {
			return null;
		}
		StringBuilder ret = new StringBuilder(end - start + 1);
		for (int i=start; i<=end; i++) {
			ret.append(buf[i]);
		}
		return ret;
	}
134785
def end_state(self):
        

        # Make sure we append any trailing text
        if self.str_begin != len(self.format):
            if len(self.state) > 1 or self.state[-1] != 'string':
                self.fmt.append_text(
                    "(Bad format string; ended in state %r)" % self.state[-1])
            else:
                self.fmt.append_text(self.format[self.str_begin:])

        # Convenience return
        return self.fmt
796788
public void load(final FormulaFactoryState state) {
    int index = -1;
    for (int i = validStates.size() - 1; i >= 0 && index == -1; i--)
      if (validStates.get(i) == state.id())
        index = i;
    if (index == -1)
      throw new IllegalArgumentException("The given formula factory state is not valid anymore.");
    this.validStates.shrinkTo(index + 1);

    shrinkMap(this.posLiterals, state.state()[0]);
    shrinkMap(this.negLiterals, state.state()[1]);
    shrinkSet(this.generatedVariables, state.state()[2]);
    shrinkMap(this.nots, state.state()[3]);
    shrinkMap(this.implications, state.state()[4]);
    shrinkMap(this.equivalences, state.state()[5]);
    shrinkMap(this.ands2, state.state()[6]);
    shrinkMap(this.ands3, state.state()[7]);
    shrinkMap(this.ands4, state.state()[8]);
    shrinkMap(this.andsN, state.state()[9]);
    shrinkMap(this.ors2, state.state()[10]);
    shrinkMap(this.ors3, state.state()[11]);
    shrinkMap(this.ors4, state.state()[12]);
    shrinkMap(this.orsN, state.state()[13]);
    shrinkMap(this.pbConstraints, state.state()[14]);
    this.ccCounter = state.state()[15];
    this.pbCounter = state.state()[16];
    this.cnfCounter = state.state()[17];

    clearCaches();
  }
1128915
public void transition(CopycatServer.State state) {
    checkThread();

    if (this.state != null && state == this.state.type()) {
      return;
    }

    LOGGER.info("{} - Transitioning to {}", cluster.member().address(), state);

    // Close the old state.
    try {
      this.state.close().get();
    } catch (InterruptedException | ExecutionException e) {
      throw new IllegalStateException("failed to close Raft state", e);
    }

    // Force state transitions to occur synchronously in order to prevent race conditions.
    try {
      this.state = createState(state);
      this.state.open().get();
    } catch (InterruptedException | ExecutionException e) {
      throw new IllegalStateException("failed to initialize Raft state", e);
    }

    stateChangeListeners.forEach(l -> l.accept(this.state.type()));
  }
750448
function(startState) {
        let dfa = new DFA();
        let stateMap = {};

        let epsilonNFASetCache = {}; // NFA-set -> NFA-set

        let startOrigin = {
            [startState]: 1
        };
        let start = this.epsilonClosure(startOrigin);
        epsilonNFASetCache[hashNFAStates(startOrigin)] = start;

        let dfaStates = {},
            newAdded = [];
        let last = 0,
            offset = 0; // distance between last state and current state
        dfaStates[hashNFAStates(start)] = 0; // default, the start state for DFA is 0
        stateMap[0] = start;
        newAdded.push(start);

        while (newAdded.length) {
            let newAddedTmp = [];

            for (let i = 0, n = newAdded.length; i < n; i++) {
                let stateSet = newAdded[i];
                let newMap = this._getNFASetTransitionMap(stateSet);

                let currentDFAState = i + offset;
                for (let letter in newMap) {
                    let toSet = newMap[letter];
                    let hashKey = hashNFAStates(toSet);
                    // find new state
                    let newItem = null;
                    if (epsilonNFASetCache[hashKey]) {
                        newItem = epsilonNFASetCache[hashKey];
                    } else {
                        newItem = this.epsilonClosure(newMap[letter]);
                    }
                    let newItemHashKey = hashNFAStates(newItem);
                    //
                    if (dfaStates[newItemHashKey] !== undefined) {
                        dfa.addTransition(currentDFAState, letter, dfaStates[newItemHashKey]);
                    } else {
                        // find new item
                        last++; // last + 1 as new DFA state
                        dfaStates[newItemHashKey] = last;
                        stateMap[last] = newItem;
                        newAddedTmp.push(newItem);

                        // build the connection from (index + offset) -> last
                        dfa.addTransition(currentDFAState, letter, last);
                    }
                }
            }

            offset += newAdded.length;
            newAdded = newAddedTmp;
        }

        return {
            dfa,
            stateMap
        };
    }
484282
protected void append(String v, int start, int end) {
        try {
            writer.write(v, start, end - start);
        } catch (Exception e) {
            throw MwsUtl.wrap(e);
        }
    }
284363
private void scan(final char[] input, final int start, final int end)
	{

		this.positions = new HashMap<Character, ArrayList<Integer>>();
		ArrayList<Integer> list;

		char c;
		for (int i = start; i < end; i++) {
			c = input[i];

			list = positions.get(c);
			if (list == null) {
				list = new ArrayList<Integer>();
				positions.put(c, list);
			}

			list.add(i);
		}
	}
232035
protected void append(RoaringArray sa, int startingIndex, int end) {
    extendArray(end - startingIndex);
    for (int i = startingIndex; i < end; ++i) {
      this.keys[this.size] = sa.keys[i];
      this.values[this.size] = sa.values[i];
      this.size++;
    }
  }
527560
public void restore(String state) {
        JsonObject json = JsonObject.readFrom(state);
        String accessToken = json.get("accessToken").asString();
        String refreshToken = json.get("refreshToken").asString();
        long lastRefresh = json.get("lastRefresh").asLong();
        long expires = json.get("expires").asLong();
        String userAgent = json.get("userAgent").asString();
        String tokenURL = json.get("tokenURL").asString();
        String baseURL = json.get("baseURL").asString();
        String baseUploadURL = json.get("baseUploadURL").asString();
        boolean autoRefresh = json.get("autoRefresh").asBoolean();
        int maxRequestAttempts = json.get("maxRequestAttempts").asInt();

        this.accessToken = accessToken;
        this.refreshToken = refreshToken;
        this.lastRefresh = lastRefresh;
        this.expires = expires;
        this.userAgent = userAgent;
        this.tokenURL = tokenURL;
        this.baseURL = baseURL;
        this.baseUploadURL = baseUploadURL;
        this.autoRefresh = autoRefresh;
        this.maxRequestAttempts = maxRequestAttempts;
    }
76858
public void appendHitRange(int start, int end) {
		hits.add(new Range(start, end));
		ranges = null;//キャッシュをクリア
	}
1327702
protected void setState(State state) {
        if (DEBUG)
            LOG.debug("{} --> {}", _state, state);
        _state = state;
    }
537445
private void endExpression(int position) throws MalformedUriTemplateException
    {

        // an expression close brace is found without a start
        if (startedTemplate)
        {
            if (!expressionCaptureOn)

            {
                throw new MalformedUriTemplateException("Expression close brace was found at position " + position
                + " yet there was no start brace.", position);
            }
            expressionCaptureOn = false;
            components.add(new Expression(buffer.toString(), this.startPosition));
            buffer = null;
        }
        else
        {
            throw new IllegalStateException("Cannot end an expression without beginning the template");
        }
    }
1142781
State endBinaryShift(int index) {
    if (binaryShiftByteCount == 0) {
      return this;
    }
    Token token = this.token;
    token = token.addBinaryShift(index - binaryShiftByteCount, binaryShiftByteCount);
    //assert token.getTotalBitCount() == this.bitCount;
    return new State(token, mode, 0, this.bitCount);
  }