ikernel.h

Go to the documentation of this file.

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

namespace shared {
    class Stream;
}
 
namespace security {
    class ISC; //ISecurityCommunication;
    struct LicenseLocation;
}
 
namespace itascaxd {
    class IInputItem;
    class IKernelBase;
    class IRange;
}
 
namespace itasca {
    class Archive2;
    class IKernelInput;
    class IKernelOutput;
    class IThing;
    class IContainer;
    class IParse;

    class IKernel {
    public:
        using signal_type = shared::Signal<const IThing *,const IContainer *>;

        shared::Signal<> abort;
        shared::Signal<const char *, const QString &, bool> pushInputItem; // type, name start
        shared::Signal<const char *, const QString &> popInputItem; // type, name
        shared::Signal<> restoreModelStateStart;
        shared::Signal<const QString &> restoreModelStateEnd; 
        shared::Signal<const QString &> restoreModelState; // name
        shared::Signal<> resetModelState;
        shared::Signal<const QString &> exportResultFile; // name
        shared::Signal<const QString &> importResultFile; // name
        shared::Signal<int32> compressingFileIndex;
        shared::Signal<int32> compressingFileProgress; // progress
        shared::Signal<const QString &, int64, int64, int64> tagInEditor; // source, line, colStart, colEnd
        shared::Signal<const QString &> projectSysPath;     // Add project path to sys.path
 
 
        virtual itascaxd::IKernelBase *getIKernelBase() = 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 StringList            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 QString outputCommandsForModel() const=0;
        virtual QString outputFishForModel() const=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,uint64 label)=0;
        virtual void remapProject(Archive2 &a)=0;
        
        virtual IParse * createStackAndParse(const QString &) = 0;

        virtual bool readSaveFileInfo(shared::Stream &dev,IInputRecord::FileDataSet *set,StringList *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 uint64                    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 uint64                    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 uint32                    getResultsIntervalIndex() const=0;

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

        virtual void stopProcessingFile(const QString &fullPathName,const QString &type)=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(shared::Stream &dev,bool readOnly,bool text)=0;

        virtual StringList restore(shared::Stream &dev,shared::Stream *out=nullptr)=0;
 
        virtual void logEvent(const QString &str)=0;

        virtual bool getInCycle() const=0;
 
        virtual QStringList getAllTypeKeywords() const=0;
        
        virtual StateInfoOutput getModelStateInformation() const=0;
        
        virtual StateInfoOutput getProgramStateInformation() const=0;
    };
}
// EoF