Subversion Repositories DevTools

//## 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,

			}

			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,

					}

				}

				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,

			}

		}

		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