request.setAttribute(Constants.FIELD_LOGS, fieldLogMap);
                }
            });
        }
    }

    /**
     * Adds function score configuration to the query builder.
     * @param functionScoreQuery Consumer that configures the function score filters.
     */
    public void addFunctionScore(final Consumer<List<FilterFunctionBuilder>> functionScoreQuery) {

import java.util.Comparator;
import java.util.Iterator;
import java.util.NoSuchElementException;
import java.util.Objects;
import java.util.Set;
import java.util.function.Function;
import java.util.function.Supplier;
import java.util.function.ToIntFunction;
import java.util.stream.Collector;
import org.jspecify.annotations.Nullable;

/**

   *
   * @throws NullPointerException if the function returns {@code null}
   * @since 12.0
   */
  public abstract <V> Optional<V> transform(Function<? super T, V> function);

  /**
   * Returns {@code true} if {@code object} is an {@code Optional} instance, and either the
   * contained references are {@linkplain Object#equals equal} to each other or both are absent.

# `UploadFile` class

You can define *path operation function* parameters to be of the type `UploadFile` to receive files from the request.

You can import it directly from `fastapi`:

```python
from fastapi import UploadFile
```

::: fastapi.UploadFile
    options:
        members:
            - file
            - filename
            - size
            - headers
            - content_type
            - read

                        </ol>
                    </div>
                </div>
            </div>
        </div>
        <section class="content">
            <div class="row">
                <div class="col-md-12">
                    <div class="card card-outline card-primary">
                        <div class="card-header">

            return path.substring(1).toLowerCase();
        }

        @Override
        public String fromClassNameToSuffix(String className) {
            if (className.endsWith("Action")) {
                return "Action";
            } else if (className.endsWith("Form")) {
                return "Form";
            } else if (className.endsWith("Assist")) {
                return "Assist";
            }

"This implementation" means the copyrightable works distributed by
Google as part of the Go project.

Google hereby grants to You a perpetual, worldwide, non-exclusive,
no-charge, royalty-free, irrevocable (except as stated in this section)
patent license to make, have made, use, offer to sell, sell, import,
transfer and otherwise run, modify and propagate the contents of this
implementation of Go, where such license applies only to those patent

            .put(5, "Pinky")
            .put(5, "Clyde")
            .build();

    List<String> badGuys = Arrays.asList("Inky", "Blinky", "Pinky", "Pinky", "Clyde");
    Function<String, Integer> stringLengthFunction =
        new Function<String, Integer>() {
          @Override
          public Integer apply(String input) {
            return input.length();
          }
        };

        }

        val taskPath = event.descriptor.taskPath
        if (shouldInclude(taskPath)) {
            action(taskPath, event.result)
        }
    }

    protected open fun shouldInclude(taskPath: String): Boolean = parameters.monitoredTaskPaths.get().contains(taskPath)

    abstract fun action(taskPath: String, taskResult: TaskOperationResult)

  @SuppressWarnings("Immutable") // array not modified after creation
  final HashFunction[] functions;

  AbstractCompositeHashFunction(HashFunction... functions) {
    for (HashFunction function : functions) {
      checkNotNull(function);
    }
    this.functions = functions;
  }

  /**
   * Constructs a {@code HashCode} from the {@code Hasher} objects of the functions. Each of them