public DependencyInfo GetDependencyInfo(Stream stream, Mesh mesh) { BinaryMemoryReader reader = new BinaryMemoryReader(stream); // read the header ID ushort headerID = ReadUShort(reader); if (headerID != (ushort)MeshChunkID.Header) { throw new AxiomException("File header not found."); } // read version string fileVersion = ReadString(reader); // set jump back to the start of the reader Seek(reader, 0, SeekOrigin.Begin); // barf if there specified version is not supported if (!implementations.ContainsKey(fileVersion)) { throw new AxiomException("Cannot find serializer implementation for version '{0}'.", fileVersion); } LogManager.Instance.Write("Mesh: Fetching dependency info '{0}'...", mesh.Name); // call implementation MeshSerializerImpl serializer = (MeshSerializerImpl)implementations[fileVersion]; DependencyInfo rv = serializer.GetDependencyInfo(stream, mesh); // warn on old version of mesh if (fileVersion != currentVersion) { LogManager.Instance.Write("WARNING: {0} is an older format ({1}); you should upgrade it as soon as possible using the OgreMeshUpdate tool.", mesh.Name, fileVersion); } return rv; }
/// <summary> /// Reads a specified number of floats and copies them into the destination pointer. /// </summary> /// <param name="count">Number of values to read.</param> /// <param name="dest">Pointer to copy the values into.</param> protected void ReadBytes(BinaryMemoryReader reader, int count, IntPtr dest) { // blast the data into the buffer unsafe { byte* pointer = (byte*)dest.ToPointer(); for(int i = 0; i < count; i++) { pointer[i] = reader.ReadByte(); } } }
public void ImportSkeleton(Stream stream, Skeleton skeleton) { // store a local reference to the mesh for modification this.skeleton = skeleton; BinaryMemoryReader reader = new BinaryMemoryReader(stream, System.Text.Encoding.ASCII); // start off by taking a look at the header ReadFileHeader(reader); SkeletonChunkID chunkID = 0; while (!IsEOF(reader)) { chunkID = ReadChunk(reader); switch (chunkID) { case SkeletonChunkID.Bone: ReadBone(reader); break; case SkeletonChunkID.BoneParent: ReadBoneParent(reader); break; case SkeletonChunkID.Animation: ReadAnimation(reader); break; case SkeletonChunkID.AttachmentPoint: ReadAttachmentPoint(reader); break; default: log.Warn("Can only parse bones, parents, and animations at the top level during skeleton loading."); log.Warn("Unexpected chunk: " + chunkID.ToString()); break; } // switch } // while // assume bones are stored in binding pose skeleton.SetBindingPose(); }
public DependencyInfo GetDependencyInfo(Stream stream, Mesh mesh) { BinaryMemoryReader reader = new BinaryMemoryReader(stream, System.Text.Encoding.ASCII); // check header ReadFileHeader(reader); MeshChunkID chunkID = 0; // read until the end while (!IsEOF(reader)) { chunkID = ReadChunk(reader); if (chunkID == MeshChunkID.DependencyInfo) { DependencyInfo info = new DependencyInfo(); ReadDependencyInfo(reader, info); return info; } else { break; } } return null; }
public unsafe void BytesRead() { Random rng = new Random(); byte[] src = new byte[1024]; byte[] chk = new byte[1024]; rng.NextBytes(src); byte[] data; using (MemoryStream ms = new MemoryStream()) { using (BinaryWriter writer = new BinaryWriter(ms)) for (int count = 0; count < 256; count++) { writer.Write(src); } data = ms.ToArray(); } fixed(byte *pData = data) { BinaryMemoryReader reader = new BinaryMemoryReader(pData, data.Length); for (int count = 0; count < 256; count++) { reader.ReadBytes(chk, 0, 1024); for (int position = 0; position < 1024; position++) { Assert.AreEqual(chk[position], src[position], $"Invalid content at position {position}."); } } } }
public unsafe void ULongLimits() { byte[] data; using (MemoryStream ms = new MemoryStream()) { using (BinaryWriter writer = new BinaryWriter(ms)) writer.Write(0x5555555555555555UL); data = ms.ToArray(); } fixed(byte *pData = data) { BinaryMemoryReader reader = new BinaryMemoryReader(pData, data.Length); try { reader.ReadUInt64(); } catch { Assert.Fail("Should not have thrown an Exception."); } BinaryMemoryWriter writer = new BinaryMemoryWriter(pData, data.Length); try { writer.Write(0x5555555555555555UL); } catch { Assert.Fail("Should not have thrown an Exception."); } } }
protected ushort ReadUShort(BinaryMemoryReader reader) { return reader.ReadUInt16(); }
protected uint ReadUInt(BinaryMemoryReader reader) { return reader.ReadUInt32(); }
/// <summary> /// Reads from the stream up to the first endline character. /// </summary> /// <returns>A string formed from characters up to the first '\n' character.</returns> protected string ReadString(BinaryMemoryReader reader) { // note: Not using Environment.NewLine here, this character is specifically used in Ogre files. return ReadString(reader, '\n'); }
protected short ReadShort(BinaryMemoryReader reader) { return reader.ReadInt16(); }
protected long ReadLong(BinaryMemoryReader reader) { return reader.ReadInt64(); }
protected float ReadFloat(BinaryMemoryReader reader) { return reader.ReadSingle(); }
protected bool ReadBool(BinaryMemoryReader reader) { return reader.ReadBoolean(); }
protected virtual void ReadPoses(BinaryMemoryReader reader) { if (!IsEOF(reader)) { MeshChunkID chunkID = ReadChunk(reader); while (!IsEOF(reader) && chunkID == MeshChunkID.Pose) { string name = ReadString(reader); ushort target = ReadUShort(reader); Pose pose = mesh.CreatePose(target, name); while (!IsEOF(reader) && (chunkID = ReadChunk(reader)) == MeshChunkID.PoseVertex) { int vertexIndex = ReadInt(reader); Vector3 offset = ReadVector3(reader); pose.VertexOffsetMap[vertexIndex] = offset; } } // grab the next chunk if (!IsEOF(reader)) { // backpedal to the start of chunk Seek(reader, -ChunkOverheadSize); } } }
protected void ReadPoseKeyframe(BinaryMemoryReader reader, VertexAnimationTrack track) { float time = ReadFloat(reader); VertexPoseKeyFrame vkf = track.CreateVertexPoseKeyFrame(time); if (!IsEOF(reader)) { MeshChunkID chunkID = ReadChunk(reader); while (!IsEOF(reader) && chunkID == MeshChunkID.AnimationPoseRef) { switch (chunkID) { case MeshChunkID.AnimationPoseRef: { ushort poseIndex = ReadUShort(reader); float influence = ReadFloat(reader); vkf.AddPoseReference(poseIndex, influence); break; } } if (!IsEOF(reader)) chunkID = ReadChunk(reader); } if (!IsEOF(reader)) { // backpedal to the start of chunk Seek(reader, -ChunkOverheadSize); } } }
protected void ReadMorphKeyframe(BinaryMemoryReader reader, VertexAnimationTrack track) { float time = ReadFloat(reader); VertexMorphKeyFrame mkf = track.CreateVertexMorphKeyFrame(time); int vertexCount = track.TargetVertexData.vertexCount; // create/populate vertex buffer HardwareVertexBuffer buffer = HardwareBufferManager.Instance.CreateVertexBuffer( VertexElement.GetTypeSize(VertexElementType.Float3), vertexCount, BufferUsage.Static, true); // lock the buffer for editing IntPtr vertices = buffer.Lock(BufferLocking.Discard); // stuff the floats into the normal buffer ReadFloats(reader, vertexCount * 3, vertices); // unlock the buffer to commit buffer.Unlock(); mkf.VertexBuffer = buffer; }
protected virtual void ReadMeshLodUsageManual(BinaryMemoryReader reader, int lodNum, ref MeshLodUsage usage) { MeshChunkID chunkId = ReadChunk(reader); if(chunkId != MeshChunkID.MeshLODManual) { throw new AxiomException("Missing MeshLODManual chunk in '{0}'.", mesh.Name); } usage.manualName = ReadString(reader); // clearing the reference just in case usage.manualMesh = null; }
protected void Seek(BinaryMemoryReader reader, long length) { Seek(reader, length, SeekOrigin.Current); }
/// <summary> /// Skips past a particular chunk. /// </summary> /// <remarks> /// Only really used during development, when logic for handling particular chunks is not yet complete. /// </remarks> protected void IgnoreCurrentChunk(BinaryMemoryReader reader) { Seek(reader, currentChunkLength - ChunkOverheadSize); }
protected void ReadSkeletonDependency(BinaryMemoryReader reader, DependencyInfo depends) { int count = reader.ReadInt16(); for (int i = 0; i < count; ++i) { string name = reader.ReadString(); depends.skeletons.Add(name); } }
public unsafe void CompressedTimeSpanRead() { int required = 0; List <long> timeLongs = new List <long>() { //Limits 1 Byte -> 3 Byte 0, 1, -1, 0x1F, -0x1F, 0x20, -0x20, 0xFF_FF, -0xFF_FF, 0x01_00_00, -0x01_00_00, //Limits 3 Byte -> 5 Byte 0x1F_FF_FF, -0x1F_FF_FF, 0x20_00_00, -0x20_00_00, 0x01_00_00_00, -0x01_00_00_00, 0xFF_FF_FF_FF, -0xFF_FF_FF_FF, 0x01_00_00_00_00, -0x01_00_00_00_00, 0x01_01_00_00_00, -0x01_01_00_00_00, 0x01_00_01_00_00, -0x01_00_01_00_00, 0x01_00_00_01_00, -0x01_00_00_01_00, 0x01_00_00_00_01, -0x01_00_00_00_01, //Limits 5 Byte -> 8 Byte 0x1F_FF_FF_FF_FF, -0x1F_FF_FF_FF_FF, 0x20_00_00_00_00, -0x20_00_00_00_00, 0x01_00_00_00_00, -0x01_00_00_00_00, 0xFF_FF_FF_FF_FF, -0xFF_FF_FF_FF_FF, 0xFF_00_FF_FF_FF, -0xFF_00_FF_FF_FF, 0xFF_FF_00_FF_FF, -0xFF_FF_00_FF_FF, 0xFF_FF_FF_00_FF, -0xFF_FF_FF_00_FF, 0xFF_FF_FF_FF_00, -0xFF_FF_FF_FF_00, 0x01_00_00_00_00_00, -0x01_00_00_00_00_00, 0x01_00_00_01_00_00, -0x01_00_00_01_00_00, 0x01_00_00_00_01_00, -0x01_00_00_00_01_00, 0x01_00_00_00_00_01, -0x01_00_00_00_00_01, 0xFF_FF_FF_FF_FF_FF, -0xFF_FF_FF_FF_FF_FF, 0x01_00_00_00_00_00_00, -0x01_00_00_00_00_00_00, 0x01_00_00_00_00_01_00, -0x01_00_00_00_00_01_00, 0x01_00_00_00_00_00_01, -0x01_00_00_00_00_00_01, 0xFF_FF_FF_FF_FF_FF_FF, -0xFF_FF_FF_FF_FF_FF_FF, 0x01_00_00_00_00_00_00_00, -0x01_00_00_00_00_00_00_00, 0x01_00_00_00_00_00_01_00, -0x01_00_00_00_00_00_01_00, 0x01_00_00_00_00_00_00_01, -0x01_00_00_00_00_00_00_01, //Limits -> 8 Byte 0x1F_FF_FF_FF_FF_FF_FF_FF, -0x1F_FF_FF_FF_FF_FF_FF_FF }; foreach (long timeLong in timeLongs) { long checkLong = timeLong; if (checkLong < 0) { checkLong = -checkLong; } if (checkLong >= 137438953472) { required += 8; } else if (checkLong >= 2097152) { required += 5; } else if (checkLong >= 32) { required += 3; } else { required += 1; } } byte[] data = new byte[required]; List <TimeSpan> timeSpans = new List <TimeSpan>(); foreach (long timeLong in timeLongs) timeSpans.Add(new TimeSpan(timeLong)); fixed(byte *pData = data) { BinaryMemoryWriter writer = new BinaryMemoryWriter(pData, data.Length); foreach (TimeSpan timeSpan in timeSpans) { writer.WriteCompressed(timeSpan); } } fixed(byte *pData = data) { BinaryMemoryReader reader = new BinaryMemoryReader(pData, data.Length); foreach (TimeSpan timeSpan in timeSpans) { Assert.AreEqual(timeSpan, reader.ReadCompressedTimeSpan(), "BinaryMemoryReader TimeSpan Compressed incompatible to BinaryMemoryWriter."); } } }
protected virtual void ReadSkeletonLink(BinaryMemoryReader reader) { mesh.SkeletonName = ReadString(reader); }
/// <summary> /// Reads a specified number of floats and copies them into the destination pointer. /// </summary> /// <remarks>This overload will also copy the values into the specified destination array.</remarks> /// <param name="count">Number of values to read.</param> /// <param name="dest">Pointer to copy the values into.</param> /// <param name="destArray">A float array that is to have the values copied into it at the same time as 'dest'.</param> protected void ReadFloats(BinaryMemoryReader reader, int count, IntPtr dest, float[] destArray) { // blast the data into the buffer unsafe { float* pointer = (float*)dest.ToPointer(); for(int i = 0; i < count; i++) { float val = reader.ReadSingle(); pointer[i] = val; destArray[i] = val; } } }
protected virtual void ReadSubMesh(BinaryMemoryReader reader) { MeshChunkID chunkID; SubMesh subMesh = mesh.CreateSubMesh(); // get the material name string materialName = ReadString(reader); subMesh.MaterialName = materialName; // use shared vertices? subMesh.useSharedVertices = ReadBool(reader); subMesh.indexData.indexStart = 0; subMesh.indexData.indexCount = ReadInt(reader); // does this use 32 bit index buffer bool idx32bit = ReadBool(reader); HardwareIndexBuffer idxBuffer = null; if(idx32bit) { // create the index buffer idxBuffer = HardwareBufferManager.Instance. CreateIndexBuffer( IndexType.Size32, subMesh.indexData.indexCount, mesh.IndexBufferUsage, mesh.UseIndexShadowBuffer); IntPtr indices = idxBuffer.Lock(BufferLocking.Discard); // read the ints into the buffer data ReadInts(reader, subMesh.indexData.indexCount, indices); // unlock the buffer to commit idxBuffer.Unlock(); } else { // 16-bit // create the index buffer idxBuffer = HardwareBufferManager.Instance. CreateIndexBuffer( IndexType.Size16, subMesh.indexData.indexCount, mesh.IndexBufferUsage, mesh.UseIndexShadowBuffer); IntPtr indices = idxBuffer.Lock(BufferLocking.Discard); // read the shorts into the buffer data ReadShorts(reader, subMesh.indexData.indexCount, indices); idxBuffer.Unlock(); } // save the index buffer subMesh.indexData.indexBuffer = idxBuffer; // Geometry chunk (optional, only present if useSharedVertices = false) if(!subMesh.useSharedVertices) { chunkID = ReadChunk(reader); if(chunkID != MeshChunkID.Geometry) { throw new AxiomException("Missing geometry data in mesh file."); } subMesh.vertexData = new VertexData(); // read the geometry data ReadGeometry(reader, subMesh.vertexData); } // get the next chunkID chunkID = ReadChunk(reader); // walk through all the bone assignments for this submesh while(!IsEOF(reader) && (chunkID == MeshChunkID.SubMeshBoneAssignment || chunkID == MeshChunkID.SubMeshOperation)) { switch(chunkID) { case MeshChunkID.SubMeshBoneAssignment: ReadSubMeshBoneAssignment(reader, subMesh); break; case MeshChunkID.SubMeshOperation: ReadSubMeshOperation(reader, subMesh); break; } // read the next chunkID if(!IsEOF(reader)) { chunkID = ReadChunk(reader); } } // while // walk back to the beginning of the last chunk ID read since // we already moved past it and it wasnt of interest to us if(!IsEOF(reader)) { Seek(reader, -ChunkOverheadSize); } // Create the bounding box for the submesh CreateSubMeshBoundingBox(subMesh); }
/// <summary> /// Reads and returns a Quaternion. /// </summary> /// <returns></returns> protected Quaternion ReadQuat(BinaryMemoryReader reader) { Quaternion quat = new Quaternion(); quat.x = reader.ReadSingle(); quat.y = reader.ReadSingle(); quat.z = reader.ReadSingle(); quat.w = reader.ReadSingle(); return quat; }
internal SunCorona(byte plasma, ref BinaryMemoryReader reader) { Plasma = (Plasma)plasma; Amount = reader.ReadSingle(); Radius = reader.ReadSingle(); }
/// <summary> /// Reads a specified number of shorts and copies them into the destination pointer. /// </summary> /// <param name="count">Number of values to read.</param> /// <param name="dest">Pointer to copy the values into.</param> protected void ReadShorts(BinaryMemoryReader reader, int count, IntPtr dest) { // blast the data into the buffer unsafe { short* pointer = (short*)dest.ToPointer(); for (int i = 0; i < count; i++) { pointer[i] = reader.ReadInt16(); } } }
internal Vector(ref BinaryMemoryReader reader) { x = reader.ReadSingle(); y = reader.ReadSingle(); }
/// <summary> /// Reads from the stream up to the specified delimiter character. /// </summary> /// <param name="delimiter">The character that signals the end of the string.</param> /// <returns>A string formed from characters up to the first instance of the specified delimeter.</returns> protected string ReadString(BinaryMemoryReader reader, char delimiter) { StringBuilder sb = new StringBuilder(); char c; // sift through each character until we hit the delimiter while((c = reader.ReadChar()) != delimiter) { sb.Append(c); } // return the accumulated string return sb.ToString(); }
internal Shot(Universe universe, Galaxy galaxy, ref BinaryMemoryReader reader) : base(universe, galaxy, ref reader) { Ammunition = (FlattiverseResourceKind)reader.ReadByte(); }
protected ulong ReadULong(BinaryMemoryReader reader) { return reader.ReadUInt64(); }
internal Meteoroid(Universe universe, Galaxy galaxy, ref BinaryMemoryReader reader) : base(universe, galaxy, ref reader) { }
/// <summary> /// Reads and returns a Vector4 structure. /// </summary> /// <returns></returns> protected Vector4 ReadVector4(BinaryMemoryReader reader) { Vector4 vector = new Vector4(); vector.x = ReadFloat(reader); vector.y = ReadFloat(reader); vector.z = ReadFloat(reader); vector.w = ReadFloat(reader); return vector; }
internal void Answer(Packet packet) { if (packet.Command == 0xFF) { Exception exception; switch (packet.Helper) { case 0x01: exception = new UniverseServerUnhandledException(); break; case 0x02: exception = new InvalidParameterException(); break; case 0x03: exception = new AccountDoesntExistException(); break; case 0x04: exception = new OperationRequiresAdminStatusException(); break; case 0x05: exception = new PermissionDeniedException(packet.SubAddress); break; case 0x06: exception = new IllegalNameException(); break; case 0x07: exception = new UnitDoesntExistException(); break; case 0x08: exception = new NoUniverseAssignmentException(); break; case 0x09: exception = new WrongStateException(); break; case 0x0A: exception = new TooManyEntriesException(); break; case 0x10: exception = new JoinRefusedException(packet.SubAddress); break; case 0x11: exception = new PartException(packet.SubAddress); break; case 0x20: exception = new UniverseDoesntExistException(); break; case 0x21: exception = new UniverseOfflineException(); break; case 0x22: exception = new UniverseGoneWhileExecutingRequestException(); break; case 0x23: exception = new NoUniverseAvailableException(); break; case 0x24: exception = new GalaxyDoesntExistException(); break; case 0x60: exception = new NonEditableUnitException(); break; case 0x61: exception = new AmbiguousXmlDataException(); break; case 0xFB: { BinaryMemoryReader tmpReader = packet.Read(); string message = tmpReader.ReadString(); string parameter = tmpReader.ReadString(); exception = new ArgumentException(message, parameter); } break; case 0xFC: { BinaryMemoryReader tmpReader = packet.Read(); string message = tmpReader.ReadString(); string parameter = tmpReader.ReadString(); exception = new ArgumentNullException(parameter, message); } break; case 0xFD: { string message = packet.Read().ReadString(); exception = new InvalidOperationException(message); } break; case 0xFE: exception = new Exception("This exception will be replaced with an generic exception."); break; case 0xFF: BinaryMemoryReader reader = packet.Read(); exception = new InvalidProgramException($"!!! INVALID EXCEPTION COUGHT BY SERVER !!!\n\nThe server has cought a \"{reader.ReadString()}\" and did just forward this to the client (you). The exception has the following message:\n\n{reader.ReadString()}\n\nAnd the following stack trace:\n\n{reader.ReadString()}\n\nIf you are in the C# course of the HS-Esslingen: Contact your teacher."); break; default: exception = new Exception($"Unknown Exception Code: 0x{packet.Helper.ToString()}."); break; } ThreadPool.QueueUserWorkItem(delegate { tcs.SetException(exception); }); return; } ThreadPool.QueueUserWorkItem(delegate { tcs.SetResult(packet); }); }
/// <summary> /// Skips to a particular part of the binary stream. /// </summary> /// <param name="length">Number of bytes to skip.</param> protected void Seek(BinaryMemoryReader reader, long length, SeekOrigin origin) { reader.Seek(length, origin); }
/// <summary> /// Reads a chunk ID and chunk size. /// </summary> /// <returns>The chunk ID at the current location.</returns> protected short ReadFileChunk(BinaryMemoryReader reader) { // get the chunk id short id = reader.ReadInt16(); // read the length for this chunk currentChunkLength = reader.ReadInt32(); return id; }
protected bool IsEOF(BinaryMemoryReader reader) { return reader.PeekChar() == -1; }
internal Buoy(Universe universe, Galaxy galaxy, ref BinaryMemoryReader reader) : base(universe, galaxy, ref reader) { Message = reader.ReadString(); }
private unsafe void received(object socketObject, SocketAsyncEventArgs eventArgs) { Socket socket = (Socket)socketObject; try { do { if (eventArgs.SocketError != SocketError.Success || eventArgs.BytesTransferred == 0) { lock (sync) { closed = true; try { Disconnected?.Invoke(); } catch { } eventArgs.Dispose(); socket.Close(); foreach (Session session in sessions) { session.Disconnected(); } return; } } recvBufferPosition += eventArgs.BytesTransferred; if (recvBufferPosition > 15) { int useableData = recvBufferPosition - (recvBufferPosition % 16); if (recvPlainPosition + useableData > 262144) { useableData = (262144 - recvPlainPosition) - ((262144 - recvPlainPosition) % 16); } recvAES.TransformBlock(recvBuffer, 0, useableData, recvPlain, recvPlainPosition); recvPlainPosition += useableData; if (useableData == recvBufferPosition) { recvBufferPosition = 0; } else { Buffer.BlockCopy(recvBuffer, useableData, recvBuffer, 0, recvBufferPosition - useableData); recvBufferPosition -= useableData; } List <Packet> packets = new List <Packet>(); Packet packet = new Packet(); fixed(byte *bRecvPlain = recvPlain) { BinaryMemoryReader reader = new BinaryMemoryReader(bRecvPlain, recvPlainPosition); while (packet.Parse(ref reader)) { if (packet.OutOfBand == 0) { packets.Add(packet); } packet = new Packet(); } if (Received != null && packets.Count > 0) { Received(packets); } if (reader.Position - bRecvPlain == recvPlainPosition) { recvPlainPosition = 0; } else { Buffer.BlockCopy(recvPlain, (int)(reader.Position - bRecvPlain), recvPlain, 0, recvPlainPosition - (int)(reader.Position - bRecvPlain)); recvPlainPosition -= (int)(reader.Position - bRecvPlain); } } } eventArgs.SetBuffer(recvBufferPosition, 262144 - recvBufferPosition); }while (!socket.ReceiveAsync(eventArgs)); } catch { lock (sync) if (!closed) { closed = true; try { Disconnected?.Invoke(); } catch { } eventArgs.Dispose(); socket.Close(); foreach (Session session in sessions) { session.Disconnected(); } } } }
internal SteadyUnit(Universe universe, Galaxy galaxy, ref BinaryMemoryReader reader) : base(universe, galaxy, ref reader) { }
internal CommodityUnit(Universe universe, Galaxy galaxy, ref BinaryMemoryReader reader) : base(universe, galaxy, ref reader) { Resource = (FlattiverseResource)reader.ReadByte(); }
/// <summary> /// Reads a file header and checks the version string. /// </summary> protected void ReadFileHeader(BinaryMemoryReader reader) { short headerID = 0; // read the header ID headerID = reader.ReadInt16(); // better hope this is the header if(headerID == (short)MeshChunkID.Header) { string fileVersion = ReadString(reader); // read the version string if(version != fileVersion) { throw new AxiomException("Invalid file: version incompatible, file reports {0}, Serializer is version {1}", fileVersion, version); } } else { throw new AxiomException("Invalid file: no header found."); } }