/// <inheritdoc />
public override CtfFieldValue Read(IPacketReader reader, CtfFieldValue parent = null)
{
Guard.NotNull(reader, nameof(reader));
reader.Align((uint)this.Align);
var structValue = new CtfStructValue();
foreach (var ctfField in this.Fields)
{
CtfFieldValue field = null;
try
{
field = ctfField.Read(reader, structValue);
}
catch (InvalidOperationException)
{
continue;
}
bool addedField = structValue.AddValue(field);
Debug.Assert(addedField);
}
return(structValue);
}
/// <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));
var valueAsIntegerValue = this.BaseType.Read(reader, parent);
if (valueAsIntegerValue == null)
{
// todo:we need some sort of error reporting
return(null);
}
if (!(valueAsIntegerValue is CtfIntegerValue integerValue))
{
return(null);
}
string enumValue;
if (integerValue.Value.Signed)
{
enumValue = this.GetName(integerValue.Value.ValueAsLong);
}
else
{
enumValue = this.GetName(integerValue.Value.ValueAsUlong);
}
return(new CtfEnumValue(enumValue, integerValue.Value));
}
/// <inheritdoc />
public CtfFieldValue Read(IPacketReader reader, CtfFieldValue parent = null)
{
Guard.NotNull(reader, nameof(reader));
var fieldValue = this.TypeDescriptor.Read(reader, parent);
fieldValue.FieldName = this.Name;
return(fieldValue);
}
/// <inheritdoc />
public override CtfFieldValue Read(IPacketReader reader, CtfFieldValue parent = null)
{
Guard.NotNull(reader, nameof(reader));
reader.Align((uint)this.Align);
byte[] value = reader.ReadString();
if (this.Encoding == EncodingTypes.Ascii)
{
return(new CtfStringValue(System.Text.Encoding.ASCII.GetString(value, 0, value.Length - 1)));
}
return(new CtfStringValue(System.Text.Encoding.UTF8.GetString(value, 0, value.Length - 1)));
}
/// <inheritdoc />
public override CtfFieldValue Read(IPacketReader reader, CtfFieldValue parent = null)
{
Guard.NotNull(reader, nameof(reader));
reader.Align((uint)this.Align);
byte[] buffer = reader.ReadBits((uint)this.Size);
if (buffer == null)
{
throw new CtfPlaybackException("IPacketReader.ReadBits returned null while reading an integer value.");
}
int byteCount = buffer.Length;
return(this.Read(buffer, byteCount));
}
/// <inheritdoc />
public ulong GetPacketContentBitCount(ICtfPacket ctfPacket)
{
CtfFieldValue streamPacketContext = ctfPacket.StreamPacketContext;
if (streamPacketContext == null)
{
throw new LTTngPlaybackException("The stream.packet.context field is not set.");
}
if (!(streamPacketContext is CtfStructValue packetContext))
{
throw new LTTngPlaybackException("The stream.packet.context is not a structure.");
}
if (!packetContext.FieldsByName.ContainsKey("content_size"))
{
throw new LTTngPlaybackException(
"Field packet_size was not found in the stream.packet.context structure.");
}
var fieldValue = packetContext.FieldsByName["content_size"];
if (!(fieldValue is CtfIntegerValue contentSize))
{
throw new LTTngPlaybackException(
"Field content_size was is not an integer value.");
}
if (!contentSize.Value.TryGetUInt64(out var bitCount))
{
throw new LTTngPlaybackException(
"Field content_size is not a valid ulong value.");
}
return(bitCount);
}
/// <inheritdoc />
public override CtfFieldValue Read(IPacketReader reader, CtfFieldValue parent = null)
{
Guard.NotNull(reader, nameof(reader));
reader.Align((uint)this.Align);
byte[] buffer = null;
if ((Exponent + Mantissa) == 32)
{
buffer = reader.ReadBits(32);
}
else if ((Exponent + Mantissa) == 64)
{
buffer = reader.ReadBits(64);
}
if (buffer == null)
{
throw new CtfPlaybackException("IPacketReader.ReadBits returned null while reading an floating_point value.");
}
int byteCount = buffer.Length;
return(this.Read(buffer, byteCount));
}
/// <inheritdoc />
public override CtfFieldValue Read(IPacketReader reader, CtfFieldValue parent = null)
{
throw new NotImplementedException();
}
/// <inheritdoc /> public abstract CtfFieldValue Read(IPacketReader reader, CtfFieldValue parent = null);
/// <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);
}
}
