*
   * <p>The returned array will be "safe" in that no references to it are maintained by this queue.
   * (In other words, this method must allocate a new array). The caller is thus free to modify the
   * returned array.
   *
   * <p>This method acts as bridge between array-based and collection-based APIs.
   *
   * @return an array containing all of the elements in this queue
   */

            }

        }
    }

    /**
     * Use a exclusive connection for this tree
     *
     * If an exclusive connection is used the caller must make sure that the tree handle is kept alive,
     * otherwise the connection will be disconnected once the usage drops to zero.
     *
     * @param np
     *            whether to use an exclusive connection

	wg           sync.WaitGroup
	streamErr    error
	blockEntries int
}

// newMetacacheBlockWriter provides a streaming block writer.
// Each block is the size of the capacity of the input channel.
// The caller should close to indicate the stream has ended.
func newMetacacheBlockWriter(in <-chan metaCacheEntry, nextBlock func(b *metacacheBlock) error) *metacacheBlockWriter {
	w := metacacheBlockWriter{blockEntries: cap(in)}
	w.wg.Add(1)

     * notification has been lost. (This is in contrast to how we can poll with, say, a
     * CountDownLatch.) In order to avoid hiding the requested notification from the caller, we need
     * to return. Fortunately, a wait on a Condition is allowed to return early on account of a
     * "spurious wakeup," so we're allowed to convert interruptions into such wakeups.
     */

    /*

```

</details>

## Was ist ein Container { #what-is-a-container }

Container (hauptsächlich Linux-Container) sind eine sehr **leichtgewichtige** Möglichkeit, Anwendungen einschließlich aller ihrer Abhängigkeiten und erforderlichen Dateien zu verpacken und sie gleichzeitig von anderen Containern (anderen Anwendungen oder Komponenten) im selben System isoliert zu halten.

      a) it must be made available under this Agreement; and

b) a copy of this Agreement must be included with each copy of the Program.

Contributors may not remove or alter any copyright notices contained within
the Program.

Each Contributor must identify itself as the originator of its Contribution,
if any, in a manner that reasonably allows subsequent Recipients to identify

    }

    @Override
    public @Nullable E getNext() {
      return null;
    }
  }

  /** Marker interface for {@link InternalEntry} implementations for strong values. */
  interface StrongValueEntry<K, V, E extends InternalEntry<K, V, E>>
      extends InternalEntry<K, V, E> {}

  /** Marker interface for {@link InternalEntry} implementations for weak values. */

        }
        if (list.size() >= 2) {
            String msg = "The size of selected list is over 1: " + list.size();
            throw new FetchingOverSafetySizeException(msg, 1); // immediately caught by caller and translated
        }
        return list.get(0);
    }

    @Override
    protected <RESULT extends ENTITY> List<RESULT> delegateSelectList(final ConditionBean cb, final Class<? extends RESULT> entityType) {

   * specified by the {@code Multimap} implementation, actions will be performed in the order of
   * iteration of {@link #entries()}. Exceptions thrown by the action are relayed to the caller.
   *
   * <p>To loop over all keys and their associated value collections, write {@code
   * Multimaps.asMap(multimap).forEach((key, valueCollection) -> action())}.
   *
   * @since 21.0
   */

        // Write FileFsFullSizeInformation data (32 bytes)
        SMBUtil.writeInt8(1000000, buffer, 20); // Total allocation units
        SMBUtil.writeInt8(500000, buffer, 28); // Caller available units
        SMBUtil.writeInt8(600000, buffer, 36); // Actual available units
        SMBUtil.writeInt4(512, buffer, 44); // Sectors per unit
        SMBUtil.writeInt4(4096, buffer, 48); // Bytes per sector