Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  package org.apache.maven.artifact.resolver;
  
  /*
   * Licensed to the Apache Software Foundation (ASF) under one
   * or more contributor license agreements.  See the NOTICE file
   * distributed with this work for additional information
   * regarding copyright ownership.  The ASF licenses this file
   * to you under the Apache License, Version 2.0 (the
   * "License"); you may not use this file except in compliance
  * with the License.  You may obtain a copy of the License at
  *
  *  http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing,
  * software distributed under the License is distributed on an
  * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
  * KIND, either express or implied.  See the License for the
  * specific language governing permissions and limitations
  * under the License.
  */
 
 import java.util.List;
 import java.util.Set;
 
 
 public class ResolutionNode
 {
     private Artifact artifact;
 
     private List<ResolutionNodechildren;
 
     private final List<Objectparents;
 
     private final int depth;
 
     private final ResolutionNode parent;
 
     private final List<ArtifactRepositoryremoteRepositories;
 
     private boolean active = true;
 
     private List<Artifacttrail;
 
     public ResolutionNodeArtifact artifactList<ArtifactRepositoryremoteRepositories )
     {
         this. = artifact;
         this. = remoteRepositories;
          = 0;
          = Collections.emptyList();
          = null;
     }
 
     public ResolutionNodeArtifact artifactList<ArtifactRepositoryremoteRepositoriesResolutionNode parent )
     {
         this. = artifact;
         this. = remoteRepositories;
          = parent.depth + 1;
          = new ArrayList<Object>();
         .addAllparent.parents );
         .addparent.getKey() );
         this. = parent;
     }
 
     public Artifact getArtifact()
     {
         return ;
     }
 
     public Object getKey()
     {
         return .getDependencyConflictId();
     }
 
     public void addDependenciesSet<ArtifactartifactsList<ArtifactRepositoryremoteRepositories,
                                  ArtifactFilter filter )
     {
         if ( artifacts != null && !artifacts.isEmpty() )
         {
              = new ArrayList<ResolutionNode>( artifacts.size() );
 
             for ( Artifact a : artifacts )
             {
                 if ( .containsa.getDependencyConflictId() ) )
                 {
                     a.setDependencyTrailgetDependencyTrail() );
 
                     throw new CyclicDependencyException"A dependency has introduced a cycle"a );
                 }
 
                .addnew ResolutionNodearemoteRepositoriesthis ) );
            }
        }
        else
        {
             = Collections.emptyList();
        }
         = null;
    }

    
    public List<StringgetDependencyTrail()
        throws OverConstrainedVersionException
    {
        List<Artifacttrial = getTrail();
        List<Stringret = new ArrayList<String>( trial.size() );
        for ( Artifact artifact : trial )
        {
            ret.addartifact.getId() );
        }
        return ret;
    }
    private List<ArtifactgetTrail()
        throws OverConstrainedVersionException
    {
        if (  == null )
        {
            List<Artifactids = new LinkedList<Artifact>();
            ResolutionNode node = this;
            while ( node != null )
            {
                Artifact artifact = node.getArtifact();
                if ( artifact.getVersion() == null )
                {
                    // set the recommended version
                    ArtifactVersion selected = artifact.getSelectedVersion();
                    // MNG-2123: null is a valid response to getSelectedVersion, don't
                    // assume it won't ever be.
                    if ( selected != null )
                    {
                        artifact.selectVersionselected.toString() );
                    }
                    else
                    {
                        throw new OverConstrainedVersionException"Unable to get a selected Version for "
                            + artifact.getArtifactId(), artifact );
                    }
                }
                ids.add( 0, artifact );
                node = node.parent;
            }
             = ids;
        }
        return ;
    }
    public boolean isResolved()
    {
        return  != null;
    }

    
Test whether the node is direct or transitive dependency.
    public boolean isChildOfRootNode()
    {
        return  != null && . == null;
    }
    {
        return .iterator();
    }
    public int getDepth()
    {
        return ;
    }
    {
        return ;
    }
    public boolean isActive()
    {
        return ;
    }
    public void enable()
    {
         = true;
        // TODO: if it was null, we really need to go find them now... or is this taken care of by the ordering?
        if (  != null )
        {
            for ( ResolutionNode node :  )
            {
                node.enable();
            }
        }
    }
    public void disable()
    {
         = false;
        if (  != null )
        {
            for ( ResolutionNode node :  )
            {
                node.disable();
            }
        }
    }
    public boolean filterTrailArtifactFilter filter )
        throws OverConstrainedVersionException
    {
        boolean success = true;
        if ( filter != null )
        {
            for ( Artifact artifact : getTrail() )
            {
                if ( !filter.includeartifact ) )
                {
                    success = false;
                }
            }
        }
        return success;
    }
    @Override
    public String toString()
    {
        return .toString() + " (" +  + "; " + (  ? "enabled" : "disabled" ) + ")";
    }
    public void setArtifactArtifact artifact )
    {
        this. = artifact;
    }
New to GrepCode? Check out our FAQ X