public void ShouldPutInt8(sbyte value, int index)
        {
            _directBuffer.Int8Put(index, value);

            Assert.AreEqual(value, *(sbyte *)(_pBuffer + index));
        }
Example #2
0
        public static int Put(DirectBuffer buffer, PrimitiveValue value, PrimitiveType type)
        {
            if (value == null)
            {
                return 0;
            }

            switch (type.Type)
            {
                case SbePrimitiveType.Char:
                    if (value.Size == 1)
                    {
                        buffer.CharPut(0, (byte)value.LongValue());
                        return 1;
                    }
                    else
                    {
                        var byteArrayValue = value.ByteArrayValue();
                        buffer.SetBytes(0, byteArrayValue, 0, byteArrayValue.Length);
                        return byteArrayValue.Length;
                    }

                case SbePrimitiveType.Int8:
                    buffer.Int8Put(0, (sbyte)value.LongValue());
                    return 1;

                case SbePrimitiveType.Int16:
                    buffer.Int16PutLittleEndian(0, (short)value.LongValue());
                    return 2;

                case SbePrimitiveType.Int32:
                    buffer.Int32PutLittleEndian(0, (int)value.LongValue());
                    return 4;

                case SbePrimitiveType.Int64:
                    buffer.Int64PutLittleEndian(0, value.LongValue());
                    return 8;

                case SbePrimitiveType.UInt8:
                    buffer.Uint8Put(0, (byte)value.LongValue());
                    return 1;

                case SbePrimitiveType.UInt16:
                    buffer.Uint16PutLittleEndian(0, (ushort)value.LongValue());
                    return 2;

                case SbePrimitiveType.UInt32:
                    buffer.Uint32PutLittleEndian(0, (uint) value.LongValue());
                    return 4;

                case SbePrimitiveType.UInt64:
                    buffer.Uint64PutLittleEndian(0, value.ULongValue());
                    return 8;

                case SbePrimitiveType.Float:
                    buffer.FloatPutLittleEndian(0, (float) value.DoubleValue());
                    return 4;

                case SbePrimitiveType.Double:
                    buffer.DoublePutLittleEndian(0, value.DoubleValue());
                    return 8;

                default:
                    return 0;
            }
        }
Example #3
0
        public static int Put(DirectBuffer buffer, PrimitiveValue value, PrimitiveType type)
        {
            if (value == null)
            {
                return(0);
            }

            switch (type.Type)
            {
            case SbePrimitiveType.Char:
                if (value.Size == 1)
                {
                    buffer.CharPut(0, (byte)value.LongValue());
                    return(1);
                }
                else
                {
                    var byteArrayValue = value.ByteArrayValue();
                    buffer.SetBytes(0, byteArrayValue, 0, byteArrayValue.Length);
                    return(byteArrayValue.Length);
                }

            case SbePrimitiveType.Int8:
                buffer.Int8Put(0, (sbyte)value.LongValue());
                return(1);

            case SbePrimitiveType.Int16:
                buffer.Int16PutLittleEndian(0, (short)value.LongValue());
                return(2);

            case SbePrimitiveType.Int32:
                buffer.Int32PutLittleEndian(0, (int)value.LongValue());
                return(4);

            case SbePrimitiveType.Int64:
                buffer.Int64PutLittleEndian(0, value.LongValue());
                return(8);

            case SbePrimitiveType.UInt8:
                buffer.Uint8Put(0, (byte)value.LongValue());
                return(1);

            case SbePrimitiveType.UInt16:
                buffer.Uint16PutLittleEndian(0, (ushort)value.LongValue());
                return(2);

            case SbePrimitiveType.UInt32:
                buffer.Uint32PutLittleEndian(0, (uint)value.LongValue());
                return(4);

            case SbePrimitiveType.UInt64:
                buffer.Uint64PutLittleEndian(0, value.ULongValue());
                return(8);

            case SbePrimitiveType.Float:
                buffer.FloatPutLittleEndian(0, (float)value.DoubleValue());
                return(4);

            case SbePrimitiveType.Double:
                buffer.DoublePutLittleEndian(0, value.DoubleValue());
                return(8);

            default:
                return(0);
            }
        }
        private void SetField(DirectBuffer buffer, SbeField field2, ref int offset)
        {
            SbeField field = field2.Clone();

            if (field.PrimitiveType == null)
            {
                field.PrimitiveType = field.Type;
            }

            if (field.PrimitiveType.ToLower().Equals("uint8"))
            {
                if (!string.IsNullOrEmpty(field.Value))
                {
                    buffer.Uint8Put(offset, (byte)int.Parse(field.Value));
                }
                offset += 1;
            }
            else if (field.PrimitiveType.ToLower().Equals("uint16"))
            {
                if (!string.IsNullOrEmpty(field.Value))
                {
                    buffer.Uint16PutLittleEndian(offset, ushort.Parse(field.Value));
                }
                offset += 2;
            }
            else if (field.PrimitiveType.ToLower().Equals("uint32"))
            {
                if (!string.IsNullOrEmpty(field.Value))
                {
                    buffer.Uint32PutLittleEndian(offset, uint.Parse(field.Value));
                }
                offset += 4;
            }
            else if (field.PrimitiveType.ToLower().Equals("uint64"))
            {
                if (!string.IsNullOrEmpty(field.Value))
                {
                    buffer.Uint64PutLittleEndian(offset, ulong.Parse(field.Value));
                }
                offset += 8;
            }
            else if (field.PrimitiveType.ToLower().Equals("int8"))
            {
                if (!string.IsNullOrEmpty(field.Value))
                {
                    buffer.Int8Put(offset, (sbyte)int.Parse(field.Value));
                }
                offset += 1;
            }
            else if (field.PrimitiveType.ToLower().Equals("int16"))
            {
                if (!string.IsNullOrEmpty(field.Value))
                {
                    buffer.Int16PutLittleEndian(offset, short.Parse(field.Value));
                }
                offset += 2;
            }
            else if (field.PrimitiveType.ToLower().Equals("int32"))
            {
                if (!string.IsNullOrEmpty(field.Value))
                {
                    buffer.Int32PutLittleEndian(offset, int.Parse(field.Value));
                }
                offset += 4;
            }
            else if (field.PrimitiveType.ToLower().Equals("int64"))
            {
                if (!string.IsNullOrEmpty(field.Value))
                {
                    buffer.Int64PutLittleEndian(offset, long.Parse(field.Value));
                }
                offset += 8;
            }
            else if (field.PrimitiveType.ToLower().Equals("char"))
            {
                if (!string.IsNullOrEmpty(field.Value))
                {
                    if (!String.IsNullOrEmpty(field.CharacterEncoding))
                    {
                        byte[] charString = Encoding.GetEncoding(field.CharacterEncoding).GetBytes(field.Value);
                        int    temp       = offset;
                        foreach (byte m in charString)
                        {
                            buffer.CharPut(temp, m);
                            temp++;
                        }
                    }
                    else
                    {
                        byte[] charString = Encoding.GetEncoding("UTF-8").GetBytes(field.Value);
                        buffer.CharPut(offset, charString[0]);
                    }
                }
                offset += field.Length.Value;
            }
        }