| public static WriteUByte ( System.ByteBuffer buffer, byte data ) : void | ||
| buffer | System.ByteBuffer | |
| data | byte | |
| return | void | |
static void Encode(Array value, int width, int encodeSize, ByteBuffer buffer)
{
encodeSize -= FixedWidth.FormatCode + width;
if (width == FixedWidth.UByte)
{
AmqpBitConverter.WriteUByte(buffer, (byte)encodeSize);
AmqpBitConverter.WriteUByte(buffer, (byte)value.Length);
}
else
{
AmqpBitConverter.WriteUInt(buffer, (uint)encodeSize);
AmqpBitConverter.WriteUInt(buffer, (uint)value.Length);
}
if (value.Length > 0)
{
object firstItem = value.GetValue(0);
EncodingBase encoding = AmqpEncoding.GetEncoding(firstItem);
AmqpBitConverter.WriteUByte(buffer, encoding.FormatCode);
if (encoding.FormatCode == FormatCode.Described)
{
DescribedType describedValue = (DescribedType)firstItem;
AmqpEncoding.EncodeObject(describedValue.Descriptor, buffer);
AmqpBitConverter.WriteUByte(buffer, AmqpEncoding.GetEncoding(describedValue.Value).FormatCode);
}
foreach (object item in value)
{
encoding.EncodeObject(item, true, buffer);
}
}
}
internal static void EncodeValue(AmqpSymbol value, FormatCode formatCode, ByteBuffer buffer)
{
int len = value.Value.Length;
if (formatCode == FormatCode.Symbol8)
{
AmqpBitConverter.WriteUByte(buffer, (byte)len);
}
else
{
AmqpBitConverter.WriteUInt(buffer, (uint)len);
}
buffer.Validate(write: true, len);
int bytes = Encoding.ASCII.GetBytes(value.Value, 0, len, buffer.Buffer, buffer.WritePos);
if (bytes != len)
{
throw new AmqpException(new Error()
{
Condition = AmqpErrorCode.InternalError,
Description = "Symbol encoded byte count not equal to its length."
});
}
buffer.Append(len);
}
internal static void Encode(IList value, int count, Type itemType, ByteBuffer buffer)
{
int width;
int encodeSize = ArrayEncoding.GetEncodeSize(value, count, itemType, false, out width);
AmqpBitConverter.WriteUByte(buffer, width == FixedWidth.UByte ? FormatCode.Array8 : FormatCode.Array32);
ArrayEncoding.Encode(value, count, itemType, width, encodeSize, buffer);
}
static void EncodeArray <T>(ByteBuffer buffer, IList <T> array, int count, FormatCode formatCode,
Action <ByteBuffer, T, int> encoder)
{
AmqpBitConverter.WriteUByte(buffer, formatCode);
for (int i = 0; i < count; i++)
{
encoder(buffer, array[i], i);
}
}
public override void EncodeObject(object value, bool arrayEncoding, ByteBuffer buffer)
{
Array array = (Array)value;
int width;
int encodeSize = ArrayEncoding.GetEncodeSize(array, arrayEncoding, out width);
AmqpBitConverter.WriteUByte(buffer, width == FixedWidth.UByte ? FormatCode.Array8 : FormatCode.Array32);
ArrayEncoding.Encode(array, width, encodeSize, buffer);
}
public override void EncodeObject(object value, bool arrayEncoding, ByteBuffer buffer)
{
IList array = (IList)value;
Type itemType = array.Count > 0 ? array[0].GetType() : null;
int width;
int encodeSize = ArrayEncoding.GetEncodeSize(array, array.Count, itemType, arrayEncoding, out width);
AmqpBitConverter.WriteUByte(buffer, width == FixedWidth.UByte ? FormatCode.Array8 : FormatCode.Array32);
ArrayEncoding.Encode(array, array.Count, itemType, width, encodeSize, buffer);
}
public static void Encode(Guid?value, ByteBuffer buffer)
{
if (value.HasValue)
{
AmqpBitConverter.WriteUByte(buffer, FormatCode.Uuid);
AmqpBitConverter.WriteUuid(buffer, value.Value);
}
else
{
AmqpEncoding.EncodeNull(buffer);
}
}
public static void Encode(DateTime?value, ByteBuffer buffer)
{
if (value.HasValue)
{
AmqpBitConverter.WriteUByte(buffer, FormatCode.TimeStamp);
AmqpBitConverter.WriteLong(buffer, TimeStampEncoding.GetMilliseconds(value.Value));
}
else
{
AmqpEncoding.EncodeNull(buffer);
}
}
public static void Encode(decimal?value, ByteBuffer buffer)
{
if (value.HasValue)
{
AmqpBitConverter.WriteUByte(buffer, FormatCode.Decimal128);
DecimalEncoding.EncodeValue(value.Value, buffer);
}
else
{
AmqpEncoding.EncodeNull(buffer);
}
}
public static void Encode(char?value, ByteBuffer buffer)
{
if (value.HasValue)
{
AmqpBitConverter.WriteUByte(buffer, FormatCode.Char);
AmqpBitConverter.WriteInt(buffer, char.ConvertToUtf32(new string(value.Value, 1), 0));
}
else
{
AmqpEncoding.EncodeNull(buffer);
}
}
public static void Encode(DateTime?value, ByteBuffer buffer)
{
if (value.HasValue)
{
AmqpBitConverter.WriteUByte(buffer, FormatCode.TimeStamp);
AmqpBitConverter.WriteTimestamp(buffer, value.Value);
}
else
{
AmqpEncoding.EncodeNull(buffer);
}
}
static void Encode(byte[] encodedData, int width, ByteBuffer buffer)
{
if (width == FixedWidth.UByte)
{
AmqpBitConverter.WriteUByte(buffer, (byte)encodedData.Length);
}
else
{
AmqpBitConverter.WriteUInt(buffer, (uint)encodedData.Length);
}
AmqpBitConverter.WriteBytes(buffer, encodedData, 0, encodedData.Length);
}
public static void Encode(string value, ByteBuffer buffer)
{
if (value == null)
{
AmqpEncoding.EncodeNull(buffer);
}
else
{
byte[] encodedData = Encoding.UTF8.GetBytes(value);
int encodeWidth = AmqpEncoding.GetEncodeWidthBySize(encodedData.Length);
AmqpBitConverter.WriteUByte(buffer, encodeWidth == FixedWidth.UByte ? FormatCode.String8Utf8 : FormatCode.String32Utf8);
StringEncoding.Encode(encodedData, encodeWidth, buffer);
}
}
public static void Encode <T>(T[] value, ByteBuffer buffer)
{
if (value == null)
{
AmqpEncoding.EncodeNull(buffer);
}
else
{
int width;
int encodeSize = ArrayEncoding.GetEncodeSize(value, false, out width);
AmqpBitConverter.WriteUByte(buffer, width == FixedWidth.UByte ? FormatCode.Array8 : FormatCode.Array32);
ArrayEncoding.Encode(value, width, encodeSize, buffer);
}
}
public static void Encode(AmqpSymbol value, ByteBuffer buffer)
{
if (value.Value == null)
{
AmqpEncoding.EncodeNull(buffer);
}
else
{
byte[] encodedData = Encoding.ASCII.GetBytes(value.Value);
int encodeWidth = AmqpEncoding.GetEncodeWidthBySize(encodedData.Length);
AmqpBitConverter.WriteUByte(buffer, encodeWidth == FixedWidth.UByte ? FormatCode.Symbol8 : FormatCode.Symbol32);
SymbolEncoding.Encode(encodedData, encodeWidth, buffer);
}
}
public static void Encode(AmqpMap value, ByteBuffer buffer)
{
if (value == null)
{
AmqpEncoding.EncodeNull(buffer);
}
else
{
int encodeWidth = MapEncoding.GetEncodeWidth(value);
AmqpBitConverter.WriteUByte(buffer, encodeWidth == FixedWidth.UByte ? FormatCode.Map8 : FormatCode.Map32);
int size = encodeWidth + value.ValueSize;
MapEncoding.Encode(value, encodeWidth, size, buffer);
}
}
internal static void Encode(IList value, int count, Type itemType, int width, int encodeSize, ByteBuffer buffer)
{
encodeSize -= FixedWidth.FormatCode + width;
if (width == FixedWidth.UByte)
{
AmqpBitConverter.WriteUByte(buffer, (byte)encodeSize);
AmqpBitConverter.WriteUByte(buffer, (byte)count);
}
else
{
AmqpBitConverter.WriteUInt(buffer, (uint)encodeSize);
AmqpBitConverter.WriteUInt(buffer, (uint)count);
}
EncodeValue(value, count, itemType, buffer);
}
public static void Encode(IList value, ByteBuffer buffer)
{
if (value == null)
{
AmqpEncoding.EncodeNull(buffer);
}
else if (value.Count == 0)
{
AmqpBitConverter.WriteUByte(buffer, FormatCode.List0);
}
else
{
int valueSize = ListEncoding.GetValueSize(value);
int width = AmqpEncoding.GetEncodeWidthByCountAndSize(value.Count, valueSize);
AmqpBitConverter.WriteUByte(buffer, width == FixedWidth.UByte ? FormatCode.List8 : FormatCode.List32);
int size = width + valueSize;
ListEncoding.Encode(value, width, size, buffer);
}
}
static void Encode(IList value, int width, int size, ByteBuffer buffer)
{
if (width == FixedWidth.UByte)
{
AmqpBitConverter.WriteUByte(buffer, (byte)size);
AmqpBitConverter.WriteUByte(buffer, (byte)value.Count);
}
else
{
AmqpBitConverter.WriteUInt(buffer, (uint)size);
AmqpBitConverter.WriteUInt(buffer, (uint)value.Count);
}
if (value.Count > 0)
{
foreach (object item in value)
{
AmqpEncoding.EncodeObject(item, buffer);
}
}
}
static void Encode(AmqpMap value, int width, int size, ByteBuffer buffer)
{
if (width == FixedWidth.UByte)
{
AmqpBitConverter.WriteUByte(buffer, (byte)size);
AmqpBitConverter.WriteUByte(buffer, (byte)(value.Count * 2));
}
else
{
AmqpBitConverter.WriteUInt(buffer, (uint)size);
AmqpBitConverter.WriteUInt(buffer, (uint)(value.Count * 2));
}
if (value.Count > 0)
{
foreach (KeyValuePair <MapKey, object> item in value)
{
AmqpEncoding.EncodeObject(item.Key.Key, buffer);
AmqpEncoding.EncodeObject(item.Value, buffer);
}
}
}
public static void Encode(ArraySegment <byte> value, ByteBuffer buffer)
{
if (value.Array == null)
{
AmqpEncoding.EncodeNull(buffer);
}
else
{
int width = AmqpEncoding.GetEncodeWidthBySize(value.Count);
if (width == FixedWidth.UByte)
{
AmqpBitConverter.WriteUByte(buffer, FormatCode.Binary8);
AmqpBitConverter.WriteUByte(buffer, (byte)value.Count);
}
else
{
AmqpBitConverter.WriteUByte(buffer, FormatCode.Binary32);
AmqpBitConverter.WriteUInt(buffer, (uint)value.Count);
}
AmqpBitConverter.WriteBytes(buffer, value.Array, value.Offset, value.Count);
}
}
internal static void Encode(AmqpSymbol value, FormatCode formatCode, ByteBuffer buffer)
{
AmqpBitConverter.WriteUByte(buffer, formatCode);
EncodeValue(value, formatCode, buffer);
}
internal static void EncodeValue(IList value, int count, Type itemType, ByteBuffer buffer)
{
if (count == 0)
{
return;
}
EncodingBase encoding = AmqpEncoding.GetEncoding(itemType);
switch (encoding.FormatCode)
{
case FormatCode.UInt:
EncodeArray <uint>(buffer, (IList <uint>)value, count, FormatCode.UInt, (b, v, i) => AmqpBitConverter.WriteUInt(b, v));
return;
case FormatCode.Int:
buffer.Validate(true, FixedWidth.Int * count);
EncodeArray <int>(buffer, (IList <int>)value, count, FormatCode.Int, (b, v, i) =>
{
AmqpBitConverter.WriteInt(b.Buffer, b.WritePos + i * FixedWidth.Int, v);
});
buffer.Append(FixedWidth.Int * count);
return;
case FormatCode.ULong:
EncodeArray <ulong>(buffer, (IList <ulong>)value, count, FormatCode.ULong, (b, v, i) => AmqpBitConverter.WriteULong(b, v));
return;
case FormatCode.Long:
EncodeArray <long>(buffer, (IList <long>)value, count, FormatCode.Long, (b, v, i) => AmqpBitConverter.WriteLong(b, v));
return;
case FormatCode.Symbol32:
EncodeArray <AmqpSymbol>(buffer, (IList <AmqpSymbol>)value, count, FormatCode.Symbol32, (b, v, i) => SymbolEncoding.EncodeValue(v, FormatCode.Symbol32, b));
return;
case FormatCode.Boolean:
EncodeArray <bool>(buffer, (IList <bool>)value, count, FormatCode.Boolean, (b, v, i) => AmqpBitConverter.WriteUByte(b, (byte)(v ? 1 : 0)));
return;
case FormatCode.UByte:
EncodeArray <byte>(buffer, (IList <byte>)value, count, FormatCode.UByte, (b, v, i) => AmqpBitConverter.WriteUByte(b, v));
return;
case FormatCode.Byte:
EncodeArray <sbyte>(buffer, (IList <sbyte>)value, count, FormatCode.Byte, (b, v, i) => AmqpBitConverter.WriteByte(b, v));
return;
case FormatCode.UShort:
EncodeArray <ushort>(buffer, (IList <ushort>)value, count, FormatCode.UShort, (b, v, i) => AmqpBitConverter.WriteUShort(b, v));
return;
case FormatCode.Short:
EncodeArray <short>(buffer, (IList <short>)value, count, FormatCode.Short, (b, v, i) => AmqpBitConverter.WriteShort(b, v));
return;
case FormatCode.Float:
EncodeArray <float>(buffer, (IList <float>)value, count, FormatCode.Float, (b, v, i) => AmqpBitConverter.WriteFloat(b, v));
return;
case FormatCode.Double:
EncodeArray <double>(buffer, (IList <double>)value, count, FormatCode.Double, (b, v, i) => AmqpBitConverter.WriteDouble(b, v));
return;
case FormatCode.Decimal128:
EncodeArray <decimal>(buffer, (IList <decimal>)value, count, FormatCode.Decimal128, (b, v, i) => DecimalEncoding.EncodeValue(v, b));
return;
case FormatCode.Char:
EncodeArray <char>(buffer, (IList <char>)value, count, FormatCode.Char, (b, v, i) => AmqpBitConverter.WriteChar(b, v));
return;
case FormatCode.TimeStamp:
EncodeArray <DateTime>(buffer, (IList <DateTime>)value, count, FormatCode.TimeStamp, (b, v, i) => AmqpBitConverter.WriteTimestamp(b, v));
return;
case FormatCode.Uuid:
EncodeArray <Guid>(buffer, (IList <Guid>)value, count, FormatCode.Uuid, (b, v, i) => AmqpBitConverter.WriteUuid(b, v));
return;
default:
break;
}
object firstItem = value[0];
AmqpBitConverter.WriteUByte(buffer, encoding.FormatCode);
if (encoding.FormatCode == FormatCode.Described)
{
DescribedType describedValue = (DescribedType)firstItem;
AmqpEncoding.EncodeObject(describedValue.Descriptor, buffer);
AmqpBitConverter.WriteUByte(buffer, AmqpEncoding.GetEncoding(describedValue.Value).FormatCode);
}
for (int i = 0; i < count; i++)
{
encoding.EncodeObject(value[i], true, buffer);
}
}
public static void EncodeNull(ByteBuffer buffer)
{
AmqpBitConverter.WriteUByte(buffer, FormatCode.Null);
}
