CommandExecutionResult.h

Go to the documentation of this file.

#ifndef CommandExecutionResult_h
#define CommandExecutionResult_h
 
#include "CscCommon.h"
#include "../CommandParamsSpec.h"
 
namespace conscience_core::bridging::commands::result {
 
 
#define COMMAND_RESULT_JSON_SERIALIZER(TClass, ...)                                                                                      \
    namespace {                                                                                                                          \
    bool __registerCommandResultJsonSerializer_##TClass = registerCommandDataJsonSerializer(typeid(TClass), [](const any &objectAny) { \
        auto logger = CscLogger::getForCategory(#TClass "JsonSerializerFunc");                                                           \
        const TClass *object = anyToPointer<TClass>(objectAny);                                                                          \
        optional<JsonSerializableData> result = {};                                                                         \
        if (object != nullptr) {                                                                                                         \
            map<string, JsonSerializableData> jsonMap;                                                                                   \
            FOR_EACH(FIELDS_ASSIGN_INTO_JSONMAP_PRINT_NOTYPE, __VA_ARGS__)                                                                 \
            result = jsonMap;                                                                                                            \
        }                                                                                                                                \
        return result;                                                                                                                   \
    });                                                                                                                                  \
    }
 
ENUM(CscCommandResultType,
    RESULT_NONE,
    RESULT_SEQUENCE,
    RESULT_POSITIONS,
    RESULT_FILE,
    RESULT_STRING,
    RESULT_BINARY,
    RESULT_OBJECT,
    RESULT_LIST,
    RESULT_BOOL,
    RESULT_LONG,
    RESULT_UNSIGNEDLONG,
    RESULT_DOUBLEFLOAT);
;
string commandResultTypeToString(CscCommandResultType type);
 
class CSC_DLL_IMPORTEXPORT CscCommandExecutionResult {
public:
    virtual ~CscCommandExecutionResult() = default;
    virtual DoubleSizedArray encode() const = 0;
 
    virtual string encodeToString() const {
        DoubleSizedArray result = encode();
        return doubleArrayToString(result.array, result.size);
    }
 
    virtual CscCommandResultType getType() const = 0;
 
    virtual string toSummary() const;
 
    virtual CscCommandExecutionResult *clone(bool retainData) const {
        hasPointersOwnership = hasPointersOwnership && !retainData;
        return doClone();
    }
 
protected: 
    virtual CscCommandExecutionResult *doClone() const = 0;
    mutable bool hasPointersOwnership = true;
};
 
class CSC_DLL_IMPORTEXPORT CscCommandExecutionResultDouble : public CscCommandExecutionResult {
public:
    CscCommandExecutionResultDouble(double value);
    ~CscCommandExecutionResultDouble() override = default;
    DoubleSizedArray encode() const override;
    CscCommandResultType getType() const override;
    string encodeToString() const override;
    string toSummary() const override;
    double getValue() const;
protected:
    CscCommandExecutionResult *doClone() const override;
private:
    double value;
};
 
template <class TResult>
class CscCommandExecutionResultObject : public CscCommandExecutionResult {
public:
    CSC_DLL_IMPORTEXPORT CscCommandExecutionResultObject(const TResult *value) : value(value) {}
    CSC_DLL_IMPORTEXPORT ~CscCommandExecutionResultObject() override { if (hasPointersOwnership && value != nullptr) { delete value; } }
    CSC_DLL_IMPORTEXPORT DoubleSizedArray encode() const override { throw std::runtime_error("not supported - obsolete feature encode to double array"); }
    CSC_DLL_IMPORTEXPORT CscCommandResultType getType() const override { return CscCommandResultType::RESULT_OBJECT; }
    CSC_DLL_IMPORTEXPORT string encodeToString() const override {
        function<optional<JsonSerializableData>(const any &object)> serializer = getCommandDataJsonSerializer<TResult>();
        optional<JsonSerializableData> resultJsonValue = serializer(value);
        if (!resultJsonValue) {
            return "null";
        }
        return jsonSerializableDataToString(resultJsonValue.value());
    }
    CSC_DLL_IMPORTEXPORT string toSummary() const override { return encodeToString(); }
    CSC_DLL_IMPORTEXPORT const TResult *getValue() const { return value; }
protected:
    CscCommandExecutionResult *doClone() const override { 
        return new CscCommandExecutionResultObject(value);
    }
private:
    const TResult *value;
};
 
template <class TResult>
class CscCommandExecutionResultList : public CscCommandExecutionResult {
public:
    CSC_DLL_IMPORTEXPORT CscCommandExecutionResultList(const vector<const TResult *> &value) : value(value) {}
    CSC_DLL_IMPORTEXPORT CscCommandExecutionResultList(const vector<TResult *> &value) : value(vectorOfPointerToConst(value)) {}
    CSC_DLL_IMPORTEXPORT ~CscCommandExecutionResultList() override { if (hasPointersOwnership) { deleteItems(value); } }
    CSC_DLL_IMPORTEXPORT DoubleSizedArray encode() const override { throw std::runtime_error("not supported - obsolete feature encode to double array"); }
    CSC_DLL_IMPORTEXPORT CscCommandResultType getType() const override { return CscCommandResultType::RESULT_LIST; }
    CSC_DLL_IMPORTEXPORT string encodeToString() const override {
        function<optional<JsonSerializableData>(const any &object)> serializer = getCommandDataJsonSerializer<TResult>();
        vector<JsonSerializableData> jsonList;
        for (const TResult *item : value) {
            optional<JsonSerializableData> resultJsonValue = serializer(item);
            if (resultJsonValue.has_value()) {
                jsonList.push_back(resultJsonValue.value());
            } else {
                jsonList.push_back(nullptr);
            }
        }
        return vectorToJson(jsonList);
    }
    CSC_DLL_IMPORTEXPORT string toSummary() const override { return encodeToString(); }
    CSC_DLL_IMPORTEXPORT const vector<const TResult *> &getValue() const { return value; }
protected:
    CscCommandExecutionResult *doClone() const override { 
        return new CscCommandExecutionResultList(value);
    }
private:
    const vector<const TResult *> value;
};
 
class CSC_DLL_IMPORTEXPORT CscCommandExecutionResultBool : public CscCommandExecutionResult {
public:
    CscCommandExecutionResultBool(bool value);
    ~CscCommandExecutionResultBool() override = default;
    DoubleSizedArray encode() const override;
    CscCommandResultType getType() const override;
    string encodeToString() const override;
    string toSummary() const override;
    bool getValue() const;
protected:
    CscCommandExecutionResult *doClone() const override;
private:
    bool value;
};
 
class CSC_DLL_IMPORTEXPORT CscCommandExecutionResultLong : public CscCommandExecutionResult {
public:
    CscCommandExecutionResultLong(long long value);
    ~CscCommandExecutionResultLong() override = default;
    DoubleSizedArray encode() const override;
    CscCommandResultType getType() const override;
    string encodeToString() const override;
    string toSummary() const override;
    long long getValue() const;
protected:
    CscCommandExecutionResult *doClone() const override;
private:
    long long value;
};
 
class CSC_DLL_IMPORTEXPORT CscCommandExecutionResultUnsignedLong : public CscCommandExecutionResult {
public:
    CscCommandExecutionResultUnsignedLong(unsigned long long value);
    ~CscCommandExecutionResultUnsignedLong() override = default;
    DoubleSizedArray encode() const override;
    CscCommandResultType getType() const override;
    string encodeToString() const override;
    string toSummary() const override;
    unsigned long long getValue() const;
protected:
    CscCommandExecutionResult *doClone() const override;
private:
    unsigned long long value;
};
 
}
 
#endif