Java Code Examples for com.google.common.collect.ArrayListMultimap#put()

private static ArrayListMultimap<String, PsInfo> parsePsInfo(final String psInfo) {
    ArrayListMultimap<String, PsInfo> multimap = ArrayListMultimap.create();
    String all = psInfo.replaceAll("[( )\t]+", " ");
    String[] lines = all.split("[\n\r(\r\n)]");
    for (String line : lines) {
        if (Strings.isNullOrEmpty(line)) {
            continue;
        }
        String[] pieces = line.split(" ");
        final String user = pieces[USER_INDEX];
        final int pid = Integer.parseInt(pieces[PID_INDEX]);
        final String command = pieces[COMMAND_INDEX];
        final String[] params = Arrays.copyOfRange(pieces, COMMAND_INDEX + 1, pieces.length);
        PsInfo process = new PsInfo(user, pid, command, params);
        multimap.put(command, process);
    }
    return multimap;
}
 

private <C,I> void register(Class<? extends I> clazz, ArrayListMultimap<String,Class<? extends I>> methods) {
  Description desc = clazz.getAnnotation(Description.class);
  String[] names;
  if (desc != null) {
    names = desc.name().split(",");
    for (int i=0; i<names.length; i++) {
      names[i] = names[i].trim();
    }
  }else{
    names = new String[]{clazz.getName().replace('.', '_')};
  }

  UDFType type = clazz.getAnnotation(UDFType.class);
  if (type != null && !type.deterministic()) {
    nonDeterministicUDFs.add(clazz);
  }


  for(int i=0; i<names.length;i++) {
    methods.put(names[i].toLowerCase(), clazz);
  }
}
 

public RoundRobinOperator(TunnelProvider tunnelProvider, OperatorContext context, RoundRobinSender config) throws OutOfMemoryException {
  super(config);
  this.config = config;
  this.allocator = context.getAllocator();
  this.handle = context.getFragmentHandle();
  this.stats = context.getStats();

  List<MinorFragmentEndpoint> destinations = config.getDestinations(context.getEndpointsIndex());
  final ArrayListMultimap<NodeEndpoint, Integer> dests = ArrayListMultimap.create();
  for(MinorFragmentEndpoint destination : destinations) {
    dests.put(destination.getEndpoint(), destination.getMinorFragmentId());
  }

  this.tunnels = new ArrayList<>();
  this.minorFragments = new ArrayList<>();
  for(final NodeEndpoint ep : dests.keySet()){
    List<Integer> minorsList= dests.get(ep);
    minorFragments.add(minorsList);
    tunnels.add(tunnelProvider.getExecTunnel(ep));
  }

  int destCount = dests.keySet().size();
  this.currentTunnelsIndex = ThreadLocalRandom.current().nextInt(destCount);
  this.currentMinorFragmentsIndex = ThreadLocalRandom.current().nextInt(minorFragments.get(currentTunnelsIndex).size());
}
 

private static ArrayListMultimap<SubTag, GT_Recipe> getRecipesToChange(SubTag... GasTags) {
    ArrayListMultimap<SubTag, GT_Recipe> toAdd = ArrayListMultimap.create();
    for (GT_Recipe recipe : GT_Recipe.GT_Recipe_Map.sBlastRecipes.mRecipeList) {
        if (recipe.mFluidInputs != null && recipe.mFluidInputs.length > 0) {
            String FluidString = recipe.mFluidInputs[0].getFluid().getName().replaceAll("molten", "").replaceAll("fluid", "");
            Materials mat = Materials.get(FluidString.substring(0, 1).toUpperCase() + FluidString.substring(1));
            if (mat != Materials._NULL) {
                for (SubTag tag : GasTags) {
                    if (mat.contains(tag)) {
                        DebugLog.log("Found EBF Recipe to change, Output:" + BW_Util.translateGTItemStack(recipe.mOutputs[0]));
                        toAdd.put(tag, recipe);
                    }
                }
            }
        }
    }
    return toAdd;
}
 

private ArrayListMultimap<String, AggregateFunction<?, ?>> getAggregateFunctionMultimap() {
  ArrayListMultimap<String, AggregateFunction<?, ?>> reductionMultimap =
      ArrayListMultimap.create();
  for (String name : summarizedColumns) {
    Column<?> column = temp.column(name);
    ColumnType type = column.type();
    for (AggregateFunction<?, ?> reduction : reductions) {
      if (reduction.isCompatibleColumn(type)) {
        reductionMultimap.put(name, reduction);
      }
    }
  }
  if (reductionMultimap.isEmpty()) {
    throw new IllegalArgumentException(
        "None of the aggregate functions provided apply to the summarized column type(s).");
  }
  return reductionMultimap;
}
 

@Override
public Multimap<String,String> deserialize(JsonElement json, Type typeOfT, JsonDeserializationContext context) throws JsonParseException {
    ArrayListMultimap<String,String> mm = ArrayListMultimap.create();
    for (Entry<String,JsonElement> e : json.getAsJsonObject().entrySet()) {
        JsonArray values = e.getValue().getAsJsonArray();
        if (values.size() == 0) {
            mm.putAll(e.getKey(), Collections.emptyList());
        } else {
            for (JsonElement value : values)
                mm.put(e.getKey(), value.getAsString());
        }
    }
    return mm;
}
 

@Test
public void fire_event() {
    ArrayListMultimap<Class<? extends DomainEvent>, Class<? extends DomainEventHandler>> multiMap =
            ArrayListMultimap.create();
    multiMap.put(SomeDomainEvent.class, MyDomainEventHandler.class);

    underTest = new DomainEventPublisherImpl(injector, multiMap);
    underTest.publish(new MyDomainEvent());
}
 

public BroadcastOperator(TunnelProvider tunnelProvider, OperatorContext context, BroadcastSender config) throws OutOfMemoryException {
  super(config);
  this.config = config;
  this.context = context;
  this.handle = context.getFragmentHandle();
  this.stats = context.getStats();

  final List<MinorFragmentEndpoint> destinations = config.getDestinations(context.getEndpointsIndex());
  final ArrayListMultimap<NodeEndpoint, Integer> dests = ArrayListMultimap.create();

  for(MinorFragmentEndpoint destination : destinations) {
    dests.put(destination.getEndpoint(), destination.getMinorFragmentId());
  }

  int destCount = dests.keySet().size();
  int i = 0;

  this.tunnels = new AccountingExecTunnel[destCount];
  this.receivingMinorFragments = new int[destCount][];
  for(final NodeEndpoint ep : dests.keySet()){
    List<Integer> minorsList= dests.get(ep);
    int[] minorsArray = new int[minorsList.size()];
    int x = 0;
    for(Integer m : minorsList){
      minorsArray[x++] = m;
    }
    receivingMinorFragments[i] = minorsArray;
    tunnels[i] = tunnelProvider.getExecTunnel(ep);
    i++;
  }
}
 

protected void createSenderReceiverMapping(EndpointsIndex.Builder indexBuilder) {
  if (isSenderReceiverMappingCreated) {
    return;
  }

  senderToReceiversMapping = ArrayListMultimap.create();
  receiverToSenderMapping = Maps.newHashMap();

  // Find the list of receiver fragment ids assigned to each SabotNode endpoint
  ArrayListMultimap<NodeEndpoint, Integer> endpointReceiverList = ArrayListMultimap.create();

  int receiverFragmentId = 0;
  for(NodeEndpoint receiverLocation : receiverLocations) {
    endpointReceiverList.put(receiverLocation, receiverFragmentId);
    receiverFragmentId++;
  }

  int senderFragmentId = 0;
  for(NodeEndpoint senderLocation : senderLocations) {
    final List<Integer> receiverMinorFragmentIds = endpointReceiverList.get(senderLocation);

    for(Integer receiverId : receiverMinorFragmentIds) {
      receiverToSenderMapping.put(receiverId, indexBuilder.addFragmentEndpoint(senderFragmentId, senderLocation));

      senderToReceiversMapping.put(senderFragmentId,
          indexBuilder.addFragmentEndpoint(receiverId, receiverLocations.get(receiverId)));
    }
    senderFragmentId++;
  }

  isSenderReceiverMappingCreated = true;
}
 

protected void createSenderReceiverMapping(EndpointsIndex.Builder indexBuilder) {
  if (isSenderReceiverMappingCreated) {
    return;
  }

  senderToReceiverMapping = Maps.newHashMap();
  receiverToSenderMapping = ArrayListMultimap.create();

  // Find the list of sender fragment ids assigned to each SabotNode endpoint.
  ArrayListMultimap<NodeEndpoint, Integer> endpointSenderList = ArrayListMultimap.create();

  int senderFragmentId = 0;
  for(NodeEndpoint senderLocation : senderLocations) {
    endpointSenderList.put(senderLocation, senderFragmentId);
    senderFragmentId++;
  }

  int receiverFragmentId = 0;
  for(NodeEndpoint receiverLocation : receiverLocations) {
    List<Integer> senderFragmentIds = endpointSenderList.get(receiverLocation);

    for(Integer senderId : senderFragmentIds) {
      senderToReceiverMapping.put(senderId,
        indexBuilder.addFragmentEndpoint(receiverFragmentId, receiverLocation));

      receiverToSenderMapping.put(receiverFragmentId,
        indexBuilder.addFragmentEndpoint(senderId, senderLocations.get(senderId)));
    }
    receiverFragmentId++;
  }

  isSenderReceiverMappingCreated = true;
}
 

public static Map<String, Collection<NodeOperation>> groupByServer(Iterable<NodeOperation> nodeOperations) {
    ArrayListMultimap<String, NodeOperation> byServer = ArrayListMultimap.create();
    for (NodeOperation nodeOperation : nodeOperations) {
        for (String server : nodeOperation.executionPhase().nodeIds()) {
            byServer.put(server, nodeOperation);
        }
    }
    return byServer.asMap();
}
 

@Test
public void testHttpPasswordRequest() throws Exception {
    MockResponse firstServerResponse = new MockResponse().setResponseCode(401).addHeader("WWW-Authenticate", "Basic realm=\"User Visible Realm\"").setBody("Not Authenticated");
    server.enqueue(firstServerResponse);
    MockResponse secondServerResponse = new MockResponse().setResponseCode(200).addHeader(HTTP_RESPONSE_HEADER_KEY, HTTP_RESPONSE_HEADER_VALUE).setBody(HTTP_BODY);
    server.enqueue(secondServerResponse);
    final String USER = "brooklyn",
            PASSWORD = "apache";
    String authUnencoded = USER + ":" + PASSWORD;
    String authEncoded = Base64.encodeBase64String(Strings.toByteArray(authUnencoded));
    HttpExecutor executor = factory.getHttpExecutor(getProps());
    HttpRequest executorRequest = new HttpRequest.Builder().headers(ImmutableMap.of("RequestHeader", "RequestHeaderValue"))
            .method("GET")
            .uri(baseUrl.toURI())
            .credentials(new UsernamePassword("brooklyn", "apache"))
            .build();
    HttpResponse executorResponse = executor.execute(executorRequest);

    RecordedRequest recordedFirstRequest = server.takeRequest();
    RecordedRequest recordedSecondRequest = server.takeRequest();

    assertRequestAndResponse(recordedFirstRequest,
            firstServerResponse,
            executorRequest,
            new HttpResponse.Builder()
                    .header("WWW-Authenticate", "Basic realm=\"User Visible Realm\"")
                    .header("Content-Length", "" + "Not Authenticated".length())
                    .content("Not Authenticated".getBytes())
                    .build());
    ArrayListMultimap newHeaders = ArrayListMultimap.create(executorRequest.headers());
    newHeaders.put("Authorization", "Basic " + authEncoded);
    assertRequestAndResponse(recordedSecondRequest,
            secondServerResponse,
            new HttpRequest.Builder().from((HttpRequestImpl)executorRequest).headers(newHeaders).build(),
            executorResponse);
}
 

public ResolvedSourceCode getResolvedSourceCode(final String sourceCode,
		final Set<Set<ASTNode>> nodeBindings, final String filename,
		final Predicate<ASTNode> includeNode) {
	final SortedMap<Integer, String> tokenPositions = tokenizer
			.tokenListWithPos(sourceCode.toCharArray());
	final SortedMap<Integer, Integer> positionToIndex = getTokenIndexForPostion(tokenPositions);
	final List<String> tokens = Lists.newArrayList(tokenPositions.values());

	final ArrayListMultimap<String, TokenNameBinding> bindings = ArrayListMultimap
			.create();

	for (final Set<ASTNode> boundName : nodeBindings) {
		if (boundName.isEmpty()
				|| boundName.stream().noneMatch(includeNode)) {
			continue;
		}
		final List<Integer> boundPositions = Lists.newArrayList();
		for (final ASTNode name : boundName) {
			// Convert position to token index and add
			final int tokenIdx = positionToIndex.get(name
					.getStartPosition());
			boundPositions.add(tokenIdx);
		}
		bindings.put(tokens.get(boundPositions.get(0)),
				new TokenNameBinding(Sets.newTreeSet(boundPositions),
						tokens, getFeatures(boundName)));
	}

	return new ResolvedSourceCode(filename, tokens, bindings);
}
 

private ListMultimap<CustomizationType, Customization> loadCustomizationMap() {
	PairingCatalog catalog = manager.getCatalog();
	assertNotNull(catalog);
	List<Customization> customizations = catalog.getCustomizations();
	ArrayListMultimap<CustomizationType, Customization> customizationMap = ArrayListMultimap.create();
	for(Customization cur : customizations) {
		customizationMap.put(cur.getType(), cur);
	}
	return customizationMap;
}
 

private ListMultimap<CustomizationType, Customization> loadCustomizationMap() {
	PairingCatalog catalog = manager.getCatalog();
	assertNotNull(catalog);
	List<Customization> customizations = catalog.getCustomizations();
	ArrayListMultimap<CustomizationType, Customization> customizationMap = ArrayListMultimap.create();
	for(Customization cur : customizations) {
		customizationMap.put(cur.getType(), cur);
	}
	return customizationMap;
}
 

public ResolvedSourceCode getResolvedSourceCode(final String sourceCode,
		final Set<Set<ASTNode>> nodeBindings, final String filename,
		final Predicate<ASTNode> includeNode) {
	final SortedMap<Integer, String> tokenPositions = tokenizer
			.tokenListWithPos(sourceCode.toCharArray());
	final SortedMap<Integer, Integer> positionToIndex = getTokenIndexForPostion(tokenPositions);
	final List<String> tokens = Lists.newArrayList(tokenPositions.values());

	final ArrayListMultimap<String, TokenNameBinding> bindings = ArrayListMultimap
			.create();

	for (final Set<ASTNode> boundName : nodeBindings) {
		if (boundName.isEmpty()
				|| boundName.stream().noneMatch(includeNode)) {
			continue;
		}
		final List<Integer> boundPositions = Lists.newArrayList();
		for (final ASTNode name : boundName) {
			// Convert position to token index and add
			final int tokenIdx = positionToIndex.get(name
					.getStartPosition());
			boundPositions.add(tokenIdx);
		}
		bindings.put(tokens.get(boundPositions.get(0)),
				new TokenNameBinding(Sets.newTreeSet(boundPositions),
						tokens, getFeatures(boundName)));
	}

	return new ResolvedSourceCode(filename, tokens, bindings);
}
 

public AnomalyDetectionInputContextBuilder fetchExistingMergedAnomalies(List<Pair<Long, Long>> startEndTimeRanges, boolean loadRawAnomalies) {
// Get existing anomalies for this time range and this function id for all combinations of dimensions
    List<MergedAnomalyResultDTO> knownMergedAnomalies;
    knownMergedAnomalies = getKnownMergedAnomalies(anomalyFunctionSpec.getId(), startEndTimeRanges, loadRawAnomalies);
    // Sort the known merged and raw anomalies by their dimension names
    ArrayListMultimap<DimensionMap, MergedAnomalyResultDTO> dimensionMapToKnownMergedAnomalies = ArrayListMultimap.create();
    for (MergedAnomalyResultDTO knownMergedAnomaly : knownMergedAnomalies) {
      dimensionMapToKnownMergedAnomalies.put(knownMergedAnomaly.getDimensions(), knownMergedAnomaly);
    }
    this.anomalyDetectionInputContext.setKnownMergedAnomalies(dimensionMapToKnownMergedAnomalies);

    return this;
  }
 

@Override
public BroadcastModule parse(MapFactory factory, Logger logger, Document doc)
    throws InvalidXMLException {
  ArrayListMultimap<Duration, Broadcast> broadcasts = ArrayListMultimap.create();

  for (Element elBroadcasts : doc.getRootElement().getChildren("broadcasts")) {
    for (Element elBroadcast : elBroadcasts.getChildren()) {
      final Node nodeBroadcast = new Node(elBroadcast);
      Broadcast.Type type =
          XMLUtils.parseEnum(
              nodeBroadcast, elBroadcast.getName(), Broadcast.Type.class, "broadcast type");

      Component message = XMLUtils.parseFormattedText(nodeBroadcast);

      FilterParser filterParser = factory.getFilters();
      Filter filter = filterParser.parseFilterProperty(elBroadcast, "filter");

      Duration after =
          XMLUtils.parseDuration(XMLUtils.getRequiredAttribute(elBroadcast, "after"));

      Attribute attrEvery = elBroadcast.getAttribute("every");
      Duration every = XMLUtils.parseDuration(attrEvery, null);

      Node countNode = Node.fromAttr(elBroadcast, "count");
      int count = XMLUtils.parseNumber(countNode, Integer.class, true, 1);

      if (count < 1) {
        throw new InvalidXMLException("Repeat count must be at least 1", countNode);
      }

      if (count > 1 && every == null) {
        // If a repeat count is specified but no interval, use the initial delay as the interval
        every = after;
      } else if (count == 1 && every != null) {
        // If a repeat interval is specified but no count, repeat forever
        count = Integer.MAX_VALUE;
      }

      if (every != null
          && TimeUtils.isShorterThan(every, CountdownRunner.MIN_REPEAT_INTERVAL)) {
        throw new InvalidXMLException(
            "Repeat interval must be at least "
                + CountdownRunner.MIN_REPEAT_INTERVAL.toMillis()
                + " milliseconds",
            attrEvery);
      }

      broadcasts.put(after, new Broadcast(type, after, count, every, message, filter));
    }
  }

  return broadcasts.isEmpty() ? null : new BroadcastModule(broadcasts);
}
 

public static SessionDescription parse(final String input) {
    final SessionDescriptionBuilder sessionDescriptionBuilder = new SessionDescriptionBuilder();
    MediaBuilder currentMediaBuilder = null;
    ArrayListMultimap<String, String> attributeMap = ArrayListMultimap.create();
    ImmutableList.Builder<Media> mediaBuilder = new ImmutableList.Builder<>();
    for (final String line : input.split(LINE_DIVIDER)) {
        final String[] pair = line.trim().split("=", 2);
        if (pair.length < 2 || pair[0].length() != 1) {
            Log.d(Config.LOGTAG, "skipping sdp parsing on line " + line);
            continue;
        }
        final char key = pair[0].charAt(0);
        final String value = pair[1];
        switch (key) {
            case 'v':
                sessionDescriptionBuilder.setVersion(ignorantIntParser(value));
                break;
            case 'c':
                if (currentMediaBuilder != null) {
                    currentMediaBuilder.setConnectionData(value);
                } else {
                    sessionDescriptionBuilder.setConnectionData(value);
                }
                break;
            case 's':
                sessionDescriptionBuilder.setName(value);
                break;
            case 'a':
                final Pair<String, String> attribute = parseAttribute(value);
                attributeMap.put(attribute.first, attribute.second);
                break;
            case 'm':
                if (currentMediaBuilder == null) {
                    sessionDescriptionBuilder.setAttributes(attributeMap);
                    ;
                } else {
                    currentMediaBuilder.setAttributes(attributeMap);
                    mediaBuilder.add(currentMediaBuilder.createMedia());
                }
                attributeMap = ArrayListMultimap.create();
                currentMediaBuilder = new MediaBuilder();
                final String[] parts = value.split(" ");
                if (parts.length >= 3) {
                    currentMediaBuilder.setMedia(parts[0]);
                    currentMediaBuilder.setPort(ignorantIntParser(parts[1]));
                    currentMediaBuilder.setProtocol(parts[2]);
                    ImmutableList.Builder<Integer> formats = new ImmutableList.Builder<>();
                    for (int i = 3; i < parts.length; ++i) {
                        formats.add(ignorantIntParser(parts[i]));
                    }
                    currentMediaBuilder.setFormats(formats.build());
                } else {
                    Log.d(Config.LOGTAG, "skipping media line " + line);
                }
                break;
        }

    }
    if (currentMediaBuilder != null) {
        currentMediaBuilder.setAttributes(attributeMap);
        mediaBuilder.add(currentMediaBuilder.createMedia());
    } else {
        sessionDescriptionBuilder.setAttributes(attributeMap);
    }
    sessionDescriptionBuilder.setMedia(mediaBuilder.build());
    return sessionDescriptionBuilder.createSessionDescription();
}
 

public static SessionDescription parse(final String input) {
    final SessionDescriptionBuilder sessionDescriptionBuilder = new SessionDescriptionBuilder();
    MediaBuilder currentMediaBuilder = null;
    ArrayListMultimap<String, String> attributeMap = ArrayListMultimap.create();
    ImmutableList.Builder<Media> mediaBuilder = new ImmutableList.Builder<>();
    for (final String line : input.split(LINE_DIVIDER)) {
        final String[] pair = line.trim().split("=", 2);
        if (pair.length < 2 || pair[0].length() != 1) {
            Log.d(Config.LOGTAG, "skipping sdp parsing on line " + line);
            continue;
        }
        final char key = pair[0].charAt(0);
        final String value = pair[1];
        switch (key) {
            case 'v':
                sessionDescriptionBuilder.setVersion(ignorantIntParser(value));
                break;
            case 'c':
                if (currentMediaBuilder != null) {
                    currentMediaBuilder.setConnectionData(value);
                } else {
                    sessionDescriptionBuilder.setConnectionData(value);
                }
                break;
            case 's':
                sessionDescriptionBuilder.setName(value);
                break;
            case 'a':
                final Pair<String, String> attribute = parseAttribute(value);
                attributeMap.put(attribute.first, attribute.second);
                break;
            case 'm':
                if (currentMediaBuilder == null) {
                    sessionDescriptionBuilder.setAttributes(attributeMap);
                    ;
                } else {
                    currentMediaBuilder.setAttributes(attributeMap);
                    mediaBuilder.add(currentMediaBuilder.createMedia());
                }
                attributeMap = ArrayListMultimap.create();
                currentMediaBuilder = new MediaBuilder();
                final String[] parts = value.split(" ");
                if (parts.length >= 3) {
                    currentMediaBuilder.setMedia(parts[0]);
                    currentMediaBuilder.setPort(ignorantIntParser(parts[1]));
                    currentMediaBuilder.setProtocol(parts[2]);
                    ImmutableList.Builder<Integer> formats = new ImmutableList.Builder<>();
                    for (int i = 3; i < parts.length; ++i) {
                        formats.add(ignorantIntParser(parts[i]));
                    }
                    currentMediaBuilder.setFormats(formats.build());
                } else {
                    Log.d(Config.LOGTAG, "skipping media line " + line);
                }
                break;
        }

    }
    if (currentMediaBuilder != null) {
        currentMediaBuilder.setAttributes(attributeMap);
        mediaBuilder.add(currentMediaBuilder.createMedia());
    } else {
        sessionDescriptionBuilder.setAttributes(attributeMap);
    }
    sessionDescriptionBuilder.setMedia(mediaBuilder.build());
    return sessionDescriptionBuilder.createSessionDescription();
}