Command.h

Go to the documentation of this file.

#ifndef ConscienceEnvironmentInteractionCommand_h
#define ConscienceEnvironmentInteractionCommand_h
 
#include "CscCommon.h"
#include "./Parser/InvalidCommandException.h"
#include "./Result/CommandExecutionResult.h"
#include "./Result/CommandExecutionResultNone.h"
#include "./Result/CommandExecutionResultSequence.h"
#include "./Result/CommandExecutionResultFile.h"
#include "CoreObjects/CscSequence.h"
#include "CoreObjects/CscPhysicsType.h"
#include "CscCommandsProcessor.h"
#include "ArtificialIntelligence/CscEntityReflexion.h"
 
typedef string CscWorldElementId;
 
using std::fstream, std::stringstream, std::istringstream, std::ios;
 
// those forward references below are very useful to optimize compilation. Please do not include these directly
namespace conscience_core::ai {
class CscEntityReflexion;
}
using namespace conscience_core::ai;
class CscEnvironmentSimulator;
 
namespace conscience_core::bridging::commands {
 
using namespace result;
typedef string CommandTypeId;
 
struct CSC_DLL_IMPORTEXPORT CommandSpecification {
    std::string name;
    std::string type;
    std::string defaultValue;
    bool optional;
};
 
typedef function<const CscCommandExecutionResult *(CscEnvironmentSimulator &environmentSimulator)> FunctionCommand;
 
class CSC_DLL_IMPORTEXPORT CscCommand {
 
public:
 
    template <class TResult = CscCommandExecutionResult>
    const TResult *execute(CscEnvironmentSimulator &environmentSimulator) {
 
        ptr<CscEntityReflexion> entityReflexion = getEntityReflexion();
        if (entityReflexion != nullptr) {
            onCommandExecutionStartOnEntity(this, entityReflexion->getSerialNumber());
        }
 
        LOG_TRACE("execute command of type: " + getTypeId());
 
        const CscCommandExecutionResult *result = doExecute(environmentSimulator);
        if (result == nullptr) {
            return nullptr;
        }
        if (auto resultTyped = dynamic_cast<const TResult *>(result)) {
            entityReflexion = getEntityReflexion();
            if (entityReflexion != nullptr) {
                onCommandExecutedOnEntity(this, entityReflexion->getSerialNumber(), result, environmentSimulator);
            }
            onCommandExecuted(this);
            return resultTyped;
        } else {
            const std::type_info &requestedTypeInfo = typeid(TResult);
            throw runtime_error("Invalid command result - requested: " + getClassName(requestedTypeInfo, true));
        }
    }
 
    const CommandTypeId &getTypeId() const;
 
    virtual ~CscCommand();
 
    typedef function<void(CscCommand *command)> CommandExecutedListener;
    static void addCommandExecutedListener(CommandExecutedListener listener);
 
    void setOriginalCommandString(string command);
 
protected:
    const CommandTypeId typeId;
 
    CscCommand(const CommandTypeId &typeId);
 
    virtual const CscCommandExecutionResult *doExecute(
        CscEnvironmentSimulator &environmentSimulator) = 0;
 
    const CscCommandExecutionResultNone *resultNone();
    const CscCommandExecutionResultSequence *resultSequence(CscSequence *sequence, const string &entitySerialNumber, bool doNotPlay = false);
    const CscCommandExecutionResultFile *resultFile(const fs::path &resultingFilePath);
 
    template <class TResult>
    const CscCommandExecutionResultObject<TResult> *resultObject(TResult *result) {
        return new CscCommandExecutionResultObject<TResult>(result);
    }
 
    virtual ptr<CscEntityReflexion> getEntityReflexion() const = 0;
 
    const CscWorldElementId getEntityId() const;
    optional<string> originalCommandString = {};
 
private:
    inline static vector<CommandExecutedListener> commandExecutedListeners;
    void onCommandExecuted(CscCommand *command);    
};
 
class CSC_DLL_IMPORTEXPORT CommandExecutionException : public runtime_error {
public:
    CommandExecutionException(const string &type, const string &message, const optional<int> &code = {});
    const string type;
    const optional<int> code;
    string toJson() const;
};
 
template <class TResult>
class CSC_DLL_IMPORTEXPORT CscCommandTypedResult : public CscCommand {
public:
    using ResultType = TResult;
 
    const TResult *execute(CscEnvironmentSimulator &environmentSimulator)
    {
        return CscCommand::execute<TResult>(environmentSimulator);
    }
 
protected:
    explicit CscCommandTypedResult(const CommandTypeId &typeId)
        : CscCommand(typeId)
    {
    }
 
    const TResult *doExecute(CscEnvironmentSimulator &environmentSimulator) override = 0;
};
 
}
 
#endif