It is more than simply understanding that m2 cannot go and check for the
  latest version of some snapshot artifact. If m2 is offline, SCM operations
  cannot succeed; no artifact downloads can take place, regardless of whether
  they are snapshot versions; artifact deployment cannot take place; certain
  types of tests cannot be setup, since the container used to run them cannot be
  reached or started.

  static final String REUSING_EDGE =
      "Edge %s already exists between the following nodes: %s, "
          + "so it cannot be reused to connect the following nodes: %s.";
  static final String MULTIPLE_EDGES_CONNECTING =
      "Cannot call edgeConnecting() when parallel edges exist between %s and %s. Consider calling "
          + "edgesConnecting() instead.";

    public BaseObject(Object delegate, BaseObject parent) {
        this.delegate = requireNonNull(delegate, "delegate cannot be null");
        this.childrenTracking = parent != null ? parent::replace : null;
    }

    public BaseObject(Object delegate, ChildrenTracking parent) {
        this.delegate = requireNonNull(delegate, "delegate cannot be null");
        this.childrenTracking = parent;
    }

    public Object getDelegate() {

                }
            }
        }

        // ArtifactId is required and cannot be inherited
        if (artifactId == null || artifactId.isEmpty()) {
            context.debug("Cannot determine artifactId for POM");
            return null;
        }

        // GroupId and version can be inherited, but if still null, we can't create a valid Artifact

	return s.tokens[s.pos].text
}

func (s *Slice) File() string {
	return s.base.Filename()
}

func (s *Slice) Base() *src.PosBase {
	return s.base
}

func (s *Slice) SetBase(base *src.PosBase) {
	// Cannot happen because we only have slices of already-scanned text,
	// but be prepared.
	s.base = base
}

func (s *Slice) Line() int {
	return s.line
}

func (s *Slice) Col() int {

            @Nonnull Session session, @Nonnull Collection<? extends ArtifactCoordinates> coordinates) {
        return builder()
                .session(requireNonNull(session, "session cannot be null"))
                .coordinates(requireNonNull(coordinates, "coordinates cannot be null"))
                .build();
    }

    @Nonnull
    static ArtifactResolverRequest build(
            @Nonnull Session session,

            @Nonnull Collection<ProducedArtifact> artifacts) {
        return builder()
                .session(requireNonNull(session, "session cannot be null"))
                .repository(requireNonNull(repository, "repository cannot be null"))
                .artifacts(requireNonNull(artifacts, "artifacts cannot be null"))
                .build();
    }

    class ArtifactDeployerRequestBuilder {
        Session session;

        Objects.requireNonNull(input, "input cannot be null");

        return read(Files.newInputStream(input.toPath()), options);
    }

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

        try (Reader in = input) {

	ErrRemoteTargetDenyAddError: {
		Code:           "XMinioAdminRemoteTargetDenyAdd",
		Description:    "Cannot add remote target endpoint since this server is in a cluster replication setup",
		HTTPStatusCode: http.StatusBadRequest,
	},
	ErrReplicationDenyEditError: {
		Code:           "XMinioReplicationDenyEdit",
		Description:    "Cannot alter local replication config since this server is in a cluster replication setup",

public class DefaultToolchainsReader implements ToolchainsReader {

    @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());