421 lines
9.7 KiB
C#
421 lines
9.7 KiB
C#
using System;
|
|
using System.Collections;
|
|
using System.Collections.Generic;
|
|
using System.ComponentModel;
|
|
using System.IO;
|
|
using ES3Internal;
|
|
using ES3Types;
|
|
|
|
public abstract class ES3Reader : IDisposable
|
|
{
|
|
[EditorBrowsable(EditorBrowsableState.Never)]
|
|
public class ES3ReaderPropertyEnumerator
|
|
{
|
|
public ES3Reader reader;
|
|
|
|
public ES3ReaderPropertyEnumerator(ES3Reader reader)
|
|
{
|
|
this.reader = reader;
|
|
}
|
|
|
|
public IEnumerator GetEnumerator()
|
|
{
|
|
while (true)
|
|
{
|
|
if (reader.overridePropertiesName != null)
|
|
{
|
|
string overridePropertiesName = reader.overridePropertiesName;
|
|
reader.overridePropertiesName = null;
|
|
yield return overridePropertiesName;
|
|
continue;
|
|
}
|
|
string text;
|
|
if ((text = reader.ReadPropertyName()) == null)
|
|
{
|
|
break;
|
|
}
|
|
yield return text;
|
|
}
|
|
}
|
|
}
|
|
|
|
[EditorBrowsable(EditorBrowsableState.Never)]
|
|
public class ES3ReaderRawEnumerator
|
|
{
|
|
public ES3Reader reader;
|
|
|
|
public ES3ReaderRawEnumerator(ES3Reader reader)
|
|
{
|
|
this.reader = reader;
|
|
}
|
|
|
|
public IEnumerator GetEnumerator()
|
|
{
|
|
while (true)
|
|
{
|
|
string text = reader.ReadPropertyName();
|
|
if (text == null)
|
|
{
|
|
break;
|
|
}
|
|
Type type = reader.ReadTypeFromHeader<object>();
|
|
byte[] bytes = reader.ReadElement();
|
|
reader.ReadKeySuffix();
|
|
if (type != null)
|
|
{
|
|
yield return new KeyValuePair<string, ES3Data>(text, new ES3Data(type, bytes));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
public ES3Settings settings;
|
|
|
|
protected int serializationDepth;
|
|
|
|
internal string overridePropertiesName;
|
|
|
|
public virtual ES3ReaderPropertyEnumerator Properties => new ES3ReaderPropertyEnumerator(this);
|
|
|
|
internal virtual ES3ReaderRawEnumerator RawEnumerator => new ES3ReaderRawEnumerator(this);
|
|
|
|
internal abstract int Read_int();
|
|
|
|
internal abstract float Read_float();
|
|
|
|
internal abstract bool Read_bool();
|
|
|
|
internal abstract char Read_char();
|
|
|
|
internal abstract decimal Read_decimal();
|
|
|
|
internal abstract double Read_double();
|
|
|
|
internal abstract long Read_long();
|
|
|
|
internal abstract ulong Read_ulong();
|
|
|
|
internal abstract byte Read_byte();
|
|
|
|
internal abstract sbyte Read_sbyte();
|
|
|
|
internal abstract short Read_short();
|
|
|
|
internal abstract ushort Read_ushort();
|
|
|
|
internal abstract uint Read_uint();
|
|
|
|
internal abstract string Read_string();
|
|
|
|
internal abstract byte[] Read_byteArray();
|
|
|
|
internal abstract long Read_ref();
|
|
|
|
[EditorBrowsable(EditorBrowsableState.Never)]
|
|
public abstract string ReadPropertyName();
|
|
|
|
protected abstract Type ReadKeyPrefix(bool ignore = false);
|
|
|
|
protected abstract void ReadKeySuffix();
|
|
|
|
internal abstract byte[] ReadElement(bool skip = false);
|
|
|
|
public abstract void Dispose();
|
|
|
|
internal virtual bool Goto(string key)
|
|
{
|
|
if (key == null)
|
|
{
|
|
throw new ArgumentNullException("Key cannot be NULL when loading data.");
|
|
}
|
|
string text;
|
|
while ((text = ReadPropertyName()) != key)
|
|
{
|
|
if (text == null)
|
|
{
|
|
return false;
|
|
}
|
|
Skip();
|
|
}
|
|
return true;
|
|
}
|
|
|
|
internal virtual bool StartReadObject()
|
|
{
|
|
serializationDepth++;
|
|
return false;
|
|
}
|
|
|
|
internal virtual void EndReadObject()
|
|
{
|
|
serializationDepth--;
|
|
}
|
|
|
|
internal abstract bool StartReadDictionary();
|
|
|
|
internal abstract void EndReadDictionary();
|
|
|
|
internal abstract bool StartReadDictionaryKey();
|
|
|
|
internal abstract void EndReadDictionaryKey();
|
|
|
|
internal abstract void StartReadDictionaryValue();
|
|
|
|
internal abstract bool EndReadDictionaryValue();
|
|
|
|
internal abstract bool StartReadCollection();
|
|
|
|
internal abstract void EndReadCollection();
|
|
|
|
internal abstract bool StartReadCollectionItem();
|
|
|
|
internal abstract bool EndReadCollectionItem();
|
|
|
|
internal ES3Reader(ES3Settings settings, bool readHeaderAndFooter = true)
|
|
{
|
|
this.settings = settings;
|
|
}
|
|
|
|
[EditorBrowsable(EditorBrowsableState.Never)]
|
|
public virtual void Skip()
|
|
{
|
|
ReadElement(skip: true);
|
|
}
|
|
|
|
public virtual T Read<T>()
|
|
{
|
|
return Read<T>(ES3TypeMgr.GetOrCreateES3Type(typeof(T)));
|
|
}
|
|
|
|
public virtual void ReadInto<T>(object obj)
|
|
{
|
|
ReadInto<T>(obj, ES3TypeMgr.GetOrCreateES3Type(typeof(T)));
|
|
}
|
|
|
|
[EditorBrowsable(EditorBrowsableState.Never)]
|
|
public T ReadProperty<T>()
|
|
{
|
|
return ReadProperty<T>(ES3TypeMgr.GetOrCreateES3Type(typeof(T)));
|
|
}
|
|
|
|
[EditorBrowsable(EditorBrowsableState.Never)]
|
|
public T ReadProperty<T>(ES3Type type)
|
|
{
|
|
ReadPropertyName();
|
|
return Read<T>(type);
|
|
}
|
|
|
|
[EditorBrowsable(EditorBrowsableState.Never)]
|
|
public long ReadRefProperty()
|
|
{
|
|
ReadPropertyName();
|
|
return Read_ref();
|
|
}
|
|
|
|
internal Type ReadType()
|
|
{
|
|
return ES3Reflection.GetType(Read<string>(ES3Type_string.Instance));
|
|
}
|
|
|
|
public object SetPrivateProperty(string name, object value, object objectContainingProperty)
|
|
{
|
|
ES3Reflection.ES3ReflectedMember eS3ReflectedProperty = ES3Reflection.GetES3ReflectedProperty(objectContainingProperty.GetType(), name);
|
|
if (eS3ReflectedProperty.IsNull)
|
|
{
|
|
throw new MissingMemberException("A private property named " + name + " does not exist in the type " + objectContainingProperty.GetType());
|
|
}
|
|
eS3ReflectedProperty.SetValue(objectContainingProperty, value);
|
|
return objectContainingProperty;
|
|
}
|
|
|
|
public object SetPrivateField(string name, object value, object objectContainingField)
|
|
{
|
|
ES3Reflection.ES3ReflectedMember eS3ReflectedMember = ES3Reflection.GetES3ReflectedMember(objectContainingField.GetType(), name);
|
|
if (eS3ReflectedMember.IsNull)
|
|
{
|
|
throw new MissingMemberException("A private field named " + name + " does not exist in the type " + objectContainingField.GetType());
|
|
}
|
|
eS3ReflectedMember.SetValue(objectContainingField, value);
|
|
return objectContainingField;
|
|
}
|
|
|
|
public virtual T Read<T>(string key)
|
|
{
|
|
if (!Goto(key))
|
|
{
|
|
throw new KeyNotFoundException("Key \"" + key + "\" was not found in file \"" + settings.FullPath + "\". Use Load<T>(key, defaultValue) if you want to return a default value if the key does not exist.");
|
|
}
|
|
Type type = ReadTypeFromHeader<T>();
|
|
return Read<T>(ES3TypeMgr.GetOrCreateES3Type(type));
|
|
}
|
|
|
|
public virtual T Read<T>(string key, T defaultValue)
|
|
{
|
|
if (!Goto(key))
|
|
{
|
|
return defaultValue;
|
|
}
|
|
Type type = ReadTypeFromHeader<T>();
|
|
return Read<T>(ES3TypeMgr.GetOrCreateES3Type(type));
|
|
}
|
|
|
|
public virtual void ReadInto<T>(string key, T obj) where T : class
|
|
{
|
|
if (!Goto(key))
|
|
{
|
|
throw new KeyNotFoundException("Key \"" + key + "\" was not found in file \"" + settings.FullPath + "\"");
|
|
}
|
|
Type type = ReadTypeFromHeader<T>();
|
|
ReadInto<T>(obj, ES3TypeMgr.GetOrCreateES3Type(type));
|
|
}
|
|
|
|
protected virtual void ReadObject<T>(object obj, ES3Type type)
|
|
{
|
|
if (!StartReadObject())
|
|
{
|
|
type.ReadInto<T>(this, obj);
|
|
EndReadObject();
|
|
}
|
|
}
|
|
|
|
protected virtual T ReadObject<T>(ES3Type type)
|
|
{
|
|
if (StartReadObject())
|
|
{
|
|
return default(T);
|
|
}
|
|
object obj = type.Read<T>(this);
|
|
EndReadObject();
|
|
return (T)obj;
|
|
}
|
|
|
|
[EditorBrowsable(EditorBrowsableState.Never)]
|
|
public virtual T Read<T>(ES3Type type)
|
|
{
|
|
if (type == null || type.isUnsupported)
|
|
{
|
|
throw new NotSupportedException("Type of " + type?.ToString() + " is not currently supported, and could not be loaded using reflection.");
|
|
}
|
|
if (type.isPrimitive)
|
|
{
|
|
return (T)type.Read<T>(this);
|
|
}
|
|
if (type.isCollection)
|
|
{
|
|
return (T)((ES3CollectionType)type).Read(this);
|
|
}
|
|
if (type.isDictionary)
|
|
{
|
|
return (T)((ES3DictionaryType)type).Read(this);
|
|
}
|
|
return ReadObject<T>(type);
|
|
}
|
|
|
|
[EditorBrowsable(EditorBrowsableState.Never)]
|
|
public virtual void ReadInto<T>(object obj, ES3Type type)
|
|
{
|
|
if (type == null || type.isUnsupported)
|
|
{
|
|
throw new NotSupportedException("Type of " + obj.GetType()?.ToString() + " is not currently supported, and could not be loaded using reflection.");
|
|
}
|
|
if (type.isCollection)
|
|
{
|
|
((ES3CollectionType)type).ReadInto(this, obj);
|
|
}
|
|
else if (type.isDictionary)
|
|
{
|
|
((ES3DictionaryType)type).ReadInto(this, obj);
|
|
}
|
|
else
|
|
{
|
|
ReadObject<T>(obj, type);
|
|
}
|
|
}
|
|
|
|
[EditorBrowsable(EditorBrowsableState.Never)]
|
|
internal Type ReadTypeFromHeader<T>()
|
|
{
|
|
if (typeof(T) == typeof(object))
|
|
{
|
|
return ReadKeyPrefix();
|
|
}
|
|
if (settings.typeChecking)
|
|
{
|
|
Type type = ReadKeyPrefix();
|
|
if (type != typeof(T))
|
|
{
|
|
throw new InvalidOperationException("Trying to load data of type " + typeof(T)?.ToString() + ", but data contained in file is type of " + type?.ToString() + ".");
|
|
}
|
|
return type;
|
|
}
|
|
ReadKeyPrefix(ignore: true);
|
|
return typeof(T);
|
|
}
|
|
|
|
public static ES3Reader Create()
|
|
{
|
|
return Create(new ES3Settings());
|
|
}
|
|
|
|
public static ES3Reader Create(string filePath)
|
|
{
|
|
return Create(new ES3Settings(filePath));
|
|
}
|
|
|
|
public static ES3Reader Create(string filePath, ES3Settings settings)
|
|
{
|
|
return Create(new ES3Settings(filePath, settings));
|
|
}
|
|
|
|
public static ES3Reader Create(ES3Settings settings)
|
|
{
|
|
Stream stream = ES3Stream.CreateStream(settings, ES3FileMode.Read);
|
|
if (stream == null)
|
|
{
|
|
return null;
|
|
}
|
|
if (settings.format == ES3.Format.JSON)
|
|
{
|
|
return new ES3JSONReader(stream, settings);
|
|
}
|
|
return null;
|
|
}
|
|
|
|
public static ES3Reader Create(byte[] bytes)
|
|
{
|
|
return Create(bytes, new ES3Settings());
|
|
}
|
|
|
|
public static ES3Reader Create(byte[] bytes, ES3Settings settings)
|
|
{
|
|
Stream stream = ES3Stream.CreateStream(new MemoryStream(bytes), settings, ES3FileMode.Read);
|
|
if (stream == null)
|
|
{
|
|
return null;
|
|
}
|
|
if (settings.format == ES3.Format.JSON)
|
|
{
|
|
return new ES3JSONReader(stream, settings);
|
|
}
|
|
return null;
|
|
}
|
|
|
|
internal static ES3Reader Create(Stream stream, ES3Settings settings)
|
|
{
|
|
stream = ES3Stream.CreateStream(stream, settings, ES3FileMode.Read);
|
|
if (settings.format == ES3.Format.JSON)
|
|
{
|
|
return new ES3JSONReader(stream, settings);
|
|
}
|
|
return null;
|
|
}
|
|
|
|
internal static ES3Reader Create(Stream stream, ES3Settings settings, bool readHeaderAndFooter)
|
|
{
|
|
if (settings.format == ES3.Format.JSON)
|
|
{
|
|
return new ES3JSONReader(stream, settings, readHeaderAndFooter);
|
|
}
|
|
return null;
|
|
}
|
|
}
|