non/Timeline/Loggable.H

345 lines
8.1 KiB
C++
Raw Normal View History

/*******************************************************************************/
/* 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. */
2008-02-22 12:44:35 +01:00
#pragma once
2008-02-22 21:20:44 +01:00
#include <stdio.h>
2008-02-24 08:42:41 +01:00
#include <stdlib.h>
#include <string.h>
#include <assert.h>
2008-02-24 08:42:41 +01:00
#include <vector>
2008-02-27 21:04:17 +01:00
#include <map>
#include <string>
#include <queue>
using namespace std;
2008-04-20 04:15:54 +02:00
#include "types.h"
2008-02-27 21:04:17 +01:00
2008-04-20 04:15:54 +02:00
class Log_Entry;
2008-02-27 21:04:17 +01:00
class Loggable;
2008-04-20 04:15:54 +02:00
typedef Loggable *(create_func)(Log_Entry &);
2008-04-21 02:28:59 +02:00
#define LOG_REGISTER_CREATE( class ) \
Loggable::register_create( #class, & class ::create );
2008-04-20 04:15:54 +02:00
2008-04-25 08:34:08 +02:00
#define LOG_NAME_FUNC( class ) \
virtual const char *class_name ( void ) const { return #class ; }
#define LOG_CREATE_FUNC( class ) \
static Loggable * \
create ( Log_Entry &e ) \
{ \
class *r = new class; \
r->set( e ); \
return (Loggable *)r; \
} \
LOG_NAME_FUNC( class ); \
2008-04-20 04:15:54 +02:00
2008-02-22 12:44:35 +01:00
2008-02-24 14:28:55 +01:00
class Logger;
class Loggable
{
2008-02-22 21:20:44 +01:00
static FILE *_fp;
2008-02-22 12:44:35 +01:00
static int _log_id;
static int _level;
2008-02-25 23:47:49 +01:00
static int _undo_index;
2008-02-22 12:44:35 +01:00
2008-02-24 08:42:41 +01:00
static vector <Loggable *> _loggables;
2008-02-27 21:04:17 +01:00
static map <string, create_func*> _class_map;
static queue <char *> _transaction;
2008-02-22 12:44:35 +01:00
private:
2008-04-24 02:33:44 +02:00
2008-02-22 12:44:35 +01:00
int _id;
2008-02-24 08:42:41 +01:00
char **_old_state;
char **_new_state;
2008-02-24 14:28:55 +01:00
int _nest;
2008-04-25 08:34:08 +02:00
void log_print( char **o, char **n ) const;
2008-02-25 05:14:19 +01:00
static void log ( const char *fmt, ... );
static void flush ( void );
static
void indent ( void )
{
int n = Loggable::_level;
while ( n-- )
2008-02-25 05:14:19 +01:00
log( "\t" );
}
2008-04-24 02:33:44 +02:00
static bool snapshot( FILE * fp );
2008-02-25 05:14:19 +01:00
public:
2008-02-22 21:20:44 +01:00
static bool open ( const char *filename );
2008-02-25 05:14:19 +01:00
static void undo ( void );
2008-02-27 21:04:17 +01:00
static int undo_index ( void ) { return _undo_index; }
2008-04-24 02:33:44 +02:00
static void compact ( void );
2008-02-22 21:20:44 +01:00
static
void
block_start ( void )
{
++Loggable::_level;
}
static
void
block_end ( void )
{
assert( --Loggable::_level >= 0 );
if ( Loggable::_level == 0 )
flush();
}
2008-02-24 08:42:41 +01:00
static
Loggable *
find ( int id )
{
if ( id > _log_id )
return NULL;
2008-02-25 05:14:19 +01:00
return _loggables[ id - 1 ];
2008-02-24 08:42:41 +01:00
}
2008-02-22 12:44:35 +01:00
Loggable ( )
{
_id = ++_log_id;
2008-02-24 08:42:41 +01:00
_old_state = NULL;
2008-02-24 14:28:55 +01:00
_nest = 0;
2008-02-24 08:42:41 +01:00
_loggables.push_back( this );
2008-02-22 12:44:35 +01:00
}
/** must be called after construction in create() methods */
void
update_id ( int id )
2008-02-27 21:04:17 +01:00
{
assert( _id == _log_id );
assert( _loggables[ _id - 1 ] == this );
_loggables[ _id - 1 ] = NULL;
2008-02-27 21:04:17 +01:00
// --_log_id;
2008-02-27 21:04:17 +01:00
_id = id;
2008-02-27 21:04:17 +01:00
/* make sure it'll fit */
_loggables.reserve( _id );
assert( ! _loggables[ _id - 1 ] );
_loggables[ _id - 1 ] = this;
}
virtual ~Loggable ( )
{
_loggables[ _id - 1 ] = NULL;
2008-02-27 21:04:17 +01:00
}
static
void
register_create ( const char *name, create_func *func )
{
printf( "registering %s to %p\n", name, func );
_class_map[ string( name ) ] = func;
}
2008-02-24 08:42:41 +01:00
/* log messages for journal */
2008-04-25 08:34:08 +02:00
virtual void get ( Log_Entry &e ) const = 0;
2008-04-20 04:15:54 +02:00
virtual void set ( Log_Entry &e ) = 0;
static bool do_this ( const char *s, bool reverse );
2008-02-24 08:42:41 +01:00
protected:
2008-02-22 12:44:35 +01:00
2008-02-24 08:42:41 +01:00
void log_start ( void );
void log_end ( void );
2008-04-25 08:34:08 +02:00
void log_create ( void ) const;
void log_destroy ( void ) const;
2008-02-22 12:44:35 +01:00
2008-02-24 11:58:16 +01:00
public:
2008-04-25 08:34:08 +02:00
virtual const char *class_name ( void ) const = 0;
2008-02-24 11:58:16 +01:00
int id ( void ) { return _id; }
2008-02-24 14:28:55 +01:00
friend class Logger;
};
2008-02-22 12:44:35 +01:00
2008-02-24 14:28:55 +01:00
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 );
}
};
2008-02-24 08:42:41 +01:00
2008-04-20 04:15:54 +02:00
class Log_Entry
{
// vector <Pair> _sa;
char **_sa;
int _i;
public:
2008-04-20 18:42:26 +02:00
struct Pair
{
const char *name;
const char *value;
};
2008-04-20 04:15:54 +02:00
Log_Entry ( )
{
_sa = (char**)malloc( sizeof( char * ) );
*_sa = NULL;
_i = 0;
}
Log_Entry ( char **sa )
{
2008-04-20 18:42:26 +02:00
_sa = sa;
_i = 0;
2008-04-20 04:15:54 +02:00
2008-04-20 18:42:26 +02:00
if ( _sa )
while ( _sa[ _i ] ) ++_i;
2008-04-20 04:15:54 +02:00
}
~Log_Entry ( )
{
if ( ! _sa )
return;
for ( _i = 0; _sa[ _i ]; ++_i )
{
free( _sa[ _i ] );
}
free( _sa );
}
/****************/
/* Construction */
/****************/
void grow ( )
{
_sa = (char**)realloc( _sa, sizeof( char * ) * (_i + 2) );
2008-04-20 18:42:26 +02:00
_sa[ _i + 1 ] = NULL;
2008-04-20 04:15:54 +02:00
}
2008-04-20 18:42:26 +02:00
#define ADD( type, format, exp ) \
2008-04-20 04:15:54 +02:00
void add ( const char *name, type v ) \
{ \
grow(); \
2008-04-20 18:42:26 +02:00
asprintf( &_sa[ _i ], "%s " format, name, (exp) ); \
strtok( _sa[ _i++ ], " " ); \
2008-04-20 04:15:54 +02:00
} \
/***************/
/* Examination */
/***************/
int size ( void ) const
{
return _i;
}
void get ( int n, const char **name, const char **value )
{
*name = _sa[ n ];
*value = *name + strlen( *name ) + 1;
}
char **sa ( void )
{
char **sa = _sa;
_sa = NULL;
return sa;
}
/* #define ADD ( type, format, exp ) \ */
/* void add ( const char *name, type v ) \ */
/* { \ */
/* char pat[ 256 ]; \ */
/* Pair p; \ */
/* p.name = strdup( name ); \ */
/* snprintf( pat, sizeof( pat ), format, exp ); \ */
/* p.value = strdup( pat ); \ */
/* _sa.push( p ); \ */
/* } \ */
ADD( int, "%d", v );
2008-04-20 18:42:26 +02:00
ADD( nframes_t, "%lu", (unsigned long)v );
2008-04-26 11:01:54 +02:00
ADD( unsigned long, "%lu", v );
2008-04-20 04:15:54 +02:00
ADD( const char *, "\"%s\"", v ? v : "" );
ADD( Loggable *, "0x%X", v ? v->id() : 0 );
ADD( float, "%f", v );
ADD( double, "%f", v );
#undef ADD
};