Esempio n. 1
0
        /// <summary>
        /// Writes a magic header.
        /// </summary>
        public void WriteHeader()
        {
            using var sw = new BinaryWriter(_stream, Encoding.UTF8, leaveOpen: true);

            // Magic
            {
                sw.Write('B');
                sw.Write('D');
            }

            // QE version
            {
                var version = Versioning.v1;
                sw.Write(version.Major);
                sw.Write(version.Minor);
                sw.Write(version.Build);
                sw.Write(version.Revision);
            }

            // Flags
            {
                sw.Write(0);
            }

            // Serializer
            {
                var serializer = _policy.GetSerializer();

                sw.Write(serializer.Name);

                sw.Write(serializer.Version.Major);
                sw.Write(serializer.Version.Minor);
                sw.Write(serializer.Version.Build);
                sw.Write(serializer.Version.Revision);

                _serializer = serializer;
            }
        }
Esempio n. 2
0
        /// <summary>
        /// Reads and asserts the magic header.
        /// </summary>
        public void ReadHeader()
        {
            using var sr = new BinaryReader(_stream, Encoding.UTF8, leaveOpen: true);

            // Magic
            {
                var position = _stream.Position;

                try
                {
                    var b = sr.ReadChar();
                    var d = sr.ReadChar();

                    if (b != 'B' || d != 'D')
                    {
                        throw MissingHeader(position);
                    }
                }
                catch (EndOfStreamException)
                {
                    throw MissingHeader(position);
                }
            }

            // QE version
            {
                var position = _stream.Position;

                try
                {
                    var major    = sr.ReadInt32();
                    var minor    = sr.ReadInt32();
                    var build    = sr.ReadInt32();
                    var revision = sr.ReadInt32();

                    var version = new Version(major, minor, build, revision);
                    if (version < Versioning.v1)
                    {
                        throw UnsupportedVersion(position, version);
                    }
                }
                catch (EndOfStreamException)
                {
                    throw MissingVersion(position);
                }
            }

            // Flags
            {
                var position = _stream.Position;

                try
                {
                    var flags = sr.ReadInt32();
                }
                catch (EndOfStreamException)
                {
                    throw MissingFlags(position);
                }
            }

            // Serializer
            {
                var position = _stream.Position;

                try
                {
                    var serName = sr.ReadString();

                    var serMajor    = sr.ReadInt32();
                    var serMinor    = sr.ReadInt32();
                    var serBuild    = sr.ReadInt32();
                    var serRevision = sr.ReadInt32();
                    var serVersion  = new Version(serMajor, serMinor, serBuild, serRevision);

                    _serializer = _policy.GetSerializer(serName, serVersion);
                }
                catch (EndOfStreamException)
                {
                    throw MissingSerializer(position);
                }
            }
        }