* Returns an immutable sorted multiset containing the given elements sorted by their natural
   * ordering.
   *
   * @throws NullPointerException if any element is null
   */
  public static <E extends Comparable<? super E>> ImmutableSortedMultiset<E> of(
      E e1, E e2, E e3, E e4) {
    return copyOf(Ordering.natural(), Arrays.asList(e1, e2, e3, e4));
  }

  /**

        item.setNewInputs(newInputs);

        // Inputs should already be sorted from constructor
        assertEquals("a", item.getInputs()[0]);

        // NewInputs not sorted yet
        assertEquals("9", item.getNewInputs()[0]);

        // Call sort
        item.sort();

        // Both should be sorted
        assertEquals("a", item.getInputs()[0]);
        assertEquals("m", item.getInputs()[1]);

      Comparator<? super E> comparator, Collection<? extends E> elements) {
    return copyOf(comparator, (Iterable<? extends E>) elements);
  }

  /**
   * Returns an immutable sorted set containing the elements of a sorted set, sorted by the same
   * {@code Comparator}. That behavior differs from {@link #copyOf(Iterable)}, which always uses the
   * natural ordering of the elements.
   *

          "woo.com.",
          "www",
          "x",
          ALMOST_TOO_LONG,
          ALMOST_TOO_MANY_LEVELS
          // keep-sorted end
          );

  private static final ImmutableSet<String> INVALID_NAME =
      ImmutableSet.of(
          // keep-sorted start
          " ",
          "",
          ".",
          "..",
          "...",
          "..bar.com",
          "..quiffle.com",

        final PrintWriter out = resp.getWriter();
        SmbFile[] dirents;
        SmbFile f;
        int i, j, len, maxLen, dirCount, fileCount, sort;
        String str, name, path, fmt;
        LinkedList<SmbFile> sorted;
        ListIterator<SmbFile> iter;
        final SimpleDateFormat sdf = new SimpleDateFormat("MM/d/yy h:mm a");
        final GregorianCalendar cal = new GregorianCalendar();

        sdf.setCalendar(cal);

		}
		if val == "" {
			canonicalQueries = append(canonicalQueries, key)
			continue
		}
		canonicalQueries = append(canonicalQueries, key+"="+val)
	}

	// The queries will be already sorted as resourceList is sorted, if canonicalQueries
	// is empty strings.Join returns empty.
	canonicalQuery := strings.Join(canonicalQueries, "&")
	if canonicalQuery != "" {
		return encodedResource + "?" + canonicalQuery
	}

        assertNotNull(result);
        // Check for sorted concatenated strings
        assertTrue("Result should contain sorted tags", result.contains("aaammmzzz"));
        assertTrue("Result should contain sorted roles", result.contains("role1role2role3"));
        assertTrue("Result should contain sorted fields", result.contains("field1field2field3"));
        assertTrue("Result should contain sorted excludes", result.contains("exclude1exclude2exclude3"));

 * quickly, since the row key is provided. However, {@code column(columnKey).size()} takes longer,
 * since an iteration across all row keys occurs.
 *
 * <p>Because a {@code TreeBasedTable} has unique sorted values for a given row, both {@code
 * row(rowKey)} and {@code rowMap().get(rowKey)} are {@link SortedMap} instances, instead of the
 * {@link Map} specified in the {@link Table} interface.
 *

  /**
   * Searches the specified list for the specified object using the binary search algorithm. The
   * list must be sorted into ascending order according to the specified comparator (as by the
   * {@link Collections#sort(List, Comparator) Collections.sort(List, Comparator)} method), prior to
   * making this call. If it is not sorted, the results are undefined.
   *

}

// sort entries by name.
// m is sorted and a sorted metadata object is returned.
// Changes to m will also be reflected in the returned object.
func (m metaCacheEntries) sort() metaCacheEntriesSorted {
	if m.isSorted() {
		return metaCacheEntriesSorted{o: m}
	}
	sort.Slice(m, m.less)
	return metaCacheEntriesSorted{o: m}
}

// isSorted returns whether the objects are sorted.