non/Loggable.H

215 lines
4.9 KiB
C++

/*******************************************************************************/
/* Copyright (C) 2008 Jonathan Moore Liles */
/* */
/* 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; see the file COPYING. If not,write to the Free Software */
/* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
/*******************************************************************************/
/* Master class for journaling. */
#pragma once
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <assert.h>
#include <vector>
#include <map>
#include <string>
#include <queue>
using namespace std;
class Loggable;
typedef Loggable *(create_func)(char **);
class Logger;
class Loggable
{
static FILE *_fp;
static int _log_id;
static int _level;
static int _undo_index;
static vector <Loggable *> _loggables;
static map <string, create_func*> _class_map;
static queue <char *> _transaction;
private:
int _id;
char **_old_state;
char **_new_state;
int _nest;
void log_print( char **o, char **n );
static void log ( const char *fmt, ... );
static void flush ( void );
static
void indent ( void )
{
int n = Loggable::_level;
while ( n-- )
log( "\t" );
}
public:
static bool open ( const char *filename );
static void undo ( void );
static int undo_index ( void ) { return _undo_index; }
static bool snapshot( const char *file );
static
void
block_start ( void )
{
// indent();
// log( "{\n" );
++Loggable::_level;
}
static
void
block_end ( void )
{
assert( --Loggable::_level >= 0 );
// indent();
// log( "}\n" );
}
static
Loggable *
find ( int id )
{
if ( id > _log_id )
return NULL;
return _loggables[ id - 1 ];
}
Loggable ( )
{
_id = ++_log_id;
_old_state = NULL;
_nest = 0;
_loggables.push_back( this );
}
/** must be called after construction in create() methods */
void
update_id ( int id )
{
assert( _id == _log_id );
_loggables[ _id - 1 ] = NULL;
--_log_id;
_id = id;
assert( ! _loggables[ _id - 1 ] );
_loggables[ _id - 1 ] = this;
}
virtual ~Loggable ( )
{
_loggables[ _id - 1 ] = NULL;
}
static
void
register_create ( const char *name, create_func *func )
{
printf( "registering %s to %p\n", name, func );
_class_map[ string( name ) ] = func;
}
/* log messages for journal */
virtual const char *class_name ( void ) = 0;
virtual char ** get ( void ) = 0;
/* this method must parse an array of name/value pair strings and make the appropriate changes too
the object state */
virtual void set ( char **sa ) = 0;
// void log ( const char *module, const char *action, const char *fmt, ... );
protected:
void log_start ( void );
void log_end ( void );
void log_create ( void );
void log_destroy ( void );
public:
int id ( void ) { return _id; }
friend class Logger;
};
class Logger
{
Loggable *_this;
Logger ( ) {}
public:
Logger ( Loggable *l ) : _this( l )
{
_this->log_start();
}
~Logger ( )
{
_this->log_end();
}
void hold ( void )
{
printf( "hold\n" );
_this->_nest++;
}
void release ( void )
{
printf( "release\n" );
_this->_nest--;
assert( _this->_nest );
}
};
/* #ifndef _LOGGABLE_C */
/* #define log( act, fmt, args... ) log( __CLASS__, act, fmt, ## args ) */
/* #endif */
/* #define LOG_START Logger _logger( this ) */
/* #define LOG_END _logger.print( this ) */