public override Field Convert(GroupValue fieldDef, ITemplateRegistry templateRegistry, ConversionContext context)
{
var name = new QName(fieldDef.GetString("Name"), fieldDef.GetString("Ns"));
bool optional = fieldDef.GetBool("Optional");
GroupValue exponentDef = fieldDef.GetGroup("Exponent");
GroupValue exponentOperatorDef = exponentDef.GetGroup("Operator").GetGroup(0);
Operator exponentOperator = GetOperator(exponentOperatorDef.Group);
ScalarValue exponentDefaultValue = ScalarValue.Undefined;
if (exponentDef.IsDefined("InitialValue"))
{
exponentDefaultValue = new IntegerValue(exponentDef.GetInt("InitialValue"));
}
GroupValue mantissaDef = fieldDef.GetGroup("Mantissa");
GroupValue mantissaOperatorDef = mantissaDef.GetGroup("Operator").GetGroup(0);
Operator mantissaOperator = GetOperator(mantissaOperatorDef.Group);
ScalarValue mantissaDefaultValue = ScalarValue.Undefined;
if (mantissaDef.IsDefined("InitialValue"))
{
mantissaDefaultValue = new LongValue(mantissaDef.GetInt("InitialValue"));
}
ComposedScalar composedDecimal = Util.ComposedDecimal(name, exponentOperator, exponentDefaultValue,
mantissaOperator, mantissaDefaultValue, optional);
IFieldValue retAuxId;
if (fieldDef.TryGetValue("AuxId", out retAuxId) && retAuxId != null)
{
composedDecimal.Id = retAuxId.ToString();
}
return(composedDecimal);
}
public void TestCopyExponentDefaultMantissa()
{
ComposedScalar decimalt = Util.ComposedDecimal(_name, Operator.Copy, ScalarValue.Undefined, Operator.Default,
new LongValue(1), false);
var context = new Context();
var pmapBuilder = new BitVectorBuilder(7);
TestUtil.AssertBitVectorEquals("11111110 00000001 00010110 10101101",
decimalt.Encode(Decimal(19245, -2), _template, context, pmapBuilder));
TestUtil.AssertBitVectorEquals("11100000", pmapBuilder.BitVector.Bytes);
pmapBuilder = new BitVectorBuilder(7);
TestUtil.AssertBitVectorEquals("00000001 00010110 10101001",
decimalt.Encode(Decimal(19241, -2), _template, context, pmapBuilder));
TestUtil.AssertBitVectorEquals("10100000", pmapBuilder.BitVector.Bytes);
pmapBuilder = new BitVectorBuilder(7);
TestUtil.AssertBitVectorEquals("10000000", decimalt.Encode(Decimal(1, 0), _template, context, pmapBuilder));
TestUtil.AssertBitVectorEquals("11000000", pmapBuilder.BitVector.Bytes);
pmapBuilder = new BitVectorBuilder(7);
Assert.AreEqual("", decimalt.Encode(Decimal(1, 0), _template, context, pmapBuilder));
TestUtil.AssertBitVectorEquals("10000000", pmapBuilder.BitVector.Bytes);
Assert.AreEqual(2, pmapBuilder.Index);
}
protected static void AssertComposedScalarField(ComposedScalar field, Type type, String name, Operator exponentOp,
ScalarValue exponentValue, Operator mantissaOp, ScalarValue mantissaValue)
{
Assert.AreEqual(type, field.Type);
Assert.AreEqual(name, field.Name);
Scalar[] fields = field.Fields;
Assert.AreEqual(exponentOp, fields[0].Operator);
Assert.AreEqual(exponentValue, fields[0].DefaultValue);
Assert.AreEqual(mantissaOp, fields[1].Operator);
Assert.AreEqual(mantissaValue, fields[1].DefaultValue);
}
public void TestOptionalConstantExponent()
{
ComposedScalar decimalt = Util.ComposedDecimal(_name, Operator.Constant,
new IntegerValue(-2),
Operator.Default,
new LongValue(100), true);
var context = new Context();
var pmapBuilder = new BitVectorBuilder(7);
Assert.AreEqual("", decimalt.Encode(Decimal(100, -2), _template, context, pmapBuilder));
TestUtil.AssertBitVectorEquals("11000000", pmapBuilder.BitVector.Bytes);
Assert.AreEqual(2, pmapBuilder.Index);
}
public void TestInitialValues()
{
var context = new Context();
ComposedScalar scalar = Util.ComposedDecimal(_name, Operator.Default, Int(-3), Operator.Delta,
ScalarValue.Undefined, false);
TestUtil.AssertBitVectorEquals("00000101 01100000 11110101",
scalar.Encode(Decimal(94325, -3), _template, context, new BitVectorBuilder(7)));
TestUtil.AssertBitVectorEquals("11100111",
scalar.Encode(Decimal(94300, -3), _template, context, new BitVectorBuilder(7)));
TestUtil.AssertBitVectorEquals("11100111",
scalar.Encode(Decimal(94275, -3), _template, context, new BitVectorBuilder(7)));
TestUtil.AssertBitVectorEquals("00000000 11001011",
scalar.Encode(Decimal(94350, -3), _template, context, new BitVectorBuilder(7)));
TestUtil.AssertBitVectorEquals("10011001",
scalar.Encode(Decimal(94375, -3), _template, context, new BitVectorBuilder(7)));
TestUtil.AssertBitVectorEquals("10011001",
scalar.Encode(Decimal(94400, -3), _template, context, new BitVectorBuilder(7)));
TestUtil.AssertBitVectorEquals("01111111 10000011",
scalar.Encode(Decimal(94275, -3), _template, context, new BitVectorBuilder(7)));
TestUtil.AssertBitVectorEquals("11100111",
scalar.Encode(Decimal(94250, -3), _template, context, new BitVectorBuilder(7)));
TestUtil.AssertBitVectorEquals("11100111",
scalar.Encode(Decimal(94225, -3), _template, context, new BitVectorBuilder(7)));
TestUtil.AssertBitVectorEquals("00000000 11111101",
scalar.Encode(Decimal(94350, -3), _template, context, new BitVectorBuilder(7)));
context = new Context();
Assert.AreEqual(Decimal(94325, -3),
scalar.Decode(BitStream("00000101 01100000 11110101"), _template, context,
PmapReader("10100000")));
Assert.AreEqual(Decimal(94300, -3),
scalar.Decode(BitStream("11100111"), _template, context, PmapReader("10100000")));
Assert.AreEqual(Decimal(94275, -3),
scalar.Decode(BitStream("11100111"), _template, context, PmapReader("10100000")));
Assert.AreEqual(Decimal(94350, -3),
scalar.Decode(BitStream("00000000 11001011"), _template, context, PmapReader("10100000")));
Assert.AreEqual(Decimal(94375, -3),
scalar.Decode(BitStream("10011001"), _template, context, PmapReader("10100000")));
Assert.AreEqual(Decimal(94400, -3),
scalar.Decode(BitStream("10011001"), _template, context, PmapReader("10100000")));
Assert.AreEqual(Decimal(94275, -3),
scalar.Decode(BitStream("01111111 10000011"), _template, context, PmapReader("10100000")));
Assert.AreEqual(Decimal(94250, -3),
scalar.Decode(BitStream("11100111"), _template, context, PmapReader("10100000")));
Assert.AreEqual(Decimal(94225, -3),
scalar.Decode(BitStream("11100111"), _template, context, PmapReader("10100000")));
Assert.AreEqual(Decimal(94350, -3),
scalar.Decode(BitStream("00000000 11111101"), _template, context, PmapReader("10100000")));
}
public void TestSimple()
{
const string encoding = "11111110 00111001 01000101 10100011";
ComposedScalar scalar = Util.ComposedDecimal(_name, Operator.Copy,
ScalarValue.Undefined,
Operator.Delta,
ScalarValue.Undefined, true);
TestUtil.AssertBitVectorEquals(encoding,
scalar.Encode(Decimal(942755, -2), _template, new Context(),
new BitVectorBuilder(7)));
Assert.AreEqual(Decimal(942755, -2),
scalar.Decode(BitStream(encoding), _template, new Context(), PmapReader("11000000")));
}
public void TestOptionalDeltaExponentCopyMantissa()
{
ComposedScalar decimalt = Util.ComposedDecimal(_name, Operator.Delta,
ScalarValue.Undefined,
Operator.Copy,
ScalarValue.Undefined, true);
var context = new Context();
var pmapBuilder = new BitVectorBuilder(7);
TestUtil.AssertBitVectorEquals("10000000", decimalt.Encode(null, _template, context, pmapBuilder));
TestUtil.AssertBitVectorEquals("10000000", pmapBuilder.BitVector.Bytes);
Assert.AreEqual(0, pmapBuilder.Index);
pmapBuilder = new BitVectorBuilder(7);
TestUtil.AssertBitVectorEquals("10000001 10000001",
decimalt.Encode(Decimal(1, 0), _template, context, pmapBuilder));
TestUtil.AssertBitVectorEquals("11000000", pmapBuilder.BitVector.Bytes);
Assert.AreEqual(1, pmapBuilder.Index);
}
public void TestOptionalDefaultNullExponent()
{
ComposedScalar decimalt = Util.ComposedDecimal(_name, Operator.Default,
ScalarValue.Undefined,
Operator.Delta, new IntegerValue(
12200), true);
var context = new Context();
var pmapBuilder = new BitVectorBuilder(7);
Assert.AreEqual("", decimalt.Encode(null, _template, context, pmapBuilder));
TestUtil.AssertBitVectorEquals("10000000", pmapBuilder.BitVector.Bytes);
Assert.AreEqual(1, pmapBuilder.Index); // ONLY ONE PMAP BIT SHOULD
// BE WRITTEN
pmapBuilder = new BitVectorBuilder(7);
TestUtil.AssertBitVectorEquals("11111110 10000001",
decimalt.Encode(Decimal(12201, -2), _template, context, pmapBuilder));
TestUtil.AssertBitVectorEquals("11000000", pmapBuilder.BitVector.Bytes);
Assert.AreEqual(1, pmapBuilder.Index);
}
private static Field createComposedDecimal(System.Xml.XmlElement fieldNode, QName name, bool optional, System.Xml.XmlNode mantissaNode, System.Xml.XmlNode exponentNode, ParsingContext context)
{
string mantissaOperator = "none";
string exponentOperator = "none";
ScalarValue mantissaDefaultValue = ScalarValue.UNDEFINED;
ScalarValue exponentDefaultValue = ScalarValue.UNDEFINED;
QName mantissaKey = null;
QName exponentKey = null;
string mantissaDictionary = context.Dictionary;
string exponentDictionary = context.Dictionary;
string mantissaNamespace = context.Namespace;
string exponentNamespace = context.Namespace;
if ((mantissaNode != null) && mantissaNode.HasChildNodes)
{
System.Xml.XmlElement operatorElement = GetElement((System.Xml.XmlElement)mantissaNode, 1);
mantissaOperator = operatorElement.Name;
if (operatorElement.HasAttribute("value"))
{
mantissaDefaultValue = FASTType.I64.GetValue(operatorElement.GetAttribute("value"));
}
if (operatorElement.HasAttribute("ns"))
{
mantissaNamespace = operatorElement.GetAttribute("ns");
}
if (operatorElement.HasAttribute("key"))
{
mantissaKey = new QName(operatorElement.GetAttribute("key"), mantissaNamespace);
}
if (operatorElement.HasAttribute("dictionary"))
{
mantissaDictionary = operatorElement.GetAttribute("dictionary");
}
}
if ((exponentNode != null) && exponentNode.HasChildNodes)
{
System.Xml.XmlElement operatorElement = GetElement((System.Xml.XmlElement)exponentNode, 1);
exponentOperator = operatorElement.Name;
if (operatorElement.HasAttribute("value"))
{
exponentDefaultValue = FASTType.I32.GetValue(operatorElement.GetAttribute("value"));
}
if (operatorElement.HasAttribute("ns"))
{
exponentNamespace = operatorElement.GetAttribute("ns");
}
if (operatorElement.HasAttribute("key"))
{
exponentKey = new QName(operatorElement.GetAttribute("key"), exponentNamespace);
}
if (operatorElement.HasAttribute("dictionary"))
{
exponentDictionary = operatorElement.GetAttribute("dictionary");
}
}
ComposedScalar scalar = Util.ComposedDecimal(name, Operator.Operator.GetOperator(exponentOperator), exponentDefaultValue, Operator.Operator.GetOperator(mantissaOperator), mantissaDefaultValue, optional);
Scalar exponent = scalar.Fields[0];
exponent.Dictionary = exponentDictionary;
if (exponentKey != null)
{
exponent.Key = exponentKey;
}
Scalar mantissa = scalar.Fields[1];
mantissa.Dictionary = mantissaDictionary;
if (mantissaKey != null)
{
mantissa.Key = mantissaKey;
}
if (fieldNode.HasAttribute("id"))
{
scalar.Id = fieldNode.GetAttribute("id");
}
return(scalar);
}
