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%420720460243.cm preserve=no

//## end module%420720460243.cm

//## begin module%420720460243.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%420720460243.cp

//## Module: TransactionStream%420720460243; Pseudo Package body

//## Subsystem: MASS::Dev::Tools::TxnTestManager::src%41F5A79001E4

//## Source file: Z:\MASS_Dev\Tools\TxnTestManager\src\TransactionStream.cpp

//## begin module%420720460243.additionalIncludes preserve=no

//## end module%420720460243.additionalIncludes

//## begin module%420720460243.includes preserve=yes

#pragma warn -com

#include <LoggingMacros.h>

#pragma warn +com

#include <vcl.h>

#pragma hdrstop

//## end module%420720460243.includes

// UdFileManifest

#include "UdFileManifest.h"

// TransactionStream

#include "TransactionStream.h"

//## begin module%420720460243.additionalDeclarations preserve=yes

#if defined( WIN32 ) || defined( __BCPLUSPLUS__ ) || defined( __BORLANDC__ )

   const char g_separator = '\\';

#else

   const char g_separator = '/';

#endif

#include <iomanip>

#include <fstream>

#include <sstream>

#include <time.h>

#include <sys/stat.h>

//## end module%420720460243.additionalDeclarations

// Class TransactionStream 

//## Operation: TransactionStream%4207228700FB

TransactionStream::TransactionStream (const std::string &folder, const std::string &batchPrefix, const std::string &batchSuffix, const bool &buildManifest, const std::string &manifestPrefix, const std::string &manifestSuffix, const std::string &pathmapTarget)

  //## begin TransactionStream::TransactionStream%4207228700FB.hasinit preserve=no

      : m_batchNumber(1),

        m_batchCount(0),

        m_batchPrefix(batchPrefix),

        m_batchSize(0),

        m_batchSuffix(batchSuffix),

        m_folder(folder),

        m_stream(0),

        m_manifest(0),

        m_filename("")

  //## end TransactionStream::TransactionStream%4207228700FB.hasinit

  //## begin TransactionStream::TransactionStream%4207228700FB.initialization preserve=yes

  //## end TransactionStream::TransactionStream%4207228700FB.initialization

{

  //## begin TransactionStream::TransactionStream%4207228700FB.body preserve=yes

	if ( buildManifest )

	{

		m_manifest = new UdFileManifest(

			folder,

			manifestPrefix,

			manifestSuffix,

			pathmapTarget );

	}

  //## end TransactionStream::TransactionStream%4207228700FB.body

}

TransactionStream::~TransactionStream()

{

  //## begin TransactionStream::~TransactionStream%420720460243_dest.body preserve=yes

	close();

	if ( m_manifest )

	{

		delete m_manifest;

		m_manifest = 0;

	}

  //## end TransactionStream::~TransactionStream%420720460243_dest.body

}

//## Other Operations (implementation)

//## Operation: buildFileName%420821AD02EF

std::string & TransactionStream::buildFileName (std::string &filename, const std::string &folder, const std::string &prefix, const std::string &suffix, const std::string &batchName, const unsigned &batchNumber)

{

  //## begin TransactionStream::buildFileName%420821AD02EF.body preserve=yes

	static const int	base = 62;

	static const char	encoding[ base ] =

		"0123456789"

		"ABCDEFGHIJKLMNOPQRSTUVWXYZ"

		"abcdefghijklmnopqrstuvwxyz";

	/**

	 *	TDateTime is in local time, and the DCE currently uses UTC.  Therefore,

	 *	we use time() to get seconds since midnight in UTC, and use TDateTime

	 *	only to get msec.

	 */

	unsigned short	hour;

	unsigned short	minute;

	unsigned short	second;

	unsigned short	millisecond;

	struct stat		statbuf;

	time_t			now;

	char			encodingTime[ 9 ];

	/**

	 *	Do this until we have a filename, but no more than 10,000 iterations,

	 *	which should be a little over 10 seconds.

	 */

	for ( int safetyLimit = 10000; safetyLimit; --safetyLimit )

	{

		TDateTime::CurrentDateTime().DecodeTime(

			&hour,

			&minute,

			&second,

			&millisecond );

		time( &now );

		encodingTime[ 6 ] = encoding[ millisecond % base ];

		millisecond /= base;

		encodingTime[ 5 ] = encoding[ millisecond % base ];

		encodingTime[ 4 ] = encoding[ now % base ];

		now /= base;

		encodingTime[ 3 ] = encoding[ now % base ];

		now /= base;

		encodingTime[ 2 ] = encoding[ now % base ];

		now /= base;

		encodingTime[ 1 ] = encoding[ now % base ];

		now /= base;

		encodingTime[ 0 ] = encoding[ now % base ];

		for ( int counter=0; counter < base; ++counter )

		{

			encodingTime[ 7 ] = encoding[ counter ];

			encodingTime[ 8 ] = 0;

			std::stringstream name;

			if ( folder.length() )

			{

				name << folder;

				if ( folder[ folder.length() - 1 ] != g_separator )

				{

					name << g_separator;

				}

			}

			if ( prefix.length() )

			{

				name << prefix;

			}

			name << encodingTime;

			if ( batchName.length() )

			{

				name << '_' << batchName << '_' << std::setw( 4 ) << std::setfill( '0' ) << std::right << batchNumber;

			}

			if ( suffix.length() )

			{

				name << suffix;

			}

			filename = name.str();

			if ( stat( filename.c_str(), &statbuf ) == -1 )

			{

				return ( filename );

			}

		}

		Sleep( 1 );

	}

	MTHROW( std::runtime_error, \

		"Cannot build a filename that is not already in use in \"" \

		<< folder \

		<< "\" with prefix \"" \

		<< prefix \

		<< "\" and suffix \"" \

		<< suffix \

		<< "\"." );

  //## end TransactionStream::buildFileName%420821AD02EF.body

}

//## Operation: close%420819C203E4

void TransactionStream::close ()

{

  //## begin TransactionStream::close%420819C203E4.body preserve=yes

	if ( m_stream )

	{

      m_stream->close();

		delete m_stream;

		m_stream = 0;

		AnsiString tmpathname, targetpathname;

      tmpathname = "../data/tmp/" + AnsiString( m_filename.c_str());

      targetpathname = AnsiString( m_folder.c_str()) + "\\" + AnsiString( m_filename.c_str());

      if (FileExists(tmpathname))

      {

         if (!RenameFile(tmpathname, targetpathname))

         {

            MessageDlg(	"cannot rename temporary UD file " + tmpathname

                        + " to " + targetpathname,

								mtConfirmation,TMsgDlgButtons() << mbOK, 0 ) ;

	      }

      }

      else

      {

         MessageDlg(	"cannot rename " + tmpathname + " as it does not exist",

							mtConfirmation,TMsgDlgButtons() << mbOK, 0 ) ;

	   }    

	}

  //## end TransactionStream::close%420819C203E4.body

}

//## Operation: incrementCount%420723C60224

void TransactionStream::incrementCount ()

{

  //## begin TransactionStream::incrementCount%420723C60224.body preserve=yes

	/**

	 *	When we have a batch size (and so we batch), then we may need to

	 *	start a new batch.

	 */

	if ( m_batchSize )

	{

		if ( m_batchCount++ >= m_batchSize )

		{

			close();

			m_batchCount = 0;

			++m_batchNumber;

			open();

		}

	}

  //## end TransactionStream::incrementCount%420723C60224.body

}

//## Operation: newBatch%420722B50215

const bool TransactionStream::newBatch (const unsigned &size, const std::string &name)

{

  //## begin TransactionStream::newBatch%420722B50215.body preserve=yes

	/**

	 *	Do we have a batch in progress

	 */

	if ( m_batchCount++ > 0 )

		{

			close();

			++m_batchNumber;

		}

	m_batchSize		= size;

	m_batchCount	= 0;

	m_batchName		= name;

	return ( open() );

  //## end TransactionStream::newBatch%420722B50215.body

}

//## Operation: open%420819AE03C4

const bool TransactionStream::open ()

{

  //## begin TransactionStream::open%420819AE03C4.body preserve=yes

	close();	// Close the stream should it be open.

	std::string filename;

   AnsiString tmpathname;

	buildFileName( filename, "", m_batchPrefix, m_batchSuffix, m_batchName, m_batchNumber );

	m_filename = filename; //save for later

   tmpathname = "../data/tmp/" + AnsiString( filename.c_str());

	m_stream = new std::ofstream(

		tmpathname.c_str(),

		std::ios_base::binary | std::ios_base::out );

	if ( m_stream->is_open() )

	{

		if ( m_manifest )

		{

			m_manifest->addUdFile( filename );

		}

		return ( true );

	}

	// When we can't open the file, then roll back.

	delete m_stream;

	m_stream = 0;

	MERROR( "Cannot open \"" << filename << "\" for writing." );

	return ( false );

  //## end TransactionStream::open%420819AE03C4.body

}

//## Operation: write%4207231D014A

const bool TransactionStream::write (const void *buffer, const unsigned &length)

{

  //## begin TransactionStream::write%4207231D014A.body preserve=yes

	if ( m_stream )

	{

		m_stream->write( reinterpret_cast< const char * >( buffer ), length );

		if ( m_stream->good() )

		{

			return ( true );

		}

		else

		{

			MERROR( "Cannot write " << length << " byte(s) to stream." );

		}

	}

	else

	{

		MERROR( "Cannot write to stream because it is not open." );

	}

	return ( false );

  //## end TransactionStream::write%4207231D014A.body

}

// Additional Declarations

  //## begin TransactionStream%420720460243.declarations preserve=yes

  //## end TransactionStream%420720460243.declarations

const void TransactionStream::logToManifest (const std::string & info, const bool &addTime )

{

     TDateTime t;

     String st = "";

     String details;

     if (addTime) 

     {

        t = Time();

        st = TimeToStr(t) + "   ";

     }

     details = "# " + st + AnsiString(info.c_str());

     //pass the data on without added value at this stage

     if ( m_manifest )

     {

         m_manifest->addTestDetails(details.c_str());

     }

}

//## begin module%420720460243.epilog preserve=yes

//## end module%420720460243.epilog