TestCommandParamsFile.h

Go to the documentation of this file.

//
// Created by Louis Grignon on 18/04/2025.
//
 
#ifndef TESTCOMMANDPARAMSFILE_H
#define TESTCOMMANDPARAMSFILE_H
 
#include <CscCommon.h>
#include <Bridging/EnvironmentInteractionCommands/MetadataBuilder/CscCommandMetadataBuilder.h>
#include <Bridging/EnvironmentInteractionCommands/Command.h>
using namespace conscience_core::bridging::commands::metadata;
using namespace conscience_core::bridging::commands;
 
namespace conscience_core::bridging::commands {
// Structure pour TestSub1
struct TestSub1CommandDataType {
    TestSub1CommandDataType() : field1("") {}
 
    TestSub1CommandDataType(const string &field1) : field1(field1) {}
 
    string field1;
};
 
// Structure pour TestSub2
struct TestSub2CommandDataType {
    TestSub2CommandDataType() : subs(), b(false) {}
 
    TestSub2CommandDataType(const vector<ptr<TestSub1CommandDataType>> &subs, bool b) : subs(subs), b(b) {}
 
    vector<ptr<TestSub1CommandDataType>> subs;
    bool b;
};
 
// Structure pour TestSub3
struct TestSub3CommandDataType {
    TestSub3CommandDataType() : maybeSubs(nullopt), c(nullopt), d(nullopt) {
    }
 
    TestSub3CommandDataType(const optional<optional<vector<optional<ptr<TestSub1CommandDataType>>>>> &maybeSubs,
                            const optional<double> &c,
                            const optional<string> &d)
        : maybeSubs(maybeSubs), c(c), d(d) {
    }
 
    optional<optional<vector<optional<ptr<TestSub1CommandDataType>>>>> maybeSubs;
    optional<double> c;
    optional<string> d;
};
 
class CommandTest : public CscCommand {
 
public:
    inline static const CommandTypeId COMMAND_ID = "TEST_COMMAND_1";
 
    CommandTest(const string &name, int age, const string &city, const ptr<TestSub2CommandDataType> &subField)
        : CscCommand(COMMAND_ID), name(name), age(age), city(city), subField(subField) {}
 
    ~CommandTest() override {
    }
 
protected:
 
    const CscCommandExecutionResultNone *doExecute(CscEnvironmentSimulator &environmentSimulator) override {
        return new CscCommandExecutionResultNone();
    }
 
    ptr<CscEntityReflexion> getEntityReflexion() const override {
        return nullptr;
    }
 
private:
    string name;
    int age;
    string city;
    ptr<TestSub2CommandDataType> subField;
 
};
 
// COMMAND_TYPE_BUILDER(CommandTest, TestSub1CommandDataType, const string &)
// COMMAND_TYPE_BUILDER(CommandTest, TestSub2CommandDataType, const vector<ptr<TestSub1CommandDataType>> &, bool)
// COMMAND_TYPE_BUILDER(CommandTest, TestSub3CommandDataType, const optional<optional<vector<optional<ptr<TestSub1CommandDataType>>>>> &,
//                      const optional<double> &,
//                      const optional<string> &)
//COMMAND_REGISTER(CommandTest, const string &, int, const string &, const ptr<TestSub2CommandDataType> &)
 
class CommandTest2 : public CscCommand {
 
public:
    inline static const CommandTypeId COMMAND_ID = "TEST_COMMAND_2";
 
    CommandTest2(double g, const vector<string> &strings,
                 const map<string, map<string, string>> &desData,
                 const map<string, ptr<TestSub1CommandDataType>> &mapOfObject,
                 const map<string, map<int, ptr<TestSub1CommandDataType>>> &mapOfMapOfObject)
        : CscCommand(COMMAND_ID), g(g), strings(strings), desData(desData), mapOfObject(mapOfObject), mapOfMapOfObject(mapOfMapOfObject) {}
 
    ~CommandTest2() override {}
 
protected:
    const CscCommandExecutionResultNone *doExecute(CscEnvironmentSimulator &environmentSimulator) override {
        return new CscCommandExecutionResultNone();
    }
 
    ptr<CscEntityReflexion> getEntityReflexion() const override {
        // Implémentez ici la logique pour obtenir l'entité de réflexion
        return nullptr;
    }
 
private:
    double g;
    vector<string> strings;
    map<string, map<string, string>> desData;
    map<string, ptr<TestSub1CommandDataType>> mapOfObject;
    map<string, map<int, ptr<TestSub1CommandDataType>>> mapOfMapOfObject;
};
 
//COMMAND_REGISTER(CommandTest2, double, const vector<string> &, const map<string, map<string, string>> &, const map<string, ptr<TestSub1CommandDataType>> &, const map<string, map<int, ptr<TestSub1CommandDataType>>> &)
 
// Classe pour la commande Simple
class CommandSimple : public CscCommand {
 
public:
    inline static const CommandTypeId COMMAND_ID = "SIMPLE_TEST_COMMAND";
 
    CommandSimple(const string &serialNumber)
        : CscCommand(COMMAND_ID), serialNumber(serialNumber) {}
 
    ~CommandSimple() override {}
 
protected:
    const CscCommandExecutionResultNone *doExecute(CscEnvironmentSimulator &environmentSimulator) override {
        return new CscCommandExecutionResultNone();
    }
 
    ptr<CscEntityReflexion> getEntityReflexion() const override {
        // Implémentez ici la logique pour obtenir l'entité de réflexion
        return nullptr;
    }
 
private:
    string serialNumber;
};
 
// COMMAND_REGISTER(CommandSimple, const string &)
 
// Classe pour la commande SimpleWithMap
class CommandSimpleWithMap : public CscCommand {
 
public:
    inline static const CommandTypeId COMMAND_ID = "SIMPLE_TEST_MAP_COMMAND";
 
    CommandSimpleWithMap(const map<string, int> &myInts)
        : CscCommand(COMMAND_ID), myInts(myInts) {}
 
    ~CommandSimpleWithMap() override {}
 
protected:
    const CscCommandExecutionResultNone *doExecute(CscEnvironmentSimulator &environmentSimulator) override {
        return new CscCommandExecutionResultNone();
    }
 
    ptr<CscEntityReflexion> getEntityReflexion() const override {
        // Implémentez ici la logique pour obtenir l'entité de réflexion
        return nullptr;
    }
 
private:
    map<string, int> myInts;
};
 
// COMMAND_REGISTER(CommandSimpleWithMap, const map<string, int> &)
 
// Classe pour la commande SimpleWithVectorOfObjects
class CommandSimpleWithVectorOfObjects : public CscCommand {
 
public:
    inline static const CommandTypeId COMMAND_ID = "SIMPLE_TEST_VECTOR_OF_OBJECTS_COMMAND";
 
    CommandSimpleWithVectorOfObjects(const vector<ptr<TestSub1CommandDataType>> &objectsList)
        : CscCommand(COMMAND_ID), objectsList(objectsList) {}
 
    ~CommandSimpleWithVectorOfObjects() override {}
 
protected:
    const CscCommandExecutionResultNone *doExecute(CscEnvironmentSimulator &environmentSimulator) override {
        return new CscCommandExecutionResultNone();
    }
 
    ptr<CscEntityReflexion> getEntityReflexion() const override {
        // Implémentez ici la logique pour obtenir l'entité de réflexion
        return nullptr;
    }
 
private:
    vector<ptr<TestSub1CommandDataType>> objectsList;
};
 
// COMMAND_REGISTER(CommandSimpleWithVectorOfObjects, const vector<ptr<TestSub1CommandDataType>> &)
 
// Classe pour la commande SimpleWithOptional
class CommandSimpleWithOptional : public CscCommand {
 
public:
    inline static const CommandTypeId COMMAND_ID = "SIMPLE_TEST_OPTIONAL";
 
    CommandSimpleWithOptional(const ptr<TestSub3CommandDataType> &sub3, const optional<map<string, int>> &maybeMyInts)
        : CscCommand(COMMAND_ID), sub3(sub3), maybeMyInts(maybeMyInts) {}
 
    ~CommandSimpleWithOptional() override {}
 
protected:
    const CscCommandExecutionResultNone *doExecute(CscEnvironmentSimulator &environmentSimulator) override {
        return new CscCommandExecutionResultNone();
    }
 
    ptr<CscEntityReflexion> getEntityReflexion() const override {
        // Implémentez ici la logique pour obtenir l'entité de réflexion
        return nullptr;
    }
 
private:
    ptr<TestSub3CommandDataType> sub3;
    optional<map<string, int>> maybeMyInts;
};
 
// COMMAND_REGISTER(CommandSimpleWithOptional, const ptr<TestSub3CommandDataType> &, const optional<map<string, int>> &)
 
// Classe pour la commande OptionalOfObject
class CommandOptionalOfObject : public CscCommand {
 
public:
    inline static const CommandTypeId COMMAND_ID = "TEST_OPTIONAL_OF_OBJECT";
 
    CommandOptionalOfObject(const optional<ptr<TestSub1CommandDataType>> &sub1)
        : CscCommand(COMMAND_ID), sub1(sub1) {}
 
    ~CommandOptionalOfObject() override {}
 
protected:
    const CscCommandExecutionResultNone *doExecute(CscEnvironmentSimulator &environmentSimulator) override {
        return new CscCommandExecutionResultNone();
    }
 
    ptr<CscEntityReflexion> getEntityReflexion() const override {
        // Implémentez ici la logique pour obtenir l'entité de réflexion
        return nullptr;
    }
 
private:
    optional<ptr<TestSub1CommandDataType>> sub1;
};
 
// COMMAND_REGISTER(CommandOptionalOfObject, const optional<ptr<TestSub1CommandDataType>> &)
 
 
}
#endif