CommandParser.h

Go to the documentation of this file.

#ifndef CscEnvironmentInteractionCommandParser_h
#define CscEnvironmentInteractionCommandParser_h
 
#include "../Command.h"
#include "./CommandParseContext.h"
#include "./InvalidCommandException.h"
 
#include "ArtificialIntelligence/CscEntityReflexion.h"
#include "ArtificialIntelligence/CscEntityReflexions.h"
#include "CoreObjects/Entities/CscEntityModelsRepository.h"
 
#include <functional>
#include <unordered_set>
 
using std::function, std::runtime_error, conscience_utils::logging::CscLogger, std::unordered_set;
 
using namespace conscience_core::core_objects;
using namespace conscience_core::ai;
 
namespace conscience_core::knowledge {
typedef uint64_t CscArtificialIntelligenceTypes;
}
 
namespace conscience_core::bridging::commands {
 
struct CSC_DLL_IMPORTEXPORT CscStringCommandParts {
    CommandTypeId commandId;
    vector<string> commandArguments;
    optional<int> knowledgeId = {};
};
 
class CSC_DLL_IMPORTEXPORT CscEnvironmentInteractionCommandParser {
 
public:
    static CscEnvironmentInteractionCommandParser *getInstance();
 
    ptr<CscCommand> parseFromString(const string &commandString);
    const CscStringCommandParts splitCommandParts(const string &commandString);
    unordered_set<CommandTypeId> getSupportedCommandIds();
 
    virtual ~CscEnvironmentInteractionCommandParser();
 
protected:
    CscEnvironmentInteractionCommandParser(
        const ConscienceEncoder &conscienceEncoder,
        CscEntityModelsRepository &entityModelRepository,
        CscEntityReflexions &entityReflexions);
 
private:
    typedef function<ptr<CscCommand>(CscCommandParseContext &params)> ParseCommandFunction;
 
    const map<CommandTypeId, ParseCommandFunction> *parseFunctions = nullptr;
 
    const map<CommandTypeId, ParseCommandFunction> &getParseFunctions();
 
    ParseCommandFunction getParseFunction(const CommandTypeId &commandId, bool autoParseFunctionOnly);
 
    inline static CscEnvironmentInteractionCommandParser *instance = nullptr;
    inline static unique_ptr<CscLogger> logger = nullptr;
 
    const ConscienceEncoder &conscienceEncoder;
    CscEntityModelsRepository &entityModelRepository;
    CscEntityReflexions &entityReflexions;
 
    ptr<CscCommand> createCommandMemberToStateFromMember(CscCommandParseContext &parseParams);
    ptr<CscCommand> createCommandMemberToObjectFromMember(CscCommandParseContext &parseParams);
    ptr<CscCommand> createCommandMemberToState(CscCommandParseContext &parseParams);
    ptr<CscCommand> createCommandMemberFocusState(CscCommandParseContext &parseParams);
    ptr<CscCommand> createCommandMemberToStateTeleport(CscCommandParseContext &parseParams);
    ptr<CscCommand> createCommandMemberToStateTeleportEulersOnly(CscCommandParseContext &parseParams);
    ptr<CscCommand> createCommandMemberToStateTeleportStrict(CscCommandParseContext &parseParams);
    ptr<CscCommand> createCommandEntityToObject(CscCommandParseContext &parseParams);
    ptr<CscCommand> createCommandUpdateWheelsPower(CscCommandParseContext &parseParams);
    ptr<CscCommand> createCommandUpdateWheels(CscCommandParseContext &parseParams);
    ptr<CscCommand> createCommandUpdatePropellers(CscCommandParseContext &parseParams);
    ptr<CscCommand> createCommandPlayStateOutputs(CscCommandParseContext &parseParams);
    ptr<CscCommand> createCommandUpdateStateOutputsFromReal(CscCommandParseContext &parseParams);
    ptr<CscCommand> createCommandUpdateConfigurationPivot(CscCommandParseContext &parseParams);
    ptr<CscCommand> createCommandEnvironmentObjectUpdate(CscCommandParseContext &parseParams);
    ptr<CscCommand> createCommandEnvironmentObjectAnalysis(CscCommandParseContext &parseParams);
    ptr<CscCommand> createCommandUpdateConfigurationMember(CscCommandParseContext &parseParams);
    struct CSC_DLL_IMPORTEXPORT VisionDetectParseResult;
    VisionDetectParseResult parseVisionDetectCommand(CscCommandParseContext &parseParams);
    ptr<CscCommand> createCommandVisionDetect(CscCommandParseContext &params);
    ptr<CscCommand> createCommandSaveConfigurationToModelPivot(CscCommandParseContext &parseParams);
    ptr<CscCommand> createCommandSaveConfigurationToModelMembers(CscCommandParseContext &parseParams);
    ptr<CscCommand> createCommandSaveConfigurationToModelParams(CscCommandParseContext &parseParams);
    ptr<CscCommand> createCommandSaveConfigurationToModelWheel(CscCommandParseContext &parseParams);
    ptr<CscCommand> createCommandSaveConfigurationToModelPropeller(CscCommandParseContext &parseParams);
    ptr<CscCommand> createCommandSaveConfigurationToModelTranslation(CscCommandParseContext &parseParams);
    ptr<CscCommand> createCommandTerrassement(CscCommandParseContext &parseParams);
    ptr<CscCommand> createCommandTerrassementPickUp(CscCommandParseContext &parseParams);
    ptr<CscCommand> createCommandTerrassementDropOff(CscCommandParseContext &parseParams);
    ptr<CscCommand> createCommandLocateTargets(CscCommandParseContext &parseParams);
    ptr<CscCommand> createCommandDrilling(CscCommandParseContext &parseParams);
    ptr<CscCommand> createCommandUpdateFloorRotation(CscCommandParseContext &parseParams);
 
    ptr<CscCommand> createCommandEntityFollowPath(CscCommandParseContext &parseParams);
    ptr<CscCommand> createCommandUpdateConfigurationTranslation(CscCommandParseContext &parseParams);
    ptr<CscCommand> createCommandTellThis(CscCommandParseContext &parseParams);
    ptr<CscCommand> createCommandFollowTrajectoryAndProject(CscCommandParseContext &parseParams);
 
    ptr<CscCommand> createCommandFollowKinematicTrajectory(CscCommandParseContext &parseParams);
    ptr<CscCommand> createCommandEntityToLocationTag(CscCommandParseContext &parseParams);
    ptr<CscCommand> createCommandKinematicMovement(CscCommandParseContext &parseParams);
    ptr<CscCommand> createCommandMultiPodWalk(CscCommandParseContext &parseParams);
 
    ptr<CscCommand> createCommandJacobianInverseKinematicMovement(CscCommandParseContext &parseParams);
 
    template <class TCommandClass>
    ptr<CscCommand> createCommandAreaAnalysis(CscCommandParseContext &parseParams) {
        const vector<string> &arguments = parseParams.arguments;
 
        logger->trace("Creating ConscienceEnvironmentInteractionCommandAreaAnalysis from arguments - size=" + to_string(arguments.size()));
        string parametersString = arguments.at(PARAMETERS_ARGUMENT_INDEX);
        logger->trace("ParametersString=" + parametersString);
 
        vector<string> *parametersTokens = splitString(parametersString, PARAMETERS_ARGUMENT_DELIMITER);
 
        int paramIndex = 0;
 
        const string entitySerialNumber = parametersTokens->at(paramIndex++);
        int numberOfPosition = stoi(parametersTokens->at(paramIndex++));
        vector<const CscPoint3d *> areaVertices = vector<const CscPoint3d *>();
 
        for (int i = 0; i < numberOfPosition; i++) {
            int x = stoi(parametersTokens->at(paramIndex++));
            int y = stoi(parametersTokens->at(paramIndex++));
            int z = stoi(parametersTokens->at(paramIndex++));
            areaVertices.push_back(new CscPoint3d(x, y, z));
        }
 
        int numberOfHoles = stoi(parametersTokens->at(paramIndex++));
        vector<vector<const CscPoint3d *>> holes = vector<vector<const CscPoint3d *>>();
 
        for (int i = 0; i < numberOfHoles; i++) {
            vector<const CscPoint3d *> hole = vector<const CscPoint3d *>();
            int numberOfPositionHole = stoi(parametersTokens->at(paramIndex++));
            for (int j = 0; j < numberOfPositionHole; j++) {
                int x = stoi(parametersTokens->at(paramIndex++));
                int y = stoi(parametersTokens->at(paramIndex++));
                int z = stoi(parametersTokens->at(paramIndex++));
                hole.push_back(new CscPoint3d(x, y, z));
            }
            holes.push_back(hole);
        }
        float areaOfPerceptionWidth = stof(parametersTokens->at(paramIndex++));
        int x = stoi(parametersTokens->at(paramIndex++));
        int y = stoi(parametersTokens->at(paramIndex++));
        int z = stoi(parametersTokens->at(paramIndex++));
        const CscPoint3d *entityPosition = new CscPoint3d(x, y, z);
 
        ptr<CscEntityReflexion> entityReflexion = entityReflexions.getBySerialNumber(entitySerialNumber);
 
        optional<bool> doNotPlay = {};
        if (parametersTokens->size() > paramIndex) {
            if (trim(parametersTokens->at(paramIndex)) != "") {
                doNotPlay = parametersTokens->at(paramIndex) == "true";
            }
            paramIndex++;
        }
 
        delete parametersTokens;
 
        return newptr<TCommandClass>(entityReflexion, areaVertices, holes, areaOfPerceptionWidth, entityPosition, doNotPlay);
    }
    ptr<CscCommand> createCommandLidarLocalizationControl(CscCommandParseContext &parseParams);
    ptr<CscCommand> createCommandStopFollowObject(CscCommandParseContext &parseParams);
 
    CscArtificialIntelligenceTypes aiBoolToTypes(bool typeGenetic, bool typeKinematic);
 
    ptr<CscCommand> doParseFromString(const string &commandString, bool forceAutoParse);
};
}
 
#endif