Java 类net.minecraftforge.fml.common.versioning.ArtifactVersion 实例源码

/**
 * Draws the screen and all the components in it.
 */
@Override
public void drawScreen(int mouseX, int mouseY, float partialTicks)
{
    this.drawDefaultBackground();
    int offset = Math.max(85 - modsMissing.missingMods.size() * 10, 10);
    this.drawCenteredString(this.fontRendererObj, "Forge Mod Loader could not connect to this server", this.width / 2, offset, 0xFFFFFF);
    offset += 10;
    this.drawCenteredString(this.fontRendererObj, "The mods and versions listed below could not be found", this.width / 2, offset, 0xFFFFFF);
    offset += 10;
    this.drawCenteredString(this.fontRendererObj, "They are required to play on this server", this.width / 2, offset, 0xFFFFFF);
    offset += 5;
    for (ArtifactVersion v : modsMissing.missingMods)
    {
        offset += 10;
        this.drawCenteredString(this.fontRendererObj, String.format("%s : %s", v.getLabel(), v.getRangeString()), this.width / 2, offset, 0xEEEEEE);
    }
    super.drawScreen(mouseX, mouseY, partialTicks);
}

/**
 * Draws the screen and all the components in it.
 */
@Override
public void drawScreen(int mouseX, int mouseY, float partialTicks)
{
    this.drawDefaultBackground();
    int offset = Math.max(85 - modsMissing.missingMods.size() * 10, 10);
    String modMissingDependenciesText = I18n.format("fml.messages.mod.missing.dependencies", TextFormatting.BOLD + modsMissing.getModName() + TextFormatting.RESET);
    this.drawCenteredString(this.fontRendererObj, modMissingDependenciesText, this.width / 2, offset, 0xFFFFFF);
    offset+=10;
    String fixMissingDependenciesText = I18n.format("fml.messages.mod.missing.dependencies.fix", modsMissing.getModName());
    this.drawCenteredString(this.fontRendererObj, fixMissingDependenciesText, this.width / 2, offset, 0xFFFFFF);
    offset+=5;
    for (ArtifactVersion v : modsMissing.missingMods)
    {
        offset+=10;
        if (v instanceof DefaultArtifactVersion)
        {
            DefaultArtifactVersion dav =  (DefaultArtifactVersion)v;
            if (dav.getRange() != null)
            {
                String message = String.format(TextFormatting.BOLD +  "%s " + TextFormatting.RESET + "%s", v.getLabel(), dav.getRange().toStringFriendly());
                this.drawCenteredString(this.fontRendererObj, message, this.width / 2, offset, 0xEEEEEE);
                continue;
            }
        }
        this.drawCenteredString(this.fontRendererObj, String.format("%s : %s", v.getLabel(), v.getRangeString()), this.width / 2, offset, 0xEEEEEE);
    }
    offset+=20;
    String seeLogText = I18n.format("fml.messages.mod.missing.dependencies.see.log", clientLog.getName());
    this.drawCenteredString(this.fontRendererObj, seeLogText, this.width / 2, offset, 0xFFFFFF);

    for (int i = 0; i < this.buttonList.size(); ++i)
    {
        this.buttonList.get(i).drawButton(this.mc, mouseX, mouseY);
    }
}

private void sendEventToModContainer(FMLEvent stateEvent, ModContainer mc)
{
    String modId = mc.getModId();
    Collection<String> requirements =  Collections2.transform(mc.getRequirements(),new ArtifactVersionNameFunction());
    for (ArtifactVersion av : mc.getDependencies())
    {
        if (av.getLabel()!= null && requirements.contains(av.getLabel()) && modStates.containsEntry(av.getLabel(),ModState.ERRORED))
        {
            FMLLog.log(modId, Level.ERROR, "Skipping event %s and marking errored mod %s since required dependency %s has errored", stateEvent.getEventType(), modId, av.getLabel());
            modStates.put(modId, ModState.ERRORED);
            return;
        }
    }
    activeContainer = mc;
    stateEvent.applyModContainer(activeContainer());
    ThreadContext.put("mod", modId);
    FMLLog.log(modId, Level.TRACE, "Sending event %s to mod %s", stateEvent.getEventType(), modId);
    eventChannels.get(modId).post(stateEvent);
    FMLLog.log(modId, Level.TRACE, "Sent event %s to mod %s", stateEvent.getEventType(), modId);
    ThreadContext.remove("mod");
    activeContainer = null;
    if (stateEvent instanceof FMLStateEvent)
    {
        if (!errors.containsKey(modId))
        {
            modStates.put(modId, ((FMLStateEvent)stateEvent).getModState());
        }
        else
        {
            modStates.put(modId, ModState.ERRORED);
        }
    }
}

public APIContainer(String providedAPI, String apiVersion, File source, ArtifactVersion ownerMod)
{
    this.providedAPI = providedAPI;
    this.version = apiVersion;
    this.ownerMod = ownerMod;
    this.ourVersion = new DefaultArtifactVersion(providedAPI, apiVersion);
    this.referredMods = Lists.newArrayList();
    this.source = source;
    this.currentReferents = Sets.newHashSet();
    this.packages = Sets.newHashSet();
}

@Override
protected void printStackTrace(WrappedPrintStream stream)
{
    stream.println("Missing Mods:");
    for (ArtifactVersion v : missingMods)
    {
        stream.println(String.format("\t%s : %s", v.getLabel(), v.getRangeString()));
    }
    stream.println("");
}

/**
 * Initialize the mod
 */
public ModContainer() {
    super(meta = new ModMetadata());

    meta.authorList = Arrays.asList("cazzar");
    meta.description = "The core library for cazzar's mods";
    meta.modId = Reference.MOD_ID;
    meta.name = "Cazzar Core Lib";
    meta.dependants = Arrays.asList((ArtifactVersion) new DefaultArtifactVersion("jukeboxreloaded", true));
    meta.url = "http://www.cazzar.net/";
    meta.version = getVersionFromJar();
}

public static void processModsList(Map<String, Object> json)
{
    for(ModVersionInfo info : registeredMods)
    {
        Map<String, String> versionInfo = (Map<String, String>)json.get(info.modName);
        if(versionInfo != null && versionInfo.containsKey(info.mcVersion))
        {
            ArtifactVersion current = new DefaultArtifactVersion(info.modVersion);

            String lat = versionInfo.get(info.mcVersion);
            ArtifactVersion latest = new DefaultArtifactVersion(lat);

            int diff = latest.compareTo(current);

            if(diff > 0)
            {
                info.modVersionNew = lat.trim();
                modsWithUpdates.add(info);
                if(requireLogging && !info.isModClientOnly)
                {
                    iChunUtil.LOGGER.info("[NEW UPDATE AVAILABLE] " + info.modName + " - " + info.modVersionNew);
                }
            }
        }
    }

    requireLogging = false;
    updatesChecked = true;
}

@Override
public Set<ArtifactVersion> getRequirements()
{
    return wrappedContainer.getRequirements();
}

@Override
public List<ArtifactVersion> getDependencies()
{
    return wrappedContainer.getDependencies();
}

@Override
public List<ArtifactVersion> getDependants()
{
    return wrappedContainer.getDependants();
}

@Override
public ArtifactVersion getProcessedVersion()
{
    return wrappedContainer.getProcessedVersion();
}

@Override
public void write(JsonWriter out, ArtifactVersion value) throws IOException
{
    // no op - we never write these out
}

@Override
public ArtifactVersion read(JsonReader in) throws IOException
{
    return VersionParser.parseVersionReference(in.nextString());
}

@Override
public List<ArtifactVersion> getDependants()
{
    return referredMods;
}

@Override
public List<ArtifactVersion> getDependencies()
{
    return selfReferenced ? ImmutableList.<ArtifactVersion>of() : ImmutableList.of(ownerMod);
}

@Override
public ArtifactVersion getProcessedVersion()
{
    return ourVersion;
}

@Override
public List<ArtifactVersion> getDependants()
{
    return Collections.emptyList();
}

@Override
public List<ArtifactVersion> getDependencies()
{
    return Collections.emptyList();
}

@Override
public Set<ArtifactVersion> getRequirements()
{
    return Collections.emptySet();
}

public MissingModsException(Set<ArtifactVersion> missingMods, String id, String name)
{
    super(String.format("Mod %s (%s) requires %s", id, name, missingMods));
    this.missingMods = missingMods;
    this.modName = name;
}

public void computeDependencies(String dependencyString, Set<ArtifactVersion> requirements, List<ArtifactVersion> dependencies, List<ArtifactVersion> dependants)
{
    if (dependencyString == null || dependencyString.length() == 0)
    {
        return;
    }

    boolean parseFailure = false;

    for (String dep : DEPENDENCYSPLITTER.split(dependencyString))
    {
        List<String> depparts = Lists.newArrayList(DEPENDENCYPARTSPLITTER.split(dep));
        // Need two parts to the string
        if (depparts.size() != 2)
        {
            parseFailure = true;
            continue;
        }
        String instruction = depparts.get(0);
        String target = depparts.get(1);
        boolean targetIsAll = target.startsWith("*");

        // Cannot have an "all" relationship with anything except pure *
        if (targetIsAll && target.length() > 1)
        {
            parseFailure = true;
            continue;
        }

        // If this is a required element, add it to the required list
        if ("required-before".equals(instruction) || "required-after".equals(instruction))
        {
            // You can't require everything
            if (!targetIsAll)
            {
                requirements.add(VersionParser.parseVersionReference(target));
            }
            else
            {
                parseFailure = true;
                continue;
            }
        }

        // You cannot have a versioned dependency on everything
        if (targetIsAll && target.indexOf('@') > -1)
        {
            parseFailure = true;
            continue;
        }
        // before elements are things we are loaded before (so they are our dependants)
        if ("required-before".equals(instruction) || "before".equals(instruction))
        {
            dependants.add(VersionParser.parseVersionReference(target));
        }
        // after elements are things that load before we do (so they are out dependencies)
        else if ("required-after".equals(instruction) || "after".equals(instruction))
        {
            dependencies.add(VersionParser.parseVersionReference(target));
        }
        else
        {
            parseFailure = true;
        }
    }

    if (parseFailure)
    {
        FMLLog.log(Level.WARN, "Unable to parse dependency string %s", dependencyString);
        throw new LoaderException(String.format("Unable to parse dependency string %s", dependencyString));
    }
}

List<ArtifactVersion> getInjectedBefore(String modId)
{
    return injectedBefore.get(modId);
}

List<ArtifactVersion> getInjectedAfter(String modId)
{
    return injectedAfter.get(modId);
}

@Override
public Set<ArtifactVersion> getRequirements()
{
    return modMetadata.requiredMods;
}

@Override
public List<ArtifactVersion> getDependencies()
{
    return modMetadata.dependencies;
}

@Override
public List<ArtifactVersion> getDependants()
{
    return modMetadata.dependants;
}

@Override
public String apply(ArtifactVersion v)
{
    return v.getLabel();
}

@Override
public Set<ArtifactVersion> getRequirements()
{
    return null;
}

@Override
public List<ArtifactVersion> getDependencies()
{
    return null;
}

@Override
public List<ArtifactVersion> getDependants()
{
    return null;
}

@Override
public ArtifactVersion getProcessedVersion()
{
    return null;
}

@Override
public Set<ArtifactVersion> getRequirements()
{
    return null;
}

@Override
public List<ArtifactVersion> getDependencies()
{
    return null;
}

@Override
public List<ArtifactVersion> getDependants()
{
    return null;
}

@Override
public ArtifactVersion getProcessedVersion()
{
    return null;
}

@Override
public List<ArtifactVersion> getDependencies() {
    return new LinkedList<ArtifactVersion>(getRequirements());
}

@Override
public Set<ArtifactVersion> getRequirements() {
    return packMetadata.requiredMods;
}

@Override
public List<ArtifactVersion> getDependencies() {
    return Collections.emptyList();
}

@Override
public List<ArtifactVersion> getDependants() {
    return Collections.emptyList();
}