org.apache.ivy.plugins.resolver

## Class BasicResolver

- java.lang.Object
- - org.apache.ivy.plugins.resolver.AbstractResolver
  - - org.apache.ivy.plugins.resolver.BasicResolver

- All Implemented Interfaces:
    Validatable, DependencyResolver, HasLatestStrategy
  Direct Known Subclasses:
    AbstractOSGiResolver, AbstractPatternsBasedResolver

      public abstract class BasicResolver
      extends AbstractResolver

- - ### Field Summary

    Fields
    Modifier and Type | Field and Description
    --- | ---
    `static java.text.SimpleDateFormat` | `DATE_FORMAT`
    `static java.lang.String` | `DESCRIPTOR_OPTIONAL`
    `static java.lang.String` | `DESCRIPTOR_REQUIRED`

  - ### Constructor Summary

    Constructors
    Constructor and Description
    `BasicResolver()`

  - ### Method Summary

    Methods
    Modifier and Type | Method and Description
    --- | ---
    `protected boolean` | `acceptLatest()`
    `protected void` | `checkModuleDescriptorRevision(ModuleDescriptor systemMd, ModuleRevisionId systemMrid)`
    `protected void` | `clearArtifactAttempts()`
    `protected void` | `clearIvyAttempts()`
    `ResolvedResource` | `doFindArtifactRef(Artifact artifact, java.util.Date date)`
    `DownloadReport` | `download(Artifact[] artifacts, DownloadOptions options)` Download artifacts with specified DownloadOptions.
    `ArtifactDownloadReport` | `download(ArtifactOrigin origin, DownloadOptions options)` Default implementation downloads the artifact without taking advantage of its location
    `boolean` | `exists(Artifact artifact)` Returns `true` if the given artifact can be located by this resolver and actually exist.
    `protected java.util.Collection` | `filterNames(java.util.Collection names)` Filters names before returning them in the findXXXNames or findTokenValues method.
    `protected abstract ResolvedResource` | `findArtifactRef(Artifact artifact, java.util.Date date)`
    `protected ResolvedResource` | `findFirstArtifactRef(ModuleDescriptor md, DependencyDescriptor dd, ResolveData data)`
    `protected abstract java.util.Collection` | `findNames(java.util.Map tokenValues, java.lang.String token)`
    `ResolvedResource` | `findResource(ResolvedResource[] rress, ResourceMDParser rmdparser, ModuleRevisionId mrid, java.util.Date date)` When the resolver has many choices, this function helps choosing one
    `protected abstract long` | `get(Resource resource, java.io.File dest)`
    `protected long` | `getAndCheck(Resource resource, java.io.File dest)`
    `protected ResolvedResource` | `getArtifactRef(Artifact artifact, java.util.Date date)`
    `java.lang.String[]` | `getChecksumAlgorithms()`
    `protected ResourceMDParser` | `getDefaultRMDParser(ModuleId mid)`
    `ResolvedModuleRevision` | `getDependency(DependencyDescriptor dd, ResolveData data)` Resolve a module by id, getting its module descriptor and resolving the revision if it's a latest one (i.e. a revision uniquely identifying the revision of a module in the current environment - If this revision is not able to identify uniquely the revision of the module outside of the current environment, then the resolved revision must begin by ##)
    `protected long` | `getPublicationDate(ModuleDescriptor md, DependencyDescriptor dd, ResolveData data)`
    `protected abstract Resource` | `getResource(java.lang.String source)`
    `protected ResourceMDParser` | `getRMDParser(DependencyDescriptor dd, ResolveData data)`
    `java.lang.String` | `getWorkspaceName()`
    `boolean` | `isAllownomd()`
    `boolean` | `isCheckconsistency()`
    `boolean` | `isEnvDependent()`
    `boolean` | `isForce()`
    `ModuleEntry[]` | `listModules(OrganisationEntry org)`
    `OrganisationEntry[]` | `listOrganisations()`
    `RevisionEntry[]` | `listRevisions(ModuleEntry mod)`
    `java.lang.String[]` | `listTokenValues(java.lang.String token, java.util.Map otherTokenValues)` List all the values the given token can take if other tokens are set as described in the otherTokenValues map.
    `ArtifactOrigin` | `locate(Artifact artifact)` Default implementation actually download the artifact Subclasses should overwrite this to avoid the download
    `protected void` | `logArtifactAttempt(Artifact art, java.lang.String attempt)`
    `protected void` | `logAttempt(java.lang.String attempt)`
    `protected void` | `logIvyAttempt(java.lang.String attempt)`
    `ResolvedModuleRevision` | `parse(ResolvedResource mdRef, DependencyDescriptor dd, ResolveData data)`
    `void` | `reportFailure()` Reports last resolve failure as Messages
    `void` | `reportFailure(Artifact art)` Reports last artifact download failure as Messages
    `void` | `setAllownomd(boolean b)`
    `void` | `setCheckconsistency(boolean checkConsitency)`
    `void` | `setChecksums(java.lang.String checksums)`
    `void` | `setDescriptor(java.lang.String descriptorRule)` Sets the module descriptor presence rule.
    `void` | `setEnvDependent(boolean envDependent)`
    `void` | `setForce(boolean force)`
    `void` | `setWorkspaceName(java.lang.String workspaceName)`
    `protected boolean` | `shouldReturnResolvedModule(DependencyDescriptor dd, ResolvedModuleRevision mr)`
    `java.lang.String` | `toString()`

    - ### Methods inherited from class org.apache.ivy.plugins.resolver.AbstractResolver

      `abortPublishTransaction, beginPublishTransaction, checkInterrupted, checkLatest, commitPublishTransaction, doValidate, dumpSettings, findModuleInCache, findModuleInCache, fromSystem, fromSystem, getCacheDownloadOptions, getCacheOptions, getChangingMatcherName, getChangingPattern, getDownloadOptions, getEventManager, getLatest, getLatestStrategy, getName, getNamespace, getParserSettings, getRepositoryCacheManager, getSettings, getSystemNode, getTypeName, hidePassword, isAfter, isValidate, listTokenValues, saveModuleRevisionIfNeeded, setCache, setChangingMatcher, setChangingPattern, setCheckmodified, setEventManager, setLatest, setLatestStrategy, setName, setNamespace, setRepositoryCacheManager, setSettings, setValidate, toSystem, toSystem, toSystem, toSystem, toSystem, toSystem, validate`

    - ### Methods inherited from class java.lang.Object

      `clone, equals, finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait`

    - ### Methods inherited from interface org.apache.ivy.plugins.resolver.DependencyResolver

      `findIvyFileRef, publish`

- - ### Field Detail

    - #### DESCRIPTOR_OPTIONAL

          public static final java.lang.String DESCRIPTOR_OPTIONAL

      See Also:
        Constant Field Values

    - #### DESCRIPTOR_REQUIRED

          public static final java.lang.String DESCRIPTOR_REQUIRED

      See Also:
        Constant Field Values

    - #### DATE_FORMAT

          public static final java.text.SimpleDateFormat DATE_FORMAT

  - ### Constructor Detail

    - #### BasicResolver

          public BasicResolver()

  - ### Method Detail

    - #### getWorkspaceName

          public java.lang.String getWorkspaceName()

    - #### setWorkspaceName

          public void setWorkspaceName(java.lang.String workspaceName)

    - #### isEnvDependent

          public boolean isEnvDependent()

    - #### setEnvDependent

          public void setEnvDependent(boolean envDependent)

    - #### getDependency

          public ResolvedModuleRevision getDependency(DependencyDescriptor dd,
                                             ResolveData data)
                                               throws java.text.ParseException

      Description copied from interface: `DependencyResolver`
      Resolve a module by id, getting its module descriptor and resolving the revision if it's a latest one (i.e. a revision uniquely identifying the revision of a module in the current environment - If this revision is not able to identify uniquely the revision of the module outside of the current environment, then the resolved revision must begin by ##)
      Throws:
        `java.text.ParseException`

    - #### shouldReturnResolvedModule

          protected boolean shouldReturnResolvedModule(DependencyDescriptor dd,
                                           ResolvedModuleRevision mr)

    - #### checkModuleDescriptorRevision

          protected void checkModuleDescriptorRevision(ModuleDescriptor systemMd,
                                           ModuleRevisionId systemMrid)

    - #### parse

          public ResolvedModuleRevision parse(ResolvedResource mdRef,
                                     DependencyDescriptor dd,
                                     ResolveData data)
                                       throws java.text.ParseException

      Throws:
        `java.text.ParseException`

    - #### getRMDParser

          protected ResourceMDParser getRMDParser(DependencyDescriptor dd,
                                      ResolveData data)

    - #### getDefaultRMDParser

          protected ResourceMDParser getDefaultRMDParser(ModuleId mid)

    - #### findResource

          public ResolvedResource findResource(ResolvedResource[] rress,
                                      ResourceMDParser rmdparser,
                                      ModuleRevisionId mrid,
                                      java.util.Date date)

      When the resolver has many choices, this function helps choosing one
      Parameters:
        `rress` - the list of resolved resource which the resolver found to fit the requirement
        `rmdparser` - the parser of module descriptor
        `mrid` - the module being resolved
        `date` - the current date
      Returns:
        the selected resource

    - #### filterNames

          protected java.util.Collection filterNames(java.util.Collection names)

      Filters names before returning them in the findXXXNames or findTokenValues method.

      Remember to call the super implementation when overriding this method.

      Parameters:
        `names` - the list to filter.
      Returns:
        the filtered list

    - #### clearIvyAttempts

          protected void clearIvyAttempts()

    - #### logIvyAttempt

          protected void logIvyAttempt(java.lang.String attempt)

    - #### logArtifactAttempt

          protected void logArtifactAttempt(Artifact art,
                                java.lang.String attempt)

    - #### logAttempt

          protected void logAttempt(java.lang.String attempt)

    - #### reportFailure

          public void reportFailure()

      Description copied from interface: `DependencyResolver`
      Reports last resolve failure as Messages
      Specified by:
        `reportFailure` in interface `DependencyResolver`
      Overrides:
        `reportFailure` in class `AbstractResolver`

    - #### reportFailure

          public void reportFailure(Artifact art)

      Description copied from interface: `DependencyResolver`
      Reports last artifact download failure as Messages
      Specified by:
        `reportFailure` in interface `DependencyResolver`
      Overrides:
        `reportFailure` in class `AbstractResolver`

    - #### acceptLatest

          protected boolean acceptLatest()

    - #### download

          public DownloadReport download(Artifact[] artifacts,
                                DownloadOptions options)

      Description copied from interface: `DependencyResolver`
      Download artifacts with specified DownloadOptions.

      The resolver will always make a best effort, and do not stop when an artifact is not available. It rather continue to attempt to download other requested artifacts, and report what has been done in the returned DownloadReport.

      The returned DownloadReport is never `null`, and always contain an `ArtifactDownloadReport` for each requested Artifact.

      Parameters:
        `artifacts` - an array of artifacts to download. Must not be `null`.
        `options` - options to apply for this download. Must not be `null`.
      Returns:
        a DownloadReport with details about each Artifact download.

    - #### clearArtifactAttempts

          protected void clearArtifactAttempts()

    - #### download

          public ArtifactDownloadReport download(ArtifactOrigin origin,
                                        DownloadOptions options)

      Description copied from class: `AbstractResolver`
      Default implementation downloads the artifact without taking advantage of its location
      Specified by:
        `download` in interface `DependencyResolver`
      Overrides:
        `download` in class `AbstractResolver`
      Parameters:
        `origin` - the location of the artifact to download. Must not be `null`.
        `options` - options to apply for this download. Must not be `null`.
      Returns:
        a report detailing how the download has gone, is never `null`.

    - #### getResource

          protected abstract Resource getResource(java.lang.String source)
                                           throws java.io.IOException

      Throws:
        `java.io.IOException`

    - #### exists

          public boolean exists(Artifact artifact)

      Description copied from interface: `DependencyResolver`
      Returns `true` if the given artifact can be located by this resolver and actually exist.
      Specified by:
        `exists` in interface `DependencyResolver`
      Overrides:
        `exists` in class `AbstractResolver`
      Parameters:
        `artifact` - the artifact which should be tested.
      Returns:
        `true` if the given artifact can be located by this resolver and actually exist.

    - #### locate

          public ArtifactOrigin locate(Artifact artifact)

      Description copied from class: `AbstractResolver`
      Default implementation actually download the artifact Subclasses should overwrite this to avoid the download
      Specified by:
        `locate` in interface `DependencyResolver`
      Overrides:
        `locate` in class `AbstractResolver`
      Parameters:
        `artifact` - the artifact which should be located
      Returns:
        the artifact location, or `null` if it can't be located by this resolver or doesn't exist.

    - #### getPublicationDate

          protected long getPublicationDate(ModuleDescriptor md,
                                DependencyDescriptor dd,
                                ResolveData data)

    - #### toString

          public java.lang.String toString()

      Overrides:
        `toString` in class `AbstractResolver`

    - #### listTokenValues

          public java.lang.String[] listTokenValues(java.lang.String token,
                                           java.util.Map otherTokenValues)

      Description copied from interface: `DependencyResolver`
      List all the values the given token can take if other tokens are set as described in the otherTokenValues map. For instance, if token = "revision" and the map contains "organisation"->"foo" "module"->"bar" The results will be the list of revisions of the module bar from the org foo.

      Note that listing does not take into account namespaces, and return raw information without any namespace transformation. The caller is responsible for calling namespace transformation with the Namespace returned by `DependencyResolver.getNamespace()`.

      Specified by:
        `listTokenValues` in interface `DependencyResolver`
      Overrides:
        `listTokenValues` in class `AbstractResolver`

    - #### listOrganisations

          public OrganisationEntry[] listOrganisations()

      Specified by:
        `listOrganisations` in interface `DependencyResolver`
      Overrides:
        `listOrganisations` in class `AbstractResolver`

    - #### listModules

          public ModuleEntry[] listModules(OrganisationEntry org)

      Specified by:
        `listModules` in interface `DependencyResolver`
      Overrides:
        `listModules` in class `AbstractResolver`

    - #### listRevisions

          public RevisionEntry[] listRevisions(ModuleEntry mod)

      Specified by:
        `listRevisions` in interface `DependencyResolver`
      Overrides:
        `listRevisions` in class `AbstractResolver`

    - #### findNames

          protected abstract java.util.Collection findNames(java.util.Map tokenValues,
                                       java.lang.String token)

    - #### findFirstArtifactRef

          protected ResolvedResource findFirstArtifactRef(ModuleDescriptor md,
                                              DependencyDescriptor dd,
                                              ResolveData data)

    - #### getAndCheck

          protected long getAndCheck(Resource resource,
                         java.io.File dest)
                              throws java.io.IOException

      Throws:
        `java.io.IOException`

    - #### getArtifactRef

          protected ResolvedResource getArtifactRef(Artifact artifact,
                                        java.util.Date date)

    - #### doFindArtifactRef

          public ResolvedResource doFindArtifactRef(Artifact artifact,
                                           java.util.Date date)

    - #### findArtifactRef

          protected abstract ResolvedResource findArtifactRef(Artifact artifact,
                                         java.util.Date date)

    - #### get

          protected abstract long get(Resource resource,
                 java.io.File dest)
                               throws java.io.IOException

      Throws:
        `java.io.IOException`

    - #### isCheckconsistency

          public boolean isCheckconsistency()

    - #### setCheckconsistency

          public void setCheckconsistency(boolean checkConsitency)

    - #### setForce

          public void setForce(boolean force)

    - #### isForce

          public boolean isForce()

    - #### isAllownomd

          public boolean isAllownomd()

    - #### setAllownomd

          public void setAllownomd(boolean b)

    - #### setDescriptor

          public void setDescriptor(java.lang.String descriptorRule)

      Sets the module descriptor presence rule. Should be one of `DESCRIPTOR_REQUIRED` or `DESCRIPTOR_OPTIONAL`.
      Parameters:
        `descriptorRule` - the descriptor rule to use with this resolver.

    - #### getChecksumAlgorithms

          public java.lang.String[] getChecksumAlgorithms()

    - #### setChecksums

          public void setChecksums(java.lang.String checksums)