|| getBaseVersion().equals(LATEST_VERSION));
    }

    @Override
    public void setResolved(boolean resolved) {
        this.resolved = resolved;
    }

    @Override
    public boolean isResolved() {
        return resolved;
    }

    @Override
    public void setResolvedVersion(String version) {
        this.version = version;
        // retain baseVersion

        return artifact.compareTo(a);
    }

    /** {@inheritDoc} */
    public void setResolved(boolean resolved) {
        artifact.setResolved(resolved);
    }

    /** {@inheritDoc} */
    public boolean isResolved() {
        return artifact.isResolved();
    }

    /** {@inheritDoc} */
    public void setResolvedVersion(String version) {

        return depth;
    }

    public void setDepth(int depth) {
        this.depth = depth;
    }

    public boolean isResolved() {
        return resolved;
    }

    public void setResolved(boolean resolved) {
        this.resolved = resolved;
    }

    public int getPomOrder() {
        return pomOrder;
    }

    public void setPomOrder(int pomOrder) {

		preambleErrors := p.gccErrors([]byte(builtinProlog + f.Preamble))
		if len(preambleErrors) > 0 {
			error_(token.NoPos, "\n%s errors for preamble:\n%s", gccBaseCmd[0], preambleErrors)
		}

		fatalf("unresolved names")
	}

	return needType
}

// loadDWARF parses the DWARF debug information generated
// by gcc to learn the details of the constants, variables, and types
// being referred to as C.xxx.

    void selectVersion(String version);

    void setGroupId(String groupId);

    void setArtifactId(String artifactId);

    boolean isSnapshot();

    void setResolved(boolean resolved);

    boolean isResolved();

    void setResolvedVersion(String version);

    void setArtifactHandler(ArtifactHandler handler);

    boolean isRelease();

    void setRelease(boolean release);

            }

            artifact.setResolved(true);

            return;
        }

        if (!artifact.isResolved()) {
            ArtifactResult result;

            try {
                ArtifactRequest artifactRequest = new ArtifactRequest();
                artifactRequest.setArtifact(RepositoryUtils.toArtifact(artifact));

                        // Conflict Resolution
                        ResolutionNode resolved = null;
                        for (Iterator<ConflictResolver> j = conflictResolvers.iterator();
                                resolved == null && j.hasNext(); ) {
                            ConflictResolver conflictResolver = j.next();

                            resolved = conflictResolver.resolveConflict(previous, node);
                        }

# yarn lockfile v1


"@colors/colors@1.5.0":
  version "1.5.0"
  resolved "https://registry.yarnpkg.com/@colors/colors/-/colors-1.5.0.tgz#bb504579c1cae923e6576a4f5da43d25f97bdbd9"
  integrity sha512-ooWCrlZP11i8GImSjTHYHLkvFDP48nS4+204nGb1RiX/WXYHmJA2III9/e2DWVabCESdW7hBAEzHRqUn9OUVvQ==

"@discoveryjs/json-ext@^0.5.0":
  version "0.5.7"

    /**
     * Create an instance of the exception with all required information.
     *
     * @param originatingArtifact the artifact that was being resolved
     * @param resolvedArtifacts   artifacts that could be resolved
     * @param missingArtifacts    artifacts that could not be resolved
     * @param remoteRepositories  remote repositories where the missing artifacts were not found
     */
    public MultipleArtifactsNotFoundException(

     * <p>
     * Specifically, if the SID has
     * been resolved and it is not a domain SID or builtin account,
     * the full DOMAIN\name form of the account will be
     * returned (e.g. MYDOM\alice or MYDOM\Domain Users).
     * If the SID has been resolved but it is is a domain SID,
     * only the domain name will be returned (e.g. MYDOM).
     * If the SID has been resolved but it is a builtin account,