public static IList Decode(ByteBuffer buffer, FormatCode formatCode)
{
if (formatCode == 0 && (formatCode = AmqpEncoding.ReadFormatCode(buffer)) == FormatCode.Null)
{
return null;
}
IList list = new List<object>();
if (formatCode == FormatCode.List0)
{
return list;
}
int size = 0;
int count = 0;
AmqpEncoding.ReadSizeAndCount(buffer, formatCode, FormatCode.List8, FormatCode.List32, out size, out count);
for (; count > 0; --count)
{
object item = AmqpEncoding.DecodeObject(buffer);
list.Add(item);
}
return list;
}
public static string Decode(ByteBuffer buffer, FormatCode formatCode)
{
if (formatCode == 0 && (formatCode = AmqpEncoding.ReadFormatCode(buffer)) == FormatCode.Null)
{
return null;
}
int count = 0;
Encoding encoding = null;
if (formatCode == FormatCode.String8Utf8)
{
count = (int)AmqpBitConverter.ReadUByte(buffer);
encoding = Encoding.UTF8;
}
else if (formatCode == FormatCode.String32Utf8)
{
count = (int)AmqpBitConverter.ReadUInt(buffer);
encoding = Encoding.UTF8;
}
else
{
throw AmqpEncoding.GetInvalidFormatCodeException(formatCode, buffer.Offset);
}
ArraySegment<byte> bytes = buffer.GetBytes(count);
return encoding.GetString(bytes.Array, bytes.Offset, count);
}
public static void VerifyFormatCode(FormatCode formatCode, FormatCode expected, int offset)
{
if (formatCode != expected)
{
throw AmqpEncoding.GetInvalidFormatCodeException(formatCode, offset);
}
}
public static ushort? Decode(ByteBuffer buffer, FormatCode formatCode)
{
if (formatCode == 0 && (formatCode = AmqpEncoding.ReadFormatCode(buffer)) == FormatCode.Null)
{
return null;
}
return AmqpBitConverter.ReadUShort(buffer);
}
public static decimal? Decode(ByteBuffer buffer, FormatCode formatCode)
{
if (formatCode == 0 && (formatCode = AmqpEncoding.ReadFormatCode(buffer)) == FormatCode.Null)
{
return null;
}
return DecimalEncoding.DecodeValue(buffer, formatCode);
}
public override object DecodeObject(ByteBuffer buffer, FormatCode formatCode)
{
if (formatCode == FormatCode.Described)
{
return DescribedEncoding.Decode(buffer, formatCode);
}
else
{
return AmqpEncoding.DecodeObject(buffer, formatCode);
}
}
static DescribedType Decode(ByteBuffer buffer, FormatCode formatCode)
{
if (formatCode != FormatCode.Described)
{
throw AmqpEncoding.GetInvalidFormatCodeException(formatCode, buffer.Offset);
}
object descriptor = AmqpEncoding.DecodeObject(buffer);
object value = AmqpEncoding.DecodeObject(buffer);
return new DescribedType(descriptor, value);
}
public static DateTime? Decode(ByteBuffer buffer, FormatCode formatCode)
{
if (formatCode == 0 && (formatCode = AmqpEncoding.ReadFormatCode(buffer)) == FormatCode.Null)
{
return null;
}
long millSeconds = AmqpBitConverter.ReadLong(buffer);
DateTime dt = AmqpConstants.StartOfEpoch + TimeSpan.FromMilliseconds(millSeconds);
return dt;
}
public static long? Decode(ByteBuffer buffer, FormatCode formatCode)
{
if (formatCode == 0 && (formatCode = AmqpEncoding.ReadFormatCode(buffer)) == FormatCode.Null)
{
return null;
}
VerifyFormatCode(formatCode, buffer.Offset, FormatCode.Long, FormatCode.SmallLong);
return formatCode == FormatCode.SmallLong ?
AmqpBitConverter.ReadByte(buffer) :
AmqpBitConverter.ReadLong(buffer);
}
public static AmqpSymbol Decode(ByteBuffer buffer, FormatCode formatCode)
{
if (formatCode == 0 && (formatCode = AmqpEncoding.ReadFormatCode(buffer)) == FormatCode.Null)
{
return new AmqpSymbol();
}
int count = 0;
AmqpEncoding.ReadCount(buffer, formatCode, FormatCode.Symbol8, FormatCode.Symbol32, out count);
ArraySegment<byte> bytes = buffer.GetBytes(count);
return Encoding.ASCII.GetString(bytes.Array, bytes.Offset, count);
}
public static int? Decode(ByteBuffer buffer, FormatCode formatCode)
{
if (formatCode == 0 && (formatCode = AmqpEncoding.ReadFormatCode(buffer)) == FormatCode.Null)
{
return null;
}
VerifyFormatCode(formatCode, buffer.Offset, FormatCode.Int, FormatCode.SmallInt);
return formatCode == FormatCode.SmallInt ?
AmqpBitConverter.ReadByte(buffer) :
AmqpBitConverter.ReadInt(buffer);
}
public static ArraySegment<byte> Decode(ByteBuffer buffer, FormatCode formatCode)
{
if (formatCode == 0 && (formatCode = AmqpEncoding.ReadFormatCode(buffer)) == FormatCode.Null)
{
return AmqpConstants.EmptyBinary;
}
int count;
AmqpEncoding.ReadCount(buffer, formatCode, FormatCode.Binary8, FormatCode.Binary32, out count);
ArraySegment<byte> value = new ArraySegment<byte>(buffer.Buffer, buffer.Offset, count);
buffer.Complete(count);
return value;
}
public static AmqpMap Decode(ByteBuffer buffer, FormatCode formatCode)
{
if (formatCode == 0 && (formatCode = AmqpEncoding.ReadFormatCode(buffer)) == FormatCode.Null)
{
return null;
}
int size = 0;
int count = 0;
AmqpEncoding.ReadSizeAndCount(buffer, formatCode, FormatCode.Map8, FormatCode.Map32, out size, out count);
AmqpMap map = new AmqpMap();
MapEncoding.ReadMapValue(buffer, map, size, count);
return map;
}
public static bool? Decode(ByteBuffer buffer, FormatCode formatCode)
{
if (formatCode == 0 && (formatCode = AmqpEncoding.ReadFormatCode(buffer)) == FormatCode.Null)
{
return null;
}
VerifyFormatCode(formatCode, buffer.Offset, FormatCode.Boolean, FormatCode.BooleanFalse, FormatCode.BooleanTrue);
if (formatCode == FormatCode.Boolean)
{
return AmqpBitConverter.ReadUByte(buffer) != 0;
}
else
{
return formatCode == FormatCode.BooleanTrue ? true : false;
}
}
public static void VerifyFormatCode(FormatCode formatCode, int offset, params FormatCode[] expected)
{
bool valid = false;
foreach (FormatCode code in expected)
{
if (formatCode == code)
{
valid = true;
break;
}
}
if (!valid)
{
throw AmqpEncoding.GetInvalidFormatCodeException(formatCode, offset);
}
}
public static ulong? Decode(ByteBuffer buffer, FormatCode formatCode)
{
if (formatCode == 0 && (formatCode = AmqpEncoding.ReadFormatCode(buffer)) == FormatCode.Null)
{
return null;
}
VerifyFormatCode(formatCode, buffer.Offset, FormatCode.ULong, FormatCode.SmallULong, FormatCode.ULong0);
if (formatCode == FormatCode.ULong0)
{
return 0;
}
else
{
return formatCode == FormatCode.SmallULong ?
AmqpBitConverter.ReadUByte(buffer) :
AmqpBitConverter.ReadULong(buffer);
}
}
static decimal DecodeValue(ByteBuffer buffer, FormatCode formatCode)
{
decimal value = 0;
switch (formatCode)
{
case FormatCode.Decimal32:
value = DecimalEncoding.DecodeDecimal32(buffer);
break;
case FormatCode.Decimal64:
value = DecimalEncoding.DecodeDecimal64(buffer);
break;
case FormatCode.Decimal128:
value = DecimalEncoding.DecodeDecimal128(buffer);
break;
default:
throw AmqpEncoding.GetInvalidFormatCodeException(formatCode, buffer.Offset);
};
return value;
}
/// <summary>
/// Assuming the trace header has been read, reads the array of sample values
/// </summary>
public virtual IList<float> ReadTrace(BinaryReader reader, FormatCode sampleFormat, int sampleCount, bool isLittleEndian)
{
var trace = new float[sampleCount];
try
{
for (int i = 0; i < sampleCount; i++)
{
switch (sampleFormat)
{
case FormatCode.IbmFloatingPoint4:
trace[i] = reader.ReadSingleIbm();
break;
case FormatCode.IeeeFloatingPoint4:
trace[i] = reader.ReadSingle();
break;
case FormatCode.TwosComplementInteger2:
trace[i] = isLittleEndian ?
reader.ReadInt16() :
reader.ReadInt16BigEndian();
break;
default:
throw new NotSupportedException(
String.Format("Unsupported sample format: {0}. Send an email to [email protected] to request support for this format.", sampleFormat));
}
}
}
catch (EndOfStreamException) { /* Encountered end of stream before end of trace. Leave remaining trace samples as zero */ }
return trace;
}
protected ImagePoint RecordToPoint(CoordinateRecord ildaRecord, FormatCode formatCode, IList <RecordColourPalette> palette)
{
var res = new ImagePoint();
switch (formatCode)
{
case FormatCode.Format2DIndexedColour:
{
var r = (Record2DIndexed)ildaRecord;
var c = palette[r.ColourIndex];
res.X = r.X;
res.Y = r.Y;
res.Blanking = r.Blanking;
res.R = c.Red;
res.G = c.Green;
res.B = c.Blue;
break;
}
case FormatCode.Format2DTrueColour:
{
var r = (Record2DTrueColour)ildaRecord;
res.X = r.X;
res.Y = r.Y;
res.Blanking = r.Blanking;
res.R = r.Red;
res.G = r.Green;
res.B = r.Blue;
break;
}
case FormatCode.Format3DIndexedColour:
{
var r = (Record3DIndexed)ildaRecord;
var c = palette[r.ColourIndex];
res.X = r.X;
res.Y = r.Y;
res.Z = r.Z;
res.Blanking = r.Blanking;
res.R = c.Red;
res.G = c.Green;
res.B = c.Blue;
break;
}
case FormatCode.Format3DTrueColour:
{
var r = (Record3DTrueColour)ildaRecord;
res.X = r.X;
res.Y = r.Y;
res.Z = r.Z;
res.Blanking = r.Blanking;
res.R = r.Red;
res.G = r.Green;
res.B = r.Blue;
break;
}
default: throw new ArgumentException($"Unknown FormatCode '{formatCode}'", nameof(formatCode));
}
return(res);
}
public override int GetHashCode() => FormatCode.GetHashCode();
/// <summary>
/// Reads the trace (header and sample values).
/// Assumes that the trace header is the next item to be read.
/// </summary>
public virtual ITrace ReadTrace(BinaryReader reader, FormatCode sampleFormat, bool isLittleEndian)
{
var header = ReadTraceHeader(reader, isLittleEndian);
if (header == null)
return null;
var values = ReadTrace(reader, sampleFormat, header.SampleCount, isLittleEndian);
return new Trace { Header = header, Values = values };
}
public static object DecodeObject(ByteBuffer buffer, FormatCode formatCode)
{
EncodingBase encoding;
if (encodingsByCode.TryGetValue(formatCode, out encoding))
{
return encoding.DecodeObject(buffer, formatCode);
}
throw GetInvalidFormatCodeException(formatCode, buffer.Offset);
}
public static AmqpException GetInvalidFormatCodeException(FormatCode formatCode, int position)
{
return GetEncodingException(string.Format(CultureInfo.CurrentCulture, "Invalid format code: {0} at position {1}.", formatCode, position));
}
public static EncodingBase GetEncoding(FormatCode formatCode)
{
EncodingBase encoding;
if (encodingsByCode.TryGetValue(formatCode, out encoding))
{
return encoding;
}
return null;
}
public static void ReadSizeAndCount(ByteBuffer buffer, FormatCode formatCode, FormatCode formatCode8, FormatCode formatCode32, out int size, out int count)
{
if (formatCode == formatCode8)
{
size = AmqpBitConverter.ReadUByte(buffer);
count = AmqpBitConverter.ReadUByte(buffer);
}
else if (formatCode == formatCode32)
{
size = (int)AmqpBitConverter.ReadUInt(buffer);
count = (int)AmqpBitConverter.ReadUInt(buffer);
}
else
{
throw GetInvalidFormatCodeException(formatCode, buffer.Offset);
}
}
public static string Format(object value, FormatCode code) => $"{Esc}[{(int)code}m{value}{Esc}[0m";
internal SecsItem(FormatCode fm, string name, object value)
{
m_Format = fm;
m_Name = name;
m_Value = value;
}
public override object DecodeObject(ByteBuffer buffer, FormatCode formatCode)
{
return(ByteEncoding.Decode(buffer, formatCode));
}
public virtual IList<float> ReadTrace(BinaryReader reader, FormatCode sampleFormat, int sampleCount)
{
var trace = new float[sampleCount];
for (int i = 0; i < sampleCount; i++)
{
switch (sampleFormat)
{
case FormatCode.IbmFloatingPoint4:
trace[i] = reader.ReadSingleIbm();
break;
case FormatCode.IeeeFloatingPoint4:
trace[i] = reader.ReadSingle();
break;
case FormatCode.TwosComplementInteger2:
trace[i] = reader.ReadInt16BigEndian();
break;
default:
throw new NotSupportedException("Unsupported sample format: " + sampleFormat.ToString());
}
}
return trace;
}
protected override void Initialize(ByteBuffer buffer, FormatCode formatCode,
out int size, out int count, out int encodeWidth, out Collection effectiveType)
{
if (formatCode != FormatCode.Described)
{
throw new AmqpException(AmqpErrorCode.InvalidField, AmqpResources.GetString(AmqpResources.AmqpInvalidFormatCode, formatCode, buffer.Offset));
}
effectiveType = null;
formatCode = AmqpEncoding.ReadFormatCode(buffer);
ulong? code = null;
AmqpSymbol symbol = default(AmqpSymbol);
if (formatCode == FormatCode.ULong0)
{
code = 0;
}
else if (formatCode == FormatCode.ULong || formatCode == FormatCode.SmallULong)
{
code = ULongEncoding.Decode(buffer, formatCode);
}
else if (formatCode == FormatCode.Symbol8 || formatCode == FormatCode.Symbol32)
{
symbol = SymbolEncoding.Decode(buffer, formatCode);
}
if (this.AreEqual(this.descriptorCode, this.descriptorName, code, symbol))
{
effectiveType = this;
}
else if (this.knownTypes != null)
{
for (int i = 0; i < this.knownTypes.Length; ++i)
{
var kvp = this.knownTypes[i];
if (kvp.Value == null)
{
SerializableType knownType = this.serializer.GetType(kvp.Key);
this.knownTypes[i] = kvp = new KeyValuePair <Type, SerializableType>(kvp.Key, knownType);
}
Composite describedKnownType = (Composite)kvp.Value;
if (this.AreEqual(describedKnownType.descriptorCode, describedKnownType.descriptorName, code, symbol))
{
effectiveType = describedKnownType;
break;
}
}
}
if (effectiveType == null)
{
throw new SerializationException(AmqpResources.GetString(AmqpResources.AmqpUnknownDescriptor, code ?? (object)symbol.Value, this.type.Name));
}
formatCode = AmqpEncoding.ReadFormatCode(buffer);
if (this.Code == FormatCode.List32)
{
if (formatCode == FormatCode.List0)
{
size = count = encodeWidth = 0;
}
else
{
encodeWidth = formatCode == FormatCode.List8 ? FixedWidth.UByte : FixedWidth.UInt;
AmqpEncoding.ReadSizeAndCount(buffer, formatCode, FormatCode.List8,
FormatCode.List32, out size, out count);
}
}
else
{
encodeWidth = formatCode == FormatCode.Map8 ? FixedWidth.UByte : FixedWidth.UInt;
AmqpEncoding.ReadSizeAndCount(buffer, formatCode, FormatCode.Map8,
FormatCode.Map32, out size, out count);
}
}
public string ToSQLAlter(Boolean quitSchemaBinding)
{
return(FormatCode.FormatAlter("FUNCTION", ToSql(), this, quitSchemaBinding));
}
protected EncodingBase(FormatCode formatCode)
{
this.formatCode = formatCode;
}
public abstract object DecodeObject(ByteBuffer buffer, FormatCode formatCode);
internal SecsItem(FormatCode fm, string name)
: this(fm, name, null)
{
}
public override object DecodeObject(ByteBuffer buffer, FormatCode formatCode)
{
return UShortEncoding.Decode(buffer, formatCode);
}
protected abstract void Initialize(ByteBuffer buffer, FormatCode formatCode,
out int size, out int count, out int encodeWidth, out Collection effectiveType);
