ireFramework.h

Go to the documentation of this file.

/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-    */
/* ex: set filetype=cpp softtabstop=4 shiftwidth=4 tabstop=4 cindent expandtab: */

/*

  Author(s): Andrew LaMora
  Created on: 2005-02-28

  (C) Copyright 2005-2007 Johns Hopkins University (JHU), All Rights
  Reserved.

--- begin cisst license - do not edit ---

This software is provided "as is" under an open source license, with
no warranty.  The complete license can be found in license.txt and
http://www.cisst.org/cisst/license.txt.

--- end cisst license ---

*/


#ifndef _ireFramework_h
#define _ireFramework_h

#include <stdexcept>

#include <cisstCommon/cmnLogger.h>
#include <cisstCommon/cmnThrow.h>


#include <cisstInteractive/ireExport.h>


class CISST_EXPORT ireFramework {

private:

    //static PyObject* pInstance;
    // NewPythonThread is true if a new Python thread should be (or was) started for the IRE
    static bool NewPythonThread;

    // IRE States:
    //     IRE_NOT_CONSTRUCTED:  initial state (before Singleton object created)
    //     IRE_INITIALIZED:      once constructed and InitShell called (Python interpreter initialized)
    //     IRE_LAUNCHED:         once LaunchIREShell called
    //     IRE_ACTIVE:           set by callback from Python IRE code just before
    //                              entering main event loop
    //     IRE_FINISHED:         set by callback from Python IRE code just after
    //                              exiting main event loop. Also set by FinalizeShell.
    //
    // In general, the IRE is expected to transition in order through the above states.
    // Currently, there is little error checking for invalid transitions. The Reset method
    // can be used to transition from IRE_FINISHED to IRE_INITIALIZED.
    enum IRE_STATES { IRE_NOT_CONSTRUCTED, IRE_INITIALIZED, IRE_LAUNCHED,
                      IRE_ACTIVE, IRE_FINISHED };

    // The current state of the IRE (see above enum)
    static IRE_STATES IRE_State;

    static void *IreThreadState;

    void InitShellInstance(void);

    void FinalizeShellInstance(void);
    void LaunchIREShellInstance(const char * startup, bool newPythonThread, bool useIPython,
                                bool useStreambuf);

    void JoinIREShellInstance(double timeout);

protected:
    ireFramework() {
        InitShellInstance();
    }

    ~ireFramework() {
        FinalizeShellInstance();
    }
public:

    static ireFramework* Instance(void);


    static inline void InitShell(void)  throw(std::runtime_error) {
        Instance()->InitShellInstance();
    }


    static inline void FinalizeShell(void)  throw(std::runtime_error) {
        Instance()->FinalizeShellInstance();
    }


    static inline void LaunchIREShell(const char *startup = "", bool newPythonThread = false, bool useIPython = false,
                                      bool useStreambuf = true) throw(std::runtime_error) {
        Instance()->LaunchIREShellInstance(startup, newPythonThread, useIPython, useStreambuf);
    }

    static inline void *RunIRE_wxPython(const char *startup) {
        try {
            LaunchIREShell(startup, false, false, true);
        }
        catch (...) {
            CMN_LOG_INIT_ERROR << "Could not launch IRE shell (wxPython)" << std::endl;
        }
        FinalizeShell();
        return 0;
    }

    static inline void *RunIRE_IPython(const char *startup) {
        try {
            LaunchIREShell(startup, false, true, false);
        }
        catch (...) {
            CMN_LOG_INIT_ERROR << "Could not launch IRE shell (IPython)" << std::endl;
        }
        FinalizeShell();
        return 0;
    }

    static inline void JoinIREShell(double timeout) {
        Instance()->JoinIREShellInstance(timeout);
    }

    static bool IsStarting();

    static bool IsActive();

    static bool IsFinished();

    static void SetActiveFlag(bool flag);

    static bool IsInitialized();

    static void Reset();

    static void UnblockThreads();

    static void BlockThreads();

    static void PrintLog(const char * str, int len);
};

#endif // _ireFramework_h