"type": "keyword"
      },
      "expiredTime": {
        "type": "long"
      },
      "createdBy": {
        "type": "keyword"
      },
      "createdTime": {
        "type": "long"
      },
      "updatedBy": {
        "type": "keyword"
      },
      "updatedTime": {
        "type": "long"
      }
    }

@NonNullApi
public class LongFromCharSequenceNotationConverter implements NotationConverter<CharSequence, Long> {

    @Override
    public void convert(CharSequence notation, NotationConvertResult<? super Long> result) throws TypeConversionException {
        try {
            result.converted(Long.valueOf(notation.toString()));
        } catch (NumberFormatException ex) {

    private final long bytesDownloaded;

    public DefaultFileDownloadFailureResult(long startTime, long endTime, List<? extends Failure> failures, long bytesDownloaded) {
        super(startTime, endTime, failures);
        this.bytesDownloaded = bytesDownloaded;
    }

    @Override
    public long getBytesDownloaded() {
        return bytesDownloaded;
    }

        this.createdBy = value;
    }

    public Long getCreatedTime() {
        checkSpecifiedProperty("createdTime");
        return createdTime;
    }

    public void setCreatedTime(Long value) {
        registerModifiedProperty("createdTime");
        this.createdTime = value;
    }

    public Long getExpiredTime() {
        checkSpecifiedProperty("expiredTime");

        } catch (CorruptedCacheException e) {
            throw e;
        } catch (Exception e) {
            throw new UncheckedIOException(e);
        }
    }

    private long alloc(long length) {
        long pos = nextBlock;
        nextBlock += length;
        return pos;
    }

    private final class BlockImpl extends Block {

    private final long bytesDownloaded;

    public DefaultFileDownloadSuccessResult(long startTime, long endTime, long bytesDownloaded) {
        super(startTime, endTime);
        this.bytesDownloaded = bytesDownloaded;
    }

    @Override
    public long getBytesDownloaded() {
        return bytesDownloaded;
    }

   *
   * <p>Instead of throwing {@link ArithmeticException}, this method silently saturates to either
   * {@link Long#MAX_VALUE} or {@link Long#MIN_VALUE}. This behavior can be useful when decomposing
   * a duration in order to call a legacy API which requires a {@code long, TimeUnit} pair.
   */
  @SuppressWarnings({
    // We use this method only for cases in which we need to decompose to primitives.

@NonNullApi
public class DefaultAvailableOsMemoryStatusAspect implements OsMemoryStatusAspect.Available {
    private final String name;
    private final long total;
    private final long free;

    public DefaultAvailableOsMemoryStatusAspect(String name, long total, long free) {
        if (name == null) {
            throw new IllegalArgumentException("name cannot be null");
        }
        if (total < 0) {

   *     wrap(String.class) == String.class
   * </pre>
   */
  public static <T> Class<T> wrap(Class<T> type) {
    checkNotNull(type);

    // cast is safe: long.class and Long.class are both of type Class<Long>
    @SuppressWarnings("unchecked")
    Class<T> wrapped = (Class<T>) PRIMITIVE_TO_WRAPPER_TYPE.get(type);
    return (wrapped == null) ? type : wrapped;
  }

  /**

      return NeverScheduledFuture.create();
    }

    private static class NeverScheduledFuture<V> extends AbstractFuture<V>
        implements ListenableScheduledFuture<V> {

      static <V> NeverScheduledFuture<V> create() {
        return new NeverScheduledFuture<>();
      }

      @Override
      public long getDelay(TimeUnit unit) {
        return Long.MAX_VALUE;