All Downloads are FREE. Search and download functionalities are using the official Maven repository.
  • Log In
  • Register

    • io.micronaut.http.bind.binders.DefaultUnmatchedRequestArgumentBinder Maven / Gradle / Ivy

    The newest version!
    /*
 * Copyright 2017-2020 original authors
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 * https://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
package io.micronaut.http.bind.binders;

import io.micronaut.core.annotation.Internal;
import io.micronaut.core.convert.ArgumentConversionContext;
import io.micronaut.core.convert.ConversionError;
import io.micronaut.core.type.Argument;
import io.micronaut.http.HttpRequest;

import java.util.ArrayList;
import java.util.List;
import java.util.Optional;
import java.util.function.Function;
import java.util.stream.Stream;

/**
 * The binder will try to bind the argument value which wasn't matched by an annotation or a type.
 *
 * @param  A type
 * @author Denis Stepanov
 * @since 4.0.0
 */
@Internal
public final class DefaultUnmatchedRequestArgumentBinder implements PostponedRequestArgumentBinder, UnmatchedRequestArgumentBinder {

    private final List> internalPreUnmatchedArgumentBinders;
    private final List> unmatchedArgumentBinders;
    private final List> internalPostUnmatchedArgumentBinders;

    /**
     * @param internalPreUnmatchedArgumentBinders  The internal pre unmatched binders
     * @param unmatchedArgumentBinders             The unmatched binders
     * @param internalPostUnmatchedArgumentBinders The internal post unmatched binders
     */
    public DefaultUnmatchedRequestArgumentBinder(List> internalPreUnmatchedArgumentBinders,
                                                 List> unmatchedArgumentBinders,
                                                 List> internalPostUnmatchedArgumentBinders) {
        this.internalPreUnmatchedArgumentBinders = internalPreUnmatchedArgumentBinders;
        this.unmatchedArgumentBinders = unmatchedArgumentBinders;
        this.internalPostUnmatchedArgumentBinders = internalPostUnmatchedArgumentBinders;
    }

    private Stream> stream() {
        return Stream.concat(
            internalPreUnmatchedArgumentBinders.stream(),
            Stream.concat(
                unmatchedArgumentBinders.stream(),
                internalPostUnmatchedArgumentBinders.stream()
            )
        );
    }

    @Override
    public RequestArgumentBinder createSpecific(Argument argument) {
        Function, RequestArgumentBinder> createSpecific = b -> b.createSpecific((Argument) argument);
        return new DefaultUnmatchedRequestArgumentBinder<>(
            internalPreUnmatchedArgumentBinders.stream().map(createSpecific).toList(),
            unmatchedArgumentBinders.stream().map(createSpecific).toList(),
            internalPostUnmatchedArgumentBinders.stream().map(createSpecific).toList()
        );
    }

    @Override
    public BindingResult bind(ArgumentConversionContext context, HttpRequest request) {
        List> pending = new ArrayList<>();
        List errors = new ArrayList<>();
        boolean allUnsatisfied = true;
        for (RequestArgumentBinder binder : stream().filter(binder -> !(binder instanceof PostponedRequestArgumentBinder)).toList()) {
            BindingResult result = binder.bind((ArgumentConversionContext) context, request);
            if (result.isPresentAndSatisfied()) {
                return (BindingResult) result;
            } else if (result instanceof PendingRequestBindingResult pendingRequestBindingResult) {
                pending.add(pendingRequestBindingResult);
                allUnsatisfied = false;
            } else {
                if (result != BindingResult.UNSATISFIED) {
                    errors.addAll(result.getConversionErrors());
                    allUnsatisfied = false;
                }
            }
        }
        if (allUnsatisfied) {
            return BindingResult.unsatisfied();
        }
        return new PendingRequestBindingResult<>() {

            @Override
            public boolean isPending() {
                return pending.stream().allMatch(PendingRequestBindingResult::isPending);
            }

            @Override
            public Optional getValue() {
                return pending.stream().filter(r -> !r.isPending()).findFirst().flatMap(r -> (Optional) r.getValue());
            }

            @Override
            public List getConversionErrors() {
                return Stream.concat(errors.stream(), pending.stream().flatMap(r -> r.getConversionErrors().stream())).toList();
            }
        };
    }

    @Override
    public BindingResult bindPostponed(ArgumentConversionContext context, HttpRequest request) {
        BindingResult lastWithError = null;
        for (RequestArgumentBinder binder : stream().filter(binder -> (binder instanceof PostponedRequestArgumentBinder)).toList()) {
            BindingResult result = binder.bind((ArgumentConversionContext) context, request);
            if (result.getValue().isPresent()) {
                return (BindingResult) result;
            }
            if (!result.getConversionErrors().isEmpty()) {
                lastWithError = (BindingResult) result;
            }
        }
        return lastWithError == null ? BindingResult.unsatisfied() : lastWithError;
    }
}
    
    
    
    

    




    
    
    © 2015 - 2025 Weber Informatics LLC | Privacy Policy