|| 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

 * under the License.
 */
package org.apache.maven.api.services.model;

import java.nio.file.Path;

/**
 * Resolves relative paths against a specific base directory.
 *
 */
public interface PathTranslator {

    /**
     * Resolves the specified path against the given base directory. The resolved path will be absolute and uses the

     */
    boolean isActive ( CIFSContext tc ) throws UnknownHostException;


    /**
     * Determines if this address is set to be permanent.
     * 
     * @param tc
     *            context to use
     * @return whether this address is permanent
     *
     * @throws UnknownHostException
     *             if the host cannot be resolved to find out.
     */

                if (artifact.getFile() == null) {
                    Artifact resolved = map.get(artifact.getDependencyConflictId());
                    if (resolved != null) {
                        artifact.setFile(resolved.getFile());
                        artifact.setDependencyTrail(resolved.getDependencyTrail());
                        artifact.setResolvedVersion(resolved.getVersion());
                        artifact.setResolved(true);

import org.apache.maven.artifact.repository.metadata.SnapshotArtifactRepositoryMetadata;
import org.apache.maven.artifact.repository.metadata.Versioning;
import org.apache.maven.artifact.resolver.ArtifactNotFoundException;
import org.apache.maven.artifact.resolver.ArtifactResolutionException;
import org.apache.maven.repository.legacy.WagonManager;
import org.codehaus.plexus.logging.AbstractLogEnabled;

/**

                break;
            }
            trace = trace.getParent();
        }
        return collectStepTrace;
    }

    /**
     * The event "artifact resolved" if fired WHENEVER an artifact is resolved, BUT it happens also when an artifact
     * descriptor (model, the POM) is being built, and parent (and parent of parent...) is being asked for. Hence, this

import org.apache.maven.api.model.Parent;

/**
 * Resolves a POM from its coordinates.
 */
public interface ModelResolver extends Service {

    /**
     * Tries to resolve the POM for the specified parent coordinates possibly updating {@code parent}.
     *
     * @param session The session to use to resolve the model, must not be {@code null}.
     * @param parent The parent coordinates to resolve, must not be {@code null}.

     * <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,

 *
 * @throws UnknownHostException if the host cannot be resolved to find out.
 */ 

    public int getNodeType() throws UnknownHostException {
        checkData();
        return nodeType;
    }

/** 
 * Determines if this address in the process of being deleted.
 *
 * @throws UnknownHostException if the host cannot be resolved to find out.
 */ 

        // The root artifact may, or may not be resolved so we need to check before we attempt to resolve.
        // This is often an artifact like a POM that is taken from disk and we already have hold of the
        // file reference. But this may be a Maven Plugin that we need to resolve from a remote repository
        // as well as its dependencies.