Rogue: Savage Rats, a retro-themed dungeon crawler
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
rogue-savage-rats/src/mightypork/util/files/ion/Ion.java

716 lines
15 KiB

package mightypork.util.files.ion;
import java.io.*;
11 years ago
import java.nio.ByteBuffer;
import java.util.HashMap;
import java.util.Map;
11 years ago
import mightypork.util.logging.Log;
/**
* Universal data storage system
*
* @author MightyPork
*/
public class Ion {
11 years ago
/*
* 0-19 ... primitive and Java built-in types
* 20-39 ... technical marks
* 40-99 ... built-in ION types
11 years ago
*/
// primitives 0..19
11 years ago
/** Null mark (for internal use) */
private static final short NULL = 0;
/** Boolean mark (for internal use) */
private static final short BOOLEAN = 1;
/** Byte mark (for internal use) */
private static final short BYTE = 2;
/** Character mark (for internal use) */
private static final short CHAR = 3;
/** Short mark (for internal use) */
private static final short SHORT = 4;
/** Integer mark (for internal use) */
private static final short INT = 5;
/** Long mark (for internal use) */
private static final short LONG = 6;
/** Float mark (for internal use) */
private static final short FLOAT = 7;
/** Double mark (for internal use) */
private static final short DOUBLE = 8;
/** String mark (for internal use) */
private static final short STRING = 9;
// technical 20..39
11 years ago
/**
* Entry mark - general purpose, marks an entry in sequence of objects. Used
* to indicate that the sequence continues wityh another element.
*/
public static final short ENTRY = 20;
11 years ago
/**
* Start mark - general purpose, marks start of a sequence of stored
* objects.
*/
public static final short START = 21;
11 years ago
/**
* End mark - general purpose, marks end of sequence of stored objects.
*/
public static final short END = 22;
11 years ago
/**
* Length mark, indicating length of something (such as array) - general
* purpose
*/
public static final short LENGTH = 23;
11 years ago
// built in 40..99
11 years ago
/** Map mark (built-in data structure) */
static final short DATA_BUNDLE = 40;
11 years ago
/** List mark (built-in data structure) */
static final short DATA_LIST = 41;
11 years ago
/** Ionizables<Mark, Class> */
11 years ago
private static Map<Short, Class<?>> customIonizables = new HashMap<>();
// buffers and helper arrays for storing to streams.
private static ByteBuffer bi = ByteBuffer.allocate(Integer.SIZE / 8);
private static ByteBuffer bd = ByteBuffer.allocate(Double.SIZE / 8);
private static ByteBuffer bf = ByteBuffer.allocate(Float.SIZE / 8);
private static ByteBuffer bc = ByteBuffer.allocate(Character.SIZE / 8);
private static ByteBuffer bl = ByteBuffer.allocate(Long.SIZE / 8);
private static ByteBuffer bs = ByteBuffer.allocate(Short.SIZE / 8);
private static byte[] ai = new byte[Integer.SIZE / 8];
private static byte[] ad = new byte[Double.SIZE / 8];
private static byte[] af = new byte[Float.SIZE / 8];
private static byte[] ac = new byte[Character.SIZE / 8];
private static byte[] al = new byte[Long.SIZE / 8];
private static byte[] as = new byte[Short.SIZE / 8];
/**
* Indicates whether range checking should be performed when registering
* marks.
*/
private static boolean markRangeChecking;
static {
markRangeChecking = false;
11 years ago
registerIonizable(Ion.DATA_BUNDLE, IonDataBundle.class);
registerIonizable(Ion.DATA_LIST, IonDataList.class);
markRangeChecking = true;
}
/**
* Register new {@link Ionizable} for direct reconstructing.
*
11 years ago
* @param mark mark to be used. Numbers 0..99 are reserved.
* @param objClass class of the registered Ionizable
*/
11 years ago
public static void registerIonizable(short mark, Class<?> objClass)
{
11 years ago
// negative marks are allowed.
if (markRangeChecking && mark >= 0 && mark < 100) {
11 years ago
throw new RuntimeException("Marks 0..99 are reserved.");
}
if (customIonizables.containsKey(mark)) {
11 years ago
throw new RuntimeException("Mark " + mark + " is already in use.");
}
11 years ago
customIonizables.put(mark, objClass);
}
/**
* Load an object from file.
*
* @param file file
* @return the loaded object
11 years ago
* @throws IOException on failure
*/
11 years ago
public static Object fromFile(File file) throws IOException
{
try(InputStream in = new FileInputStream(file)) {
final Object obj = fromStream(in);
return obj;
} catch (final IOException e) {
11 years ago
throw new IOException("Error loading ION file.", e);
}
}
/**
* Load an object from stream.
*
* @param in input stream
* @return the loaded object
11 years ago
* @throws IOException
*/
11 years ago
public static Object fromStream(InputStream in) throws IOException
{
return readObject(in);
}
/**
* Write an object to a stream.
*
* @param out output stream
* @param obj written object
* @throws IOException
*/
public static void toStream(OutputStream out, Object obj) throws IOException
{
writeObject(out, obj);
}
/**
* Store an object to file.
*
* @param path file path
* @param obj object to store
11 years ago
* @throws IOException
*/
11 years ago
public static void toFile(File path, Object obj) throws IOException
{
try(OutputStream out = new FileOutputStream(path)) {
11 years ago
writeObject(out, obj);
out.flush();
out.close();
} catch (final Exception e) {
11 years ago
throw new IOException("Error writing to ION file.", e);
}
}
/**
* Read single object from input stream, preceded by a mark. If a mark is
* not present, the behavior is undefined - in case the read bytes happen to
* match one of the registered marks, some garbage will be read. Otherwise
* an exception will be be thrown.
*
* @param in input stream
* @return the loaded object
11 years ago
* @throws IOException
*/
11 years ago
public static Object readObject(InputStream in) throws IOException
{
try {
11 years ago
final short mark = readMark(in);
if (customIonizables.containsKey(mark)) {
Ionizable ionObj;
try {
11 years ago
ionObj = ((Ionizable) customIonizables.get(mark).newInstance());
} catch (InstantiationException | IllegalAccessException e) {
throw new IOException("Cound not instantiate: " + Log.str(customIonizables.get(mark)), e);
}
11 years ago
ionObj.loadFrom(in);
return ionObj;
}
11 years ago
switch (mark) {
case Ion.NULL:
return null;
case Ion.BOOLEAN:
return readBoolean(in);
case Ion.BYTE:
return readByte(in);
case Ion.CHAR:
return readChar(in);
case Ion.SHORT:
return readShort(in);
case Ion.INT:
return readInt(in);
case Ion.LONG:
return readLong(in);
case Ion.FLOAT:
return readFloat(in);
case Ion.DOUBLE:
return readDouble(in);
case Ion.STRING:
final String s = readString(in);
return s;
default:
11 years ago
throw new IOException("Invalid Ion mark: " + mark);
}
} catch (final IOException e) {
11 years ago
throw new IOException("Error loading ION file: ", e);
}
}
11 years ago
public static void expect(InputStream in, short mark) throws IOException
{
if (readMark(in) != mark) throw new IOException("Unexpected mark in ION stream.");
}
public static short readMark(InputStream in) throws IOException
{
return readShort(in);
}
public static void writeMark(OutputStream out, short mark) throws IOException
{
writeShort(out, mark);
}
/**
* Write a single object to output stream, with a mark.
*
* @param out output stream
* @param obj stored object
11 years ago
* @throws IOException
*/
11 years ago
public static void writeObject(OutputStream out, Object obj) throws IOException
{
try {
if (obj instanceof Ionizable) {
11 years ago
writeMark(out, ((Ionizable) obj).getIonMark());
((Ionizable) obj).saveTo(out);
return;
}
if (obj instanceof Boolean) {
11 years ago
writeMark(out, Ion.BOOLEAN);
writeBoolean(out, (Boolean) obj);
return;
}
if (obj instanceof Byte) {
11 years ago
writeMark(out, Ion.BYTE);
writeByte(out, (Byte) obj);
return;
}
if (obj instanceof Character) {
11 years ago
writeMark(out, Ion.CHAR);
writeChar(out, (Character) obj);
return;
}
if (obj instanceof Short) {
11 years ago
writeMark(out, Ion.SHORT);
writeShort(out, (Short) obj);
return;
}
if (obj instanceof Integer) {
11 years ago
writeMark(out, Ion.INT);
writeInt(out, (Integer) obj);
return;
}
if (obj instanceof Long) {
11 years ago
writeMark(out, Ion.LONG);
writeLong(out, (Long) obj);
return;
}
if (obj instanceof Float) {
11 years ago
writeMark(out, Ion.FLOAT);
writeFloat(out, (Float) obj);
return;
}
if (obj instanceof Double) {
11 years ago
writeMark(out, Ion.DOUBLE);
writeDouble(out, (Double) obj);
return;
}
if (obj instanceof String) {
11 years ago
writeMark(out, Ion.STRING);
writeString(out, (String) obj);
return;
}
11 years ago
throw new IOException("Object " + Log.str(obj) + " could not be be ionized.");
} catch (final IOException e) {
11 years ago
throw new IOException("Could not store: " + obj, e);
}
}
private static byte[] getBytesBool(boolean bool)
{
return new byte[] { (byte) (bool ? 1 : 0) };
}
private static byte[] getBytesByte(byte num)
{
return new byte[] { num };
}
private static byte[] getBytesChar(char num)
{
synchronized (bc) {
bc.clear();
bc.putChar(num);
return bc.array();
}
}
private static byte[] getBytesShort(short num)
{
synchronized (bs) {
bs.clear();
bs.putShort(num);
return bs.array();
}
}
private static byte[] getBytesInt(int num)
{
synchronized (bi) {
bi.clear();
bi.putInt(num);
return bi.array();
}
}
private static byte[] getBytesLong(long num)
{
synchronized (bl) {
bl.clear();
bl.putLong(num);
return bl.array();
}
}
private static byte[] getBytesFloat(float num)
{
synchronized (bf) {
bf.clear();
bf.putFloat(num);
return bf.array();
}
}
private static byte[] getBytesDouble(double num)
{
synchronized (bd) {
bd.clear();
bd.putDouble(num);
return bd.array();
}
}
private static byte[] getBytesString(String str)
{
final char[] chars = str.toCharArray();
final ByteBuffer bstr = ByteBuffer.allocate((Character.SIZE / 8) * chars.length + (Character.SIZE / 8));
for (final char c : chars) {
bstr.putChar(c);
}
bstr.putChar((char) 0);
return bstr.array();
}
/**
* Write a boolean (without a mark)
*
* @param out output stream
* @param b boolean to write
* @throws IOException
*/
public static void writeBoolean(OutputStream out, boolean b) throws IOException
11 years ago
{
out.write(getBytesBool(b));
11 years ago
}
/**
* Write a byte (without a mark)
*
* @param out output stream
* @param b byte to write
* @throws IOException
*/
11 years ago
public static void writeByte(OutputStream out, byte b) throws IOException
{
out.write(getBytesByte(b));
}
/**
* Write a char (without a mark)
*
* @param out output stream
* @param c char to write
* @throws IOException
*/
11 years ago
public static void writeChar(OutputStream out, char c) throws IOException
{
out.write(getBytesChar(c));
}
/**
* Write a short (without a mark)
*
* @param out output stream
* @param s short to write
* @throws IOException
*/
11 years ago
public static void writeShort(OutputStream out, short s) throws IOException
{
out.write(getBytesShort(s));
}
/**
* Write an integer (without a mark)
*
* @param out output stream
* @param i integer to write
* @throws IOException
*/
11 years ago
public static void writeInt(OutputStream out, int i) throws IOException
{
out.write(getBytesInt(i));
}
/**
* Write a long (without a mark)
*
* @param out output stream
* @param l long to write
* @throws IOException
*/
11 years ago
public static void writeLong(OutputStream out, long l) throws IOException
{
out.write(getBytesLong(l));
}
/**
* Write a float (without a mark)
*
* @param out output stream
* @param f float to write
* @throws IOException
*/
11 years ago
public static void writeFloat(OutputStream out, float f) throws IOException
{
out.write(getBytesFloat(f));
}
/**
* Write a double (without a mark)
*
* @param out output stream
* @param d double to write
* @throws IOException
*/
11 years ago
public static void writeDouble(OutputStream out, double d) throws IOException
{
out.write(getBytesDouble(d));
}
/**
* Write a String (without a mark)
*
* @param out output stream
* @param str String to write
* @throws IOException
*/
11 years ago
public static void writeString(OutputStream out, String str) throws IOException
{
out.write(getBytesString(str));
}
/**
* Read a boolean (without a mark)
*
* @param in input stream
* @return boolean read
* @throws IOException
*/
11 years ago
public static boolean readBoolean(InputStream in) throws IOException
{
return readByte(in) > 0;
}
/**
* Read a byte (without a mark)
*
* @param in input stream
* @return byte read
* @throws IOException
*/
11 years ago
public static byte readByte(InputStream in) throws IOException
{
int b = in.read();
if (-1 == b) throw new IOException("End of stream.");
return (byte) b;
}
/**
* Read a char (without a mark)
*
* @param in input stream
* @return char read
* @throws IOException
*/
11 years ago
public static char readChar(InputStream in) throws IOException
{
synchronized (ac) {
if (-1 == in.read(ac, 0, ac.length)) throw new IOException("End of stream.");
final ByteBuffer buf = ByteBuffer.wrap(ac);
return buf.getChar();
}
}
/**
* Read a short (without a mark)
*
* @param in input stream
* @return short read
* @throws IOException
*/
11 years ago
public static short readShort(InputStream in) throws IOException
{
synchronized (as) {
if (-1 == in.read(as, 0, as.length)) throw new IOException("End of stream.");
final ByteBuffer buf = ByteBuffer.wrap(as);
return buf.getShort();
}
}
/**
* Read a long (without a mark)
*
* @param in input stream
* @return long read
* @throws IOException
*/
11 years ago
public static long readLong(InputStream in) throws IOException
{
synchronized (al) {
if (-1 == in.read(al, 0, al.length)) throw new IOException("End of stream.");
final ByteBuffer buf = ByteBuffer.wrap(al);
return buf.getLong();
}
}
/**
* Read an integer (without a mark)
*
* @param in input stream
* @return integer read
* @throws IOException
*/
11 years ago
public static int readInt(InputStream in) throws IOException
{
synchronized (ai) {
if (-1 == in.read(ai, 0, ai.length)) throw new IOException("End of stream.");
final ByteBuffer buf = ByteBuffer.wrap(ai);
return buf.getInt();
}
}
/**
* Read a float (without a mark)
*
* @param in input stream
* @return float read
* @throws IOException
*/
11 years ago
public static float readFloat(InputStream in) throws IOException
{
synchronized (af) {
if (-1 == in.read(af, 0, af.length)) throw new IOException("End of stream.");
final ByteBuffer buf = ByteBuffer.wrap(af);
return buf.getFloat();
}
}
/**
* Read a double (without a mark)
*
* @param in input stream
* @return double read
* @throws IOException
*/
11 years ago
public static double readDouble(InputStream in) throws IOException
{
synchronized (ad) {
if (-1 == in.read(ad, 0, ad.length)) throw new IOException("End of stream.");
final ByteBuffer buf = ByteBuffer.wrap(ad);
return buf.getDouble();
}
}
/**
* Read a string (without a mark)
*
* @param in input stream
* @return string read
* @throws IOException
*/
11 years ago
public static String readString(InputStream in) throws IOException
{
String s = "";
char c;
while ((c = readChar(in)) > 0) {
s += c;
}
11 years ago
return s;
}
}