src/tools/tRecorder.h

Go to the documentation of this file.

/*

*************************************************************************

ArmageTron -- Just another Tron Lightcycle Game in 3D.
Copyright (C) 2000  Manuel Moos (manuel@moosnet.de)

**************************************************************************

This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
  
***************************************************************************

*/

#ifndef     TRECORDER_H_INCLUDED
#define     TRECORDER_H_INCLUDED

#ifdef DEBUG
#ifndef DEBUG_DIFFERENCE
#define DEBUG_DIFFERENCE
#endif
#endif

// self include
#ifndef     TRECORDER_H_INCLUDED
#include    "tRecorder.h"
#endif

#include    "tString.h"
#include    "tError.h"

// #include    "tRecorderInternal.h"

// *****************************************************************************
// Helpers required to work around VisualC's iability to handle out-of-line
// template members. Just ignore them.
// *****************************************************************************

template< class BLOCK >
class tRecorderTemplate1
{
public:
    static bool Archive( bool strict, char const * section );                  
};

template< class BLOCK, typename DATA >
class tRecorderTemplate2
{
public:
    static bool Archive( bool strict, char const * section, DATA data );                  
};

template< class BLOCK, typename DATA1, typename DATA2 >
class tRecorderTemplate3
{
public:
    static bool Archive( bool strict, char const * section, DATA1 data1, DATA2 data2 );  
};

// *****************************************************************************
// tRecorder: simple recording interface. Most users will only need this.
// *****************************************************************************

class tRecordingBlock;
class tPlaybackBlock;

class tRecorderBase
{
public:
    static bool IsRecording();                          
    static bool IsPlayingBack();                        
    static bool IsRunning();                            
};

class tRecorder: public tRecorderBase
{
public:
    static bool Record( char const * section );         
    static bool Playback( char const * section );       
    static bool PlaybackStrict( char const * section ); 

    template< class DATA >
    static bool Record  ( char const * section, DATA const & data )
    { return tRecorderTemplate2< tRecordingBlock, DATA const & >::Archive( false, section, data ); }

    template< class DATA >
    static bool Playback( char const * section, DATA & data )
    { return tRecorderTemplate2< tPlaybackBlock, DATA & >::Archive( false, section, data ); }

    template< class DATA >
    static bool PlaybackStrict( char const * section, DATA & data )
    { return tRecorderTemplate2< tPlaybackBlock, DATA & >::Archive( true, section, data ); }

    template< class DATA1, class DATA2 >
    static bool Record( char const * section, DATA1 const & data1, DATA2 const & data2 )
    { return tRecorderTemplate3< tRecordingBlock, DATA1 const & , DATA2 const & >::Archive( false, section, data1, data2 ); }

    template< class DATA1, class DATA2 >
    static bool Playback( char const * section, DATA1 & data1, DATA2 & data2 )
    { return tRecorderTemplate3< tPlaybackBlock, DATA1 &, DATA2 & >::Archive( false, section, data1, data2 ); }

    template< class DATA1, class DATA2 >
    static bool PlaybackStrict( char const * section, DATA1 & data1, DATA2 & data2 )
    { return tRecorderTemplate3< tPlaybackBlock, DATA1 &, DATA2 & >::Archive( true, section, data1, data2 ); }
};

class tPath;

class tTextFileRecorder: public tRecorderBase
{
public:
    tTextFileRecorder();
    ~tTextFileRecorder();

    bool Open( tPath const & searchPath, char const * fileName );

    tTextFileRecorder( tPath const & searchPath, char const * fileName );

    bool EndOfFile() const;

    std::string GetLine();
private:
    // disable copying
    tTextFileRecorder(tTextFileRecorder const &);
    tTextFileRecorder & operator = (tTextFileRecorder const &);

    std::ifstream * stream_; 
    bool eof_;               
};

// typedef tRecorderTemplate<int> tRecorder;

// *****************************************************************************
// helper classes for converting data before it gets archived
// *****************************************************************************

template< class T > struct tTypeToStream
{
    typedef T TOSTREAM;             
    typedef int DUMMYREQUIRED;      
};

// recording (and back after playback) by specializing the tTypeToStream class template
#define tRECORD_AS( TYPE, STREAM ) \
template<> struct tTypeToStream< TYPE > \
{ \
    typedef STREAM TOSTREAM; \
  typedef int * DUMMYREQUIRED; \
} \

#define tRECORDING_ENUM( TYPE ) tRECORD_AS( TYPE, int )

// record chars as ints for human readability
tRECORD_AS( char, int );
tRECORD_AS( unsigned char, int );

class tLineString: public tString
{
public:
    tLineString( tString const & ); 
    tLineString();                  
    ~tLineString();                 
};

std::ostream & operator << ( std::ostream & s, tLineString const & line );

std::istream & operator >> ( std::istream & s, tLineString & line );

tRECORD_AS( tString, tLineString );

// *****************************************************************************
// support for debugging only recording (for intermediate data)
// *****************************************************************************

class tRecorderSyncBase
{
public:
    static int GetDebugLevelPlayback();

    static int GetDebugLevelRecording();
};

template< class DATA >
class tRecorderSync: public tRecorderSyncBase
{
public:
    static void Archive( char const * section, int debugLevel, DATA & data );

private:
    static float GetDifference( DATA const & a, DATA const & b );
};

// *****************************************************************************
// another helper class
// *****************************************************************************

template < class DATA > class tRecorderBlockHelper
{
public:
    static void Write ( std::ostream & stream, DATA const & data, int nodummyrequired );        
    static void Write ( std::ostream & stream, DATA const & data, int * dummyrequired );        

    static void Read  ( std::istream & stream, DATA & data, int nodummyrequired );        
    static void Read  ( std::istream & stream, DATA & data, int * dummyrequired );        
};

// *****************************************************************************
// recording blocks for stuffing more data inside a section than two elements
// *****************************************************************************

class tRecording;

class tRecordingBlockBase
{
public:
    bool Initialize( char const * section, tRecording * recording );  
    bool Initialize( char const * section );                          

    void Separator();                                                 
    static tRecording * GetArchive();                                 
protected:
    tRecordingBlockBase();                                            
    ~tRecordingBlockBase();                                           

    std::ostream & GetRecordingStream() const;                        

    bool separate_;                                                   
private:
    tRecording * recording_;                                          
};

class tRecordingBlock: public tRecordingBlockBase
{
public:
    tRecordingBlock();                                                     
    ~tRecordingBlock();                                                    

    template< class T > tRecordingBlock & operator << ( T const & data ) { return Write( data ); }

    template< class T > tRecordingBlock & Archive     ( T const & data ) { return Write( data ); }

    template< class T > tRecordingBlock & Write       ( T const & data )
    {
        // get stream
        std::ostream & stream = GetRecordingStream();

        // add separator
        if ( separate_ )
            stream << ' ';
        separate_ = true;

        // delegate to dummy using or dummyless function
        typename tTypeToStream< T >::DUMMYREQUIRED dummyRequired = 0;
        tRecorderBlockHelper< T >::Write( stream, data, dummyRequired );

        return *this;
    }
};

// *****************************************************************************

class tPlayback;

class tPlaybackBlockBase
{
public:
    bool Initialize( char const * section, tPlayback * playback );    
    bool Initialize( char const * section );                          

    void Separator() const;                                           
    static tPlayback * GetArchive();                                  
protected:
    tPlaybackBlockBase();                                             
    ~tPlaybackBlockBase();                                            

    std::istream & GetPlaybackStream() const;                         

private:
    tPlayback * playback_;                                             
};

class tPlaybackBlock: public tPlaybackBlockBase
{
public:
    tPlaybackBlock();                                         
    ~tPlaybackBlock();                                        

    template< class T > tPlaybackBlock & operator >> ( T & data ){ return Read( data ); }

    template< class T > tPlaybackBlock & Archive     ( T & data ){ return Read( data ); }

    template< class T > tPlaybackBlock & Read        ( T & data )
    {
        // delegate to dummy using or dummyless function
        typename tTypeToStream< T >::DUMMYREQUIRED dummyrequired = 0;
        tRecorderBlockHelper< T >::Read( GetPlaybackStream(), data, dummyrequired );

        return *this;
    }
};

// typedef tRecordingBlockTemplate< int > tRecordingBlock;
// typedef tPlaybackBlockTemplate< int > tPlaybackBlock;

// Note: both tRecordingBlock and tPlaybackBlock share common mebe fuctions. See uInputQueue.cpp
// (or the tRecorderTemplate::Archive implementation) how to
// exploit this with templates to make sure you read exaclty the same data as you write.

// *****************************************************************************
// * Implementation
// *****************************************************************************

/*

// *******************************************************************************************
// *
// *    Record
// *
// *******************************************************************************************
// *******************************************************************************************

template< class DUMMY  >
template<  class DATA >
bool tRecorderTemplate< DUMMY >::Record( char const * section, DATA const & data )
{
    // delegate
    return Archive< tRecordingBlock >( false, section, data );
}

// *******************************************************************************************
// *
// *    Playback
// *
// *******************************************************************************************
// *******************************************************************************************

template< class DUMMY  >
template<  class DATA >
bool tRecorderTemplate< DUMMY >::Playback( char const * section, DATA & data )
{
    // delegate
    return Archive< tPlaybackBlock >( false, section, data );
}

// *******************************************************************************************
// *
// *    PlaybackStrict
// *
// *******************************************************************************************
// *******************************************************************************************

template< class DUMMY  >
template<  class DATA >
bool tRecorderTemplate< DUMMY >::PlaybackStrict( char const * section, DATA & data )
{
    // delegate
    return Archive< tPlaybackBlock >( true, section, data );
}

// *******************************************************************************************
// *
// *    Record
// *
// *******************************************************************************************
// *******************************************************************************************

template< class DUMMY  >
template<  class DATA1, class DATA2 >
bool tRecorderTemplate< DUMMY >::Record( char const * section, DATA1 const & data1, DATA2 const & data2 )
{
    // delegate
    return Archive< tRecordingBlock >( false, section, data1, data2 );
}

// *******************************************************************************************
// *
// *    Playback
// *
// *******************************************************************************************
// *******************************************************************************************

template< class DUMMY  >
template<  class DATA1, class DATA2 >
bool tRecorderTemplate< DUMMY >::Playback( char const * section, DATA1 & data1, DATA2 & data2 )
{
    // delegate
    return Archive< tPlaybackBlock >( false, section, data1, data2 );
}

// *******************************************************************************************
// *
// *    PlaybackStrict
// *
// *******************************************************************************************
// *******************************************************************************************

template< class DUMMY  >
template<  class DATA1, class DATA2 >
bool tRecorderTemplate< DUMMY >::PlaybackStrict( char const * section, DATA1 & data1, DATA2 & data2 )
{
    // delegate
    return Archive< tPlaybackBlock >( true, section, data1, data2 );
}

// *******************************************************************************************
// *    
// *    Archive
// *    
// *******************************************************************************************
// *******************************************************************************************

template< class DUMMY  >
template<  class BLOCK >
bool tRecorderTemplate< DUMMY >::Archive( bool strict, char const * section )
{
    // create recording/playback block
    BLOCK block;

    // initialize
    if ( block.Initialize( section ) )
    {
        // return success
        return true;
    }

    // report failure
    tASSERT( !strict  || !BLOCK::GetArchive() );
    return false;
}

// *******************************************************************************************
// *    
// *    Archive
// *    
// *******************************************************************************************
// *******************************************************************************************

template< class DUMMY  >
template<  class BLOCK, class DATA >
bool tRecorderTemplate< DUMMY >::Archive( bool strict, char const * section, DATA & data )
{
    // create recording/playback block
    BLOCK block;

    // initialize
    if ( block.Initialize( section ) )
    {
        // successfully initialized: archive data
        block.Archive( data );

        // return success
        return true;
    }

    // report failure
    tASSERT( !strict || !BLOCK::GetArchive() );
    return false;
}

// *******************************************************************************************
// *    
// *    Archive
// *    
// *******************************************************************************************
// *******************************************************************************************

template< class DUMMY  >
template<  class BLOCK, class DATA1, class DATA2 >
bool tRecorderTemplate< DUMMY >::Archive( bool strict, char const * section, DATA1 & data1, DATA2 & data2 )
{
    // create recording/playback block
    BLOCK block;

    // initialize
    if ( block.Initialize( section ) )
    {
        // successfully initialized: archive data
        block.Archive( data1 ).Archive( data2 );

        // return success
        return true;
    }

    // report failure
    tASSERT( !strict  || !BLOCK::GetArchive() );
    return false;
}

// *******************************************************************************************
// *******************************************************************************************
// *******************************************************************************************
// *******************************************************************************************

// *******************************************************************************************
// *
// *    tRecordingBlockTemplate
// *
// *******************************************************************************************
// *******************************************************************************************

template< class DUMMY >
tRecordingBlockTemplate< DUMMY >::tRecordingBlockTemplate( void )
{
}

// *******************************************************************************************
// *
// *    ~tRecordingBlockTemplate
// *
// *******************************************************************************************
// *******************************************************************************************

template< class DUMMY >
tRecordingBlockTemplate< DUMMY >::~tRecordingBlockTemplate( void )
{
}

// *******************************************************************************************
// *
// *    operator <<
// *
// *******************************************************************************************
// *******************************************************************************************

template< class DUMMY  >
template<  class T >
tRecordingBlockTemplate< DUMMY > & tRecordingBlockTemplate< DUMMY >::operator <<( T const & data )
{
    // delegate
    return Write( data );
}

// *******************************************************************************************
// *
// *    Archive
// *
// *******************************************************************************************
// *******************************************************************************************

template< class DUMMY  >
template<  class T >
tRecordingBlockTemplate< DUMMY > & tRecordingBlockTemplate< DUMMY >::Archive( T const & data )
{
    // delegate
    return Write( data );
}

// *******************************************************************************************
// *
// *    Write
// *
// *******************************************************************************************
// *******************************************************************************************

template< class DUMMY  >
template<  class T >
tRecordingBlockTemplate< DUMMY > & tRecordingBlockTemplate< DUMMY >::Write( T const & data )
{
    // get stream
    std::ostream & stream = GetRecordingStream();

    // add small separator
    if (separate_)
        stream << ' ';
    separate_ = true;

    // delegate to dummy using or dummyless function
    typename tTypeToStream< T >::DUMMYREQUIRED dummyrequired = 0;
    Write( data, dummyrequired );

    return *this;
}

// *******************************************************************************************
// *
// *    Write
// *
// *******************************************************************************************
// *******************************************************************************************

template< class DUMMY  >
template<  class T >
void tRecordingBlockTemplate< DUMMY >::Write( T const & data, int nodummyrequired )
{
    // get stream
    std::ostream & stream = GetRecordingStream();

    // add small separator
    stream << ' ';
    
    // write
    stream << data;

}

// *******************************************************************************************
// *
// *    Write
// *
// *******************************************************************************************
// *******************************************************************************************

template< class DUMMY  >
template<  class T >
void tRecordingBlockTemplate< DUMMY >::Write( T const & data, int * dummyrequired )
{
    // get stream
    std::ostream & stream = GetRecordingStream();
    
    // write ( converted )
    typedef typename tTypeToStream< T >::TOSTREAM TOSTREAM;
    TOSTREAM dummy = static_cast< TOSTREAM >( data );
    stream << dummy;
}

// *******************************************************************************************
// *******************************************************************************************
// *******************************************************************************************
// *******************************************************************************************

// *******************************************************************************************
// *
// *    tPlaybackBlockTemplate
// *
// *******************************************************************************************
// *******************************************************************************************

template< class DUMMY >
tPlaybackBlockTemplate< DUMMY >::tPlaybackBlockTemplate( void )
{
}

// *******************************************************************************************
// *
// *    ~tPlaybackBlockTemplate
// *
// *******************************************************************************************
// *******************************************************************************************

template< class DUMMY >
tPlaybackBlockTemplate< DUMMY >::~tPlaybackBlockTemplate( void )
{
}

// *******************************************************************************************
// *
// *    operator >>
// *
// *******************************************************************************************
// *******************************************************************************************

template< class DUMMY  >
template<  class T >
tPlaybackBlockTemplate< DUMMY > & tPlaybackBlockTemplate< DUMMY >::operator >>( T & data )
{
    // delegate
    return Read( data );
}

// *******************************************************************************************
// *
// *    Archive
// *
// *******************************************************************************************
// *******************************************************************************************

template< class DUMMY  >
template<  class T >
tPlaybackBlockTemplate< DUMMY > & tPlaybackBlockTemplate< DUMMY >::Archive( T & data )
{
    // delegate
    return Read( data );
}

// *******************************************************************************************
// *
// *    Read
// *
// *******************************************************************************************
// *******************************************************************************************

template< class DUMMY  >
template<  class T >
tPlaybackBlockTemplate< DUMMY > & tPlaybackBlockTemplate< DUMMY >::Read( T & data )
{
    // delegate to dummy using or dummyless function
    typename tTypeToStream< T >::DUMMYREQUIRED dummyrequired = 0;
    Read( data, dummyrequired );

    return *this;
}

// *******************************************************************************************
// *
// *    Read
// *
// *******************************************************************************************
// *******************************************************************************************

template< class DUMMY  >
template<  class T >
void tPlaybackBlockTemplate< DUMMY >::Read( T & data, int nodummyrequired )
{
    // get stream
    std::istream & stream = GetPlaybackStream();
    tASSERT( stream.good() );

    // read
    stream >> data;
}

// *******************************************************************************************
// *
// *    Read
// *
// *******************************************************************************************
// *******************************************************************************************

template< class DUMMY  >
template<  class T >
void tPlaybackBlockTemplate< DUMMY >::Read( T & data, int * dummyrequired )
{
    // get stream
    std::istream & stream = GetPlaybackStream();
    tASSERT( stream.good() );

    // read ( with conversion )
    typedef typename tTypeToStream< T >::TOSTREAM TOSTREAM;
    TOSTREAM dummy ;
    stream >> dummy;
    data = static_cast< T >( dummy );
}

*/

// ******************************************************************************************
// *
// *    Archive
// *
// ******************************************************************************************
// ******************************************************************************************

template< class DATA >
void tRecorderSync< DATA >::Archive( char const * section, int level, DATA & data )
{
    // see if it is really a DEBUG only section
    tASSERT( section && *section == '_' );

    if ( level <= GetDebugLevelPlayback() )
    {
        DATA copy = data;

        // read data from archive
        if ( tRecorder::PlaybackStrict( section, copy ) )
        {
#ifdef DEBUG_DIFFERENCE
            // determine difference
            REAL diff = GetDifference( data, copy );

            static REAL alarmDiff = EPS;
            if ( diff > alarmDiff )
            {
                alarmDiff = diff * 2;
                REAL st_GetDifference( REAL a, REAL b);
                REAL st_GetDifference( int a, int b);
                REAL st_GetDifference( tString const & a, tString const & b );
                std::cout << "Syncing difference found: " << data << "!=" << copy << " by " << diff << "\n";
                st_Breakpoint();
            }
#endif

            // restore data, hoping that the playback can take the little bump
            if ( level <= GetDebugLevelRecording() )
            {
                data = copy;
            }
        }
        else if ( tRecorder::IsPlayingBack() )
        {
            std::cout << "Syncing difference found: expected " << section << ".\n";

            st_Breakpoint();
        }
    }

    // archive data
    if ( level <= GetDebugLevelRecording() )
        tRecorder::Record( section, data );
}

REAL st_GetDifference( REAL a, REAL b);
REAL st_GetDifference( int a, int b);
REAL st_GetDifference( unsigned int a, unsigned int b);
REAL st_GetDifference( long unsigned int a, long unsigned int b);
REAL st_GetDifference( tString const & a, tString const & b );

// ******************************************************************************************
// *
// *    GetDifference
// *
// ******************************************************************************************
// ******************************************************************************************

template< class DATA >
float tRecorderSync< DATA >::GetDifference( DATA const & a, DATA const & b )
{
    return st_GetDifference( a, b );
}

// ******************************************************************************************
// *
// *    Archive
// *
// ******************************************************************************************
// ******************************************************************************************

template< class BLOCK >
bool tRecorderTemplate1< BLOCK >::Archive( bool strict, char const * section )
{
    // create recording/playback block
    BLOCK block;

    // initialize
    if ( block.Initialize( section ) )
    {
        // return success
        return true;
    }

    // report failure
    tASSERT( !strict  || !BLOCK::GetArchive() );
    return false;
}

// ******************************************************************************************
// *
// *    Archive
// *
// ******************************************************************************************
// ******************************************************************************************

template< class BLOCK, typename DATA >
bool tRecorderTemplate2< BLOCK, DATA >::Archive( bool strict, char const * section, DATA data )
{
    // create recording/playback block
    BLOCK block;

    // initialize
    if ( block.Initialize( section ) )
    {
        // successfully initialized: archive data
        block.Archive( data );

        // return success
        return true;
    }

    // report failure
    tASSERT( !strict || !BLOCK::GetArchive() );
    return false;
}

// ******************************************************************************************
// *
// *    Archive
// *
// ******************************************************************************************
// ******************************************************************************************

template< class BLOCK, typename DATA1, typename DATA2 >
bool tRecorderTemplate3< BLOCK, DATA1, DATA2 >::Archive( bool strict, char const * section, DATA1 data1, DATA2 data2 )
{
    // create recording/playback block
    BLOCK block;

    // initialize
    if ( block.Initialize( section ) )
    {
        // successfully initialized: archive data
        block.Archive( data1 ).Archive( data2 );

        // return success
        return true;
    }

    // report failure
    tASSERT( !strict  || !BLOCK::GetArchive() );
    return false;
}

// ******************************************************************************************
// *
// *    Write
// *
// ******************************************************************************************
// ******************************************************************************************

template< class DATA >
void tRecorderBlockHelper< DATA >::Write( std::ostream & stream, DATA const & data, int nodummyrequired )
{
    // write
    stream << data;
}

// ******************************************************************************************
// *
// *    Write
// *
// ******************************************************************************************
// ******************************************************************************************

template< class DATA >
void tRecorderBlockHelper< DATA >::Write( std::ostream & stream, DATA const & data, int * dummyrequired )
{
    // write ( converted )
    typedef typename tTypeToStream< DATA >::TOSTREAM TOSTREAM;
    TOSTREAM dummy = static_cast< TOSTREAM >( data );
    stream << dummy;
}

// ******************************************************************************************
// *
// *    Read
// *
// ******************************************************************************************
// ******************************************************************************************

template< class DATA >
void tRecorderBlockHelper< DATA >::Read( std::istream & stream, DATA & data, int nodummyrequired )
{
    tASSERT( stream.good() );

    // read
    stream >> data;
}

// ******************************************************************************************
// *
// *    Read
// *
// ******************************************************************************************
// ******************************************************************************************

template< class DATA >
void tRecorderBlockHelper< DATA >::Read( std::istream & stream, DATA & data, int * dummyrequired )
{
    tASSERT( stream.good() );

    // read ( with conversion )
    typedef typename tTypeToStream< DATA >::TOSTREAM TOSTREAM;
    TOSTREAM dummy ;
    stream >> dummy;
    data = static_cast< DATA >( dummy );
}

#endif // TRECORDING_H_INCLUDED

---