while (true) {
      var socket: Socket? = null
      try {
        socket = serverSocket.accept()
        val sslSocket = doSsl(socket)
        val protocolString = Platform.get().getSelectedProtocol(sslSocket)
        val protocol = if (protocolString != null) get(protocolString) else null
        if (protocol != Protocol.HTTP_2) {
          throw ProtocolException("Protocol $protocol unsupported")
        }
        val connection =

                List<Plugin> pending = new ArrayList<>();
                for (Plugin element : src) {
                    Object key = getPluginKey(element);
                    Plugin existing = master.get(key);
                    if (existing != null) {
                        mergePlugin(existing, element, sourceDominant, context);

                        if (!pending.isEmpty()) {

func (ssec) ParseHTTP(h http.Header) (key [32]byte, err error) {
	if h.Get(xhttp.AmzServerSideEncryptionCustomerAlgorithm) != xhttp.AmzEncryptionAES {
		return key, ErrInvalidCustomerAlgorithm
	}
	if h.Get(xhttp.AmzServerSideEncryptionCustomerKey) == "" {
		return key, ErrMissingCustomerKey
	}
	if h.Get(xhttp.AmzServerSideEncryptionCustomerKeyMD5) == "" {
		return key, ErrMissingCustomerKeyMD5
	}

 *   <li>missing artifacts</li>
 *   <li>network/transfer errors</li>
 *   <li>file system errors: permissions</li>
 * </ul>
 *
 * TODO carlos: all these possible has*Exceptions and get*Exceptions methods make the clients too
 *       complex requiring a long list of checks, need to create a parent/interface/encapsulation
 *       for the types of exceptions
 */
@Deprecated

        return new Result<>(hasErrors(problems), model, problems);
    }

    /**
     * New result consisting of given result and new problem. Convenience for newResult(result.get(),
     * concat(result.getProblems(),problems)).
     *
     * @param result
     * @param problem
     */
    public static <T> Result<T> addProblem(Result<T> result, ModelProblem problem) {

        extendsFrom(configurations.implementation.get())
        attributes {
            attribute(Usage.USAGE_ATTRIBUTE, objects.named(Usage.JAVA_RUNTIME))
            attribute(Category.CATEGORY_ATTRIBUTE, objects.named(Category.DOCUMENTATION))
            attribute(DocsType.DOCS_TYPE_ATTRIBUTE, objects.named("gradle-source-folders"))
        }
        val main = sourceSets.main.get()
        main.java.srcDirs.forEach {

            endpoint = val.toString();
            final String lep = endpoint.toLowerCase();
            if (lep.startsWith("\\pipe\\")) {
                final String iface = (String) INTERFACES.get(lep.substring(6));
                if (iface != null) {
                    int c, p;
                    c = iface.indexOf(':');
                    p = iface.indexOf('.', c + 1);

        child = (position > 0 && position <= filteredChildren.size()) ? filteredChildren.get(position - 1) : null;
        return child != null;
    }

    private void filterChildren(int position) {
        for (; position > filteredChildren.size() && filteredIndex < children.size(); filteredIndex++) {
            XmlNode child = children.get(filteredIndex);
            if (testNode(child)) {
                filteredChildren.add(child);

from fastapi import FastAPI, Path, Query

app = FastAPI()


@app.get("/items/{item_id}")
async def read_items(
    *,
    item_id: int = Path(title="The ID of the item to get", ge=0, le=1000),
    q: str,
    size: float = Query(gt=0, lt=10.5),
):
    results = {"item_id": item_id}
    if q:
        results.update({"q": q})
    if size:
        results.update({"size": size})

async def common_parameters(
    q: Union[str, None] = None, skip: int = 0, limit: int = 100
):
    return {"q": q, "skip": skip, "limit": limit}


@app.get("/items/")
async def read_items(commons: Annotated[dict, Depends(common_parameters)]):
    return commons


@app.get("/users/")
async def read_users(commons: Annotated[dict, Depends(common_parameters)]):