/// <summary>
/// Construye un nuevo formateador de mapas de bits.
/// </summary>
/// <param name="fieldNumber">
/// Es el número de campo del mensaje que el formateador es capaz de formatear.
/// </param>
/// <param name="lowerFieldNumber">
/// Es el número de campo menor que el mapa de bits puede anunciar.
/// </param>
/// <param name="upperFieldNumber">
/// Es el número de campo mayor que el mapa de bits puede anunciar.
/// </param>
/// <param name="encoder">
/// Es el objeto capaz de codificar/decodificar los datos del mapa de bits.
/// </param>
/// <param name="description">
/// Es la descripción del mapa de bits.
/// </param>
/// <exception cref="ArgumentOutOfRangeException">
/// <paramref name="lowerFieldNumber"/> debe ser mayor que cero y menor
/// o igual a <paramref name="upperFieldNumber"/>.
/// </exception>
/// <exception cref="ArgumentNullException">
/// El parámetro <paramref name="encoder"/> es inválido.
/// </exception>
public BitMapFieldFormatter(int fieldNumber, int lowerFieldNumber,
int upperFieldNumber, IBinaryEncoder encoder, string description) :
base(fieldNumber, description)
{
if (lowerFieldNumber < 0)
{
throw new ArgumentOutOfRangeException("lowerFieldNumber", lowerFieldNumber,
SR.CantBeLowerThanZero);
}
if (lowerFieldNumber > upperFieldNumber)
{
throw new ArgumentOutOfRangeException("lowerFieldNumber", lowerFieldNumber,
SR.MustBeLowerOrEqualToUpperFieldNumber);
}
if (encoder == null)
{
throw new ArgumentNullException("encoder");
}
_lowerFieldNumber = lowerFieldNumber;
_upperFieldNumber = upperFieldNumber;
_encoder = encoder;
_bitmapLength = ((_upperFieldNumber - _lowerFieldNumber) + 8) / 8;
}
/// <summary>
/// Encodes the <see cref="Array" /> directly if the array is one dimensional or as <see cref="Variant" /> otherwise.
/// </summary>
/// <typeparam name="type">The type of the array element type.</typeparam>
/// <param name="encoder">The encoder <see cref="IBinaryEncoder" /> to write the value encapsulated in this instance.</param>
/// <param name="value">The value to be encoded as an instance of <see cref="Array" />.</param>
/// <param name="writeValue">Thi delegate encapsulates binary encoding functionality.</param>
/// <param name="builtInType"><see cref="BuiltInType" /> of the array item to be encoded in case of variant.</param>
public void WriteArray <type>(IBinaryEncoder encoder, Array value, Action <type> writeValue, BuiltInType builtInType)
{
if (value == null)
{
encoder.Write((byte)0);
return;
}
byte _encodingByte = (byte)builtInType;
if (value.Rank > 1)
{
//Encode it as the Variant
if (builtInType == BuiltInType.Enumeration)
{
_encodingByte = (byte)BuiltInType.Int32;
}
_encodingByte |= (byte)VariantEncodingMask.IsArray;
if (value.Rank > 1)
{
_encodingByte |= (byte)VariantEncodingMask.ArrayDimensionsPresents;
}
encoder.Write(_encodingByte);
}
EncodeArray <type>(encoder.Write, value, writeValue);
}
public static string EncodeString(this IBinaryEncoder encoder, string stringToEncode, Encoding encoding = null)
{
if (encoding is null)
{
encoding = defaultEncoding;
}
return(encoding.GetString(encoder.Encode(stringToEncode, encoding)));
}
/// <summary>
/// Encodes the <see cref="string" /> as a sequence of UTF8 characters without a null terminator and preceded by the length in bytes.
/// The length in bytes is encoded as Int32. A value of −1 is used to indicate a ‘null’ string.
/// </summary>
/// <param name="encoder">The encoder <see cref="IBinaryEncoder" /> to write the value encapsulated in this instance.</param>
/// <param name="value">The value to be encoded as an instance of <see cref="Guid" />.</param>
public void Write(IBinaryEncoder encoder, string value)
{
if (value == null)
{
encoder.Write((Int32)(-1));
return;
}
byte[] _bytes = new UTF8Encoding().GetBytes(value);
Write(encoder, _bytes);
}
public static byte[] Encode(this IBinaryEncoder encoder, string stringToEncode, Encoding encoding = null)
{
if (encoding is null)
{
encoding = defaultEncoding;
}
byte[] byteToEncode = encoding.GetBytes(stringToEncode);
return(encoder.Encode(byteToEncode));
}
/// <summary>
/// Writes the <c>ByteString</c> using the provided encoder <see cref="IBinaryEncoder" />.
/// </summary>
/// <param name="encoder">The encoder and an object implementing the <see cref="IBinaryEncoder" /> interface.</param>
/// <param name="value">The value to be encoded.</param>
public virtual void Write(IBinaryEncoder encoder, byte[] value)
{
if (value == null)
{
encoder.Write((Int32)(-1));
}
else
{
encoder.Write((Int32)value.Length);
encoder.Write(value);
}
}
/// <summary>
/// It initializes a new binary field formatter instance.
/// </summary>
/// <param name="fieldNumber">
/// It's the number of the field this formatter formats/parse.
/// </param>
/// <param name="lengthManager">
/// It's the field length manager.
/// </param>
/// <param name="encoder">
/// It's the field value encoder.
/// </param>
/// <param name="description">
/// It's the description of the field formatter.
/// </param>
public BinaryFieldFormatter(int fieldNumber, LengthManager lengthManager,
IBinaryEncoder encoder, string description) :
base(fieldNumber, description)
{
if (lengthManager == null)
{
throw new ArgumentNullException("lengthManager");
}
if (encoder == null)
{
throw new ArgumentNullException("encoder");
}
_lengthManager = lengthManager;
_encoder = encoder;
}
/// <summary>
/// Writes the <see cref="IVariant"/> using provided encoder <see cref="IBinaryEncoder"/>
/// </summary>
/// <param name="encoder">The encoder to write the value encapsulated in this instance.</param>
/// <param name="value">The value to be encoded as an instance of <see cref="IVariant"/>.</param>
public virtual void Write(IBinaryEncoder encoder, IVariant value)
{
// check for null.
if (value.Value == null || value.UATypeInfo == null || value.UATypeInfo.BuiltInType == BuiltInType.Null)
{
encoder.Write((byte)0);
return;
}
// encode enums as int32.
byte _encodingByte = (byte)value.UATypeInfo.BuiltInType;
if (value.UATypeInfo.BuiltInType == BuiltInType.Enumeration)
{
_encodingByte = (byte)BuiltInType.Int32;
}
if (value.UATypeInfo.ValueRank < 0)
{
encoder.Write(_encodingByte);
WriteValue(encoder, value.UATypeInfo.BuiltInType, value.Value);
}
else
{
_encodingByte |= (byte)VariantEncodingMask.IsArray;
Array _array = null;
if (value.Value != null)
{
_array = value.Value as Array;
if (_array == null)
{
throw new ArgumentOutOfRangeException(nameof(value), $"{nameof(value.Value)} must be of the {nameof(Array)} type and cannot be null");
}
if (_array.Rank > 1)
{
_encodingByte |= (byte)VariantEncodingMask.ArrayDimensionsPresents;
}
}
encoder.Write(_encodingByte);
EncodeArray(encoder, value.UATypeInfo.BuiltInType, _array);
}
}
/// <summary>
/// Writes a <see cref="Guid" /> to the current stream as a 16-element byte array that contains the value and advances the stream position by 16 bytes.
/// </summary>
/// <param name="encoder">The encoder to write the value encapsulated in this instance.</param>
/// <param name="value">The value to be encoded as an instance of <see cref="Guid"/>.</param>
public virtual void Write(IBinaryEncoder encoder, Guid value)
{
encoder.Write(value.ToByteArray());
}
public override void Write(IBinaryEncoder encoder, IExtensionObject value)
{
throw new NotImplementedException();
}
public void Write(IBinaryEncoder encoder, string value)
{
Assert.AreSame(this, encoder);
_encoder.Write(this, value);
}
public void WriteArray <type>(IBinaryEncoder encoder, Array value, Action <type> writeValue, BuiltInType builtInType)
{
throw new NotImplementedException();
}
/// <summary> /// Writes <see cref="DateTime" /> using the provided encoder <see cref="IBinaryEncoder" />. /// </summary> /// <param name="encoder">The encoder - an object implementing the <see cref="IBinaryEncoder" /> interface.</param> /// <param name="value">The value to be encoded.</param> public abstract void Write(IBinaryEncoder encoder, ILocalizedText value);
public override void Write(IBinaryEncoder encoder, IVariant value)
{
base.Write(encoder, value);
}
/// <summary> /// Writes <see cref="IStatusCode" /> using the provided encoder <see cref="IBinaryEncoder" />. /// </summary> /// <param name="encoder">The encoder - an object implementing the <see cref="IBinaryEncoder" /> interface.</param> /// <param name="value">The value to be encoded.</param> public abstract void Write(IBinaryEncoder encoder, IStatusCode value);
/// <summary> /// Writes <see cref="IDiagnosticInfo" /> using the provided encoder <see cref="IBinaryEncoder" />. /// </summary> /// <param name="encoder">The encoder - an object implementing the <see cref="IBinaryEncoder" /> interface.</param> /// <param name="value">The value to be encoded.</param> public abstract void Write(IBinaryEncoder encoder, IDiagnosticInfo value);
public void Write(IBinaryEncoder encoder, IExpandedNodeId value)
{
_encoder.Write(this, value);
}
/// <summary> /// Writes <see cref="INodeId" /> using the provided encoder <see cref="IBinaryEncoder" />. /// </summary> /// <param name="encoder">The encoder - an object implementing the <see cref="IBinaryEncoder" /> interface.</param> /// <param name="value">The value to be encoded.</param> public abstract void Write(IBinaryEncoder encoder, INodeId value);
public void Write(IBinaryEncoder encoder, IDiagnosticInfo value)
{
_encoder.Write(this, value);
}
public void Write(IBinaryEncoder encoder, IDataValue value)
{
_encoder.Write(this, value);
}
public override void Write(IBinaryEncoder encoder, IQualifiedName value)
{
throw new NotImplementedException();
}
public override void Write(IBinaryEncoder encoder, IExpandedNodeId value)
{
throw new NotImplementedException();
}
private void WriteValue(IBinaryEncoder encoder, BuiltInType builtInType, object value)
{
switch (builtInType)
{
case BuiltInType.Boolean:
encoder.Write((Boolean)value);
return;
case BuiltInType.SByte:
encoder.Write((SByte)value);
return;
case BuiltInType.Byte:
encoder.Write((Byte)value);
return;
case BuiltInType.Int16:
encoder.Write((Int16)value);
return;
case BuiltInType.UInt16:
encoder.Write((UInt16)value);
return;
case BuiltInType.Int32:
encoder.Write((Int32)value);
return;
case BuiltInType.UInt32:
encoder.Write((System.UInt32)value);
return;
case BuiltInType.Int64:
encoder.Write((Int64)value);
return;
case BuiltInType.UInt64:
encoder.Write((UInt64)value);
return;
case BuiltInType.Float:
encoder.Write((Single)value);
return;
case BuiltInType.Double:
encoder.Write((Double)value);
return;
case BuiltInType.String:
Write(encoder, (String)value);
return;
case BuiltInType.DateTime:
Write(encoder, (DateTime)value);
return;
case BuiltInType.Guid:
encoder.Write((Guid)value);
return;
case BuiltInType.ByteString:
Write(encoder, (byte[])value);
return;
case BuiltInType.XmlElement:
Write(encoder, (XmlElement)value);
return;
case BuiltInType.NodeId:
Write(encoder, (XmlElement)value);
return;
case BuiltInType.ExpandedNodeId:
Write(encoder, (IExpandedNodeId)value);
return;
case BuiltInType.StatusCode:
Write(encoder, (IStatusCode)value);
return;
case BuiltInType.QualifiedName:
Write(encoder, (IQualifiedName)value);
return;
case BuiltInType.LocalizedText:
Write(encoder, (ILocalizedText)value);
return;
case BuiltInType.ExtensionObject:
Write(encoder, (ILocalizedText)value);
return;
case BuiltInType.DataValue:
Write(encoder, (IDataValue)value);
return;
case BuiltInType.Variant:
Write(encoder, (IVariant)value);
return;
case BuiltInType.DiagnosticInfo:
Write(encoder, (IDiagnosticInfo)value);
return;
case BuiltInType.Enumeration:
encoder.Write((int)value);
return;
case BuiltInType.Null:
default:
throw new ArgumentOutOfRangeException($"Cannot encode unknown type in Variant object (0x{builtInType:X2}).");
}
}
/// <summary> /// Writes <see cref="IDataValue" /> using the provided encoder <see cref="IBinaryEncoder" />. /// </summary> /// <param name="encoder">The encoder - an object implementing the <see cref="IBinaryEncoder" /> interface.</param> /// <param name="value">The value to be encoded.</param> public abstract void Write(IBinaryEncoder encoder, IDataValue value);
public override void Write(IBinaryEncoder encoder, ILocalizedText value)
{
throw new NotImplementedException();
}
/// <summary> /// Writes <see cref="ILocalizedText" /> using the provided encoder <see cref="IBinaryEncoder" />. /// </summary> /// <param name="encoder">The encoder - an object implementing the <see cref="IBinaryEncoder" /> interface.</param> /// <param name="value">The value to be encoded.</param> public abstract void Write(IBinaryEncoder encoder, IExtensionObject value);
public override void Write(IBinaryEncoder encoder, IDiagnosticInfo value)
{
throw new NotImplementedException();
}
public void Write(IBinaryEncoder encoder, IExtensionObject value)
{
_encoder.Write(this, value);
}
public override void Write(IBinaryEncoder encoder, XmlElement value)
{
throw new NotImplementedException();
}
/// <summary> /// Writes <see cref="IQualifiedName" /> using the provided encoder <see cref="IBinaryEncoder" />. /// </summary> /// <param name="encoder">The encoder - an object implementing the <see cref="IBinaryEncoder" /> interface.</param> /// <param name="value">The value to be encoded.</param> public abstract void Write(IBinaryEncoder encoder, IQualifiedName value);
public void Write(IBinaryEncoder encoder, ILocalizedText value)
{
Assert.AreSame(this, encoder);
_encoder.Write(this, value);
}
/// <summary> /// Writes <see cref="XmlElement" /> using the provided encoder <see cref="IBinaryEncoder" />. /// </summary> /// <param name="encoder">The encoder - an object implementing the <see cref="IBinaryEncoder" /> interface.</param> /// <param name="value">The value to be encoded.</param> public abstract void Write(IBinaryEncoder encoder, XmlElement value);
public void Write(IBinaryEncoder encoder, IQualifiedName value)
{
Assert.AreSame(this, encoder);
_encoder.Write(this, value);
}
private void EncodeArray(IBinaryEncoder encoder, BuiltInType builtInType, Array value)
{
switch (builtInType)
{
case BuiltInType.Boolean:
EncodeArray <Boolean>(encoder.Write, value, encoder.Write);
break;
case BuiltInType.SByte:
EncodeArray <SByte>(encoder.Write, value, encoder.Write);
break;
case BuiltInType.Byte:
EncodeArray <Byte>(encoder.Write, value, encoder.Write);
break;
case BuiltInType.Int16:
EncodeArray <Int16>(encoder.Write, value, encoder.Write);
break;
case BuiltInType.UInt16:
EncodeArray <UInt16>(encoder.Write, value, encoder.Write);
break;
case BuiltInType.Int32:
case BuiltInType.Enumeration:
EncodeArray <Int32>(encoder.Write, value, encoder.Write);
break;
case BuiltInType.UInt32:
EncodeArray <UInt32>(encoder.Write, value, encoder.Write);
break;
case BuiltInType.Int64:
EncodeArray <Int64>(encoder.Write, value, encoder.Write);
break;
case BuiltInType.UInt64:
EncodeArray <UInt64>(encoder.Write, value, encoder.Write);
break;
case BuiltInType.Float:
EncodeArray <Single>(encoder.Write, value, encoder.Write);
break;
case BuiltInType.Double:
EncodeArray <Double>(encoder.Write, value, encoder.Write);
break;
case BuiltInType.String:
EncodeArray <String>(encoder.Write, value, x => Write(encoder, x));
break;
case BuiltInType.DateTime:
EncodeArray <DateTime>(encoder.Write, value, x => Write(encoder, x));
break;
case BuiltInType.Guid:
EncodeArray <Guid>(encoder.Write, value, x => Write(encoder, x));
break;
case BuiltInType.ByteString:
EncodeArray <Byte[]>(encoder.Write, value, x => Write(encoder, x));
break;
case BuiltInType.XmlElement:
EncodeArray <XmlElement>(encoder.Write, value, x => Write(encoder, x));
break;
case BuiltInType.NodeId:
EncodeArray <INodeId>(encoder.Write, value, x => Write(encoder, x));
break;
case BuiltInType.ExpandedNodeId:
EncodeArray <IExpandedNodeId>(encoder.Write, value, x => Write(encoder, x));
break;
case BuiltInType.StatusCode:
EncodeArray <IStatusCode>(encoder.Write, value, x => Write(encoder, x));
break;
case BuiltInType.QualifiedName:
EncodeArray <IQualifiedName>(encoder.Write, value, x => Write(encoder, x));
break;
case BuiltInType.LocalizedText:
EncodeArray <ILocalizedText>(encoder.Write, value, x => Write(encoder, x));
break;
case BuiltInType.ExtensionObject:
EncodeArray <IExtensionObject>(encoder.Write, value, x => Write(encoder, x));
break;
case BuiltInType.DataValue:
EncodeArray <IDataValue>(encoder.Write, value, x => Write(encoder, x));
break;
case BuiltInType.Variant:
EncodeArray <IVariant>(encoder.Write, value, x => Write(encoder, x));
break;
case BuiltInType.DiagnosticInfo:
EncodeArray <IDiagnosticInfo>(encoder.Write, value, x => Write(encoder, x));
break;
case BuiltInType.Null:
default:
break;
}
;
}
public void Write(IBinaryEncoder encoder, IStatusCode value)
{
Assert.AreSame(this, encoder);
_encoder.Write(this, value);
}
/// <summary>
/// Writes <see cref="DateTime" /> using the provided encoder <see cref="IBinaryEncoder" />.
/// </summary>
/// <param name="encoder">The encoder - an object implementing the <see cref="IBinaryEncoder" /> interface.</param>
/// <param name="value">The value to be encoded.</param>
public virtual void Write(IBinaryEncoder encoder, DateTime value)
{
encoder.Write(CommonDefinitions.GetUADataTimeTicks(value));
}
public void Write(IBinaryEncoder encoder, IVariant value)
{
Assert.AreSame(this, encoder);
_encoder.Write(this, value);
}
