// 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); }