return new Float(((java.util.Date) o).getTime());
        } else {
            return toFloat(o.toString());
        }
    }

    private static Float toFloat(final String s) {
        if (StringUtil.isEmpty(s)) {
            return null;
        }
        return new Float(DecimalFormatUtil.normalize(s));
    }

    /**
     * {@literal float}に変換します。
     *
     * @param o
     *            変換元のオブジェクト

      collection = ((ImmutableEnumSet<?>) collection).delegate;
    }
    return delegate.containsAll(collection);
  }

  @Override
  public boolean isEmpty() {
    return delegate.isEmpty();
  }

  @Override
  public boolean equals(@CheckForNull Object object) {
    if (object == this) {
      return true;
    }
    if (object instanceof ImmutableEnumSet) {

    TopKSelector<Integer> top = TopKSelector.least(0);
    for (int i = 0; i < 10; i++) {
      top.offer(i);
    }
    assertThat(top.topK()).isEmpty();
  }

  public void testNoElementsOffered() {
    TopKSelector<Integer> top = TopKSelector.least(10);
    assertThat(top.topK()).isEmpty();
  }

  public void testOfferedFewerThanK() {
    TopKSelector<Integer> top = TopKSelector.least(10);
    top.offer(3);
    top.offer(5);

    Optional<Object> getOptional() {
      if (extras.isEmpty()) {
        return Optional.ofNullable(element);
      } else {
        throw multiples(false);
      }
    }

    Object getElement() {
      if (element == null) {
        throw new NoSuchElementException();
      } else if (extras.isEmpty()) {
        return element;
      } else {
        throw multiples(false);

            return Iterators.size(iterator());
          }

          @Override
          public boolean isEmpty() {
            return !iterator().hasNext();
          }
        };
      }

      Iterator<Entry<Range<K>, V>> entryIterator() {
        if (subRange.isEmpty()) {
          return Iterators.emptyIterator();
        }
        Cut<K> cutToStart =
            MoreObjects.firstNonNull(

    public Map<String, byte[]> getInputValueHashesBytes() {
        return getBeforeExecutionState()
            .map(ExecutionInputState::getInputProperties)
            .filter(inputValueFingerprints -> !inputValueFingerprints.isEmpty())
            .map(inputValueFingerprints -> inputValueFingerprints.entrySet().stream()
                .collect(toLinkedHashMap(valueSnapshot -> Hashing.hashHashable(valueSnapshot).toByteArray())))
            .orElse(null);

     * and their subtypes that live in the `org.gradle.` package.
     *
     * TODO: Rename to getInstrumentedSuperTypes();
     */
    Set<String> getSuperTypes(String type);

    boolean isEmpty();

    static InstrumentationTypeRegistry empty() {
        return EMPTY;
    }

    class EmptyInstrumentationTypeRegistry implements InstrumentationTypeRegistry {
        @Override

        callSiteStack.push(entryPoint);
        return entryPoint;
    }

    @Override
    public void leaveCall(EntryPointCallSite entryPoint) {
        if (callSiteStack.isEmpty()) {
            throwMismatchedLeaveCallException(entryPoint);
        }
        EntryPointCallSite top = callSiteStack.peek();
        if (top != entryPoint) {
            throwMismatchedLeaveCallException(entryPoint);

        if (versioning.getRelease() != null && !versioning.getRelease().isEmpty()) {
            merge(RELEASE, infos, versioning.getLastUpdated(), versioning.getRelease(), repository);
        }

        if (versioning.getLatest() != null && !versioning.getLatest().isEmpty()) {
            merge(LATEST, infos, versioning.getLastUpdated(), versioning.getLatest(), repository);
        }

        StringBuilder path = new StringBuilder(128);

        if (!metadata.getGroupId().isEmpty()) {
            path.append(metadata.getGroupId().replace('.', '/')).append('/');

            if (!metadata.getArtifactId().isEmpty()) {
                path.append(metadata.getArtifactId()).append('/');

                if (!metadata.getVersion().isEmpty()) {
                    path.append(metadata.getVersion()).append('/');
                }