Exemple #1
0
        public OperationStatus ReadFrom(
            ReadOnlySpan <byte> span,
            out CopyCommand copy)
        {
            if (span.Length < _minSize)
            {
                copy = default;
                return(OperationStatus.NeedMoreData);
            }
            byte       command    = span[0];
            const byte minCommand = _baseCommand +
                                    4 * (byte)CommandModifier.OneByte +
                                    (byte)CommandModifier.OneByte;
            const byte maxCommand = _baseCommand +
                                    4 * (byte)CommandModifier.EightBytes +
                                    (byte)CommandModifier.EightBytes;

            if (command < minCommand || command > maxCommand)
            {
                copy = default;
                return(OperationStatus.InvalidData);
            }
            command -= _baseCommand;

            var startModifier = (CommandModifier)(command >> 2);
            var opStatus      = CommandArg.ReadFrom(
                span.Slice(1),
                startModifier,
                out var startArg);

            if (opStatus != OperationStatus.Done)
            {
                copy = default;
                return(opStatus);
            }

            var lengthModifier = (CommandModifier)(command & 0x03);

            opStatus = CommandArg.ReadFrom(
                span.Slice(1 + startArg.Size),
                lengthModifier,
                out var lengthArg);
            if (opStatus != OperationStatus.Done)
            {
                copy = default;
                return(opStatus);
            }

            copy = new CopyCommand(startArg, lengthArg);
            return(OperationStatus.Done);
        }
Exemple #2
0
        public OperationStatus ReadFrom(
            ReadOnlySpan <byte> span,
            out LiteralCommand literal)
        {
            if (span.Length < _minSize)
            {
                literal = default;
                return(OperationStatus.NeedMoreData);
            }
            byte       command    = span[0];
            const byte maxCommand = _baseCommand + (byte)CommandModifier.EightBytes;

            if (command == 0 || command > maxCommand)
            {
                literal = default;
                return(OperationStatus.InvalidData);
            }
            else if (command < _baseCommand)
            {
                literal = new LiteralCommand(length: command);
                return(OperationStatus.Done);
            }

            var argModifier = (CommandModifier)(command - _baseCommand);
            var opStatus    = CommandArg.ReadFrom(
                span.Slice(1),
                argModifier,
                out var arg);

            if (opStatus != OperationStatus.Done)
            {
                literal = default;
                return(opStatus);
            }
            literal = new LiteralCommand(arg);
            return(OperationStatus.Done);
        }