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);
}
public override byte[] Encode(IFieldValue value, Group encodeTemplate, Context context,
BitVectorBuilder presenceMapBuilder)
{
if (value == null)
{
// Only encode null in the first field.
return(_fields[0].Encode(null, encodeTemplate, context, presenceMapBuilder));
}
var buffer = new MemoryStream(_fields.Length * 8);
IFieldValue[] values = _valueConverter.Split(value);
for (int i = 0; i < _fields.Length; i++)
{
try
{
byte[] tempByteArray = _fields[i].Encode(values[i], encodeTemplate, context, presenceMapBuilder);
buffer.Write(tempByteArray, 0, tempByteArray.Length);
}
catch (IOException e)
{
throw new RuntimeException(e);
}
}
return(buffer.ToArray());
}
public override byte[] Encode(IFieldValue value, Group encodeTemplate, Context context,
BitVectorBuilder presenceMapBuilder)
{
var message = (Message)value;
return(message.Template.Encode(message, context));
}
public override byte[] Encode(IFieldValue value, Group encodeTemplate, Context context,
BitVectorBuilder presenceMapBuilder)
{
if (HasTypeReference)
{
context.CurrentApplicationType = TypeReference;
}
if (value == null)
{
return(_length.Encode(null, encodeTemplate, context, presenceMapBuilder));
}
var buffer = new MemoryStream();
var val = (SequenceValue)value;
int len = val.Length;
try
{
byte[] tmp = _length.Encode(new IntegerValue(len), encodeTemplate, context, presenceMapBuilder);
buffer.Write(tmp, 0, tmp.Length);
foreach (GroupValue v in val.Elements)
{
tmp = _group.Encode(v, encodeTemplate, context);
buffer.Write(tmp, 0, tmp.Length);
}
}
catch (IOException e)
{
Global.ErrorHandler.OnError(e, DynError.IoError, "An IO error occurred while encoding {0}", this);
}
return(buffer.ToArray());
}
public override byte[] Encode(IFieldValue fieldValue, Group encodeTemplate, Context context,
BitVectorBuilder presenceMapBuilder)
{
IDictionary dict = context.GetDictionary(Dictionary);
ScalarValue priorValue = context.Lookup(dict, encodeTemplate, Key);
var value = (ScalarValue)fieldValue;
if (!_operatorCodec.CanEncode(value, this))
{
Global.ErrorHandler.OnError(null, DynError.CantEncodeValue,
"The scalar {0} cannot encode the value {1}", this, value);
}
ScalarValue valueToEncode = _operatorCodec.GetValueToEncode(value, priorValue, this,
presenceMapBuilder);
if (_operator.ShouldStoreValue(value))
{
context.Store(dict, encodeTemplate, Key, value);
}
if (valueToEncode == null)
{
return(ByteUtil.EmptyByteArray);
}
byte[] encoding = _typeCodec.Encode(valueToEncode);
if (context.TraceEnabled && encoding.Length > 0)
{
context.EncodeTrace.Field(this, fieldValue, valueToEncode, encoding, presenceMapBuilder.Index);
}
return(encoding);
}
public void TestNullValue()
{
var scalar = new Scalar("deltaString", FastType.String, Operator.Delta, ScalarValue.Undefined, true);
var template = new MessageTemplate("template", new Field[] {scalar});
var bvBuilder = new BitVectorBuilder(7);
TestUtil.AssertBitVectorEquals("10000000", scalar.Encode(null, template, new Context(), bvBuilder));
// assertEquals(null, scalar.decode(bitStream("10000000"), ScalarValue.UNDEFINED));
}
public override ScalarValue GetValueToEncode(ScalarValue value, ScalarValue priorValue, Scalar field,
BitVectorBuilder presenceMapBuilder)
{
if (field.IsOptional)
{
presenceMapBuilder.OnValueSkipOnNull = value;
}
return(null); // Never encode constant value.
}
public void TestNullValue()
{
var scalar = new Scalar("deltaString", FastType.String, Operator.Delta, ScalarValue.Undefined, true);
var template = new MessageTemplate("template", new Field[] { scalar });
var bvBuilder = new BitVectorBuilder(7);
TestUtil.AssertBitVectorEquals("10000000", scalar.Encode(null, template, new Context(), bvBuilder));
// assertEquals(null, scalar.decode(bitStream("10000000"), ScalarValue.UNDEFINED));
}
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 TestCopyExponentDeltaMantissa()
{
ComposedScalar decimalt = Util.ComposedDecimal(_name, Operator.Copy, ScalarValue.Undefined, Operator.Delta,
new IntegerValue(1), false);
var context = new Context();
var pmapBuilder = new BitVectorBuilder(7);
TestUtil.AssertBitVectorEquals("11111110 00000001 00010110 10101100",
decimalt.Encode(Decimal(19245, -2), _template, context, pmapBuilder));
TestUtil.AssertBitVectorEquals("11000000", pmapBuilder.BitVector.Bytes);
pmapBuilder = new BitVectorBuilder(7);
TestUtil.AssertBitVectorEquals("11111100",
decimalt.Encode(Decimal(19241, -2), _template, context, pmapBuilder));
TestUtil.AssertBitVectorEquals("10000000", pmapBuilder.BitVector.Bytes);
}
public virtual ScalarValue GetValueToEncode(ScalarValue value, ScalarValue priorValue, Scalar scalar,
BitVectorBuilder presenceMapBuilder)
{
ScalarValue valueToEncode = GetValueToEncode(value, priorValue, scalar);
if (valueToEncode == null)
{
presenceMapBuilder.Skip();
}
else
{
presenceMapBuilder.Set();
}
return(valueToEncode);
}
public override byte[] Encode(IFieldValue value, Group encodeTemplate, Context context,
BitVectorBuilder presenceMapBuilder)
{
byte[] encoding = Encode(value, encodeTemplate, context);
if (IsOptional)
{
if (encoding.Length != 0)
{
presenceMapBuilder.Set();
}
else
{
presenceMapBuilder.Skip();
}
}
return(encoding);
}
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);
}
public override byte[] Encode(FieldValue value_Renamed, Group encodeTemplate, Context context, BitVectorBuilder presenceMapBuilder)
{
return(null);
}
public abstract byte[] Encode(FieldValue value_Renamed, Group encodeTemplate, Context context, BitVectorBuilder presenceMapBuilder);
public byte[] Encode(IFieldValue value, Group template, Context context)
{
if (value == null)
{
return(ByteUtil.EmptyByteArray);
}
var groupValue = (GroupValue)value;
if (context.TraceEnabled)
{
context.EncodeTrace.GroupStart(this);
}
var presenceMapBuilder = new BitVectorBuilder(template.MaxPresenceMapSize);
try
{
var fieldEncodings = new byte[_fields.Length][];
for (int fieldIndex = 0; fieldIndex < _fields.Length; fieldIndex++)
{
IFieldValue fieldValue = groupValue.GetValue(fieldIndex);
Field field = _fields[fieldIndex];
if (!field.IsOptional && fieldValue == null)
{
Global.ErrorHandler.OnError(null, DynError.GeneralError, "Mandatory field {0} is null", field);
// BUG? error is ignored?
}
byte[] encoding = field.Encode(fieldValue, field.MessageTemplate ?? template, context,
presenceMapBuilder);
fieldEncodings[fieldIndex] = encoding;
}
var buffer = new MemoryStream();
if (UsesPresenceMap)
{
byte[] pmap = presenceMapBuilder.BitVector.TruncatedBytes;
if (context.TraceEnabled)
{
context.EncodeTrace.Pmap(pmap);
}
buffer.Write(pmap, 0, pmap.Length);
}
foreach (var t in fieldEncodings)
{
if (t != null)
{
buffer.Write(t, 0, t.Length);
}
}
if (context.TraceEnabled)
{
context.EncodeTrace.GroupEnd();
}
return(buffer.ToArray());
}
catch (IOException e)
{
throw new RuntimeException(e);
}
}
public override byte[] Encode(IFieldValue value, Group encodeTemplate, Context context,
BitVectorBuilder presenceMapBuilder)
{
byte[] encoding = Encode(value, encodeTemplate, context);
if (IsOptional)
{
if (encoding.Length != 0)
presenceMapBuilder.Set();
else
presenceMapBuilder.Skip();
}
return encoding;
}
public virtual byte[] Encode(FieldValue value_Renamed, Group template, Context context)
{
if (value_Renamed == null)
{
return(new byte[] {});
}
var groupValue = (GroupValue)value_Renamed;
if (context.TraceEnabled)
{
context.GetEncodeTrace().GroupStart(this);
}
var presenceMapBuilder = new BitVectorBuilder(template.MaxPresenceMapSize);
try
{
var fieldEncodings = new byte[fields.Length][];
for (int fieldIndex = 0; fieldIndex < fields.Length; fieldIndex++)
{
FieldValue fieldValue = groupValue.GetValue(fieldIndex);
Field field = GetField(fieldIndex);
if (!field.Optional && fieldValue == null)
{
Global.HandleError(Error.FastConstants.GENERAL_ERROR, "Mandatory field " + field + " is null");
}
byte[] encoding = field.Encode(fieldValue, template, context, presenceMapBuilder);
fieldEncodings[fieldIndex] = encoding;
}
var buffer = new System.IO.MemoryStream();
if (UsesPresenceMap())
{
byte[] pmap = presenceMapBuilder.BitVector.TruncatedBytes;
if (context.TraceEnabled)
{
context.GetEncodeTrace().Pmap(pmap);
}
byte[] temp_byteArray = pmap;
buffer.Write(temp_byteArray, 0, temp_byteArray.Length);
}
for (int i = 0; i < fieldEncodings.Length; i++)
{
if (fieldEncodings[i] != null)
{
byte[] temp_byteArray2 = fieldEncodings[i];
buffer.Write(temp_byteArray2, 0, temp_byteArray2.Length);
}
}
if (context.TraceEnabled)
{
context.GetEncodeTrace().GroupEnd();
}
return(buffer.ToArray());
}
catch (System.IO.IOException e)
{
throw new RuntimeException(e);
}
}
public byte[] Encode(IFieldValue value, Group template, Context context)
{
if (value == null)
return ByteUtil.EmptyByteArray;
var groupValue = (GroupValue) value;
if (context.TraceEnabled)
{
context.EncodeTrace.GroupStart(this);
}
var presenceMapBuilder = new BitVectorBuilder(template.MaxPresenceMapSize);
try
{
var fieldEncodings = new byte[_fields.Length][];
for (int fieldIndex = 0; fieldIndex < _fields.Length; fieldIndex++)
{
IFieldValue fieldValue = groupValue.GetValue(fieldIndex);
Field field = _fields[fieldIndex];
if (!field.IsOptional && fieldValue == null)
{
Global.ErrorHandler.OnError(null, DynError.GeneralError, "Mandatory field {0} is null", field);
// BUG? error is ignored?
}
byte[] encoding = field.Encode(fieldValue, field.MessageTemplate ?? template, context,
presenceMapBuilder);
fieldEncodings[fieldIndex] = encoding;
}
var buffer = new MemoryStream();
if (UsesPresenceMap)
{
byte[] pmap = presenceMapBuilder.BitVector.TruncatedBytes;
if (context.TraceEnabled)
context.EncodeTrace.Pmap(pmap);
buffer.Write(pmap, 0, pmap.Length);
}
foreach (var t in fieldEncodings)
{
if (t != null)
buffer.Write(t, 0, t.Length);
}
if (context.TraceEnabled)
context.EncodeTrace.GroupEnd();
return buffer.ToArray();
}
catch (IOException e)
{
throw new RuntimeException(e);
}
}
public override ScalarValue GetValueToEncode(ScalarValue value_Renamed, ScalarValue priorValue, Scalar field, BitVectorBuilder presenceMapBuilder)
{
if (field.Optional)
presenceMapBuilder.OnValueSkipOnNull = value_Renamed;
return null; // Never encode constant value.
}
public override byte[] Encode(FieldValue value_Renamed, Group encodeTemplate, Context context, BitVectorBuilder presenceMapBuilder)
{
if (value_Renamed == null)
{
// Only encode null in the first field.
return fields[0].Encode(null, encodeTemplate, context, presenceMapBuilder);
}
var buffer = new System.IO.MemoryStream(fields.Length * 8);
var values = valueConverter.Split(value_Renamed);
for (int i = 0; i < fields.Length; i++)
{
try
{
var temp_byteArray = fields[i].Encode(values[i], encodeTemplate, context, presenceMapBuilder);
buffer.Write(temp_byteArray, 0, temp_byteArray.Length);
}
catch (System.IO.IOException e)
{
throw new RuntimeException(e);
}
}
return buffer.ToArray();
}
public virtual byte[] Encode(FieldValue value_Renamed, Group template, Context context)
{
if (value_Renamed == null)
{
return new byte[]{};
}
var groupValue = (GroupValue) value_Renamed;
if (context.TraceEnabled)
{
context.GetEncodeTrace().GroupStart(this);
}
var presenceMapBuilder = new BitVectorBuilder(template.MaxPresenceMapSize);
try
{
var fieldEncodings = new byte[fields.Length][];
for (int fieldIndex = 0; fieldIndex < fields.Length; fieldIndex++)
{
FieldValue fieldValue = groupValue.GetValue(fieldIndex);
Field field = GetField(fieldIndex);
if (!field.Optional && fieldValue == null)
{
Global.HandleError(Error.FastConstants.GENERAL_ERROR, "Mandatory field " + field + " is null");
}
byte[] encoding = field.Encode(fieldValue, template, context, presenceMapBuilder);
fieldEncodings[fieldIndex] = encoding;
}
var buffer = new System.IO.MemoryStream();
if (UsesPresenceMap())
{
byte[] pmap = presenceMapBuilder.BitVector.TruncatedBytes;
if (context.TraceEnabled)
context.GetEncodeTrace().Pmap(pmap);
byte[] temp_byteArray = pmap;
buffer.Write(temp_byteArray, 0, temp_byteArray.Length);
}
for (int i = 0; i < fieldEncodings.Length; i++)
{
if (fieldEncodings[i] != null)
{
byte[] temp_byteArray2 = fieldEncodings[i];
buffer.Write(temp_byteArray2, 0, temp_byteArray2.Length);
}
}
if (context.TraceEnabled)
context.GetEncodeTrace().GroupEnd();
return buffer.ToArray();
}
catch (System.IO.IOException e)
{
throw new RuntimeException(e);
}
}
public override ScalarValue GetValueToEncode(ScalarValue value, ScalarValue priorValue, Scalar scalar,
BitVectorBuilder presenceMapBuilder)
{
return(GetValueToEncode(value, priorValue, scalar));
}
public override byte[] Encode(FieldValue value_Renamed, Group encodeTemplate, Context context, BitVectorBuilder presenceMapBuilder)
{
if (HasTypeReference())
{
context.CurrentApplicationType = TypeReference;
}
if (value_Renamed == null)
{
return(length.Encode(null, encodeTemplate, context, presenceMapBuilder));
}
var buffer = new System.IO.MemoryStream();
var val = (SequenceValue)value_Renamed;
int len = val.Length;
try
{
var temp_byteArray = length.Encode(new IntegerValue(len), encodeTemplate, context, presenceMapBuilder);
buffer.Write(temp_byteArray, 0, temp_byteArray.Length);
System.Collections.IEnumerator iter = val.Iterator();
while (iter.MoveNext())
{
var temp_byteArray2 = group.Encode((FieldValue)iter.Current, encodeTemplate, context);
buffer.Write(temp_byteArray2, 0, temp_byteArray2.Length);
}
}
catch (System.IO.IOException e)
{
Global.HandleError(Error.FastConstants.IO_ERROR, "An IO error occurred while encoding " + this, e);
}
return(buffer.ToArray());
}
public override byte[] Encode(FieldValue value_Renamed, Group encodeTemplate, Context context, BitVectorBuilder presenceMapBuilder)
{
var message = (Message) value_Renamed;
return message.Template.Encode(message, context);
}
public override byte[] Encode(FieldValue value_Renamed, Group encodeTemplate, Context context, BitVectorBuilder presenceMapBuilder)
{
return null;
}
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 abstract byte[] Encode(IFieldValue value, Group encodeTemplate, Context context,
BitVectorBuilder presenceMapBuilder);
public override ScalarValue GetValueToEncode(ScalarValue value, ScalarValue priorValue, Scalar scalar,
BitVectorBuilder presenceMapBuilder)
{
return GetValueToEncode(value, priorValue, scalar);
}
public override byte[] Encode(FieldValue value_Renamed, Group encodeTemplate, Context context, BitVectorBuilder presenceMapBuilder)
{
if (value_Renamed == null)
{
// Only encode null in the first field.
return(fields[0].Encode(null, encodeTemplate, context, presenceMapBuilder));
}
var buffer = new System.IO.MemoryStream(fields.Length * 8);
var values = valueConverter.Split(value_Renamed);
for (int i = 0; i < fields.Length; i++)
{
try
{
var temp_byteArray = fields[i].Encode(values[i], encodeTemplate, context, presenceMapBuilder);
buffer.Write(temp_byteArray, 0, temp_byteArray.Length);
}
catch (System.IO.IOException e)
{
throw new RuntimeException(e);
}
}
return(buffer.ToArray());
}
public override byte[] Encode(IFieldValue value, Group encodeTemplate, Context context,
BitVectorBuilder presenceMapBuilder)
{
if (value == null)
{
// Only encode null in the first field.
return _fields[0].Encode(null, encodeTemplate, context, presenceMapBuilder);
}
var buffer = new MemoryStream(_fields.Length*8);
IFieldValue[] values = _valueConverter.Split(value);
for (int i = 0; i < _fields.Length; i++)
{
try
{
byte[] tempByteArray = _fields[i].Encode(values[i], encodeTemplate, context, presenceMapBuilder);
buffer.Write(tempByteArray, 0, tempByteArray.Length);
}
catch (IOException e)
{
throw new RuntimeException(e);
}
}
return buffer.ToArray();
}
public override byte[] Encode(IFieldValue value, Group encodeTemplate, Context context,
BitVectorBuilder presenceMapBuilder)
{
if (HasTypeReference)
context.CurrentApplicationType = TypeReference;
if (value == null)
return _length.Encode(null, encodeTemplate, context, presenceMapBuilder);
var buffer = new MemoryStream();
var val = (SequenceValue) value;
int len = val.Length;
try
{
byte[] tmp = _length.Encode(new IntegerValue(len), encodeTemplate, context, presenceMapBuilder);
buffer.Write(tmp, 0, tmp.Length);
foreach (GroupValue v in val.Elements)
{
tmp = _group.Encode(v, encodeTemplate, context);
buffer.Write(tmp, 0, tmp.Length);
}
}
catch (IOException e)
{
Global.ErrorHandler.OnError(e, DynError.IoError, "An IO error occurred while encoding {0}", this);
}
return buffer.ToArray();
}
public override byte[] Encode(IFieldValue fieldValue, Group encodeTemplate, Context context,
BitVectorBuilder presenceMapBuilder)
{
IDictionary dict = context.GetDictionary(Dictionary);
ScalarValue priorValue = context.Lookup(dict, encodeTemplate, Key);
var value = (ScalarValue) fieldValue;
if (!_operatorCodec.CanEncode(value, this))
{
Global.ErrorHandler.OnError(null, DynError.CantEncodeValue,
"The scalar {0} cannot encode the value {1}", this, value);
}
ScalarValue valueToEncode = _operatorCodec.GetValueToEncode(value, priorValue, this,
presenceMapBuilder);
if (_operator.ShouldStoreValue(value))
{
context.Store(dict, encodeTemplate, Key, value);
}
if (valueToEncode == null)
{
return ByteUtil.EmptyByteArray;
}
byte[] encoding = _typeCodec.Encode(valueToEncode);
if (context.TraceEnabled && encoding.Length > 0)
{
context.EncodeTrace.Field(this, fieldValue, valueToEncode, encoding, presenceMapBuilder.Index);
}
return encoding;
}
public override byte[] Encode(FieldValue fieldValue, Group encodeTemplate, Context context, BitVectorBuilder presenceMapBuilder)
{
var priorValue = context.Lookup(Dictionary, encodeTemplate, Key);
var value_Renamed = (ScalarValue) fieldValue;
if (!operatorCodec.CanEncode(value_Renamed, this))
{
Global.HandleError(Error.FastConstants.D3_CANT_ENCODE_VALUE, "The scalar " + this + " cannot encode the value " + value_Renamed);
}
var valueToEncode = operatorCodec.GetValueToEncode(value_Renamed, priorValue, this, presenceMapBuilder);
if (operator_Renamed.ShouldStoreValue(value_Renamed))
{
context.Store(Dictionary, encodeTemplate, Key, value_Renamed);
}
if (valueToEncode == null)
{
return new byte[0];
}
byte[] encoding = typeCodec.Encode(valueToEncode);
if (context.TraceEnabled && encoding.Length > 0)
{
context.GetEncodeTrace().Field(this, fieldValue, valueToEncode, encoding, presenceMapBuilder.Index);
}
return encoding;
}
public override byte[] Encode(FieldValue fieldValue, Group encodeTemplate, Context context, BitVectorBuilder presenceMapBuilder)
{
var priorValue = context.Lookup(Dictionary, encodeTemplate, Key);
var value_Renamed = (ScalarValue)fieldValue;
if (!operatorCodec.CanEncode(value_Renamed, this))
{
Global.HandleError(Error.FastConstants.D3_CANT_ENCODE_VALUE, "The scalar " + this + " cannot encode the value " + value_Renamed);
}
var valueToEncode = operatorCodec.GetValueToEncode(value_Renamed, priorValue, this, presenceMapBuilder);
if (operator_Renamed.ShouldStoreValue(value_Renamed))
{
context.Store(Dictionary, encodeTemplate, Key, value_Renamed);
}
if (valueToEncode == null)
{
return(new byte[0]);
}
byte[] encoding = typeCodec.Encode(valueToEncode);
if (context.TraceEnabled && encoding.Length > 0)
{
context.GetEncodeTrace().Field(this, fieldValue, valueToEncode, encoding, presenceMapBuilder.Index);
}
return(encoding);
}
public override byte[] Encode(FieldValue value_Renamed, Group encodeTemplate, Context context, BitVectorBuilder presenceMapBuilder)
{
if (HasTypeReference())
context.CurrentApplicationType = TypeReference;
if (value_Renamed == null)
{
return length.Encode(null, encodeTemplate, context, presenceMapBuilder);
}
var buffer = new System.IO.MemoryStream();
var val = (SequenceValue) value_Renamed;
int len = val.Length;
try
{
var temp_byteArray = length.Encode(new IntegerValue(len), encodeTemplate, context, presenceMapBuilder);
buffer.Write(temp_byteArray, 0, temp_byteArray.Length);
System.Collections.IEnumerator iter = val.Iterator();
while (iter.MoveNext())
{
var temp_byteArray2 = group.Encode((FieldValue) iter.Current, encodeTemplate, context);
buffer.Write(temp_byteArray2, 0, temp_byteArray2.Length);
}
}
catch (System.IO.IOException e)
{
Global.HandleError(Error.FastConstants.IO_ERROR, "An IO error occurred while encoding " + this, e);
}
return buffer.ToArray();
}
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 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);
}
public virtual ScalarValue GetValueToEncode(ScalarValue value_Renamed, ScalarValue priorValue, Scalar scalar, BitVectorBuilder presenceMapBuilder)
{
var valueToEncode = GetValueToEncode(value_Renamed, priorValue, scalar);
if (valueToEncode == null)
presenceMapBuilder.Skip();
else
presenceMapBuilder.set_Renamed();
return valueToEncode;
}
