src/tools/tRecorder.cpp

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.
  
***************************************************************************

*/

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

#include    "tConfiguration.h"
#include    "tDirectories.h"
#include    "tRecorderInternal.h"

#undef  INLINE_DEF
#define INLINE_DEF

// *****************************************************************************************
// *
// *   IsRecording
// *
// *****************************************************************************************
// *****************************************************************************************

bool tRecorderBase::IsRecording( void )
{
    return tRecordingBlock::GetArchive();
}

// *****************************************************************************************
// *
// *   IsPlayingBack
// *
// *****************************************************************************************
// *****************************************************************************************

bool tRecorderBase::IsPlayingBack( void )
{
    return tPlaybackBlock::GetArchive();
}

// *****************************************************************************************
// *
// *   IsRunning
// *
// *****************************************************************************************
// *****************************************************************************************

bool tRecorderBase::IsRunning( void )
{
    return IsRecording() || IsPlayingBack();
}

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

bool tRecorder::Record( char const * section )
{
    // delegate
    return tRecorderTemplate1< tRecordingBlock >::Archive( false, section );
}

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

bool tRecorder::Playback( char const * section )
{
    // delegate
    return tRecorderTemplate1< tPlaybackBlock >::Archive( false, section );
}

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

bool tRecorder::PlaybackStrict( char const * section )
{
    // delegate
    return tRecorderTemplate1< tPlaybackBlock >::Archive( true, section );
}

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

// *****************************************************************************************
// *
// *    tLineString
// *
// *****************************************************************************************
// *****************************************************************************************

tLineString::tLineString( tString const & other )
        :tString( other )
{
}

// *****************************************************************************************
// *
// *    tLineString
// *
// *****************************************************************************************
// *****************************************************************************************

tLineString::tLineString( void )
{
}

// *****************************************************************************************
// *
// *    ~tLineString
// *
// *****************************************************************************************
// *****************************************************************************************

tLineString::~tLineString( void )
{
}

std::ostream & operator << ( std::ostream & s, tLineString const & line )
{
    // write magic character
    s << 'L';

    // print string, encode newlines
    for( int i=0; i<line.Len(); ++i)
    {
        char c = line[i];
        if ( c == '\n' )
            s << "\\n";
        if ( c == '\\' )
            s << "\\\\";
        else if ( c != '\0' )
            s << c;
    }

    return s << '\n';
}

std::istream & operator >> ( std::istream & s, tLineString & line )
{
    // read magic character
    char c;
    s >> c;
    tASSERT( 'L' == c );

    tString read;

    // read line
    read.ReadLine(s);

    // std::cout << "Read: " << read << "\n";

    line.Clear();

    // copy line, replacing "\n" with real newline
    for(size_t i=0; i<read.Size(); ++i)
    {
        char c = read[i];
        if ( c != '\\' || i+1 == read.Size() || ( read[i+1] != 'n' && read[i+1] != '\\' ) )
        {
            line << c;
        }
        else if ( read[i+1] == '\\' )
        {
            line << "\\";
            i++;
        }
        else // if ( read[i+1] != 'n' )
        {
            line << "\n";
            i++;
        }
    }

    return s;
}

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

// *****************************************************************************************
// *
// *    Initialize
// *
// *****************************************************************************************
// *****************************************************************************************

bool tRecordingBlockBase::Initialize( char const * section, tRecording * recording )
{
    // initialize recording pointer
    recording_ = recording;
    if (!recording_)
        return false;

    // start section
    recording_->BeginSection( section );

    // return success
    return true;
}

// *****************************************************************************************
// *
// *    Initialize
// *
// *****************************************************************************************
// *****************************************************************************************

bool tRecordingBlockBase::Initialize( char const * section )
{
    // delegate
    return Initialize( section, tRecording::currentRecording_ );
}

// *****************************************************************************************
// *
// *    Separator
// *
// *****************************************************************************************
// *****************************************************************************************

void tRecordingBlockBase::Separator( void )
{
    GetRecordingStream() << "\n";
    separate_ = false;
}

// ******************************************************************************************
// *
// *    GetArchive
// *
// ******************************************************************************************
// ******************************************************************************************

tRecording * tRecordingBlockBase::GetArchive( void )
{
    return tRecording::currentRecording_;
}

// *****************************************************************************************
// *
// *    tRecordingBlockBase
// *
// *****************************************************************************************
// *****************************************************************************************

tRecordingBlockBase::tRecordingBlockBase( void )
        : separate_( true ), recording_( NULL )
{
}

// *****************************************************************************************
// *
// *    ~tRecordingBlockBase
// *
// *****************************************************************************************
// *****************************************************************************************

tRecordingBlockBase::~tRecordingBlockBase( void )
{
    // make sure everything is logged, even if program crashes
    if (recording_)
        GetRecordingStream().flush();

    recording_ = 0;
}

// *****************************************************************************************
// *
// *    GetRecordingStream
// *
// *****************************************************************************************
// *****************************************************************************************

std::ostream & tRecordingBlockBase::GetRecordingStream() const
{
    tASSERT( recording_ );

    return recording_->DoGetStream();
}

// *******************************************************************************************
// *
// *    tRecordingBlock
// *
// *******************************************************************************************
// *******************************************************************************************

tRecordingBlock::tRecordingBlock( void )
{
}

// *******************************************************************************************
// *
// *    ~tRecordingBlock
// *
// *******************************************************************************************
// *******************************************************************************************

tRecordingBlock::~tRecordingBlock( void )
{
}

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

// *****************************************************************************************
// *
// *    Initialize
// *
// *****************************************************************************************
// *****************************************************************************************

bool tPlaybackBlockBase::Initialize( char const * section, tPlayback * playback )
{
    // initialize playback pointer
    playback_ = playback;
    if (!playback_)
        return false;

    // read section
    if( playback_->GetNextSection() != section )
    {
        playback_ = NULL;
        return false;
    }

    // return success
    return true;
}

// *****************************************************************************************
// *
// *    Initialize
// *
// *****************************************************************************************
// *****************************************************************************************

bool tPlaybackBlockBase::Initialize( char const * section )
{
    return Initialize( section, tPlayback::currentPlayback_ );
}

// *****************************************************************************************
// *
// *    Separator
// *
// *****************************************************************************************
// *****************************************************************************************

void tPlaybackBlockBase::Separator( void ) const
{
}
// ******************************************************************************************
// *
// *    GetArchive
// *
// ******************************************************************************************
// ******************************************************************************************

tPlayback * tPlaybackBlockBase::GetArchive( void )
{
    return tPlayback::currentPlayback_;
}

// *****************************************************************************************
// *
// *    tPlaybackBlockBase
// *
// *****************************************************************************************
// *****************************************************************************************

tPlaybackBlockBase::tPlaybackBlockBase( void )
        : playback_( 0 )
{
}

// *****************************************************************************************
// *
// *    ~tPlaybackBlockBase
// *
// *****************************************************************************************
// *****************************************************************************************

tPlaybackBlockBase::~tPlaybackBlockBase( void )
{
    // end current block and read next
    if ( playback_ )
        playback_->AdvanceSection();

    playback_ = 0;
}

// *****************************************************************************************
// *
// *    GetPlaybackStream
// *
// *****************************************************************************************
// *****************************************************************************************

std::istream & tPlaybackBlockBase::GetPlaybackStream() const
{
    tASSERT( playback_ );

    return playback_->DoGetStream();
}

// *******************************************************************************************
// *
// *    tPlaybackBlock
// *
// *******************************************************************************************
// *******************************************************************************************

tPlaybackBlock::tPlaybackBlock( void )
{
}

// *******************************************************************************************
// *
// *    ~tPlaybackBlock
// *
// *******************************************************************************************
// *******************************************************************************************

tPlaybackBlock::~tPlaybackBlock( void )
{
}

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

static int st_debugLevelRecording=0;
static tSettingItem<int>rdb( "RECORDING_DEBUGLEVEL",
                             st_debugLevelRecording );

// returns the playback debug level, archiving the result
static int st_GetDebugLevelPlayback()
{
    // sync level with recording
    int level = st_debugLevelRecording;
    tRecorder::Playback( "DEBUGLEVEL", level );
    tRecorder::Record( "DEBUGLEVEL", st_debugLevelRecording );

    return level;
}

// *******************************************************************************************
// *
// *    GetDebugLevelPlayback
// *
// *******************************************************************************************
// *******************************************************************************************

int tRecorderSyncBase::GetDebugLevelPlayback( void )
{
    // get the playback level only once
    static int level = st_GetDebugLevelPlayback();

    return level;
}

// *******************************************************************************************
// *
// *    GetDebugLevelRecording
// *
// *******************************************************************************************
// *******************************************************************************************

int tRecorderSyncBase::GetDebugLevelRecording( void )
{
    return st_debugLevelRecording;
}

REAL st_GetDifference( REAL a, REAL b)
{
    return fabs( a - b );
}

REAL st_GetDifference( int a, int b)
{
    return fabs( REAL( a - b ) );
}

REAL st_GetDifference( unsigned int a, unsigned int b)
{
    return fabs( REAL( a - b ) );
}

REAL st_GetDifference( unsigned long int a, unsigned long int b)
{
    return fabs( REAL( a - b ) );
}

REAL st_GetDifference( tString const & a, tString const & b )
{
    return ( a == b ) ? 0 : 1;
}

static char const * st_fileOpen = "FILE_OPEN";
static char const * st_fileRead = "FILE_READ";

// *******************************************************************************
// *
// *    Open
// *
// *******************************************************************************
// *******************************************************************************

bool tTextFileRecorder::Open( tPath const & searchPath, char const * fileName )
{
    tASSERT( !stream_ );

    bool result = false;

    // try to read opening state from recording
    if ( !tRecorder::Playback( st_fileOpen, result, eof_ ) )
    {
        // open the stream (if not in recording mode)
        stream_ = tNEW( std::ifstream );
        result = searchPath.Open( *stream_, fileName );
        eof_ = !result || !stream_->good() || stream_->eof();
    }
    tRecorder::Record( st_fileOpen, result, eof_ );

    return result;
}

// *******************************************************************************
// *
// *    tTextFileRecorder
// *
// *******************************************************************************
// *******************************************************************************

tTextFileRecorder::tTextFileRecorder( tPath const & searchPath, char const * fileName )
        : stream_(NULL), eof_(false)
{
    Open( searchPath, fileName );
}

// *******************************************************************************
// *
// *    tTextFileRecorder
// *
// *******************************************************************************
// *******************************************************************************

tTextFileRecorder::tTextFileRecorder( void )
        : stream_(NULL), eof_(false)
{
    stream_ = NULL;
}

// *******************************************************************************
// *
// *    ~tTextFileRecorder
// *
// *******************************************************************************
// *******************************************************************************

tTextFileRecorder::~tTextFileRecorder( void )
{
    delete stream_;
    stream_ = NULL;
}

// *******************************************************************************
// *
// *    EndOfFile
// *
// *******************************************************************************
// *******************************************************************************

bool tTextFileRecorder::EndOfFile( void ) const
{
    return eof_;
}

// *******************************************************************************
// *
// *    GetLine
// *
// *******************************************************************************
// *******************************************************************************

std::string tTextFileRecorder::GetLine( void )
{
    // try to read opening state from recording
    tLineString line;
    if ( !tRecorder::Playback( st_fileRead, line, eof_ ) )
    {
        // read a line
        tASSERT( stream_ );
        line.ReadLine( *stream_ );
        std::ws( *stream_ );
        eof_ = !stream_->good() || stream_->eof();
    }
    tRecorder::Record( st_fileRead, line, eof_ );

    // convert and return read line
    return std::string(line);
}

---