CommandBank.h

/*
 
MIT License
 
Copyright (c) 2017 FMI Open Development / Markus Peura, first.last@fmi.fi
 
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
 
The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.
 
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.
 
*/
/*
Part of Rack development has been done in the BALTRAD projects part-financed
by the European Union (European Regional Development Fund and European
Neighbourhood Partnership Instrument, Baltic Sea Region Programme 2007-2013)
*/
 
 
// New design (2020)
 
#ifndef COMMAND_BANK_H_
#define COMMAND_BANK_H_
 
#include <iostream>
 
#include "drain/util/Bank.h"
#include "drain/util/Flags.h"
#include "Command.h"
#include "Program.h"
 
 
namespace drain {
 
typedef int bank_section_t;
 
 
class CommandBank : public BankSuper<Command> { // BankSuper<BasicCommand> {
 
public:
 
    typedef data_t command_t;
 
    CommandBank() :  scriptTriggerFlag(0) {
    };
 
    CommandBank(const CommandBank & bank) :  scriptTriggerFlag(bank.scriptTriggerFlag){
        // Copy sections?
    };
 
    //static  // Otherwise ok, but handler as error...
    //const Flagger::value_t SCRIPT_DEFINED;
 
 
    static
    std::set<std::string> & trimWords();
 
    static
    void deriveCmdName(std::string & name, char prefix=0);
    //const std::set<std::string> & trim = trimWords());
 
 
    template <class D, char PREFIX=0>
    D & addExternal(const D & entry, char alias = 0){
        std::string key(entry.getName());
        deriveCmdName(key, PREFIX);
        //return BankSuper<Command>::template addExternal<D>(entry, key, alias);
        return BankSuper<Command>::addExternal(entry, key, alias);
    }
 
    // Template arg PREFIX is tricky, sometimes need for dynamic
    template <class D>
    D & addExternal(char PREFIX, const D & entry, char alias=0){
        std::string key(entry.getName());
        deriveCmdName(key, PREFIX);
        return BankSuper<Command>::addExternal(entry, key, alias);
    }
 
    template <class D, char PREFIX=0>
    inline
    D & addExternal(const D & entry, const std::string & key, char alias = 0){
        //return BankSuper<Command>::template addExternal<D>(entry, key, alias);
        return BankSuper<Command>::addExternal(entry, key, alias);
    }
 
 
 
    //  void includeFile(const std::string & filename, Program & prog, Program::iterator it) const;
 
 
 
    // static
    void readFileTXT(const std::string & filename, Script & script) const;
 
    void readFile(const std::string & filename, Program & prog) const;
 
 
    void scriptify(int argc, const char **argv, Script & script) const;
 
 
    //static
    void scriptify(const std::string & cmdLine, Script & script) const;
 
 
    bool scriptify(const std::string & arg, const std::string & argNext, Script & script) const;
 
 
 
    //  void append(const Script & script, Program & prog, Context & context) const ;
    void append(const Script & script, Program & prog) const ;
 
protected:
 
    void append(const Script & script, Context & ctx, Program & prog) const ;
 
 
    static
    void tokenize(const std::string & cmdLine, std::list<std::string> & args);
 
public:
 
    drain::StringMapper logFileSyntax;  // todo:setter
 
    inline
    void flushRoutine(Script & script, Context & ctx, Program & prog){
        append(script, ctx, prog);
        script.clear();
    }
 
 
    void remove(Program & prog) const;
 
    void run(const std::string & cmd, const std::string & params, Context & ctx);
 
    //void run(ScriptTxt & script, drain::Context & context);
    // void run(Script & script, ClonerBase<Context> & contextSrc);
 
    // Newish
    void run(Program & prog, ClonerBase<Context> & contextCloner); // !! May be RackContext!
 
 
    void help(std::ostream & ostr = std::cout);
 
    void help(FlagResolver::ivalue_t sectionFilter, std::ostream & ostr = std::cout); // Flagger::ivalue_t sectionFilter
 
    void help(const std::string & key, std::ostream & ostr = std::cout);
 
    void info(const std::string & key, const command_t & cmd, std::ostream & ostr = std::cout, bool detailed=true) const ;
 
 
    const std::string & resolveFull(const key_t & key) const;
 
    template <class T>
    void exportStatus(std::map<std::string, T> & statusMap) const;
 
 
    // drain::Flagger::ivalue_t
    bank_section_t scriptTriggerFlag;
 
 
    inline
    void setScriptTriggerFlag(bank_section_t sectionFlag){ // drain::Flagger::ivalue_t
        scriptTriggerFlag = sectionFlag;
    };
 
 
    std::string defaultCmdKey;
 
    inline
    void setDefaultCmdKey(const std::string & s){
        defaultCmdKey = s;
    };
 
    std::string notFoundHandlerCmdKey;
 
 
    inline
    void setNotFoundHandlerCmdKey(const std::string & s){
        notFoundHandlerCmdKey = s;
    };
 
    std::string scriptCmd;
 
    /***
     *   For example: "script"
     */
    inline
    void setScriptCmd(const std::string & s){
        scriptCmd = s;
    }
 
    /***
     *   For example: "exec"
    inline
    void setScriptExecCmd(const std::string & s){
        execScriptCmd = s;
    }
     */
 
 
    /***
     *   For example: "execFile"
     */
    inline
    void setScriptFileCmd(const std::string & s){
        execFileCmd = s;
    }
 
    std::string execFileCmd;
 
 
    template <class ...TT>
    void linkRelatedCommands(const TT & ... cmds){
        std::set<std::string> cmdList;
        linkRelatedCommandList(cmdList, cmds...); // infinite loop?
    }
 
    void linkRelatedCommandList(const std::set<std::string> & cmdList);
 
 
protected:
 
    /*
    template <class ...TT>
    void linkRelatedCommandList(std::set<std::string> & cmdList, const TT & ... cmds){
        linkRelatedCommands(cmdList, cmds...);
    }
    */
 
    template <class ...TT>
    void linkRelatedCommandList(std::set<std::string> & cmdList, const std::string & cmd, const TT & ... cmds){
        cmdList.insert(cmd);
        linkRelatedCommandList(cmdList, cmds...);
    }
 
 
    template <class ...TT>
    void linkRelatedCommandList(std::set<std::string> & cmdList, const char *cmd, const TT & ... cmds){
        cmdList.insert(cmd);
        linkRelatedCommandList(cmdList, cmds...);
    }
 
    /*
    void linkRelatedCommandList(std::set<std::string> & cmdList, const std::string & cmd){
        cmdList.insert(cmd);
        linkRelatedCommandList(cmdList);
    }
 
    void linkRelatedCommandList(std::set<std::string> & cmdList, const char * cmd){
        cmdList.insert(cmd);
        linkRelatedCommandList(cmdList);
    }
    */
 
    // template <class ...TT>
    // void linkRelatedCommands(std::list<std::string> & cmdList, const TT & ... cmds){
    // }
 
 
 
    // std::string execScriptCmd;
 
 
};
 
template <class T>
void CommandBank::exportStatus(std::map<std::string, T> & statusMap) const {
    for (map_t::const_iterator it = this->begin(); it!=this->end(); ++it){
        statusMap[it->first] = it->second->getSource().getParameters().getValues();
    }
}
 
 
extern
CommandBank & getCommandBank();
 
 
} /* namespace drain */
 
#endif