private PresentWhenExtensionAnnotationMatchesExtensionSet whenExtensionsAndAliasesInRegionInclude(
      String region, final Set<Extension> extensions, final Multimap<URI, URI> aliases) {
    final LoadingCache<String, Set<? extends Extension>> extensionsForRegion =
        CacheBuilder.newBuilder()
            .build(
                CacheLoader.from(
                    Functions.forMap(
                        ImmutableMap.<String, Set<? extends Extension>>of(
                            region, extensions, "differentregion", ImmutableSet.<Extension>of()))));

    PresentWhenExtensionAnnotationMatchesExtensionSet fn =
        Guice.createInjector(
                new AbstractModule() {
                  @Override
                  protected void configure() {
                    MapBinder<URI, URI> aliasBindings =
                        MapBinder.newMapBinder(
                                binder(), URI.class, URI.class, NamespaceAliases.class)
                            .permitDuplicates();
                    for (URI key : aliases.keySet()) {
                      for (URI value : aliases.get(key)) {
                        aliasBindings.addBinding(key).toInstance(value);
                      }
                    }
                  }

                  @Provides
                  LoadingCache<String, Set<? extends Extension>> getExtensions() {
                    return extensionsForRegion;
                  }
                })
            .getInstance(PresentWhenExtensionAnnotationMatchesExtensionSet.class);

    return fn;
  }
 public TemplateBuilder createTemplateBuilder() {
   final Supplier<Set<? extends Image>> images =
       Suppliers.<Set<? extends Image>>ofInstance(
           ImmutableSet.of(
               new ImageBuilder()
                   .providerId("ebs-image-provider")
                   .name("image")
                   .id("us-east-1/bogus-image")
                   .location(jcloudsDomainLocation)
                   .userMetadata(ImmutableMap.of("rootDeviceType", RootDeviceType.EBS.value()))
                   .operatingSystem(
                       new OperatingSystem(
                           OsFamily.UBUNTU,
                           null,
                           "1.0",
                           VirtualizationType.PARAVIRTUAL.value(),
                           "ubuntu",
                           true))
                   .description("description")
                   .version("1.0")
                   .defaultCredentials(LoginCredentials.builder().user("root").build())
                   .status(Image.Status.AVAILABLE)
                   .build()));
   ImmutableMap<RegionAndName, Image> imageMap =
       (ImmutableMap<RegionAndName, Image>) ImagesToRegionAndIdMap.imagesToMap(images.get());
   Supplier<LoadingCache<RegionAndName, ? extends Image>> imageCache =
       Suppliers.<LoadingCache<RegionAndName, ? extends Image>>ofInstance(
           CacheBuilder.newBuilder()
               .<RegionAndName, Image>build(CacheLoader.from(Functions.forMap(imageMap))));
   JcloudsStubTemplateBuilder jcloudsStubTemplateBuilder = new JcloudsStubTemplateBuilder();
   return jcloudsStubTemplateBuilder.newTemplateBuilder(images, imageCache);
 }
 @Override
 public ILearningCharmGroup[] getCharmGroups(Identified type) {
   if (MartialArtsUtilities.MARTIAL_ARTS.equals(type)) {
     return martialArtsGroups;
   }
   return Functions.forMap(nonMartialArtsGroupsByType, new ILearningCharmGroup[0]).apply(type);
 }
      @Override
      public Map<Symbol, Symbol> visitProject(ProjectNode node, Set<Symbol> lookupSymbols) {
        // Map from output Symbols to source Symbols
        Map<Symbol, Symbol> directSymbolTranslationOutputMap =
            Maps.transformValues(
                Maps.filterValues(node.getAssignments(), SymbolReference.class::isInstance),
                Symbol::from);
        Map<Symbol, Symbol> outputToSourceMap =
            lookupSymbols
                .stream()
                .filter(directSymbolTranslationOutputMap.keySet()::contains)
                .collect(toImmutableMap(identity(), directSymbolTranslationOutputMap::get));

        checkState(
            !outputToSourceMap.isEmpty(),
            "No lookup symbols were able to pass through the projection");

        // Map from source Symbols to underlying index source Symbols
        Map<Symbol, Symbol> sourceToIndexMap =
            node.getSource().accept(this, ImmutableSet.copyOf(outputToSourceMap.values()));

        // Generate the Map the connects lookup symbols to underlying index source symbols
        Map<Symbol, Symbol> outputToIndexMap =
            Maps.transformValues(
                Maps.filterValues(outputToSourceMap, in(sourceToIndexMap.keySet())),
                Functions.forMap(sourceToIndexMap));
        return ImmutableMap.copyOf(outputToIndexMap);
      }
  private synchronized void removeLeastRecentlyUsedCommand() {
    Ordering<String> ordering =
        Ordering.from(lastUsedComparator).onResultOf(Functions.forMap(this.hayStack));
    ImmutableSortedMap<String, CommandEntry> orderedHay =
        ImmutableSortedMap.copyOf(this.hayStack, ordering);
    String oldestKey = orderedHay.keySet().last();

    hayStack.remove(oldestKey);
  }
 private Iterable<IncludeScannable> getLipoScannables(NestedSet<Artifact> realMandatoryInputs) {
   return lipoScannableMap == null
       ? ImmutableList.<IncludeScannable>of()
       : Iterables.filter(
           Iterables.transform(
               Iterables.filter(
                   FileType.filter(
                       realMandatoryInputs,
                       CppFileTypes.C_SOURCE,
                       CppFileTypes.CPP_SOURCE,
                       CppFileTypes.ASSEMBLER_WITH_C_PREPROCESSOR),
                   Predicates.not(Predicates.equalTo(getSourceFile()))),
               Functions.forMap(lipoScannableMap, null)),
           Predicates.notNull());
 }
 public List<String> getSortedPeopleList(String firstName, String lastName) {
   // TODO: Talk to solrDao that would give a list of people salary pair. Then sort them on a logic
   People linkedInPeople = linkedInDao.getPerson(firstName, lastName);
   Map<String, BigDecimal> personSalaryMap = new HashMap<String, BigDecimal>();
   for (Person person : linkedInPeople.getPersonList()) {
     String key =
         person.getFirstName() + "_" + person.getLastName() + "_" + person.getCurrentStatus();
     personSalaryMap.put(key, getSalary(person));
   }
   Map<String, String> mockPeopleList = new HashMap<String, String>();
   List<String> sortedPeople =
       Ordering.natural()
           .onResultOf(Functions.forMap(personSalaryMap))
           .immutableSortedCopy(personSalaryMap.keySet());
   return sortedPeople;
 }
  @Override
  public synchronized ArrayList<String> find(String needle) {

    Ordering<String> ordering =
        Ordering.from(comparator).onResultOf(Functions.forMap(this.hayStack));
    ImmutableSortedMap<String, CommandEntry> orderedHay =
        ImmutableSortedMap.copyOf(this.hayStack, ordering);

    ArrayList<String> needles = new ArrayList<>();
    for (String straw : orderedHay.keySet()) {
      if (straw.contains(needle)) {
        needles.add(straw);
      }
    }
    return needles;
  }
 @Override
 protected CacheLoader<String, Optional<String>> bucketToRegion(
     @Region Supplier<Set<String>> regionSupplier, final S3Client client) {
   return CacheLoader.<String, Optional<String>>from(
       Functions.forMap(
           ImmutableMap.<String, Optional<String>>builder()
               .put("bucket", Optional.<String>absent())
               .put("destinationbucket", Optional.<String>absent())
               .put("bucket-us-standard", Optional.of("us-standard"))
               .put("bucket-us-west-1", Optional.of("us-west-1"))
               .put("bucket-us-west-2", Optional.of("us-west-2"))
               .put("bucket-eu-west-1", Optional.of("eu-west-1"))
               .put("bucket-sa-east-1", Optional.of("sa-east-1"))
               .put("bucket-ap-southeast-1", Optional.of("ap-southeast-1"))
               .put("bucket-ap-northeast-1", Optional.of("ap-northeast-1"))
               .build()));
 }
Exemple #10
0
  @JsonCreator
  public PlanFragment(
      @JsonProperty("id") PlanFragmentId id,
      @JsonProperty("root") PlanNode root,
      @JsonProperty("symbols") Map<Symbol, Type> symbols,
      @JsonProperty("distribution") PlanDistribution distribution,
      @JsonProperty("partitionedSource") PlanNodeId partitionedSource,
      @JsonProperty("outputPartitioning") OutputPartitioning outputPartitioning) {
    this.id = checkNotNull(id, "id is null");
    this.root = checkNotNull(root, "root is null");
    this.symbols = checkNotNull(symbols, "symbols is null");
    this.distribution = checkNotNull(distribution, "distribution is null");
    this.partitionedSource = partitionedSource;

    tupleInfos =
        IterableTransformer.on(root.getOutputSymbols())
            .transform(Functions.forMap(symbols))
            .transform(Type.toRaw())
            .transform(
                new Function<TupleInfo.Type, TupleInfo>() {
                  @Override
                  public TupleInfo apply(TupleInfo.Type input) {
                    return new TupleInfo(input);
                  }
                })
            .list();

    ImmutableList.Builder<PlanNode> sources = ImmutableList.builder();
    findSources(root, sources, partitionedSource);
    this.sources = sources.build();

    ImmutableSet.Builder<PlanNodeId> sourceIds = ImmutableSet.builder();
    for (PlanNode source : this.sources) {
      sourceIds.add(source.getId());
    }
    if (partitionedSource != null) {
      sourceIds.add(partitionedSource);
    }
    this.sourceIds = sourceIds.build();

    this.outputPartitioning = checkNotNull(outputPartitioning, "outputPartitioning is null");
  }
Exemple #11
0
 Set<Course> getPrerequisites() {
   return ImmutableSet.copyOf(
       Lists.transform(serial.getPrereqCourseIdList(), Functions.forMap(program.courses)));
 }
 public void setFormValidationSupplierMap(
     final Map<String, Supplier<ValidationProvider>> formValidationSupplierMap) {
   this.setFormValidationSupplierFunction(
       Functions.<String, Supplier<ValidationProvider>>forMap(formValidationSupplierMap, null));
 }
 @Override
 public Function<JetDeclaration, JetScope> getDeclaringScopes() {
   return Functions.forMap(declaringScopes);
 }
Exemple #14
0
  public void testMixedSaveLoadSave() throws IOException {
    Graph<Number, Number> graph1 = new SparseMultigraph<Number, Number>();
    for (int i = 0; i < 5; i++) {
      graph1.addVertex(i);
    }
    int j = 0;

    List<Number> id = new ArrayList<Number>(graph1.getVertices());
    GreekLabels<Number> gl = new GreekLabels<Number>(id);
    Number[] edges = {0, 1, 2, 3, 4, 5};

    graph1.addEdge(j++, 0, 1, EdgeType.DIRECTED);
    graph1.addEdge(j++, 0, 2, EdgeType.DIRECTED);
    graph1.addEdge(j++, 1, 2, EdgeType.DIRECTED);
    graph1.addEdge(j++, 1, 3);
    graph1.addEdge(j++, 1, 4);
    graph1.addEdge(j++, 4, 3);

    Map<Number, Number> nr = new HashMap<Number, Number>();
    for (int i = 0; i < edges.length; i++) {
      nr.put(edges[i], new Float(Math.random()));
    }

    assertEquals(graph1.getEdgeCount(), 6);

    //        System.err.println(" mixed graph1 = "+graph1);
    //        for(Number edge : graph1.getEdges()) {
    //        	System.err.println("edge "+edge+" is directed? "+graph1.getEdgeType(edge));
    //        }
    //        for(Number v : graph1.getVertices()) {
    //        	System.err.println(v+" outedges are "+graph1.getOutEdges(v));
    //        	System.err.println(v+" inedges are "+graph1.getInEdges(v));
    //        	System.err.println(v+" incidentedges are "+graph1.getIncidentEdges(v));
    //        }

    String testFilename = "mtest.net";
    String testFilename2 = testFilename + "2";

    // assign arbitrary locations to each vertex
    Map<Number, Point2D> locations = new HashMap<Number, Point2D>();
    for (Number v : graph1.getVertices()) {
      locations.put(v, new Point2D.Double(v.intValue() * v.intValue(), 1 << v.intValue()));
    }
    Function<Number, Point2D> vld = Functions.forMap(locations);

    PajekNetWriter<Number, Number> pnw = new PajekNetWriter<Number, Number>();
    pnw.save(graph1, testFilename, gl, Functions.forMap(nr), vld);

    Graph<Number, Number> graph2 = pnr.load(testFilename, graphFactory);
    Function<Number, String> pl = pnr.getVertexLabeller();
    List<Number> id2 = new ArrayList<Number>(graph2.getVertices());
    Function<Number, Point2D> vld2 = pnr.getVertexLocationTransformer();

    assertEquals(graph1.getVertexCount(), graph2.getVertexCount());
    assertEquals(graph1.getEdgeCount(), graph2.getEdgeCount());

    // test vertex labels and locations
    for (int i = 0; i < graph1.getVertexCount(); i++) {
      Number v1 = id.get(i);
      Number v2 = id2.get(i);
      assertEquals(gl.apply(v1), pl.apply(v2));
      assertEquals(vld.apply(v1), vld2.apply(v2));
    }

    // test edge weights
    Function<Number, Number> nr2 = pnr.getEdgeWeightTransformer();
    for (Number e2 : graph2.getEdges()) {
      Pair<Number> endpoints = graph2.getEndpoints(e2);
      Number v1_2 = endpoints.getFirst();
      Number v2_2 = endpoints.getSecond();
      Number v1_1 = id.get(id2.indexOf(v1_2));
      Number v2_1 = id.get(id2.indexOf(v2_2));
      Number e1 = graph1.findEdge(v1_1, v2_1);
      assertNotNull(e1);
      assertEquals(nr.get(e1).floatValue(), nr2.apply(e2).floatValue(), 0.0001);
    }

    pnw.save(graph2, testFilename2, pl, nr2, vld2);

    compareIndexedGraphs(graph1, graph2);

    pnr.setVertexLabeller(null);
    Graph<Number, Number> graph3 = pnr.load(testFilename2, graphFactory);

    compareIndexedGraphs(graph2, graph3);

    File file1 = new File(testFilename);
    File file2 = new File(testFilename2);

    Assert.assertTrue(file1.length() == file2.length());
    file1.delete();
    file2.delete();
  }
  private List<Element> elementsForGroup(
      String lastModified, LakeviewContentGroup contentGroup, Set<String> seenItems) {
    DateTime brandPublicationDate = null;
    DateTime brandEndDate = null;
    int addedSeasons = 0;

    List<Element> elements = Lists.newLinkedList();

    if (contentGroup.isFlattened()) {
      for (Episode episode : contentGroup.episodes()) {
        DateTime publicationDate = orginalPublicationDate(episode);
        if (publicationDate != null) {
          Element episodeElem =
              createEpisodeElem(episode, contentGroup.brand(), null, publicationDate, lastModified);
          String itemId = itemId(episodeElem);
          if (!seenItems.contains(itemId)) {
            elements.add(episodeElem);
            brandPublicationDate =
                publicationDate.isBefore(brandPublicationDate)
                    ? publicationDate
                    : brandPublicationDate;
            brandEndDate = latestOf(publicationDate, brandEndDate);
            seenItems.add(itemId);
          } else {
            log.warn("Not including duplicate of " + itemId);
          }
        }
      }
    } else {
      Map<String, Episode> episodeSeriesIndex =
          Maps.uniqueIndex(contentGroup.episodes(), Identified.TO_URI);

      Function<ChildRef, Episode> childRefToEpisode =
          Functions.compose(Functions.forMap(episodeSeriesIndex, null), ChildRef.TO_URI);
      for (Series series : contentGroup.series()) {
        DateTime seriesPublicationDate = null;

        int addedEpisodes = 0;
        for (Episode episode : sortedSeriesEpisodes(series.getChildRefs(), childRefToEpisode)) {
          DateTime publicationDate = orginalPublicationDate(episode);
          if (publicationDate != null) {
            Element epElem =
                createEpisodeElem(
                    episode, contentGroup.brand(), series, publicationDate, lastModified);
            String itemId = itemId(epElem);
            if (!seenItems.contains(itemId)) {
              elements.add(epElem);
              addedEpisodes++;
              seenItems.add(itemId);
              seriesPublicationDate = earliestOf(publicationDate, seriesPublicationDate);
              brandEndDate = latestOf(publicationDate, brandEndDate);
            } else {
              log.warn("Not including duplicate of " + itemId);
            }
          }
        }

        if (seriesPublicationDate != null) {
          addedSeasons++;
          elements.add(
              elements.size() - addedEpisodes,
              createSeriesElem(series, contentGroup.brand(), seriesPublicationDate, lastModified));
          brandPublicationDate =
              seriesPublicationDate.isBefore(brandPublicationDate)
                  ? seriesPublicationDate
                  : brandPublicationDate;
        }
      }
    }

    Element brandElem = null;
    if (brandPublicationDate != null) {
      brandElem =
          createBrandElem(
              contentGroup.brand(),
              brandPublicationDate,
              brandEndDate,
              lastModified,
              contentGroup,
              addedSeasons);
      if (brandElem != null) {
        elements.add(0, brandElem);
      }
    }

    return brandElem != null ? elements : ImmutableList.<Element>of();
  }
Exemple #16
0
 Set<Resource> getRequiredResources() {
   return ImmutableSet.copyOf(
       Lists.transform(serial.getRequiredResourceList(), Functions.forMap(program.resources)));
 }
Exemple #17
0
 // Does not cache!
 Set<Teacher> getTeachers() {
   return ImmutableSet.copyOf(
       Lists.transform(serial.getTeacherIdList(), Functions.forMap(program.teachers)));
 }
/** @since 2.3 */
public final class AnnotationRuleParser implements ServerComponent {

  private static final Logger LOG = LoggerFactory.getLogger(AnnotationRuleParser.class);

  public List<Rule> parse(String repositoryKey, Collection<Class> annotatedClasses) {
    List<Rule> rules = Lists.newArrayList();
    for (Class annotatedClass : annotatedClasses) {
      rules.add(create(repositoryKey, annotatedClass));
    }
    return rules;
  }

  private Rule create(String repositoryKey, Class annotatedClass) {
    org.sonar.check.Rule ruleAnnotation =
        AnnotationUtils.getAnnotation(annotatedClass, org.sonar.check.Rule.class);
    if (ruleAnnotation != null) {
      return toRule(repositoryKey, annotatedClass, ruleAnnotation);
    }
    LOG.warn(
        "The class "
            + annotatedClass.getCanonicalName()
            + " should be annotated with "
            + Rule.class);
    return null;
  }

  private Rule toRule(String repositoryKey, Class clazz, org.sonar.check.Rule ruleAnnotation) {
    String ruleKey = StringUtils.defaultIfEmpty(ruleAnnotation.key(), clazz.getCanonicalName());
    String ruleName = StringUtils.defaultIfEmpty(ruleAnnotation.name(), null);
    String description = StringUtils.defaultIfEmpty(ruleAnnotation.description(), null);
    Rule rule = Rule.create(repositoryKey, ruleKey, ruleName);
    rule.setDescription(description);
    rule.setSeverity(RulePriority.fromCheckPriority(ruleAnnotation.priority()));
    rule.setCardinality(ruleAnnotation.cardinality());
    rule.setStatus(ruleAnnotation.status().name());

    List<Field> fields = FieldUtils2.getFields(clazz, true);
    for (Field field : fields) {
      addRuleProperty(rule, field);
    }
    return rule;
  }

  private void addRuleProperty(Rule rule, Field field) {
    org.sonar.check.RuleProperty propertyAnnotation =
        field.getAnnotation(org.sonar.check.RuleProperty.class);
    if (propertyAnnotation != null) {
      String fieldKey = StringUtils.defaultIfEmpty(propertyAnnotation.key(), field.getName());
      RuleParam param = rule.createParameter(fieldKey);
      param.setDescription(propertyAnnotation.description());
      param.setDefaultValue(propertyAnnotation.defaultValue());
      if (!StringUtils.isBlank(propertyAnnotation.type())) {
        try {
          param.setType(PropertyType.valueOf(propertyAnnotation.type().trim()).name());
        } catch (IllegalArgumentException e) {
          throw new SonarException("Invalid property type [" + propertyAnnotation.type() + "]", e);
        }
      } else {
        param.setType(guessType(field.getType()).name());
      }
    }
  }

  private static final Function<Class<?>, PropertyType> TYPE_FOR_CLASS =
      Functions.forMap(
          ImmutableMap.<Class<?>, PropertyType>builder()
              .put(Integer.class, PropertyType.INTEGER)
              .put(int.class, PropertyType.INTEGER)
              .put(Float.class, PropertyType.FLOAT)
              .put(float.class, PropertyType.FLOAT)
              .put(Boolean.class, PropertyType.BOOLEAN)
              .put(boolean.class, PropertyType.BOOLEAN)
              .build(),
          PropertyType.STRING);

  @VisibleForTesting
  static PropertyType guessType(Class<?> type) {
    return TYPE_FOR_CLASS.apply(type);
  }
}
 private boolean isBackgroundValueLessThanMinimumValueForCircle(
     final IGenericTraitCollection traitCollection, CircleType type) {
   return Functions.forMap(typesByMinimumValue, 0).apply(type)
       > getBackgroundValue(traitCollection);
 }
 private List<OUTCOME_TYPE> getTopOutcomes(Map<OUTCOME_TYPE, Double> scoredOutcomes) {
   // get just the outcomes that fit within the stack
   Ordering<OUTCOME_TYPE> ordering =
       Ordering.natural().onResultOf(Functions.forMap(scoredOutcomes));
   return ordering.greatestOf(scoredOutcomes.keySet(), this.stackSize);
 }
Exemple #21
0
 /**
  * Wraps {@link Functions#forMap(Map, Object)}; returns a function that looks up its argument in a
  * map, using the given default value if the map does not contain that key.
  */
 public static <K, V> Function<K, V> lookup(Map<K, ? extends V> map, V defaultValue) {
   return Functions.forMap(map, defaultValue);
 }
Exemple #22
0
 /**
  * Wraps {@link Functions#forMap(Map)}; returns a function that looks up its argument in a map.
  */
 public static <K, V> Function<K, V> lookup(Map<K, V> map) {
   return Functions.forMap(map);
 }