/// <summary>
/// Formats the specified field.
/// </summary>
/// <param name="field">
/// It's the field to format.
/// </param>
/// <param name="formatterContext">
/// It's the context of formatting to be used by the method.
/// </param>
public override void Format(Field field,
ref FormatterContext formatterContext)
{
if (!(field is BinaryField))
{
throw new ArgumentException(
SR.BinaryMessageFieldExpected, "field");
}
if ((field == null) | (field.GetBytes() == null))
{
_lengthManager.WriteLength(field, 0, 0, ref formatterContext);
_lengthManager.WriteLengthTrailer(field, 0, 0, ref formatterContext);
}
else
{
_lengthManager.WriteLength(field, field.GetBytes().Length,
_encoder.GetEncodedLength(field.GetBytes().Length),
ref formatterContext);
_encoder.Encode(field.GetBytes(), ref formatterContext);
_lengthManager.WriteLengthTrailer(field, field.GetBytes().Length,
_encoder.GetEncodedLength(field.GetBytes().Length),
ref formatterContext);
}
}
/// <summary>
/// Formats the specified field.
/// </summary>
/// <param name="field">
/// It's the field to format.
/// </param>
/// <param name="formatterContext">
/// It's the context of formatting to be used by the method.
/// </param>
public override void Format(Field field,
ref FormatterContext formatterContext)
{
if (!(field is InnerMessageField))
{
throw new ArgumentException(
SR.InnerMessageFieldExpected, "field");
}
Message message = null;
if (field != null)
{
message = field.Value as Message;
}
if (message == null)
{
_lengthManager.WriteLength(field, 0, 0, ref formatterContext);
_lengthManager.WriteLengthTrailer(field, 0, 0, ref formatterContext);
}
else
{
message.Formatter = _messageFormatter;
byte[] data = message.GetBytes();
_lengthManager.WriteLength(field, data.Length,
_encoder.GetEncodedLength(data.Length), ref formatterContext);
_encoder.Encode(data, ref formatterContext);
_lengthManager.WriteLengthTrailer(field, data.Length,
_encoder.GetEncodedLength(data.Length), ref formatterContext);
}
}
/// <summary>
/// It formats the length of the data of the messaging components.
/// </summary>
/// <param name="length">
/// It's the length to format.
/// </param>
/// <param name="formatterContext">
/// It's the formatter context to store the formatted length.
/// </param>
/// <exception cref="ArgumentOutOfRangeException">
/// It's thrown when <paramref name="length"/> is greater than the
/// maximum value supported by the instance.
/// </exception>
public void Encode(int length, ref FormatterContext formatterContext)
{
if (length > _lengths[_lengthsIndex])
{
throw new ArgumentOutOfRangeException("length", length,
SR.LessOrEqualToN(_lengths[_lengthsIndex]));
}
// Check if we must resize our buffer.
if (formatterContext.FreeBufferSpace < (_lengthsIndex + 1))
{
formatterContext.ResizeBuffer(_lengthsIndex + 1);
}
byte[] buffer = formatterContext.GetBuffer();
// Write encoded length.
for (int i = formatterContext.UpperDataBound + _lengthsIndex;
i >= formatterContext.UpperDataBound; i--)
{
buffer[i] = ( byte)(length % 256);
length /= 256;
}
// Update formatter context upper data bound.
formatterContext.UpperDataBound += _lengthsIndex + 1;
}
/// <summary>
/// Escribe el largo de los datos del campo en el contexto de
/// formateo del mensaje.
/// </summary>
/// <param name="component">
/// Es el componente de mensajería del que se está escribiendo
/// el largo de sus datos.
/// </param>
/// <param name="dataLength">
/// Es el largo de los datos del componente (puede diferir del largo
/// de los datos obtenidos de <paramref name="component"/>, pues pueden
/// estar rellenados)
/// </param>
/// <param name="encodedLength">
/// Es el largo de los datos codificados.
/// </param>
/// <param name="formatterContext">
/// Es el contexto de formateo del mensaje.
/// </param>
/// <exception cref="MessagingException">
/// El largo de los datos no concuerda con el largo conocido por
/// este administrador.
/// </exception>
public override void WriteLength(MessagingComponent component,
int dataLength, int encodedLength, ref FormatterContext formatterContext)
{
if (dataLength != MaximumLength)
{
throw new ArgumentOutOfRangeException("dataLength", dataLength,
SR.InsufficientDataMoreIsRequired(MaximumLength));
}
}
/// <summary>
/// Formatea un mapa de bits.
/// </summary>
/// <param name="field">
/// Es el campo a formatear.
/// </param>
/// <param name="formatterContext">
/// Es el contexto de formateo que debe ser empleado.
/// </param>
public override void Format(Field field,
ref FormatterContext formatterContext)
{
if (!(field is BitMapField))
{
throw new ArgumentException(SR.FieldMustBeABitmap, "field");
}
_encoder.Encode((( BitMapField)field).GetBytes(), ref formatterContext);
}
/// <summary>
/// Convierte a un array de bytes los datos del mensaje.
/// </summary>
/// <returns>
/// Un array de bytes.
/// </returns>
public override byte[] GetBytes()
{
byte[] data = null;
if (_formatter != null)
{
FormatterContext formatterContext = new FormatterContext(FormatterContext.DefaultBufferSize);
_formatter.Format(this, ref formatterContext);
data = formatterContext.GetData();
}
return(data);
}
/// <summary>
/// Escribe el largo de los datos del campo en el contexto de
/// formateo del mensaje.
/// </summary>
/// <param name="component">
/// Es el componente de mensajería del que se está escribiendo
/// el largo de sus datos.
/// </param>
/// <param name="dataLength">
/// Es el largo de los datos del componente (puede diferir del largo
/// de los datos obtenidos de <paramref name="component"/>, pues pueden
/// estar rellenados)
/// </param>
/// <param name="encodedLength">
/// Es el largo de los datos codificados.
/// </param>
/// <param name="formatterContext">
/// Es el contexto de formateo del mensaje.
/// </param>
public override void WriteLength(MessagingComponent component,
int dataLength, int encodedLength, ref FormatterContext formatterContext)
{
if ((dataLength < _minimumLength) ||
(dataLength > MaximumLength))
{
throw new ArgumentOutOfRangeException("dataLength", dataLength,
SR.Between(_minimumLength, MaximumLength));
}
_lengthEncoder.Encode(dataLength, ref formatterContext);
}
/// <summary>
/// It encodes the given data.
/// </summary>
/// <param name="data">
/// It's the data to encode.
/// </param>
/// <param name="formatterContext">
/// It's the formatter context to store the encoded data.
/// </param>
public void Encode(byte[] data, ref FormatterContext formatterContext)
{
int length = (data.Length + 1) >> 1;
// Check if we must resize formatter context buffer.
if (formatterContext.FreeBufferSpace < length)
{
formatterContext.ResizeBuffer(length);
}
byte[] buffer = formatterContext.GetBuffer();
int offset = formatterContext.UpperDataBound;
// Initialize result bytes.
for (int i = offset + length - 1; i >= offset; i--)
{
buffer[i] = 0;
}
// Format data.
int start = (((data.Length & 1) == 1) && _leftPadded) ? 1 : 0;
for (int i = start; i < (start + data.Length); i++)
{
if (data[i - start] < 0x40)
{
buffer[offset + (i >> 1)] |= ( byte)(((data[i - start]) - 0x30) <<
((i & 1) == 1 ? 0 : 4));
}
else
{
buffer[offset + (i >> 1)] |= ( byte)(((data[i - start]) - 0x37) <<
((i & 1) == 1 ? 0 : 4));
}
}
// Pad if required.
if ((_pad >= 0) && (data.Length & 1) == 1)
{
if (_leftPadded)
{
buffer[offset] |= ( byte)(_pad << 4);
}
else
{
buffer[offset + length - 1] |= ( byte)(0x0F & _pad);
}
}
formatterContext.UpperDataBound += length;
}
/// <summary>
/// It encodes the given data.
/// </summary>
/// <param name="data">
/// It's the data to encode.
/// </param>
/// <param name="formatterContext">
/// It's the formatter context to store the encoded data.
/// </param>
public void Encode(byte[] data, ref FormatterContext formatterContext)
{
// Check if we must resize formatter context buffer.
if (formatterContext.FreeBufferSpace < (data.Length << 1))
{
formatterContext.ResizeBuffer(data.Length << 1);
}
byte[] buffer = formatterContext.GetBuffer();
int offset = formatterContext.UpperDataBound;
// Format data.
for (int i = 0; i < data.Length; i++)
{
buffer[offset + (i << 1)] = HexadecimalAsciiDigits[(data[i] & 0xF0) >> 4];
buffer[offset + (i << 1) + 1] = HexadecimalAsciiDigits[data[i] & 0x0F];
}
formatterContext.UpperDataBound += data.Length << 1;
}
/// <summary>
/// Formatea un campo cuyo valor es una cadena de caracteres.
/// </summary>
/// <param name="header">
/// Es el cabezal a formatear.
/// </param>
/// <param name="formatterContext">
/// Es el contexto de formateo que debe ser empleado.
/// </param>
public virtual void Format(MessageHeader header,
ref FormatterContext formatterContext)
{
string headerValue = null;
if (header != null)
{
if (!(header is StringMessageHeader))
{
throw new ArgumentException(SR.StringHeaderExpected, "header");
}
headerValue = (( StringMessageHeader)header).Value;
}
// Pad if padding available.
if (_padding != null)
{
headerValue = _padding.Pad(headerValue,
_lengthManager.MaximumLength);
}
if (headerValue == null)
{
_lengthManager.WriteLength(header, 0, 0, ref formatterContext);
_lengthManager.WriteLengthTrailer(header, 0, 0, ref formatterContext);
}
else
{
_lengthManager.WriteLength(header, headerValue.Length,
_encoder.GetEncodedLength(headerValue.Length),
ref formatterContext);
_encoder.Encode(headerValue, ref formatterContext);
_lengthManager.WriteLengthTrailer(header, headerValue.Length,
_encoder.GetEncodedLength(headerValue.Length),
ref formatterContext);
}
}
/// <summary>
/// Formatea un campo cuyo valor es una cadena de caracteres.
/// </summary>
/// <param name="field">
/// Es el campo a formatear.
/// </param>
/// <param name="formatterContext">
/// Es el contexto de formateo que debe ser empleado.
/// </param>
public override void Format(Field field,
ref FormatterContext formatterContext)
{
if (!(field is StringField))
{
throw new ArgumentException(SR.StringMessageFieldExpected, "field");
}
string fieldValue = (( StringField)field).FieldValue;
// Pad if padding available.
if (_padding != null)
{
fieldValue = _padding.Pad(fieldValue, _lengthManager.MaximumLength);
}
if (_validator != null)
{
_validator.Validate(fieldValue);
}
if (fieldValue == null)
{
_lengthManager.WriteLength(field, 0, 0, ref formatterContext);
_lengthManager.WriteLengthTrailer(field, 0, 0, ref formatterContext);
}
else
{
_lengthManager.WriteLength(field, fieldValue.Length,
_encoder.GetEncodedLength(fieldValue.Length),
ref formatterContext);
_encoder.Encode(fieldValue, ref formatterContext);
_lengthManager.WriteLengthTrailer(field, fieldValue.Length,
_encoder.GetEncodedLength(fieldValue.Length),
ref formatterContext);
}
}
/// <summary>
/// Escribe el largo de los datos del campo en el contexto de
/// formateo del mensaje.
/// </summary>
/// <param name="component">
/// Es el componente de mensajería del que se está escribiendo
/// el largo de sus datos.
/// </param>
/// <param name="dataLength">
/// Es el largo de los datos del componente (puede diferir del largo
/// de los datos obtenidos de <paramref name="component"/>, pues pueden
/// estar rellenados)
/// </param>
/// <param name="encodedLength">
/// Es el largo de los datos codificados.
/// </param>
/// <param name="formatterContext">
/// Es el contexto de formateo del mensaje.
/// </param>
public virtual void WriteLength(MessagingComponent component,
int dataLength, int encodedLength, ref FormatterContext formatterContext)
{
}
/// <summary> /// Formats the specified field. /// </summary> /// <param name="field"> /// It's the field to format. /// </param> /// <param name="formatterContext"> /// It's the context of formatting to be used by the method. /// </param> public abstract void Format(Field field, ref FormatterContext formatterContext);
/// <summary>
/// It formats a message.
/// </summary>
/// <param name="message">
/// It's the message to be formatted.
/// </param>
/// <param name="formatterContext">
/// It's the formatter context to be used in the format.
/// </param>
public virtual void Format(Message message,
ref FormatterContext formatterContext)
{
formatterContext.CurrentMessage = message;
// Write header.
if (_packetHeader != null)
{
formatterContext.Write(_packetHeader);
}
// Format header if we have one header formatter.
if (_headerFormatter != null)
{
try {
_headerFormatter.Format(message.Header, ref formatterContext);
} catch (Exception e) {
throw new MessagingException(SR.CantFormatMessageHeader, e);
}
}
// Allow subclasses to put information between header data and
// fields data.
BeforeFieldsFormatting(message, ref formatterContext);
// If bitmaps are present in the message formatter, check if we
// must add them to the message.
bool atLeastOne = false;
int firstBitmap = -1;
for (int i = _bitmaps.Length - 1; (i >= 0) && (_bitmaps[i] >= 0); i--)
{
firstBitmap = i;
if (message.Fields.Contains(_bitmaps[i]))
{
// Check if present field is a bitmap.
if (!(message[_bitmaps[i]] is BitMapField))
{
throw new MessagingException(SR.FieldMustBeBitmap(_bitmaps[i]));
}
atLeastOne = true;
}
else
{
// Get bitmap from field formatters collection.
BitMapFieldFormatter bitmap =
( BitMapFieldFormatter)_fieldsFormatters[_bitmaps[i]];
// Add bitmap to message if required.
if (message.Fields.ContainsAtLeastOne(bitmap.LowerFieldNumber,
bitmap.UpperFieldNumber))
{
message.Fields.Add(new BitMapField(bitmap.FieldNumber,
bitmap.LowerFieldNumber, bitmap.UpperFieldNumber));
atLeastOne = true;
}
}
}
if (!atLeastOne && firstBitmap > -1)
{
// In a bitmaped message, at least the first bitmap must be present.
BitMapFieldFormatter bitmap = ( BitMapFieldFormatter )_fieldsFormatters[_bitmaps[firstBitmap]];
message.Fields.Add(new BitMapField(bitmap.FieldNumber,
bitmap.LowerFieldNumber, bitmap.UpperFieldNumber));
}
// Correct bitmap values.
message.CorrectBitMapsValues();
// Format fields.
for (int i = 0; i <= message.Fields.MaximumFieldNumber; i++)
{
if (message.Fields.Contains(i))
{
// If we haven't the field formatter, throw an exception.
if (!_fieldsFormatters.Contains(i))
{
throw new MessagingException(SR.UnknownFieldFormatter(i));
}
// Set parent message.
if (message.Fields[i] is InnerMessageField)
{
InnerMessageField innerMessageField = message.Fields[i] as InnerMessageField;
if (innerMessageField != null)
{
Message innerMessage = innerMessageField.Value as Message;
if (innerMessage != null)
{
innerMessage.Parent = message;
}
}
}
try {
_fieldsFormatters[i].Format(message.Fields[i],
ref formatterContext);
} catch (Exception e) {
throw new MessagingException(SR.CantFormatField(i), e);
}
}
}
}
/// <summary>
/// Invocado por <see cref="Format"/> para permitir a las clases que
/// extienden <see cref="BasicMessageFormatter"/>, operar entre el
/// formateo del cabezal del mensaje que está siendo formateado, y
/// sus campos.
/// </summary>
/// <param name="message">
/// Es el mensaje que se está formateando.
/// </param>
/// <param name="formatterContext">
/// Es el contexto de formateo que debe está siendo empleado.
/// </param>
/// <remarks>
/// Sobreescriba este método si necesita por ejemplo, agregar
/// información en el contexto de formateo entre la información
/// del cabezal y los campos.
/// </remarks>
public virtual void BeforeFieldsFormatting(Message message,
ref FormatterContext formatterContext)
{
}
/// <summary>
/// Formatea los datos del componente de mensajería.
/// </summary>
/// <param name="data">
/// Son los datos del componente de mensajería.
/// </param>
/// <param name="formatterContext">
/// Es el contexto de formateo donde se almacenará la
/// información formateada.
/// </param>
public void Encode(string data, ref FormatterContext formatterContext)
{
formatterContext.Write(data);
}
/// <summary>
/// Formatea los datos del componente de mensajería.
/// </summary>
/// <param name="data">
/// Son los datos del componente de mensajería.
/// </param>
/// <param name="formatterContext">
/// Es el contexto de formateo donde se almacenará la
/// información formateada.
/// </param>
public void Encode(byte[] data, ref FormatterContext formatterContext)
{
formatterContext.Write(data);
}
