}

  @Override
  public int size() {
    return Ints.saturatedCast(size);
  }

  @Override
  public int count(@Nullable Object element) {
    // isActuallyE checks for null, but we check explicitly to help nullness checkers.
    if (element == null || !isActuallyE(element)) {
      return 0;
    }
    Enum<?> e = (Enum<?>) element;
    return counts[e.ordinal()];
  }

  // Modification Operations

     * perform runtime null checks on the input and output. (That would also make NullPointerTester
     * happy!) However, since we didn't do that for many years, we're not about to start now.
     * (Runtime checks could be particularly bad for users of LegacyConverter.)
     *
     * Luckily, our nullness checker is smart enough to realize that `convert` has @PolyNull-like

     * that users *can* pass null arguments to Joiner, we annotate it as if it always tolerates null
     * inputs, rather than as if it never tolerates them.
     *
     * We rely on checkers to implement special cases to catch dangerous calls to join(), etc. based
     * on what they know about the particular Joiner instances the calls are performed on.
     *

     * that users *can* pass null arguments to Joiner, we annotate it as if it always tolerates null
     * inputs, rather than as if it never tolerates them.
     *
     * We rely on checkers to implement special cases to catch dangerous calls to join(), etc. based
     * on what they know about the particular Joiner instances the calls are performed on.
     *

But you might want to still keep the return type annotation in the function to get the support from tools like editors and type checkers (e.g. mypy).

In this case, you can disable the response model generation by setting `response_model=None`:

{* ../../docs_src/response_model/tutorial003_05_py310.py hl[7] *}

ffgan <******@****.***> 1749399125 +0800

## Use the instance as a dependency { #use-the-instance-as-a-dependency }

Then, we could use this `checker` in a `Depends(checker)`, instead of `Depends(FixedContentQueryChecker)`, because the dependency is the instance, `checker`, not the class itself.

And when solving the dependency, **FastAPI** will call this `checker` like:

```Python
checker(q="somequery")
```

        throw new UnsupportedOperationException("checkUserLoginable is not supported.");
    }

    /**
     * Checks the credential using the provided credential checker.
     * This method is not supported in the Fess implementation.
     *
     * @param checker the credential checker to use
     * @throws UnsupportedOperationException always thrown as this method is not supported
     */
    @Override

 *   {@literal @Override} public int hashCode() {...}
 *   ...
 * }
 * </pre>
 *
 * <p>No cascading checks are performed against the return values of methods unless the method is a
 * static factory method. Neither are semantics of mutation methods such as {@code
 * someList.add(obj)} checked. For more detailed discussion of supported and unsupported cases, see
 * {@link #testEquals}, {@link #testNulls} and {@link #testSerializable}.

        This structured process helps ensure translations can be properly maintained long-term.
  - type: checkboxes
    id: checks
    attributes:
      label: Initial Checks
      description: Please confirm and check all the following options.
      options:
        - label: I checked that this language is not already being translated in FastAPI docs.
          required: true