Supervisor.h

Go to the documentation of this file.

#ifndef SUPERVISOR_H_
#define SUPERVISOR_H_

#include "component/SyncComponent.h"
#include "logger/DecimationLogWriter.h"
#include "logger/Logger.h"
#include "logger/Reporter.h"
#include "module/ModuleLoader.h"
#include "supervisor/CommandLine.h"
#include "supervisor/Maintainer.h"

#include <dirent.h>

class BinaryLogWriter;
class CycleStarter;
class DataEntry;
class DecimationLogManager;
class FileLogWriter;
class Handler;
class LinearApproximationLogWriter;
class LogEngine;
class MissionItem;
class MissionManager;
class SplitFileLogWriter;

#ifndef __APPLE_CC__
#define DIRENT_CONST const
#else
#define DIRENT_CONST
#endif

typedef int ( *FileFilterType )( DIRENT_CONST struct dirent * );

class Supervisor
{
public:

    friend class CommandLine;
    friend class CBIT;

    Supervisor( int argc, char **argv, Str& dataDir );

    virtual ~Supervisor();

    virtual void initialize();

    virtual void run();

    virtual void uninitialize();

    static Str GenerateDataDir( const Str& logSymlinkSubdir = "" );

    static Str RestartLogs();

    static void IncrementShoreFile();

    static Str GetToShoreFilename( LogWriter::ServiceType serviceType );

    static Str GetLatestLogFilename( FileFilterType fileFilter );

    static bool IsRestart()
    {
        return Restart_;
    }

    static int GetArgc()
    {
        return Argc_;
    }

    static char** GetArgv()
    {
        return Argv_;
    }

    static void ClearArgs();

    static void SendData( DataEntry* dataEntry, LogWriter::ServiceType serviceType );

    static bool IsMissionManagerFailed();

    static bool IsMissionRunning();

    static void TouchRunningFile();

    static void ClearRunningFile();

    static bool WasRunning()
    {
        return WasRunning_;
    }

    static bool IsRunningSimsInRealTime()
    {
        return RunSimsInRealTime_;
    }

    static void QueueSBD( const char* path );

    static char* GetQueuedSBD();

    static void ConfigureDecimation( LogWriter::ServiceType serviceType,
                                     DecimationLogWriter::DecimationType decimationType,
                                     const Str& name, DataValue* parameter, Logger& logger );

private:

    static void SetArgs( const char* args );

    static void SetRestart( bool restart )
    {
        Restart_ = restart;
    }

    static Supervisor* GetInstance()
    {
        return Instance_;
    }

    // Note that the copy constructor below is private and not given a body.
    // Any attempt to call it will return a compiler error.
    Supervisor( const Supervisor& old ); // disallow copy constructor

    void configure();

    bool loadMission( const char* missionName );

    bool resumeMission( const char* missionName );

    bool runMission( const char* missionName, bool quitAtEnd );

    void showStack( );

    void stopMission();

    void terminate();

    void addMaintain( unsigned short int uriCode, DataValue* dataValue,
                      SyncComponent::CycleOrder cycleOrder, bool unavailable = false, bool invalid = false );

    void removeMaintain( unsigned short int uriCode );

    void removeAllMaintains();

    void listMaintains();

    void addReport( unsigned short int uriCode,  Reporter::ReportType type = Reporter::REPORT_CHANGE, const Timespan *timespan = NULL );

    void removeReport( unsigned short int uriCode );

    void removeAllReports();

    void listReports();

    // Kick off the command line
    void startCommandLine();

    static bool Restart_;

    static int Argc_;
    static char **Argv_;
    static char *Args_;
    static bool WasRunning_;

    static bool RunSimsInRealTime_;

    LogEngine* logEngine_;

    Logger logger_;

    int argc_;
    char **argv_;

    // alternate configuration location
    Str altConfig_;

    ListOfLoadedModulePtrs loadedModules_;
    ModuleLoader moduleLoader_;

    Handler* commandLineHandler_;

    MissionManager* missionManager_;

    Maintainer* maintainer_;

    Reporter* reporter_;

    bool running_;

    Str& dataDir_;

    FlexArray<char*> sbdQueue_;

    DecimationLogManager* decimationLogManager_;

    FileLogWriter* syslogFileWriter_;
    BinaryLogWriter* slateWriter_;
    SplitFileLogWriter* slateFileWriter_;
    FileLogWriter* slateDirFileWriter_;
    FileLogWriter* kmlFileWriter_;
    LinearApproximationLogWriter* kmlApproximationWriter_;

    static int FilterLogDir( DIRENT_CONST struct dirent* dirEntry );

    static Supervisor* Instance_;

    static FileFilterType GetServiceFilter( LogWriter::ServiceType serviceType, bool lzma );

    static int FilterCourier( DIRENT_CONST struct dirent* dirEntry );

    static int FilterCourierLzma( DIRENT_CONST struct dirent* dirEntry );

    static int FilterExpress( DIRENT_CONST struct dirent* dirEntry );

    static int FilterExpressLzma( DIRENT_CONST struct dirent* dirEntry );

    static int FilterPriority( DIRENT_CONST struct dirent* dirEntry );

    static int FilterPriorityLzma( DIRENT_CONST struct dirent* dirEntry );

    static int FilterNormal( DIRENT_CONST struct dirent* dirEntry );

    static int FilterNormalLzma( DIRENT_CONST struct dirent* dirEntry );
};

#endif /*Supervisor_H_*/