vici.h

Go to the documentation of this file.

/*
 *              vici.h
 *
 *              This header file is the public interface for the modules
 *              used by the VICI project.
 *
 *      Copyright 2012 - 2018 Brenton Ross
 *
 *      This file is part of VICI.
 *
 *   VICI is free software: you can redistribute it and/or modify
 *   it under the terms of the GNU General Public License as published by
 *   the Free Software Foundation, either version 3 of the License, or
 *   (at your option) any later version.
 *
 *   VICI is distributed in the hope that it will be useful,
 *   but WITHOUT ANY WARRANTY; without even the implied warranty of
 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *   GNU General Public License for more details.
 *
 *   You should have received a copy of the GNU General Public License
 *   along with VICI.  If not, see <http://www.gnu.org/licenses/>.
 *
 *   Dedicated to the memory of John Yelland, a life-long friend.
 *
 */

#ifndef VICI_H
#define VICI_H

#include <string>
#include <vector>
#include <map>
#include <memory>
#include <vici/vx.h>
#include <vici/stringy.h>

// declare a set of functions that construct
// the factory for each module.
extern "C"
{
void * makeEBNFFactory();               
void * makeSyntaxFactory();             
void * makeAdminFactory();              
void * makeSearchFactory();             
void * makeCommandFactory();    
void * makeSymbolFactory();             
void * makeCanvasFactory();             
void * makeSecureFactory();             
void * makeCronFactory();               
void * makeInstallerFactory();  
void * makeInterpreterFactory();
void * makeEditorFactory();             
void * makeViciFactory();               
}

namespace VICI
{

typedef const std::string &csr;

typedef int NodeId;

typedef int ThreadId;

typedef std::vector< std::string > ArgList;

// -------------------------------------------------------


class Factory
{
public:
        virtual ~Factory(){}
};

typedef std::shared_ptr< Factory > FactoryPtr;

// -------------------------------------------------------

enum Module
{
        EBNF_Module,
        Syntax_Module,
        Admin_Module,
        Search_Module,
        Command_Module,
        Symbol_Module,
        Canvas_Module,
        Secure_Module,
        Cron_Module,
        Installer_Module,
        Interpreter_Module,
        Editor_Module,
        Vici_Module
};


// -------------------------------------------------------


class FactoryFactory
{
private:
        FactoryFactory();
        std::map< Module, FactoryPtr> factories;
public:
        static FactoryFactory & instance();


        template< class T >
        void getFactory( Module nm, std::shared_ptr< T > &f )
        {
                auto F = factories.find(nm);
                if ( F == factories.end() )
                        throw VX(Code) << "Could not find factory for " << nm;
                f = std::dynamic_pointer_cast<T>(F->second);
                if (f == nullptr)
                        throw VX(Code) << "Module refers to wrong type of factory";
        }


        void registerFactory( Module m, FactoryPtr f);
};

// -------------------------------------------------------



class Window
{
public:
        virtual ~Window() {}            
};


class Scene
{
public:
        virtual ~Scene() {}             
};

// -------------------------------------------------------

namespace EBNF
{


class ParseTree
{
public:
        virtual ~ParseTree(){}          
};


class EBNF
{
public:
        virtual ~EBNF(){}               


        virtual bool validate( csr s ) = 0;


        virtual void getError( int & line, int & column, std::string & text ) = 0;


        virtual ParseTree * parse( csr s ) = 0;
};


class EBNF_Factory : public VICI::Factory
{
public:
        virtual ~EBNF_Factory() {}              


        virtual EBNF * makeEBNF() = 0;
};

typedef std::shared_ptr< EBNF_Factory > EBNF_FactoryPtr;

} // end EBNF namespace

// -------------------------------------------------------

namespace Syntax
{


class Syntax
{
public:
        virtual ~Syntax() {}            


        virtual void show( csr s ) = 0;

};


class SyntaxFactory : public VICI::Factory
{
public:
        virtual ~SyntaxFactory() {}             


        virtual Syntax * makeSyntax( Window *w, EBNF::EBNF * ebnf) = 0;
};

typedef std::shared_ptr< SyntaxFactory > SyntaxFactoryPtr;

}
// -------------------------------------------------------

namespace Admin
{


class ViciAdmin
{
public:
        virtual ~ViciAdmin() {}         
        virtual VICI::Window * getMainWindow() = 0;             
};


class ViciAdminFactory : public VICI::Factory
{
public:
        virtual ~ViciAdminFactory() {}          


        virtual ViciAdmin * makeViciAdmin() = 0;
};

typedef std::shared_ptr< ViciAdminFactory > ViciAdminFactoryPtr;

}
// -------------------------------------------------------

namespace Search
{


class SearchClient
{
public:
        virtual ~SearchClient() {}              


        virtual void selectedCommand( NodeId n, csr c ) = 0;
};


class Search
{
public:
        virtual ~Search() {}            

        virtual void show() = 0;        

        virtual void setNode( NodeId ) = 0;             
};


class SearchFactory : public VICI::Factory
{
public:
        virtual ~SearchFactory() {}                     


        virtual Search * makeSearch( Window *w, SearchClient *sc ) = 0;
};

typedef std::shared_ptr< SearchFactory > SearchFactoryPtr;

}
// -------------------------------------------------------

namespace Sec
{
class Secure;
}

namespace Interp
{


class InterpreterClient
{
public:
        virtual ~InterpreterClient() {}                 


        virtual void setValue( csr varName, csr value ) = 0;


        virtual void setFile( int state, csr filename ) = 0;


        virtual void setCursor( ThreadId tid, NodeId node) = 0;


        virtual void breakReached( ThreadId tid, NodeId node) = 0;


        virtual void dataReady( NodeId node) = 0;


        virtual void reportError( Severity sev, csr msg ) = 0;

        virtual void done() = 0;
};


class Interpreter
{
public:
        static const NodeId OutDisplay = -1;            
        static const NodeId ErrDisplay = -2;            

        virtual ~Interpreter() {}       

        virtual void addClient( InterpreterClient * ) = 0;              

        virtual void setScript( csr filename ) = 0;                             

        virtual void setArgs( VICI::ArgList args) = 0;                  


        virtual void debugMode( bool mode ) = 0;


        virtual int openDisplay( NodeId node ) = 0;


        virtual void dataAck(NodeId node) = 0;


        virtual void setValue( csr varName, csr value ) = 0;


        virtual void setPosn( ThreadId tid, NodeId node) = 0;


        virtual void setBreak( NodeId node, bool set ) = 0;


        virtual void setInterval( double secs ) = 0;


        virtual void saveSnapshot( csr filename ) = 0;


        virtual void loadSnapshot( csr filename ) = 0;

        virtual void run() = 0;


        virtual void run( csr functionName ) = 0;

        virtual void pause() = 0;

        // single step a thread of the script
        virtual void step( ThreadId tid ) = 0;

        virtual void resume() = 0;

        virtual void kill() = 0;

        virtual int result() = 0;
};


class InterpreterFactory : public VICI::Factory
{
public:
        virtual ~InterpreterFactory() {}        


        virtual Interpreter * makeInterpreter( Sec::Secure *sec ) = 0;
};

typedef std::shared_ptr< InterpreterFactory > InterpreterFactoryPtr;

}

// -------------------------------------------------------


namespace Symbol
{

typedef long Colour;


class SymbolAttributes
{
public:
        SymbolAttributes() : lineColour(0), fillColour(0) {}

        Colour lineColour;                              
        Colour fillColour;                              
        std::string fillPattern;                
        std::string linePattern;                
};

enum Style {
        SymCommand,                     
        SymChoice,                      
        SymFuncRef,                     
        SymFunc,                        
        SymVar,                         
        SymConst,                       
        SymMutex,                       
        SymSem,                         
        SymFile,                        
        SymInline,                      
        SymPipe,                        
        SymDisplay,                     

        SymLock,                        
        SymUnlock,                      
        SymWait,                        
        SymPost,                        

        SymFlow,                        
        SymSuccess,                     
        SymFail,                        
        SymSignal,                      
        SymStdIn,                       
        SymStdOut,                      
        SymStdErr                       
};


class TextAttributes
{
public:
        TextAttributes() : fontSize(12.0) {}

        std::string fontName;           
        float fontSize;                         
};


class SymbolOwner
{
public:
        virtual ~SymbolOwner() {}                                                       
        virtual void selected() = 0;                                            
        virtual void opened() = 0;                                                      

        virtual void dragged( double x, double y ) = 0;
};


class Symbol
{
public:
        virtual ~Symbol() {}    


        virtual Symbol *clone( SymbolOwner * owner) = 0;


        virtual void setAttributes( SymbolAttributes & att ) = 0;


        virtual bool isCommand() = 0;


        virtual void draw( Scene *scene, double x, double y, double scale ) = 0;


        virtual void attachCommand( const ArgList & args ) = 0;


        virtual void setNodeId( NodeId nid) = 0;


        virtual Style getStyle() = 0;


        virtual void setHighlight(bool x) = 0;
};


class SymbolClient
{
public:
        virtual ~SymbolClient() {}      


        virtual void selection( Symbol *sym ) = 0;


        virtual void symbolAttr( SymbolAttributes & att) = 0;


        virtual void textAttr( TextAttributes & att) = 0;
};


class SymbolMgr
{
public:
        virtual ~SymbolMgr() {} 


        virtual void addClient( SymbolClient * client ) = 0;


        virtual SymbolAttributes getDefaultAttr(Style s) = 0;


        virtual TextAttributes   getDefaultTextAttr() = 0;


        virtual Symbol * getSymbol(Style style, SymbolOwner *owner) = 0;
};


class SymbolFactory : public VICI::Factory
{
public:
        virtual ~SymbolFactory() {}     


        virtual SymbolMgr * makeSymbolMgr( Window *w ) = 0;
};

typedef std::shared_ptr< SymbolFactory > SymbolFactoryPtr;

}       // end Symbol namespace

// -------------------------------------------------------

namespace Canvas
{


class CanvasClient
{
public:
        virtual ~CanvasClient() {}      


        virtual void newSymbol( Symbol::Symbol *sym ) = 0;

        virtual void newChart() = 0;

        virtual void changedChart() = 0;

        virtual void searchAction( NodeId ) = 0;

        virtual void commandAction( NodeId, const ArgList & ) = 0;

        virtual void breakAction( NodeId, bool set ) = 0;
};


class Canvas : public Symbol::SymbolClient, public Interp::InterpreterClient
{
public:
        virtual ~Canvas() {}    

        // menu actions

        virtual void load( csr filename ) = 0;


        virtual void save( csr filename ) = 0;


        virtual void setExecution( bool active, csr node ) = 0;


        virtual void setCommand( NodeId nid, const ArgList & args) = 0;

        // symbol interface

        virtual void selection(Symbol::Symbol * sym) = 0;


        virtual void symbolAttr(Symbol::SymbolAttributes & att) = 0;


        virtual void textAttr(Symbol::TextAttributes & att) = 0;

        virtual ArgList getNames() = 0;
};


class CanvasFactory : public VICI::Factory
{
public:
        virtual ~CanvasFactory() {}     


        virtual Canvas * makeCanvas( Window *, Symbol::SymbolMgr *, Interp::Interpreter *, CanvasClient * ) = 0;
};

typedef std::shared_ptr< CanvasFactory > CanvasFactoryPtr;

} // end namespace

// -------------------------------------------------------

namespace Cmnd
{


class CommandClient
{
public:
        virtual ~CommandClient() {}     


        virtual void optionsAndParameters( NodeId nid, const ArgList & args) = 0;


        virtual void cmndError( csr msg ) = 0;
};


class Command : public Symbol::SymbolClient
{
public:
        virtual ~Command() {}   

        virtual void show() = 0;


        virtual void setCommand( NodeId nid, const ArgList & args ) = 0;

        // SymbolClient Interface


        virtual void selection( Symbol::Symbol *sym ) = 0;

        virtual void symbolAttr( Symbol::SymbolAttributes & ) = 0;

        virtual void textAttr( Symbol::TextAttributes & ) = 0;
};


class CommandFactory : public VICI::Factory
{
public:
        virtual ~CommandFactory() {}    


        virtual Command * makeCommand( Window *, CommandClient *, Canvas::Canvas * ) = 0;
};

typedef std::shared_ptr< CommandFactory > CommandFactoryPtr;

} // end namespace

// -------------------------------------------------------

namespace Sec
{


class Secure
{
public:
        virtual ~Secure() {}    


        virtual bool verifySignature( csr filename ) = 0;


        virtual void addSignature(csr filename ) = 0;
};


class SecureFactory : public VICI::Factory
{
public:
        virtual ~SecureFactory() {}     


        virtual Secure * makeSecure() = 0;
};

typedef std::shared_ptr< SecureFactory > SecureFactoryPtr;

} // end namespace

// -------------------------------------------------------

namespace Cron
{


class Cron
{
public:
        virtual ~Cron() {}      


        virtual void setCurrentFile( csr filename ) = 0;

        virtual void show() = 0;
};


class CronFactory : public VICI::Factory
{
public:
        virtual ~CronFactory() {}       


        virtual Cron * makeCron( Window *w) = 0;
};

typedef std::shared_ptr< CronFactory > CronFactoryPtr;

} // end namespace

// -------------------------------------------------------

namespace Inst
{


class Installer
{
public:
        virtual ~Installer() {} 


        virtual void setCurrentFile( csr filename ) = 0;

        virtual void show() = 0;
};


class InstallerFactory : public VICI::Factory
{
public:
        virtual ~InstallerFactory() {}  


        virtual Installer * makeInstaller( Window *w ) = 0;
};

typedef std::shared_ptr< InstallerFactory > InstallerFactoryPtr;

}

// -------------------------------------------------------

namespace Ed
{


class ViciEditor : public Canvas::CanvasClient, public Symbol::SymbolClient,
                                        public Cmnd::CommandClient, public Search::SearchClient
{
public:
        virtual ~ViciEditor() {}        
        virtual VICI::Window * getMainWindow() = 0;             
        virtual void openFile( const VICI::Path & ) = 0;        
};


class ViciEditorFactory : public VICI::Factory
{
public:
        virtual ~ViciEditorFactory() {} 


        virtual ViciEditor * makeViciEditor() = 0;
};

typedef std::shared_ptr< ViciEditorFactory > ViciEditorFactoryPtr;

}

// -------------------------------------------------------



class Vici : public Interp::InterpreterClient
{
public:
        virtual ~Vici() {}      

        virtual Interp::Interpreter * getInterpreter() = 0;

        virtual void openFile( const Path & ) = 0;

        virtual void autoStart() = 0;
};


class ViciFactory : public VICI::Factory
{
public:
        virtual ~ViciFactory() {}       


        virtual Vici * makeVici( Window *w = nullptr ) = 0;
};

typedef std::shared_ptr< ViciFactory > ViciFactoryPtr;

// -------------------------------------------------------


} // end of namespace VICI
#endif /* VICI_H_ */