package net.sourceforge.javautil.classloader.resolver;
import java.util.ArrayList;
import java.util.List;
import net.sourceforge.javautil.classloader.resolver.impl.ClassPackageImpl;
import net.sourceforge.javautil.classloader.source.ClassSource;
/**
* Since the resolving process can get complicated, it is better recorded via
* a network based node relationship instead of something like a tree/node relationship.
*
* @author elponderador
* @author $Author$
* @version $Id$
*/
public class ClassPackageResolverNetworkNode {
public enum Type { Available, Downloadable, Unavailable }
protected boolean primary = false;
protected Type type;
protected ClassPackageResolverContext context;
protected IClassPackageDependencyReference reference;
protected List<ClassPackageResolverNetworkNode> relationships = new ArrayList<ClassPackageResolverNetworkNode>();
protected List<ClassPackageResolverNetworkNode> dependencies = new ArrayList<ClassPackageResolverNetworkNode>();
protected IClassPackageResolver resolver;
protected IClassPackageDescriptor descriptor;
protected ClassSource resolution;
protected IClassPackageRepositoryLocal repository;
protected IClassPackageRepositoryLocalImportable local;
protected IClassPackageRepositoryRemote remote;
public ClassPackageResolverNetworkNode(ClassPackageResolverContext context, IClassPackageDependencyReference reference) {
this.context = context;
this.reference = reference;
}
public ClassPackageResolverContext getContext() { return context; }
public void setContext(ClassPackageResolverContext context) { this.context = context; }
public Type getType() { return type; }
public void setType(Type type) { this.type = type; }
public IClassPackageDependencyReference getReference() { return reference; }
public void setReference(IClassPackageDependencyReference reference) { this.reference = reference; }
public List<ClassPackageResolverNetworkNode> getRelationships() { return relationships; }
public void setRelationships(List<ClassPackageResolverNetworkNode> relationships) { this.relationships = relationships; }
public List<ClassPackageResolverNetworkNode> getDependencies() { return dependencies; }
public void setDependencies(List<ClassPackageResolverNetworkNode> dependencies) { this.dependencies = dependencies; }
public IClassPackageDescriptor getDescriptor() { return descriptor; }
public void setDescriptor(IClassPackageDescriptor descriptor) { this.descriptor = descriptor; }
public boolean isPrimary() { return primary; }
public void setPrimary(boolean primary) { this.primary = primary; }
public IClassPackageResolver getResolver() { return resolver; }
public void setResolver(IClassPackageResolver resolver) { this.resolver = resolver; }
public ClassSource getResolution() { return resolution; }
public void setResolution(ClassSource resolution) { this.resolution = resolution; }
public IClassPackageRepositoryLocalImportable getLocal() { return local; }
public void setLocal(IClassPackageRepositoryLocalImportable local) { this.repository = this.local = local; }
public IClassPackageRepositoryLocal getRepository() { return repository; }
public void setRepository(IClassPackageRepositoryLocal repository) { this.repository = repository; }
public IClassPackageRepositoryRemote getRemote() { return remote; }
public void setRemote(IClassPackageRepositoryRemote remote) { this.remote = remote; }
public List<? extends IClassArtifactReference> getExclusions() { return reference.getExclusions(); }
public void importPackage (IClassPackageResolver resolver) {
local.importPackage(remote, resolver, reference);
local.clearCachedInformation(reference);
this.descriptor = local.getDescriptor(resolver, reference);
this.resolution = local.getMainClassSource(resolver, reference);
}
public IClassPackage createPackage () {
if (resolution == null) throw new ClassPackageException(reference, "Package not locally available: " + reference);
return new ClassPackageImpl(repository, descriptor, resolution);
}
}