* order. However, the table's {@code row()} method returns instances of a different class than
   * {@code factory.get()} does.
   *
   * <p>Call this method only when the simpler factory methods in classes like {@link
   * HashBasedTable} and {@link TreeBasedTable} won't suffice.
   *
   * <p>The views returned by the {@code Table} methods {@link Table#column}, {@link

        // Initialize QueryProcessor if needed
        queryProcessor = new QueryProcessor();
        queryProcessor.init();
        ComponentUtil.register(queryProcessor, "queryProcessor");

        // Call child class specific setup
        setUpChild();
    }

    /**
     * Override this method in child classes to perform additional setup
     */
    protected void setUpChild() throws Exception {

        public String escape(String string) {
          return checkNotNull(string);
        }

        @Override
        protected char @Nullable [] escape(char c) {
          // TODO: Fix tests not to call this directly and make it throw an error.
          return null;
        }
      };

  /**
   * Returns a builder for creating simple, fast escapers. A builder instance can be reused and each

 * that every {@code Runnable} that is {@linkplain #add added} will be executed after {@link
 * #execute()} is called. Any {@code Runnable} added after the call to {@code execute} is still
 * guaranteed to execute. There is no guarantee, however, that listeners will be executed in the
 * order that they are added.
 *

Der springende Punkt ist, dass eine Abhängigkeit aufrufbar („callable“) sein sollte.

Ein „**Callable**“ in Python ist etwas, das wie eine Funktion aufgerufen werden kann („to call“).

Wenn Sie also ein Objekt `something` haben (das möglicherweise _keine_ Funktion ist) und Sie es wie folgt aufrufen (ausführen) können:

```Python
something()
```

oder

```Python

	RET R30					   // c0035fd6
	RET	foo(SB)

// B/BL/B.cond cases, and canonical names JMP, CALL.
	BL	1(PC)      // CALL 1(PC)
	BL	(R2)       // CALL (R2)
	BL	foo(SB)    // CALL foo(SB)
	BL	bar<>(SB)  // CALL bar<>(SB)
	B	foo(SB)    // JMP foo(SB)
	BEQ	1(PC)
	BEQ	2(PC)
	TBZ	$1, R1, 2(PC)
	TBNZ	$2, R2, 2(PC)
	JMP	foo(SB)
	CALL	foo(SB)

// ADR
	ADR	next, R11     // ADR R11 // 2b000010
next:
	NOP

    void testSetFileInfoClassSetsCorrectInfoType() {
        request = new Smb2QueryInfoRequest(mockConfig);

        // Initially set a different info type
        request.setInfoType((byte) 0x05);

        // Call setFileInfoClass which should override info type
        request.setFileInfoClass((byte) 0x10);

        try {
            Field infoTypeField = Smb2QueryInfoRequest.class.getDeclaredField("infoType");

   * When multiple elements are equivalent according to {@code compareTo()}, only the first one
   * specified is included. To create a copy of a {@code SortedSet} that preserves the comparator,
   * call {@link #copyOfSorted} instead. This method iterates over {@code elements} at most once.
   *
   * <p>Note that if {@code s} is a {@code Set<String>}, then {@code ImmutableSortedSet.copyOf(s)}

        FessCurtainFinallyHook customHook = new FessCurtainFinallyHook() {
            @Override
            public void hook(final FwAssistantDirector assistantDirector) {
                // Use reflection to call private method
                try {
                    Method method = FessCurtainFinallyHook.class.getDeclaredMethod("shutdownCommonsHttpClient");
                    method.setAccessible(true);

   *
   * <p><b>Note:</b> The returned map's values are guaranteed to be of type {@link SortedSet}. To
   * obtain this map with the more specific generic type {@code Map<K, SortedSet<V>>}, call {@link
   * Multimaps#asMap(SortedSetMultimap)} instead. <b>However</b>, the returned map <i>itself</i> is
   * not necessarily a {@link SortedMap}: A {@code SortedSetMultimap} must expose the <i>values</i>