Java Code Examples for com.google.common.collect.Maps

@Override public List<Reference> search(String query){
  Map<String,String> queryMap=Maps.newHashMap();
  queryMap.put("q",query);
  queryMap.put("type","user");
  return graphApi.fetchConnections("search",null,Reference.class,queryMap);
}
 

private void updateGroup(Uri<? extends Component> uri,AWSEC2Client ec2,IAMApi iam,SecurityGroup group){
  String user_id=iam.getCurrentUser().getId();
  Set<String> raw_rules=Sets.newHashSet();
  for (  Map.Entry<String,Collection<String>> entry : uri.getFullParams().entrySet()) {
    raw_rules.addAll(entry.getValue());
  }
  Set<IpRule> rules=Sets.newHashSet();
  for (  String raw_thing : raw_rules) {
    rules.add(IpRule.parse(user_id,raw_thing));
  }
  Map<IpRule,IpPermission> map=Maps.newHashMap();
  Set<IpRule> existing_rules=Sets.newHashSet();
  for (  IpPermission permission : group.getIpPermissions()) {
    IpRule r=IpRule.fromPermission(permission);
    existing_rules.add(r);
    map.put(r,permission);
  }
  Set<IpRule> to_remove=Sets.difference(existing_rules,rules);
  Set<IpRule> to_add=Sets.difference(rules,existing_rules);
  List<IpPermission> adds=Lists.newArrayListWithExpectedSize(to_add.size());
  for (  IpRule rule : to_add) {
    adds.add(rule.toIpPermission());
  }
  if (!adds.isEmpty()) {
    ec2.getSecurityGroupServices().authorizeSecurityGroupIngressInRegion(null,group.getName(),adds);
  }
  List<IpPermission> removals=Lists.newArrayListWithExpectedSize(to_remove.size());
  for (  IpRule rule : to_remove) {
    removals.add(map.get(rule));
  }
}
 

@Override public ArtifactoryRedeployPublisher newInstance(StaplerRequest req,JSONObject formData) throws FormException {
  ArtifactoryRedeployPublisher publisher=req.bindJSON(ArtifactoryRedeployPublisher.class,formData);
  if (formData.has("details")) {
    JSONObject serverDetails=formData.getJSONObject("details");
    if (serverDetails.has("stagingPlugin")) {
      PluginSettings settings=new PluginSettings();
      Map<String,String> paramMap=Maps.newHashMap();
      JSONObject pluginSettings=serverDetails.getJSONObject("stagingPlugin");
      String pluginName=pluginSettings.getString("pluginName");
      settings.setPluginName(pluginName);
      Map<String,Object> filteredPluginSettings=Maps.filterKeys(pluginSettings,new Predicate<String>(){
        public boolean apply(        String input){
          return StringUtils.isNotBlank(input) && !"pluginName".equals(input);
        }
      }
);
      for (      Map.Entry<String,Object> settingsEntry : filteredPluginSettings.entrySet()) {
        String key=settingsEntry.getKey();
        paramMap.put(key,pluginSettings.getString(key));
      }
      if (!paramMap.isEmpty()) {
        settings.setParamMap(paramMap);
      }
      publisher.details.setStagingPlugin(settings);
    }
  }
  return publisher;
}
 

private Map<YearAndMonth,Double> readResults(File outputFile) throws IOException {
  Pattern separator=Pattern.compile("\t");
  Map<YearAndMonth,Double> averageTemperatures=Maps.newHashMap();
  for (  String line : new FileLineIterable(outputFile)) {
    String[] tokens=separator.split(line);
    int year=Integer.parseInt(tokens[0]);
    int month=Integer.parseInt(tokens[1]);
    double temperature=Double.parseDouble(tokens[2]);
    averageTemperatures.put(new YearAndMonth(year,month),temperature);
  }
  return averageTemperatures;
}
 

public Map<String,String> loadProperties() throws IOException {
  Map<String,String> result=Maps.newTreeMap();
  String configFile=System.getProperty("config");
  if (configFile != null) {
    result.putAll(loadPropertiesFrom(configFile));
  }
  result.putAll(getSystemProperties());
  return ImmutableSortedMap.copyOf(result);
}
 

@Override public void start(){
  ConnectionPoolMBeanManager.getInstance().registerMonitor(config.getName(),this);
  String seeds=config.getSeeds();
  if (seeds != null && !seeds.isEmpty()) {
    Map<BigInteger,List<Host>> ring=Maps.newHashMap();
    ring.put(new BigInteger("0"),config.getSeedHosts());
    setHosts(ring);
  }
  latencyScoreStrategy.start(new Listener(){
    @Override public void onUpdate(){
      rebuildPartitions();
    }
    @Override public void onReset(){
      rebuildPartitions();
    }
  }
);
}
 

private Map<String,String> getConfiguredTemplates(){
  if (configuredTemplates == null) {
    String parameterValue=checkNotNull(getInitParameter(VELOCITY_TEMPLATES_CONFIG_PARAMETER),VELOCITY_TEMPLATES_CONFIG_PARAMETER + " servlet configuration parameter");
    Collection<String> entries=new LinkedHashSet<String>(Arrays.asList(StringUtils.split(parameterValue,';')));
    entries=Collections2.filter(entries,new Predicate<String>(){
      @Override public boolean apply(      @Nullable String s){
        return StringUtils.isNotBlank(s);
      }
    }
);
    Map<String,String> result=Maps.newHashMap();
    for (    String entry : entries) {
      String data[]=StringUtils.split(entry,'|');
      result.put(StringUtils.trimToNull(data[0]),StringUtils.trimToNull(data[1]));
    }
    configuredTemplates=ImmutableMap.copyOf(result);
  }
  return configuredTemplates;
}
 

public CoreTestFixture(Class<?> testClass) throws InvalidTestException {
  this.testClass=testClass;
  fields=Maps.newHashMap();
  for (  Field field : TestClassUtils.getFields(testClass)) {
    fields.put(field,null);
  }
  mockFields=TestClassUtils.getMockFields(fields.keySet());
  stubFields=TestClassUtils.getStubFields(fields.keySet());
  unitField=TestClassUtils.getUnitField(fields.keySet());
  containerClass=PluginUtils.getContainerPluginClass(testClass);
  pluginClasses=PluginUtils.getPluginClasses(testClass);
}
 

@Test public void tDuplicateFields() throws Exception {
  GuiceContainer container=new GuiceContainer();
  Map<Field,Object> fieldValues=Maps.newHashMap();
  fieldValues.put(DuplicateFields.class.getDeclaredField("field1"),"field 1");
  fieldValues.put(DuplicateFields.class.getDeclaredField("field2"),"field 2");
  fieldValues.put(DuplicateFields.class.getDeclaredField("field3"),new Integer(3));
  DuplicateFields df=(DuplicateFields)container.createTest(DuplicateFields.class,fieldValues);
  assertFalse("field 1".equals(df.field1));
  assertFalse("field 2".equals(df.field2));
  assertEquals(3,df.field3.intValue());
}
 

@Override public ExecutableFlow apply(Map<String,Object> descriptor){
  Map<String,ExecutableFlow> jobs=Maps.uniqueIndex(Iterables.<Map<String,Object>,ExecutableFlow>transform(Verifier.getVerifiedObject(descriptor,"jobs",Map.class).values(),jobDeserializer),new Function<ExecutableFlow,String>(){
    @Override public String apply(    ExecutableFlow flow){
      return flow.getName();
    }
  }
);
  Map<String,List<String>> dependencies=Verifier.getVerifiedObject(descriptor,"dependencies",Map.class);
  List<String> roots=Verifier.getVerifiedObject(descriptor,"root",List.class);
  String id=Verifier.getString(descriptor,"id");
  return buildFlow(id,roots,dependencies,jobs);
}
 

public static Map<List<String>,FsObject> createRootMap(List<String> names){
  Map<List<String>,FsObject> map=Maps.newLinkedHashMap();
  for (  String name : names.isEmpty() ? Collections.singleton(".") : names) {
    File file=new File(name);
    List<String> path=getPath(file);
    Preconditions.checkState(map.put(path,new FsObject(file,path)) == null,"Duplicate path: %s",path);
  }
  return map;
}
 

public Map<String,Map<Integer,Boolean>> getServerMatrix(){
  if (matrix == null) {
    matrix=Maps.newHashMap();
    for (    Buildable buildable : getBuildables()) {
      Map<Integer,Boolean> serverMatches=Maps.newHashMap();
      for (      SonarServer server : getServers()) {
        serverMatches.put(server.getID(),Iterables.any(buildable.getBuildDefinition().getTaskDefinitions(),SonarPredicates.isSonarServerDependingTask(server.getID())));
      }
      matrix.put(buildable.getKey(),serverMatches);
    }
  }
  return matrix;
}
 

@Override public Horse getHorse(int runnerId,int raceId){
  Map<String,Integer> params=Maps.newHashMap();
  params.put("runnerId",runnerId);
  params.put("raceId",raceId);
  return (Horse)hibernateTemplate.findByNamedQueryAndNamedParam("getHorse",new String[]{"runnerId","raceId"},new Integer[]{runnerId,raceId}).get(0);
}
 

public PromotionBuilder addProperty(String key,String value){
  if (properties == null) {
    properties=Maps.newHashMap();
  }
  Collection<String> collection;
  if (!properties.containsKey(key)) {
    collection=Sets.newHashSet();
  }
 else {
    collection=properties.get(key);
  }
  collection.add(value);
  properties.put(key,collection);
  return this;
}
 

private static void generate(Set<org.bukkit.permissions.Permission> permissions,Set<String> children,String prefix,String name){
  if (children.isEmpty()) {
    Map<String,Boolean> childrenMap=Maps.newHashMapWithExpectedSize(children.size());
    for (    String child : children) {
      childrenMap.put(child,true);
    }
    permissions.add(new org.bukkit.permissions.Permission(prefix + (prefix.isEmpty() ? "" : ".") + name,childrenMap));
  }
}
 

public static Map<String,String> readTagMapping(String tagMapFile) throws Exception {
  Map<String,String> tagMap=Maps.newHashMap();
  BufferedReader br=new BufferedReader(new FileReader(tagMapFile));
  for (String line=null; (line=br.readLine()) != null; ) {
    String[] tokens=line.split("\\s+");
    tagMap.put(tokens[0],tokens[1]);
  }
  return tagMap;
}
 

public AndroidWebDriver(Activity activity){
  this.activity=activity;
  store=Maps.newHashMap();
  findBy=new AndroidFindBy();
  currentWindowOrFrame=new DomWindow("");
  store=Maps.newHashMap();
  touchScreen=new AndroidTouchScreen(this);
  navigation=new AndroidNavigation();
  options=new AndroidOptions();
  element=getOrCreateWebElement("");
  localStorage=new AndroidLocalStorage(this);
  sessionStorage=new AndroidSessionStorage(this);
  targetLocator=new AndroidTargetLocator();
  viewManager=new WebViewManager();
  newWebView(true);
  CookieSyncManager.createInstance(activity);
  sessionCookieManager=new SessionCookieManager();
  CookieManager cookieManager=CookieManager.getInstance();
  cookieManager.removeAllCookie();
  networkHandler=new NetworkStateHandler(activity,webview);
}
 

/** 
 * <p class="changed_added_4_0"> Utility method to get all bean properties, similar to Introspector </p>
 * @param type
 * @return
 */
Map<String,AptBeanProperty> getBeanProperties(TypeElement type){
  if (null == type) {
    return Collections.emptyMap();
  }
  Name qName=type.getQualifiedName();
  Map<String,AptBeanProperty> result=beanPropertyCache.get(qName);
  if (result != null) {
    return result;
  }
  result=Maps.newHashMap();
  List<? extends Element> members=this.processingEnv.getElementUtils().getAllMembers(type);
  for (  Element element : members) {
    if (ElementKind.METHOD.equals(element.getKind())) {
      ExecutableElement method=(ExecutableElement)element;
      processMethod(type,result,method);
    }
  }
  beanPropertyCache.put(qName,result);
  return result;
}
 

/** 
 * Look through all of the declared, static, final fields of the context object, grab the value, and insert a mapping from the field's name to the object. Note that this will index non-public fields.
 * @return the bindable constants map
 * @throws IllegalArgumentException on reflection error
 * @throws IllegalAccessException on reflection error
 */
private Map<String,Object> indexBindableConstants() throws IllegalArgumentException, IllegalAccessException {
  Map<String,Object> map=Maps.newHashMap();
  for (  Field field : object.getClass().getDeclaredFields()) {
    boolean accessible=field.isAccessible();
    field.setAccessible(true);
    if (Reflections.isFieldFinal(field) && Reflections.isFieldStatic(field)) {
      map.put(field.getName(),field.get(object));
    }
    field.setAccessible(accessible);
  }
  return map;
}
 

private Map<String,Object> translateToForeignNames(Map<String,Object> from){
  SortedMap<String,Object> to=Maps.newTreeMap();
  for (  ColumnPair pair : pairs) {
    to.put(pair.foreign,from.get(pair.local));
  }
  return to;
}
 

private Map<FlagType,Map<String,FlagInfo>> getPopulatedMap(){
  Map<FlagType,Map<String,FlagInfo>> populated=Maps.newEnumMap(FlagType.class);
  for (  FlagType type : FlagType.values()) {
    populated.put(type,new HashMap<String,FlagInfo>());
  }
  return populated;
}
 

/** 
 * Constructor that initializes this SoyMapData from an existing map.
 * @param data The initial data in an existing map.
 */
public SoyMapData(Map<String,?> data){
  map=Maps.newHashMapWithExpectedSize(data.size());
  for (  Map.Entry<String,?> entry : data.entrySet()) {
    String key;
    try {
      key=entry.getKey();
    }
 catch (    ClassCastException cce) {
      throw new SoyDataException("Attempting to convert a map with non-string key to Soy data (key type " + ((Map.Entry<?,?>)entry).getKey().getClass().getName() + ").");
    }
    Object value=entry.getValue();
    try {
      map.put(key,SoyData.createFromExistingData(value));
    }
 catch (    SoyDataException sde) {
      sde.prependKeyToDataPath(key);
      throw sde;
    }
  }
}