}

            @Nonnull
            @Override
            public Optional<Path> getPath() {
                return Optional.ofNullable(path);
            }

            @Nonnull
            @Override
            public Optional<Source> getSource() {
                return Optional.ofNullable(source);
            }

            @Override

        }

        @Override
        public Optional<Lifecycle> lookup(String id) {
            return Optional.empty();
        }
    };

    private static final PackagingRegistry emptyPackagingRegistry = new PackagingRegistry() {
        @Override
        public Optional<Packaging> lookup(String id) {
            return Optional.of(new Packaging() {
                @Override

            <multiplicity>*</multiplicity>
          </association>
        </field>
        <field>
          <name>optional</name>
          <version>4.0.0+</version>
          <description>
            Indicates the dependency is optional for use of this library. While the
            version of the dependency will be taken into account for dependency calculation if the

            }

            @Nonnull
            @Override
            public Optional<Project> getProject() {
                return Optional.ofNullable(project);
            }

            @Nonnull
            @Override
            public Optional<Artifact> getRootArtifact() {
                return Optional.ofNullable(rootArtifact);
            }

            @Nonnull
            @Override

                    return Optional.of(project.getArtifact().getFile().toPath());
                }
            }
        }
        Path path = paths.get(id);
        if (path == null && artifact instanceof DefaultArtifact) {
            path = ((DefaultArtifact) artifact).getArtifact().getPath();
        }
        return Optional.ofNullable(path);
    }

    @Override

        if (lifecycleMapping == null) {
            return Optional.empty();
        }
        Type type = typeRegistry.lookup(id).orElse(null);
        if (type == null) {
            return Optional.empty();
        }
        return Optional.of(new DefaultPackaging(id, type, getPlugins(lifecycleMapping)));
    }

            return "UNRESOLVED";
        }

        @Override
        public String id() {
            return "UNRESOLVED";
        }

        @Override
        public Optional<String> option() {
            return Optional.empty();
        }

        @Override
        public String option(Iterable<? extends Path> paths) {
            return "";
        }
    };

    /**

 * under the License.
 */
package org.apache.maven.api.services;

import java.util.Optional;

import org.apache.maven.api.ExtensibleEnum;
import org.apache.maven.api.Service;
import org.apache.maven.api.annotations.Nonnull;

public interface ExtensibleEnumRegistry<T extends ExtensibleEnum> extends Service {
    @Nonnull
    Optional<T> lookup(@Nonnull String id);

    @Nonnull
    default T require(@Nonnull String id) {

        assertEquals("runtime", pom.getValue("dependencyManagement/dependencies[1]/scope"));
        assertEquals(Boolean.FALSE, pom.getValue("dependencyManagement/dependencies[1]/optional"));
        assertEquals(1, ((List<?>) pom.getValue("dependencyManagement/dependencies[1]/exclusions")).size());
        assertEquals(

        private ActivationFrame nextFrame(String property) {
            return new ActivationFrame(property, Optional.empty());
        }

        private <P> ActivationFrame nextFrame(String property, Function<P, InputLocationTracker> child) {
            @SuppressWarnings("unchecked")
            final Optional<P> parent = (Optional<P>) stk.peek().parent;
            return new ActivationFrame(property, parent.map(child));
        }