try {
                        c = interpolator.interpolate(value, recursionInterceptor);
                    } catch (InterpolationException e) {
                        problems.add(BuilderProblem.Severity.ERROR, ModelProblem.Version.BASE, e.getMessage(), e);
                    }
                    cache.put(value, c);
                }
                return c;
            }
            return value;
        };

                }

                props.setProperty(key, Long.toString(System.currentTimeMillis()));

                if (error != null) {
                    props.setProperty(key + ERROR_KEY_SUFFIX, error);
                } else {
                    props.remove(key + ERROR_KEY_SUFFIX);
                }

                getLogger().debug("Writing resolution-state to: " + touchfile);

            } else {
                result = addExceptionToResult(
                        new DefaultMavenExecutionResult(), new InternalErrorException("Internal error: " + e, e));
            }
        } finally {
            legacySupport.setSession(null);
        }

        return result;
    }

    //
    // 1) Setup initial properties.
    //

                + "(" + result.getPomFile() + ") has "
                + children.size() + " error" + (children.size() == 1 ? "" : "s");

        return new ExceptionSummary(null, message, null, children);
    }

    private ExceptionSummary handle(ModelProblem problem, String projectId) {
        if (ModelProblem.Severity.ERROR.compareTo(problem.getSeverity()) >= 0) {
            String message = problem.getMessage();

TransferEvent extends WagonEvent { public static final int TRANSFER_INITIATED = 0; public static final int TRANSFER_STARTED = 1; public static final int TRANSFER_COMPLETED = 2; public static final int TRANSFER_PROGRESS = 3; public static final int TRANSFER_ERROR = 4; public static final int REQUEST_GET = 5; public static final int REQUEST_PUT = 6; private org.apache.maven.wagon.resource.Resource resource; private int eventType; private int requestType; private Exception exception; private java.io.File localFile;...

                if (!ID_REGEX.matcher(pluginGroup).matches()) {
                    addViolation(
                            problems,
                            BuilderProblem.Severity.ERROR,
                            "pluginGroups.pluginGroup[" + i + "]",
                            null,
                            "must denote a valid group id and match the pattern " + ID);
                }
            }

  It means warning users that since the network is missing, certain features and
  operations will be unavailable, rather than simply waiting for those
  operations to fail, then trying to help users decipher the error messages they
  get as a result.

* Implications for Resolution

** Dependency Resolution

  This one is obvious...we only have access to the repositories using

org.apache.commons.logging.Log { protected java.util.logging.Logger logger; public void Jdk14Logger(String); private void log(java.util.logging.Level, String, Throwable); public void debug(Object); public void debug(Object, Throwable); public void error(Object); public void error(Object, Throwable); public void fatal(Object); public void fatal(Object, Throwable); public java.util.logging.Logger getLogger(); public void info(Object); public void info(Object, Throwable); public boolean isDebugEnabled(); public boolean...

                    throw e;
                } catch (TransferFailedException e) {
                    String error = (e.getMessage() != null)
                            ? e.getMessage()
                            : e.getClass().getSimpleName();
                    updateCheckManager.touch(artifact, repository, error);
                    throw e;
                }

Class<?> findExpectedType(Class<?> fromClass) { for (Class<?> c = fromClass; c != Object.class; c = c.getSuperclass()) { for (Method method : c.getDeclaredMethods()) { if (canObtainExpectedTyp(method)) { return expectedTypeFrom(method); } } } throw new Error("Cannot determine correct type for " + methodName + "() method."); } /** * @param method The method to examine. * @return true if this method references the relevant type */ protected boolean canObtainExpectedTyp(Method method) { return method.get...