/// <summary>
/// Initializes a new instance of the <see cref="ArrayTypeValue"/> class.
/// Values are decoded from the byte store
/// </summary>
/// <param name="theArrayTypeDefinition">The array type definition.</param>
/// <param name="theBytes">The bytes.</param>
/// <param name="parent">The parent.</param>
public ArrayTypeValue(ArrayTypeDefinition theArrayTypeDefinition, ByteStore theBytes, Value parent)
: base(theArrayTypeDefinition, parent)
{
m_ArrayTypeDefinition = theArrayTypeDefinition;
m_ArrayValues = new ArrayValueContainer(m_ArrayTypeDefinition.UpperBound);
if (m_ArrayTypeDefinition.Rank > 0)
{
// Fixed-size arrays - populate with decoded elements of the base type
m_ArrayValues.Populate(() => m_ArrayTypeDefinition.ElementType.Decode(theBytes, this));
}
else if (!string.IsNullOrEmpty(m_ArrayTypeDefinition.UpperBoundVariable))
{
// Variable size array. Locate the discriminator if there is one
// TODO
}
else
{
// Variable size array - number of elements limited by the number of bytes available or an end marker being discovered
bool done = false;
do
{
Value theValue = m_ArrayTypeDefinition.ElementType.Decode(theBytes, this);
m_ArrayValues.Add(theValue);
if (theValue.FundamentalType.TypeId == TypeId.StructType)
{
done = IsEndMarker(theValue as StructureValue);
}
}
while (!done);
}
}
/// <summary>
/// Creates a new Value object, deriving the value by decoding the specified bytes.
/// Each derived class creates its corresponding value type
/// </summary>
/// <param name="theBytes">The collection of bytes containing the value to be decoded</param>
/// <param name="parent">The parent.</param>
/// <returns>
/// The decoded value object
/// </returns>
public override Value Decode(ByteStore theBytes, Value parent)
{
TypeDefinition baseType = DictionaryManager.DereferenceTypeDef(this);
Value theValue = baseType.Decode(theBytes, parent);
theValue.OverrideInitialType(this);
return theValue;
}
/// <summary>
/// Initializes a new instance of the <see cref="StringValue"/> class.
/// </summary>
/// <param name="theBytes">The bytes.</param>
/// <param name="theStringDefinition">The string definition.</param>
/// <param name="parent">The parent.</param>
public StringValue(ByteStore theBytes, StringDefinition theStringDefinition, Value parent)
: base(theStringDefinition, parent)
{
List<Byte> stringBytes = new List<byte>();
// Read bytes until they run out or we hit null terminator
Byte theByte = 0xff;
while (theBytes.ReadPosition < theBytes.PayloadLength && theByte != '\0')
{
theByte = theBytes.GetByte();
stringBytes.Add(theByte);
}
m_Value = Encoding.ASCII.GetString(stringBytes.ToArray());
}
/// <summary>
/// Creates a new Value object, deriving the value by decoding the specified bytes.
/// Each derived class creates its corresponding value type
/// </summary>
/// <param name="theBytes">The collection of bytes containing the value to be
/// decoded</param>
/// <param name="parent"></param>
/// <returns>
/// The decoded value object
/// </returns>
public override Value Decode(ByteStore theBytes, Value parent)
{
return new EnumValue(this, theBytes, parent);
}
/// <summary>
/// Encodes the value into the list of bytes
/// </summary>
/// <param name="theBytes"></param>
public override void Encode(ByteStore theBytes)
{
foreach (var arrayItem in m_ArrayValues)
{
arrayItem.Encode(theBytes);
}
}
/// <summary>
/// Creates a new Value object, deriving the value by decoding the specified bytes.
/// Each derived class creates its corresponding value type
/// </summary>
/// <param name="theBytes">The collection of bytes containing the value to be
/// decoded</param>
/// <param name="parent"></param>
/// <returns>
/// The decoded value object
/// </returns>
public override Value Decode(ByteStore theBytes, Value parent)
{
// Find the discriminator for the switch and look up its value
StructureValue theParentStruct = parent as StructureValue;
if (theParentStruct == null)
{
throw new DataDictionaryException("SwitchDefinition {0}: Parent {1} is not a struct value",
Name, parent.FundamentalType.Name);
}
SwitchCaseDefinition caseDefinition = GetSwitchCaseDefinition(theParentStruct);
if (caseDefinition == null)
{
throw new DataDictionaryException("SwitchDefinition {0}: case value not found", Name);
}
TypeDefinition typeToDecode = caseDefinition.Type;
return typeToDecode.Decode(theBytes, parent);
}
/// <summary>
/// Encodes the value into the list of bytes
/// </summary>
/// <param name="theBytes">The bytes.</param>
public override void Encode(ByteStore theBytes)
{
m_WrappedValue.Encode(theBytes);
}
/// <summary>
/// Encodes the value into the list of bytes
/// </summary>
/// <param name="theBytes"></param>
public override void Encode(ByteStore theBytes)
{
ulong tempValue = 0;
tempValue = m_BaseTypeDefinition.IsSigned ? (ulong)SignedValue : UnsignedValue;
switch (GetSizeBytes())
{
case 0:
// 0-size end marker
break;
case 1:
theBytes.PutByte((byte)tempValue);
break;
case 2:
theBytes.PutUint16((ushort)tempValue);
break;
case 4:
theBytes.PutUint32((uint)tempValue);
break;
case 8:
theBytes.PutUint64(tempValue);
break;
default:
throw new DataDictionaryException(String.Format("{0} Illegal ByteSize {1}",
m_BaseTypeDefinition.Name,
GetSizeBytes()));
}
}
/// <summary>
/// Initializes a new instance of the <see cref="BaseTypeValue"/> class with
/// values extracted from the byte store
/// </summary>
/// <param name="baseTypeDefinition">The base type definition.</param>
/// <param name="theBytes">The bytes.</param>
/// <param name="parent">The parent.</param>
public BaseTypeValue(BaseTypeDefinition baseTypeDefinition, ByteStore theBytes, Value parent)
: this(baseTypeDefinition, parent)
{
ulong tempValue = 0;
switch (m_BaseTypeDefinition.FixedSizeBytes.Value)
{
case 0:
// Special case for end-markers for lists of elements
break;
case 1:
tempValue = theBytes.GetByte();
break;
case 2:
tempValue = theBytes.GetUint16();
break;
case 4:
tempValue = theBytes.GetUint32();
break;
case 8:
tempValue = theBytes.GetUint64();
break;
default:
throw new DataDictionaryException(String.Format("{0} Illegal ByteSize {1}",
m_BaseTypeDefinition.Name,
m_BaseTypeDefinition.FixedSizeBytes.Value));
}
if (m_BaseTypeDefinition.IsSigned)
{
SignedValue = (long)tempValue;
}
else
{
UnsignedValue = tempValue;
}
}
/// <summary>
/// Encodes the value into the list of bytes
/// </summary>
/// <param name="theBytes">The bytes.</param>
public virtual void Encode(ByteStore theBytes)
{
throw new NotImplementedException();
}
/// <summary>
/// Initializes a new instance of the <see cref="EnumValue"/> class by extracting the
/// encoded value from the byte store
/// </summary>
/// <param name="theEnumDefinition">The enum definition.</param>
/// <param name="theBytes">The bytes.</param>
/// <param name="parent">The parent.</param>
public EnumValue(EnumDefinition theEnumDefinition, ByteStore theBytes, Value parent)
: this(theEnumDefinition, parent)
{
switch (theEnumDefinition.FixedSizeBytes)
{
case 1:
IntegerValue = (int)theBytes.GetByte();
break;
case 2:
IntegerValue = (int)theBytes.GetUint16();
break;
case 4:
IntegerValue = (int)theBytes.GetUint32();
break;
default:
throw new DataDictionaryException(string.Format("Illegal byte size {0} for enum {1}", theEnumDefinition.FixedSizeBytes, m_EnumDefinition.Name));
}
StringValue = m_EnumDefinition.IntegerValueToString(IntegerValue);
}
/// <summary>
/// Encodes the value into the list of bytes
/// </summary>
/// <param name="theBytes"></param>
public override void Encode(ByteStore theBytes)
{
switch (GetSizeBytes())
{
case 1:
theBytes.PutByte((byte) IntegerValue);
break;
case 2:
theBytes.PutUint16((ushort) IntegerValue);
break;
case 4:
theBytes.PutUint32((uint) IntegerValue);
break;
default:
throw new DataDictionaryException(string.Format("Illegal byte size {0} for enum {1}", GetSizeBytes(), m_EnumDefinition.Name));
}
}
/// <summary>
/// Creates a new Value object, deriving the value by decoding the specified bytes.
/// Each derived class creates its corresponding value type
/// </summary>
/// <param name="theBytes">The collection of bytes containing the value to be decoded</param>
/// <param name="parent">The parent.</param>
/// <returns>
/// The decoded value object
/// </returns>
public virtual Value Decode(ByteStore theBytes, Value parent)
{
throw new DataDictionaryException("Cannot decode type {0}", Name);
}
