Ejemplo n.º 1
0
        /// <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);
            }
        }
Ejemplo n.º 3
0
        /// <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;
        }
Ejemplo n.º 4
0
 /// <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));
     }
 }
Ejemplo n.º 5
0
        /// <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);
        }
Ejemplo n.º 6
0
 /// <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);
        }
Ejemplo n.º 8
0
        /// <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;
        }
Ejemplo n.º 9
0
        /// <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);
            }
        }
Ejemplo n.º 11
0
        /// <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);
            }
        }
Ejemplo n.º 12
0
 /// <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)
 {
 }
Ejemplo n.º 13
0
 /// <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)
 {
 }
Ejemplo n.º 16
0
 /// <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);
 }
Ejemplo n.º 17
0
 /// <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);
 }