jay
/
binary-data-format
mirror of https://github.com/jsrobson10/binary-data-format
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Modified the human readable serialization to use streams instead of 

strings, to make human readable formats able to handle an output of
greater than 2GB.
This commit is contained in:
jsrobson10 2020-06-20 13:38:59 +10:00
parent 39de6a5df4
commit 23a49277c1
5 changed files with 183 additions and 114 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

26
src/bdf/types/BdfArray.java
View File

@ -1,5 +1,7 @@
package bdf.types; package bdf.types;
import java.io.IOException;
import java.io.OutputStream;
import java.util.ArrayList; import java.util.ArrayList;
import java.util.Iterator; import java.util.Iterator;
@ -66,39 +68,39 @@ public class BdfArray implements IBdfType, Iterable<BdfObject>
} }
@Override @Override
public String serializeHumanReadable(BdfIndent indent, int it) public void serializeHumanReadable(OutputStream stream, BdfIndent indent, int it) throws IOException
{ {
if(elements.size() == 0) { if(elements.size() == 0) {
return "[]"; stream.write("[]".getBytes());
return;
} }
String data = "["; stream.write('[');
for(int i=0;i<elements.size();i++) for(int i=0;i<elements.size();i++)
{ {
BdfObject o = elements.get(i); BdfObject o = elements.get(i);
data += indent.breaker; stream.write(indent.breaker.getBytes());
for(int n=0;n<=it;n++) { for(int n=0;n<=it;n++) {
data += indent.indent; stream.write(indent.indent.getBytes());
} }
data += o.serializeHumanReadable(indent, it + 1); o.serializeHumanReadable(stream, indent, it + 1);
if(elements.size() > i+1) if(elements.size() > i+1) {
{ stream.write(", ".getBytes());
data += ", ";
} }
} }
data += indent.breaker; stream.write(indent.breaker.getBytes());
for(int n=0;n<it;n++) { for(int n=0;n<it;n++) {
data += indent.indent; stream.write(indent.indent.getBytes());
} }
return data + "]"; stream.write(']');
} }
public BdfArray add(BdfObject o) public BdfArray add(BdfObject o)

29
src/bdf/types/BdfNamedList.java
View File

@ -1,5 +1,7 @@
package bdf.types; package bdf.types;
import java.io.IOException;
import java.io.OutputStream;
import java.nio.charset.StandardCharsets; import java.nio.charset.StandardCharsets;
import java.util.ArrayList; import java.util.ArrayList;
@ -93,41 +95,40 @@ public class BdfNamedList implements IBdfType
} }
@Override @Override
public String serializeHumanReadable(BdfIndent indent, int it) public void serializeHumanReadable(OutputStream stream, BdfIndent indent, int it) throws IOException
{ {
if(elements.size() == 0) { if(elements.size() == 0) {
return "{}"; stream.write("{}".getBytes());
return;
} }
String data = "{"; stream.write('{');
for(int i=0;i<elements.size();i++) for(int i=0;i<elements.size();i++)
{ {
Element e = elements.get(i); Element e = elements.get(i);
data += indent.breaker; stream.write(indent.breaker.getBytes());
for(int n=0;n<=it;n++) { for(int n=0;n<=it;n++) {
data += indent.indent; stream.write(indent.indent.getBytes());
} }
data += DataHelpers.serializeString(new String(e.key, StandardCharsets.UTF_8)); stream.write((DataHelpers.serializeString(new String(e.key, StandardCharsets.UTF_8)) + ": ").getBytes());
data += ": "; e.object.serializeHumanReadable(stream, indent, it + 1);
data += e.object.serializeHumanReadable(indent, it + 1);
if(elements.size() > i+1) if(elements.size() > i+1) {
{ stream.write(", ".getBytes());
data += ", ";
} }
} }
data += indent.breaker; stream.write(indent.breaker.getBytes());
for(int n=0;n<it;n++) { for(int n=0;n<it;n++) {
data += indent.indent; stream.write(indent.indent.getBytes());
} }
return data + "}"; stream.write('}');
} }
public BdfObject get(String key) public BdfObject get(String key)

205
src/bdf/types/BdfObject.java
View File

@ -1,5 +1,8 @@
package bdf.types; package bdf.types;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.OutputStream;
import java.nio.ByteBuffer; import java.nio.ByteBuffer;
import bdf.data.BdfDatabase; import bdf.data.BdfDatabase;
@ -113,100 +116,168 @@ public class BdfObject implements IBdfType
return t; return t;
} }
public String serializeHumanReadable(BdfIndent indent) {
return serializeHumanReadable(indent, 0);
}
public String serializeHumanReadable() {
return serializeHumanReadable(new BdfIndent("", ""), 0);
}
public String serializeHumanReadable(BdfIndent indent, int it) public String serializeHumanReadable(BdfIndent indent, int it)
{ {
if(type == BdfTypes.BOOLEAN) { ByteArrayOutputStream stream = new ByteArrayOutputStream();
if(this.getBoolean()) return "true";
else return "false"; try {
serializeHumanReadable(stream, indent, it);
return stream.toString();
} }
// Objects catch(IOException e) {
if(type == BdfTypes.ARRAY) return ((IBdfType)object).serializeHumanReadable(indent, it); return "undefined";
if(type == BdfTypes.NAMED_LIST) return ((IBdfType)object).serializeHumanReadable(indent, it); }
if(type == BdfTypes.STRING) return DataHelpers.serializeString((String)object); }
// Primitives public void serializeHumanReadable(OutputStream stream, BdfIndent indent) throws IOException {
if(type == BdfTypes.BYTE) return (Byte.toString(this.getByte())+"B"); serializeHumanReadable(stream, indent, 0);
if(type == BdfTypes.DOUBLE) return (Double.toString(this.getDouble())+"D"); }
if(type == BdfTypes.FLOAT) return (Float.toString(this.getFloat())+"F");
if(type == BdfTypes.INTEGER) return (Integer.toString(this.getInteger())+"I");
if(type == BdfTypes.LONG) return (Long.toString(this.getLong())+"L");
if(type == BdfTypes.SHORT) return (Short.toString(this.getShort())+"S");
if(type == BdfTypes.BOOLEAN) return this.getBoolean() ? "true" : "false";
// Arrays public void serializeHumanReadable(OutputStream stream) throws IOException {
if(type == BdfTypes.ARRAY_INTEGER) { serializeHumanReadable(stream, new BdfIndent("", ""), 0);
String str = "(" + calcIndent(indent, it); }
for(int i : this.getIntegerArray()) {
str += indent.breaker + calcIndent(indent, it) + Integer.toString(i) + "I, "; public void serializeHumanReadable(OutputStream stream, BdfIndent indent, int it) throws IOException
{
String str = null;
switch(type)
{
case BdfTypes.ARRAY:
((IBdfType)object).serializeHumanReadable(stream, indent, it);
return;
case BdfTypes.NAMED_LIST:
((IBdfType)object).serializeHumanReadable(stream, indent, it);
return;
case BdfTypes.STRING:
str = DataHelpers.serializeString((String)object);
break;
case BdfTypes.BOOLEAN:
if(this.getBoolean()) str = "true";
else str = "false";
break;
case BdfTypes.BYTE:
str = Byte.toString(this.getByte())+"B";
break;
case BdfTypes.INTEGER:
str = Integer.toString(this.getInteger())+"I";
break;
case BdfTypes.SHORT:
str = Short.toString(this.getShort())+"S";
break;
case BdfTypes.LONG:
str = Long.toString(this.getLong())+"L";
break;
case BdfTypes.DOUBLE:
str = Double.toString(this.getDouble())+"D";
break;
case BdfTypes.FLOAT:
str = Float.toString(this.getFloat())+"F";
break;
case BdfTypes.ARRAY_INTEGER: {
stream.write(("(" + calcIndent(indent, it)).getBytes());
int[] array = this.getIntegerArray();
for(int i=0;i<array.length;i++) {
stream.write((indent.breaker + calcIndent(indent, it) + Integer.toString(array[i]) + "I").getBytes());
if(i == array.length - 1) stream.write(", ".getBytes());
} }
str = str.substring(0, str.length() - 2); stream.write((indent.breaker + calcIndent(indent, it - 1) + ")").getBytes());
str += indent.breaker + calcIndent(indent, it - 1) + ")"; break;
return str;
} }
if(type == BdfTypes.ARRAY_BOOLEAN) { case BdfTypes.ARRAY_BOOLEAN: {
String str = "("; stream.write(("(" + calcIndent(indent, it)).getBytes());
for(boolean i : this.getBooleanArray()) { boolean[] array = this.getBooleanArray();
str += indent.breaker + calcIndent(indent, it) + (i ? "true" : "false") + ", "; for(int i=0;i<array.length;i++) {
stream.write((indent.breaker + calcIndent(indent, it) + (array[i] ? "true" : "false")).getBytes());
if(i == array.length - 1) stream.write(", ".getBytes());
} }
str = str.substring(0, str.length() - 2); stream.write((indent.breaker + calcIndent(indent, it - 1) + ")").getBytes());
str += indent.breaker + calcIndent(indent, it - 1) + ")"; break;
return str;
} }
if(type == BdfTypes.ARRAY_BYTE) { case BdfTypes.ARRAY_SHORT: {
String str = "(" + calcIndent(indent, it); stream.write(("(" + calcIndent(indent, it)).getBytes());
for(byte i : this.getByteArray()) { short[] array = this.getShortArray();
str += indent.breaker + calcIndent(indent, it) + Byte.toString(i) + "B, "; for(int i=0;i<array.length;i++) {
stream.write((indent.breaker + calcIndent(indent, it) + Short.toString(array[i]) + "S").getBytes());
if(i == array.length - 1) stream.write(", ".getBytes());
} }
str = str.substring(0, str.length() - 2); stream.write((indent.breaker + calcIndent(indent, it - 1) + ")").getBytes());
str += indent.breaker + calcIndent(indent, it - 1) + ")"; break;
return str;
} }
if(type == BdfTypes.ARRAY_LONG) { case BdfTypes.ARRAY_LONG: {
String str = "(" + calcIndent(indent, it); stream.write(("(" + calcIndent(indent, it)).getBytes());
for(long i : this.getLongArray()) { long[] array = this.getLongArray();
str += indent.breaker + calcIndent(indent, it) + Long.toString(i) + "L, "; for(int i=0;i<array.length;i++) {
stream.write((indent.breaker + calcIndent(indent, it) + Long.toString(array[i]) + "L").getBytes());
if(i == array.length - 1) stream.write(", ".getBytes());
} }
str = str.substring(0, str.length() - 2); stream.write((indent.breaker + calcIndent(indent, it - 1) + ")").getBytes());
str += indent.breaker + calcIndent(indent, it - 1) + ")"; break;
return str;
} }
if(type == BdfTypes.ARRAY_SHORT) { case BdfTypes.ARRAY_BYTE: {
String str = "(" + calcIndent(indent, it); stream.write(("(" + calcIndent(indent, it)).getBytes());
for(short i : this.getShortArray()) { byte[] array = this.getByteArray();
str += indent.breaker + calcIndent(indent, it) + Short.toString(i) + "S, "; for(int i=0;i<array.length;i++) {
stream.write((indent.breaker + calcIndent(indent, it) + Byte.toString(array[i]) + "B").getBytes());
if(i == array.length - 1) stream.write(", ".getBytes());
} }
str = str.substring(0, str.length() - 2); stream.write((indent.breaker + calcIndent(indent, it - 1) + ")").getBytes());
str += indent.breaker + calcIndent(indent, it - 1) + ")"; break;
return str;
} }
if(type == BdfTypes.ARRAY_DOUBLE) { case BdfTypes.ARRAY_DOUBLE: {
String str = "(" + calcIndent(indent, it); stream.write(("(" + calcIndent(indent, it)).getBytes());
for(double i : this.getDoubleArray()) { double[] array = this.getDoubleArray();
str += indent.breaker + calcIndent(indent, it) + Double.toString(i) + "D, "; for(int i=0;i<array.length;i++) {
stream.write((indent.breaker + calcIndent(indent, it) + Double.toString(array[i]) + "D").getBytes());
if(i == array.length - 1) stream.write(", ".getBytes());
} }
str = str.substring(0, str.length() - 2); stream.write((indent.breaker + calcIndent(indent, it - 1) + ")").getBytes());
str += indent.breaker + calcIndent(indent, it - 1) + ")"; break;
return str;
} }
if(type == BdfTypes.ARRAY_FLOAT) { case BdfTypes.ARRAY_FLOAT: {
String str = "(" + calcIndent(indent, it); stream.write(("(" + calcIndent(indent, it)).getBytes());
for(float i : this.getFloatArray()) { float[] array = this.getFloatArray();
str += indent.breaker + calcIndent(indent, it) + Float.toString(i) + "F, "; for(int i=0;i<array.length;i++) {
stream.write((indent.breaker + calcIndent(indent, it) + Float.toString(array[i]) + "F").getBytes());
if(i == array.length - 1) stream.write(", ".getBytes());
} }
str = str.substring(0, str.length() - 2); stream.write((indent.breaker + calcIndent(indent, it - 1) + ")").getBytes());
str += indent.breaker + calcIndent(indent, it - 1) + ")"; break;
return str;
} }
// Return null if the object is undefined default:
return "undefined"; str = "undefined";
break;
}
if(str != null) {
stream.write(str.getBytes());
}
} }
public BdfObject() { public BdfObject() {

13
src/bdf/types/IBdfType.java
View File

@ -1,5 +1,8 @@
package bdf.types; package bdf.types;
import java.io.IOException;
import java.io.OutputStream;
import bdf.data.IBdfDatabase; import bdf.data.IBdfDatabase;
interface IBdfType interface IBdfType
@ -7,13 +10,5 @@ interface IBdfType
int serialize(IBdfDatabase database); int serialize(IBdfDatabase database);
int serializeSeeker(); int serializeSeeker();
String serializeHumanReadable(BdfIndent indent, int it); void serializeHumanReadable(OutputStream stream, BdfIndent indent, int it) throws IOException;
public default String serializeHumanReadable(BdfIndent indent) {
return this.serializeHumanReadable(indent, 0);
}
public default String serializeHumanReadable() {
return this.serializeHumanReadable(new BdfIndent("", ""), 0);
}
} }

14
src/tests/Tests.java
View File

@ -37,16 +37,16 @@ public class Tests {
data.writeToStream(file); data.writeToStream(file);
*/ */
/*
BdfObject bdf = new BdfObject(); BdfObject bdf = new BdfObject();
BdfArray a = bdf.getArray(); BdfArray a = bdf.getArray();
byte[] bytes = new byte[1024*1024*1024]; byte[] bytes = new byte[1024*1024*1024/2];
for(int i=0;i<bytes.length;i++) { for(int i=0;i<bytes.length;i++) {
bytes[i] = (byte)0; bytes[i] = (byte)0;
} }
for(int i=0;i<1000;i++) { for(int i=0;i<10;i++) {
BdfArray a2 = new BdfArray(); BdfArray a2 = new BdfArray();
a.add(BdfObject.withArray(a2)); a.add(BdfObject.withArray(a2));
a = a2; a = a2;
@ -58,11 +58,11 @@ public class Tests {
FileOutputStream file = new FileOutputStream("./database.bdf"); FileOutputStream file = new FileOutputStream("./database.bdf");
data.writeToStream(file); data.writeToStream(file);
*/
BdfFileManager bdf = new BdfFileManager("./database.bdf");
System.out.println("Loaded bdf"); //BdfFileManager bdf = new BdfFileManager("./database.bdf");
Thread.sleep(5000); //System.out.println("Loaded bdf");
//Thread.sleep(5000);
} }
} }