(Solved) [1.8] Gson error

[SCAREX]

Recently I've been using Gson but in the last days I had problems with Gson, so I have deleted my last modifications but nothing could correct this problem. (I'm using MinecraftForge 1.8-11.14.1.1397)

 

Stacktrace :

 

Thread [updater Thread] (Suspended (exception NoClassDefFoundError))

Gson.fromJson(JsonReader, Type) line: 820

Gson.fromJson(Reader, Type) line: 768

Gson.fromJson(String, Type) line: 717

Gson.fromJson(String, Class<T>) line: 689

Updater$1.run() line: 114

 

My code :

package fr.scarex.updater;

import java.io.InputStream;
import java.lang.reflect.Method;
import java.lang.reflect.Type;
import java.net.HttpURLConnection;
import java.net.MalformedURLException;
import java.net.Proxy;
import java.net.URL;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Comparator;
import java.util.Iterator;
import java.util.List;
import java.util.Map.Entry;
import java.util.TreeMap;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

import net.minecraft.client.Minecraft;
import net.minecraftforge.common.MinecraftForge;
import net.minecraftforge.fml.common.Loader;
import net.minecraftforge.fml.common.Mod;
import net.minecraftforge.fml.common.ModContainer;
import net.minecraftforge.fml.common.event.FMLInitializationEvent;

import org.apache.commons.io.Charsets;
import org.apache.commons.io.IOUtils;
import org.apache.commons.lang3.ArrayUtils;
import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;

import com.google.gson.Gson;
import com.google.gson.GsonBuilder;
import com.google.gson.JsonArray;
import com.google.gson.JsonDeserializationContext;
import com.google.gson.JsonDeserializer;
import com.google.gson.JsonElement;
import com.google.gson.JsonObject;
import com.google.gson.JsonParseException;

import fr.scarex.updater.exception.VersionFormatException;
import fr.scarex.updater.handler.UpdaterHandler;

/**
* @author SCAREX
*/
@Mod(modid = Updater.MODID, name = Updater.NAME, version = Updater.VERSION, clientSideOnly = true)
public class Updater
{
public static final String MODID = "supdater";
public static final String NAME = "Updater";
public static final String VERSION = "0.1.0-SNAPSHOT";

public static final Logger logger = LogManager.getLogger("Updater");

public static Gson gson;

public static Version mcversion;

@Mod.EventHandler
public void init(FMLInitializationEvent event) {
	GsonBuilder builder = new GsonBuilder();
	builder.registerTypeAdapter(Version.class, new VersionDeserializer());
	builder.registerTypeAdapter(ModVersions.class, new ModVersionsDeserializer());
	gson = builder.create();
	MinecraftForge.EVENT_BUS.register(new UpdaterHandler());
	doUpdate();
}

public static ArrayList<ModVersions> modsList = new ArrayList<Updater.ModVersions>();

public String getVersionFileURL() {
	return "http://scarex.on.vg/Updater/versions.json";
}

public String getUpdaterVersion() {
	return Updater.VERSION;
}

public static void doUpdate() {
	Thread t = new Thread("Updater Thread") {
		@Override
		public void run() {
			try {
				mcversion = Version.parseMcVersion();
			} catch (VersionFormatException e1) {
				e1.printStackTrace();
			}

			modsList.clear();
			for (ModContainer mod : Loader.instance().getModList()) {
				if (mod.getMod() != null) {
					Class<?> clazz = mod.getMod().getClass();
					if (!clazz.getCanonicalName().startsWith("net.minecraft")) {
						try {
							String rawVersion;
							Version currentVersion;
							try {
								Method versionMethod = clazz.getDeclaredMethod("getUpdaterVersion");
								rawVersion = (String) versionMethod.invoke(mod.getMod());
								currentVersion = Version.parseVersion(rawVersion);
							} catch (Exception e) {
								rawVersion = mod.getVersion();
								currentVersion = Version.parseVersion(rawVersion);
							}
							String stringUrl = (String) clazz.getDeclaredMethod("getVersionFileURL").invoke(mod.getMod());
							URL versionFile = new URL(stringUrl);

							InputStream is = null;
							try {
								HttpURLConnection con = (HttpURLConnection) versionFile.openConnection(Proxy.NO_PROXY);
								con.setConnectTimeout(15000);
								con.setReadTimeout(15000);

								is = con.getInputStream();
								ModVersions modV = gson.fromJson(IOUtils.toString(is, Charsets.UTF_, ModVersions.class);
								modV.setModContainer(mod);
								modV.setVersionFileLink(stringUrl);
								modV.setCurrentVersion(currentVersion);
								modsList.add(modV);
							} catch (Exception e) {
								logger.warn("Couldn't get version file with given url : " + versionFile, e);
							}
							IOUtils.closeQuietly(is);
						} catch (Exception e) {
							logger.warn("Couldn't retrieve mod's informations from mod " + mod.getName() + "(" + clazz.getCanonicalName() + ")", e);
						}
					}
				}
			}
		}
	};
	t.start();
}

public static class ModVersions
{
	public static final Comparator<String> comparator = new Comparator<String>() {
		@Override
		public int compare(String s, String s1) {
			try {
				return Version.parseVersion(s).isNewerOrEqualWithSameIndex(mcversion, 1) ? (Version.parseVersion(s1).isNewerOrEqualWithSameIndex(mcversion, 1) ? s.compareTo(s1) : 1) : -1;
			} catch (VersionFormatException e) {
				e.printStackTrace();
			}
			return 0;
		}
	};
	public static final Pattern PARAMETERS_FINDER = Pattern.compile("{{(.+)}}");
	private ModContainer modContainer;
	private String versionFileLink;
	private String downloadLink;
	private TreeMap<String, Version[]> versions;
	private Version currentVersion;

	public ModVersions(ModContainer modC, String modid, String versionFile, String dlink, TreeMap<String, Version[]> versions, Version currentV) {
		this.modContainer = modC;
		this.versionFileLink = versionFile;
		this.downloadLink = dlink;
		this.versions = versions;
		this.currentVersion = currentV;
	}

	public ModVersions(String dlink, TreeMap<String, Version[]> versions) {
		this.downloadLink = dlink;
		this.versions = versions;
	}

	public Version getLatestVersionForUser(byte usertype, boolean acceptSnapshots) {
		Entry<String, Version[]> entry = this.versions.lastEntry();
		if ((entry.getKey().substring(0, 3)).equalsIgnoreCase(Minecraft.getMinecraft().getVersion().substring(0, 3))) {
			Version[] versions = entry.getValue();
			Version version = versions[0];
			for (int i = 0; i < versions.length; i++) {
				if (versions[i].isNewerThanOrEqual(version) && versions[i].getUserType() == usertype && (versions[i].isSnapshot() && acceptSnapshots)) version = versions[i];
			}
			return version;
		}
		return null;
	}

	public URL getDownloadLinkForVersion(Version v, String mcversion) {
		String beginning = this.versionFileLink.replaceFirst("/(*)$", "");
		String middle = this.downloadLink != null ? this.downloadLink : "";
		String end = v.getDownloadLink() != null ? v.getDownloadLink() : "";
		logger.info(beginning + " | " + middle + " | " + end);
		String fullURL = "";
		if (v.getDownloadLink().startsWith("http://") || v.getDownloadLink().startsWith("https://")) {
			fullURL = v.getDownloadLink();
		} else {
			if (middle.startsWith("http://") || middle.startsWith("https://"))
				fullURL = middle + end;
			else
				fullURL = beginning + middle + end;
		}
		StringBuffer sb = new StringBuffer(fullURL);
		Matcher m = PARAMETERS_FINDER.matcher(fullURL);
		while (m.find()) {
			if ("name".equalsIgnoreCase(m.group(1)))
				m.appendReplacement(sb, v.getName());
			else if ("version".equalsIgnoreCase(m.group(1)))
				m.appendReplacement(sb, v.getVersionString());
			else if ("user-type".equalsIgnoreCase(m.group(1)))
				m.appendReplacement(sb, "" + v.getUserType());
			else if ("importance".equalsIgnoreCase(m.group(1)))
				m.appendReplacement(sb, "" + v.getImportance());
			else if ("mc-version".equalsIgnoreCase(m.group(1))) m.appendReplacement(sb, mcversion);
		}
		m.appendTail(sb);
		logger.info(sb.toString());
		URL url = null;
		try {
			url = new URL(sb.toString());
		} catch (MalformedURLException e) {
			logger.warn(e);
		}
		return url;
	}

	public ModContainer getModContainer() {
		return this.modContainer;
	}

	public void setModContainer(ModContainer modC) {
		this.modContainer = modC;
	}

	public String getVersionFileLink() {
		return versionFileLink;
	}

	public void setVersionFileLink(String versionFileLink) {
		this.versionFileLink = versionFileLink;
	}

	public Version getCurrentVersion() {
		return currentVersion;
	}

	public void setCurrentVersion(Version currentVersion) {
		this.currentVersion = currentVersion;
	}

	public TreeMap<String, Version[]> getVersions() {
		return versions;
	}

	public void setVersions(TreeMap<String, Version[]> versions) {
		this.versions = versions;
	}

	@Override
	public String toString() {
		return "ModVersions [modContainer=" + modContainer + ", versionFileLink=" + versionFileLink + ", downloadLink=" + downloadLink + "]";
	}

	public String getMapAsString() {
		Iterator ite = versions.entrySet().iterator();
		String output = "";
		while (ite.hasNext()) {
			Entry<String, Version[]> entry = (Entry<String, Updater.Version[]>) ite.next();
			output += "[Mc-version=" + entry.getKey() + ", versions=" + Arrays.toString(entry.getValue()) + "]\n";
		}
		return output;
	}
}

public static class Version implements Comparable<Version>
{
	private static final Pattern pattern = Pattern.compile("(?i)(\\d+)((?:\\.\\d+)*)([a-zA-Z])?(-snapshot)?");
	private static final Pattern patternMC = Pattern.compile("(?i)(\\d+)((?:\\.\\d+)*)([a-z- ]*)");
	private String name;
	private String changes;
	private String downloadLink;
	private String versionString;
	private int[] releases;
	private char releaseChar;
	private boolean snapshot;
	private byte userType;
	private byte importance;

	public Version(String versionS, char releaseChar, boolean snapshot, int ... releases) {
		this.versionString = versionS;
		this.releaseChar = releaseChar;
		this.snapshot = snapshot;
		this.releases = releases;
	}

	public boolean isNewerThanOrEqual(Version v) {
		if (v.getLength() > this.getLength())
			return false;
		else if (v.getLength() < this.getLength()) return true;
		for (int i = 0; i < this.getLength(); i++) {
			if (v.getIndex(i) > this.getIndex(i))
				return false;
			else if (v.getIndex(i) < this.getIndex(i)) return true;
		}
		if (v.getReleaseChar() < this.getReleaseChar()) return true;
		return true;
	}

	public boolean isNewerOrEqualWithSameIndex(Version v, int index) {
		for (int i = 0; i <= index; i++) {
			if (v.getIndex(i) != this.getIndex(i)) return false;
		}
		for (int i = index + 1; i < Math.min(this.getLength(), v.getLength()); i++) {
			if (this.getIndex(i) < v.getIndex(i)) return false;
		}
		return true;
	}

	@Override
	public int compareTo(Version v) {
		return this.isNewerThanOrEqual(v) ? -1 : 1;
	}

	public static Version parseVersion(String version) throws VersionFormatException {
		Matcher m = pattern.matcher(version);
		if (m.matches()) {
			List<Integer> list = new ArrayList<Integer>();
			list.add(new Integer(m.group(1)));
			String[] array = m.group(2).split("\\.");
			for (int i = 1; i < array.length; i++) {
				list.add(Integer.parseInt(array[i]));
			}
			char c = m.group(3) != null && m.group(3).length() == 1 && Character.isAlphabetic(m.group(3).charAt(0)) ? m.group(3).charAt(0) : 'a';
			boolean snapshot = "-snapshot".equalsIgnoreCase(m.group(4)) ? true : false;
			return new Version(version, c, snapshot, ArrayUtils.toPrimitive(list.toArray(new Integer[0])));
		} else {
			throw new VersionFormatException(version);
		}
	}

	public static Version parseMcVersion() throws VersionFormatException {
		Matcher m = patternMC.matcher(Minecraft.getMinecraft().getVersion());
		if (m.matches()) {
			List<Integer> list = new ArrayList<Integer>();
			list.add(new Integer(m.group(1)));
			String[] array = m.group(2).split("\\.");
			for (int i = 1; i < array.length; i++) {
				list.add(Integer.parseInt(array[i]));
			}
			return new Version(Minecraft.getMinecraft().getVersion(), 'a', false, ArrayUtils.toPrimitive(list.toArray(new Integer[0])));
		} else {
			throw new VersionFormatException(Minecraft.getMinecraft().getVersion());
		}
	}

	public int getIndex(int i) {
		return this.releases[i];
	}

	public int getLength() {
		return this.releases.length;
	}

	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}

	public char getReleaseChar() {
		return releaseChar;
	}

	public void setReleaseChar(char releaseChar) {
		this.releaseChar = releaseChar;
	}

	public boolean isSnapshot() {
		return snapshot;
	}

	public void setSnapshot(boolean snapshot) {
		this.snapshot = snapshot;
	}

	public byte getUserType() {
		return userType;
	}

	public void setUserType(byte userType) {
		this.userType = userType;
	}

	public String getChanges() {
		return changes;
	}

	public void setChanges(String changes) {
		this.changes = changes;
	}

	public String getDownloadLink() {
		return downloadLink;
	}

	public void setDownloadLink(String downloadLink) {
		this.downloadLink = downloadLink;
	}

	public byte getImportance() {
		return importance;
	}

	public void setImportance(byte importance) {
		this.importance = importance;
	}

	public String getVersionString() {
		return versionString;
	}

	public void setVersionString(String versionString) {
		this.versionString = versionString;
	}

	@Override
	public String toString() {
		return "Version [name=" + name + ", releases=" + Arrays.toString(releases) + ", releaseChar=" + releaseChar + ", snapshot=" + snapshot + ", userType=" + userType + "]";
	}

	public String toName() {
		String output = "";
		for (int i = 0; i < releases.length - 1; i++) {
			output += releases[i] + ".";
		}
		return output + releases[releases.length - 1] + (releaseChar == 'a' ? "" : releaseChar) + (snapshot ? "-snapshot" : "");
	}
}

public static class VersionDeserializer implements JsonDeserializer<Version>
{
	@Override
	public Version deserialize(JsonElement json, Type typeOfT, JsonDeserializationContext ctx) throws JsonParseException {
		JsonObject obj = json.getAsJsonObject();
		Version version = null;
		try {
			version = Version.parseVersion(obj.get("version").getAsString());
		} catch (VersionFormatException e) {
			throw new JsonParseException("version couldn't be deserialized");
		}
		String name = obj.has("name") ? obj.get("name").getAsString() : "";
		version.setName(name);

		byte usertype = obj.has("user-type") ? obj.get("user-type").getAsByte() : 0;
		version.setUserType(usertype);

		String changes = obj.has("changes") ? obj.get("changes").getAsString() : "";
		version.setChanges(changes);

		byte imp = obj.has("importance") ? obj.get("importance").getAsByte() : 0;
		version.setImportance(imp);

		String dl = obj.has("download-link") ? obj.get("download-link").getAsString() : "";
		version.setDownloadLink(dl);
		return version;
	}
}

public static class ModVersionsDeserializer implements JsonDeserializer<ModVersions>
{
	@Override
	public ModVersions deserialize(JsonElement json, Type typeOfT, JsonDeserializationContext ctx) throws JsonParseException {
		JsonObject obj = json.getAsJsonObject();

		TreeMap<String, Version[]> map = new TreeMap<String, Version[]>(ModVersions.comparator);
		String dlink = obj.has("download-link") ? obj.get("download-link").getAsString() : "";

		JsonObject mcvobj = obj.get("mc-versions").getAsJsonObject();
		Iterator ite = mcvobj.entrySet().iterator();
		while (ite.hasNext()) {
			Entry<String, JsonElement> entry = (Entry<String, JsonElement>) ite.next();
			JsonArray jarray = entry.getValue().getAsJsonArray();

			Version[] versions = new Version[jarray.size()];
			Iterator ite1 = jarray.iterator();
			int i = 0;
			while (ite1.hasNext()) {
				JsonObject vobj = (JsonObject) ite1.next();
				versions[i] = ctx.<Version> deserialize(vobj, Version.class);
				i++;
			}
			Arrays.sort(versions);
			map.put(entry.getKey(), versions);
		}
		return new ModVersions(dlink, map);
	}
}
}

 

I searched on Google and MinecraftForgeFrance but no one could help me.

[voltagex]

http://stackoverflow.com/questions/34413/why-am-i-getting-a-noclassdeffounderror-in-java

[SCAREX]

The gson is in my buildpath : http://puu.sh/hv727/bb86fe2872.png

[SCAREX]

Problem solved, it was just eclipse doing strange things :

 

The debug mode was telling me that the problem was from Gson but the problem was from a pattern in my class (I found it when I launch the game in run mode instead of debug mode)