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); } } } }