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