// encodes the given node
public void Encode(BinaryWriter writer, EsfNode node)
{
try {
//NamedNode named = node as NamedNode;
if (node.TypeCode == EsfType.RECORD_BLOCK_ENTRY)
{
EncodeSized(writer, (node as ParentNode).AllNodes);
}
else if (node.TypeCode < EsfType.BOOL_ARRAY)
{
WriteValueNode(writer, node);
}
else if (node.TypeCode < EsfType.RECORD)
{
WriteArrayNode(writer, node);
}
else if (node.TypeCode == EsfType.RECORD)
{
WriteRecordNode(writer, node);
}
else if (node.TypeCode == EsfType.RECORD_BLOCK)
{
WriteRecordArrayNode(writer, node);
}
else
{
throw new NotImplementedException(string.Format("Cannot write type code {0:x} at {1:x}", node.TypeCode));
}
} catch {
Console.WriteLine(string.Format("failed to write node {0}", node));
throw;
}
}
public EsfNode ReadValueNode(BinaryReader reader, EsfType typeCode)
{
EsfNode esfNode = CreateValueNode(typeCode);
(esfNode as ICodecNode).Decode(reader, typeCode);
return(esfNode);
}
protected override RecordNode DecodeDelegate()
{
byte[] value = (compressedNode.Values[0] as EsfValueNode <byte[]>).Value;
ParentNode parentNode = compressedNode.Children[0];
uint value2 = (parentNode.Values[0] as EsfValueNode <uint>).Value;
byte[] value3 = (parentNode.Values[1] as EsfValueNode <byte[]>).Value;
Decoder decoder = new Decoder();
decoder.SetDecoderProperties(value3);
byte[] array = new byte[value2];
using (MemoryStream inStream = new MemoryStream(value, writable: false))
{
using (MemoryStream memoryStream = new MemoryStream(array))
{
decoder.Code(inStream, memoryStream, value.Length, value2, null);
array = memoryStream.ToArray();
}
}
AbcaFileCodec abcaFileCodec = new AbcaFileCodec();
EsfNode esfNode = abcaFileCodec.Parse(array);
using (BinaryReader reader = new BinaryReader(new MemoryStream(array)))
{
esfNode = abcaFileCodec.Parse(reader);
}
return(esfNode as RecordNode);
}
public override bool Iterate(EsfNode fromNode)
{
ParentNode parent = fromNode.Parent as ParentNode;
bool result = (parent != null);
if (result)
{
bool pastNode = false;
foreach (EsfNode candidate in parent.AllNodes)
{
if (pastNode)
{
if (!Visit(candidate))
{
result = false;
break;
}
}
else
{
pastNode = (candidate == fromNode);
}
}
}
return(result);
}
// public T[] ReadArrayItems<T>(BinaryReader reader, ValueReader<T> ReadValue) {
// long targetOffset = ReadSize(reader);
// List<T> items = new List<T>();
// while (reader.BaseStream.Position < targetOffset) {
// items.Add(ReadValue(reader));
// }
// return items.ToArray();
// }
protected void WriteArrayNode(BinaryWriter writer, EsfNode arrayNode)
{
// writer.Write((byte) arrayNode.TypeCode);
#if DEBUG
Console.WriteLine("writing array node type {0} at {1}", arrayNode.TypeCode, writer.BaseStream.Position);
#endif
(arrayNode as ICodecNode).Encode(writer);
}
public override bool Iterate(EsfNode node)
{
bool result = (node != null && Visit(node));
if (result)
{
Iterate(node.Parent as ParentNode);
}
return(result);
}
// 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 virtual void WriteValueNode(BinaryWriter writer, EsfNode node)
{
if (node is ICodecNode)
{
(node as ICodecNode).Encode(writer);
return;
}
throw new InvalidDataException($"Invalid type code {node.TypeCode:x} at {writer.BaseStream.Position:x}");
}
public static string CreatePath(EsfNode node, string separator = "/")
{
NodePathCreator creator = new NodePathCreator {
PathSeparator = separator
};
new ParentIterator {
Visit = creator.Visit
}.Iterate(node);
return(creator.Path);
}
public virtual void WriteValueNode(BinaryWriter writer, EsfNode node)
{
if (node is ICodecNode)
{
(node as ICodecNode).Encode(writer);
}
else
{
throw new InvalidDataException(string.Format("Invalid type code {0:x} at {1:x}", node.TypeCode, writer.BaseStream.Position));
}
}
protected void WriteRecordArrayNode(BinaryWriter writer, EsfNode node)
{
RecordArrayNode recordArrayNode = node as RecordArrayNode;
if (recordArrayNode != null)
{
recordArrayNode.Encode(writer);
return;
}
throw new InvalidOperationException();
}
/*
* Invalidate until the first memory-mapped node is found.
*/
private bool Invalidate(EsfNode node)
{
MemoryMappedRecordNode mapped = node as MemoryMappedRecordNode;
bool continuteIteration = mapped == null;
if (mapped != null)
{
mapped.Invalid = true;
}
// don't continue when a node was invalidated
return(!continuteIteration);
}
public void EncodeRootNode(BinaryWriter writer, EsfNode rootNode)
{
WriteHeader(writer);
long position = writer.BaseStream.Position;
writer.Write(0);
WriteRecordNode(writer, rootNode);
long position2 = writer.BaseStream.Position;
WriteNodeNames(writer);
writer.BaseStream.Seek(position, SeekOrigin.Begin);
writer.Write((uint)position2);
}
public override bool Iterate(EsfNode node)
{
bool result = Visit(node);
if (result)
{
ParentNode parent = node as ParentNode;
if (parent != null)
{
parent.AllNodes.ForEach(n => Iterate(n));
}
}
return(result);
}
public void EncodeRootNode(BinaryWriter writer, EsfNode rootNode)
{
WriteHeader(writer);
long currentPosition = writer.BaseStream.Position;
writer.Write(0);
WriteRecordNode(writer, rootNode);
// remember the offset of the node name list
long nodeNamePosition = writer.BaseStream.Position;
WriteNodeNames(writer);
writer.BaseStream.Seek(currentPosition, SeekOrigin.Begin);
writer.Write((uint)nodeNamePosition);
}
public EsfNode Parse(BinaryReader reader)
{
reader.BaseStream.Seek(0L, SeekOrigin.Begin);
Header = ReadHeader(reader);
uint num = reader.ReadUInt32();
long position = reader.BaseStream.Position;
reader.BaseStream.Seek(num, SeekOrigin.Begin);
ReadNodeNames(reader);
reader.BaseStream.Seek(position, SeekOrigin.Begin);
EsfNode esfNode = Decode(reader);
esfNode.Codec = this;
return(esfNode);
}
public EsfNode Parse(BinaryReader reader)
{
reader.BaseStream.Seek(0, SeekOrigin.Begin);
Header = ReadHeader(reader);
uint nodeNameOffset = reader.ReadUInt32();
long restorePosition = reader.BaseStream.Position;
reader.BaseStream.Seek(nodeNameOffset, SeekOrigin.Begin);
ReadNodeNames(reader);
reader.BaseStream.Seek(restorePosition, SeekOrigin.Begin);
EsfNode result = Decode(reader);
result.Codec = this;
return(result);
}
public bool Visit(EsfNode node)
{
INamedNode named = node as INamedNode;
if (named is CompressedNode)
{
path = path.Substring(path.IndexOf(PathSeparator) + 1);
}
if (!(named is MemoryMappedRecordNode) || string.IsNullOrEmpty(path))
{
path = string.Format("{0}{1}{2}", named.GetName(), PathSeparator, path);
#if DEBUG
Console.WriteLine("node {0} - {1}", named.GetName(), node.GetType());
#endif
}
return(true);
}
// reads a node from the reader at its current position
public EsfNode Decode(BinaryReader reader)
{
// read type code
byte typeCode = reader.ReadByte();
if (NodeReadStarting != null)
{
NodeReadStarting(typeCode, reader.BaseStream.Position - 1);
}
EsfNode result = Decode(reader, typeCode);
if (NodeReadFinished != null)
{
NodeReadFinished(result, reader.BaseStream.Position);
}
// Console.WriteLine(string.Format("decoded {0} at {1:x}", result.TypeCode, reader.BaseStream.Position));
return(result);
}
public EsfNode Decode(BinaryReader reader)
{
byte b = reader.ReadByte();
if (this.NodeReadStarting != null)
{
this.NodeReadStarting(b, reader.BaseStream.Position - 1);
}
EsfNode esfNode = Decode(reader, b);
if (this.NodeReadFinished != null)
{
this.NodeReadFinished(esfNode, reader.BaseStream.Position);
}
return(esfNode);
}
protected virtual void WriteRecordNode(BinaryWriter writer, EsfNode node)
{
RecordNode recordNode = node as RecordNode;
recordNode.Encode(writer);
}
protected virtual EsfNode CreateArrayNode(EsfType typeCode)
{
EsfNode result = null;
switch (typeCode)
{
case EsfType.BOOL_ARRAY:
result = new EsfArrayNode <bool>(this, typeCode);
// CreateArrayNode<bool>(reader), ItemReader = ReadBool);
break;
case EsfType.INT8_ARRAY:
result = new EsfArrayNode <sbyte>(this, typeCode);
break;
case EsfType.INT16_ARRAY:
result = new EsfArrayNode <short>(this, typeCode);
break;
case EsfType.INT32_ARRAY:
result = new EsfArrayNode <int>(this, typeCode);
break;
case EsfType.INT64_ARRAY:
result = new EsfArrayNode <long>(this, typeCode);
break;
case EsfType.UINT8_ARRAY:
result = new EsfArrayNode <byte>(this, typeCode);
break;
case EsfType.UINT16_ARRAY:
result = new EsfArrayNode <ushort>(this, typeCode);
break;
case EsfType.UINT32_ARRAY:
result = new EsfArrayNode <uint>(this, typeCode);
break;
case EsfType.UINT64_ARRAY:
result = new EsfArrayNode <ulong>(this, typeCode);
break;
case EsfType.SINGLE_ARRAY:
result = new EsfArrayNode <float>(this, typeCode);
break;
case EsfType.DOUBLE_ARRAY:
result = new EsfArrayNode <double>(this, typeCode);
break;
case EsfType.COORD2D_ARRAY:
result = new EsfArrayNode <Coordinates2D>(this, typeCode)
{
Separator = "-"
};
break;
case EsfType.COORD3D_ARRAY:
result = new EsfArrayNode <Coordinates2D>(this, typeCode)
{
Separator = "-"
};
break;
case EsfType.UTF16_ARRAY:
result = new EsfArrayNode <string>(this, EsfType.UTF16_ARRAY);
break;
case EsfType.ASCII_ARRAY:
result = new EsfArrayNode <string>(this, EsfType.ASCII_ARRAY);
break;
case EsfType.ANGLE_ARRAY:
result = new EsfArrayNode <ushort>(this, typeCode);
break;
default:
throw new InvalidDataException(string.Format("Unknown array type code {0}", typeCode));
}
result.TypeCode = typeCode;
return(result);
}
// create
public virtual EsfNode CreateValueNode(EsfType typeCode, bool optimize = true)
{
EsfNode result = null;
switch (typeCode)
{
case EsfType.BOOL:
result = new BoolNode();
break;
case EsfType.INT8:
result = new SByteNode();
break;
case EsfType.INT16:
result = new ShortNode();
break;
case EsfType.INT32:
result = new IntNode();
break;
case EsfType.INT64:
result = new LongNode();
break;
case EsfType.UINT8:
result = new ByteNode();
break;
case EsfType.UINT16:
result = new UShortNode();
break;
case EsfType.UINT32:
result = new UIntNode();
break;
case EsfType.UINT64:
result = new ULongNode();
break;
case EsfType.SINGLE:
result = new FloatNode();
break;
case EsfType.DOUBLE:
result = new DoubleNode();
break;
case EsfType.COORD2D:
result = new Coordinate2DNode();
break;
case EsfType.COORD3D:
result = new Coordinates3DNode();
break;
case EsfType.UTF16:
result = new StringNode(ReadUtf16, WriteUtf16);
break;
case EsfType.ASCII:
result = new StringNode(ReadAscii, WriteUtf16);
break;
case EsfType.ANGLE:
result = new UShortNode();
break;
default:
throw new InvalidDataException(string.Format("Invalid type code {0:x}", typeCode));
}
result.TypeCode = typeCode;
return(result);
}
protected void WriteArrayNode(BinaryWriter writer, EsfNode arrayNode)
{
(arrayNode as ICodecNode).Encode(writer);
}
private void ModifiedDelegate(EsfNode node)
{
Modified = node.Modified;
}
public virtual EsfNode CreateValueNode(EsfType typeCode, bool optimize = true)
{
EsfNode esfNode = null;
switch (typeCode)
{
case EsfType.BOOL:
esfNode = new BoolNode();
break;
case EsfType.INT8:
esfNode = new SByteNode();
break;
case EsfType.INT16:
esfNode = new ShortNode();
break;
case EsfType.INT32:
esfNode = new IntNode();
break;
case EsfType.INT64:
esfNode = new LongNode();
break;
case EsfType.UINT8:
esfNode = new ByteNode();
break;
case EsfType.UINT16:
esfNode = new UShortNode();
break;
case EsfType.UINT32:
esfNode = new UIntNode();
break;
case EsfType.UINT64:
esfNode = new ULongNode();
break;
case EsfType.SINGLE:
esfNode = new FloatNode();
break;
case EsfType.DOUBLE:
esfNode = new DoubleNode();
break;
case EsfType.COORD2D:
esfNode = new Coordinate2DNode();
break;
case EsfType.COORD3D:
esfNode = new Coordinates3DNode();
break;
case EsfType.UTF16:
esfNode = new StringNode(ReadUtf16, WriteUtf16);
break;
case EsfType.ASCII:
esfNode = new StringNode(ReadAscii, WriteAscii);
break;
case EsfType.ANGLE:
esfNode = new UShortNode();
break;
default:
esfNode = new BoolNode();
break;
}
esfNode.TypeCode = typeCode;
return(esfNode);
}
protected virtual void WriteRecordNode(BinaryWriter writer, EsfNode node)
{
(node as RecordNode).Encode(writer);
}
public static void LogReadNode(EsfNode node, long position)
{
Console.WriteLine("{1:x}: read {0}", node, position);
}
public EsfFile(EsfNode rootNode, EsfCodec codec)
{
Codec = codec;
RootNode = rootNode;
}
protected virtual EsfNode CreateArrayNode(EsfType typeCode)
{
EsfNode esfNode = null;
switch (typeCode)
{
case EsfType.BOOL_ARRAY:
esfNode = new EsfArrayNode <bool>(this, typeCode);
break;
case EsfType.INT8_ARRAY:
esfNode = new EsfArrayNode <sbyte>(this, typeCode);
break;
case EsfType.INT16_ARRAY:
esfNode = new EsfArrayNode <short>(this, typeCode);
break;
case EsfType.INT32_ARRAY:
esfNode = new EsfArrayNode <int>(this, typeCode);
break;
case EsfType.INT64_ARRAY:
esfNode = new EsfArrayNode <long>(this, typeCode);
break;
case EsfType.UINT8_ARRAY:
esfNode = new EsfArrayNode <byte>(this, typeCode);
break;
case EsfType.UINT16_ARRAY:
esfNode = new EsfArrayNode <ushort>(this, typeCode);
break;
case EsfType.UINT32_ARRAY:
esfNode = new EsfArrayNode <uint>(this, typeCode);
break;
case EsfType.UINT64_ARRAY:
esfNode = new EsfArrayNode <ulong>(this, typeCode);
break;
case EsfType.SINGLE_ARRAY:
esfNode = new EsfArrayNode <float>(this, typeCode);
break;
case EsfType.DOUBLE_ARRAY:
esfNode = new EsfArrayNode <double>(this, typeCode);
break;
case EsfType.COORD2D_ARRAY:
esfNode = new EsfArrayNode <Tuple <float, float> >(this, typeCode)
{
Separator = "-"
};
break;
case EsfType.COORD3D_ARRAY:
esfNode = new EsfArrayNode <Tuple <float, float> >(this, typeCode)
{
Separator = "-"
};
break;
case EsfType.UTF16_ARRAY:
esfNode = new EsfArrayNode <string>(this, EsfType.UTF16_ARRAY);
break;
case EsfType.ASCII_ARRAY:
esfNode = new EsfArrayNode <string>(this, EsfType.ASCII_ARRAY);
break;
case EsfType.ANGLE_ARRAY:
esfNode = new EsfArrayNode <ushort>(this, typeCode);
break;
default:
throw new InvalidDataException($"Unknown array type code {typeCode}");
}
esfNode.TypeCode = typeCode;
return(esfNode);
}
