void
FieldInstructionStaticTemplateRef::encodeNop(
Codecs::DataDestination & destination,
Codecs::PresenceMap & pmap,
Codecs::Encoder & encoder,
const Messages::MessageAccessor & accessor) const
{
// static templateRef
// static
TemplateCPtr target;
if(!encoder.findTemplate(templateName_, templateNamespace_, target))
{
encoder.reportFatal("[ERR D9]", "Unknown template name for static templateref.", *identity_);
}
// retrieve the field corresponding to this templateRef
// which if it exists should be a FieldGroup
const QuickFAST::Messages::MessageAccessor * group;
if(accessor.getGroup(*identity_, group))
{
encoder.encodeSegmentBody(
destination,
pmap,
target,
*group);
}
else
{
encoder.encodeSegmentBody(
destination,
pmap,
target,
accessor);
}
}
void
FieldInstructionDecimal::encodeDelta(
Codecs::DataDestination & destination,
Codecs::PresenceMap & /*pmap*/,
Codecs::Encoder & encoder,
const Messages::MessageAccessor & accessor) const
{
// assume default
Decimal previousValue;
// ... then initialize them from the dictionary
Context::DictionaryStatus previousStatus = fieldOp_->getDictionaryValue(encoder, previousValue);
if(previousStatus != Context::OK_VALUE && fieldOp_->hasValue())
{
previousValue = typedValue_;
fieldOp_->setDictionaryValue(encoder, previousValue);
}
// get the value from the application data
Decimal value;
if(accessor.getDecimal(*identity_, ValueType::DECIMAL, value))
{
int32 exponentDelta = static_cast<int32>(value.getExponent()) - int64(previousValue.getExponent());
if(!isMandatory())
{
if(exponentDelta >= 0)
{
exponentDelta += 1;
}
}
encodeSignedInteger(destination, encoder.getWorkingBuffer(), exponentDelta);
int64 mantissaDelta = int64(value.getMantissa()) - int64(previousValue.getMantissa());
encodeSignedInteger(destination, encoder.getWorkingBuffer(), mantissaDelta);
if(previousStatus != Context::OK_VALUE || value != previousValue)
{
fieldOp_->setDictionaryValue(encoder, value);
}
}
else // not defined by accessor
{
if(isMandatory())
{
encoder.reportFatal("[ERR U01]", "Missing mandatory field.", *identity_);
}
destination.putByte(nullInteger);
}
}
void
FieldInstructionDecimal::encodeDefault(
Codecs::DataDestination & destination,
Codecs::PresenceMap & pmap,
Codecs::Encoder & encoder,
const Messages::MessageAccessor & accessor) const
{
// get the value from the application data
Decimal value;
if(accessor.getDecimal(*identity_, ValueType::DECIMAL, value))
{
if(typedValueIsDefined_ &&
value == typedValue_)
{
pmap.setNextField(false); // not in stream. use default
}
else
{
pmap.setNextField(true); // != default. Send value
if(isMandatory())
{
encodeDecimal(destination, encoder.getWorkingBuffer(), value.getExponent(), value.getMantissa());
}
else
{
encodeNullableDecimal(destination, encoder.getWorkingBuffer(), value.getExponent(), value.getMantissa());
}
}
}
else // not defined by accessor
{
if(isMandatory())
{
encoder.reportFatal("[ERR U01]", "Missing mandatory field.", *identity_);
}
// if there is a default value
// you have to cancel this by sending a null.
if(fieldOp_->hasValue())
{
pmap.setNextField(true);
destination.putByte(nullDecimal);
}
else
{
pmap.setNextField(false);
}
}
}
void
FieldInstructionDecimal::encodeConstant(
Codecs::DataDestination & /*destination*/,
Codecs::PresenceMap & pmap,
Codecs::Encoder & encoder,
const Messages::MessageAccessor & accessor) const
{
if(!isMandatory())
{
// get the value from the application data
Decimal value;
if(accessor.getDecimal(*identity_, ValueType::DECIMAL, value))
{
if(value != typedValue_)
{
encoder.reportFatal("[ERR U10]", "Constant value does not match application data.", *identity_);
}
pmap.setNextField(true);
}
else // not defined by accessor
{
pmap.setNextField(false);
}
}
}
void
FieldInstructionDynamicTemplateRef::encodeNop(
Codecs::DataDestination & destination,
Codecs::PresenceMap & pmap,
Codecs::Encoder & encoder,
const Messages::MessageAccessor & accessor) const
{
encoder.reportFatal("[ERR I1]", "Encoding dynamic templates is not supported.");
}
void
FieldInstruction::encodeTail(
Codecs::DataDestination & /*destination*/,
Codecs::PresenceMap & /*pmap*/,
Codecs::Encoder & encoder,
const Messages::MessageAccessor & /*fieldSet*/) const
{
encoder.reportFatal("[ERR S2]", "Tail Field Operator not supported for this data type.", identity_);
}
void
FieldInstructionGroup::encodeNop(
Codecs::DataDestination & destination,
Codecs::PresenceMap & pmap,
Codecs::Encoder & encoder,
const Messages::MessageAccessor & messageAccessor) const
{
if(!segmentBody_)
{
encoder.reportFatal("[ERR U08}", "Segment not defined for Group instruction.");
}
// retrieve the field corresponding to this group
// Note that applications may support merging groups
// by returning true from getGroup but using the same accessor.
const Messages::MessageAccessor * group;
if(messageAccessor.getGroup(*identity_, group))
{
if(! isMandatory())
{
pmap.setNextField(true);
}
encoder.encodeGroup(destination, segmentBody_, *group);
messageAccessor.endGroup(*identity_, group);
}
else
{
if(isMandatory())
{
encoder.reportFatal("[ERR U01]", "Missing mandatory group.");
encoder.encodeGroup(destination, segmentBody_, messageAccessor);
}
else
{
pmap.setNextField(false);
}
}
}
void
FieldInstructionDecimal::encodeCopy(
Codecs::DataDestination & destination,
Codecs::PresenceMap & pmap,
Codecs::Encoder & encoder,
const Messages::MessageAccessor & accessor) const
{
Decimal previousValue(0,0);
Context::DictionaryStatus previousStatus = fieldOp_->getDictionaryValue(encoder, previousValue);
if(previousStatus == Context::UNDEFINED_VALUE)
{
if(fieldOp_->hasValue())
{
previousValue = typedValue_;
fieldOp_->setDictionaryValue(encoder, previousValue);
// pretend we got the data from the dictionary
previousStatus = Context::OK_VALUE;
}
else
{
// pretend we got a null from the dictionary
fieldOp_->setDictionaryValueNull(encoder);
previousStatus = Context::NULL_VALUE;
}
}
// get the value from the application data
Decimal value;
if(accessor.getDecimal(*identity_, ValueType::DECIMAL, value))
{
if(previousStatus == Context::OK_VALUE && previousValue == value)
{
pmap.setNextField(false); // not in stream, use copy
}
else
{
pmap.setNextField(true);// value in stream
if(isMandatory())
{
encodeDecimal(destination, encoder.getWorkingBuffer(), value.getExponent(), value.getMantissa());
}
else
{
encodeNullableDecimal(destination, encoder.getWorkingBuffer(), value.getExponent(), value.getMantissa());
}
fieldOp_->setDictionaryValue(encoder, value);
}
}
else // not defined by accessor
{
if(isMandatory())
{
encoder.reportFatal("[ERR U01]", "Missing mandatory decimal field.", *identity_);
// if reportFatal returns we're being lax about encoding rules
// let the copy happen.
pmap.setNextField(false);
}
else
{
// Missing optional field. If we have a previous, non-null value
// we need to explicitly null it out. Otherwise just don't send it.
if(previousValue != Context::NULL_VALUE)
{
pmap.setNextField(true);// value in stream
destination.putByte(nullDecimal);
fieldOp_->setDictionaryValueNull(encoder);
}
else
{
pmap.setNextField(false);
}
}
}
}
void
FieldInstructionDecimal::encodeNop(
Codecs::DataDestination & destination,
Codecs::PresenceMap & pmap,
Codecs::Encoder & encoder,
const Messages::MessageAccessor & accessor) const
{
// get the value from the application data
Decimal value;
if(accessor.getDecimal(*identity_, ValueType::DECIMAL, value))
{
exponent_t exponent = value.getExponent();
mantissa_t mantissa = value.getMantissa();
if(bool(exponentInstruction_))
{
Messages::FieldCPtr exponentField(Messages::FieldInt32::create(exponent));
Messages::SingleFieldAccessor exponentAccessor(exponentInstruction_->getIdentity(), exponentField);
exponentInstruction_->encode(
destination,
pmap,
encoder,
exponentAccessor);
Messages::FieldCPtr mantissaField(Messages::FieldInt64::create(mantissa));
Messages::SingleFieldAccessor mantissaAccessor(mantissaInstruction_->getIdentity(), mantissaField);
mantissaInstruction_->encode(
destination,
pmap,
encoder,
mantissaAccessor);
}
else
{
if(!isMandatory())
{
encodeNullableDecimal(
destination,
encoder.getWorkingBuffer(),
value.getExponent(),
value.getMantissa());
}
else
{
encodeDecimal(
destination,
encoder.getWorkingBuffer(),
value.getExponent(),
value.getMantissa());
}
}
}
else // not defined by accessor
{
if(isMandatory())
{
encoder.reportFatal("[ERR U01]", "Missing mandatory field.", *identity_);
}
if(exponentInstruction_)
{
Messages::EmptyAccessor empty;
exponentInstruction_->encode(
destination,
pmap,
encoder,
empty);
}
else
{
destination.putByte(nullInteger);
}
}
}
void
FieldInstructionSequence::encodeNop(
Codecs::DataDestination & destination,
Codecs::PresenceMap & pmap,
Codecs::Encoder & encoder,
const Messages::MessageAccessor & accessor) const
{
if(!segment_)
{
encoder.reportFatal("[ERR U07]", "SegmentBody not defined for Sequence instruction.");
}
size_t length = 0;
if(accessor.getSequenceLength(*identity_, length))
{
Messages::FieldCPtr lengthField(Messages::FieldUInt32::create(QuickFAST::uint32(length)));
Codecs::FieldInstructionCPtr lengthInstruction;
if(segment_->getLengthInstruction(lengthInstruction))
{
Messages::SingleFieldAccessor accessor(lengthInstruction->getIdentity(), lengthField);
lengthInstruction->encode(destination, pmap, encoder, accessor);
}
else
{
FieldInstructionUInt32 defaultLengthInstruction;
defaultLengthInstruction.setPresence(isMandatory());
Messages::SingleFieldAccessor accessor(defaultLengthInstruction.getIdentity(), lengthField);
defaultLengthInstruction.encode(destination, pmap, encoder, accessor);
}
for(size_t pos = 0; pos < length; ++pos)
{
const Messages::MessageAccessor * entry;
if(accessor.getSequenceEntry(*identity_, pos, entry))
{
encoder.encodeGroup(destination, segment_, *entry);
}
else
{
std::stringstream msg;
msg << "Sequence entry " << pos << " of " << length << " missing.";
encoder.reportError("Uxx", msg.str(), *identity_);
}
accessor.endSequenceEntry(*identity_, pos, entry);
}
accessor.endSequence(*identity_);
}
else
{
// The sequence is not present in the application record
if(isMandatory())
{
encoder.reportFatal("[ERR U01]", "Missing mandatory sequence.");
// if reportFail returns, we're being lax about encoding rules
// Send a sequence with no entries.
Codecs::FieldInstructionCPtr lengthInstruction;
if(segment_->getLengthInstruction(lengthInstruction))
{
Messages::SingleFieldAccessor accessor(lengthInstruction->getIdentity(), 0);
lengthInstruction->encode(destination, pmap, encoder, accessor);
}
else
{
destination.putByte(zeroIntegerNonnullable);
}
}
else
{
Codecs::FieldInstructionCPtr lengthInstruction;
if(segment_->getLengthInstruction(lengthInstruction))
{
// let the length instruction encode the fact that it's missing
Messages::EmptyAccessor accessor;
lengthInstruction->encode(destination, pmap, encoder, accessor);
}
else
{
// implicit length instruction: nullable uint32 with no field operator
destination.putByte(nullInteger);
}
}
}
}