SdlCommandParser.h

Go to the documentation of this file.

#pragma once
 
#include "SDL/sdl_fwd.h"
#include "SDL/SdlInputClauses.h"
#include "SDL/ESdlTypeCategory.h"
#include "SDL/SdlDataPacketInterface.h"
#include "DataIO/FileSystem/Path.h"
#include "Utility/SemanticVersion.h"
#include "Utility/TSpan.h"
 
#include <string>
#include <string_view>
#include <unordered_map>
#include <memory>
 
namespace ph
{
 
enum class ESdlCommandType
{
    Unknown = 0,
    Directive,
    Load,
    Removal,
    Update,
    Execution,
    NamedDataPacket,
    Phantom
};
 
class SdlCommandParser
{
public:
    explicit SdlCommandParser(TSpanView<const SdlClass*> targetClasses);
    SdlCommandParser(TSpanView<const SdlClass*> targetClasses, const Path& sceneWorkingDirectory);
    virtual ~SdlCommandParser();
 
    // TODO: rename existing methods to enterAndWait() and flushAndWait() and add flush() and enter() once multithreading is added
    // TODO: removeResource() callback for load error, etc.
 
    void parse(std::string_view rawCommandSegment);
 
    void flush();
 
    void setPacketInterface(std::unique_ptr<SdlDataPacketInterface> interface);
    void setSceneWorkingDirectory(const Path& directory);
    SdlDataPacketInterface& getPacketInterface();
    const Path& getSceneWorkingDirectory() const;
    const SemanticVersion& getCommandVersion() const;
    std::size_t numParsedCommands() const;
    std::size_t numParseErrors() const;
 
protected:
    virtual bool beginCommand(
        ESdlCommandType commandType, 
        const SdlClass* targetClass,
        SdlInputContext* out_ctx) = 0;
 
    virtual void endCommand() = 0;
 
    virtual ISdlResource* createResource(
        std::string_view resourceName, 
        const SdlInputContext& ctx,
        ESdlCommandType commandType) = 0;
    
    virtual void initResource(
        std::string_view resourceName,
        ISdlResource* resource, 
        const SdlInputContext& ctx,
        SdlInputClauses& clauses,
        ESdlCommandType commandType) = 0;
    
    virtual ISdlResource* getResource(
        std::string_view resourceName,
        const SdlInputContext& ctx) = 0;
 
    virtual void runExecutor(
        std::string_view executorName,
        const SdlInputContext& ctx,
        ISdlResource* targetResource,
        SdlInputClauses& clauses,
        ESdlCommandType commandType) = 0;
 
    virtual void commandVersionSet(
        const SemanticVersion& version,
        const SdlInputContext& ctx) = 0;
 
    virtual void storeNamedDataPacket(
        std::string_view packetName,
        const SdlInputClauses& packet,
        const SdlInputContext& ctx) = 0;
 
private:
    // OPT: use view
    struct CommandHeader final
    {
        ESdlCommandType commandType = ESdlCommandType::Unknown;
        std::string targetCategory;
        std::string targetType;
        std::string executorName;
        std::string dataPacketName;
        std::string reference;
        std::string dataString;
 
        bool isRecognized() const;
    };
 
    SemanticVersion m_commandVersion;
 
    std::unordered_map<std::string, const SdlClass*> m_mangledNameToClass;
    std::unique_ptr<SdlDataPacketInterface> m_packetInterface;
 
    Path m_sceneWorkingDirectory;
    bool m_isInSingleLineComment;
    std::string m_processedCommandCache;
    std::size_t m_generatedNameCounter;
    std::size_t m_numParsedCommands;
    std::size_t m_numParseErrors;
 
private:
    void enterProcessed(std::string_view processedCommandSegment);
 
    void parseCommand(const std::string& command);
    void parseSingleCommand(const CommandHeader& command);
 
    void parseLoadCommand(const CommandHeader& command);
    void parseExecutionCommand(const CommandHeader& command);
    void parseDirectiveCommand(const CommandHeader& command);
    void parseNamedDataPacketCommand(const CommandHeader& command);
 
    void getClauses(
        std::string_view packetCommand, 
        const SdlInputContext& ctx,
        std::string_view targetName,
        ISdlResource* targetInstance,
        SdlInputClauses* out_clauses);
 
    const SdlClass* getSdlClass(const std::string& mangledClassName) const;
    const SdlClass* getSdlClass(std::string_view categoryName, std::string_view typeName) const;
 
private:
    static std::string getMangledName(std::string_view categoryName, std::string_view typeName);
    static void getMangledName(std::string_view categoryName, std::string_view typeName, std::string* out_mangledName);
    static CommandHeader parseCommandHeader(std::string_view command);
};
 
// In-header Implementations:
 
inline const Path& SdlCommandParser::getSceneWorkingDirectory() const
{
    return m_sceneWorkingDirectory;
}
 
inline const SemanticVersion& SdlCommandParser::getCommandVersion() const
{
    return m_commandVersion;
}
 
inline std::size_t SdlCommandParser::numParsedCommands() const
{
    return m_numParsedCommands;
}
 
inline std::size_t SdlCommandParser::numParseErrors() const
{
    return m_numParseErrors;
}
 
inline bool SdlCommandParser::CommandHeader::isRecognized() const
{
    return commandType != ESdlCommandType::Unknown;
}
 
}// end namespace ph