示例#1
1
 @Override
 public AbstractDate plus(long amountToAdd, TemporalUnit unit) {
   if (unit instanceof ChronoUnit) {
     ChronoUnit f = (ChronoUnit) unit;
     switch (f) {
       case DAYS:
         return plusDays(amountToAdd);
       case WEEKS:
         return plusWeeks(amountToAdd);
       case MONTHS:
         return plusMonths(amountToAdd);
       case YEARS:
         return plusYears(amountToAdd);
       case DECADES:
         return plusYears(Math.multiplyExact(amountToAdd, 10));
       case CENTURIES:
         return plusYears(Math.multiplyExact(amountToAdd, 100));
       case MILLENNIA:
         return plusYears(Math.multiplyExact(amountToAdd, 1000));
       case ERAS:
         return with(ERA, Math.addExact(getLong(ERA), amountToAdd));
       default:
         break;
     }
     throw new UnsupportedTemporalTypeException("Unsupported unit: " + unit);
   }
   return unit.addTo(this, amountToAdd);
 }
示例#2
0
 // -------------------------------------------------------------------------
 long until(AbstractDate end, TemporalUnit unit) {
   if (unit instanceof ChronoUnit) {
     switch ((ChronoUnit) unit) {
       case DAYS:
         return daysUntil(end);
       case WEEKS:
         return weeksUntil(end);
       case MONTHS:
         return monthsUntil(end);
       case YEARS:
         return monthsUntil(end) / lengthOfYearInMonths();
       case DECADES:
         return monthsUntil(end) / (lengthOfYearInMonths() * 10);
       case CENTURIES:
         return monthsUntil(end) / (lengthOfYearInMonths() * 100);
       case MILLENNIA:
         return monthsUntil(end) / (lengthOfYearInMonths() * 1000);
       case ERAS:
         return end.getLong(ERA) - getLong(ERA);
       default:
         break;
     }
     throw new UnsupportedTemporalTypeException("Unsupported unit: " + unit);
   }
   return unit.between(this, end);
 }
示例#3
0
  @Override
  public boolean equals(Object o) {
    if (!(o instanceof EveryAST)) {
      return false;
    }

    EveryAST oe = (EveryAST) o;
    return value.equals(oe.value) && unit.equals(oe.unit);
  }
示例#4
0
 /**
  * Gets the value of the requested unit.
  *
  * <p>This returns a value for each of the three supported units, {@link ChronoUnit#YEARS YEARS},
  * {@link ChronoUnit#MONTHS MONTHS} and {@link ChronoUnit#DAYS DAYS}. All other units throw an
  * exception.
  *
  * @param unit the {@code TemporalUnit} for which to return the value
  * @return the long value of the unit
  * @throws DateTimeException if the unit is not supported
  */
 @Override
 public long get(TemporalUnit unit) {
   if (unit == ChronoUnit.YEARS) {
     return getYears();
   } else if (unit == ChronoUnit.MONTHS) {
     return getMonths();
   } else if (unit == ChronoUnit.DAYS) {
     return getDays();
   } else {
     throw new DateTimeException("Unsupported unit: " + unit.getName());
   }
 }
示例#5
0
  public ReceivedResponse request(URI uri, Duration duration, Action<? super RequestSpec> action)
      throws Throwable {
    CountDownLatch latch = new CountDownLatch(1);
    AtomicReference<ExecResult<ReceivedResponse>> result = new AtomicReference<>();

    try (ExecController execController = new DefaultExecController(2)) {
      execController
          .fork()
          .onComplete(e -> {})
          .start(
              e -> {
                HttpClient.httpClient(UnpooledByteBufAllocator.DEFAULT, Integer.MAX_VALUE)
                    .request(uri, action.prepend(s -> s.readTimeout(Duration.ofHours(1))))
                    .map(
                        response -> {
                          TypedData responseBody = response.getBody();
                          ByteBuf responseBodyBuffer = responseBody.getBuffer();
                          responseBodyBuffer =
                              Unpooled.unreleasableBuffer(responseBodyBuffer.retain());

                          return new DefaultReceivedResponse(
                              response.getStatus(),
                              response.getHeaders(),
                              new ByteBufBackedTypedData(
                                  responseBodyBuffer, responseBody.getContentType()));
                        })
                    .connect(
                        new Downstream<DefaultReceivedResponse>() {
                          @Override
                          public void success(DefaultReceivedResponse value) {
                            result.set(ExecResult.of(Result.success(value)));
                            latch.countDown();
                          }

                          @Override
                          public void error(Throwable throwable) {
                            result.set(ExecResult.of(Result.error(throwable)));
                            latch.countDown();
                          }

                          @Override
                          public void complete() {
                            result.set(ExecResult.complete());
                            latch.countDown();
                          }
                        });
              });

      try {
        if (!latch.await(duration.toNanos(), TimeUnit.NANOSECONDS)) {
          TemporalUnit unit = duration.getUnits().get(0);
          throw new IllegalStateException(
              "Request to "
                  + uri
                  + " took more than "
                  + duration.get(unit)
                  + " "
                  + unit.toString()
                  + " to complete");
        }
      } catch (InterruptedException e) {
        throw Exceptions.uncheck(e);
      }

      return result.get().getValueOrThrow();
    }
  }