*
 * <p>You can create an immutable copy of an existing {@code Graph} using {@link
 * ImmutableGraph#copyOf(Graph)}:
 *
 * <pre>{@code
 * ImmutableGraph<Integer> immutableGraph = ImmutableGraph.copyOf(graph);
 * }</pre>
 *
 * <p>Instances of {@link ImmutableGraph} do not implement {@link MutableGraph} (obviously!) and are

 * ImmutableNetwork}.
 *
 * <p>You can create an immutable copy of an existing {@code Network} using {@link
 * ImmutableNetwork#copyOf(Network)}:
 *
 * <pre>{@code
 * ImmutableNetwork<Integer, MyEdge> immutableGraph = ImmutableNetwork.copyOf(network);
 * }</pre>
 *
 * <p>Instances of {@link ImmutableNetwork} do not implement {@link MutableNetwork} (obviously!) and

              @Override
              public Set<AnEnum> create(AnEnum[] elements) {
                return (elements.length == 0)
                    ? EnumSet.noneOf(AnEnum.class)
                    : EnumSet.copyOf(MinimalCollection.of(elements));
              }
            })
        .named("EnumSet")
        .withFeatures(
            SetFeature.GENERAL_PURPOSE,
            CollectionFeature.SERIALIZABLE,

                    OutputStream err) {
                this.command = requireNonNull(command, "command");
                this.commandName = requireNonNull(commandName, "commandName");
                this.args = List.copyOf(requireNonNull(args, "args"));
                this.logger = requireNonNull(logger, "logger");
                this.messageBuilderFactory = requireNonNull(messageBuilderFactory, "messageBuilderFactory");

        }
    }

    @Override
    public Object clone() {
        final ArrayMap<K, V> copy = new ArrayMap<>();
        copy.threshold = threshold;
        copy.mapTable = Arrays.copyOf(mapTable, size);
        copy.listTable = Arrays.copyOf(listTable, size);
        copy.size = size;
        return copy;
    }

    /**
     * エントリのインデックスを返します。
     *
     * @param entry
     *            エントリ

                  @Override
                  protected Multiset<String> create(String[] elements) {
                    return new StandardImplForwardingMultiset<>(ImmutableMultiset.copyOf(elements));
                  }
                })
            .named("ForwardingMultiset[ImmutableMultiset] with standard " + "implementations")

   * @throws ClassCastException if any value is not an instance of the type specified by its key
   */
  public static <B, S extends B> ImmutableClassToInstanceMap<B> copyOf(
      Map<? extends Class<? extends S>, ? extends S> map) {
    if (map instanceof ImmutableClassToInstanceMap) {
      @SuppressWarnings("rawtypes") // JDT-based J2KT Java frontend does not permit the direct cast

        MessageDigest mac = Crypto.getHMACT64(sk);
        int seq = SMBUtil.readInt4(mic, 12);
        mac.update(mic, 12, 4); // sequence
        byte[] dgst = mac.digest(data); // data
        byte[] trunc = Arrays.copyOf(dgst, 8);

        if ( log.isDebugEnabled() ) {
            log.debug("Digest " + Hexdump.toHexString(dgst));
            log.debug("Truncated " + Hexdump.toHexString(trunc));
        }

    // would cause one to be evicted.
    return new CacheBuilderFactory()
        .withKeyStrengths(ImmutableSet.of(Strength.STRONG, Strength.WEAK))
        .withValueStrengths(ImmutableSet.copyOf(Strength.values()))
        .withConcurrencyLevels(ImmutableSet.of(1, 4, 16, 64))
        .withMaximumSizes(ImmutableSet.of(400, 1000))
        .withInitialCapacities(ImmutableSet.of(0, 1, 10, 100, 1000))

      this.bytes = initialBytes.clone();
    }

    @Override
    public InputStream openStream() {
      return new In();
    }

    public void append(byte[] b) {
      byte[] newBytes = Arrays.copyOf(bytes, bytes.length + b.length);
      System.arraycopy(b, 0, newBytes, bytes.length, b.length);
      bytes = newBytes;
    }

    private class In extends InputStream {
      private int pos;