/** * Attempts to deserialize the given arguments into a new instance of the * given class. * <p> * The class must implement {@link ConfigurationSerializable}, including * the extra methods as specified in the javadoc of * ConfigurationSerializable. * <p> * If a new instance could not be made, an example being the class not * fully implementing the interface, null will be returned. * * @param args Arguments for deserialization * @param clazz Class to deserialize into * @return New instance of the specified class */ public static ConfigurationSerializable deserializeObject(Map<String, ?> args, Class<? extends ConfigurationSerializable> clazz) { return new ConfigurationSerialization(clazz).deserialize(args); }
/** * Registers the given {@link ConfigurationSerializable} class by its * alias * * @param clazz Class to register */ public static void registerClass(Class<? extends ConfigurationSerializable> clazz) { DelegateDeserialization delegate = clazz.getAnnotation(DelegateDeserialization.class); if (delegate == null) { registerClass(clazz, getAlias(clazz)); registerClass(clazz, clazz.getName()); } }
/** * Gets the correct alias for the given {@link ConfigurationSerializable} * class * * @param clazz Class to get alias for * @return Alias to use for the class */ public static String getAlias(Class<? extends ConfigurationSerializable> clazz) { DelegateDeserialization delegate = clazz.getAnnotation(DelegateDeserialization.class); if (delegate != null) { if ((delegate.value() == null) || (delegate.value() == clazz)) { delegate = null; } else { return getAlias(delegate.value()); } } if (delegate == null) { SerializableAs alias = clazz.getAnnotation(SerializableAs.class); if ((alias != null) && (alias.value() != null)) { return alias.value(); } } return clazz.getName(); } }
@SerializableAs("BlockVector") public class BlockVector extends Vector {
void setClass(final String name, final Class<?> clazz) { if (!classes.containsKey(name)) { classes.put(name, clazz); if (ConfigurationSerializable.class.isAssignableFrom(clazz)) { Class<? extends ConfigurationSerializable> serializable = clazz.asSubclass(ConfigurationSerializable.class); ConfigurationSerialization.registerClass(serializable); } } }
@Override public Node representData(Object data) { ConfigurationSerializable serializable = (ConfigurationSerializable) data; Map<String, Object> values = new LinkedHashMap<String, Object>(); values.put(ConfigurationSerialization.SERIALIZED_TYPE_KEY, ConfigurationSerialization.getAlias(serializable.getClass())); values.putAll(serializable.serialize()); return super.representData(values); } }
public ConfigurationSerializable deserialize(Map<String, ?> args) { Validate.notNull(args, "Args must not be null"); ConfigurationSerializable result = null; Method method = null; if (result == null) { method = getMethod("deserialize", true); if (method != null) { result = deserializeViaMethod(method, args); } } if (result == null) { method = getMethod("valueOf", true); if (method != null) { result = deserializeViaMethod(method, args); } } if (result == null) { Constructor<? extends ConfigurationSerializable> constructor = getConstructor(); if (constructor != null) { result = deserializeViaCtor(constructor, args); } } return result; }
throw new IllegalArgumentException("Cannot have null alias"); clazz = getClassByAlias(alias); if (clazz == null) { throw new IllegalArgumentException("Specified class does not exist ('" + alias + "')"); return new ConfigurationSerialization(clazz).deserialize(args);
@Override protected Object resolveObject(Object obj) throws IOException { if (obj instanceof Wrapper) { try { (obj = ConfigurationSerialization.deserializeObject(((Wrapper<?>) obj).map)).getClass(); // NPE } catch (Throwable ex) { throw newIOException("Failed to deserialize object", ex); } } return super.resolveObject(obj); }
private void removeClass(String name) { Class<?> clazz = classes.remove(name); try { if ((clazz != null) && (ConfigurationSerializable.class.isAssignableFrom(clazz))) { Class<? extends ConfigurationSerializable> serializable = clazz.asSubclass(ConfigurationSerializable.class); ConfigurationSerialization.unregisterClass(serializable); } } catch (NullPointerException ex) { // Boggle! // (Native methods throwing NPEs is not fun when you can't stop it before-hand) } }
@DelegateDeserialization(GlowOfflinePlayer.class) public class GlowPlayer extends GlowHumanEntity implements Player {
@SerializableAs("PotionEffect") public class PotionEffect implements ConfigurationSerializable { private static final String AMPLIFIER = "amplifier";
/** * Initialize a server using the command-line arguments. * * @param args the command-line arguments * @return the new server, or null if the command-line arguments include e.g. {@code --version} */ public static GlowServer createFromArguments(String... args) { ServerConfig config = parseArguments(args); // we don't want to create a server when called with --version if (config == null) { return null; } ConfigurationSerialization.registerClass(GlowOfflinePlayer.class); GlowPotionEffect.register(); GlowEnchantment.register(); GlowDispenser.register(); return new GlowServer(config); }
static Wrapper<ImmutableMap<String, ?>> newWrapper(ConfigurationSerializable obj) { return new Wrapper<ImmutableMap<String, ?>>(ImmutableMap.<String, Object>builder().put(ConfigurationSerialization.SERIALIZED_TYPE_KEY, ConfigurationSerialization.getAlias(obj.getClass())).putAll(obj.serialize()).build()); }
@Override public Object construct(Node node) { if (node.isTwoStepsConstruction()) { throw new YAMLException("Unexpected referential mapping structure. Node: " + node); } Map<?, ?> raw = (Map<?, ?>) super.construct(node); if (raw.containsKey(ConfigurationSerialization.SERIALIZED_TYPE_KEY)) { Map<String, Object> typed = new LinkedHashMap<String, Object>(raw.size()); for (Map.Entry<?, ?> entry : raw.entrySet()) { typed.put(entry.getKey().toString(), entry.getValue()); } try { return ConfigurationSerialization.deserializeObject(typed); } catch (IllegalArgumentException ex) { throw new YAMLException("Could not deserialize object", ex); } } return raw; }
@SerializableAs("Color") public final class Color implements ConfigurationSerializable { private static final int BIT_MASK = 0xff;
private void registerConfigurationClasses() { ConfigurationSerialization.registerClass(ResourceSpawner.class, "RessourceSpawner"); ConfigurationSerialization.registerClass(Team.class, "Team"); ConfigurationSerialization.registerClass(PlayerStatistic.class, "PlayerStatistic"); }
@SerializableAs("Firework") public final class FireworkEffect implements ConfigurationSerializable {
@SerializableAs("Vector") public class Vector implements Cloneable, ConfigurationSerializable { private static final long serialVersionUID = -2657651106777219169L;
@SerializableAs("Player") public final class GlowOfflinePlayer implements OfflinePlayer {