コード例 #1
0
        /// <inheritdoc />
        public override CtfFieldValue Read(IPacketReader reader, CtfFieldValue parent = null)
        {
            Guard.NotNull(reader, nameof(reader));

            // todo:handle dynamic scoped tags

            if (parent == null)
            {
                throw new CtfPlaybackException("No parent specified for variant. Unable to find variant tag for reading.");
            }

            var tagFieldValue = parent.FindField(this.Switch);

            if (tagFieldValue == null)
            {
                throw new CtfPlaybackException($"Unable to find variant tag for reading: {this.Switch}.");
            }

            if (!(tagFieldValue is CtfEnumValue tagEnum))
            {
                throw new CtfPlaybackException($"The tag field is not an enumeration value: {this.Switch}.");
            }

            var variantTypeToRead = GetVariant(tagEnum.Value);

            if (variantTypeToRead == null)
            {
                throw new CtfPlaybackException($"The enumeration value did not match a field in the variant: {tagEnum.Value}.");
            }

            var variantValue = variantTypeToRead.Read(reader, parent);

            return(new CtfVariantValue(variantValue, tagEnum.Value, tagEnum));
        }
        /// <inheritdoc />
        public override CtfFieldValue Read(IPacketReader reader, CtfFieldValue parent = null)
        {
            Guard.NotNull(reader, nameof(reader));

            // this will align to the underlying type when we do a Type.read

            List <CtfFieldValue> values = new List <CtfFieldValue>();

            try
            {
                IntegerLiteral integerValue;
                if (IntegerLiteralString.TryCreate(this.Index, out var integerStringIndex))
                {
                    integerValue = new IntegerLiteral(integerStringIndex);
                }
                else
                {
                    Debug.Assert(parent != null);
                    if (parent == null)
                    {
                        return(null);
                    }

                    var indexField = parent.FindField(this.Index);
                    if (!(indexField is CtfIntegerValue indexValue))
                    {
                        Debug.Assert(false, "is this a valid value?");
                        return(null);
                    }

                    integerValue = indexValue.Value;
                }

                if (integerValue.Signed)
                {
                    if (integerValue.ValueAsLong < 0)
                    {
                        // we shouldn't hit this, it should be caught before now
                        throw new CtfPlaybackException("Negative array indexing is not supported.");
                    }

                    for (long x = 0; x < integerValue.ValueAsLong; x++)
                    {
                        values.Add(this.Type.Read(reader));
                    }

                    return(new CtfArrayValue(values.ToArray()));
                }

                for (ulong x = 0; x < integerValue.ValueAsUlong; x++)
                {
                    values.Add(this.Type.Read(reader));
                }

                return(new CtfArrayValue(values.ToArray()));
            }
            catch (ArgumentException)
            {
                Debug.Assert(false, "What did I miss?");
                return(null);
            }
        }