public void Flush()
        {
            var positionLookup = new Dictionary <object, long>();

            while (mCmdQueue.Count > 0)
            {
                var cmd = mCmdQueue.Dequeue();
                if (cmd.Instance == null || !positionLookup.TryGetValue(cmd.Instance, out var pos))
                {
                    pos = AlignmentHelper.Align(Position, cmd.Alignment > 0 ? cmd.Alignment : DefaultAlignment);
                    if (cmd.Instance != null)
                    {
                        positionLookup[cmd.Instance] = pos;
                    }

                    mBaseStream.Seek(pos, SeekOrigin.Begin);
                    cmd.Writer(this, cmd.Value);

                    if (cmd.PopulateInfo)
                    {
                        ((( IBinarySourceInfo )cmd.Instance)).BinarySourceInfo =
                            new BinarySourceInfo(FilePath, pos, Position, ( int )(Position - pos), Endianness);
                    }
                }

                var prevPos = Position;
                mBaseStream.Seek(cmd.Position, SeekOrigin.Begin);
                OffsetHandler.RegisterOffsetPosition(cmd.Position);
                WriteOffsetValue(OffsetHandler.CalculateOffset(pos, cmd.OffsetOrigin));
                mBaseStream.Seek(prevPos, SeekOrigin.Begin);
            }
        }
        public T ReadObjectAtOffset <T>(long offset)
            where T : IBinarySerializable, new()
        {
            T value = default;

            var target = OffsetHandler.ResolveOffset(offset);

            if (target != -1)
            {
                if (!mObjectCache.TryGetValue(target, out var cachedValue))
                {
                    mObjectCache[target] = value = new T();
                    var positionSave = Position;
                    Seek(target, SeekOrigin.Begin);
                    ReadObject(value);
                    Seek(positionSave, SeekOrigin.Begin);
                }
                else
                {
                    value = ( T )cachedValue;
                }
            }

            return(value);
        }
        public SeekToken AtOffset(long offset)
        {
            var target = OffsetHandler.ResolveOffset(offset);

            if (target != -1)
            {
                return(new SeekToken(mBaseStream, target, SeekOrigin.Begin));
            }

            throw new InvalidOperationException("Offset is not valid");
        }
        public void ReadAtOffset(long offset, Action action)
        {
            var target = OffsetHandler.ResolveOffset(offset);

            if (target != -1)
            {
                var positionSave = Position;
                Seek(target, SeekOrigin.Begin);
                action();
                Seek(positionSave, SeekOrigin.Begin);
            }
        }
        public T[] ReadArrayAtOffset <T>(long offset, int count) where T : unmanaged
        {
            T[] value = default;

            var target = OffsetHandler.ResolveOffset(offset);

            if (target != -1)
            {
                if (!mObjectCache.TryGetValue(target, out var cachedValue))
                {
                    var positionSave = Position;
                    Seek(target, SeekOrigin.Begin);
                    value = ReadArray <T>(count);
                    Seek(positionSave, SeekOrigin.Begin);
                    mObjectCache[target] = value;
                }
                else
                {
                    value = ( T[] )cachedValue;
                }
            }

            return(value);
        }
Exemplo n.º 6
0
 // Things to run when form has loaded and displayed
 private void Form1_Shown(Object sender, EventArgs e)
 {
     // Download offsets right when user launches program
     OffsetHandler.getOffsets();
 }