Add files via upload

Author: SimplyProgrammer

Sample Open Source Implementations/head/Bar.java

@@ -0,0 +1,59 @@
+package head;
+
+import java.util.List;
+
+import ugp.org.SerialX.Serializer;
+
+public final class Bar extends Foo //Sample object that inheres
+{
+	byte by0 = (byte) 142; 
+	short s0 = 555;
+	double d2 = 5;
+	Object sampleParent;
+	
+	public Bar(Object... args) {
+		// TODO Auto-generated constructor stub
+	}
+	
+	@Override
+	public String toString() 
+	{
+		return "Bar[" + a + " " + b + " " + c + " " + d + " " + f + " " + ch + " " + s + " " + nah + " " + l + " " + by0 + " " + s0 + "]";
+	}
+	
+	public static class BarProtocol extends FooProtocol //Protocol to serialize Bar
+	{
+		@Override
+		public Object[] serialize(Foo object) 
+		{
+			return new Object[] {object.a, object.b, object.c, object.d, object.f, object.ch, object.s, object.nah, object.l, ((Bar) object).by0, ((Bar) object).s0, Serializer.Code("$parent")};
+		}
+
+		@SuppressWarnings("unchecked")
+		@Override
+		public Foo unserialize(Class<? extends Foo> objectClass, Object... args) 
+		{
+			Bar f = new Bar();
+			f.a = (int) args[0];
+			f.b = (int) args[1];
+			f.c = (int) args[2];
+			f.d = (double) args[3];
+			f.f = (float) args[4];
+			f.ch = (char) args[5];
+			f.s = (String) args[6];
+			f.nah = (boolean) args[7];
+			f.l = (List<Object>) args[8];
+			f.by0 = (byte) args[9];
+			f.s0 = (short) args[10];
+			f.sampleParent = args[11];
+			
+			return f;
+		}		
+		
+		@Override
+		public Class<? extends Foo> applicableFor()
+		{
+			return Bar.class;
+		}
+	}
+}

Sample Open Source Implementations/head/Foo.java

@@ -0,0 +1,68 @@
+package head;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+import java.util.Random;
+import java.util.concurrent.CopyOnWriteArrayList;
+
+import ugp.org.SerialX.Protocols.SerializationProtocol;
+
+public class Foo //Sample object
+{
+	int a = 8, b = 1, c = 456;
+	double d = 5;
+	float f = 1453.364564564132454654511324f;
+	char ch = 'l';
+	String s = "a"; 
+	boolean nah = false;
+	List<Object> l = new CopyOnWriteArrayList<Object>(Arrays.asList(6, 45,464654, 9.9, 56f));
+	
+	public Foo() 
+	{
+		l.add(6);
+		l.add(9);
+		l.add(13);
+		l.add(new Random());
+		l.add(new ArrayList<>(new ArrayList<>(new ArrayList<>(Arrays.asList(4, 5,6d)))));
+	}
+	
+	@Override
+	public String toString()
+	{
+		return "Foo[" + a + " " + b + " " + c + " " + d + " " + f + " " + ch + " " + s + " " + nah + " " + l + "]";
+	}
+	
+	public static class FooProtocol extends SerializationProtocol<Foo> //Protocol to serialize Foo
+	{
+		@Override
+		public Object[] serialize(Foo object) 
+		{
+			return new Object[] {};
+		}
+
+		@SuppressWarnings("unchecked")
+		@Override
+		public Foo unserialize(Class<? extends Foo> objectClass, Object... args) 
+		{
+			Foo f = new Foo();
+			f.a = (int) args[0];
+			f.b = (int) args[1];
+			f.c = (int) args[2];
+			f.d = (double) args[3];
+			f.f = (float) args[4];
+			f.ch = (char) args[5];
+			f.s = (String) args[6];
+			f.nah = (boolean) args[7];
+			f.l = (List<Object>) args[8];
+			
+			return f;
+		}		
+		
+		@Override
+		public Class<? extends Foo> applicableFor()
+		{
+			return Foo.class;
+		}
+	};
+}

Sample Open Source Implementations/head/Main.java

@@ -0,0 +1,77 @@
+package head;
+
+import java.io.File;
+import java.lang.reflect.Field;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Random;
+import java.util.concurrent.atomic.AtomicLong;
+
+import ugp.org.SerialX.Serializer;
+import ugp.org.SerialX.Protocols.SerializationProtocol;
+
+public class Main 
+{
+	public static void main(String[] args)
+	{
+		//Protocol registration
+		Serializer.PROTOCOL_REGISTRY.addAll(new Bar.BarProtocol(), new Foo.FooProtocol(), new SerializationProtocol<Random>() //Sample custom protocol to serialized Random. 
+		{																													  //Random will be serialized also without protocol via classic Java Base64 because it implements java.io.Serializable!
+			@Override
+			public Object[] serialize(Random object) 
+			{
+				long seed = 0;
+				try
+				{
+					Field f = Random.class.getDeclaredField("seed");
+					f.setAccessible(true);
+					seed = ((AtomicLong) f.get(object)).get();
+				}
+				catch (Exception e) 
+				{
+					e.printStackTrace();
+				}
+				return new Object[] {seed};
+			}
+
+			@Override
+			public Random unserialize(Class<? extends Random> objectClass, Object... args) 
+			{
+				return new Random((long) args[0]);
+			}
+
+			@Override
+			public Class<? extends Random> applicableFor() 
+			{
+				return Random.class;
+			}
+		});
+		
+		File f = new File("./test.srlx");
+		
+		//Sample objects
+		Random r = new Random();
+		List<Object> list = new ArrayList<>();
+		for (int i = 0; i < 10; i++)
+			list.add(r.nextBoolean() ? r.nextInt(i+1) : r.nextBoolean());
+		int[] intArr = {1, 2, 3, 4};
+
+		HashMap<String, Object> vars = new HashMap<>(); //Variables to serialize
+		vars.put("yourMom", "is heavier than sun...");
+		vars.put("num", 6);
+		
+		Serializer.generateComments = true; //Enabling comment generation
+		
+		Serializer.globalVariables.put("parent", "father"); //Setting global variables
+		
+		Serializer.PROTOCOL_REGISTRY.GetProtocolFor(String.class).setActive(false); //Disabling a string protocol. This will force Serializer to serialize string with regular Java Base64 because String implements java.io.Serializable!
+		Serializer.SerializeTo(f, vars, "145asaa4144akhdgj31hahaXDDLol", r, list, Serializer.Comment("Size of array"), Serializer.Var("arrSize", list.size()), new Bar(), 1, 2.2, 3, 'A', true, false, null, intArr, Serializer.Code("$num")); //Saving to file (serializing)
+																				  //This will insert an comment        Another way to add variable except Map<String, Object> 				             			 $ is used to obtain value from variable
+		
+		Serializer.PROTOCOL_REGISTRY.setActivityForAll(true); //Enabling all protocols
+		System.out.println(Serializer.LoadFrom(f)); //Loading from file
+		System.out.println(Serializer.LoadVariablesFrom(f)); //Loading variables from file
+ 	}
+
+}