* Method write.
     *
     * @param writer a writer object.
     * @param persistedToolchains a persistedToolchains object.
     * @throws IOException java.io.IOException if any.
     */
    public void write(Writer writer, PersistedToolchains persistedToolchains) throws IOException {
        try {
            delegate.write(writer, persistedToolchains.getDelegate());
        } catch (XMLStreamException e) {

        toolchain.setType("TYPE");
        toolchain.setProvides(props);
        PersistedToolchains persistedToolchains = new PersistedToolchains();
        persistedToolchains.setToolchains(Collections.singletonList(toolchain));

        String xml = new DefaultToolchainsXmlFactory().toXmlString(persistedToolchains.getDelegate());
        ToolchainsBuildingRequest request = new DefaultToolchainsBuildingRequest();

package org.apache.maven.toolchain.io;

import java.io.File;
import java.io.IOException;
import java.io.InputStream;
import java.io.Reader;
import java.util.Map;

import org.apache.maven.toolchain.model.PersistedToolchains;

/**
 * Handles deserialization of toolchains from some kind of textual format like XML.
 *
 * @since 3.3.0
 * @deprecated since 4.0.0, use {@code org.apache.maven.api.services.xml.ToolchainsXmlFactory} instead

     * @return PersistedToolchains
     * @throws IOException IOException if any.
     * @throws XmlPullParserException XmlPullParserException if
     *         any.
     * @see XmlStreamReader
     */
    public PersistedToolchains read(Reader reader, boolean strict) throws IOException, XmlPullParserException {
        try {
            return new PersistedToolchains(delegate.read(reader, strict, null));

        }

        return result;
    }

    private PersistedToolchains readToolchains(
            Source toolchainsSource, ToolchainsBuildingRequest request, ProblemCollector problems) {
        if (toolchainsSource == null) {
            return new PersistedToolchains();
        }

        PersistedToolchains toolchains;

        try {

    private PersistedToolchains effectiveToolchains;

    private List<Problem> problems;

    /**
     * Default constructor
     *
     * @param effectiveToolchains the merged toolchains, may not be {@code null}
     * @param problems the problems while building the effectiveToolchains, if any.
     */
    public DefaultToolchainsBuildingResult(PersistedToolchains effectiveToolchains, List<Problem> problems) {

    @Override
    public PersistedToolchains build(File userToolchainsFile) throws MisconfiguredToolchainException {
        PersistedToolchains toolchains = null;

        if (userToolchainsFile != null && userToolchainsFile.isFile()) {
            try (InputStream in = Files.newInputStream(userToolchainsFile.toPath())) {
                toolchains = new PersistedToolchains(new MavenToolchainsStaxReader().read(in));

    @Override
    public PersistedToolchains read(File input, Map<String, ?> options) throws IOException {
        Objects.requireNonNull(input, "input cannot be null");

        try (InputStream in = Files.newInputStream(input.toPath())) {
            InputSource source = InputSource.of(input.toString());
            return new PersistedToolchains(new MavenToolchainsStaxReader().read(in, isStrict(options), source));

 * under the License.
 */
package org.apache.maven.toolchain.building;

import java.util.List;

import org.apache.maven.building.Problem;
import org.apache.maven.toolchain.model.PersistedToolchains;

/**
 * Collects the output of the toolchains builder.
 *
 * @since 3.3.0
 * @deprecated since 4.0.0, use {@code org.apache.maven.api.services.ToolchainsBuilder} instead
 */
@Deprecated(since = "4.0.0")

 * under the License.
 */
package org.apache.maven.toolchain.io;

import java.io.IOException;
import java.io.Writer;
import java.util.Map;

import org.apache.maven.toolchain.model.PersistedToolchains;

/**
 * Handles serialization of toolchains into some kind of textual format like XML.
 *
 * @deprecated since 4.0.0, use {@code org.apache.maven.api.services.xml.ToolchainsXmlFactory} instead
 */