Globals.cpp

Go to the documentation of this file.

//SpikeStream includes
#include "Globals.h"
#include "SpikeStreamException.h"
#include "SpikeStreamAnalysisException.h"
using namespace spikestream;

//Other includes
#include <iostream>
using namespace std;

//Define controlling output of memory information
#define MEMORY_DEBUG

//Declare static variables
QHash<QString, unsigned int> Globals::analysisMap;
QHash<QString, bool> Globals::analysisRunningMap;
AnalysisDao* Globals::analysisDao = NULL;
Archive* Globals::archive = NULL;
ArchiveDao* Globals::archiveDao = NULL;
bool Globals::archivePlaying = false;
EventRouter* Globals::eventRouter = new EventRouter();
Network* Globals::network = NULL;
NetworkDao* Globals::networkDao = NULL;
NetworkDisplay* Globals::networkDisplay = new NetworkDisplay();
bool Globals::rendering = false;
QString Globals::spikeStreamRoot = "";
QString Globals::workingDirectory = "";
AbstractSimulation* Globals::simulation = NULL;
bool Globals::simulationRunning = false;


/*---------------------------------------------------------------------------------*/
/*----------                  PUBLIC METHODS                          -------------*/
/*---------------------------------------------------------------------------------*/

void Globals::clearAnalysisRunning(const QString &analysisName){
        analysisRunningMap.remove(analysisName);
}


bool Globals::isAnalysisLoaded(const QString& analysisName){
        //Map has an entry for this analysis - return false if ID is zero
        if(analysisMap.contains(analysisName)){
                if(analysisMap[analysisName] == 0)
                        return false;
                return true;
        }

        //No entry in map so no analysis loaded
        return false;
}


bool Globals::isAnalysisRunning(){
        //Analysis running map is empty, so no analyses are running
        if(analysisRunningMap.isEmpty())
                return false;
        return true;
}


unsigned int Globals::getAnalysisID(const QString& analysisName){
        if(analysisMap.contains(analysisName))
                return analysisMap[analysisName];

        //No analysis ID has been set for this name, so return zero
        return 0;
}


bool Globals::archiveLoaded(){
        if(archive == NULL)
                return false;
        return true;
}


void Globals::cleanUp(){
        #ifdef MEMORY_DEBUG
                cout<<"Cleaning up Globals"<<endl;
        #endif//MEMORY_DEBUG

        if(archive != NULL){
                delete archive;
                archive = NULL;
        }
        if(network != NULL){
                //Delete network if it has been marked as temporary and has not been saved.
                if(network->isTransient() && !network->isSaved()){
                        NetworkDaoThread networkDaoThread(networkDao->getDBInfo());
                        networkDaoThread.startDeleteNetwork(network->getID());
                        networkDaoThread.wait();
                }
                delete network;
                network = NULL;
        }
        if(networkDao != NULL){
                delete networkDao;
                networkDao = NULL;
        }
        if(eventRouter != NULL){
                delete eventRouter;
                eventRouter = NULL;
        }
}


AnalysisDao* Globals::getAnalysisDao(){
        return analysisDao;
}


Archive* Globals::getArchive(){
        if(archive == NULL)
                throw SpikeStreamException("No archive loaded. You should check that archive is loaded using archiveLoaded() before calling this method.");
        return archive;
}


ArchiveDao* Globals::getArchiveDao(){
        return archiveDao;
}


Network* Globals::getNetwork(){
        if(network == NULL)
                throw SpikeStreamException("No network loaded. You should check that network is loaded using networkLoaded() before calling this method.");
        return network;
}


NetworkDao* Globals::getNetworkDao(){
        return networkDao;
}


NetworkDisplay* Globals::getNetworkDisplay(){
        return networkDisplay;
}


AbstractSimulation* Globals::getSimulation(){
        return Globals::simulation;
}


QString Globals::getSpikeStreamRoot(){
        return spikeStreamRoot;
}


QString Globals::getWorkingDirectory(){
        return workingDirectory;
}


bool Globals::networkLoaded(){
        if(network == NULL)
                return false;
        return true;
}


bool Globals::isRendering() {
        return rendering;
}


bool Globals::isArchivePlaying() {
        return archivePlaying;
}


bool  Globals::isSimulationLoaded(){
        if(simulation == NULL)
                return false;
        return true;
}


bool  Globals::isSimulationRunning(){
        return Globals::simulationRunning;
}

bool Globals::networkChangeOk(){
        //If no network is loaded, then simulation or analysis will not be running
        if(!Globals::networkLoaded())
                return true;

        //Cannot change network when simulation is running
        if(Globals::isSimulationRunning()){
                qWarning()<<"Network cannot be changed or deleted whilst a simulation is running.\nStop the simulation and try again.";
                return false;
        }

        //Cannot change network when analysis is running
        if(Globals::isAnalysisRunning()){
                qWarning()<<"Network cannot be changed or deleted whilst an analysis is running.\nStop all analyses and try again.";
                return false;
        }

        //Cannot change network when archive is playing
        if(Globals::isArchivePlaying()){
                qWarning()<<"Network cannot be changed or deleted whilst an archive is playing.\nStop archive playback and try again.";
                return false;
        }

        //Check that user wants to unload simulation
        if(Globals::isSimulationLoaded()){
                qWarning()<<"A simulation is currently loaded.\nUnload the simulation before changing or deleting the current network.";
                return false;
        }

        //Network change is ok if we have reached this point
        return true;
}


void Globals::setAnalysisID(const QString& analysisName, unsigned int id){
        analysisMap[analysisName] = id;
}


void Globals::setAnalysisRunning(const QString &analysisName){
        analysisRunningMap[analysisName] = true;
}


void Globals::setSimulationRunning(bool simulationRunning){
        Globals::simulationRunning = simulationRunning;
}


/*-------------------------------------------------------------*/
/*------                 PRIVATE METHODS                 ------*/
/*-------------------------------------------------------------*/

void Globals::setAnalysisDao(AnalysisDao* newAnalysisDao){
        //Clean up the old analysis DAO if it exists
        if(Globals::analysisDao != NULL)
                delete analysisDao;

        Globals::analysisDao = newAnalysisDao;
}


void Globals::setArchive(Archive* arch){
        //Clean up the old network if it exists
        if(Globals::archive != NULL)
                delete Globals::archive;

        //Store reference to the new network.
        Globals::archive = arch;
}


void Globals::setArchiveDao(ArchiveDao* archiveDao){
        //Clean up the old network DAO if it exists
        if(Globals::archiveDao != NULL)
                delete archiveDao;

        Globals::archiveDao = archiveDao;
}


void Globals::setArchivePlaying(bool archivePlaying){
        Globals::archivePlaying = archivePlaying;
}


void Globals::setEventRouter(EventRouter* eventRouter){
        //Clean up the old network if it exists
        if(Globals::eventRouter != NULL)
                delete eventRouter;

        Globals::eventRouter = eventRouter;
}


void Globals::setNetwork(Network* net){
        //Clean up the old network if it exists
        if(Globals::network != NULL)
                delete Globals::network;

        //Store reference to the new network.
        Globals::network = net;
}


void Globals::setNetworkDisplay(NetworkDisplay* networkDisplay){
        //Clean up the old network display if it exists
        if(Globals::networkDisplay != NULL)
                delete networkDisplay;

        //Store reference to the new network display
        Globals::networkDisplay = networkDisplay;
}


void Globals::setNetworkDao(NetworkDao* networkDao){
        //Clean up the old network DAO if it exists
        if(Globals::networkDao != NULL)
                delete networkDao;

        Globals::networkDao = networkDao;
}


void Globals::setRendering(bool rendering){
        Globals::rendering = rendering;
}


void Globals::setSimulation(AbstractSimulation* simulation){
        Globals::simulation = simulation;
}


void Globals::setSpikeStreamRoot(QString rootDir){
        spikeStreamRoot = rootDir;
}


void Globals::setWorkingDirectory(QString workDir){
        workingDirectory = workDir;
}