/// <summary>
/// This constructor creates a SECSItem that has a type of <code>A</code> with
/// a specified number of length bytes. This form of the constructor is not
/// needed much nowadays. In the past there were situations where the equipment
/// required that messages contained SECSItems that had a specified number of
/// length bytes. This form of the constructor is here to handle these problem child cases.
/// Note: It will be created with the number of length bytes set
/// to the greater of the number of length bytes specified or
/// the number required based on the length of the <c>value</c> parameter.
/// </summary>
/// <param name="value">The value to be assigned to this SECSItem.</param>
/// <param name="desiredNumberOfLengthBytes">The number of length bytes to be used for this SECSItem.</param>
public ASCIISECSItem(string value, SECSItemNumLengthBytes desiredNumberOfLengthBytes) : base(SECSItemFormatCode.A, value == null ? 0 : value.Length, desiredNumberOfLengthBytes)
{
if (value != null)
{
this.value = value;
}
}
/// <summary>
/// This constructor creates a <c>SECSItem</c> that has a type of <c>L</c>
/// with the specified value and specified number of length bytes.
///
/// This form of the constructor is not needed much nowadays. In the past
/// there were situations where the equipment required that messages
/// contained SECSItems that had a specified number of length bytes.
/// This form of the constructor is here to handle these problem child cases.
/// Note: It will be created with the greater of the specified number of length bytes
/// or the number of length bytes required to
/// accommodate the size of the provided list of <c>SECSItem</c>s.
/// </summary>
/// <param name="value">The value to be assigned to this <code>SECSItem</code>.</param>
/// <param name="desiredNumberOfLengthBytes">The number of length bytes to be used for this <c>SECSItem</c>.
/// The value for the number of length bytes must be <c>ONE</c>, <c>TWO</c>, or <c>THREE</c>.</param>
public ListSECSItem(LinkedList <SECSItem> value, SECSItemNumLengthBytes desiredNumberOfLengthBytes) : base(SECSItemFormatCode.L, value == null ? 0 : value.Count, desiredNumberOfLengthBytes)
{
if (value == null)
{
this.value = new LinkedList <SECSItem>();
}
else
{
this.value = value;
}
}
/// <summary>
/// This is a base class constructor for a <c>SECSItem</c>. When using this constructor, the
/// outbound number of length bytes will be set to the minimum number required to
/// handle an item with the length that is specified by the value of the
/// <c>length</c> parameter.
///
/// This constructor sets the following base class attributes from the provided data:
/// <c>formatCode</c>, <c>lengthInBytes</c>, and <c>outboundNumberOfLengthBytes</c>.
/// </summary>
/// <param name="formatCode">The Format Code of the created <c>SECSItem</c>.</param>
/// <param name="lengthInBytes">The length in bytes of the item, or in the case of a
/// <c>ListSECSItem</c> the number of items it contains.It must be between 0
/// and 16777215 inclusive..</param>
protected SECSItem(SECSItemFormatCode formatCode, int lengthInBytes)
{
if (lengthInBytes < 0 || lengthInBytes > (int)0x00FFFFFF)
{
throw new ArgumentException(
"The value for the length argument must be between 0 and 16777215 inclusive.");
}
this.formatCode = formatCode;
this.lengthInBytes = lengthInBytes;
outboundNumberOfLengthBytes = CalculateMinimumNumberOfLengthBytes(lengthInBytes);
}
/// <summary>
/// This method is used to change the number of length bytes used when this
/// <c>SECSItem</c> is converted to its "wire/transmission" format. The
/// value the number of length bytes will actually set to the greater of
/// the minimum required or the number desired.
/// </summary>
/// <param name="length">The length length in bytes of the <c>SECSItem</c>.</param>
/// <param name="desiredNumberOfLengthBytes">The number of length bytes to be used
/// for this <c>SECSItem</c>. The value for the number of length bytes must
/// be <c>ONE</c>, <c>TWO</c>, or <c>THREE</c>.</param>
public void SetOutboundNumberOfLengthBytes(int length, SECSItemNumLengthBytes desiredNumberOfLengthBytes)
{
if (length < 0 || length > (int)0x00FFFFFF)
{
throw new ArgumentException(
"The value for the length argument must be between 0 and 16777215 inclusive.");
}
outboundNumberOfLengthBytes = CalculateMinimumNumberOfLengthBytes(length);
if (outboundNumberOfLengthBytes.CompareTo(desiredNumberOfLengthBytes) < 0)
{
outboundNumberOfLengthBytes = desiredNumberOfLengthBytes;
}
}
/// <summary>
/// Return the minimum number of length bytes required based on the
/// specified length. The result should be SECSItemNumLengthBytes.ONE,
/// SECSItemNumLengthBytes.TWO, or SECSItemNumLengthBytes.THREE.
/// The maximum length of a <c>SECSItem</c> in its " wire/transmission format"
/// is 16777215 (stored in 24 bits).
/// </summary>
/// <returns>The minimum number of length bytes required.</returns>
/// <param name="lengthOfData">The length of the data in bytes.</param>
private SECSItemNumLengthBytes CalculateMinimumNumberOfLengthBytes(int lengthOfData)
{
SECSItemNumLengthBytes result = SECSItemNumLengthBytes.ONE;
if (lengthOfData > 255)
{
if (lengthOfData < 65536)
{
result = SECSItemNumLengthBytes.TWO;
}
else
{
result = SECSItemNumLengthBytes.THREE;
}
}
return(result);
}
/// <summary>
/// Initializes a new instance of the <see cref="T:com.CIMthetics.CSharpSECSTools.SECSItems.F8SECSItem"/> class.
/// </summary>
/// <param name="value">The value to be assigned to this <c>SECSItem</c>.</param>
/// <param name="desiredNumberOfLengthBytes">The number of length bytes to be used for this <c>SECSItem</c>.
/// The value for the number of length bytes must be <c>ONE</c>, <c>TWO</c>, or <c>THREE</c>.</param>
public F8SECSItem(double value, SECSItemNumLengthBytes desiredNumberOfLengthBytes) : base(SECSItemFormatCode.F8, 8, desiredNumberOfLengthBytes)
{
this.value = value;
}
/// <summary>
/// This constructor creates a SECSItem that has a type of <c>I4</c>
/// with the specified value.
///
/// This form of the constructor is not needed much nowadays. In the past
/// there were situations where the equipment required that messages
/// contained SECSItems that had a specified number of length bytes.
/// This form of the constructor is here to handle these problem child cases.
///
/// Note: It will be created with the number of length bytes set to greater of,
/// the specified number of length bytes or the number required based on the
/// length (in elements) of the<code>int []</code> provided.
/// </summary>
/// <param name="value">The value to be assigned to this <c>SECSItem</c>.</param>
/// <param name="desiredNumberOfLengthBytes">The number of length bytes to be used for this <c>SECSItem</c>.
/// The value for the number of length bytes must be <c>ONE</c>, <c>TWO</c>, or <c>THREE</c>.</param>
public I4ArraySECSItem(Int32[] value, SECSItemNumLengthBytes desiredNumberOfLengthBytes) : base(SECSItemFormatCode.I4, value.Length * 4, desiredNumberOfLengthBytes)
{
this.value = value;
}
/// <summary>
/// Initializes a new instance of the <see cref="T:com.CIMthetics.CSharpSECSTools.SECSItems.U8ArraySECSItem"/> class.
/// </summary>
/// <param name="value">The value to be assigned to this <c>SECSItem</c>.</param>
/// <param name="desiredNumberOfLengthBytes">The number of length bytes to be used for this <c>SECSItem</c>.
/// The value for the number of length bytes must be <c>ONE</c>, <c>TWO</c>, or <c>THREE</c>.</param>
public U8ArraySECSItem(UInt64[] value, SECSItemNumLengthBytes desiredNumberOfLengthBytes) : base(SECSItemFormatCode.U8, value.Length * 8, desiredNumberOfLengthBytes)
{
this.value = value;
}
/// <summary>
/// This constructor creates a <c>SECSItem</c> that has a type of <c>F4</c>
/// with the specified value. This form of the constructor is not needed
/// much nowadays. In the past there were situations where the equipment
/// required that messages contained SECSItems that had a specified number
/// of length bytes. This form of the constructor is here to handle these
/// problem child cases. Note: It will be created with the specified number
/// of length bytes.
/// </summary>
/// <param name="value">The value to be assigned to this <c>SECSItem</c>.</param>
/// <param name="desiredNumberOfLengthBytes">The number of length bytes to be used for this <code>SECSItem</code>.
/// The value for the number of length bytes must be <c>ONE</c>, <c>TWO</c>, or <c>THREE</c>.</param>
public F4SECSItem(float value, SECSItemNumLengthBytes desiredNumberOfLengthBytes) : base(SECSItemFormatCode.F4, 4, desiredNumberOfLengthBytes)
{
this.value = value;
}
/// <summary>
/// This constructor creates a <c>SECSItem</c> that has a type of <c>U8</c>
/// with the specified value.
///
/// This form of the constructor is not needed much nowadays. In the past
/// there were situations where the equipment required that messages
/// contained SECSItems that had a specified number of length bytes.
/// This form of the constructor is here to handle these problem child cases.
/// Note: It will be created with the specified number of length bytes.
/// </summary>
/// <param name="value">The value to be assigned to this <c>SECSItem</c>.</param>
/// <param name="desiredNumberOfLengthBytes">The number of length bytes to be used for this <c>SECSItem</c>.
/// The value for the number of length bytes must be <c>ONE</c>, <c>TWO</c>, or <c>THREE</c>.</param>
public U8SECSItem(UInt64 value, SECSItemNumLengthBytes desiredNumberOfLengthBytes) : base(SECSItemFormatCode.U8, 8, desiredNumberOfLengthBytes)
{
this.value = value;
}
/// <summary>
/// Initializes a new instance of the <see cref="T:com.CIMthetics.CSharpSECSTools.SECSItems.I1ArraySECSItem"/> class.
/// </summary>
/// <param name="value">The value to be assigned to this <c>SECSItem</c>.</param>
/// <param name="desiredNumberOfLengthBytes">The number of length bytes to be used for this <code>SECSItem</code>.
/// The value for the number of length bytes must be <c>ONE</c>, <c>TWO</c>, or <c>THREE</c>.</param>
public I1ArraySECSItem(sbyte[] value, SECSItemNumLengthBytes desiredNumberOfLengthBytes) : base(SECSItemFormatCode.I1, value.Length, desiredNumberOfLengthBytes)
{
this.value = value;
}
/// <summary>
/// This is a base class constructor for a SECSItem. This form of the constructor
/// is used when parsing wire/transmission format data and converting it into
/// its "C# form".
///
/// This constructor sets the following base class attributes from the provided data:
/// <c>formatCode</c>,
/// <c>inboundNumberOfLengthBytes</c>,
/// <c>outboundNumberOfLengthBytes</c>
/// <c>lengthInBytes</c> or if the <c>formatCode</c> is of type <c>L</c>(List) <c>lengthInBytes</c>
/// will be the number of items in the list.
///
/// The exception <c>ArgumentException</c> will be thrown in the following circumstances:
/// the <c>data</c> argument is <c>null</c>, the <c>data</c> argument has a length of zero, or
/// the number of length bytes parsed out is zero.
///
/// In normal use the only time the <c>ArgumentException</c>
/// exception should be caught is if you are reading data from a piece of
/// equipment that does not properly speak SECS and you want to be able to
/// recover from the error gracefully.Typically the ACM process will have
/// detected this equipment and it will not be allowed into the factory in
/// the first place.
/// </summary>
protected SECSItem(byte[] data, int itemOffset)
{
if (data == null)
{
throw new ArgumentNullException("\"data\" argument must not be null.");
}
if (data.Length < 2)
{
throw new ArgumentException("\"data\" argument must have a length >= 2.");
}
/*
* if (data.Length == 0)
* {
* throw new ArgumentException ("The number of length bytes is not allowed to be ZERO.");
* }
*/
formatCode = SECSItemFormatCodeFunctions.GetSECSItemFormatCodeFromNumber((byte)((data[itemOffset] >> 2) & 0x0000003F));
byte[] temp1 = new byte[4];
switch (data [itemOffset] & 0x03)
{
case 0:
{
throw new ArgumentException("The number of length bytes is not allowed to be ZERO.");
}
case 1:
{
inboundNumberOfLengthBytes = SECSItemNumLengthBytes.ONE;
outboundNumberOfLengthBytes = inboundNumberOfLengthBytes;
temp1[0] = 0;
temp1[1] = 0;
temp1[2] = 0;
temp1[3] = data[itemOffset + 1];
break;
}
case 2:
{
inboundNumberOfLengthBytes = SECSItemNumLengthBytes.TWO;
outboundNumberOfLengthBytes = inboundNumberOfLengthBytes;
if (data.Length < 3)
{
throw new ArgumentException("With two length bytes the minimum length for the \"data\" argument is 3.");
}
temp1[0] = 0;
temp1[1] = 0;
temp1[2] = data[itemOffset + 1];
temp1[3] = data[itemOffset + 2];
break;
}
case 3:
{
inboundNumberOfLengthBytes = SECSItemNumLengthBytes.THREE;
outboundNumberOfLengthBytes = inboundNumberOfLengthBytes;
if (data.Length < 4)
{
throw new ArgumentException("With three length bytes the minimum length for the \"data\" argument is 4.");
}
temp1[0] = 0;
temp1[1] = data[itemOffset + 1];
temp1[2] = data[itemOffset + 2];
temp1[3] = data[itemOffset + 3];
break;
}
}
if (BitConverter.IsLittleEndian)
{
Array.Reverse(temp1);
}
lengthInBytes = BitConverter.ToInt32(temp1, 0);
/*
* if (formatCode == SECSItemFormatCode.L)
* numberOfElements = incomingDataLength;
* else
* lengthInBytes = incomingDataLength;
*/
}
/// <summary>
/// This is a base class constructor for a SECSItem. When using this constructor, the
/// number of length bytes will be set to the greater of, the specified number of
/// length bytes, or the minimum number required to
/// handle an item with the length that is specified by the value of the
/// <c>lengthInBytes</c> parameter.
/// This constructor sets the following base class attributes from the provided data:
/// <c>formatCode</c>,
/// <c>lengthInBytes</c>, and
/// <c>outboundNumberOfLengthBytes</c>.
/// Note: An <c>ArgumentException</c> will be thrown if the value of the
/// <c>lengthInBytes</c> parameter is outside the range of 0 - 16777215
/// inclusive.
/// </summary>
/// <param name="formatCode">The SECS Item Format code for this SECSItem.</param>
/// <param name="lengthInBytes">The length in bytes that this SECSItem will take up in
/// its wire/transmission format.</param>
/// <param name="desiredNumberOfLengthBytes">This parameter expresses the desired
/// number or length bytes to be used for this SECSItem when it is converted
/// to its wire/transmission format.</param>
protected SECSItem(SECSItemFormatCode formatCode, int lengthInBytes, SECSItemNumLengthBytes desiredNumberOfLengthBytes)
{
this.formatCode = formatCode;
this.lengthInBytes = lengthInBytes;
SetOutboundNumberOfLengthBytes(lengthInBytes, desiredNumberOfLengthBytes);
}
/// <summary>
/// This constructor creates a SECSItem that has a type of <c>F4</c> with the specified value.
/// This form of the constructor is not needed much nowadays. In the past there were situations
/// where the equipment required that messages contained SECSItems that had a specified number
/// of length bytes. This form of the constructor is here to handle these problem child cases.
/// Note: It will be created with the number of length bytes set to greater of, the specified
/// number of length bytes or the number required based on the length (in elements) of the
/// <c>float []</c> provided.
/// </summary>
/// <param name="value">The value to be assigned to this <c>SECSItem</c>.</param>
/// <param name="desiredNumberOfLengthBytes">The number of length bytes to be used for this <c>SECSItem</c>.
/// The value for the number of length bytes must be <c>ONE</c>, <c>TWO</c>, or <c>THREE</c>..</param>
public F4ArraySECSItem(float[] value, SECSItemNumLengthBytes desiredNumberOfLengthBytes) : base(SECSItemFormatCode.F4, value.Length * 4, desiredNumberOfLengthBytes)
{
this.value = value;
}
/// <summary>
/// This constructor creates a SECSItem that has a type of <c>F8</c>
/// with the specified value. This form of the constructor is not
/// needed much nowadays. In the past there were situations where
/// the equipment required that messages contained SECSItems that
/// had a specified number of length bytes. This form of the constructor
/// is here to handle these problem child cases.
///
/// Note: It will be created with the number of length bytes set to greater of,
/// the specified number of length bytes or the number required based on the
/// length (in elements) of the<code>double []</code> provided.
/// </summary>
/// <param name="value">The value to be assigned to this <c>SECSItem</c>.</param>
/// <param name="desiredNumberOfLengthBytes">The number of length bytes to be used for
/// this <c>SECSItem</c>. The value for the number of length bytes must be
/// <c>ONE</c>, <c>TWO</c>, or <c>THREE</c>.</param>
public F8ArraySECSItem(double[] value, SECSItemNumLengthBytes desiredNumberOfLengthBytes) : base(SECSItemFormatCode.F8, value.Length * 8, desiredNumberOfLengthBytes)
{
this.value = value;
}
/// <summary>
/// Initializes a new instance of the <see cref="T:com.CIMthetics.CSharpSECSTools.SECSItems.I2SECSItem"/> class.
/// </summary>
/// <param name="value">The value to be assigned to this <c>SECSItem</c>.</param>
/// <param name="desiredNumberOfLengthBytes">The number of length bytes to be used for this <c>SECSItem</c>.
/// The value for the number of length bytes must be <c>ONE</c>, <c>TWO</c>, or <c>THREE</c>.</param>
public I2SECSItem(Int16 value, SECSItemNumLengthBytes desiredNumberOfLengthBytes) : base(SECSItemFormatCode.I2, 2, desiredNumberOfLengthBytes)
{
this.value = value;
}
/// <summary>
/// This constructor creates a <c>SECSItem</c> that has a type of <c>BO</c> with the specified value.
/// This form of the constructor is not needed much nowadays. In the past there were situations
/// where the equipment required that messages contained <c>SECSItem</c>s that had a specified number
/// of length bytes. This form of the constructor is here to handle these problem child cases.
///
/// Note: It will be created with the number of length bytes set to greater of,
/// the specified number of length bytes or the number required based on the
/// length (in elements) of the <c>bool []</c> provided.
/// </summary>
/// <param name="value">The value to be assigned to this <c>SECSItem</c>.</param>
/// <param name="desiredNumberOfLengthBytes">The number of length bytes to be used for this <c>SECSItem</c>.
/// The value for the number of length bytes must be<c> ONE</c>, <c>TWO</c>, or <c>THREE</c>.</param>
public BooleanArraySECSItem(bool[] value, SECSItemNumLengthBytes desiredNumberOfLengthBytes) : base(SECSItemFormatCode.BO, value.Length, desiredNumberOfLengthBytes)
{
this.value = value;
}
/// <summary>
/// This constructor creates a SECSItem that has a type of <c>I1</c>
/// with the specified value.
///
/// This form of the constructor is not needed much nowadays. In the past
/// there were situations where the equipment required that messages
/// contained SECSItems that had a specified number of length bytes.
/// This form of the constructor is here to handle these problem child cases.
///
/// Note: It will be created with the specified number of length bytes.
/// </summary>
/// <param name="value">The value to be assigned to this <code>SECSItem</code>.</param>
/// <param name="desiredNumberOfLengthBytes">The number of length bytes to be used for this <c>SECSItem</c>.
/// The value for the number of length bytes must be <c>ONE</c>, <c>TWO</c>, or <c>THREE</c>.</param>
public I1SECSItem(sbyte value, SECSItemNumLengthBytes desiredNumberOfLengthBytes) : base(SECSItemFormatCode.I1, 1, desiredNumberOfLengthBytes)
{
this.value = value;
}
/// <summary>
/// This constructor creates a SECSItem that has a type of <c>I2</c> with the specified value.
///
/// This form of the constructor is not needed much nowadays. In the past
/// there were situations where the equipment required that messages
/// contained SECSItems that had a specified number of length bytes.
/// This form of the constructor is here to handle these problem child cases.
///
/// Note: It will be created with the number of length bytes set to greater of,
/// the specified number of length bytes or the number required based on the
/// length (in elements) of the<code>short []</code> provided.
/// </summary>
/// <param name="value">The value to be assigned to this <c>SECSItem</c>.</param>
/// <param name="desiredNumberOfLengthBytes">The number of length bytes to be used for this <c>SECSItem</c>.
/// The value for the number of length bytes must be <c>ONE</c>, <c>TWO</c>, or <c>THREE</c>.</param>
public I2ArraySECSItem(Int16[] value, SECSItemNumLengthBytes desiredNumberOfLengthBytes) : base(SECSItemFormatCode.I2, value.Length * 2, desiredNumberOfLengthBytes)
{
this.value = value;
}
/// <summary>
/// Initializes a new instance of the <see cref="T:com.CIMthetics.CSharpSECSTools.SECSItems.I4SECSItem"/> class.
/// </summary>
/// <param name="value">The value to be assigned to this <c>SECSItem</c>.</param>
/// <param name="desiredNumberOfLengthBytes">The number of length bytes to be used for this <c>SECSItem</c>.
/// The value for the number of length bytes must be <c>ONE</c>, <c>TWO</c>, or <c>THREE</c>.</param>
public I4SECSItem(Int32 value, SECSItemNumLengthBytes desiredNumberOfLengthBytes) : base(SECSItemFormatCode.I4, 4, desiredNumberOfLengthBytes)
{
this.value = value;
}
/// <summary>
/// This constructor creates a SECSItem that has a type of <c>B</c> with
/// a specified number of length bytes.
///
/// This form of the constructor is not needed much nowadays. In the past
/// there were situations where the equipment required that messages
/// contained SECSItems that had a specified number of length bytes.
/// This form of the constructor is here to handle these problem child cases.
///
/// Note: It will be created with the number of length bytes set
/// to the greater of the number of length bytes specified or
/// the number required based on the length of the <c>value</c>
/// parameter.
/// </summary>
/// <param name="value">The value to be assigned to this SECSItem.</param>
/// <param name="desiredNumberOfLengthBytes">The number of length bytes to be used for this SECSItem.
/// The value for the number of length bytes must be ONE, TWO, or THREE..</param>
public BinarySECSItem(byte[] value, SECSItemNumLengthBytes desiredNumberOfLengthBytes) : base(SECSItemFormatCode.B, value.Length, desiredNumberOfLengthBytes)
{
this.value = value;
}
/// <summary>
/// This constructor creates a SECSItem that has a type of <c>BO</c>
/// with the specified value. This form of the constructor is not needed much nowadays.
/// In the past there were situations where the equipment required that messages
/// contained SECSItems that had a specified number of length bytes. This form of the
/// constructor is here to handle these problem child cases.
/// Note: It will be created with the specified number of length bytes.
/// </summary>
/// <param name="value">The value to be assigned to this <code>SECSItem</code>.</param>
/// <param name="desiredNumberOfLengthBytes">The number of length bytes to be used for this <code>SECSItem</code>.
/// The value for the number of length bytes must be <c>ONE</c>, <c>TWO</c>, or <c>THREE</c>.</param>
public BooleanSECSItem(bool value, SECSItemNumLengthBytes desiredNumberOfLengthBytes) : base(SECSItemFormatCode.BO, 1, desiredNumberOfLengthBytes)
{
this.value = value;
}
