import com.badlogic.gdx.utils.SerializationException; //导入依赖的package包/类
/** Parses the given reader.
 * @param reader the reader
 * @throws SerializationException if the reader cannot be successfully parsed. */
public void parse (Reader reader) {
	try {
		char[] data = new char[1024];
		int offset = 0;
		while (true) {
			int length = reader.read(data, offset, data.length - offset);
			if (length == -1) break;
			if (length == 0) {
				char[] newData = new char[data.length * 2];
				System.arraycopy(data, 0, newData, 0, data.length);
				data = newData;
			} else
				offset += length;
		}
		parse(data, 0, offset);
	} catch (IOException ex) {
		throw new SerializationException(ex);
	} finally {
		StreamUtils.closeQuietly(reader);
	}
}
 

import com.badlogic.gdx.utils.SerializationException; //导入依赖的package包/类
private String getOwnerCharacterName() {
	if (ownerCharacterName == null && s_ownerCharacterId != null) {
		try {
			GameObject go = GameState.getGameObjectById(s_ownerCharacterId);
			if (go instanceof GameCharacter) {
				ownerCharacterName =  ((GameCharacter) go).getName();
			} else {
				XmlReader xmlReader = new XmlReader();
				Element root = xmlReader.parse(Gdx.files
						.internal(Configuration.getFolderCharacters()
								+ s_ownerCharacterId + ".xml"));
				ownerCharacterName = root.getChildByName(
						XMLUtil.XML_PROPERTIES).get(
						XMLUtil.XML_ATTRIBUTE_NAME);
			}
		} catch (SerializationException e) {
			throw new GdxRuntimeException("Could not determine the owner with type "+s_ownerCharacterId, e);
		}
		if (ownerCharacterName == null) {
			throw new GdxRuntimeException("Could not determine the owner with type "+s_ownerCharacterId);
		}
	}
	return Strings.getString(ownerCharacterName);
}
 

import com.badlogic.gdx.utils.SerializationException; //导入依赖的package包/类
/**
 * Parses the supplied InputStream without closing it at the end using the
 * supplied XmlReader.
 * 
 * @param inStream
 * @return
 */
public static Element parseNonCLosing(XmlReader parser, InputStream inStream) {
	try {
		InputStreamReader inReader = new InputStreamReader(inStream, "UTF-8");
		char[] data = new char[1024];
		int offset = 0;
		while (true) {
			int length = inReader.read(data, offset, data.length - offset);
			if (length == -1)
				break;
			if (length == 0) {
				char[] newData = new char[data.length * 2];
				System.arraycopy(data, 0, newData, 0, data.length);
				data = newData;
			} else
				offset += length;
		}
		return parser.parse(data, 0, offset);
	} catch (IOException ex) {
		throw new SerializationException(ex);
	}
}
 

import com.badlogic.gdx.utils.SerializationException; //导入依赖的package包/类
@Override
public void handleHttpResponse(Net.HttpResponse httpResponse) {
    try {
        handleResponse(httpResponse.getResultAsString());
        if (statsReporterResponseListener != null) {
            statsReporterResponseListener.succeed(responseVO);
        }
    } catch (Error error) {
        Gdx.app.error(TAG, error.getMessage());
        if (statsReporterResponseListener != null) {
            statsReporterResponseListener.failed(error);
        }
    } catch (SerializationException e) {
        e.printStackTrace();
        if (statsReporterResponseListener != null) {
            statsReporterResponseListener.failed(e);
        }
    }
}
 

import com.badlogic.gdx.utils.SerializationException; //导入依赖的package包/类
private Skin loadSkin(GdxFileSystem fileSystem) {
    String skinPath = "skin/uiskin.json";

    FileHandle skinFile = null;
    if (fileSystem.getFileExists(FilePath.of(skinPath))) {
        skinFile = fileSystem.resolve(skinPath);
    } else {
        // Fallback: use the internal skin stored in the classpath
        skinFile = Gdx.files.classpath("builtin/" + skinPath);
    }

    // Load skin
    if (skinFile != null) {
        try {
            return new Skin(skinFile);
        } catch (SerializationException se) {
            LOG.error("Error loading Scene2d skin", se);
        }
    }
    return new Skin();
}
 

import com.badlogic.gdx.utils.SerializationException; //导入依赖的package包/类
public void loadChapter(String selChapter) throws IOException {
	undoStack.clear();

	setSelectedScene(null);

	try {
		chapter.load(selChapter);
		firePropertyChange(NOTIFY_CHAPTER_LOADED);
		Ctx.project.getEditorConfig().setProperty("project.selectedChapter", selChapter);
	} catch (SerializationException ex) {
		// check for not compiled custom actions
		if (ex.getCause() != null && ex.getCause() instanceof ClassNotFoundException) {
			EditorLogger.msg("Custom action class not found. Trying to compile...");
			if (RunProccess.runGradle(Ctx.project.getProjectDir(), "desktop:compileJava")) {
				((FolderClassLoader)ActionFactory.getActionClassLoader()).reload();
				chapter.load(selChapter);
			} else {
				throw new IOException("Failed to run Gradle.");
			}
		} else {
			throw ex;
		}
	}

	i18n.load(selChapter);
}
 

import com.badlogic.gdx.utils.SerializationException; //导入依赖的package包/类
/**
 * Use this to load in an individual .json scene. Any previously loaded scene
 * data will be lost (including Box2D objects!)
 * 
 * @param _file
 *           File to read.
 * @return The scene represented by the RUBE JSON file.
 */
public RubeScene loadScene(FileHandle _file)
{
   if (mRubeWorldSerializer != null)
   {
      mRubeWorldSerializer.resetScene();
   }
   if (mWorld != null)
   {
      mRubeWorldSerializer.usePreexistingWorld(mWorld);
   }
   RubeScene scene = null;
   try
   {
      scene = json.fromJson(RubeScene.class, _file);
   }
   catch (SerializationException ex)
   {
      throw new SerializationException("Error reading file: " + _file, ex);
   }
   return scene;
}
 

import com.badlogic.gdx.utils.SerializationException; //导入依赖的package包/类
/**
 * This method accumulates objects defined in a scene, allowing several separate
 * RUBE .json files to be combined. Objects are added to the scene's data, as
 * well as within the Box2D world that is ultimately returned.
 * 
 * @param _file
 *           The JSON file to parse
 * @return The cumulative scene
 */
public RubeScene addScene(FileHandle _file)
{
   RubeScene scene = null;

   if ((mRubeWorldSerializer != null) && (mWorld != null))
   {
      mRubeWorldSerializer.usePreexistingWorld(mWorld);
   }
   try
   {
      scene = json.fromJson(RubeScene.class, _file);
   }
   catch (SerializationException ex)
   {
      throw new SerializationException("Error reading file: " + _file, ex);
   }
   return scene;
}
 

import com.badlogic.gdx.utils.SerializationException; //导入依赖的package包/类
private void readNamedObjects(Json paramJson, Class paramClass, ObjectMap<String, ObjectMap> paramObjectMap)
{
  if (paramClass == Skin.TintedDrawable.class);
  for (Object localObject1 = Drawable.class; ; localObject1 = paramClass)
  {
    Iterator localIterator = paramObjectMap.entries().iterator();
    while (true)
    {
      if (!localIterator.hasNext())
        return;
      ObjectMap.Entry localEntry = (ObjectMap.Entry)localIterator.next();
      String str = (String)localEntry.key;
      Object localObject2 = paramJson.readValue(paramClass, localEntry.value);
      if (localObject2 != null)
        try
        {
          this.this$0.add(str, localObject2, (Class)localObject1);
        }
        catch (Exception localException)
        {
          throw new SerializationException("Error reading " + paramClass.getSimpleName() + ": " + (String)localEntry.key, localException);
        }
    }
  }
}
 

import com.badlogic.gdx.utils.SerializationException; //导入依赖的package包/类
public Skin read(Json paramJson, Object paramObject, Class paramClass)
{
  Iterator localIterator = ((ObjectMap)paramObject).entries().iterator();
  while (localIterator.hasNext())
  {
    ObjectMap.Entry localEntry = (ObjectMap.Entry)localIterator.next();
    String str = (String)localEntry.key;
    ObjectMap localObjectMap = (ObjectMap)localEntry.value;
    try
    {
      readNamedObjects(paramJson, Class.forName(str), localObjectMap);
    }
    catch (ClassNotFoundException localClassNotFoundException)
    {
      throw new SerializationException(localClassNotFoundException);
    }
  }
  return this.val$skin;
}
 

import com.badlogic.gdx.utils.SerializationException; //导入依赖的package包/类
@Override
public final void write(Json json) {
    for (Entry<String, StoragePrimitive> entry : properties.entrySet()) {
        try {
            json.getWriter().json(entry.getKey(), entry.getValue().toJson());
        } catch (IOException e) {
            throw new SerializationException(e);
        }
    }
}
 

import com.badlogic.gdx.utils.SerializationException; //导入依赖的package包/类
private void loadEntities(){
	logger.debug("Loading Entities");
	
	Json json = new Json();
	for (String s : manifest.entities){
		try {
			EntityConfig config = json.fromJson(EntityConfig.class, Gdx.files.internal(s));
			entityConfigs.put(config.name,config);
		}
		catch (SerializationException ex){
			logger.error("Failed to load entity file: " + s);
			logger.error(ex.getMessage());
		}
	}
}
 

import com.badlogic.gdx.utils.SerializationException; //导入依赖的package包/类
private void loadWeapons(){
	logger.debug("Loading Weapons");
	Json json = new Json();;
	for (String s : manifest.weapons){
		try {
			WeaponConfig config = json.fromJson(WeaponConfig.class, Gdx.files.internal(s));
			weaponConfigs.put(config.name,config);
		}
		catch (SerializationException ex){
			logger.error("Failed to load weapons file: " + s);
			logger.error(ex.getMessage());
		}
	}
}
 

import com.badlogic.gdx.utils.SerializationException; //导入依赖的package包/类
/** Adds all resources in the specified skin JSON file. */
public void load (FileHandle skinFile) {
	try {
		getJsonLoader(skinFile).fromJson(Skin.class, skinFile);
	} catch (SerializationException ex) {
		throw new SerializationException("Error reading file: " + skinFile, ex);
	}
}
 

import com.badlogic.gdx.utils.SerializationException; //导入依赖的package包/类
@Override
public void init () {
	FileHandle storage = fileAccess.getMetadataFolder();
	FileHandle storageFile = storage.child("donateReminder.json");

	Json json = new Json();
	json.setIgnoreUnknownFields(true);
	json.addClassTag("EditorRunCounter", EditorRunCounter.class);

	EditorRunCounter runCounter;
	try {
		if (storageFile.exists()) {
			runCounter = json.fromJson(EditorRunCounter.class, storageFile);
		} else
			runCounter = new EditorRunCounter();
	} catch (SerializationException ignored) {
		runCounter = new EditorRunCounter();
	}

	runCounter.counter++;

	if (runCounter.counter % 50 == 0) {
		VisTable table = new VisTable(true);

		table.add("If you like VisEditor please consider").spaceRight(3);
		table.add(new LinkLabel("donating.", DONATE_URL));
		LinkLabel hide = new LinkLabel("Hide");
		table.add(hide);
		menuBar.setUpdateInfoTableContent(table);

		hide.setListener(labelUrl -> menuBar.setUpdateInfoTableContent(null));
	}

	json.toJson(runCounter, storageFile);
}
 

import com.badlogic.gdx.utils.SerializationException; //导入依赖的package包/类
@Override
public void init () {
	FileHandle storage = fileAccess.getMetadataFolder();

	storageFile = storage.child("recentProjects.json");

	json = new Json();
	json.setIgnoreUnknownFields(true);
	json.addClassTag("RecentProjectEntry", RecentProjectEntry.class);

	try {

		if (storageFile.exists()) {
			recentProjects = json.fromJson(new Array<RecentProjectEntry>().getClass(), storageFile);

			Iterator<RecentProjectEntry> it = recentProjects.iterator();
			while (it.hasNext()) {
				RecentProjectEntry entry = it.next();

				if (Gdx.files.absolute(entry.projectPath).exists() == false) it.remove();
			}
		} else
			recentProjects = new Array<>();

	} catch (SerializationException ignored) { //no big deal if cache can't be loaded
		recentProjects = new Array<>();
	}
}
 

import com.badlogic.gdx.utils.SerializationException; //导入依赖的package包/类
private Settings readSettings () {
	if (settingsFile.exists()) {
		try {
			return json.fromJson(Settings.class, settingsFile);
		} catch (SerializationException e) {
			settingsFile.delete();
			return new Settings();
		}
	} else
		return new Settings();
}
 

import com.badlogic.gdx.utils.SerializationException; //导入依赖的package包/类
/** Adds all resources in the specified skin JSON file. */
public void load(FileHandle skinFile) {
	try {
		getJsonLoader(skinFile).fromJson(Skin.class, skinFile);
	} catch (SerializationException ex) {
		throw new SerializationException("Error reading file: " + skinFile, ex);
	}
}
 

import com.badlogic.gdx.utils.SerializationException; //导入依赖的package包/类
@Override
public void readFields(Object object, JsonValue jsonMap) {
	try {
		super.readFields(object, jsonMap);
	} catch (SerializationException e) {
		Gdx.app.error("Assets", "Error reading fields " + jsonMap + " to "
				+ object, e);
	}
}
 

import com.badlogic.gdx.utils.SerializationException; //导入依赖的package包/类
public boolean run() {
	exported = false;
	Map<String, Object> entities = new HashMap<String, Object>();
	FileHandle projectFileHandle = new FileHandle(projectPath);

	// Try to load all game entities
	GameAssets gameAssets = new GameAssets(new ExporterFiles(),
			new ExporterImageUtils()) {
		protected FileHandle[] resolveBindings() {
			return new FileHandle[] { resolve("bindings.json"),
					resolve("editor-bindings.json") };
		}
	};
	try {
		loadAllEntities(gameAssets, projectFileHandle, entities);
	} catch (SerializationException serializationException) {
		System.err
				.println("[ERROR] A serialization exception occurred while exporting "
						+ projectPath
						+ ". The project could not be exported.");
		return false;
	}

	// Export
	Exporter exporter = new Exporter(gameAssets);
	doExport(projectPath, destinationPath, entities, gameAssets,
			exporter, new DefaultCallback());
	return exported;
}