import static org.apache.maven.internal.impl.Utils.cast;

public interface InternalSession extends Session {

    static InternalSession from(Session session) {
        return cast(InternalSession.class, session, "session should be an " + InternalSession.class);
    }

    static InternalSession from(org.eclipse.aether.RepositorySystemSession session) {

        }

        // reactor failure modes
        if (t instanceof RuntimeException || !(t instanceof Exception)) {
            // fail fast on RuntimeExceptions, Errors and "other" Throwables
            // assume these are system errors and further build is meaningless
            buildContext.getReactorBuildStatus().halt();

    WrapperNode(Node delegate, List<Node> children) {
        this.delegate = delegate;
        this.children = children;
    }

    @Override
    DependencyNode getDependencyNode() {
        return Utils.cast(AbstractNode.class, delegate, "delegate").getDependencyNode();
    }

    @Override
    public List<Node> getChildren() {
        return children;
    }

    @Override
    public Artifact getArtifact() {

        }

        /*
         * NOTE: This is primarily to keep backward-compat with Maven 2.x which did not validate that dependencies are
         * unique within a single POM. Upon multiple declarations, 2.x just kept the last one but retained the order of
         * the first occurrence. So when we're in lenient/compat mode, we have to deal with such broken POMs and mimic

        }
    }

    public Iterator<ExecutionPlanItem> iterator() {
        return getExecutionPlanItems().iterator();
    }

    /**
     * Returns the last ExecutionPlanItem in the supplied phase. If no items are in the specified phase,
     * the closest executionPlanItem from an earlier phase item will be returned.
     *
     * @param requestedPhase the requested phase

         * to the object graph below this root, using either 'getXXX()' or 'isXXX()'
         * accessor types to resolve the value for each successive expression part.
         * Finally, return the result of the last expression part's resolution.</p>
         *
         * <p><b>NOTE:</b> The object-graph nagivation actually takes place via the
         * {@link ReflectionValueExtractor} class.</p>
         */

            injector.bindInstance(org.apache.maven.api.MojoExecution.class, execution);
            injector.bindInstance(org.apache.maven.api.plugin.Log.class, log);
            mojo = mojoInterface.cast(injector.getInstance(
                    Key.of(mojoDescriptor.getImplementationClass(), mojoDescriptor.getRoleHint())));

        } catch (Exception e) {

                return null;
            }
        };
    }

    static <T extends Throwable> void uncheckedThrow(Throwable t) throws T {
        throw (T) t; // rely on vacuous cast
    }

    private Model fireEvent(
            Model model,
            ModelBuilderRequest request,
            ModelProblemCollector problems,

import org.apache.maven.project.MavenProject;
import org.apache.maven.project.ProjectSorter;

/**
 * ReactorManager - unused
 */
@Deprecated
public class ReactorManager {
    public static final String FAIL_FAST = "fail-fast";

    public static final String FAIL_AT_END = "fail-at-end";

    public static final String FAIL_NEVER = "fail-never";

    public static final String MAKE_MODE = "make";

                                if (last != null) {
                                    logger.debug(String.valueOf(last));
                                }

                                last = next;
                            }
                        }

                        if (last != null) {
                            logger.debug(String.valueOf(last));
                        }
                    }