return lookup(type);
    }

    @Override
    public <T> Optional<T> lookupOptional(Class<T> type) {
        return Optional.ofNullable(type.cast(components.get(type)));
    }

    @Override
    public <T> Optional<T> lookupOptional(Class<T> type, String name) {
        return lookupOptional(type);
    }

    @Override
    public <T> List<T> lookupList(Class<T> type) {
        return List.of();

    }

    @Override
    public <T> T lookup(Class<T> type, String name) {
        return null;
    }

    @Override
    public <T> Optional<T> lookupOptional(Class<T> type) {
        return Optional.empty();
    }

    @Override
    public <T> Optional<T> lookupOptional(Class<T> type, String name) {
        return Optional.empty();
    }

    @Override
    public <T> List<T> lookupList(Class<T> type) {

    }

    @Override
    public <T> T lookup(Class<T> type, String name) {
        return null;
    }

    @Override
    public <T> Optional<T> lookupOptional(Class<T> type) {
        return Optional.empty();
    }

    @Override
    public <T> Optional<T> lookupOptional(Class<T> type, String name) {
        return Optional.empty();
    }

    @Override
    public <T> List<T> lookupList(Class<T> type) {

        try {
            return container.lookup(type, name);
        } catch (ComponentLookupException e) {
            throw new LookupException(e);
        }
    }

    @Override
    public <T> Optional<T> lookupOptional(Class<T> type) {
        try {
            return Optional.of(container.lookup(type));
        } catch (ComponentLookupException e) {
            if (e.getCause() instanceof NoSuchElementException) {

     * @param <T> The component type.
     * @throws LookupException if there is some provisioning related issue.
     */
    @Nonnull
    <T> Optional<T> lookupOptional(Class<T> type);

    /**
     * Performs a lookup for optional typed component.
     *
     * @param type The component type.
     * @param name The component name.

                throw new LookupException("empty lookup");
            }

            @Override
            public <T> Optional<T> lookupOptional(Class<T> type) {
                return Optional.empty();
            }

            @Override
            public <T> Optional<T> lookupOptional(Class<T> type, String name) {
                return Optional.empty();
            }

            @Override

        // which are bound to a project's classloader, without any clear definition
        // of a "project scope"
        LifecycleMapping lifecycleMapping =
                lookup.lookupOptional(LifecycleMapping.class, id).orElse(null);
        if (lifecycleMapping == null) {
            return Optional.empty();
        }
        Type type = typeRegistry.lookup(id).orElse(null);
        if (type == null) {

     * from current module and for example not extensions coming from other modules.
     */
    private LifecycleMapping lookupLifecycleMapping(final String packaging) {
        return lookup.lookupOptional(LifecycleMapping.class, packaging).orElse(null);
    }

    private void parseLifecyclePhaseDefinitions(Map<Plugin, Plugin> plugins, String phase, LifecyclePhase goals) {

            current = context.cwd.resolve(context.options().alternatePomFile().get());
        }
        ModelProcessor modelProcessor =
                lookup.lookupOptional(ModelProcessor.class).orElse(null);
        if (modelProcessor != null) {
            return modelProcessor.locateExistingPom(current);
        } else {
            return Files.isRegularFile(current) ? current : null;

                return result;
            }

            validateOptionalProfiles(session, request.getProfileActivation());

            LifecycleStarter lifecycleStarter = lookup.lookupOptional(LifecycleStarter.class, request.getBuilderId())
                    .orElseGet(() -> lookup.lookup(LifecycleStarter.class));

            lifecycleStarter.execute(session);