interpreter.h

Go to the documentation of this file.

 
#pragma once
 
#include <vector>
#include <set>
#include <string>
#include <unordered_map>
#include <map>
#include <memory>
 
#include <parsnip/parsnip_command.h>
 
#include "fundamentals.h"
#include "response.h"
 
#define KEY_AUDIOOPTIONS "audioOptions"
#define KEY_WAITOPTIONS "waitOptions"
#define KEY_TUNEROPTIONS "tunerOptions"
#define KEY_LIBRARYOPTIONS "libraryOptions"
#define KEY_PANDORAOPTIONS "pandoraOptions"
#define KEY_PLAYBACKSELECTION "playbackOptions"
 
#define KEY_OPTIONS "options"
#define KEY_COMMAND "command"
#define KEY_REQUEST "request"
 
#define KEY_ASUSER "asUser"
#define KEY_WITHSOURCE "withSource"
#define KEY_INROOM "inRoom"
#define REQUEST_ASUSER "asUserExecute"
#define REQUEST_WITHSOURCE "withSourceExecute"
#define REQUEST_INROOM "inRoomExecute"
 
#define PARSER_SOURCEIDENTITY "sourceId"
#define KEY_SOURCE "source"
#define SOURCEIDENTITY " {" KEY_SOURCE ":" PARSER_SOURCEIDENTITY "}"
 
class PianodConnection;
 
class PianodParser : public Parsnip::Parser {
    friend class PianodDispatcher;
    std::unordered_map <std::string, const Parsnip::OptionParser::Definitions> option_definitions;
public:
    void addOptionParser (const std::string &name, Parsnip::OptionParser::Definitions defs);
};
 
 
 
class PianodSchema : public Parsnip::SchemaSet {
public:
    using CommandIds = std::map <std::string, CommandId>;
    using SchemaList = std::vector<std::string>;
private:
    CommandIds command_ids;
public:
    using RequestPair = std::pair <CommandId, const Parsnip::Data *>;
    using SchemaSet::SchemaSet;
    using SchemaSet::validate;
 
    CommandId getCommandId (const std::string &name) const;
    void addRequestNames (const CommandIds &mappings);
    void validate (const std::string &command, const Parsnip::Data &request);
    std::ostream &dump (const std::string &command, std::ostream &target = std::clog) const;
    std::ostream &dumpAll (std::ostream &target = std::clog) const;
    SchemaList allRequestNames() const;
};
using PianodSchemaRef = std::shared_ptr <PianodSchema>;
 
 
 
class PianodDispatcher : public Parsnip::Dispatcher <ResponseCollector, PianodConnection &> {
    using base_type = Parsnip::Dispatcher <ResponseCollector, PianodConnection &>;
    PianodSchemaRef schema;
    std::vector <class PianodInterpreter *> interpreters; 
public:
    using HelpList = std::vector<std::string>;
    using base_type::operator();
    
    PianodDispatcher (const Parsnip::ParserRef &parser, const PianodSchemaRef &schema);
    void addHandler (const Parsnip::Parser::Definitions &defs, class PianodInterpreter *interpreter);
    void rewriteJsonRequest (Parsnip::Data &request) const;
    ResponseCollector jsonRequest (const Parsnip::Data &request, PianodConnection &context) const;
    ResponseCollector redispatch (const Parsnip::Data &options, PianodConnection &context) const;
 
    const HelpList getHelp (std::vector <std::string> search);
};
 
 
 
class PianodInterpreter : public Parsnip::Interpreter <ResponseCollector , PianodConnection &> {
    friend PianodDispatcher;
    virtual ResponseCollector interpret (Parsnip::Parser::CommandId command_id, const Parsnip::Data &parameters, PianodConnection & context) override final;
protected:
    using StringVector = std::vector <std::string>;
    static const Parsnip::Data EmptyDictionary;
    static const StringVector EmptyStringVector;
 
    virtual bool authorizedCommand (Parsnip::Parser::CommandId command_id, PianodConnection &context) = 0;
 
    virtual ResponseCollector handleCommand (Parsnip::Parser::CommandId command_id, const Parsnip::Data &parameters, PianodConnection &context) = 0;
 
    virtual const Parsnip::Parser::Definitions &getParserDefinitions () = 0;
 
public:
    static bool optionIs (const Parsnip::Data &options, const char *name, const char *expected);
    template <typename ValueType, typename LookupType>
    static inline ValueType optionalValue (const Parsnip::Data &options, const char *name, const LookupType &lookup, const ValueType default_value) {
        return (options.contains (name) ? lookup [options [name].asString()] : default_value);
    }
    using HelpList = PianodDispatcher::HelpList;
    virtual void registerInterpreter (PianodDispatcher &dispatcher);
    const HelpList getHelp (const std::vector <std::string> &search, std::set <std::string> *option_parsers);
};