Java 类org.apache.commons.lang3.tuple.MutablePair 实例源码

private void getValidEdgePosition() {
    // loops through valid road end points and adds valid edges (both ships and roads)
    for (CoordinatePair i : aSessionController.requestValidRoadEndpoints(aSessionController.getPlayerColor())) {
        for (CoordinatePair j : aSessionController.getIntersectionsAndEdges()) {
            if (aSessionController.isAdjacent(i, j)) {

                Pair<CoordinatePair, CoordinatePair> edge = new MutablePair<>(i, j);
                validEdges.add(edge);

                for (EdgeUnit eu : aSessionController.getRoadsAndShips()) {
                    if (eu.hasEndpoint(i) && eu.hasEndpoint(j)) {
                        validEdges.remove(edge);
                    }
                }
            }
        }
    }
}

void updateValidEdges(List<Pair<CoordinatePair,CoordinatePair>> validEdges) {
 // loops through valid road end points and adds valid edges (both ships and roads)
    for (CoordinatePair i : aSessionController.requestValidRoadEndpoints(aSessionController.getPlayerColor())) {
        for (CoordinatePair j : aSessionController.getIntersectionsAndEdges()) { 
            if (aSessionController.isAdjacent(i, j)) {

                Pair<CoordinatePair, CoordinatePair> edge = new MutablePair<>(i, j);
                validEdges.add(edge);

                for (EdgeUnit eu : aSessionController.getRoadsAndShips()) {
                    if (eu.hasEndpoint(i) && eu.hasEndpoint(j)) {
                        validEdges.remove(edge);
                    }
                }
            }
        } 
    }
}

public static int createChannel(@Nonnull String name, @Nullable Map<ChannelProperty, String> channelProperties, @Nullable Map<ChannelPermission, Integer> permissions)
{
    MutablePair<ResultType, Object> pair = MutablePair.of(ResultType.INTEGER, -1);
    int id = generator++;
    TeamSpeakAPI.results.put(id, pair);
    final String[] msg = {"createchannel:" + name};
    if (channelProperties != null)
        channelProperties.forEach(((channelProperty, s) -> msg[0] += ":" + channelProperties.toString().toUpperCase() + "=" + s));
    if (permissions != null)
        permissions.forEach(((channelPermission, integer) -> msg[0] += ":" + channelPermission.toString().toLowerCase() + "-" + integer));
    TeamSpeakAPI.publish(id, msg[0]);
    try
    {
        synchronized (pair)
        {
            pair.wait(TeamSpeakAPI.TIMEOUT);
        }
    } catch (Exception ignored) {}
    return (int)pair.getRight();
}

public static List<UUID> movePlayers(@Nonnull List<UUID> uuids, int channelId)
{
    MutablePair<ResultType, Object> pair = MutablePair.of(ResultType.UUID_LIST, new ArrayList<>());
    int id = generator++;
    TeamSpeakAPI.results.put(id, pair);
    final String[] msg = {"move:" + channelId};
    uuids.forEach(uuid -> msg[0] += ":" + uuid);
    TeamSpeakAPI.publish(id, msg[0]);
    try
    {
        synchronized (pair)
        {
            pair.wait(TeamSpeakAPI.TIMEOUT);
        }
    } catch (Exception ignored) {}
    return (List<UUID>) pair.getRight();
}

public static MutablePair<Long, Long> getProcNetDevStats() throws Exception {
  ProcessBuilder ps = new ProcessBuilder("cat", "/proc/net/dev");
  Process pr = ps.start();
  pr.waitFor();

  BufferedReader in = new BufferedReader(new InputStreamReader(pr.getInputStream()));
  String line;
  int counter = 0;
  long receivedBytes = 0;
  long outBytes = 0;

  while ((line = in.readLine()) != null) {
    System.out.println(counter + ": " + line);
    if (line.contains("eth0")) {
      String[] strs = line.split(" ");
      receivedBytes = Long.parseLong(strs[3]);
      outBytes = Long.parseLong(strs[41]);
      System.out.println(" inBytes = " + receivedBytes + "  outBytes = " + outBytes);
    }
    counter++;
  }
  in.close();

  MutablePair<Long, Long> result = new MutablePair<>(receivedBytes, outBytes);
  return result;
}

public Map<String, MutablePair<String, CommentsNodeImpl>> copyMap(CommentsNodeImpl parent)
{
    Map<String, MutablePair<String, CommentsNodeImpl>> result = new HashMap<>(this.dataMap.size());
    for (Entry<String, MutablePair<String, CommentsNodeImpl>> entry : this.dataMap.entrySet())
    {
        String keyToCpy = entry.getKey();
        MutablePair<String, CommentsNodeImpl> valueToCpy = entry.getValue();
        CommentsNodeImpl nodeToCpy = valueToCpy.getRight();
        CommentsNodeImpl copiedNode;
        if (nodeToCpy == null)
        {
            copiedNode = null;
        }
        else
        {
            copiedNode = new CommentsNodeImpl(parent);
            copiedNode.dataMap.putAll(nodeToCpy.copyMap(parent));
        }
        MutablePair<String, CommentsNodeImpl> copied = new MutablePair<>(valueToCpy.getLeft(), copiedNode);
        result.put(keyToCpy, copied);
    }
    return result;
}

@Override
public void trim()
{
    for (Iterator<Entry<String, MutablePair<String, CommentsNodeImpl>>> iterator = this.dataMap.entrySet().iterator(); iterator.hasNext(); )
    {
        Entry<String, MutablePair<String, CommentsNodeImpl>> entry = iterator.next();
        MutablePair<String, CommentsNodeImpl> value = entry.getValue();
        CommentsNodeImpl right = value.getRight();
        if (right != null)
        {
            right.trim();
        }
        if (((right == null) || right.dataMap.isEmpty()) && (value.getLeft() == null))
        {
            iterator.remove();
            continue;
        }
        if (right == null)
        {
            continue;
        }
        right.trim();
    }
}

@Override
@Nullable
public String getComment(String path)
{
    MutablePair<String, CommentsNodeImpl> nodePair = this.dataMap.get(path);
    if (nodePair != null)
    {
        String comment = nodePair.getLeft();
        if (comment != null)
        {
            return comment;
        }
    }
    MutablePair<String, CommentsNodeImpl> anyNodePair = this.dataMap.get(ANY);
    if (anyNodePair != null)
    {
        return anyNodePair.getKey();
    }
    return null;
}

@Override
public CommentsNodeImpl getNode(String path)
{
    MutablePair<String, CommentsNodeImpl> nodePair = this.dataMap.get(path);
    CommentsNodeImpl node = (nodePair == null) ? null : nodePair.getRight();
    if (node == null)
    {
        MutablePair<String, CommentsNodeImpl> anyNodePair = this.dataMap.get(ANY);
        node = (anyNodePair == null) ? null : anyNodePair.getRight();
        if (node == null)
        {
            CommentsNodeImpl commentsNode = new CommentsNodeImpl(this);
            if (nodePair != null)
            {
                nodePair.setRight(commentsNode);
            }
            else
            {
                this.dataMap.put(path, new MutablePair<>(null, commentsNode));
            }
            return commentsNode;
        }
        return node;
    }
    return node;
}

private Pair<String, String> prefixSplitter(String input) {
    MutablePair<String, String> result = new MutablePair<>("", input);
    if (input.startsWith("Device")) {
        result.setLeft("Device");
        result.setRight(input.replaceFirst("Device", ""));
    } else if (input.startsWith("OperatingSystem")) {
        result.setLeft("Operating System");
        result.setRight(input.replaceFirst("OperatingSystem", ""));
    } else if (input.startsWith("LayoutEngine")) {
        result.setLeft("Layout Engine");
        result.setRight(input.replaceFirst("LayoutEngine", ""));
    } else if (input.startsWith("Agent")) {
        result.setLeft("Agent");
        result.setRight(input.replaceFirst("Agent", ""));
    }
    return result;
}

/**
 * Issue requests to AM RM Client again if previous container requests expired and were not allocated by Yarn
 * @param amRmClient
 * @param requestedResources
 * @param loopCounter
 * @param resourceRequestor
 * @param containerRequests
 * @param removedContainerRequests
 */
public void reissueContainerRequests(AMRMClient<ContainerRequest> amRmClient, Map<StreamingContainerAgent.ContainerStartRequest, MutablePair<Integer, ContainerRequest>> requestedResources, int loopCounter, ResourceRequestHandler resourceRequestor, List<ContainerRequest> containerRequests, List<ContainerRequest> removedContainerRequests)
{
  if (!requestedResources.isEmpty()) {
    for (Map.Entry<StreamingContainerAgent.ContainerStartRequest, MutablePair<Integer, ContainerRequest>> entry : requestedResources.entrySet()) {
      /*
       * Create container requests again if pending requests were not allocated by Yarn till timeout.
       */
      if ((loopCounter - entry.getValue().getKey()) > NUMBER_MISSED_HEARTBEATS) {
        StreamingContainerAgent.ContainerStartRequest csr = entry.getKey();
        LOG.debug("Request for container {} timed out. Re-requesting container", csr.container);
        removedContainerRequests.add(entry.getValue().getRight());
        ContainerRequest cr = resourceRequestor.createContainerRequest(csr, false);
        entry.getValue().setLeft(loopCounter);
        entry.getValue().setRight(cr);
        containerRequests.add(cr);
      }
    }
  }
}

/**
 * Implement InputOperator Interface.
 */
@Override
public void emitTuples()
{
  if (currentWindowId <= windowDataManager.getLargestCompletedWindow()) {
    return;
  }
  int count = consumer.getQueueSize();
  if (maxTuplesPerWindow > 0) {
    count = Math.min(count, maxTuplesPerWindow - emitCount);
  }
  for (int i = 0; i < count; i++) {
    Pair<String, Record> data = consumer.pollRecord();
    String shardId = data.getFirst();
    String recordId = data.getSecond().getSequenceNumber();
    emitTuple(data);
    MutablePair<String, Integer> shardOffsetAndCount = currentWindowRecoveryState.get(shardId);
    if (shardOffsetAndCount == null) {
      currentWindowRecoveryState.put(shardId, new MutablePair<String, Integer>(recordId, 1));
    } else {
      shardOffsetAndCount.setRight(shardOffsetAndCount.right + 1);
    }
    shardPosition.put(shardId, recordId);
  }
  emitCount += count;
}

private void processTopN(HashMap<String, Number> topNMap, HashMap<String, Object> schemaObj)
{
  @SuppressWarnings("unchecked")
  HashMap<String, Object>[] result = (HashMap<String, Object>[])Array.newInstance(HashMap.class, topNMap.size());

  int j = 0;
  for (Entry<String, Number> e : topNMap.entrySet()) {
    result[j] = new HashMap<String, Object>();
    result[j].put("name", e.getKey());
    String val = formatter.format(e.getValue());
    result[j++].put("value", val);
  }
  if (operator.isWebSocketConnected) {
    schemaObj.put("type", "topN");
    schemaObj.put("n", operator.nInTopN);
    operator.wsoo.input.process(new MutablePair<String, Object>(operator.getFullTopic(operator.topNTopic, schemaObj), result));
  }
  else {
    operator.coo.input.process(topNMap);
  }

}

@Override
public void process(TimeSeriesData[] tuple)
{
  @SuppressWarnings({"unchecked", "rawtypes"})
  HashMap<String, Number>[] timeseriesMapData = new HashMap[tuple.length];
  int i = 0;
  for (TimeSeriesData data : tuple) {
    HashMap<String, Number> timeseriesMap = Maps.newHashMapWithExpectedSize(2);
    timeseriesMap.put("timestamp", data.time);
    timeseriesMap.put("value", data.data);
    timeseriesMapData[i++] = timeseriesMap;
  }

  if (operator.isWebSocketConnected) {
    HashMap<String, Object> schemaObj = new HashMap<>();
    schemaObj.put("type", "timeseries");
    schemaObj.put("minValue", operator.timeSeriesMin);
    schemaObj.put("maxValue", operator.timeSeriesMax);
    operator.wsoo.input.process(new MutablePair<String, Object>(operator.getFullTopic( operator.timeSeriesTopic, schemaObj), timeseriesMapData));
  } else {
    operator.coo.input.process(tuple);
  }
}

@Override
public void process(HashMap<String, Number> topNMap)
{
  @SuppressWarnings({"unchecked", "rawtypes"})
  HashMap<String, Object>[] result = new HashMap[topNMap.size()];
  int j = 0;
  for (Entry<String, Number> e : topNMap.entrySet()) {
    result[j] = new HashMap<>();
    result[j].put("name", e.getKey());
    result[j++].put("value", e.getValue());
  }
  if (operator.isWebSocketConnected) {
    HashMap<String, Object> schemaObj = new HashMap<>();
    schemaObj.put("type", "topN");
    schemaObj.put("n", operator.nInTopN);
    operator.wsoo.input.process(new MutablePair<String, Object>(operator.getFullTopic(operator.topNTopic, schemaObj), result));
  } else {
    operator.coo.input.process(topNMap);
  }
}

@Override
public void process(HashMap<String, Number> pieNumbers)
{
  @SuppressWarnings("unchecked")
  HashMap<String, Object>[] result = (HashMap<String, Object>[])Array.newInstance(HashMap.class, pieNumbers.size());

  int j = 0;
  for (Entry<String, Number> e : pieNumbers.entrySet()) {
    result[j] = new HashMap<>();
    result[j].put("label", e.getKey());
    result[j++].put("value", e.getValue());
  }
  if (operator.isWebSocketConnected) {
    HashMap<String, Object> schemaObj = new HashMap<>();
    schemaObj.put("type", "piechart");
    schemaObj.put("n", operator.nInPie);
    operator.wsoo.input.process(new MutablePair<String, Object>(operator.getFullTopic(operator.pieChartTopic, schemaObj), result));
  } else {
    operator.coo.input.process(pieNumbers);
  }
}

@Override
public void populateDAG(DAG dag, Configuration configuration)
{
  RandomNumberPairGenerator inputOperator = new RandomNumberPairGenerator();
  WindowedOperatorImpl<MutablePair<Double, Double>, MutablePair<MutableLong, MutableLong>, Double> windowedOperator = new WindowedOperatorImpl<>();
  Accumulation<MutablePair<Double, Double>, MutablePair<MutableLong, MutableLong>, Double> piAccumulation = new PiAccumulation();

  windowedOperator.setAccumulation(piAccumulation);
  windowedOperator.setDataStorage(new InMemoryWindowedStorage<MutablePair<MutableLong, MutableLong>>());
  windowedOperator.setWindowStateStorage(new InMemoryWindowedStorage<WindowState>());
  windowedOperator.setWindowOption(new WindowOption.GlobalWindow());
  windowedOperator.setTriggerOption(TriggerOption.AtWatermark().withEarlyFiringsAtEvery(Duration.millis(1000)).accumulatingFiredPanes());

  ConsoleOutputOperator outputOperator = new ConsoleOutputOperator();
  dag.addOperator("inputOperator", inputOperator);
  dag.addOperator("windowedOperator", windowedOperator);
  dag.addOperator("outputOperator", outputOperator);
  dag.addStream("input_windowed", inputOperator.output, windowedOperator.input);
  dag.addStream("windowed_output", windowedOperator.output, outputOperator.input);
}

public Map<String, MutablePair<String, CommentsNodeImpl>> copyMap(CommentsNodeImpl parent)
{
    Map<String, MutablePair<String, CommentsNodeImpl>> result = new HashMap<>(this.dataMap.size());
    for (Entry<String, MutablePair<String, CommentsNodeImpl>> entry : this.dataMap.entrySet())
    {
        String keyToCpy = entry.getKey();
        MutablePair<String, CommentsNodeImpl> valueToCpy = entry.getValue();
        CommentsNodeImpl nodeToCpy = valueToCpy.getRight();
        CommentsNodeImpl copiedNode;
        if (nodeToCpy == null)
        {
            copiedNode = null;
        }
        else
        {
            copiedNode = new CommentsNodeImpl(parent);
            copiedNode.dataMap.putAll(nodeToCpy.copyMap(parent));
        }
        MutablePair<String, CommentsNodeImpl> copied = new MutablePair<>(valueToCpy.getLeft(), copiedNode);
        result.put(keyToCpy, copied);
    }
    return result;
}

@Override
public void trim()
{
    for (Iterator<Entry<String, MutablePair<String, CommentsNodeImpl>>> iterator = this.dataMap.entrySet().iterator(); iterator.hasNext(); )
    {
        Entry<String, MutablePair<String, CommentsNodeImpl>> entry = iterator.next();
        MutablePair<String, CommentsNodeImpl> value = entry.getValue();
        CommentsNodeImpl right = value.getRight();
        if (right != null)
        {
            right.trim();
        }
        if (((right == null) || right.dataMap.isEmpty()) && (value.getLeft() == null))
        {
            iterator.remove();
            continue;
        }
        if (right == null)
        {
            continue;
        }
        right.trim();
    }
}

@Override
@Nullable
public String getComment(String path)
{
    MutablePair<String, CommentsNodeImpl> nodePair = this.dataMap.get(path);
    if (nodePair != null)
    {
        String comment = nodePair.getLeft();
        if (comment != null)
        {
            return comment;
        }
    }
    MutablePair<String, CommentsNodeImpl> anyNodePair = this.dataMap.get(ANY);
    if (anyNodePair != null)
    {
        return anyNodePair.getKey();
    }
    return null;
}

@Override
public CommentsNodeImpl getNode(String path)
{
    MutablePair<String, CommentsNodeImpl> nodePair = this.dataMap.get(path);
    CommentsNodeImpl node = (nodePair == null) ? null : nodePair.getRight();
    if (node == null)
    {
        MutablePair<String, CommentsNodeImpl> anyNodePair = this.dataMap.get(ANY);
        node = (anyNodePair == null) ? null : anyNodePair.getRight();
        if (node == null)
        {
            CommentsNodeImpl commentsNode = new CommentsNodeImpl(this);
            if (nodePair != null)
            {
                nodePair.setRight(commentsNode);
            }
            else
            {
                this.dataMap.put(path, new MutablePair<>(null, commentsNode));
            }
            return commentsNode;
        }
        return node;
    }
    return node;
}

/**
 * Invoked when a mapping of a map of one of the settings is removed.<br>
 * This is used to adjust the merged map accordingly
 * 
 * @param sc the setting of which the entry was removed
 * @param key the key of the mapping to be removed
 */
private synchronized void onRemove(SettingsContainer sc, Object key) {
    MutablePair<V, Integer> pair = this.mergedMap.get(key);

    if (pair != null && pair.getRight() == sc.listIndex) {
        Pair<V, Integer> newVal = getIndexAndValueForKey(key);

        if (newVal != null) {
            pair.setLeft(newVal.getLeft());
            pair.setRight(newVal.getRight());
        }
        else this.mergedMap.remove(key);
    }

    removeMapIfEmpty(sc.listIndex);
}

/**
 * Return the longest suffix of bases shared among all provided vertices
 *
 * For example, if the vertices have sequences AC, CC, and ATC, this would return
 * a single C.  However, for ACC and TCC this would return CC.  And for AC and TG this
 * would return null;
 *
 * @param middleVertices a non-empty set of vertices
 * @return
 */
@VisibleForTesting
static Pair<SeqVertex, SeqVertex> commonPrefixAndSuffixOfVertices(final Collection<SeqVertex> middleVertices) {
    final List<byte[]> kmers = new ArrayList<>(middleVertices.size());

    int min = Integer.MAX_VALUE;
    for ( final SeqVertex v : middleVertices ) {
        kmers.add(v.getSequence());
        min = Math.min(min, v.getSequence().length);
    }

    final int prefixLen = GraphUtils.commonMaximumPrefixLength(kmers);
    final int suffixLen = GraphUtils.commonMaximumSuffixLength(kmers, min - prefixLen);

    final byte[] kmer = kmers.get(0);
    final byte[] prefix = Arrays.copyOfRange(kmer, 0, prefixLen);
    final byte[] suffix = Arrays.copyOfRange(kmer, kmer.length - suffixLen, kmer.length);
    return new MutablePair<>(new SeqVertex(prefix), new SeqVertex(suffix));
}

public static Pair<int[],byte[]> getNumTandemRepeatUnits(final byte[] refBases, final byte[] altBases, final byte[] remainingRefContext) {
     /* we can't exactly apply same logic as in basesAreRepeated() to compute tandem unit and number of repeated units.
       Consider case where ref =ATATAT and we have an insertion of ATAT. Natural description is (AT)3 -> (AT)2.
     */

    byte[] longB;
    // find first repeat unit based on either ref or alt, whichever is longer
    if (altBases.length > refBases.length)
        longB = altBases;
    else
        longB = refBases;

    // see if non-null allele (either ref or alt, whichever is longer) can be decomposed into several identical tandem units
    // for example, -*,CACA needs to first be decomposed into (CA)2
    final int repeatUnitLength = findRepeatedSubstring(longB);
    final byte[] repeatUnit = Arrays.copyOf(longB, repeatUnitLength);

    final int[] repetitionCount = new int[2];
    // look for repetitions forward on the ref bases (i.e. starting at beginning of ref bases)
    int repetitionsInRef = findNumberOfRepetitions(repeatUnit, refBases, true);
    repetitionCount[0] = findNumberOfRepetitions(repeatUnit, ArrayUtils.addAll(refBases, remainingRefContext), true)-repetitionsInRef;
    repetitionCount[1] = findNumberOfRepetitions(repeatUnit, ArrayUtils.addAll(altBases, remainingRefContext), true)-repetitionsInRef;

    return new MutablePair<>(repetitionCount, repeatUnit);

}

/**
 * Return the longest suffix of bases shared among all provided vertices
 *
 * For example, if the vertices have sequences AC, CC, and ATC, this would return
 * a single C.  However, for ACC and TCC this would return CC.  And for AC and TG this
 * would return null;
 *
 * @param middleVertices a non-empty set of vertices
 * @return
 */
@VisibleForTesting
static Pair<SeqVertex, SeqVertex> commonPrefixAndSuffixOfVertices(final Collection<SeqVertex> middleVertices) {
    final List<byte[]> kmers = new ArrayList<>(middleVertices.size());

    int min = Integer.MAX_VALUE;
    for ( final SeqVertex v : middleVertices ) {
        kmers.add(v.getSequence());
        min = Math.min(min, v.getSequence().length);
    }

    final int prefixLen = GraphUtils.commonMaximumPrefixLength(kmers);
    final int suffixLen = GraphUtils.commonMaximumSuffixLength(kmers, min - prefixLen);

    final byte[] kmer = kmers.get(0);
    final byte[] prefix = Arrays.copyOfRange(kmer, 0, prefixLen);
    final byte[] suffix = Arrays.copyOfRange(kmer, kmer.length - suffixLen, kmer.length);
    return new MutablePair<>(new SeqVertex(prefix), new SeqVertex(suffix));
}

@Test
public void testCacheValueSuccess() {
    String myPath = "aaa";
    ExecutableModellingResult executableModellingResult = mock(ExecutableModellingResult.class);
    SlangSource slangSource = mock(SlangSource.class);

    final MutablePair<CacheValue, Boolean> pair = new MutablePair<>();
    doAnswer(new Answer() {
        @Override
        public Object answer(InvocationOnMock invocation) throws Throwable {
            pair.setLeft((CacheValue) invocation.getArguments()[1]);
            return null;
        }
    }).when(cache).put(anyString(), any(CacheValue.class));

    // Tested call
    cachedPrecompileServiceImpl.cacheValue(myPath, executableModellingResult, slangSource);
    verify(cache).put(eq(myPath), same(pair.getLeft()));
}

@Test
public void testCacheValueDoesNothingForNull() {
    String myPath = null;
    ExecutableModellingResult executableModellingResult = mock(ExecutableModellingResult.class);
    SlangSource slangSource = mock(SlangSource.class);

    final MutablePair<CacheValue, Boolean> pair = new MutablePair<>();
    doAnswer(new Answer() {
        @Override
        public Object answer(InvocationOnMock invocation) throws Throwable {
            pair.setLeft((CacheValue) invocation.getArguments()[1]);
            return null;
        }
    }).when(cache).put(anyString(), any(CacheValue.class));

    // Tested call
    cachedPrecompileServiceImpl.cacheValue(myPath, executableModellingResult, slangSource);
    verify(cache, never()).put(anyString(), any(CacheValue.class));
}

public static Pair<SphinxHeader, byte[]> packageSurb(SphinxParams params,
                                                     SphinxSingleUseReplyBlock nymTuple,
                                                     byte[] message) throws SphinxException, CryptoException {
    byte[] body = params.pi(
            nymTuple.ktilde,
            padBody(
                    params.m,
                    Arrays.concatenate(
                            new byte[params.k],
                            message
                    )
            )
    );
    return new MutablePair<>(nymTuple.header, body);
}

public static Pair<SphinxParams, Pair<SphinxHeader, byte[]>> unpackMessage(List<SphinxParams> params, byte[] m) throws IOException {
    Unpacker unpacker = Unpacker.getUnpacker(m);
    unpacker.unpackArrayHeader();
    unpacker.unpackArrayHeader();
    int paramsMaxLength = unpacker.unpackInt();
    int paramsM = unpacker.unpackInt();
    unpacker.unpackArrayHeader();
    unpacker.unpackArrayHeader();
    ECPoint alpha = unpacker.unpackEcPoint();
    byte[] beta = unpacker.readPayload(unpacker.unpackBinaryHeader());
    byte[] gamma = unpacker.readPayload(unpacker.unpackBinaryHeader());

    SphinxHeader header = new SphinxHeader(alpha, beta, gamma);

    byte[] message = unpacker.readPayload(unpacker.unpackBinaryHeader());

    SphinxParams msgParams = null;
    for (SphinxParams param : params) {
        if (paramsMaxLength == param.maxLength &&
                paramsM == param.m) {
            msgParams = param;
            break;
        }
    }
    if (msgParams == null) {
        throw new RuntimeException("No parameter settings.");
    }
    return new MutablePair<>(msgParams, new MutablePair<>(header, message));
}

public CreateScreen(CatanGame pGame, Screen parentScreen) {
    this.parentScreen = parentScreen;
    game = pGame;
    boardHexes = new ArrayList<>();
    boardOrigin = new MutablePair<>();
    setupBoardOrigin(Gdx.graphics.getWidth(), Gdx.graphics.getHeight());

}

/**
 * Put flows to local storage with cached state.
 * @param flows that will be added
 */
public void addPredefinedFlow(ImmutablePair<Flow, Flow> flows) {
    if (Objects.nonNull(flows.getLeft())) {
        predefinedFlows.add(new MutablePair<>(flows.getLeft(), CachedFlowState.CACHED));
    }
    if (Objects.nonNull(flows.getRight())) {
        predefinedFlows.add(new MutablePair<>(flows.getRight(), CachedFlowState.CACHED));
    }
}

public static boolean deleteChannel(int channelId)
{
    MutablePair<ResultType, Object> pair = MutablePair.of(ResultType.BOOLEAN, false);
    int id = generator++;
    TeamSpeakAPI.results.put(id, pair);
    TeamSpeakAPI.publish(id, "deletechannel:" + channelId);
    try
    {
       synchronized (pair)
       {
           pair.wait(TeamSpeakAPI.TIMEOUT);
       }
    } catch (Exception ignored) {}
    return (boolean)pair.getRight();
}

public static boolean isLinked(@Nonnull UUID uuid)
{
    MutablePair<ResultType, Object> pair = MutablePair.of(ResultType.BOOLEAN, false);
    int id = generator++;
    TeamSpeakAPI.results.put(id, pair);
    TeamSpeakAPI.publish(id, "linked:" + uuid);
    try
    {
        synchronized (pair)
        {
            pair.wait(TeamSpeakAPI.TIMEOUT);
        }
    } catch (Exception ignored) {}
    return (boolean)pair.getRight();
}

@Override
public void receive(String channel, String packet)
{
    String[] args = packet.split(":");
    String[] prefix = args[0].split("/");
    if (!prefix[0].equals(SamaGamesAPI.get().getServerName()))
        return ;
    int id = Integer.parseInt(prefix[1]);
    MutablePair<ResultType, Object> result = TeamSpeakAPI.results.get(id);
    TeamSpeakAPI.results.remove(id);
    boolean ok = args.length > 1 && !args[1].equals("ERROR");
    if (!ok)
        SamaGamesAPI.get().getPlugin().getLogger().severe("[TeamSpeakAPI] Error : " + (args.length > 2 ? args[2] : "Unknown") + "(packet = " + packet + ")");
    else
        switch (result.getLeft())
        {
            case UUID_LIST:
                List<UUID> uuid = (List<UUID>) result.getRight();
                for (int i = 1; i < args.length; i++)
                    uuid.add(UUID.fromString(args[i]));
                break;
            case INTEGER:
                result.setRight(Integer.parseInt(args[1]));
                break;
            case BOOLEAN:
                result.setRight(args[1].equalsIgnoreCase("OK") || args[1].equalsIgnoreCase("true"));
                break ;
            default:
                break ;
        }
    synchronized (result)
    {
        result.notifyAll();
    }
}

/**
 * 开始滚动数据
 *
 * @param queryBuilder 查询句柄
 * @return 滚动id和当前的一批数据
 */
public Pair<String, List<Webpage>> startScroll(QueryBuilder queryBuilder, int size) {
    SearchRequestBuilder searchRequestBuilder = client.prepareSearch(INDEX_NAME)
            .setTypes(TYPE_NAME)
            .setQuery(queryBuilder)
            .setSize(size)
            .setScroll(TimeValue.timeValueMinutes(SCROLL_TIMEOUT));
    SearchResponse response = searchRequestBuilder.execute().actionGet();
    return new MutablePair<>(response.getScrollId(), warpHits2List(response.getHits()));
}

public static int getBurnTime(ItemStack stack) {
    for(MutablePair<ItemStack, Integer> pair : basicCoalGenerator) {
        if(pair.left.isItemEqual(stack)) {
            return pair.right;
        }
    }
    return 0;
}

public static boolean containsItemStack(ItemStack stack) {
    for(MutablePair<ItemStack, Integer> pair : basicCoalGenerator) {
        if(stack != null && pair.left.isItemEqual(stack)) {
            return true;
        }
    }
    return false;
}

public static void removeBasicCoalGeneratorItem(ItemStack stack) {
    MutablePair<ItemStack, Integer> toRemove = null;
    for(MutablePair<ItemStack, Integer> pair : basicCoalGenerator) {
        if(pair.left.isItemEqual(stack)) {
            toRemove = pair;
        }
    }
    basicCoalGenerator.remove(toRemove);
}

public static List<ItemStack> getItemStacks() {
    List<ItemStack> list = new ArrayList<ItemStack>();
    for(MutablePair<ItemStack, Integer> pair : basicCoalGenerator) {
        list.add(pair.left);
    }
    return list;
}

@Override
public Pair<Boolean, String> canJoinGame(UUID player, boolean reconnect)
{
    if (this.getPlayers().size() >= SamaGamesAPI.get().getGameManager().getGameProperties().getMaxSlots())
        return new MutablePair<>(false, "Serveur plein");
    return new MutablePair<>(true, null);
}