import org.jboss.forge.furnace.versions.Version; //导入依赖的package包/类
/**
 * Create an {@link AddonId} from the given name, {@link Version}, and API {@link Version}.
 */
public static AddonId from(String name, Version version, Version apiVersion)
{
   Assert.notNull(name, "Name cannot be null.");
   if (name.trim().isEmpty())
      throw new IllegalArgumentException("Name cannot be empty.");
   Assert.notNull(version, "Version cannot be null.");
   if (version.toString().trim().isEmpty())
      throw new IllegalArgumentException("Version cannot be empty.");

   AddonId id = new AddonId();
   id.name = name;
   id.version = version;
   if (apiVersion == null || apiVersion.toString().trim().isEmpty())
      id.apiVersion = EmptyVersion.getInstance();
   else
      id.apiVersion = apiVersion;
   return id;
}
 

import org.jboss.forge.furnace.versions.Version; //导入依赖的package包/类
@Override
public List<AddonId> listEnabledCompatibleWithVersion(final Version version)
{
   return lock.performLocked(LockMode.READ, new Callable<List<AddonId>>()
   {
      @Override
      public List<AddonId> call() throws Exception
      {
         List<AddonId> list = listAll();
         List<AddonId> result = new ArrayList<>();
         for (AddonId entry : list)
         {
            if (version == null || entry.getApiVersion() == null
                     || Versions.isApiCompatible(version, entry.getApiVersion()))
            {
               result.add(entry);
            }
         }
         return result;
      }
   });
}
 

import org.jboss.forge.furnace.versions.Version; //导入依赖的package包/类
private ModuleIdentifier findCompatibleInstalledModule(AddonId addonId)
{
   ModuleIdentifier result = null;

   Addon addon = currentAddon.get();
   Version runtimeAPIVersion = AddonRepositoryImpl.getRuntimeAPIVersion();

   for (AddonRepository repository : stateManager.getViewsOf(addon).iterator().next().getRepositories())
   {
      List<AddonId> enabled = repository.listEnabledCompatibleWithVersion(runtimeAPIVersion);
      for (AddonId id : enabled)
      {
         if (id.getName().equals(addonId.getName()))
         {
            result = moduleCache.getModuleId(addon);
            break;
         }
      }
   }

   return result;
}
 

import org.jboss.forge.furnace.versions.Version; //导入依赖的package包/类
@Override
public List<AddonId> listEnabledCompatibleWithVersion(final Version version)
{
   return lock.performLocked(LockMode.READ, new Callable<List<AddonId>>()
   {
      @Override
      public List<AddonId> call() throws Exception
      {
         List<AddonId> list = listEnabled();
         List<AddonId> result = list;

         result = new ArrayList<AddonId>();
         for (AddonId entry : list)
         {
            if (version == null || entry.getApiVersion() == null
                     || Versions.isApiCompatible(version, entry.getApiVersion()))
            {
               result.add(entry);
            }
         }
         return result;
      }
   });
}
 

import org.jboss.forge.furnace.versions.Version; //导入依赖的package包/类
@Override
public Result execute(UIExecutionContext context) throws Exception
{
    if (!context.getPrompt().promptBoolean(
        "Are you sure you want to continue? This command will delete current directories: addons, bin, lib, rules/migration-core"))
    {
        return Results.fail("Updating distribution was aborted.");
    }

    // Find the latest version.
    Coordinate latestDist = this.updater.getLatestReleaseOf("org.jboss.windup", "windup-distribution");
    Version latestVersion = SingleVersion.valueOf(latestDist.getVersion());
    Version installedVersion = currentAddon.getId().getVersion();
    if (latestVersion.compareTo(installedVersion) <= 0)
    {
        return Results.fail(Util.WINDUP_BRAND_NAME_ACRONYM+" CLI is already in the most updated version.");
    }

    distUpdater.replaceWindupDirectoryWithDistribution(latestDist);

    return Results.success("Sucessfully updated "+Util.WINDUP_BRAND_NAME_ACRONYM+" CLI to version " + latestDist.getVersion() + ". Please restart RHAMT CLI.");
}
 

import org.jboss.forge.furnace.versions.Version; //导入依赖的package包/类
public static Version getRuntimeAPIVersion()
{
   String versionOverride = System.getProperty("furnace.version.override");
   if (versionOverride != null)
   {
      return SingleVersion.valueOf(versionOverride);
   }
   return Versions.getImplementationVersionFor(AddonRepository.class);
}
 

import org.jboss.forge.furnace.versions.Version; //导入依赖的package包/类
protected AddonVertex getVertex(String name, Version version)
{
   AddonVertex result = null;
   for (AddonVertex vertex : getGraph().vertexSet())
   {
      if (vertex.getName().equals(name) && version.compareTo(vertex.getVersion()) == 0)
      {
         result = vertex;
         break;
      }
   }
   return result;
}
 

import org.jboss.forge.furnace.versions.Version; //导入依赖的package包/类
protected AddonVertex getOrCreateVertex(String name, Version version)
{
   AddonVertex vertex = getVertex(name, version);
   if (vertex == null)
   {
      vertex = new AddonVertex(name, version);
      addLocalVertex(vertex);
   }
   return vertex;
}
 

import org.jboss.forge.furnace.versions.Version; //导入依赖的package包/类
public AddonVertex(String name, Version version)
{
   Assert.notNull(name, "Name must not be null.");
   Assert.notNull(version, "Version must not be null.");
   this.name = name;
   this.version = version;
}
 

import org.jboss.forge.furnace.versions.Version; //导入依赖的package包/类
public Set<AddonVertex> getVertices(String name, Version version)
{
   Set<AddonVertex> result = new HashSet<AddonVertex>();
   for (AddonVertex vertex : getGraph().vertexSet())
   {
      if (vertex.getName().equals(name) && version.compareTo(vertex.getVersion()) == 0)
      {
         result.add(vertex);
      }
   }
   return result;
}
 

import org.jboss.forge.furnace.versions.Version; //导入依赖的package包/类
public static Version getRuntimeAPIVersion()
{
   String version = AddonRepository.class.getPackage()
            .getImplementationVersion();
   if (version != null)
   {
      return new SingleVersion(version);
   }
   return EmptyVersion.getInstance();
}
 

import org.jboss.forge.furnace.versions.Version; //导入依赖的package包/类
public static Version getRuntimeAPIVersion()
{
    String version = Bootstrap.class.getPackage().getImplementationVersion();
    if (version != null)
    {
        return SingleVersion.valueOf(version);
    }
    return EmptyVersion.getInstance();
}
 

import org.jboss.forge.furnace.versions.Version; //导入依赖的package包/类
@Override
public Version getSpecVersion()
{
   return SingleVersion.valueOf("2.1");
}
 

import org.jboss.forge.furnace.versions.Version; //导入依赖的package包/类
@Override
public Version getVersion() {
    return new SingleVersion("2.0");
}
 

import org.jboss.forge.furnace.versions.Version; //导入依赖的package包/类
/**
 * Get the API {@link Version} of this {@link AddonId}.
 */
public Version getApiVersion()
{
   return apiVersion;
}
 

import org.jboss.forge.furnace.versions.Version; //导入依赖的package包/类
/**
 * Get the {@link Version} of this {@link AddonId}.
 */
public Version getVersion()
{
   return version;
}
 

import org.jboss.forge.furnace.versions.Version; //导入依赖的package包/类
@Test(expected = IllegalArgumentException.class)
public void testNullVersionCompact()
{
   AddonId.from("name", (Version) null);
}
 

import org.jboss.forge.furnace.versions.Version; //导入依赖的package包/类
@Test(expected = IllegalArgumentException.class)
public void testNoNameOrVersionCompact()
{
   AddonId.from(null, (Version) null);
}
 

import org.jboss.forge.furnace.versions.Version; //导入依赖的package包/类
public AddonInfoBuilder setAPIVersion(Version apiVersion)
{
   AddonId newId = AddonId.from(addon.getName(), addon.getVersion(), apiVersion);
   this.addon = newId;
   return this;
}
 

import org.jboss.forge.furnace.versions.Version; //导入依赖的package包/类
/**
 * Calculate the necessary request based in the list of installed addons for a given {@link MutableAddonRepository}
 *
 * @param addonInfo
 * @param repository
 * @param installedAddons
 * @return
 */
private AddonActionRequest createRequest(final AddonInfo requestedAddonInfo, final AddonInfo addonInfo,
         final MutableAddonRepository repository,
         final Map<AddonId, AddonRepository> installedAddons)
{
   final AddonActionRequest request;
   AddonId addon = addonInfo.getAddon();
   if (installedAddons.containsKey(addon))
   {
      // Already contains the installed addon. Update ONLY if the version is SNAPSHOT and if it is the requested
      // addon
      if (Versions.isSnapshot(addon.getVersion()) && addonInfo.equals(requestedAddonInfo))
      {
         AddonRepository addonRepository = installedAddons.get(addon);
         if (repository.equals(addonRepository))
         {
            request = createUpdateRequest(addonInfo, addonInfo, repository, furnace);
         }
         else
         {
            request = createDeployRequest(addonInfo, repository, furnace);
         }
      }
      else
      {
         request = null;
      }
   }
   else
   {
      // Addon is not installed or has a different version
      Entry<AddonId, AddonRepository> differentVersionEntry = null;
      for (Entry<AddonId, AddonRepository> addonEntry : installedAddons.entrySet())
      {
         AddonId addonId = addonEntry.getKey();
         if (addonId.getName().equals(addon.getName()))
         {
            differentVersionEntry = addonEntry;
            break;
         }
      }
      if (differentVersionEntry != null)
      {
         // Avoiding ClassCastExceptions
         Version differentVersion = SingleVersion.valueOf(differentVersionEntry.getKey().getVersion().toString());
         Version addonVersion = SingleVersion.valueOf(addon.getVersion().toString());
         // TODO: Review condition below
         // Update ONLY if it is the requested addon
         if (differentVersion.compareTo(addonVersion) < 0 && addonInfo.equals(requestedAddonInfo))
         {
            if (repository.equals(differentVersionEntry.getValue()))
            {
               request = createUpdateRequest(info(differentVersionEntry.getKey()), addonInfo, repository, furnace);
            }
            else
            {
               request = createDeployRequest(addonInfo, repository, furnace);
            }
         }
         else
         {
            // No update needed. Don't do anything with it
            request = null;
         }
      }
      else
      {
         request = createDeployRequest(addonInfo, repository, furnace);
      }
   }
   return request;
}