CommandParamsSpec.h

Go to the documentation of this file.

#ifndef ConscienceEnvironmentInteractionCommandParams_h
#define ConscienceEnvironmentInteractionCommandParams_h
 
#include "CscCommon.h"
#include "Util/json.h"
#include <any>
#include <functional>
#include <type_traits>
#include <typeinfo>
#include <shared_mutex>
#include <Util/shared_recursive_mutex.h>
#include <Configuration/CscKeyDirectories.h>
 
using std::type_info, std::any, std::shared_mutex, std::shared_lock, std::unique_lock, std::any_cast, std::function;
using namespace conscience_utils::mutexutils;
using namespace conscience_core::bridging;
 
#define FOR_EACH_PAIR(macro, ...) \
    __VA_OPT__(MACRO_EXPAND(FOR_EACH_PAIR_HELPER(macro, __VA_ARGS__)))
 
#define FOR_EACH_PAIR_HELPER(macro, a1, a2, ...) \
    macro(a1, a2)                                \
        __VA_OPT__(FOR_EACH_PAIR_AGAIN MACRO_PARENS(macro, __VA_ARGS__))
#define FOR_EACH_PAIR_AGAIN() FOR_EACH_PAIR_HELPER
 
template <typename TClass>
const TClass *anyToPointer(const any &objectAny) {
    if (!objectAny.has_value()) {
        return nullptr;
    }
    try {
        ptr<const TClass> objectPtr = any_cast<ptr<const TClass>>(objectAny);
        return objectPtr == nullptr ? nullptr : objectPtr.get();
    } catch (exception &e) {
    }
    try {
        ptr<TClass> objectPtr = any_cast<ptr<TClass>>(objectAny);
        return objectPtr == nullptr ? nullptr : objectPtr.get();
    } catch (exception &e) {
    }
    try {
        return any_cast<TClass *>(objectAny);
    } catch (exception &e) {
    }
    try {
        return any_cast<const TClass *>(objectAny);
    } catch (exception &e) {
    }
    throw runtime_error("cannot get " + getClassName(typeid(TClass), true) + "* from " + getClassName(objectAny.type(), true));
}
 
template <class TValue>
using map_by_string = std::map<string, TValue>;
 
template <class TValue>
using map_by_int = std::map<int, TValue>;
 
using namespace conscience_utils::JSON;
 
namespace conscience_core::bridging::commands {
 
ENUM(CommandParamMetaType,
     CommandParamMetaType_double,
     CommandParamMetaType_float,
     CommandParamMetaType_int,
     CommandParamMetaType_long,
     CommandParamMetaType_unsigned_long_long,
     CommandParamMetaType_bool,
     CommandParamMetaType_string,
     CommandParamMetaType_list,
     CommandParamMetaType_map,
     CommandParamMetaType_object,
     CommandParamMetaType_optional,
     CommandParamMetaType_enum,
     CommandParamMetaType_entityReflexion,
     CommandParamMetaType_entityModel,
     CommandParamMetaType_placeModel,
     CommandParamMetaType_objectModel);
 
class CSC_DLL_IMPORTEXPORT MissingCommandDataTypeException : public runtime_error {
public:
    MissingCommandDataTypeException(const string &missingParamType, const string &message);
    const string missingParamTypeName;
};
 
class CSC_DLL_IMPORTEXPORT MissingCommandMetadataException : public runtime_error {
public:
    MissingCommandMetadataException(const string &missingCommandId, const string &message);
    const string missingCommandId;
};
 
class CSC_DLL_IMPORTEXPORT WrongCommandDataTypeDuringParseException : public runtime_error {
public:
    WrongCommandDataTypeDuringParseException(const string &name, CommandParamMetaType expectedType, int actualUnderlyingType);
    const string name;
    const CommandParamMetaType expectedType;
    const int actualUnderlyingType;
};
 
class CSC_DLL_IMPORTEXPORT WrongCommandParamsSizeDuringParseException : public runtime_error {
public:
    WrongCommandParamsSizeDuringParseException(const string &name, int expectedSize, int actualSize);
    const string name;
    const int expectedSize;
    const int actualSize;
};
 
class CSC_DLL_IMPORTEXPORT CscCommandDataTypeBase {
public:
    virtual map<string, JsonSerializableData> toJsonMap() = 0;
};
 
class CscCommandDataTypeMetadata;
 
struct CSC_DLL_IMPORTEXPORT CscEnumInfos {
    string enumSimpleName;
    string enumQualifiedName;
    map<string, unsigned long long> values;
    map<string, string> valuesDoc;
    string doc;
    string headerFileRelativePath = "";
 
    string toString() const {
        return enumQualifiedName + " - values=" + mapToString(values) + " - headerFileRelativePath=" + headerFileRelativePath;
    }
};
 
enum CscCommandPtrType {
    CommandPtrType_STAR,
    CommandPtrType_SHARED,
    CommandPtrType_REF,
    CommandPtrType_PLAIN
};
 
inline bool isNullableObjectType(CscCommandPtrType refType) {
    return refType == CommandPtrType_STAR || refType == CommandPtrType_SHARED;
}
 
class CSC_DLL_IMPORTEXPORT CscCommandDataTypeNodeMetadata {
private:
    string name = "";
    string doc = "";
    CommandParamMetaType type;
    const CscEnumInfos *enumInfos = nullptr;
 
    vector<const CscCommandDataTypeNodeMetadata *> nestedParams;
    const CscCommandDataTypeMetadata *objectTypeMetadata = nullptr;
 
    optional<CscCommandPtrType> ptrType = {};
 
    CscCommandDataTypeNodeMetadata(const string &name, const string &doc, CommandParamMetaType type);
    CscCommandDataTypeNodeMetadata(const string &name, const string &doc, const CscCommandDataTypeNodeMetadata *elementsType, CommandParamMetaType type);
    CscCommandDataTypeNodeMetadata(const string &name, const string &doc, const CscCommandDataTypeNodeMetadata *elementsType);
    CscCommandDataTypeNodeMetadata(const string &name, const string &doc, const CscCommandDataTypeNodeMetadata *keysType, const CscCommandDataTypeNodeMetadata *valuesType);
    CscCommandDataTypeNodeMetadata(const string &name, const string &doc, const CscCommandDataTypeMetadata *objectTypeMetadata, CscCommandPtrType ptrType);
    CscCommandDataTypeNodeMetadata(const string &name, const string &doc, const CscEnumInfos *enumInfos);
 
public:
    static const CscCommandDataTypeNodeMetadata *forPrimitive(const string &name, const string &doc, CommandParamMetaType type);
    static const CscCommandDataTypeNodeMetadata *forList(const string &name, const string &doc, const CscCommandDataTypeNodeMetadata *elementsType);
    static const CscCommandDataTypeNodeMetadata *forMap(const string &name, const string &doc, const CscCommandDataTypeNodeMetadata *keysType, const CscCommandDataTypeNodeMetadata *valuesType);
    static const CscCommandDataTypeNodeMetadata *forObject(const string &name, const string &doc, const CscCommandDataTypeMetadata *objectTypeMetadata, CscCommandPtrType ptrType);
    static const CscCommandDataTypeNodeMetadata *forOptional(const string &name, const string &doc, const CscCommandDataTypeNodeMetadata *optionalType);
    static const CscCommandDataTypeNodeMetadata *forEnum(const string &name, const string &doc, const CscEnumInfos *enumInfos);
    ~CscCommandDataTypeNodeMetadata();
 
    const string &getName() const;
 
    const string &getDoc() const;
 
    CommandParamMetaType getType() const;
 
    bool isValueRequired() const;
 
    string typeToString() const;
 
    const vector<const CscCommandDataTypeNodeMetadata *> &getNestedParams() const;
 
    const CscCommandDataTypeMetadata *getObjectTypeMetadata() const;
 
    optional<CscCommandPtrType> getPtrType() const;
 
    const CscEnumInfos *getEnumMetadata() const;
 
    bool isTypeOrOptionalOfType(CommandParamMetaType commandParamMeta) const;
 
    static vector<const CscCommandDataTypeNodeMetadata *> parseFromFieldsList(const string &fieldsList);
 
    void appendDoc(const string &doc);
 
    CscCommandDataTypeNodeMetadata(const string &name, const string &doc, CommandParamMetaType type, vector<const CscCommandDataTypeNodeMetadata *> &nestedTypes, optional<CscCommandPtrType> ptrType, const CscCommandDataTypeMetadata *objectTypeMetadata, const CscEnumInfos *enumInfos);
 
    const CscCommandDataTypeNodeMetadata *resolveTypePath(const string &path) const;
    void collectReferencedObjectTypesMetadataRecursively(vector<const CscCommandDataTypeMetadata *> &targetList) const;
    void collectEnumsMetadataRecursively(vector<const CscEnumInfos *> &targetList) const;
};
 
struct CSC_DLL_IMPORTEXPORT CommandTypesMetadataByTypeNameMutexUniqueType {};
using CommandTypesMetadataByTypeNameMutex = shared_recursive_mutex_t<CommandTypesMetadataByTypeNameMutexUniqueType>;
inline CommandTypesMetadataByTypeNameMutex &commandTypesMetadataByTypeNameMutex() {
    return CommandTypesMetadataByTypeNameMutex::instance();
}
 
inline map<string, CscCommandDataTypeMetadata *> &commandTypesMetadataByTypeName() {
    static map<string, CscCommandDataTypeMetadata *> theMap;
    return theMap;
}
 
struct CSC_DLL_IMPORTEXPORT CommandsMetadataByIdMutexUniqueType {};
using CommandsMetadataByIdMutex = shared_recursive_mutex_t<CommandsMetadataByIdMutexUniqueType>;
inline CommandsMetadataByIdMutex &commandsMetadataByIdMutex() {
    return CommandsMetadataByIdMutex::instance();
}
 
inline map<string, const CscCommandDataTypeMetadata *> &commandsMetadataById() {
    static map<string, const CscCommandDataTypeMetadata *> theMap;
    return theMap;
}
 
CSC_DLL_IMPORTEXPORT bool hasCommandTypeMetadataForName(const string &qualifiedTypeName);
CSC_DLL_IMPORTEXPORT const CscCommandDataTypeMetadata *getCommandTypeMetadataByName(const string &qualifiedTypeName);
CSC_DLL_IMPORTEXPORT const CscCommandDataTypeMetadata *updateCommandTypeMetadataByName(const string &headerFileRelativePath, const string &classQualifiedName, const string &classSimpleName, const string &doc, const vector<const CscCommandDataTypeNodeMetadata *> &paramsMetadata, optional<string> commandId);
 
CSC_DLL_IMPORTEXPORT void registerCommandTypeMetadata(CscCommandDataTypeMetadata *typeMetadata);
 
CSC_DLL_IMPORTEXPORT void registerCommandMetadataTypeById(const CscCommandDataTypeMetadata *typeMetadata);
 
CSC_DLL_IMPORTEXPORT const CscCommandDataTypeNodeMetadata *parseMetadataTypeNode(const string &name, const string &typeString);
 
class CSC_DLL_IMPORTEXPORT CscCommandDataTypeMetadata {
private:
    string headerFileRelativePath;
    string paramsClassNameWithNamespace;
    string paramsClassName;
    int version;
    string commandId;
    string description;
    vector<const CscCommandDataTypeNodeMetadata *> params;
    function<any()> createNullInstanceFunction;
 
public:
    CscCommandDataTypeMetadata(const string &headerFileFullPath,
                               const type_info &paramsClass,
                               int version, const string &commandId,
                               const string &fieldsList,
                               const string &description);
    CscCommandDataTypeMetadata(const string &headerFileFullPath,
                               const string &paramsClassNameWithNamespace,
                               const string &paramsClassName,
                               int version, const string &commandId,
                               const vector<const CscCommandDataTypeNodeMetadata *> &params,
                               const string &description);
    ~CscCommandDataTypeMetadata();
 
    const string getClassName(bool withNamespace = true) const;
 
    const string &getCommandId() const;
 
    const string &getHeaderFileRelativePath() const;
 
    vector<const CscCommandDataTypeMetadata *> getAllObjectTypesMetadata() const;
 
    vector<const CscEnumInfos *> getAllEnumsMetadata() const;
 
    void collectReferencedObjectTypesMetadataRecursively(vector<const CscCommandDataTypeMetadata *> &targetList) const;
    void collectEnumsMetadataRecursively(vector<const CscEnumInfos *> &targetList) const;
 
    int getVersion() const;
    const string &getDescription() const;
    const vector<const CscCommandDataTypeNodeMetadata *> &getParams() const;
 
    vector<string> getParamNames() const;
 
    void update(const string &headerFileRelativePath, const string &classQualifiedName, const string &classSimpleName, const string &doc, const vector<const CscCommandDataTypeNodeMetadata *> &paramsMetadata, const string &commandId);
 
    const CscCommandDataTypeNodeMetadata *resolveTypePath(const string &path) const;
 
    static map<string, const CscCommandDataTypeMetadata *> getAllCommandsMetadata();
    static vector<string> getKnownCommandIds();
 
    static const CscCommandDataTypeMetadata *getCommandMetadata(const string &commandId);
};
 
struct CSC_DLL_IMPORTEXPORT CommandDataJsonSerializersMutexUniqueType {};
using CommandDataJsonSerializersMutex = shared_recursive_mutex_t<CommandDataJsonSerializersMutexUniqueType>;
inline CommandDataJsonSerializersMutex &commandDataJsonSerializersMutex() {
    return CommandDataJsonSerializersMutex::instance();
}
 
inline map<const type_info *, function<optional<JsonSerializableData>(const any &object)>> &getCommandDataJsonSerializers() {
    static map<const type_info *, function<optional<JsonSerializableData>(const any &object)>> serializers;
    return serializers;
}
 
inline bool registerCommandDataJsonSerializer(const type_info &typeInfo, function<optional<JsonSerializableData>(const any &object)> serializer) {
    map<const type_info *, function<optional<JsonSerializableData>(const any &object)>> &serializers = getCommandDataJsonSerializers();
    unique_lock lock(commandDataJsonSerializersMutex());
    bool existing = serializers.find(&typeInfo) != serializers.end();
    LOG_DEBUG("register deserializer for " + string(typeInfo.name()) + " -- existing=" + boolToString(existing));
    serializers[&typeInfo] = serializer;
 
    return true;
}
 
namespace {
function<optional<JsonSerializableData>(const any &object)> SERIALIZER_STRING = [](const any &object) -> optional<JsonSerializableData> {
    const string *stringPtr = anyToPointer<string>(object);
    if (stringPtr == nullptr) {
        return nullopt;
    }
    return *stringPtr;
};
}
 
template <typename TData>
inline function<optional<JsonSerializableData>(const any &object)> getCommandDataJsonSerializer() {
    map<const type_info *, function<optional<JsonSerializableData>(const any &object)>> &serializers = getCommandDataJsonSerializers();
    shared_lock lock(commandDataJsonSerializersMutex());
    const type_info &resultType = typeid(TData);
    auto jsonSerializerMatch = serializers.find(&resultType);
    if (jsonSerializerMatch == serializers.end()) {
        using TDataCleaned = std::remove_cvref_t<TData>;
        if constexpr (std::is_same_v<TDataCleaned, string>) {
            return SERIALIZER_STRING;
        }
        if constexpr (std::is_arithmetic_v<TDataCleaned> || std::is_enum_v<TDataCleaned>) {
            return [](const any &object) -> optional<JsonSerializableData> {
                const TDataCleaned *objectPtr = anyToPointer<TDataCleaned>(object);
                if (objectPtr == nullptr) {
                    return nullopt;
                }
                if constexpr (std::is_enum_v<TDataCleaned>) {
                    using Under = std::underlying_type_t<TDataCleaned>;
                    return JsonSerializableData(static_cast<Under>(*objectPtr));
                } else {
                    return JsonSerializableData(*objectPtr);
                }
            };
        }
        throw runtime_error("no serializer for type: " + conscience_utils::getClassName(resultType, true));
    }
    return jsonSerializerMatch->second;
}
 
class CSC_DLL_IMPORTEXPORT BaseCommandParams {
};
 
#define FIELDS_PAIR_PRINT(type, name) type name;
 
template <typename T>
T field_value_any_cast(any anyValue);
 
template <IsMap TMap>
TMap field_value_any_cast(any anyValue);
 
template <IsOptional TOptional>
TOptional field_value_any_cast(any anyValue);
 
template <IsVector TVector>
TVector field_value_any_cast(any anyValue);
 
template <typename T>
T field_value_any_cast(any anyValue) {
    try {
        return any_cast<T>(anyValue);
    } catch (const std::bad_any_cast &e) {
        LOG_WARN(string("cannot cast ") + getClassName(anyValue.type(), false) + " to " + getClassName(typeid(T), false) + ": " + e.what());
        throw;
    }
}
 
template <IsMap TMap>
TMap field_value_any_cast(any anyValue) {
    using K = typename TMap::key_type;
    using V = typename TMap::mapped_type;
    if (anyValue.type() == typeid(TMap)) {
        return any_cast<TMap>(anyValue);
    }
 
    try {
        map<K, any> mapAny = any_cast<map<K, any>>(anyValue);
        TMap result;
        for (auto it : mapAny) {
            result[it.first] = field_value_any_cast<V>(it.second);
        }
        return result;
 
    } catch (const std::bad_any_cast &e) {
        LOG_WARN(string("cannot cast ") + getClassName(anyValue.type(), false) + " to " + getClassName(typeid(map<K, any>), false) + ": " + e.what());
        throw;
    }
}
 
template <IsOptional TOptional>
TOptional field_value_any_cast(any anyValue) {
    using TElement = typename TOptional::value_type;
    if (anyValue.type() == typeid(TOptional)) {
        return any_cast<TOptional>(anyValue);
    }
    TOptional result;
    if (anyValue.type() == typeid(optional<any>)) {
        auto theOptional = any_cast<optional<any>>(anyValue);
        if (theOptional.has_value()) {
            result = field_value_any_cast<TElement>(theOptional.value());
        }
    } else if (anyValue.has_value()) {
        result = field_value_any_cast<TElement>(anyValue);
    }
 
    return result;
}
 
template <IsVector TVector>
TVector field_value_any_cast(any anyValue) {
    using TElement = typename TVector::value_type;
    if (anyValue.type() == typeid(TVector)) {
        return any_cast<TVector>(anyValue);
    }
    try {
        vector<any> vectorAny = any_cast<vector<any>>(anyValue);
        TVector result;
        for (auto it : vectorAny) {
            result.push_back(field_value_any_cast<TElement>(it));
        }
        return result;
    } catch (const std::bad_any_cast &e) {
        LOG_WARN(string("cannot cast ") + getClassName(anyValue.type(), false) + " to " + getClassName(typeid(vector<any>), false) + ": " + e.what());
        throw;
    }
}
 
#define FIELDS_ASSIGN_FROM_MAP_PRINT(FIELD_type, FIELD_name)                                     \
    try {                                                                                        \
        if (fieldsValues.find(#FIELD_name) != fieldsValues.end()) {                              \
            any actualValue = fieldsValues.at(#FIELD_name);                                      \
            if (string(#FIELD_type) == "string" && typeid(const char *) == actualValue.type()) { \
                actualValue = string(any_cast<const char *>(actualValue));                       \
            }                                                                                    \
            LOGGER_TRACE("set " + string(#FIELD_name));                                          \
            actualValue = field_value_any_cast<FIELD_type>(actualValue);                         \
            targetObject->FIELD_name = any_cast<FIELD_type>(actualValue);                        \
        } else {                                                                                 \
            LOGGER_WARN(string("cannot find ") + #FIELD_name)                                    \
        }                                                                                        \
    } catch (const std::bad_any_cast &e) {                                                       \
        LOGGER_INFO(string("cannot set ") + #FIELD_type + " " + #FIELD_name + ": " + e.what());  \
        throw e;                                                                                 \
    }
 
template <typename T>
concept HasBuiltinCommandJsonSerialization = IsVector<T> || IsStarPointer<std::remove_cvref_t<T>> || IsMap<T> || IsSharedPointer<std::remove_cvref_t<T>>;
 
template <typename T>
    requires(IsSharedPointer<std::remove_cvref_t<T>>)
JsonSerializableData field_value_to_json_serializable(T value);
 
template <typename T>
    requires(IsStarPointer<std::remove_cvref_t<T>>)
JsonSerializableData field_value_to_json_serializable(T value);
 
template <typename T>
JsonSerializableData field_value_to_json_serializable(optional<T> value);
 
template <IsVector TVector>
JsonSerializableData field_value_to_json_serializable(TVector value);
 
template <IsMap TMap>
JsonSerializableData field_value_to_json_serializable(TMap value);
 
template <typename T>
requires (std::is_convertible_v<T, JsonSerializableData> && !HasBuiltinCommandJsonSerialization<T>)
JsonSerializableData field_value_to_json_serializable(T value);
 
template <typename T>
requires (!std::is_convertible_v<T, JsonSerializableData> && !HasBuiltinCommandJsonSerialization<T>)
JsonSerializableData field_value_to_json_serializable(T value);
 
template <typename T>
    requires(IsStarPointer<std::remove_cvref_t<T>>)
JsonSerializableData field_value_to_json_serializable(T value) {
    using TPointee = std::remove_cvref_t<typename PointeeType<std::remove_cvref_t<T>>::pointee_type>;
 
    if (value == nullptr) {
        return nullptr;
    }
    if constexpr (std::is_base_of_v<CscCommandDataTypeBase, TPointee>) {
        if (auto jsonObject = dynamic_cast<CscCommandDataTypeBase *>(value)) {
            return jsonObject->toJsonMap();
        }
        throw runtime_error("cannot retrieve data type as CscCommandDataTypeBase: " + getClassName(typeid(TPointee), true));
    } else {
        function<optional<JsonSerializableData>(const any &object)> serializer = getCommandDataJsonSerializer<TPointee>();
        optional<JsonSerializableData> jsonMap = serializer(value);
        if (jsonMap.has_value()) {
            return jsonMap.value();
        }
        return nullptr;
    }
 
    throw runtime_error("unsupported object type for serialization: " + getClassName(typeid(TPointee), true));
}
 
template <typename T>
    requires(IsSharedPointer<std::remove_cvref_t<T>>)
JsonSerializableData field_value_to_json_serializable(T value) {
    if (value == nullptr) {
        return nullptr;
    }
    return field_value_to_json_serializable(value.get());
}
 
template <typename T>
JsonSerializableData field_value_to_json_serializable(optional<T> value) {
    if (!value.has_value()) {
        return nullptr;
    }
    return field_value_to_json_serializable(value.value());
}
 
template <IsMap TMap>
JsonSerializableData field_value_to_json_serializable(TMap value) {
    using K = typename TMap::key_type;
    map<K, JsonSerializableData> jsonMap;
    for (auto it : value) {
        jsonMap[it.first] = field_value_to_json_serializable(it.second);
    }
    return jsonMap;
}
 
template <IsVector TVector>
JsonSerializableData field_value_to_json_serializable(TVector value) {
    vector<JsonSerializableData> jsonList;
    for (auto it : value) {
        jsonList.push_back(field_value_to_json_serializable(it));
    }
    return jsonList;
}
 
 
 
template <typename T>
requires (std::is_convertible_v<T, JsonSerializableData> && !HasBuiltinCommandJsonSerialization<T>)
JsonSerializableData field_value_to_json_serializable(T value) {
    return value;
}
 
template <typename T>
requires (!std::is_convertible_v<T, JsonSerializableData> && !HasBuiltinCommandJsonSerialization<T>)
JsonSerializableData field_value_to_json_serializable(T value) {
    function<optional<JsonSerializableData>(const any &object)> serializer = getCommandDataJsonSerializer<T>();
    optional<JsonSerializableData> jsonMap = serializer(&value);
    if (jsonMap.has_value()) {
        return jsonMap.value();
    }
    return nullptr;
}
 
#define FIELDS_ASSIGN_INTO_JSONMAP_PRINT(FIELD_type, FIELD_name)                                           \
    try {                                                                                                  \
        JsonSerializableData jsonSerializableValue = field_value_to_json_serializable(object->FIELD_name); \
        jsonMap[#FIELD_name] = jsonSerializableValue;                                                      \
    } catch (const exception &e) {                                                                         \
        LOGGER_INFO(string("cannot set ") + #FIELD_type + " " + #FIELD_name + " into map: " + e.what());   \
        throw e;                                                                                           \
    }
 
#define FIELDS_ASSIGN_INTO_JSONMAP_PRINT_NOTYPE(FIELD_name) \
    FIELDS_ASSIGN_INTO_JSONMAP_PRINT(UnspecifiedType, FIELD_name)
 
template <typename T>
concept IsCommandParams = std::is_base_of<BaseCommandParams, T>::value;
 
CSC_DLL_IMPORTEXPORT map<string, any> parseCommandParametersAsMap(const string &commandId, const vector<string> &commandStringArguments, optional<int> knowledgeId, bool objectsAsMap, bool resolveObjects = true, bool permissive = false);
 
CSC_DLL_IMPORTEXPORT void listCommandsWithDocumentedParams();
 
inline bool isUserCommand(const string &commandId) {
    return fs::is_directory(CscKeyDirectories::getInstance()->getUserCustomCommandCodeDir(commandId));
}
 
CSC_DLL_IMPORTEXPORT fs::path resolveCommandFileAbsolutePathFromRelative(const fs::path &headerFileRelativePath, const string &forCommandId);
 
}
 
#endif