ikernel.h

Go to the documentation of this file.

#pragma once
#include "base/src/baseqt.h"
#include "utility/interface/iinputrecord.h"
#include "utility/interface/isignalbase.h"
#include "utility/interface/itextinput.h"
#include "security/interface/isecurity.h"

namespace security {
    class ISC; //ISecurityCommunication;
    struct LicenseLocation;
}

namespace itascaxd {
    class IInputItem;
    class IRange;
}

namespace itasca {
    class Archive2;
    class IKernelInput;
    class IKernelOutput;
    class IThing;
    class IContainer;

    class IKernel {
    public:
        typedef Signal2<const IThing *,const IContainer *> signal_type;

        virtual const QObject *getQObject() const=0;

        virtual bool initialize(IKernelInput *input,IKernelOutput *output)=0;

        virtual bool disconnectFromInterface()=0;

        virtual bool security(security::ISC *scomm)=0;

        virtual bool preCommandLineArguments(QStringList * args)=0;

        virtual bool commandLineArguments(const QStringList &args)=0;
        virtual QList<InputLine> fromCommandLineArguments(const QStringList &args)=0;

        virtual QString processCommands(itascaxd::IInputItem *ii,const QString &inputPath=QString(),
                                        bool recursive=false,bool suppress=false)=0;

        virtual QString processCommands(const QList<InputLine> &sl,
                                        const QString &inputPath=QString(),bool recursive=false)=0;

        virtual QString processCommand(const InputLine &s,const QString &inputPath=QString(),
                                       bool recursive=false)=0;

        virtual bool getAutoTestMode() const=0;

        virtual QStringList            getTestDirectories() const=0;

        virtual IKernelOutput *getIKernelOutput()=0;

        virtual void addCommandDocumentation(const QString &referencename,const QStringList &list)=0; 

        virtual void addSphinxCommands(const QStringList &)=0;

        virtual void addSphinxFish(const QStringList &)=0;

        virtual int testValidCommand(const QString &line, QString *errorinfo=0) const=0;

        virtual int testValidCommandText(const QString &text, QString *errorinfo=0, QList<int> *errorlines=0) const=0;

        virtual QPair<QString,QString> expandCommandKeyword(const QString &line,QString &fileName,int cursor=-1) const=0;
        virtual QStringList getCommandInformation(const QString &line,int cursor=-1,bool thinkFish=false) const=0;

        virtual QString getSaveFileName() const=0;

        virtual bool modelChanged() const=0;

        virtual bool projectChanged() const=0;

        virtual void saveProject(Archive2 &a) const=0;
        virtual bool restoreProject(Archive2 &a,quint64 label)=0;
        virtual void remapProject(Archive2 &a)=0;

        virtual bool readSaveFileInfo(QIODevice *dev,IInputRecord::FileDataSet *set,QStringList *lines) const=0;

        virtual void compressFileList(const QStringList &files)=0;
        virtual void decompressFileList(const QStringList &files)=0;
        virtual bool fileIsCompressed(const QString &filename) const=0;

        // RESULT FILE SUPPORT
        struct ResultsDesc {
            QString name_;
            QString command_;
            bool    state_ = false;
            QString category_;
        };
        virtual std::vector<ResultsDesc>   getResultsState() const=0;
        // TRUE if results files will be generated automatically during cycling.
        virtual bool                       getResultsIntervalOn() const=0;
        // non-zero if results files will be generated based on a real-time interval.
        virtual quint64                    getResultsIntervalClock() const=0;
        // The name of the process used to determine the model time -- from the list of
        //    processes available to the current model.
        virtual QString                    getResultsIntervalProcess() const=0;
        // non-zero if results files will be generated based on the number of cycles/steps.
        virtual quint64                    getResultsIntervalStep() const=0;
        // non-zero if results files will be generated based on accumulated model time
        //    in the process returned by getResultsIntervalProcess().
        virtual double                     getResultsIntervalTime() const=0;
        // Returns the prefix used for automatically generated results files.
        virtual QString                    getResultsIntervalPrefix() const=0;
        // Returns the current index used for automatically generated results files.
        // This is appended to the prefix and incremented automatically.
        virtual quint32                    getResultsIntervalIndex() const=0;

        // Signals/Slots
        virtual void pushInputItem(const char *type,const QString &name,bool start)=0;

        virtual void popInputItem(const char *type,const QString &name)=0;

        //virtual void saveModelState(const QString &name)=0;

        virtual void restoreModelState(const QString &name)=0;

        virtual void resetModelState()=0;

        virtual void exportResultFile(const QString &name)=0;
        virtual void importResultFile(const QString &name)=0;

        virtual void startProcessingFile(const QString &fullPathName,const QString &type)=0;

        virtual void stopProcessingFile(const QString &fullPathName,const QString &type)=0;

        virtual void compressingFileIndex(int index)=0;        
        virtual void compressingFileProgress(int progress)=0;

        virtual void resetModel(bool quiet=false)=0; 

        virtual void resetProject(bool quiet=false)=0;

        virtual void cleanModel(bool all=false)=0;

        virtual void calmModel()=0;

        virtual void filterModel(const itascaxd::IRange &)=0;

        virtual signal_type *getResetSignal() const=0;

        virtual signal_type *getSaveSignal() const=0;

        virtual signal_type *getRestoredSignal() const=0;

        virtual void    save(QIODevice *dev,bool readOnly,bool text)=0;

        virtual QStringList restore(QIODevice *dev,ItascaTextStream *out=0)=0;

        virtual void logEvent(const QString &str)=0;

        virtual bool getInCycle() const=0;

        virtual QStringList getAllTypeKeywords() const=0;

        virtual void abort()=0;

        virtual void loadMPI()=0;
    };
}
// EoF