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

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

        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;
        buildFileName( filename, m_folder, m_batchPrefix, m_batchSuffix, m_batchName, m_batchNumber );

        m_stream = new std::ofstream(
                filename.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

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