Subversion Repositories DevTools

Rev

Rev 2230 | Blame | Compare with Previous | Last modification | View Log | RSS feed 

//## begin module%1.7%.codegen_version preserve=yes
//   Read the documentation to learn more about C++ code generator
//   versioning.
//## end module%1.7%.codegen_version

//## begin module%41F607FA0261.cm preserve=no
//## end module%41F607FA0261.cm

//## begin module%41F607FA0261.cp preserve=no
//      C O P Y R I G H T   N O T I C E
//      This material is confidential to ERG and may not be disclosed in whole
//      or in part to any third party nor used in any manner whatsoever other
//      than for the purposes expressly consented to by ERG in writing.
//
//      This material is also copyright and may not be reproduced, stored in a
//      retrieval system or transmitted in any form or by any means in whole or
//      in part without the express written consent of ERG.
//## end module%41F607FA0261.cp

//## Module: TransactionSpecification%41F607FA0261; Pseudo Package body
//## Subsystem: MASS::Dev::Tools::TxnTestManager::src%41F5A79001E4
//## Source file: Z:\MASS_Dev\Tools\TxnTestManager\src\TransactionSpecification.cpp

//## begin module%41F607FA0261.additionalIncludes preserve=no
//## end module%41F607FA0261.additionalIncludes

//## begin module%41F607FA0261.includes preserve=yes
#pragma warn -com
#include <LoggingMacros.h>
#pragma warn +com
//## end module%41F607FA0261.includes

// IXmlSchemaWrapperSchema
#include "IXmlSchemaWrapperSchema.h"
// IXmlSchemaWrapperString
#include "IXmlSchemaWrapperString.h"
// Iteration
#include "Iteration.h"
// TestScenario
#include "TestScenario.h"
// TimeEstimate
#include "TimeEstimate.h"
// ProgressBar
#include "ProgressBar.h"
// IXmlSchemaWrapperByteArray
#include "IXmlSchemaWrapperByteArray.h"
// IXmlSchemaWrapperElement
#include "IXmlSchemaWrapperElement.h"
// IXmlSchemaWrapperFactory
#include "IXmlSchemaWrapperFactory.h"
// IXmlSchemaWrapperStream
#include "IXmlSchemaWrapperStream.h"
// TransactionSpecificationValue
#include "TransactionSpecificationValue.h"
// TransactionSpecification
#include "TransactionSpecification.h"
// MacQualification
#include "MacQualification.h"
// EvaluationCallback
#include "EvaluationCallback.h"
// EvaluationContext
#include "EvaluationContext.h"
// TransactionStream
#include "TransactionStream.h"
// TransactionStructure
#include "TransactionStructure.h"
// IHash
#include "IHash.h"
// IMessageDigest
#include "IMessageDigest.h"
//## begin module%41F607FA0261.additionalDeclarations preserve=yes
#include <sstream>
#include "Utilities.h"

#define COMPENSATE_FOR_PARSER_BUG 0
#if COMPENSATE_FOR_PARSER_BUG
static void rotateBuffer( unsigned char * buffer, const unsigned int & length )
{
        unsigned char b;

        for ( unsigned int i=0, j=length-1; i<length/2; ++i,--j )
        {
                b = buffer[ i ];
                buffer[ i ] = buffer[ j ];
                buffer[ j ] = b;
        }
}
#endif

//## end module%41F607FA0261.additionalDeclarations


// Class TransactionSpecification 

//## begin TransactionSpecification::headerStructureName%4206D764033E.attr preserve=no  private: static char {RAC} "SysHdr_t"
const char *TransactionSpecification::g_headerStructureName = "SysHdr_t";
//## end TransactionSpecification::headerStructureName%4206D764033E.attr

//## Operation: TransactionSpecification%41F7060D0204
TransactionSpecification::TransactionSpecification (const int &transactionSpecificationNumber)
  //## begin TransactionSpecification::TransactionSpecification%41F7060D0204.hasinit preserve=no
      : m_structureIndex(0),
        m_transactionSpecificationNumber(0),
        m_udSubtype(0),
        m_udType(0),
        m_formatVersion(0),
        m_scenario(0),
        m_string(0),
        m_structure(0),
        m_macFields(0)
  //## end TransactionSpecification::TransactionSpecification%41F7060D0204.hasinit
  //## begin TransactionSpecification::TransactionSpecification%41F7060D0204.initialization preserve=yes
  //## end TransactionSpecification::TransactionSpecification%41F7060D0204.initialization
{
  //## begin TransactionSpecification::TransactionSpecification%41F7060D0204.body preserve=yes

  m_transactionSpecificationNumber = transactionSpecificationNumber;

  //## end TransactionSpecification::TransactionSpecification%41F7060D0204.body
}

//## Operation: TransactionSpecification%42045473030D
TransactionSpecification::TransactionSpecification (const int &transactionSpecificationNumber, const std::string &payloadStructureName, TestScenario& scenario)
  //## begin TransactionSpecification::TransactionSpecification%42045473030D.hasinit preserve=no
      : m_structureIndex(0),
        m_transactionSpecificationNumber(0),
        m_udSubtype(0),
        m_udType(0),
        m_formatVersion(0),
        m_scenario(0),
        m_string(0),
        m_structure(0),
        m_macFields(0)
  //## end TransactionSpecification::TransactionSpecification%42045473030D.hasinit
  //## begin TransactionSpecification::TransactionSpecification%42045473030D.initialization preserve=yes
  //## end TransactionSpecification::TransactionSpecification%42045473030D.initialization
{
  //## begin TransactionSpecification::TransactionSpecification%42045473030D.body preserve=yes

        m_formatVersion = scenario.getIteration().getFormatVersion();
        m_scenario              = &scenario;
        m_string
                = &scenario.getIteration().getSchemaWrapperFactory().createString();
        m_structureName = payloadStructureName;
        m_transactionSpecificationNumber
                = transactionSpecificationNumber;

        // Allocate the structures that we'll need for this transaction.
        TransactionStructure * object = 0;
        try
        {
                object =new TransactionStructure(
                        g_headerStructureName,
                        m_scenario->getIteration().getIterationId(),
                        m_scenario->getIteration().getSchemaWrapperFactory(),
                        m_scenario->getIteration().getSchema(),
                        true );
                m_structure.push_back( object );
                object = 0;

                object =new TransactionStructure(
                        payloadStructureName,
                        m_scenario->getIteration().getIterationId(),
                        m_scenario->getIteration().getSchemaWrapperFactory(),
                        m_scenario->getIteration().getSchema(),
                        false );
                m_structure.push_back( object );
                object = 0;
        }
        catch ( ... )
        {
                // Rollback.
                delete object;
                object = 0;

                for ( std::vector< TransactionStructure * >::iterator
                                structure = m_structure.begin();
                          structure != m_structure.end();
                          ++structure )
                {
                        delete *structure;
                        *structure = 0;
                }
                m_structure.clear();

                throw;
        }

  //## end TransactionSpecification::TransactionSpecification%42045473030D.body
}


TransactionSpecification::~TransactionSpecification()
{
  //## begin TransactionSpecification::~TransactionSpecification%41F607FA0261_dest.body preserve=yes

        for ( std::map< std::string, TransactionSpecificationValue * >::iterator
                        transaction = m_value.begin();
                  transaction != m_value.end();
                  ++transaction )
        {
                delete transaction->second;
                transaction->second = 0;
        }
        m_value.clear();

        for ( std::vector< TransactionStructure * >::iterator
                        structure = m_structure.begin();
                  structure != m_structure.end();
                  ++structure )
        {
                delete *structure;
                *structure = 0;
        }
        m_structure.clear();

        if ( m_string && m_scenario )
        {
                m_scenario->getIteration().getSchemaWrapperFactory().destroyString( *m_string );
                m_string = 0;
        }
        m_scenario = 0; // We don't own this object.

  //## end TransactionSpecification::~TransactionSpecification%41F607FA0261_dest.body
}



//## Other Operations (implementation)
//## Operation: addMacField%4212DBC1031E
void TransactionSpecification::addMacField (XMLSchema::IXmlSchemaWrapperElement &element)
{
  //## begin TransactionSpecification::addMacField%4212DBC1031E.body preserve=yes

        m_macFields.push_back( &element );  

  //## end TransactionSpecification::addMacField%4212DBC1031E.body
}

//## Operation: addValue%41F70652035C
void TransactionSpecification::addValue (const std::string &xPath, const std::string &value, const bool &obsolete)
{
  //## begin TransactionSpecification::addValue%41F70652035C.body preserve=yes

        TransactionSpecificationValue * theValue = 0;

        try
        {
                theValue = new TransactionSpecificationValue( xPath, value, obsolete );

                if ( !m_value.insert(
                                std::map< std::string, TransactionSpecificationValue * >::value_type(
                                        theValue->getXPath(),
                                        theValue ) ).second )
                {
                        MTHROW( std::runtime_error, \
                                "Cannot add value \"" \
                                << theValue->getXPath() \
                                << "\" to transaction " \
                                << m_transactionSpecificationNumber \
                                << '.' );
                }
        }
        catch ( ... )
        {
                delete theValue;
                theValue = 0;

                throw;
        }

  //## end TransactionSpecification::addValue%41F70652035C.body
}

//## Operation: clearMacFields%42130B2D0377
void TransactionSpecification::clearMacFields ()
{
  //## begin TransactionSpecification::clearMacFields%42130B2D0377.body preserve=yes

        XMLSchema::IXmlSchemaWrapperFactory & factory
                = m_scenario->getIteration().getSchemaWrapperFactory();
        for ( std::vector< XMLSchema::IXmlSchemaWrapperElement * >
                        ::iterator element = m_macFields.begin();
                  element != m_macFields.end();
                  ++element )
        {
                factory.destroySchemaElement( **element );
                *element = 0;
        }
        m_macFields.clear();

  //## end TransactionSpecification::clearMacFields%42130B2D0377.body
}

//## Operation: clearMarks%41F705790276
void TransactionSpecification::clearMarks ()
{
  //## begin TransactionSpecification::clearMarks%41F705790276.body preserve=yes

        for ( std::map< std::string, TransactionSpecificationValue * >::iterator
                        where = m_value.begin();
                  where != m_value.end();
                  ++where )
        {
                where->second->unmark();
        }

  //## end TransactionSpecification::clearMarks%41F705790276.body
}

//## Operation: generate%4204564D02F3
const bool TransactionSpecification::generate (TransactionStream& stream, const bool &generateHeaders, EvaluationContext& evaluationContext)
{
  //## begin TransactionSpecification::generate%4204564D02F3.body preserve=yes

        XMLSchema::IXmlSchemaWrapperFactory & xmlSchemaWrapperFactory
                = m_scenario->getIteration().getSchemaWrapperFactory();
                
        /**
         *      Traverse the structures associated with this transaction  in order,
         *      querying our collection of defined fields for every schema element
         *      that we encounter.  When we have a match, then we evaluate the
         *      expression found, and assign the result to the schema element currently
         *      being visited.
         */

        evaluationContext.setTransaction( *this );

        EvaluationCallback callback( *this, evaluationContext );

        bool generated = false;
        m_structureIndex = 0;
        std::vector< TransactionStructure * >::iterator structure;
        for ( structure = m_structure.begin();
                  structure != m_structure.end();
                  ++structure )
        {
                if ( generateHeaders || !(*structure)->isHeader() )
                {
                        generated = (*structure)->getSchemaElement().traverse( callback );
                        if ( !generated )
                        {
                                break;
                        }
                }
                ++m_structureIndex;
        }

        if ( generated )
        {
                /**
                 *      If we have any MAC fields, then we must compute the MAC and assign
                 *      the MAC to each element in the collection.
                 */
                if ( m_macFields.size() )
                {
                        if ( evaluationContext.haveMessageDigest() )
                        {
                                /**
                                 *      Create a serialsation stream, and serialise all attributes
                                 *      into it that are to be included in the MAC.  Then MAC the
                                 *      stream.  We need to do this because we need to MAC the
                                 *      serialised form, not the internal binary form.
                                 */
                                MacQualification macQualification( evaluationContext );

                                XMLSchema::IXmlSchemaWrapperStream *    stream  = 0;
                                XMLSchema::IXmlSchemaWrapperByteArray * digest  = 0;

                                try
                                {
                                        stream = &xmlSchemaWrapperFactory.createXdrStream();
                                        digest = &xmlSchemaWrapperFactory.createByteArray();

                                        for ( structure = m_structure.begin();
                                                  structure != m_structure.end();
                                                  ++structure )
                                        {
                                                // We only include the structure in the MAC computation,
                                                // never the header.
                                                if ( !(*structure)->isHeader() )
                                                {
                                                        if ( !(*structure)->write(
                                                                        *stream,
                                                                        macQualification ) )
                                                        {
                                                                generated = false;
                                                                break;
                                                        }
                                                }
                                        }

                                        if ( generated )
                                        {
                                                void *                  buffer = 0;
                                                unsigned int    length = 0;

                                                // When we get a zero-length MAC, we don't assign it.
                                                if ( stream->getData( buffer, length ) )
                                                {
                                                        evaluationContext.getMessageDigest().reset();

                                                        if ( evaluationContext.haveHash() )
                                                        {
                                                                IHash & hash = evaluationContext.getHash();

                                                                hash.reset();
                                                                generated =
                                                                        hash.updateByteArray(
                                                                                buffer,
                                                                                length ) &&
                                                                        hash.digest();
                                                                if ( generated )
                                                                {
                                                                        generated = evaluationContext.
                                                                                getMessageDigest().updateByteArray(
                                                                                        hash.getValue(),
                                                                                        hash.getLength() );
                                                                }
                                                        }
                                                        else
                                                        {
                                                                generated = evaluationContext.getMessageDigest().
                                                                        updateByteArray( buffer, length );
                                                        }
                                                        if ( generated )
                                                        {
                                                                if ( evaluationContext.getMessageDigest().digest() )
                                                                {
                                                                        if ( evaluationContext.getMessageDigest().getLength() )
                                                                        {
#if COMPENSATE_FOR_PARSER_BUG
                                                                                /**
                                                                                 *      Compensate for the parser treating
                                                                                 *      an array of 8 U8 as a U64 (Why does
                                                                                 *      it do that?  Its wrong.).
                                                                                 */
                                                                                unsigned char * b = const_cast< unsigned char * >( evaluationContext.getMessageDigest().getValue() );
                                                                                length = evaluationContext.getMessageDigest().getLength();
                                                                                rotateBuffer( b, length );
                                                                                digest->assign( b, length );
#else
                                                                                digest->assign(
                                                                                        evaluationContext.getMessageDigest().getValue(),
                                                                                        evaluationContext.getMessageDigest().getLength() );
#endif // #ifdef COMPENSATE_FOR_PARSER_BUG

                                                                                for ( std::vector< XMLSchema::IXmlSchemaWrapperElement * >
                                                                                                ::iterator macField = m_macFields.begin();
                                                                                          macField != m_macFields.end();
                                                                                          ++macField )
                                                                                {
                                                                                        if ( !(*macField)->setByteArray( *digest ) )
                                                                                        {
                                                                                                generated = false;
                                                                                                break;
                                                                                        }
                                                                                }
                                                                        }
                                                                        else
                                                                        {
                                                                                generated = false;
                                                                        }
                                                                }
                                                                else
                                                                {
                                                                        generated = false;
                                                                }
                                                        }
                                                }
                                        }

                                }
                                __finally
                                {
                                        if ( digest )
                                        {
                                                xmlSchemaWrapperFactory.destroyByteArray( *digest );
                                                digest = 0;
                                        }

                                        if ( stream )
                                        {
                                                xmlSchemaWrapperFactory.destroyStream( *stream );
                                                stream = 0;
                                        }
                                }
                        }
                        else
                        {
                                generated = false;
                        }

                        if ( !generated )
                        {
                                std::stringstream message;
                                message
                                        << "Cannot compute MAC.  Is the security subsystem operational?";
                                MERROR( message.str() );
                                message << "  Ignore the error and continue?";

                                generated = ( MessageDlg(
                                                                        message.str().c_str(),
                                                                        mtConfirmation,
                                                                        TMsgDlgButtons() << mbYes << mbNo,
                                                                        0 ) == mrYes );
                        }
                        clearMacFields();
                }
        }

        if ( generated )
        {
                for ( structure = m_structure.begin();
                          structure != m_structure.end();
                          ++structure )
                {
                        if ( generateHeaders || !(*structure)->isHeader() )
                        {
                                /**
                                 *      Serialise the structure into the transaction stream.
                                 */
                                generated = (*structure)->write( stream );
                                if ( !generated )
                                {
                                        break;
                                }
                        }
                }

                stream.incrementCount();
                if ( evaluationContext.haveProgressBar() )
                {
                        evaluationContext.getProgressBar().increment();
                }
                evaluationContext.getTimeEstimate().increment();
        }

        return ( generated );

  //## end TransactionSpecification::generate%4204564D02F3.body
}

//## Operation: getCurrentStructure%4213183F01DD
const TransactionStructure & TransactionSpecification::getCurrentStructure () const
{
  //## begin TransactionSpecification::getCurrentStructure%4213183F01DD.body preserve=yes

        return ( *m_structure[ m_structureIndex ] );  

  //## end TransactionSpecification::getCurrentStructure%4213183F01DD.body
}

//## Operation: getFormatVersion%4208BB80011D
const int & TransactionSpecification::getFormatVersion () const
{
  //## begin TransactionSpecification::getFormatVersion%4208BB80011D.body preserve=yes

        return ( m_formatVersion );

  //## end TransactionSpecification::getFormatVersion%4208BB80011D.body
}

//## Operation: getScenario%420471B00192
const TestScenario & TransactionSpecification::getScenario () const
{
  //## begin TransactionSpecification::getScenario%420471B00192.body preserve=yes

        return ( *m_scenario );

  //## end TransactionSpecification::getScenario%420471B00192.body
}

//## Operation: getTransactionField%4204283B033E
TransactionSpecificationValue& TransactionSpecification::getTransactionField (const std::string &xpath)
{
  //## begin TransactionSpecification::getTransactionField%4204283B033E.body preserve=yes

        std::map< std::string, TransactionSpecificationValue * >::const_iterator
                instance = m_value.find( xpath );

        if ( instance != m_value.end() )
        {
                return ( *instance->second );
        }
        else
        {
                TransactionSpecificationValue * object = 0;

                try
                {
                        object = new TransactionSpecificationValue( xpath, *this );

                        if ( m_value.insert(
                                        std::map< std::string, TransactionSpecificationValue * >::value_type(
                                                xpath,
                                                object ) ).second )
                        {
                                return ( *object );
                        }
                        else
                        {
                                MTHROW( std::runtime_error, \
                                        "Cannot add transaction field \"" \
                                        << xpath \
                                        << "\" to transaction " \
                                        << m_transactionSpecificationNumber \
                                        << '.' );
                        }
                }
                catch ( ... )
                {
                        delete object;
                        object = 0;

                        throw;
                }
        }

  //## end TransactionSpecification::getTransactionField%4204283B033E.body
}

//## Operation: getTransactionSpecificationNumber%41F71AD2002F
const int & TransactionSpecification::getTransactionSpecificationNumber () const
{
  //## begin TransactionSpecification::getTransactionSpecificationNumber%41F71AD2002F.body preserve=yes

        return ( m_transactionSpecificationNumber );

  //## end TransactionSpecification::getTransactionSpecificationNumber%41F71AD2002F.body
}

//## Operation: getUdSubtype%4208AFAF01F7
const unsigned short & TransactionSpecification::getUdSubtype () const
{
  //## begin TransactionSpecification::getUdSubtype%4208AFAF01F7.body preserve=yes

        return ( m_udSubtype );

  //## end TransactionSpecification::getUdSubtype%4208AFAF01F7.body
}

//## Operation: getUdType%4208AFAF0245
const unsigned short & TransactionSpecification::getUdType () const
{
  //## begin TransactionSpecification::getUdType%4208AFAF0245.body preserve=yes

        return ( m_udType );

  //## end TransactionSpecification::getUdType%4208AFAF0245.body
}

//## Operation: getValues%41F705A600AC
const std::map< std::string, TransactionSpecificationValue * > & TransactionSpecification::getValues () const
{
  //## begin TransactionSpecification::getValues%41F705A600AC.body preserve=yes

        return ( m_value );

  //## end TransactionSpecification::getValues%41F705A600AC.body
}

//## Operation: isContained%41F70575014E
const bool TransactionSpecification::isContained (const std::string &xPath) const
{
  //## begin TransactionSpecification::isContained%41F70575014E.body preserve=yes

  return ( m_value.find( xPath ) != m_value.end() );

  //## end TransactionSpecification::isContained%41F70575014E.body
}

//## Operation: isMarked%41F708CB0307
const bool TransactionSpecification::isMarked (const std::string &xPath) const
{
  //## begin TransactionSpecification::isMarked%41F708CB0307.body preserve=yes

        std::map< std::string, TransactionSpecificationValue * >::const_iterator
                instance = m_value.find( xPath );

        if ( instance != m_value.end() )
        {
                return ( instance->second->isMarked() );
        }
        else
        {
                MTHROW( std::runtime_error, \
                        "Cannot find value " << xPath << '.' );
        }

  //## end TransactionSpecification::isMarked%41F708CB0307.body
}

//## Operation: markValue%41F7069E002F
void TransactionSpecification::markValue (const std::string &xPath)
{
  //## begin TransactionSpecification::markValue%41F7069E002F.body preserve=yes

        std::map< std::string, TransactionSpecificationValue * >::const_iterator
                instance = m_value.find( xPath );

        if ( instance != m_value.end() )
        {
                instance->second->mark();
        }
        else
        {
                MTHROW( std::runtime_error, \
                        "Cannot find value " << xPath << '.' );
        }

  //## end TransactionSpecification::markValue%41F7069E002F.body
}

//## Operation: setUdSubtype%42044110019A
const unsigned short & TransactionSpecification::setUdSubtype (const unsigned short &value)
{
  //## begin TransactionSpecification::setUdSubtype%42044110019A.body preserve=yes

        return ( m_udSubtype = value );

  //## end TransactionSpecification::setUdSubtype%42044110019A.body
}

//## Operation: setUdType%420440DE038E
const unsigned short & TransactionSpecification::setUdType (const unsigned short &value)
{
  //## begin TransactionSpecification::setUdType%420440DE038E.body preserve=yes

        return ( m_udType = value );

  //## end TransactionSpecification::setUdType%420440DE038E.body
}

//## Operation: evaluate%4205C6F500FC
const bool TransactionSpecification::evaluate (XMLSchema::IXmlSchemaWrapperElement &element, EvaluationContext& context)
{
  //## begin TransactionSpecification::evaluate%4205C6F500FC.body preserve=yes

        /**
         *      Build an XPath from the name of the structure that we are traversing
         *      right now and the xpath reported by the element being visited.  Then
         *      look for a field with that XPath.
         */

        std::stringstream xpath;
        if ( element.getAttributeValue( "xpath", *m_string ) )
        {
                xpath
                        << '/'
                        << m_structure[ m_structureIndex ]->getName()
                        << m_string->c_str();

                /**
                 *      Find the element if we have it.  We get calls for everything, not
                 *      just for what we have.  When we don't have the element, then we
                 *      have nothing to set, which is fine.
                 */
                std::map< std::string, TransactionSpecificationValue * >::iterator
                        field = m_value.find( xpath.str() );
                if ( field != m_value.end() )
                {
                        std::string value;
                        bool postponed = false;
                        if ( field->second->evaluate( value, true, context, postponed ) )
                        {
                                if ( !postponed )
                                {
                                        *m_string = value.c_str();
                                        if ( element.setString( *m_string ) )
                                        {
                                                return ( true );
                                        }
                                        else
                                        {
                                                std::string datatype;
                                                if ( element.getAttributeValue( "datatype", *m_string ) )
                                                {
                                                        datatype = m_string->c_str();
                                                }

                                                std::stringstream message;
                                                message
                                                        << "Cannot set value of \""
                                                        << xpath.str()
                                                        << "\" to \""
                                                        << value
                                                        << "\" as \""
                                                        << datatype
                                                        << "\".";
                                                MERROR( message.str() );
                                                message << "  Continue?";

                                                return ( MessageDlg(
                                                                        message.str().c_str(),
                                                                        mtConfirmation,
                                                                        TMsgDlgButtons() << mbYes << mbNo,
                                                                        0 ) == mrYes );
                                        }
                                }
                                else
                                {
                                        return ( true );
                                }
                        }
                        else
                        {
                                std::stringstream message;
                                message
                                        << "Cannot evaluate value of \"" \
                                        << field->second->getExpression() \
                                        << "\" for \"" \
                                        << xpath.str() \
                                        << "\".";
                                MERROR( message.str() );
                                message << "  Continue?";

                                return ( MessageDlg(
                                                        message.str().c_str(),
                                                        mtConfirmation,
                                                        TMsgDlgButtons() << mbYes << mbNo,
                                                        0 ) == mrYes );
                        }
                }
                else
                {
                        // We have no value for this element, which is fine.
                        return ( true );
                }
        }
        else
        {
                MERROR( "Cannot get xpath for schema element " << &element << '.' );
        }

        return ( false );

  //## end TransactionSpecification::evaluate%4205C6F500FC.body
}

// Additional Declarations
  //## begin TransactionSpecification%41F607FA0261.declarations preserve=yes
  //## end TransactionSpecification%41F607FA0261.declarations

//## begin module%41F607FA0261.epilog preserve=yes
//## end module%41F607FA0261.epilog