public void Encode(BinaryWriter writer)
{
EsfType containedTypeCode = ContainedTypeCode;
EsfType myRealType = (EsfType)(containedTypeCode + 0x40);
#if DEBUG
Console.WriteLine("encoding array with {2} bytes, code {0} containing {1}", myRealType, containedTypeCode, Value.Length);
#endif
writer.Write((byte)myRealType);
byte[] encodedArray = new byte[0];
using (var stream = new MemoryStream()) {
using (var memWriter = new BinaryWriter(stream)) {
CodecNode <T> valueNode = Codec.CreateValueNode(containedTypeCode, false) as CodecNode <T>;
valueNode.TypeCode = containedTypeCode;
foreach (T item in Value)
{
valueNode.Value = item;
valueNode.WriteValue(memWriter);
}
encodedArray = stream.ToArray();
#if DEBUG
Console.WriteLine("size is {0}", encodedArray.Length);
#endif
Codec.WriteOffset(writer, encodedArray.Length);
writer.Write(encodedArray);
}
}
}
public override EsfNode CreateValueNode(EsfType typeCode, bool optimize = false)
{
StringNode stringNode;
switch (typeCode)
{
case EsfType.UTF16:
stringNode = new StringNode(ReadUtf16String, WriteUtf16Reference);
break;
case EsfType.ASCII:
stringNode = new StringNode(ReadAsciiString, WriteAsciiReference);
break;
case EsfType.ASCII_W21:
stringNode = new StringNode(ReadAsciiString, WriteAsciiReference);
break;
case EsfType.ASCII_W25:
stringNode = new StringNode(ReadAsciiString, WriteAsciiReference);
break;
default:
return(base.CreateValueNode(typeCode));
}
stringNode.TypeCode = typeCode;
return(stringNode);
}
public EsfNode ReadValueNode(BinaryReader reader, EsfType typeCode)
{
EsfNode esfNode = CreateValueNode(typeCode);
(esfNode as ICodecNode).Decode(reader, typeCode);
return(esfNode);
}
public void Encode(BinaryWriter writer)
{
EsfType containedTypeCode = ContainedTypeCode;
EsfType esfType = containedTypeCode + 64;
writer.Write((byte)esfType);
byte[] array = new byte[0];
using (MemoryStream memoryStream = new MemoryStream())
{
using (BinaryWriter writer2 = new BinaryWriter(memoryStream))
{
CodecNode <T> codecNode =
base.Codec.CreateValueNode(containedTypeCode, optimize: false) as CodecNode <T>;
codecNode.TypeCode = containedTypeCode;
T[] value = Value;
for (int i = 0; i < value.Length; i++)
{
T val2 = codecNode.Value = value[i];
codecNode.WriteValue(writer2);
}
array = memoryStream.ToArray();
base.Codec.WriteOffset(writer, array.Length);
writer.Write(array);
}
}
}
public override EsfNode CreateValueNode(EsfType typeCode, bool optimize = false)
{
StringNode result;
switch (typeCode)
{
case EsfType.UTF16:
result = new StringNode(ReadUtf16String, WriteUtf16Reference);
break;
case EsfType.ASCII:
result = new StringNode(ReadAsciiString, WriteAsciiReference);
break;
// HACK: RoninX
case EsfType.ASCII_W21:
result = new StringNode(ReadAsciiString, WriteAsciiReference);
break;
case EsfType.ASCII_W25:
result = new StringNode(ReadAsciiString, WriteAsciiReference);
break;
default:
return(base.CreateValueNode(typeCode));
}
result.TypeCode = typeCode;
return(result);
}
protected override int ReadValue(BinaryReader reader, EsfType readAs)
{
int result;
switch (readAs)
{
case EsfType.INT32_ZERO:
result = 0;
break;
case EsfType.INT32_BYTE:
result = reader.ReadSByte();
break;
case EsfType.INT32_SHORT:
result = reader.ReadInt16();
break;
case EsfType.INT32_24BIT:
result = ReadInt24(reader);
break;
case EsfType.INT32:
result = reader.ReadInt32();
break;
default:
throw new InvalidOperationException();
}
return(result);
}
protected override uint ReadValue(BinaryReader reader, EsfType readAs)
{
switch (readAs)
{
case EsfType.UINT32_ZERO:
return(0u);
case EsfType.UINT32_ONE:
return(1u);
case EsfType.UINT32_BYTE:
return(reader.ReadByte());
case EsfType.UINT32_SHORT:
return(reader.ReadUInt16());
case EsfType.UINT32_24BIT:
return(ReadUInt24(reader));
case EsfType.UINT32:
return(reader.ReadUInt32());
default:
throw new InvalidOperationException();
}
}
public EsfArrayNode(EsfCodec codec, EsfType code) : base(delegate(string s) { throw new InvalidOperationException(); }) {
Codec = codec;
Separator = " ";
TypeCode = code;
ConvertItem = DefaultFromString;
Value = new T[0];
}
private void TestIntNode(int val, EsfType expectedTypeCode = EsfType.INVALID)
{
EsfValueNode <int> node = new OptimizedIntNode {
Value = val
};
TestNode(node, expectedTypeCode);
}
private void TestUIntNode(uint val, EsfType typeCode = EsfType.UINT32)
{
EsfValueNode <uint> node = new OptimizedUIntNode {
Value = val, TypeCode = typeCode
};
TestNode(node);
}
public virtual void Decode(BinaryReader reader, EsfType unused)
{
base.Codec.ReadRecordInfo(reader, base.OriginalTypeCode, out string name, out byte version);
base.Name = name;
base.Version = version;
base.Size = base.Codec.ReadSize(reader);
Value = base.Codec.ReadToOffset(reader, reader.BaseStream.Position + base.Size);
}
// Adds readers for optimized values
public override EsfNode CreateValueNode(EsfType typeCode, bool optimize = true)
{
EsfNode result;
switch (typeCode)
{
case EsfType.BOOL:
case EsfType.BOOL_TRUE:
case EsfType.BOOL_FALSE:
if (optimize)
{
return(new OptimizedBoolNode());
}
else
{
result = new BoolNode();
}
break;
case EsfType.UINT32:
case EsfType.UINT32_ZERO:
case EsfType.UINT32_ONE:
case EsfType.UINT32_BYTE:
case EsfType.UINT32_SHORT:
case EsfType.UINT32_24BIT:
return(new OptimizedUIntNode
{
SingleByteMin = !optimize
});
case EsfType.INT32:
case EsfType.INT32_ZERO:
case EsfType.INT32_BYTE:
case EsfType.INT32_SHORT:
case EsfType.INT32_24BIT:
return(new OptimizedIntNode
{
SingleByteMin = !optimize
});
case EsfType.SINGLE:
case EsfType.SINGLE_ZERO:
if (optimize)
{
return(new OptimizedFloatNode());
}
else
{
result = new FloatNode();
}
break;
default:
return(base.CreateValueNode(typeCode));
}
result.TypeCode = typeCode;
return(result);
}
protected override float ReadValue(BinaryReader reader, EsfType readAs)
{
if (readAs != EsfType.SINGLE_ZERO)
{
return(reader.ReadSingle());
}
return(0f);
}
// read
public EsfNode ReadValueNode(BinaryReader reader, EsfType typeCode)
{
try {
EsfNode result = CreateValueNode(typeCode);
(result as ICodecNode).Decode(reader, typeCode);
return(result);
} catch (Exception e) {
throw new InvalidDataException(string.Format("{0} at {1:x}", e.Message, reader.BaseStream.Position));
}
}
public override void Decode(BinaryReader reader, EsfType type)
{
base.Codec.ReadRecordInfo(reader, base.OriginalTypeCode, out string name, out byte version);
base.Name = name;
base.Version = version;
int num = base.Codec.ReadSize(reader);
int num2 = (int)(reader.BaseStream.Position - mapStart);
byteCount = num + num2;
reader.BaseStream.Seek(num, SeekOrigin.Current);
}
public virtual void Decode(BinaryReader reader, EsfType unused)
{
string outName;
byte outVersion;
Codec.ReadRecordInfo(reader, OriginalTypeCode, out outName, out outVersion);
Name = outName;
Version = outVersion;
Size = Codec.ReadSize(reader);
Value = Codec.ReadToOffset(reader, reader.BaseStream.Position + Size);
}
protected virtual EsfNode ReadArrayNode(BinaryReader reader, EsfType typeCode)
{
EsfNode result;
try {
result = CreateArrayNode(typeCode);
} catch (Exception) {
throw new InvalidDataException(string.Format("{0} at {1:x}", reader.BaseStream.Position));
}
(result as ICodecNode).Decode(reader, typeCode);
return(result);
}
private EsfValueNode <T> TestNode <T>(EsfValueNode <T> node, EsfType expectedTypeCode = EsfType.INVALID)
{
byte[] data = encodeNode(node);
EsfNode decoded = decodeNode(data);
EsfValueNode <T> node2 = decoded as EsfValueNode <T>;
assertEqual(node, node2);
if (expectedTypeCode != EsfType.INVALID)
{
assertEqual(node2.TypeCode, expectedTypeCode);
}
encodeNode(node2);
return(node2);
}
public override void Decode(BinaryReader reader, EsfType type)
{
// we need to keep track of the original data to give it to the actual parser later
string name;
byte remember;
Codec.ReadRecordInfo(reader, OriginalTypeCode, out name, out remember);
Name = name;
Version = remember;
int size = Codec.ReadSize(reader);
int infoSize = (int)(reader.BaseStream.Position - mapStart);
byteCount = size + infoSize;
reader.BaseStream.Seek(size, SeekOrigin.Current);
}
public void Decode(BinaryReader reader, EsfType type)
{
EsfType containedTypeCode = ContainedTypeCode;
int num = base.Codec.ReadSize(reader);
List <T> list = new List <T>();
using (BinaryReader binaryReader = new BinaryReader(new MemoryStream(reader.ReadBytes(num))))
{
while (binaryReader.BaseStream.Position < num)
{
list.Add(ReadFromCodec(binaryReader, containedTypeCode));
}
}
Value = list.ToArray();
}
protected override EsfNode CreateArrayNode(EsfType typeCode)
{
EsfNode result;
// support array types for new primitives
// this sets the type code of the base type to later have an easier time
switch (typeCode)
{
case EsfType.BOOL_TRUE_ARRAY:
case EsfType.BOOL_FALSE_ARRAY:
case EsfType.UINT_ZERO_ARRAY:
case EsfType.UINT_ONE_ARRAY:
case EsfType.INT32_ZERO_ARRAY:
case EsfType.SINGLE_ZERO_ARRAY:
// trying to read this should result in an infinite loop
throw new InvalidDataException(string.Format("Array {0:x} of zero-byte entries makes no sense", typeCode));
case EsfType.UINT32_BYTE_ARRAY:
case EsfType.UINT32_SHORT_ARRAY:
case EsfType.UINT32_24BIT_ARRAY:
result = new OptimizedArrayNode <uint>(this, typeCode, delegate(uint val) {
return(new OptimizedUIntNode
{
Value = val,
SingleByteMin = true
});
});
break;
case EsfType.INT32_BYTE_ARRAY:
case EsfType.INT32_SHORT_ARRAY:
result = new OptimizedArrayNode <int>(this, typeCode, delegate(int val) {
return(new OptimizedIntNode
{
Value = val,
SingleByteMin = true
});
});
break;
default:
result = base.CreateArrayNode(typeCode);
return(result);
}
result.TypeCode = (EsfType)typeCode;
return(result);
}
protected override bool ReadValue(BinaryReader reader, EsfType readAs)
{
switch (readAs)
{
case EsfType.BOOL:
return(reader.ReadBoolean());
case EsfType.BOOL_TRUE:
return(true);
case EsfType.BOOL_FALSE:
return(false);
default:
throw new InvalidOperationException();
}
}
public virtual EsfNode Decode(BinaryReader reader, byte code)
{
// create node appropriate to type code
EsfNode result;
try {
long position = reader.BaseStream.Position;
EsfType typeCode = (EsfType)code;
// writeDebug = reader.BaseStream.Position > 0xd80000;
if (code < (byte)EsfType.BOOL_ARRAY)
{
result = ReadValueNode(reader, typeCode);
// if (Log != null) { Log(result.ToXml()); };
}
else if (typeCode < EsfType.RECORD)
{
result = ReadArrayNode(reader, typeCode);
}
else if (typeCode == EsfType.RECORD)
{
result = ReadRecordNode(reader, code);
}
else if (typeCode == EsfType.RECORD_BLOCK)
{
result = ReadRecordArrayNode(reader, code);
}
else
{
throw new InvalidDataException(string.Format("Type code {0:x} at {1:x} invalid", typeCode, reader.BaseStream.Position - 1));
}
// if (Log != null) { Log(string.Format("Read node {0} / {1}", result, result.TypeCode));
if (NodeReadFinished != null)
{
NodeReadFinished(result, position);
}
} catch (Exception e) {
Console.WriteLine(string.Format("Exception at {0:x}: {1}", reader.BaseStream.Position, e));
throw e;
}
return(result);
}
public void Decode(BinaryReader reader, EsfType type)
{
EsfType containedTypeCode = ContainedTypeCode;
#if DEBUG
// Console.WriteLine("decoding array type code {0} containing {1}", type, containedTypeCode);
#endif
int size = Codec.ReadSize(reader);
#if DEBUG
// Console.WriteLine("Reading array[{0}] with {1} elements", type, size);
#endif
List <T> read = new List <T>();
using (var itemReader = new BinaryReader(new MemoryStream(reader.ReadBytes(size)))) {
while (itemReader.BaseStream.Position < size)
{
read.Add(ReadFromCodec(itemReader, containedTypeCode));
}
}
Value = read.ToArray();
}
protected override EsfNode CreateArrayNode(EsfType typeCode)
{
EsfNode esfNode;
switch (typeCode)
{
case EsfType.BOOL_TRUE_ARRAY:
case EsfType.BOOL_FALSE_ARRAY:
case EsfType.UINT_ZERO_ARRAY:
case EsfType.UINT_ONE_ARRAY:
case EsfType.INT32_ZERO_ARRAY:
case EsfType.SINGLE_ZERO_ARRAY:
throw new InvalidDataException($"Array {typeCode:x} of zero-byte entries makes no sense");
case EsfType.UINT32_BYTE_ARRAY:
case EsfType.UINT32_SHORT_ARRAY:
case EsfType.UINT32_24BIT_ARRAY:
esfNode = new OptimizedArrayNode <uint>(this, typeCode, (uint val) => new OptimizedUIntNode
{
Value = val,
SingleByteMin = true
});
break;
case EsfType.INT32_BYTE_ARRAY:
case EsfType.INT32_SHORT_ARRAY:
esfNode = new OptimizedArrayNode <int>(this, typeCode, (int val) => new OptimizedIntNode
{
Value = val,
SingleByteMin = true
});
break;
default:
return(base.CreateArrayNode(typeCode));
}
esfNode.TypeCode = typeCode;
return(esfNode);
}
public void Decode(BinaryReader reader, EsfType unused)
{
base.Codec.ReadRecordInfo(reader, base.OriginalTypeCode, out string name, out byte version);
base.Name = name;
base.Version = version;
base.Size = base.Codec.ReadSize(reader);
int num = base.Codec.ReadCount(reader);
List <EsfNode> list = new List <EsfNode>(num);
for (int i = 0; i < num; i++)
{
RecordEntryNode recordEntryNode = new RecordEntryNode(base.Codec)
{
Name = $"{base.Name} - {i}",
TypeCode = EsfType.RECORD_BLOCK_ENTRY
};
recordEntryNode.Decode(reader, EsfType.RECORD_BLOCK_ENTRY);
list.Add(recordEntryNode);
}
Value = list;
}
protected override bool ReadValue(BinaryReader reader, EsfType readAs)
{
bool result;
switch (readAs)
{
case EsfType.BOOL:
result = reader.ReadBoolean();
break;
case EsfType.BOOL_TRUE:
result = true;
break;
case EsfType.BOOL_FALSE:
result = false;
break;
default:
throw new InvalidOperationException();
}
return(result);
}
public void Decode(BinaryReader reader, EsfType unused)
{
string name;
byte version;
Codec.ReadRecordInfo(reader, OriginalTypeCode, out name, out version);
Name = name;
Version = version;
Size = (int)Codec.ReadSize(reader);
int itemCount = Codec.ReadCount(reader);
List <EsfNode> containedNodes = new List <EsfNode>(itemCount);
for (int i = 0; i < itemCount; i++)
{
RecordEntryNode contained = new RecordEntryNode(Codec)
{
Name = string.Format("{0} - {1}", Name, i),
TypeCode = EsfType.RECORD_BLOCK_ENTRY
};
contained.Decode(reader, EsfType.RECORD_BLOCK_ENTRY);
containedNodes.Add(contained);
}
Value = containedNodes;
}
// Adds readers for optimized values
public override EsfNode CreateValueNode(EsfType typeCode, bool optimize = true)
{
EsfNode result;
switch (typeCode)
{
case EsfType.BOOL:
case EsfType.BOOL_TRUE:
case EsfType.BOOL_FALSE:
if (optimize)
{
return(new OptimizedBoolNode());
}
else
{
result = new BoolNode();
}
break;
case EsfType.UINT32:
case EsfType.UINT32_ZERO:
case EsfType.UINT32_ONE:
case EsfType.UINT32_BYTE:
case EsfType.UINT32_SHORT:
case EsfType.UINT32_24BIT:
return(new OptimizedUIntNode
{
SingleByteMin = !optimize
});
case EsfType.INT32:
case EsfType.INT32_ZERO:
case EsfType.INT32_BYTE:
case EsfType.INT32_SHORT:
case EsfType.INT32_24BIT:
return(new OptimizedIntNode
{
SingleByteMin = !optimize
});
case EsfType.SINGLE:
case EsfType.SINGLE_ZERO:
if (optimize)
{
return(new OptimizedFloatNode());
}
else
{
result = new FloatNode();
}
break;
//TODO confirm intended data types of types indicated by unknown enum values
case EsfType.UNKNOWN_23:
result = new SByteNode();
break;
case EsfType.UNKNOWN_24:
result = new ShortNode();
break;
default:
return(base.CreateValueNode(typeCode));
}
result.TypeCode = typeCode;
return(result);
}
///<inheritdoc />
protected override Type26 ReadValue(BinaryReader reader, EsfType readAs)
{
return(new Type26(reader));
}
