public static <T extends Comparable<? super T>> TopKSelector<T> least(int k) {
    return least(k, Ordering.natural());
  }

  /**
   * Returns a {@code TopKSelector} that collects the lowest {@code k} elements added to it,
   * relative to the specified comparator, and returns them via {@link #topK} in ascending order.
   *
   * @throws IllegalArgumentException if {@code k < 0} or {@code k > Integer.MAX_VALUE / 2}
   */

  public ImmutableList<E> asList() {
    ImmutableList<E> list = asList;
    return (list == null) ? (asList = createAsList()) : list;
  }

  ImmutableList<E> createAsList() {
    switch (size()) {
      case 0:
        return ImmutableList.of();
      case 1:
        return ImmutableList.of(iterator().next());
      default:
        return new RegularImmutableAsList<E>(this, toArray());
    }
  }

  /**
   * Returns x rounded to either the greatest double less than or equal to the precise value of x,
   * or the least double greater than or equal to the precise value of x.
   */
  abstract double roundToDoubleArbitrarily(X x);

  /** Returns the sign of x: either -1, 0, or 1. */
  abstract int sign(X x);

  /** Returns d's value as an X, rounded with the specified mode. */

  /**
   * Returns an empty {@code ImmutableClassToInstanceMap}.
   *
   * <p><b>Performance note:</b> the instance returned is a singleton.
   *
   * @since 19.0
   */
  @SuppressWarnings("unchecked")
  public static <B> ImmutableClassToInstanceMap<B> of() {
    return (ImmutableClassToInstanceMap<B>) EMPTY;
  }

  /**

            return allRecordCount;
        }

        /**
         * Returns the page size (number of records per page).
         *
         * @return the page size
         */
        public int getPageSize() {
            return pageSize;
        }

        /**
         * Returns the current page number (1-based).
         *
         * @return the current page number
         */

		// Upon error just return Go-syntax representation of the value
		return fmt.Sprintf("%#v", req)
	}

	// Formatted string.
	return strings.TrimSpace(buffer.String())
}

// isFile - returns whether given path is a file or not.
func isFile(path string) bool {
	if fi, err := os.Stat(path); err == nil {
		return fi.Mode().IsRegular()
	}

	return false
}

  SortedSet<E> create(Object... elements);

  /**
   * Returns an element less than the {@link #samples()} and less than {@link
   * #belowSamplesGreater()}.
   */
  E belowSamplesLesser();

  /**
   * Returns an element less than the {@link #samples()} but greater than {@link
   * #belowSamplesLesser()}.
   */
  E belowSamplesGreater();

  /**
   * Returns an element greater than the {@link #samples()} but less than {@link

  SortedSet<E> create(Object... elements);

  /**
   * Returns an element less than the {@link #samples()} and less than {@link
   * #belowSamplesGreater()}.
   */
  E belowSamplesLesser();

  /**
   * Returns an element less than the {@link #samples()} but greater than {@link
   * #belowSamplesLesser()}.
   */
  E belowSamplesGreater();

  /**
   * Returns an element greater than the {@link #samples()} but less than {@link

        return getMimeType(extension, "application/octet-stream");
    }

    /**
     * Returns the MIME type for the given file extension with a custom default.
     *
     * @param extension the file extension to look up (without the dot)
     * @param def the default MIME type to return if no mapping is found
     * @return the MIME type for the extension, or the specified default if not found

        fq = filterQueryString;
    }

    /**
     * Returns the query string.
     * @return The query string.
     */
    public String getQueryString() {
        return q;
    }

    /**
     * Returns the filter query string.
     * @return The filter query string.
     */
    public String getFilterQueryString() {
        return fq;
    }