ikernel.h

Go to the documentation of this file.

#pragma once
 
#include "base/src/baseqt.h"
#include "module/interface/ikernelbase.h"
#include "utility/interface/iinputrecord.h"
#include "utility/interface/itextinput.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 IKernel {
    public:
        using Skip = itascaxd::IKernelBase::Skip;
 
        using signal_type = shared::Signal<const IThing *,const IContainer *>;
 
        shared::Signal<> abort;
        shared::Signal<const char *, const string &, bool> pushInputItem; // type, name start
        shared::Signal<const char *, const string &> popInputItem; // type, name
        shared::Signal<const string &> restoreModelState; // name
        shared::Signal<> resetModelState;
        shared::Signal<const string &> exportResultFile; // name
        shared::Signal<const string &> importResultFile; // name
        shared::Signal<int32> compressingFileIndex;
        shared::Signal<int32> compressingFileProgress; // progress
        shared::Signal<const string &, int64, int64, int64> tagInEditor; // source, line, colStart, colEnd
        shared::Signal<const string &> projectSysPath;     // Add project path to sys.path\
        // This signal is sent immediately *after* a command has been processed without error.
        // The string is the full command string seen by 
        shared::Signal<std::vector<InputLine>> commandProcessed;
 
        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 void securityCheck(security::Check check = security::Check::Normal)=0;
 
        virtual bool preCommandLineArguments(StringList * args)=0;
 
        virtual bool commandLineArguments(const StringList &args)=0;
        virtual std::vector<InputLine> fromCommandLineArguments(const StringList &args)=0;
 
        virtual string processCommands(itascaxd::IInputItem *ii,const string &inputPath=string(),
                                        bool recursive=false,bool suppress=false)=0;
 
        virtual string processCommands(const std::vector<InputLine> &sl,
                                        const string &inputPath=string(),bool recursive=false)=0;
 
        virtual string processCommand(const InputLine &s,const string &inputPath=string(),
                                       bool recursive=false)=0;
 
        virtual bool getAutoTestMode() const=0;
 
        virtual StringList            getTestDirectories() const=0;
 
        virtual IKernelOutput *getIKernelOutput()=0;
 
        virtual void addCommandDocumentation(const string &referencename,const StringList &list)=0; 
 
        virtual void addSphinxCommands(const StringList &)=0;
 
        virtual void addSphinxFish(const StringList &)=0;
        
        virtual string outputCommandsForModel() const=0;
        virtual string outputFishForModel() const=0;
 
        virtual int testValidCommand(const string &line, string *errorinfo=0) const=0;
 
        virtual int testValidCommandText(const string &text, string *errorinfo=0, std::vector<int> *errorlines=0) const=0;
 
        virtual QPair<string,string> expandCommandKeyword(const string &line,string &fileName,int cursor=-1) const=0;
        virtual StringList getCommandInformation(const string &line,int cursor=-1,bool thinkFish=false) const=0;
 
        virtual string 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 bool readSaveFileInfo(shared::Stream &dev,IInputRecord::FileDataSet *set,StringList *lines) const=0;
 
        virtual void compressFileList(const StringList &files)=0;
        virtual void decompressFileList(const StringList &files)=0;
        virtual bool fileIsCompressed(const string &filename) const=0;
 
        // RESULT FILE SUPPORT
        struct ResultsDesc {
            string name_;
            string command_;
            bool    state_ = false;
            string 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 string                    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 string                    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 string &fullPathName,const string &type)=0;
 
        virtual void stopProcessingFile(const string &fullPathName,const string &type)=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,Skip skip)=0;
 
        virtual void logEvent(const string &str)=0;
 
        virtual bool getInCycle() const=0;
 
        virtual StringList getAllTypeKeywords() const=0;
    };
 
}
// EoF