}

        request.setToolchains(
                Optional.ofNullable(context.effectiveToolchains).map(PersistedToolchains::getToolchains).stream()
                        .flatMap(List::stream)
                        .map(ToolchainModel::new)
                        .collect(Collectors.groupingBy(ToolchainModel::getType)));

import javax.inject.Inject;
import javax.inject.Named;
import javax.inject.Singleton;

import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.List;
import java.util.stream.Collectors;

import org.apache.maven.api.xml.XmlNode;
import org.apache.maven.execution.MavenSession;
import org.apache.maven.model.Plugin;
import org.apache.maven.plugin.BuildPluginManager;

public class LayeredMavenOptions<O extends MavenOptions> extends LayeredOptions<O> implements MavenOptions {
    public static MavenOptions layerMavenOptions(Collection<MavenOptions> options) {
        List<MavenOptions> o = options.stream().filter(Objects::nonNull).toList();
        if (o.isEmpty()) {
            throw new IllegalArgumentException("No options specified (or all were null)");
        } else if (o.size() == 1) {
            return o.get(0);

 * specific language governing permissions and limitations
 * under the License.
 */
package org.apache.maven.toolchain.io;

import javax.inject.Named;
import javax.inject.Singleton;
import javax.xml.stream.XMLStreamException;

import java.io.File;
import java.io.IOException;
import java.io.InputStream;
import java.io.Reader;
import java.nio.file.Files;
import java.util.Map;
import java.util.Objects;

	"path/filepath"
	"reflect"
	"testing"

	"github.com/alecthomas/participle"
	"github.com/minio/minio/internal/s3select/jstream"
)

func getJSONStructs(b []byte) ([]any, error) {
	dec := jstream.NewDecoder(bytes.NewBuffer(b), 0).ObjectAsKVS().MaxDepth(100)
	var result []any
	for parsedVal := range dec.Stream() {
		result = append(result, parsedVal.Value)
	}
	if err := dec.Err(); err != nil {
		return nil, err
	}

 * KIND, either express or implied.  See the License for the
 * specific language governing permissions and limitations
 * under the License.
 */
package org.apache.maven.internal.transformation;

import javax.xml.stream.XMLStreamException;

import java.io.IOException;
import java.nio.file.Path;

import org.apache.maven.api.services.ModelBuilderException;
import org.apache.maven.api.services.ModelSource;

	o.SetFilter()
	if o.Transient {
		o.Create = false
	}

	// We have 2 cases:
	// 1) Cold listing, just list.
	// 2) Returning, but with no id. Start async listing.
	// 3) Returning, with ID, stream from list.
	//
	// If we don't have a list id we must ask the server if it has a cache or create a new.
	if o.ID != "" && !o.Transient {
		// Create or ping with handout...

 * KIND, either express or implied.  See the License for the
 * specific language governing permissions and limitations
 * under the License.
 */
package org.apache.maven.configuration;

import javax.xml.stream.XMLStreamException;

import java.io.File;
import java.io.StringReader;
import java.nio.file.Path;
import java.nio.file.Paths;

import org.apache.maven.api.xml.XmlService;

    private final List<Object> objects;

    public SimpleLookup(List<Object> objects) {
        this.objects = objects;
    }

    @Override
    public <T> T lookup(Class<T> type) {
        return objects.stream()
                .filter(type::isInstance)
                .map(type::cast)
                .findAny()
                .orElseThrow(() -> new LookupException("No service of type " + type));
    }

    @Override

 * under the License.
 */
package org.apache.maven.project;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.Set;
import java.util.stream.Collectors;

import org.apache.maven.project.Graph.Vertex;
import org.junit.jupiter.api.Test;

import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertFalse;