libifstubs.h

Go to the documentation of this file.

/*
 *              libifstubs.h
 *
 *              This is the public interface for a library the provides a stub
 *              version of all the VICI modules. This allows each module to be
 *              developed independently. This library is only used for testing
 *              and is not part of the installed system.
 *
 *      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/>.
 */

#ifndef STUB_LIBIFSTUBS_H
#define STUB_LIBIFSTUBS_H

#include <vector>
#include <map>
#include "vici.h"

namespace VICI
{

namespace stub
{

// Event simulating infrastructure

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

        virtual void execute() = 0;
};

class Dispatcher
{
private:
        Dispatcher();
        std::map< std::string, std::map< std::string, Event * > > table;
        std::vector< std::string > traceData;
        bool tracing;
public:

        static Dispatcher & instance();


        void registerEvent( csr useCase, csr event,     Event *fn );


        void sendEvent( csr useCase, csr event );

        void clearTrace() { traceData.clear(); }


        void enableTracing( bool x ) { tracing = x; if (!x) clearTrace(); }


        void trace(csr x) { if(tracing) traceData.push_back(x); }


        std::vector< std::string > &getTrace() { return traceData; }
};

template < class T >
class AnEvent : public Event
{
private:
        T * obj;
        void (T::*fn)();
public:

        AnEvent( void (T::*f)(), T *x ) : obj(x), fn(f) {}

        virtual void execute() { (obj->*fn)(); }
};

// Scaffolding classes used to demonstrate module level
// use cases.

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

class WindowStub : public Window
{
public:
        WindowStub();
};



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

class EBNF_Stub : public EBNF::EBNF
{
public:
        EBNF_Stub();
        virtual bool validate( csr s );
        virtual void getError( int &, int &, std::string & );
        virtual VICI::EBNF::ParseTree * parse( csr s );
};

class EBNF_Stub_Factory : public EBNF::EBNF_Factory
{
public:
        EBNF_Stub_Factory(){}
        virtual EBNF::EBNF * makeEBNF();
};

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

class SyntaxStub : public Syntax::Syntax
{
protected:
        Window *win;    // reference

        EBNF::EBNF *ebnf;               // reference
public:

        SyntaxStub( Window *w, EBNF::EBNF * e);
        ~SyntaxStub();
        virtual void show( csr s );
};

class SyntaxStubFactory : public Syntax::SyntaxFactory
{
public:
        SyntaxStubFactory(){}
        virtual Syntax::Syntax * makeSyntax( Window *, EBNF::EBNF * );
};

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

class ViciAdminStub : public Admin::ViciAdmin
{
private:
        Window * window;        // owned
        EBNF::EBNF * ebnf;              // owned
        Syntax::Syntax * syntax;        // owned

        // interface testing
        int line;
        int column;
        std::string message;
        bool validEbnf;

        void uc102a();
        void uc102();

public:
        ViciAdminStub();
        ~ViciAdminStub();

        virtual VICI::Window * getMainWindow(){ return nullptr; }

        ViciAdminStub( const ViciAdminStub & ) = delete;
        ViciAdminStub & operator = ( const ViciAdminStub & ) = delete;
};

class ViciAdminStubFactory : public Admin::ViciAdminFactory
{
public:
        virtual Admin::ViciAdmin * makeViciAdmin();
};


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

class SearchStub : public Search::Search
{
private:
        VICI::Search::SearchClient *client;

        // interface testing
        void uc107();

public:

        SearchStub(Window *w, VICI::Search::SearchClient *c);
        virtual void show();
        virtual void setNode( NodeId );
};

class SearchStubFactory : public Search::SearchFactory
{
public:
        virtual Search::Search * makeSearch( Window *, Search::SearchClient * );
};

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

class CommandStub : public Cmnd::Command
{
private:
        Window *win;
        Cmnd::CommandClient *client;
        EBNF::EBNF *ebnf;

        // use case tests
        void uc107();

public:

        CommandStub( Window *w, Cmnd::CommandClient *c, Canvas::Canvas * );
        virtual void show();
        virtual void setCommand( NodeId nid, const ArgList & args  );
        virtual void selection( Symbol::Symbol * );
        virtual void symbolAttr( Symbol::SymbolAttributes & );
        virtual void textAttr( Symbol::TextAttributes & );
};

class CommandStubFactory : public Cmnd::CommandFactory
{
public:
        virtual Cmnd::Command * makeCommand( Window *, Cmnd::CommandClient *, Canvas::Canvas * );
};

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

class SymbolStub : public Symbol::Symbol
{
private:
        bool isCommandSymbol;
public:

        SymbolStub( bool command ) : isCommandSymbol(command) {}
        virtual Symbol *clone(VICI::Symbol::SymbolOwner *) { return new SymbolStub(isCommandSymbol); }
        virtual bool isCommand() { return isCommandSymbol; }
        virtual void setAttributes( VICI::Symbol::SymbolAttributes & ) {}
        virtual void draw( Scene *, double x, double y, double scale ) {}
        virtual void attachCommand( const ArgList & ) {}
        virtual void setNodeId(NodeId) {}
        virtual VICI::Symbol::Style getStyle() { return VICI::Symbol::SymCommand; }
        virtual void setHighlight(bool){}
};

class SymbolMgrStub : public Symbol::SymbolMgr
{
private:
        std::vector< Symbol::SymbolClient * > clients;

        // interface testing
        void uc107();

public:

        SymbolMgrStub( Window *w );
        virtual void addClient( Symbol::SymbolClient * );

        virtual Symbol::SymbolAttributes getDefaultAttr(Symbol::Style);
        virtual Symbol::TextAttributes   getDefaultTextAttr();
        virtual Symbol::Symbol * getSymbol(Symbol::Style, Symbol::SymbolOwner *);
};

class SymbolStubFactory : public Symbol::SymbolFactory
{
public:
        virtual Symbol::SymbolMgr * makeSymbolMgr( Window * );
};

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

class CanvasStub : public Canvas::Canvas
{
private:
        Symbol::SymbolMgr *symgr;
        VICI::Canvas::CanvasClient * client;
        Interp::Interpreter *interpreter;

        // use case tests
        void uc107();
        void uc109();
        void uc115();
        void uc137a(); void uc137b();
        void uc138a(); void uc138b(); void uc138c();
        void uc140a(); void uc140b(); void uc140c();
        void uc141a(); void uc141b(); void uc141c();

public:

         CanvasStub( Window *w, Symbol::SymbolMgr *s, Interp::Interpreter*i,
                         VICI::Canvas::CanvasClient *c );

        // menu actions
        virtual void load( csr filename );
        virtual void save( csr filename );

        // display of executing script
        virtual void setExecution( bool active, csr node );

        // assigning a command to the current symbol
        virtual void setCommand( NodeId, const ArgList & );

        // symbol interface
        virtual void selection(VICI::Symbol::Symbol*);
        virtual void symbolAttr(VICI::Symbol::SymbolAttributes&);
        virtual void textAttr(VICI::Symbol::TextAttributes&);
        virtual VICI::ArgList getNames();

        // InterpreterClient Interface
        // this gets called when a script variable has a change of value
        virtual void setValue( csr varName, csr value );

        // this gets called when a monitored file changes state.
        virtual void setFile( int state, csr filename );

        virtual void setCursor( ThreadId, NodeId );
        virtual void breakReached( ThreadId, NodeId );

        // this gets called when data is available on a display
        virtual void dataReady( NodeId );

        virtual void reportError( Severity, csr );


        virtual void done();
};

class CanvasStubFactory : public Canvas::CanvasFactory
{
        virtual Canvas::Canvas * makeCanvas( Window *, Symbol::SymbolMgr *,
                        Interp::Interpreter *, Canvas::CanvasClient * );
};



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

class SecureStub : public Sec::Secure
{
public:
        SecureStub();
        virtual bool verifySignature( csr filename );

        // sign this file with the user's key
        virtual void addSignature( csr filename );
};

class SecureStubFactory : public Sec::SecureFactory
{
public:
        virtual Sec::Secure * makeSecure();
};

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

class CronStub : public Cron::Cron
{
public:

        CronStub( Window *w );
        virtual void setCurrentFile( csr filename );
        virtual void show();
};

class CronStubFactory : public Cron::CronFactory
{
public:
        virtual Cron::Cron * makeCron( Window *);
};

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

class InstallerStub : public Inst::Installer
{
public:

        InstallerStub( Window *w );
        virtual void setCurrentFile( csr filename );
        virtual void show();
};

class InstallerStubFactory : public Inst::InstallerFactory
{
public:
        virtual Inst::Installer * makeInstaller( Window * );
};

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

class InterpreterStub : public Interp::Interpreter
{
private:
        Interp::InterpreterClient *client;

        // interface testing
        std::string state;
        void uc138() { state = "uc138"; }
        void uc140() { state = "uc140"; }
        void uc141() { state = "uc141"; }
public:

        InterpreterStub( Sec::Secure *s );
        virtual void addClient( Interp::InterpreterClient *sc ) { client = sc; }
        virtual void debugMode(bool);
        virtual void setScript( csr filename );
        virtual void setArgs( ArgList args);

        // this is called when a variable has its value changed by the user
        virtual void setValue( csr varName, csr value );

        virtual void setPosn( ThreadId, NodeId );
        virtual void setInterval( double secs );
        virtual void setBreak( NodeId, bool );
        virtual int openDisplay( NodeId );
        virtual void dataAck( NodeId );
        // single step a thread of the script
        virtual void step( ThreadId );
        // resume a paused script
        virtual void resume();
        virtual void run();
        virtual void run( csr funcName );
        virtual void pause();
        virtual void kill();
        virtual int  result();

        virtual void saveSnapshot( csr filename );
        virtual void loadSnapshot( csr filename );
};

class InterpreterStubFactory : public Interp::InterpreterFactory
{
public:
        virtual Interp::Interpreter * makeInterpreter( Sec::Secure * );
};

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

class ViciEditorStub : public Ed::ViciEditor
{
private:
        Window *win;
        Symbol::SymbolMgr *symgr;
        Canvas::Canvas *canvas;
        Search::Search *search;
        Cmnd::Command *command;
        Sec::Secure *secure;
        Interp::Interpreter *interpreter;
        Inst::Installer *installer;
        Cron::Cron *cron;

        // interface testing
        void uc108();
        void uc113();
        void uc142();
        void uc144();

public:
        ViciEditorStub();

        virtual VICI::Window * getMainWindow(){ return nullptr; }
        virtual void openFile( const VICI::Path & ){}

        // CanvasClient Interface
        virtual void newSymbol( Symbol::Symbol * );
        virtual void newChart();
        virtual void changedChart();
        virtual void searchAction( NodeId );
        virtual void commandAction( NodeId, const ArgList & );
        virtual void breakAction( NodeId, bool );

        // SymbolClient Interface
        virtual void selection( Symbol::Symbol * );
        virtual void symbolAttr( Symbol::SymbolAttributes & );
        virtual void textAttr( Symbol::TextAttributes & );

        // CommandClient Interface
        virtual void optionsAndParameters( NodeId, const ArgList & );
        virtual void cmndError( csr );

        // SearchClient Interface
        virtual void selectedCommand( NodeId, csr );

};

class ViciEditorStubFactory : public Ed::ViciEditorFactory
{
public:
        virtual Ed::ViciEditor * makeViciEditor();
};

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

class ViciStub : public Vici
{
private:
        void uc145();
        void uc148();
        void uc150a(); void uc150b(); void uc150c();

        Sec::Secure * secure;
        Interp::Interpreter *  interpreter;

public:
        ViciStub();
        virtual Interp::Interpreter * getInterpreter() { return interpreter; }
        virtual void openFile( const VICI::Path & ){}
        virtual void autoStart(){}

        // this gets called when a script variable has a change of value
        virtual void setValue( csr varName, csr value );

        // this gets called when a monitored file changes state.
        virtual void setFile( int state, csr filename );

        // this gets called as the shell steps through the script
        virtual void setCursor( ThreadId, NodeId );

        virtual void breakReached( ThreadId, NodeId );

        // this gets called when data is available on a display
        virtual void dataReady( NodeId );

        virtual void reportError( Severity, csr );

        // this gets called when the script completes
        virtual void done();
};

class ViciStubFactory : public ViciFactory
{
public:
        virtual Vici * makeVici(Window *w = nullptr);
};

}  // end namespace stub
}  // end namespace VICI
#endif