org.apache.ivy.core.resolve

## Class IvyNode

- java.lang.Object
- - org.apache.ivy.core.resolve.IvyNode

- All Implemented Interfaces:
    java.lang.Comparable

      public class IvyNode
      extends java.lang.Object
      implements java.lang.Comparable

- - ### Constructor Summary

    Constructors
    Constructor and Description
    `IvyNode(ResolveData data, IvyNode parent, DependencyDescriptor dd)`
    `IvyNode(ResolveData data, ModuleDescriptor md)`

  - ### Method Summary

    Methods
    Modifier and Type | Method and Description
    --- | ---
    `void` | `addCaller(java.lang.String rootModuleConf, IvyNode callerNode, java.lang.String callerConf, java.lang.String requestedConf, java.lang.String[] dependencyConfs, DependencyDescriptor dd)`
    `void` | `blacklist(IvyNodeBlacklist bdata)` Blacklists the current node, so that a new resolve process won't ever consider this node as available in the repository.
    `void` | `clean()` Clean data related to one root module configuration only
    `int` | `compareTo(java.lang.Object obj)`
    `void` | `discardConf(java.lang.String rootModuleConf, java.lang.String conf)`
    `boolean` | `doesCallersExclude(java.lang.String rootModuleConf, Artifact artifact, java.util.Stack callersStack)`
    `boolean` | `equals(java.lang.Object obj)`
    `IvyNode` | `findNode(ModuleRevisionId mrid)`
    `Artifact[]` | `getAllArtifacts()` Returns all the artifacts of this dependency required in all the root module configurations
    `IvyNodeCallers.Caller[]` | `getAllCallers()`
    `java.util.Collection` | `getAllCallersModuleIds()`
    `java.util.Collection` | `getAllEvictingConflictManagers()`
    `java.util.Collection` | `getAllEvictingNodes()`
    `java.util.Collection` | `getAllEvictingNodesDetails()`
    `IvyNodeCallers.Caller[]` | `getAllRealCallers()`
    `Artifact[]` | `getArtifacts(java.lang.String rootModuleConf)` Returns the artifacts of this dependency required in the configurations themselves required in the given root module configuration
    `IvyNodeBlacklist` | `getBlacklistData(java.lang.String rootModuleConf)` Returns the blacklist data of this node in the given root module conf, or `null` if this node is not blacklisted in this root module conf.
    `IvyNodeCallers.Caller[]` | `getCallers(java.lang.String rootModuleConf)`
    `Configuration` | `getConfiguration(java.lang.String conf)`
    `java.lang.String[]` | `getConfigurations(java.lang.String rootModuleConf)` Returns the configurations of the dependency required in a given root module configuration.
    `ConflictManager` | `getConflictManager(ModuleId mid)`
    `java.lang.String[]` | `getConfsToFetch()`
    `ResolveData` | `getData()`
    `java.util.Collection` | `getDependencies(java.lang.String rootModuleConf, java.lang.String[] confs, java.lang.String requestedConf)`
    `java.util.Collection` | `getDependencies(java.lang.String rootModuleConf, java.lang.String conf, java.lang.String requestedConf)` Load the dependencies of the current node The resulting collection of nodes may have some configuration to load
    `DependencyDescriptor` | `getDependencyDescriptor(IvyNode parent)`
    `ModuleDescriptor` | `getDescriptor()`
    `java.lang.String[]` | `getEvictedConfs()`
    `IvyNodeEviction.EvictionData` | `getEvictedData(java.lang.String rootModuleConf)`
    `java.util.Collection` | `getEvictedNodes(ModuleId mid, java.lang.String rootModuleConf)`
    `java.util.Collection` | `getEvictedRevisions(ModuleId mid, java.lang.String rootModuleConf)`
    `IvyNodeEviction.EvictionData` | `getEvictionDataInRoot(java.lang.String rootModuleConf, IvyNode ancestor)`
    `ModuleRevisionId` | `getId()`
    `long` | `getLastModified()` Returns the last modified timestamp of the module represented by this Node, or 0 if the last modified timestamp is currently unkwown (module not loaded)
    `IvyNodeUsage` | `getMainUsage()`
    `ModuleId` | `getModuleId()`
    `ResolvedModuleRevision` | `getModuleRevision()`
    `java.util.Collection` | `getPendingConflicts(java.lang.String rootModuleConf, ModuleId mid)` Returns a collection of Nodes in conflict for which conflict has been detected but conflict resolution hasn't been done yet
    `java.lang.Exception` | `getProblem()`
    `java.lang.String` | `getProblemMessage()`
    `long` | `getPublication()`
    `java.lang.String[]` | `getRealConfs(java.lang.String conf)`
    `IvyNode` | `getRealNode()`
    `java.lang.String[]` | `getRequiredConfigurations()` returns all the current required configurations of the node
    `java.lang.String[]` | `getRequiredConfigurations(IvyNode in, java.lang.String inConf)` returns the required configurations from the given node
    `ModuleRevisionId` | `getResolvedId()`
    `java.util.Set` | `getResolvedNodes(ModuleId moduleId, java.lang.String rootModuleConf)` A copy of the set of resolved nodes (real nodes)
    `java.util.Collection` | `getResolvedRevisions(ModuleId moduleId, java.lang.String rootModuleConf)`
    `IvyNode` | `getRoot()`
    `java.lang.String[]` | `getRootModuleConfigurations()` Returns the root module configurations in which this dependency is required
    `java.util.Set` | `getRootModuleConfigurationsSet()` Returns the root module configurations in which this dependency is required
    `Artifact[]` | `getSelectedArtifacts(Filter artifactFilter)` Returns all the artifacts of this dependency required in the root module configurations in which the node is not evicted nor blacklisted
    `boolean` | `hasAnyMergedUsageWithTransitiveDependency(java.lang.String rootModuleConf)` Indicates if there is any of the merged usages of this node which has a depender with transitive dependency descriptor.
    `boolean` | `hasConfigurationsToLoad()`
    `int` | `hashCode()`
    `boolean` | `hasProblem()`
    `boolean` | `isBlacklisted(java.lang.String rootModuleConf)` Indicates if this node has been blacklisted in the given root module conf.
    `boolean` | `isCompletelyBlacklisted()` Indicates if this node has been blacklisted in all root module configurations.
    `boolean` | `isCompletelyEvicted()`
    `protected boolean` | `isConfRequiredByMergedUsageOnly(java.lang.String rootModuleConf, java.lang.String conf)`
    `boolean` | `isDownloaded()`
    `boolean` | `isEvicted(java.lang.String rootModuleConf)`
    `boolean` | `isFetched(java.lang.String conf)`
    `boolean` | `isLoaded()`
    `boolean` | `isSearched()`
    `boolean` | `loadData(java.lang.String rootModuleConf, IvyNode parent, java.lang.String parentConf, java.lang.String conf, boolean shouldBePublic, IvyNodeUsage usage)` After the call node may be discarded.
    `void` | `markEvicted(IvyNodeEviction.EvictionData evictionData)`
    `void` | `markEvicted(java.lang.String rootModuleConf, IvyNode node, ConflictManager conflictManager, java.util.Collection resolved)`
    `void` | `setEvictedNodes(ModuleId moduleId, java.lang.String rootModuleConf, java.util.Collection evicted)`
    `void` | `setPendingConflicts(ModuleId moduleId, java.lang.String rootModuleConf, java.util.Collection conflicts)`
    `void` | `setResolvedNodes(ModuleId moduleId, java.lang.String rootModuleConf, java.util.Collection resolved)`
    `java.lang.String` | `toString()`
    `void` | `updateConfsToFetch(java.util.Collection confs)`

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

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

- - ### Constructor Detail

    - #### IvyNode

          public IvyNode(ResolveData data,
                 IvyNode parent,
                 DependencyDescriptor dd)

    - #### IvyNode

          public IvyNode(ResolveData data,
                 ModuleDescriptor md)

  - ### Method Detail

    - #### loadData

          public boolean loadData(java.lang.String rootModuleConf,
                         IvyNode parent,
                         java.lang.String parentConf,
                         java.lang.String conf,
                         boolean shouldBePublic,
                         IvyNodeUsage usage)

      After the call node may be discarded. To avoid using discarded node, make sure to get the real node after the call IvyNode node = ... node.loadData(); node = node.getRealNode(); ...

    - #### getDependencies

          public java.util.Collection getDependencies(java.lang.String rootModuleConf,
                                             java.lang.String[] confs,
                                             java.lang.String requestedConf)

    - #### getDependencies

          public java.util.Collection getDependencies(java.lang.String rootModuleConf,
                                             java.lang.String conf,
                                             java.lang.String requestedConf)

      Load the dependencies of the current node

      The resulting collection of nodes may have some configuration to load

      Parameters:
        `rootModuleConf` - the requested configuration of the root module
        `conf` - the configuration to load of this node
        `requestedConf` - the actual node conf requested, possibly extending the `conf` one.
      Returns:

    - #### getDependencyDescriptor

          public DependencyDescriptor getDependencyDescriptor(IvyNode parent)

    - #### hasConfigurationsToLoad

          public boolean hasConfigurationsToLoad()

    - #### updateConfsToFetch

          public void updateConfsToFetch(java.util.Collection confs)

    - #### getRequiredConfigurations

          public java.lang.String[] getRequiredConfigurations(IvyNode in,
                                                     java.lang.String inConf)

      returns the required configurations from the given node
      Parameters:
        `in` -
      Returns:

    - #### getRequiredConfigurations

          public java.lang.String[] getRequiredConfigurations()

      returns all the current required configurations of the node
      Returns:

    - #### getConfiguration

          public Configuration getConfiguration(java.lang.String conf)

    - #### getConfigurations

          public java.lang.String[] getConfigurations(java.lang.String rootModuleConf)

      Returns the configurations of the dependency required in a given root module configuration.
      Parameters:
        `rootModuleConf` -
      Returns:

    - #### isConfRequiredByMergedUsageOnly

          protected boolean isConfRequiredByMergedUsageOnly(java.lang.String rootModuleConf,
                                                java.lang.String conf)

    - #### discardConf

          public void discardConf(java.lang.String rootModuleConf,
                         java.lang.String conf)

    - #### getRootModuleConfigurations

          public java.lang.String[] getRootModuleConfigurations()

      Returns the root module configurations in which this dependency is required
      Returns:

    - #### getRootModuleConfigurationsSet

          public java.util.Set getRootModuleConfigurationsSet()

      Returns the root module configurations in which this dependency is required
      Returns:

    - #### getConfsToFetch

          public java.lang.String[] getConfsToFetch()

    - #### getRealConfs

          public java.lang.String[] getRealConfs(java.lang.String conf)

    - #### getAllArtifacts

          public Artifact[] getAllArtifacts()

      Returns all the artifacts of this dependency required in all the root module configurations
      Returns:

    - #### getSelectedArtifacts

          public Artifact[] getSelectedArtifacts(Filter artifactFilter)

      Returns all the artifacts of this dependency required in the root module configurations in which the node is not evicted nor blacklisted
      Parameters:
        `artifactFilter` -
      Returns:

    - #### getArtifacts

          public Artifact[] getArtifacts(java.lang.String rootModuleConf)

      Returns the artifacts of this dependency required in the configurations themselves required in the given root module configuration
      Parameters:
        `rootModuleConf` -
      Returns:

    - #### hasProblem

          public boolean hasProblem()

    - #### getProblem

          public java.lang.Exception getProblem()

    - #### getProblemMessage

          public java.lang.String getProblemMessage()

    - #### isDownloaded

          public boolean isDownloaded()

    - #### isSearched

          public boolean isSearched()

    - #### isLoaded

          public boolean isLoaded()

    - #### isFetched

          public boolean isFetched(java.lang.String conf)

    - #### findNode

          public IvyNode findNode(ModuleRevisionId mrid)

    - #### getRoot

          public IvyNode getRoot()

    - #### getConflictManager

          public ConflictManager getConflictManager(ModuleId mid)

    - #### getRealNode

          public IvyNode getRealNode()

    - #### getId

          public ModuleRevisionId getId()

    - #### getModuleId

          public ModuleId getModuleId()

    - #### getDescriptor

          public ModuleDescriptor getDescriptor()

    - #### getData

          public ResolveData getData()

    - #### getModuleRevision

          public ResolvedModuleRevision getModuleRevision()

    - #### getPublication

          public long getPublication()

    - #### getLastModified

          public long getLastModified()

      Returns the last modified timestamp of the module represented by this Node, or 0 if the last modified timestamp is currently unkwown (module not loaded)
      Returns:
        the last modified timestamp of the module represented by this Node

    - #### getResolvedId

          public ModuleRevisionId getResolvedId()

    - #### clean

          public void clean()

      Clean data related to one root module configuration only

    - #### getCallers

          public IvyNodeCallers.Caller[] getCallers(java.lang.String rootModuleConf)

    - #### getAllCallersModuleIds

          public java.util.Collection getAllCallersModuleIds()

    - #### getAllCallers

          public IvyNodeCallers.Caller[] getAllCallers()

    - #### getAllRealCallers

          public IvyNodeCallers.Caller[] getAllRealCallers()

    - #### addCaller

          public void addCaller(java.lang.String rootModuleConf,
                       IvyNode callerNode,
                       java.lang.String callerConf,
                       java.lang.String requestedConf,
                       java.lang.String[] dependencyConfs,
                       DependencyDescriptor dd)

    - #### doesCallersExclude

          public boolean doesCallersExclude(java.lang.String rootModuleConf,
                                   Artifact artifact,
                                   java.util.Stack callersStack)

    - #### getResolvedNodes

          public java.util.Set getResolvedNodes(ModuleId moduleId,
                                       java.lang.String rootModuleConf)

      A copy of the set of resolved nodes (real nodes)

    - #### getResolvedRevisions

          public java.util.Collection getResolvedRevisions(ModuleId moduleId,
                                                  java.lang.String rootModuleConf)

    - #### markEvicted

          public void markEvicted(IvyNodeEviction.EvictionData evictionData)

    - #### getAllEvictingConflictManagers

          public java.util.Collection getAllEvictingConflictManagers()

    - #### getAllEvictingNodes

          public java.util.Collection getAllEvictingNodes()

    - #### getAllEvictingNodesDetails

          public java.util.Collection getAllEvictingNodesDetails()

    - #### getEvictedConfs

          public java.lang.String[] getEvictedConfs()

    - #### getEvictedData

          public IvyNodeEviction.EvictionData getEvictedData(java.lang.String rootModuleConf)

    - #### getEvictedNodes

          public java.util.Collection getEvictedNodes(ModuleId mid,
                                             java.lang.String rootModuleConf)

    - #### getEvictedRevisions

          public java.util.Collection getEvictedRevisions(ModuleId mid,
                                                 java.lang.String rootModuleConf)

    - #### getEvictionDataInRoot

          public IvyNodeEviction.EvictionData getEvictionDataInRoot(java.lang.String rootModuleConf,
                                                           IvyNode ancestor)

    - #### isCompletelyEvicted

          public boolean isCompletelyEvicted()

    - #### isEvicted

          public boolean isEvicted(java.lang.String rootModuleConf)

    - #### markEvicted

          public void markEvicted(java.lang.String rootModuleConf,
                         IvyNode node,
                         ConflictManager conflictManager,
                         java.util.Collection resolved)

    - #### setEvictedNodes

          public void setEvictedNodes(ModuleId moduleId,
                             java.lang.String rootModuleConf,
                             java.util.Collection evicted)

    - #### setResolvedNodes

          public void setResolvedNodes(ModuleId moduleId,
                              java.lang.String rootModuleConf,
                              java.util.Collection resolved)

    - #### toString

          public java.lang.String toString()

      Overrides:
        `toString` in class `java.lang.Object`

    - #### equals

          public boolean equals(java.lang.Object obj)

      Overrides:
        `equals` in class `java.lang.Object`

    - #### compareTo

          public int compareTo(java.lang.Object obj)

      Specified by:
        `compareTo` in interface `java.lang.Comparable`

    - #### hashCode

          public int hashCode()

      Overrides:
        `hashCode` in class `java.lang.Object`

    - #### getPendingConflicts

          public java.util.Collection getPendingConflicts(java.lang.String rootModuleConf,
                                                 ModuleId mid)

      Returns a collection of Nodes in conflict for which conflict has been detected but conflict resolution hasn't been done yet
      Parameters:
        `rootModuleConf` -
        `mid` - the module id for which pending conflicts should be found
      Returns:
        a Collection of IvyNode in pending conflict

    - #### setPendingConflicts

          public void setPendingConflicts(ModuleId moduleId,
                                 java.lang.String rootModuleConf,
                                 java.util.Collection conflicts)

    - #### blacklist

          public void blacklist(IvyNodeBlacklist bdata)

      Blacklists the current node, so that a new resolve process won't ever consider this node as available in the repository.

      This is useful in combination with `RestartResolveProcess` for conflict manager implementation which use a best effort strategy to find compatible dependency set, like `LatestCompatibleConflictManager`

      Parameters:
        `rootModuleConf` - the root module configuration in which the node should be blacklisted

    - #### isBlacklisted

          public boolean isBlacklisted(java.lang.String rootModuleConf)

      Indicates if this node has been blacklisted in the given root module conf.

      A blacklisted node should be considered as if it doesn't even exist on the repository.

      Parameters:
        `rootModuleConf` - the root module conf for which we'd like to know if the node is blacklisted
      Returns:
        true if this node is blacklisted int he given root module conf, false otherwise
      See Also:
        `#blacklist(String)`

    - #### isCompletelyBlacklisted

          public boolean isCompletelyBlacklisted()

      Indicates if this node has been blacklisted in all root module configurations.
      Returns:
        true if this node is blacklisted in all root module configurations, false otherwise
      See Also:
        `#blacklist(String)`

    - #### getBlacklistData

          public IvyNodeBlacklist getBlacklistData(java.lang.String rootModuleConf)

      Returns the blacklist data of this node in the given root module conf, or `null` if this node is not blacklisted in this root module conf.
      Parameters:
        `rootModuleConf` - the root module configuration to consider
      Returns:
        the blacklist data if any

    - #### getMainUsage

          public IvyNodeUsage getMainUsage()

    - #### hasAnyMergedUsageWithTransitiveDependency

          public boolean hasAnyMergedUsageWithTransitiveDependency(java.lang.String rootModuleConf)

      Indicates if there is any of the merged usages of this node which has a depender with transitive dependency descriptor.

      If at there is at least one usage from the merged usages for which there is a depender in the given root module conf which has a dependency descriptor with transitive == true, then it returns true. Otherwise it returns false.

      Parameters:
        `rootModuleConf` - the root module configuration to consider
      Returns:
        true if there is any merged usage with transitive dd, false otherwise.