Exemplo n.º 1
0
  public void testImmutableSortedCopy() {
    ImmutableList<Integer> unsortedInts = ImmutableList.of(5, 3, 0, 9, 3);
    ImmutableList<Integer> sortedInts = numberOrdering.immutableSortedCopy(unsortedInts);
    assertEquals(Arrays.asList(0, 3, 3, 5, 9), sortedInts);

    assertEquals(
        Collections.<Integer>emptyList(),
        numberOrdering.immutableSortedCopy(Collections.<Integer>emptyList()));

    List<Integer> listWithNull = Arrays.asList(5, 3, null, 9);
    try {
      Ordering.natural().nullsFirst().immutableSortedCopy(listWithNull);
      fail();
    } catch (NullPointerException expected) {
    }
  }
Exemplo n.º 2
0
 @GET("/backend/config/alerts")
 String getAlertList() throws JsonProcessingException {
   List<AlertConfigDto> alertConfigDtos = Lists.newArrayList();
   List<AlertConfig> alertConfigs = configRepository.getAlertConfigs();
   alertConfigs = orderingByName.immutableSortedCopy(alertConfigs);
   for (AlertConfig alertConfig : alertConfigs) {
     alertConfigDtos.add(AlertConfigDto.fromConfig(alertConfig));
   }
   return mapper.writeValueAsString(alertConfigDtos);
 }
Exemplo n.º 3
0
    void testSortedCopy() {
      List<T> shuffledList = Lists.newArrayList(strictlyOrderedList);
      shuffledList = shuffledCopy(shuffledList, new Random(5));

      assertEquals(strictlyOrderedList, ordering.sortedCopy(shuffledList));

      if (!strictlyOrderedList.contains(null)) {
        assertEquals(strictlyOrderedList, ordering.immutableSortedCopy(shuffledList));
      }
    }
Exemplo n.º 4
0
    @Override
    public Optional<ImmutableSet<PreemptionVictim>> filterPreemptionVictims(
        ITaskConfig pendingTask,
        Iterable<PreemptionVictim> possibleVictims,
        AttributeAggregate jobState,
        Optional<HostOffer> offer,
        StoreProvider storeProvider) {

      // This enforces the precondition that all of the resources are from the same host. We need to
      // get the host for the schedulingFilter.
      Set<String> hosts =
          ImmutableSet.<String>builder()
              .addAll(Iterables.transform(possibleVictims, VICTIM_TO_HOST))
              .addAll(Iterables.transform(offer.asSet(), OFFER_TO_HOST))
              .build();

      ResourceSlot slackResources = sum(Iterables.transform(offer.asSet(), OFFER_TO_RESOURCE_SLOT));

      FluentIterable<PreemptionVictim> preemptableTasks =
          FluentIterable.from(possibleVictims).filter(preemptionFilter(pendingTask));

      if (preemptableTasks.isEmpty()) {
        return Optional.absent();
      }

      Set<PreemptionVictim> toPreemptTasks = Sets.newHashSet();

      Iterable<PreemptionVictim> sortedVictims =
          resourceOrder.immutableSortedCopy(preemptableTasks);

      Optional<IHostAttributes> attributes =
          storeProvider.getAttributeStore().getHostAttributes(Iterables.getOnlyElement(hosts));

      if (!attributes.isPresent()) {
        metrics.recordMissingAttributes();
        return Optional.absent();
      }

      for (PreemptionVictim victim : sortedVictims) {
        toPreemptTasks.add(victim);

        ResourceSlot totalResource =
            sum(Iterables.transform(toPreemptTasks, victimToResources)).add(slackResources);

        Set<Veto> vetoes =
            schedulingFilter.filter(
                new UnusedResource(totalResource, attributes.get()),
                new ResourceRequest(pendingTask, jobState));

        if (vetoes.isEmpty()) {
          return Optional.of(ImmutableSet.copyOf(toPreemptTasks));
        }
      }
      return Optional.absent();
    }
Exemplo n.º 5
0
  public void testAllEqual() {
    Ordering<Object> comparator = Ordering.allEqual();
    assertSame(comparator, comparator.reverse());

    assertEquals(comparator.compare(null, null), 0);
    assertEquals(comparator.compare(new Object(), new Object()), 0);
    assertEquals(comparator.compare("apples", "oranges"), 0);
    assertSame(comparator, reserialize(comparator));
    assertEquals("Ordering.allEqual()", comparator.toString());

    List<String> strings = ImmutableList.of("b", "a", "d", "c");
    assertEquals(strings, comparator.sortedCopy(strings));
    assertEquals(strings, comparator.immutableSortedCopy(strings));
  }
Exemplo n.º 6
0
 public HashLine(char[] buffer, PathFragment defaultPath) {
   CharSequence bufString = CharBuffer.wrap(buffer);
   Matcher m = pattern.matcher(bufString);
   List<SingleHashLine> unorderedTable = new ArrayList<>();
   Map<String, PathFragment> pathCache = new HashMap<>();
   while (m.find()) {
     String pathString = m.group(2);
     PathFragment pathFragment = pathCache.get(pathString);
     if (pathFragment == null) {
       pathFragment = defaultPath.getRelative(pathString);
       pathCache.put(pathString, pathFragment);
     }
     unorderedTable.add(
         new SingleHashLine(
             m.start(0) + 1, // offset (+1 to skip \n in pattern)
             Integer.parseInt(m.group(1)), // line number
             pathFragment)); // filename is an absolute path
   }
   this.table = hashOrdering.immutableSortedCopy(unorderedTable);
   this.bufferLength = buffer.length;
   this.defaultPath = Preconditions.checkNotNull(defaultPath);
 }
Exemplo n.º 7
0
  /**
   * Generate a similarity matrix from a given set of submissions.
   *
   * @param inputSubmissions Submissions to generate from
   * @param results Results to build from. Must contain results for every possible unordered pair of
   *     input submissions
   * @return Similarity Matrix built from given results
   * @throws InternalAlgorithmError Thrown on missing results, or results containing a submission
   *     not in the input
   */
  public static SimilarityMatrix generateMatrix(
      Set<Submission> inputSubmissions, Set<AlgorithmResults> results)
      throws InternalAlgorithmError {
    checkNotNull(inputSubmissions);
    checkNotNull(results);
    checkArgument(
        !inputSubmissions.isEmpty(), "Must provide at least 1 submission to build matrix from");
    checkArgument(
        !results.isEmpty(), "Must provide at least 1 AlgorithmResults to build matrix from!");

    // Generate the matrix we'll use
    AlgorithmResults[][] matrix =
        new AlgorithmResults[inputSubmissions.size()][inputSubmissions.size()];

    // Ordering sortBy = Ordering.natural();
    Ordering<Submission> sortBy =
        Ordering.from(
            new Comparator<Submission>() {
              public int compare(Submission a, Submission b) {
                return ((Double) b.getTotalCopyScore()).compareTo(a.getTotalCopyScore());
              }
            });

    // Order the submissions
    List<Submission> orderedSubmissions = sortBy.immutableSortedCopy(inputSubmissions);

    // Generate the matrix

    // Start with the diagonal, filling with 100% similarity
    for (int i = 0; i < orderedSubmissions.size(); i++) {
      Submission s = orderedSubmissions.get(i);

      matrix[i][i] = new AlgorithmResults(Pair.of(s, s), Real.ONE, Real.ONE);
    }

    // Now go through all the results, and build appropriate two MatrixEntry objects for each
    for (AlgorithmResults result : results) {
      int aIndex = orderedSubmissions.indexOf(result.a);
      int bIndex = orderedSubmissions.indexOf(result.b);

      if (aIndex == -1) {
        if (!result.a.testFlag("invalid")) {
          throw new InternalAlgorithmError(
              "Processed Algorithm Result with submission not in given input submissions with name \""
                  + result.a.getName()
                  + "\"");
        }
      } else if (bIndex == -1) {
        if (!result.b.testFlag("invalid")) {
          throw new InternalAlgorithmError(
              "Processed Algorithm Result with submission not in given input submissions with name \""
                  + result.b.getName()
                  + "\"");
        }
      } else {
        matrix[aIndex][bIndex] = result.inverse();
        matrix[bIndex][aIndex] = result;
      }
    }

    // Verification pass: Go through and ensure that the entire array was populated
    for (int x = 0; x < orderedSubmissions.size(); x++) {
      for (int y = 0; y < orderedSubmissions.size(); y++) {
        if (matrix[x][y] == null) {
          throw new InternalAlgorithmError(
              "Missing Algorithm Results for comparison of submissions \""
                  + orderedSubmissions.get(x).getName()
                  + "\" and \""
                  + orderedSubmissions.get(y).getName()
                  + "\"");
        }
      }
    }

    return new SimilarityMatrix(matrix, orderedSubmissions, orderedSubmissions, results);
  }
Exemplo n.º 8
0
  // Used in bulk get API (getAccountPayments)
  private Payment toPayment(
      final PaymentModelDao curPaymentModelDao,
      final Iterable<PaymentTransactionModelDao> curTransactionsModelDao,
      @Nullable final Iterable<PaymentTransactionInfoPlugin> pluginTransactions,
      final InternalTenantContext internalTenantContext) {
    final Ordering<PaymentTransaction> perPaymentTransactionOrdering =
        Ordering.<PaymentTransaction>from(
            new Comparator<PaymentTransaction>() {
              @Override
              public int compare(final PaymentTransaction o1, final PaymentTransaction o2) {
                return o1.getEffectiveDate().compareTo(o2.getEffectiveDate());
              }
            });

    // Need to filter for optimized codepaths looking up by account_record_id
    final Iterable<PaymentTransactionModelDao> filteredTransactions =
        Iterables.filter(
            curTransactionsModelDao,
            new Predicate<PaymentTransactionModelDao>() {
              @Override
              public boolean apply(final PaymentTransactionModelDao curPaymentTransactionModelDao) {
                return curPaymentTransactionModelDao
                    .getPaymentId()
                    .equals(curPaymentModelDao.getId());
              }
            });

    PaymentModelDao newPaymentModelDao = curPaymentModelDao;
    final Collection<PaymentTransaction> transactions = new LinkedList<PaymentTransaction>();
    for (final PaymentTransactionModelDao curPaymentTransactionModelDao : filteredTransactions) {
      PaymentTransactionModelDao newPaymentTransactionModelDao = curPaymentTransactionModelDao;

      final PaymentTransactionInfoPlugin paymentTransactionInfoPlugin =
          findPaymentTransactionInfoPlugin(newPaymentTransactionModelDao, pluginTransactions);
      if (paymentTransactionInfoPlugin != null) {
        // Make sure to invoke the Janitor task in case the plugin fixes its state on the fly
        // See https://github.com/killbill/killbill/issues/341
        final boolean hasChanged =
            incompletePaymentTransactionTask.updatePaymentAndTransactionIfNeededWithAccountLock(
                newPaymentModelDao,
                newPaymentTransactionModelDao,
                paymentTransactionInfoPlugin,
                internalTenantContext);
        if (hasChanged) {
          newPaymentModelDao =
              paymentDao.getPayment(newPaymentModelDao.getId(), internalTenantContext);
          newPaymentTransactionModelDao =
              paymentDao.getPaymentTransaction(
                  newPaymentTransactionModelDao.getId(), internalTenantContext);
        }
      }

      final PaymentTransaction transaction =
          new DefaultPaymentTransaction(
              newPaymentTransactionModelDao.getId(),
              newPaymentTransactionModelDao.getAttemptId(),
              newPaymentTransactionModelDao.getTransactionExternalKey(),
              newPaymentTransactionModelDao.getCreatedDate(),
              newPaymentTransactionModelDao.getUpdatedDate(),
              newPaymentTransactionModelDao.getPaymentId(),
              newPaymentTransactionModelDao.getTransactionType(),
              newPaymentTransactionModelDao.getEffectiveDate(),
              newPaymentTransactionModelDao.getTransactionStatus(),
              newPaymentTransactionModelDao.getAmount(),
              newPaymentTransactionModelDao.getCurrency(),
              newPaymentTransactionModelDao.getProcessedAmount(),
              newPaymentTransactionModelDao.getProcessedCurrency(),
              newPaymentTransactionModelDao.getGatewayErrorCode(),
              newPaymentTransactionModelDao.getGatewayErrorMsg(),
              paymentTransactionInfoPlugin);
      transactions.add(transaction);
    }

    final List<PaymentTransaction> sortedTransactions =
        perPaymentTransactionOrdering.immutableSortedCopy(transactions);
    return new DefaultPayment(
        curPaymentModelDao.getId(),
        curPaymentModelDao.getCreatedDate(),
        curPaymentModelDao.getUpdatedDate(),
        curPaymentModelDao.getAccountId(),
        curPaymentModelDao.getPaymentMethodId(),
        curPaymentModelDao.getPaymentNumber(),
        curPaymentModelDao.getExternalKey(),
        sortedTransactions);
  }
Exemplo n.º 9
0
 final List<MeasureFilterRow> sort(List<MeasureFilterRow> rows, boolean ascending) {
   Ordering<MeasureFilterRow> ordering =
       sortFieldOrdering(ascending).onResultOf(sortFieldFunction());
   return ordering.immutableSortedCopy(rows);
 }