Conscience Core
Classes | Namespaces | Macros | Typedefs | Functions | Variables
CscCommandAutoParse.h File Reference
#include <memory>
#include "CscCommon.h"
#include "../FunctionCommandWrapper.h"
#include "CommandParseContext.h"

Go to the source code of this file.

Classes

class  conscience_core::bridging::commands::CscCommandAutoParseMetadata
 

Namespaces

 conscience_core
 
 conscience_core::bridging
 
 conscience_core::bridging::commands
 

Macros

#define COMMAND_FUNCTION(COMMAND_FUNCTION_paramsClassPrefix, COMMAND_FUNCTION_commandId)
 
#define TRY_ANY_CAST(targetType, varName, outVarName, parentName)
 
#define COMMAND_REGISTER(COMMAND_REGISTER_className, ...)
 
#define USER_COMMAND_REGISTER(COMMAND_REGISTER_className, ...)
 
#define COMMAND_TYPE_BUILDER(PREFIX, COMMAND_REGISTER_className, ...)
 

Typedefs

typedef function< void *(const map< string, any > &paramsValues, const vector< string > &paramNames)> conscience_core::bridging::commands::CommandTypeBuilder
 

Functions

map< const std::type_info *, CommandTypeBuilder > & conscience_core::bridging::commands::commandTypeBuilders ()
 
void conscience_core::bridging::commands::registerCommandTypeBuilder (const std::type_info &type, const CommandTypeBuilder &builder)
 
optional< CommandTypeBuilder > conscience_core::bridging::commands::getCommandTypeBuilder (const std::type_info &type)
 
template<IsMap TMap>
TMap conscience_core::bridging::commands::convertMapValueToArg (const std::any &anyValue, const string &argName, size_t argIndex)
 
template<IsOptional TOptional>
requires(IsStarPointer< std::remove_cvref_t< T >>) T convertMapValueToArg(const std requires(IsSharedPointer< std::remove_cvref_t< T >>) T convertMapValueToArg(const std TOptional conscience_core::bridging::commands::convertMapValueToArg (const std::any &anyValue, const string &argName, size_t argIndex)
 
template<IsVector TVector>
TVector conscience_core::bridging::commands::convertMapValueToArg (const std::any &anyValue, const string &argName, size_t argIndex)
 
template<IsEnum TEnum>
requires(IsStdFixedArray< TArray >) TArray convertMapValueToArg(const std TEnum conscience_core::bridging::commands::convertMapValueToArg (const std::any &anyValue, const string &argName, size_t argIndex)
 
template<IsOptional TOptional>
TOptional conscience_core::bridging::commands::convertMapValueToArg (const std::any &anyValue, const string &argName, size_t argIndex)
 
template<typename TNumber >
TNumber conscience_core::bridging::commands::getNumberFromString (const string &strValue)
 
template<typename TArray >
 conscience_core::bridging::commands::requires (IsStdFixedArray< TArray >) TArray convertMapValueToArg(const std
 
template<typename Tuple , typename Map , std::size_t... Is>
Tuple conscience_core::bridging::commands::extractArgsHelper (const Map &paramMap, const std::vector< std::string > &paramNames, std::index_sequence< Is... >)
 
template<typename Tuple >
Tuple conscience_core::bridging::commands::extractArgs (const std::map< std::string, std::any > &paramMap, const std::vector< std::string > &paramNames)
 
template<typename T , typename... Params>
T * conscience_core::bridging::commands::createInstance (const std::map< std::string, std::any > &paramMap, const std::vector< std::string > &paramNames)
 
ptr< CscEntityReflexion > conscience_core::bridging::commands::getEntityReflexionFromAny (std::any anyValue, const string &argName)
 
template<typename T >
bool conscience_core::bridging::commands::doesAnyContainStarPointer (const std::any &anyValue)
 
template<typename T >
bool conscience_core::bridging::commands::doesAnyContainSharedPtr (const std::any &anyValue)
 
template<typename TObject >
constexpr bool conscience_core::bridging::commands::isCommandBuiltinObjectType ()
 
template<typename T >
 conscience_core::bridging::commands::requires (IsStarPointer< std::remove_cvref_t< T >>) JsonSerializableData field_value_to_json_serializable(T value)
 
template<typename T >
 conscience_core::bridging::commands::requires (IsSharedPointer< std::remove_cvref_t< T >>) JsonSerializableData field_value_to_json_serializable(T value)
 
template<typename TTargetType >
 conscience_core::bridging::commands::requires (!IsStdFixedArray< TTargetType > &&!IsOptional< TTargetType > &&!IsEnum< TTargetType > &&!IsVector< TTargetType > &&!IsMap< TTargetType > &&!IsSharedPointer< TTargetType > &&!IsStarPointer< TTargetType >) TTargetType convertMapValueToArg(const std
 

Variables

template<IsEnum TEnum>
requires(!IsStdFixedArray< TTargetType > &&!IsOptional< TTargetType > &&!IsEnum< TTargetType > &&!IsVector< TTargetType > &&!IsMap< TTargetType > &&!IsSharedPointer< TTargetType > &&!IsStarPointer< TTargetType >) TTargetType convertMapValueToArg(const std TEnum conscience_core::bridging::commands::convertMapValueToArg (const std::any &anyValue, const string &argName, size_t argIndex)
 

Macro Definition Documentation

◆ COMMAND_FUNCTION

#define COMMAND_FUNCTION (   COMMAND_FUNCTION_paramsClassPrefix,
  COMMAND_FUNCTION_commandId 
)
Value:
\
COMMAND_FUNCTION_paramsClassPrefix##CommandResult cscCommand_##COMMAND_FUNCTION_paramsClassPrefix(ptr<COMMAND_FUNCTION_paramsClassPrefix##CommandParams> params, CscEnvironmentSimulator &environmentSimulator); \ \
static FunctionCommand get##COMMAND_FUNCTION_paramsClassPrefix##Command(ptr<COMMAND_FUNCTION_paramsClassPrefix##CommandParams> params) { \
\
return [params](CscEnvironmentSimulator &environmentSimulator) { \
auto result = cscCommand_##COMMAND_FUNCTION_paramsClassPrefix(params, environmentSimulator); \
return result.toRawResult(); \
}; \
} \
class CSC_DLL_IMPORTEXPORT __##COMMAND_FUNCTION_paramsClassPrefix##AutoParseMetadataInit { \
inline static const CscCommandAutoParseMetadata *__metadata = CscCommandAutoParseMetadata::registerCommand(COMMAND_FUNCTION_commandId, #COMMAND_FUNCTION_paramsClassPrefix, [](CscCommandParseContext &params) { \
string commandId = COMMAND_FUNCTION_commandId; \
ptr<COMMAND_FUNCTION_paramsClassPrefix##CommandParams> paramsObject = parseCommandParameters<COMMAND_FUNCTION_paramsClassPrefix##CommandParams>(commandId, params.arguments, params.knowledgeId); \
FunctionCommand functionCommand = get##COMMAND_FUNCTION_paramsClassPrefix##Command(paramsObject); \
ptr<CscEntityReflexion> entityReflexion = params.getEntityReflexionFromParameter(); \
return newptr<FunctionCommandWrapper>(entityReflexion, commandId, functionCommand, params.originalCommandString, params.arguments); \
}); \
};

Declares a function for a Conscience Command. It will be automatically parsable by CommandParser

◆ COMMAND_REGISTER

#define COMMAND_REGISTER (   COMMAND_REGISTER_className,
  ... 
)
Value:
class CSC_DLL_IMPORTEXPORT __##COMMAND_REGISTER_className##AutoParseMetadataInit { \
inline static void *registerCommand() { \
string commandId = COMMAND_REGISTER_className::COMMAND_ID; \
auto builder = [commandId](const map<string, any> &commandParams, const vector<string> &paramNames) { \
return createInstance<COMMAND_REGISTER_className __VA_OPT__(, ) __VA_ARGS__>(commandParams, paramNames); \
}; \
registerCommandTypeBuilder(typeid(COMMAND_REGISTER_className), builder); \
CscCommandAutoParseMetadata::registerCommand(commandId, #COMMAND_REGISTER_className, [commandId, builder](CscCommandParseContext &params) { \
map<string, any> commandParams = parseCommandParametersAsMap(commandId, params.arguments, params.knowledgeId, /* sub objects are maps */ true); \
const CscCommandDataTypeMetadata *commandParamsInfo = CscCommandDataTypeMetadata::getCommandMetadata(commandId); \
return ptr<COMMAND_REGISTER_className>(builder(commandParams, commandParamsInfo->getParamNames())); \
}); \
/* we used to return instance but we should not keep any reference to command to allow shared lib hot reload (and not point of keeping __metadata instance) */ \
return nullptr; \
} \
inline static void *__metadata = registerCommand(); \
};

◆ COMMAND_TYPE_BUILDER

#define COMMAND_TYPE_BUILDER (   PREFIX,
  COMMAND_REGISTER_className,
  ... 
)
Value:
namespace { \
static bool __##PREFIX##__##COMMAND_REGISTER_className##initialized = ([]() { \
auto builder = [](const map<string, any> &commandParams, const vector<string> &paramNames) { \
return createInstance<COMMAND_REGISTER_className, __VA_ARGS__>(commandParams, paramNames); \
}; \
registerCommandTypeBuilder(typeid(COMMAND_REGISTER_className), builder); \
return true; \
})(); \
}

◆ TRY_ANY_CAST

#define TRY_ANY_CAST (   targetType,
  varName,
  outVarName,
  parentName 
)
Value:
try { \
outVarName = std::any_cast<targetType>(varName); \
} catch (std::exception & e) { \
LOG_ERROR(string("cannot cast to ") + getClassName(typeid(targetType), false) + " name=" + parentName + " - " + string(e.what())); \
throw runtime_error(string("cannot cast to ") + getClassName(typeid(targetType), false) + " name=" + parentName); \
}

◆ USER_COMMAND_REGISTER

#define USER_COMMAND_REGISTER (   COMMAND_REGISTER_className,
  ... 
)
Value:
class CSC_USER_DLL_EXPORT __##COMMAND_REGISTER_className##AutoParseMetadataInit { \
inline static void *registerCommand() { \
string commandId = COMMAND_REGISTER_className::COMMAND_ID; \
auto builder = [commandId](const map<string, any> &commandParams, const vector<string> &paramNames) { \
return createInstance<COMMAND_REGISTER_className __VA_OPT__(, ) __VA_ARGS__>(commandParams, paramNames); \
}; \
registerCommandTypeBuilder(typeid(COMMAND_REGISTER_className), builder); \
CscCommandAutoParseMetadata::registerCommand(commandId, #COMMAND_REGISTER_className, [commandId, builder](CscCommandParseContext &params) { \
map<string, any> commandParams = parseCommandParametersAsMap(commandId, params.arguments, params.knowledgeId, /* sub objects are maps */ true); \
const CscCommandDataTypeMetadata *commandParamsInfo = CscCommandDataTypeMetadata::getCommandMetadata(commandId); \
return ptr<COMMAND_REGISTER_className>(builder(commandParams, commandParamsInfo->getParamNames())); \
}); \
/* we used to return instance but we should not keep any reference to command to allow shared lib hot reload (and not point of keeping __metadata instance) */ \
return nullptr; \
} \
inline static void *__metadata = registerCommand(); \
};
CSC_DLL_IMPORTEXPORT
#define CSC_DLL_IMPORTEXPORT
Definition: os.h:31
conscience_core::bridging::commands::parseCommandParametersAsMap
map< string, any > parseCommandParametersAsMap(const string &commandId, const vector< string > &commandStringArguments, optional< int > knowledgeId, bool objectsAsMap, bool resolveObjects, bool permissive)
Definition: CommandParamsSpec.cpp:821
conscience_utils::getClassName
string getClassName(const type_info &paramsClass, bool withNamespace)
Definition: conscience_util.cpp:593
CSC_USER_DLL_EXPORT
#define CSC_USER_DLL_EXPORT
Definition: os.h:17
CscEnvironmentSimulator
Definition: CscEnvironmentSimulator.h:35
conscience_core::bridging::commands::FunctionCommand
function< const CscCommandExecutionResult *(CscEnvironmentSimulator &environmentSimulator)> FunctionCommand
Definition: Command.h:38
ptr
std::shared_ptr< T > ptr
Definition: CscCommon.h:29
Generated by doxygen 1.8.17