Elektra conversion. More...

#include "kdb.h"
#include "types.h"

Include dependency graph for conversion.h:

This graph shows which files directly or indirectly include this file:

Functions
int	elektraKeyToString (const Key key, const char *variable)
	Converts a Key to string.
int	elektraKeyToBoolean (const Key key, kdb_boolean_t variable)
	Converts a Key to boolean.
int	elektraKeyToChar (const Key key, kdb_char_t variable)
	Converts a Key to char.
int	elektraKeyToOctet (const Key key, kdb_octet_t variable)
	Converts a Key to octet.
int	elektraKeyToShort (const Key key, kdb_short_t variable)
	Converts a Key to short.
int	elektraKeyToUnsignedShort (const Key key, kdb_unsigned_short_t variable)
	Converts a Key to unsigned_short.
int	elektraKeyToLong (const Key key, kdb_long_t variable)
	Converts a Key to long.
int	elektraKeyToUnsignedLong (const Key key, kdb_unsigned_long_t variable)
	Converts a Key to unsigned_long.
int	elektraKeyToLongLong (const Key key, kdb_long_long_t variable)
	Converts a Key to long_long.
int	elektraKeyToUnsignedLongLong (const Key key, kdb_unsigned_long_long_t variable)
	Converts a Key to unsigned_long_long.
int	elektraKeyToFloat (const Key key, kdb_float_t variable)
	Converts a Key to float.
int	elektraKeyToDouble (const Key key, kdb_double_t variable)
	Converts a Key to double.
char *	elektraBooleanToString (kdb_boolean_t value)
	Converts a boolean to string.
char *	elektraCharToString (kdb_char_t value)
	Converts a char to string.
char *	elektraOctetToString (kdb_octet_t value)
	Converts an octet to string.
char *	elektraShortToString (kdb_short_t value)
	Converts a short to string.
char *	elektraUnsignedShortToString (kdb_unsigned_short_t value)
	Converts an unsigned short to string.
char *	elektraLongToString (kdb_long_t value)
	Converts a long to string.
char *	elektraUnsignedLongToString (kdb_unsigned_long_t value)
	Converts an unsigned long to string.
char *	elektraLongLongToString (kdb_long_long_t value)
	Converts a long long to string.
char *	elektraUnsignedLongLongToString (kdb_unsigned_long_long_t value)
	Converts an unsigned long long to string.
char *	elektraFloatToString (kdb_float_t value)
	Converts a float to string.
char *	elektraDoubleToString (kdb_double_t value)
	Converts a double to string.

Detailed Description

Elektra conversion.

Copyright: BSD License (see doc/LICENSE.md or http://www.libelektra.org)

Function Documentation

◆ elektraBooleanToString()

char * elektraBooleanToString ( kdb_boolean_t value )

Converts a boolean to string.

The string is allocated with elektraMalloc() and must be disposed of with elektraFree().

Parameters

value the boolean to convert

Returns: a new string allocated with elektraMalloc, or 0 on error

◆ elektraCharToString()

char * elektraCharToString ( kdb_char_t value )

Converts a char to string.

The string is allocated with elektraMalloc() and must be disposed of with elektraFree().

Parameters

value the value to convert

Returns: a new string allocated with elektraMalloc, or 0 on error

◆ elektraDoubleToString()

char * elektraDoubleToString ( kdb_double_t value )

Converts a double to string.

The string is allocated with elektraMalloc() and must be disposed of with elektraFree().

Parameters

value the value to convert

Returns: a new string allocated with elektraMalloc, or 0 on error

◆ elektraFloatToString()

char * elektraFloatToString ( kdb_float_t value )

Converts a float to string.

The string is allocated with elektraMalloc() and must be disposed of with elektraFree().

Parameters

value the value to convert

Returns: a new string allocated with elektraMalloc, or 0 on error

◆ elektraKeyToBoolean()

int elektraKeyToBoolean	(	const Key *	key,
		kdb_boolean_t *	variable )

Converts a Key to boolean.

The value "1" is regarded as true, anything is as false.

The variable pointed to by variable is unchanged, if an error occurs.

Parameters

Key	the key to convert
variable	pointer to the output variable

Return values

1	on success
0	otherwise

Copyright: BSD License (see doc/COPYING or http://www.libelektra.org)

Create key to type conversion function.

This supermacro creates the following functions:

int NAME_MACRO (TYPE_NAME) (Key * key, TYPE * variable)

Parameters

TYPE	valid C type (e.g. int or kdb_short_t)
TYPE_NAME	name suffix for the functions (e.g. Int or UnsignedLong)
VALUE_TYPE	optional, defaults to TYPE. Ideally a larger type assigned to variable value for checking the range before the variable is updated
TO_VALUE	expression for converting string (variable containing the key value) to VALUE_TYPE
CHECK_CONVERSION	optional, defaults to true. A boolean expression. Allows to check the range after conversion. Use ELEKTRA_TYPE_CHECK_CONVERSION to check if a conversion using strto*()-functions was successful and ELEKTRA_TYPE_CHECK_CONVERSION_RANGE (RANGE) to check additionally for a specified range.
CHECK_FAIL_BLOCK	optional, defaults to logging a warning in the key. The code to be executed (before returning 0), if CHECK_CONVERSION evaluates to false.
PRE_CHECK_CONVERSION_BLOCK	optional, defaults to empty. Allows to add additional code for pre-conversion checks (e.g. ELEKTRA_TYPE_NEGATIVE_PRE_CHECK_BLOCK)
PRE_CHECK_CONVERSION	optional, defaults to true. A boolean expression to check the contents of string before conversion (e.g. ELEKTRA_TYPE_NEGATIVE_PRE_CHECK).
PRE_CHECK_FAIL_BLOCK	optional, defaults to logging a warning in the key. The code to be executed (before returning 0), if PRE_CHECK_CONVERSION evaluates to false.
DISABLE_UNDEF_PARAMETERS	define to disable undefining of parameters after the macro. Use if parameters are used within another supermacro.
CODE_ONLY	optional, defaults to 0. Set to 1 to only generate the function body. This is useful, if you want to create a function with a custom signature for example.
KEY_PARAM_NAME	must be set, #if CODE_ONLY, will be set to 'key' otherwise. The name of the variable/parameter containing the Key, whose value will be converted
VARIABLE_PARAM_NAME	must be set, #if CODE_ONLY, will be set to 'variable' otherwise. The name of the variable/parameter containing the pointer to where the result should be written

Convert string to TYPE.

The variable is only changed if no conversion error occurred

Example: int variable = 1234; if (!NAME_MACRO (TYPE_NAME) (key, &variable)) { // conversion failed // variable == 1234 } // variable was changed

Parameters

Key	key
variable	pointer to variable

Return values

1	on success
0	on conversion error

◆ elektraKeyToChar()

int elektraKeyToChar	(	const Key *	key,
		kdb_char_t *	variable )

Converts a Key to char.

The variable pointed to by variable is unchanged, if an error occurs.

Parameters

Key	the key to convert
variable	pointer to the output variable

Return values

1	on success
0	otherwise

Copyright: BSD License (see doc/COPYING or http://www.libelektra.org)

Create key to type conversion function.

This supermacro creates the following functions:

int NAME_MACRO (TYPE_NAME) (Key * key, TYPE * variable)

Parameters

TYPE	valid C type (e.g. int or kdb_short_t)
TYPE_NAME	name suffix for the functions (e.g. Int or UnsignedLong)
VALUE_TYPE	optional, defaults to TYPE. Ideally a larger type assigned to variable value for checking the range before the variable is updated
TO_VALUE	expression for converting string (variable containing the key value) to VALUE_TYPE
CHECK_CONVERSION	optional, defaults to true. A boolean expression. Allows to check the range after conversion. Use ELEKTRA_TYPE_CHECK_CONVERSION to check if a conversion using strto*()-functions was successful and ELEKTRA_TYPE_CHECK_CONVERSION_RANGE (RANGE) to check additionally for a specified range.
CHECK_FAIL_BLOCK	optional, defaults to logging a warning in the key. The code to be executed (before returning 0), if CHECK_CONVERSION evaluates to false.
PRE_CHECK_CONVERSION_BLOCK	optional, defaults to empty. Allows to add additional code for pre-conversion checks (e.g. ELEKTRA_TYPE_NEGATIVE_PRE_CHECK_BLOCK)
PRE_CHECK_CONVERSION	optional, defaults to true. A boolean expression to check the contents of string before conversion (e.g. ELEKTRA_TYPE_NEGATIVE_PRE_CHECK).
PRE_CHECK_FAIL_BLOCK	optional, defaults to logging a warning in the key. The code to be executed (before returning 0), if PRE_CHECK_CONVERSION evaluates to false.
DISABLE_UNDEF_PARAMETERS	define to disable undefining of parameters after the macro. Use if parameters are used within another supermacro.
CODE_ONLY	optional, defaults to 0. Set to 1 to only generate the function body. This is useful, if you want to create a function with a custom signature for example.
KEY_PARAM_NAME	must be set, #if CODE_ONLY, will be set to 'key' otherwise. The name of the variable/parameter containing the Key, whose value will be converted
VARIABLE_PARAM_NAME	must be set, #if CODE_ONLY, will be set to 'variable' otherwise. The name of the variable/parameter containing the pointer to where the result should be written

Convert string to TYPE.

The variable is only changed if no conversion error occurred

Example: int variable = 1234; if (!NAME_MACRO (TYPE_NAME) (key, &variable)) { // conversion failed // variable == 1234 } // variable was changed

Parameters

Key	key
variable	pointer to variable

Return values

1	on success
0	on conversion error

◆ elektraKeyToDouble()

int elektraKeyToDouble	(	const Key *	key,
		kdb_double_t *	variable )

Converts a Key to double.

The variable pointed to by variable is unchanged, if an error occurs.

Parameters

Key	the key to convert
variable	pointer to the output variable

Return values

1	on success
0	otherwise

Copyright: BSD License (see doc/COPYING or http://www.libelektra.org)

Create key to type conversion function.

This supermacro creates the following functions:

int NAME_MACRO (TYPE_NAME) (Key * key, TYPE * variable)

Parameters

TYPE	valid C type (e.g. int or kdb_short_t)
TYPE_NAME	name suffix for the functions (e.g. Int or UnsignedLong)
VALUE_TYPE	optional, defaults to TYPE. Ideally a larger type assigned to variable value for checking the range before the variable is updated
TO_VALUE	expression for converting string (variable containing the key value) to VALUE_TYPE
CHECK_CONVERSION	optional, defaults to true. A boolean expression. Allows to check the range after conversion. Use ELEKTRA_TYPE_CHECK_CONVERSION to check if a conversion using strto*()-functions was successful and ELEKTRA_TYPE_CHECK_CONVERSION_RANGE (RANGE) to check additionally for a specified range.
CHECK_FAIL_BLOCK	optional, defaults to logging a warning in the key. The code to be executed (before returning 0), if CHECK_CONVERSION evaluates to false.
PRE_CHECK_CONVERSION_BLOCK	optional, defaults to empty. Allows to add additional code for pre-conversion checks (e.g. ELEKTRA_TYPE_NEGATIVE_PRE_CHECK_BLOCK)
PRE_CHECK_CONVERSION	optional, defaults to true. A boolean expression to check the contents of string before conversion (e.g. ELEKTRA_TYPE_NEGATIVE_PRE_CHECK).
PRE_CHECK_FAIL_BLOCK	optional, defaults to logging a warning in the key. The code to be executed (before returning 0), if PRE_CHECK_CONVERSION evaluates to false.
DISABLE_UNDEF_PARAMETERS	define to disable undefining of parameters after the macro. Use if parameters are used within another supermacro.
CODE_ONLY	optional, defaults to 0. Set to 1 to only generate the function body. This is useful, if you want to create a function with a custom signature for example.
KEY_PARAM_NAME	must be set, #if CODE_ONLY, will be set to 'key' otherwise. The name of the variable/parameter containing the Key, whose value will be converted
VARIABLE_PARAM_NAME	must be set, #if CODE_ONLY, will be set to 'variable' otherwise. The name of the variable/parameter containing the pointer to where the result should be written

Convert string to TYPE.

The variable is only changed if no conversion error occurred

Example: int variable = 1234; if (!NAME_MACRO (TYPE_NAME) (key, &variable)) { // conversion failed // variable == 1234 } // variable was changed

Parameters

Key	key
variable	pointer to variable

Return values

1	on success
0	on conversion error

◆ elektraKeyToFloat()

int elektraKeyToFloat	(	const Key *	key,
		kdb_float_t *	variable )

Converts a Key to float.

The variable pointed to by variable is unchanged, if an error occurs.

Parameters

Key	the key to convert
variable	pointer to the output variable

Return values

1	on success
0	otherwise

Copyright: BSD License (see doc/COPYING or http://www.libelektra.org)

Create key to type conversion function.

This supermacro creates the following functions:

int NAME_MACRO (TYPE_NAME) (Key * key, TYPE * variable)

Parameters

TYPE	valid C type (e.g. int or kdb_short_t)
TYPE_NAME	name suffix for the functions (e.g. Int or UnsignedLong)
VALUE_TYPE	optional, defaults to TYPE. Ideally a larger type assigned to variable value for checking the range before the variable is updated
TO_VALUE	expression for converting string (variable containing the key value) to VALUE_TYPE
CHECK_CONVERSION	optional, defaults to true. A boolean expression. Allows to check the range after conversion. Use ELEKTRA_TYPE_CHECK_CONVERSION to check if a conversion using strto*()-functions was successful and ELEKTRA_TYPE_CHECK_CONVERSION_RANGE (RANGE) to check additionally for a specified range.
CHECK_FAIL_BLOCK	optional, defaults to logging a warning in the key. The code to be executed (before returning 0), if CHECK_CONVERSION evaluates to false.
PRE_CHECK_CONVERSION_BLOCK	optional, defaults to empty. Allows to add additional code for pre-conversion checks (e.g. ELEKTRA_TYPE_NEGATIVE_PRE_CHECK_BLOCK)
PRE_CHECK_CONVERSION	optional, defaults to true. A boolean expression to check the contents of string before conversion (e.g. ELEKTRA_TYPE_NEGATIVE_PRE_CHECK).
PRE_CHECK_FAIL_BLOCK	optional, defaults to logging a warning in the key. The code to be executed (before returning 0), if PRE_CHECK_CONVERSION evaluates to false.
DISABLE_UNDEF_PARAMETERS	define to disable undefining of parameters after the macro. Use if parameters are used within another supermacro.
CODE_ONLY	optional, defaults to 0. Set to 1 to only generate the function body. This is useful, if you want to create a function with a custom signature for example.
KEY_PARAM_NAME	must be set, #if CODE_ONLY, will be set to 'key' otherwise. The name of the variable/parameter containing the Key, whose value will be converted
VARIABLE_PARAM_NAME	must be set, #if CODE_ONLY, will be set to 'variable' otherwise. The name of the variable/parameter containing the pointer to where the result should be written

Convert string to TYPE.

The variable is only changed if no conversion error occurred

Example: int variable = 1234; if (!NAME_MACRO (TYPE_NAME) (key, &variable)) { // conversion failed // variable == 1234 } // variable was changed

Parameters

Key	key
variable	pointer to variable

Return values

1	on success
0	on conversion error

◆ elektraKeyToLong()

int elektraKeyToLong	(	const Key *	key,
		kdb_long_t *	variable )

Converts a Key to long.

The variable pointed to by variable is unchanged, if an error occurs.

Parameters

Key	the key to convert
variable	pointer to the output variable

Return values

1	on success
0	otherwise

Copyright: BSD License (see doc/COPYING or http://www.libelektra.org)

Create key to type conversion function.

This supermacro creates the following functions:

int NAME_MACRO (TYPE_NAME) (Key * key, TYPE * variable)

Parameters

TYPE	valid C type (e.g. int or kdb_short_t)
TYPE_NAME	name suffix for the functions (e.g. Int or UnsignedLong)
VALUE_TYPE	optional, defaults to TYPE. Ideally a larger type assigned to variable value for checking the range before the variable is updated
TO_VALUE	expression for converting string (variable containing the key value) to VALUE_TYPE
CHECK_CONVERSION	optional, defaults to true. A boolean expression. Allows to check the range after conversion. Use ELEKTRA_TYPE_CHECK_CONVERSION to check if a conversion using strto*()-functions was successful and ELEKTRA_TYPE_CHECK_CONVERSION_RANGE (RANGE) to check additionally for a specified range.
CHECK_FAIL_BLOCK	optional, defaults to logging a warning in the key. The code to be executed (before returning 0), if CHECK_CONVERSION evaluates to false.
PRE_CHECK_CONVERSION_BLOCK	optional, defaults to empty. Allows to add additional code for pre-conversion checks (e.g. ELEKTRA_TYPE_NEGATIVE_PRE_CHECK_BLOCK)
PRE_CHECK_CONVERSION	optional, defaults to true. A boolean expression to check the contents of string before conversion (e.g. ELEKTRA_TYPE_NEGATIVE_PRE_CHECK).
PRE_CHECK_FAIL_BLOCK	optional, defaults to logging a warning in the key. The code to be executed (before returning 0), if PRE_CHECK_CONVERSION evaluates to false.
DISABLE_UNDEF_PARAMETERS	define to disable undefining of parameters after the macro. Use if parameters are used within another supermacro.
CODE_ONLY	optional, defaults to 0. Set to 1 to only generate the function body. This is useful, if you want to create a function with a custom signature for example.
KEY_PARAM_NAME	must be set, #if CODE_ONLY, will be set to 'key' otherwise. The name of the variable/parameter containing the Key, whose value will be converted
VARIABLE_PARAM_NAME	must be set, #if CODE_ONLY, will be set to 'variable' otherwise. The name of the variable/parameter containing the pointer to where the result should be written

Convert string to TYPE.

The variable is only changed if no conversion error occurred

Example: int variable = 1234; if (!NAME_MACRO (TYPE_NAME) (key, &variable)) { // conversion failed // variable == 1234 } // variable was changed

Parameters

Key	key
variable	pointer to variable

Return values

1	on success
0	on conversion error

◆ elektraKeyToLongLong()

int elektraKeyToLongLong	(	const Key *	key,
		kdb_long_long_t *	variable )

Converts a Key to long_long.

The variable pointed to by variable is unchanged, if an error occurs.

Parameters

Key	the key to convert
variable	pointer to the output variable

Return values

1	on success
0	otherwise

Copyright: BSD License (see doc/COPYING or http://www.libelektra.org)

Create key to type conversion function.

This supermacro creates the following functions:

int NAME_MACRO (TYPE_NAME) (Key * key, TYPE * variable)

Parameters

TYPE	valid C type (e.g. int or kdb_short_t)
TYPE_NAME	name suffix for the functions (e.g. Int or UnsignedLong)
VALUE_TYPE	optional, defaults to TYPE. Ideally a larger type assigned to variable value for checking the range before the variable is updated
TO_VALUE	expression for converting string (variable containing the key value) to VALUE_TYPE
CHECK_CONVERSION	optional, defaults to true. A boolean expression. Allows to check the range after conversion. Use ELEKTRA_TYPE_CHECK_CONVERSION to check if a conversion using strto*()-functions was successful and ELEKTRA_TYPE_CHECK_CONVERSION_RANGE (RANGE) to check additionally for a specified range.
CHECK_FAIL_BLOCK	optional, defaults to logging a warning in the key. The code to be executed (before returning 0), if CHECK_CONVERSION evaluates to false.
PRE_CHECK_CONVERSION_BLOCK	optional, defaults to empty. Allows to add additional code for pre-conversion checks (e.g. ELEKTRA_TYPE_NEGATIVE_PRE_CHECK_BLOCK)
PRE_CHECK_CONVERSION	optional, defaults to true. A boolean expression to check the contents of string before conversion (e.g. ELEKTRA_TYPE_NEGATIVE_PRE_CHECK).
PRE_CHECK_FAIL_BLOCK	optional, defaults to logging a warning in the key. The code to be executed (before returning 0), if PRE_CHECK_CONVERSION evaluates to false.
DISABLE_UNDEF_PARAMETERS	define to disable undefining of parameters after the macro. Use if parameters are used within another supermacro.
CODE_ONLY	optional, defaults to 0. Set to 1 to only generate the function body. This is useful, if you want to create a function with a custom signature for example.
KEY_PARAM_NAME	must be set, #if CODE_ONLY, will be set to 'key' otherwise. The name of the variable/parameter containing the Key, whose value will be converted
VARIABLE_PARAM_NAME	must be set, #if CODE_ONLY, will be set to 'variable' otherwise. The name of the variable/parameter containing the pointer to where the result should be written

Convert string to TYPE.

The variable is only changed if no conversion error occurred

Example: int variable = 1234; if (!NAME_MACRO (TYPE_NAME) (key, &variable)) { // conversion failed // variable == 1234 } // variable was changed

Parameters

Key	key
variable	pointer to variable

Return values

1	on success
0	on conversion error

◆ elektraKeyToOctet()

int elektraKeyToOctet	(	const Key *	key,
		kdb_octet_t *	variable )

Converts a Key to octet.

The variable pointed to by variable is unchanged, if an error occurs.

Parameters

Key	the key to convert
variable	pointer to the output variable

Return values

1	on success
0	otherwise

Copyright: BSD License (see doc/COPYING or http://www.libelektra.org)

Create key to type conversion function.

This supermacro creates the following functions:

int NAME_MACRO (TYPE_NAME) (Key * key, TYPE * variable)

Parameters

TYPE	valid C type (e.g. int or kdb_short_t)
TYPE_NAME	name suffix for the functions (e.g. Int or UnsignedLong)
VALUE_TYPE	optional, defaults to TYPE. Ideally a larger type assigned to variable value for checking the range before the variable is updated
TO_VALUE	expression for converting string (variable containing the key value) to VALUE_TYPE
CHECK_CONVERSION	optional, defaults to true. A boolean expression. Allows to check the range after conversion. Use ELEKTRA_TYPE_CHECK_CONVERSION to check if a conversion using strto*()-functions was successful and ELEKTRA_TYPE_CHECK_CONVERSION_RANGE (RANGE) to check additionally for a specified range.
CHECK_FAIL_BLOCK	optional, defaults to logging a warning in the key. The code to be executed (before returning 0), if CHECK_CONVERSION evaluates to false.
PRE_CHECK_CONVERSION_BLOCK	optional, defaults to empty. Allows to add additional code for pre-conversion checks (e.g. ELEKTRA_TYPE_NEGATIVE_PRE_CHECK_BLOCK)
PRE_CHECK_CONVERSION	optional, defaults to true. A boolean expression to check the contents of string before conversion (e.g. ELEKTRA_TYPE_NEGATIVE_PRE_CHECK).
PRE_CHECK_FAIL_BLOCK	optional, defaults to logging a warning in the key. The code to be executed (before returning 0), if PRE_CHECK_CONVERSION evaluates to false.
DISABLE_UNDEF_PARAMETERS	define to disable undefining of parameters after the macro. Use if parameters are used within another supermacro.
CODE_ONLY	optional, defaults to 0. Set to 1 to only generate the function body. This is useful, if you want to create a function with a custom signature for example.
KEY_PARAM_NAME	must be set, #if CODE_ONLY, will be set to 'key' otherwise. The name of the variable/parameter containing the Key, whose value will be converted
VARIABLE_PARAM_NAME	must be set, #if CODE_ONLY, will be set to 'variable' otherwise. The name of the variable/parameter containing the pointer to where the result should be written

Convert string to TYPE.

The variable is only changed if no conversion error occurred

Example: int variable = 1234; if (!NAME_MACRO (TYPE_NAME) (key, &variable)) { // conversion failed // variable == 1234 } // variable was changed

Parameters

Key	key
variable	pointer to variable

Return values

1	on success
0	on conversion error

◆ elektraKeyToShort()

int elektraKeyToShort	(	const Key *	key,
		kdb_short_t *	variable )

Converts a Key to short.

The variable pointed to by variable is unchanged, if an error occurs.

Parameters

Key	the key to convert
variable	pointer to the output variable

Return values

1	on success
0	otherwise

Copyright: BSD License (see doc/COPYING or http://www.libelektra.org)

Create key to type conversion function.

This supermacro creates the following functions:

int NAME_MACRO (TYPE_NAME) (Key * key, TYPE * variable)

Parameters

TYPE	valid C type (e.g. int or kdb_short_t)
TYPE_NAME	name suffix for the functions (e.g. Int or UnsignedLong)
VALUE_TYPE	optional, defaults to TYPE. Ideally a larger type assigned to variable value for checking the range before the variable is updated
TO_VALUE	expression for converting string (variable containing the key value) to VALUE_TYPE
CHECK_CONVERSION	optional, defaults to true. A boolean expression. Allows to check the range after conversion. Use ELEKTRA_TYPE_CHECK_CONVERSION to check if a conversion using strto*()-functions was successful and ELEKTRA_TYPE_CHECK_CONVERSION_RANGE (RANGE) to check additionally for a specified range.
CHECK_FAIL_BLOCK	optional, defaults to logging a warning in the key. The code to be executed (before returning 0), if CHECK_CONVERSION evaluates to false.
PRE_CHECK_CONVERSION_BLOCK	optional, defaults to empty. Allows to add additional code for pre-conversion checks (e.g. ELEKTRA_TYPE_NEGATIVE_PRE_CHECK_BLOCK)
PRE_CHECK_CONVERSION	optional, defaults to true. A boolean expression to check the contents of string before conversion (e.g. ELEKTRA_TYPE_NEGATIVE_PRE_CHECK).
PRE_CHECK_FAIL_BLOCK	optional, defaults to logging a warning in the key. The code to be executed (before returning 0), if PRE_CHECK_CONVERSION evaluates to false.
DISABLE_UNDEF_PARAMETERS	define to disable undefining of parameters after the macro. Use if parameters are used within another supermacro.
CODE_ONLY	optional, defaults to 0. Set to 1 to only generate the function body. This is useful, if you want to create a function with a custom signature for example.
KEY_PARAM_NAME	must be set, #if CODE_ONLY, will be set to 'key' otherwise. The name of the variable/parameter containing the Key, whose value will be converted
VARIABLE_PARAM_NAME	must be set, #if CODE_ONLY, will be set to 'variable' otherwise. The name of the variable/parameter containing the pointer to where the result should be written

Convert string to TYPE.

The variable is only changed if no conversion error occurred

Example: int variable = 1234; if (!NAME_MACRO (TYPE_NAME) (key, &variable)) { // conversion failed // variable == 1234 } // variable was changed

Parameters

Key	key
variable	pointer to variable

Return values

1	on success
0	on conversion error

◆ elektraKeyToString()

int elektraKeyToString	(	const Key *	key,
		const char **	variable )

Converts a Key to string.

The variable pointed to by variable is unchanged, if an error occurs.

Parameters

Key	the key to convert
variable	pointer to the output variable

Return values

1	on success
0	otherwise

Copyright: BSD License (see doc/COPYING or http://www.libelektra.org)

Create key to type conversion function.

This supermacro creates the following functions:

int NAME_MACRO (TYPE_NAME) (Key * key, TYPE * variable)

Parameters

TYPE	valid C type (e.g. int or kdb_short_t)
TYPE_NAME	name suffix for the functions (e.g. Int or UnsignedLong)
VALUE_TYPE	optional, defaults to TYPE. Ideally a larger type assigned to variable value for checking the range before the variable is updated
TO_VALUE	expression for converting string (variable containing the key value) to VALUE_TYPE
CHECK_CONVERSION	optional, defaults to true. A boolean expression. Allows to check the range after conversion. Use ELEKTRA_TYPE_CHECK_CONVERSION to check if a conversion using strto*()-functions was successful and ELEKTRA_TYPE_CHECK_CONVERSION_RANGE (RANGE) to check additionally for a specified range.
CHECK_FAIL_BLOCK	optional, defaults to logging a warning in the key. The code to be executed (before returning 0), if CHECK_CONVERSION evaluates to false.
PRE_CHECK_CONVERSION_BLOCK	optional, defaults to empty. Allows to add additional code for pre-conversion checks (e.g. ELEKTRA_TYPE_NEGATIVE_PRE_CHECK_BLOCK)
PRE_CHECK_CONVERSION	optional, defaults to true. A boolean expression to check the contents of string before conversion (e.g. ELEKTRA_TYPE_NEGATIVE_PRE_CHECK).
PRE_CHECK_FAIL_BLOCK	optional, defaults to logging a warning in the key. The code to be executed (before returning 0), if PRE_CHECK_CONVERSION evaluates to false.
DISABLE_UNDEF_PARAMETERS	define to disable undefining of parameters after the macro. Use if parameters are used within another supermacro.
CODE_ONLY	optional, defaults to 0. Set to 1 to only generate the function body. This is useful, if you want to create a function with a custom signature for example.
KEY_PARAM_NAME	must be set, #if CODE_ONLY, will be set to 'key' otherwise. The name of the variable/parameter containing the Key, whose value will be converted
VARIABLE_PARAM_NAME	must be set, #if CODE_ONLY, will be set to 'variable' otherwise. The name of the variable/parameter containing the pointer to where the result should be written

Convert string to TYPE.

The variable is only changed if no conversion error occurred

Example: int variable = 1234; if (!NAME_MACRO (TYPE_NAME) (key, &variable)) { // conversion failed // variable == 1234 } // variable was changed

Parameters

Key	key
variable	pointer to variable

Return values

1	on success
0	on conversion error

◆ elektraKeyToUnsignedLong()

int elektraKeyToUnsignedLong	(	const Key *	key,
		kdb_unsigned_long_t *	variable )

Converts a Key to unsigned_long.

The variable pointed to by variable is unchanged, if an error occurs.

Parameters

Key	the key to convert
variable	pointer to the output variable

Return values

1	on success
0	otherwise

Copyright: BSD License (see doc/COPYING or http://www.libelektra.org)

Create key to type conversion function.

This supermacro creates the following functions:

int NAME_MACRO (TYPE_NAME) (Key * key, TYPE * variable)

Parameters

TYPE	valid C type (e.g. int or kdb_short_t)
TYPE_NAME	name suffix for the functions (e.g. Int or UnsignedLong)
VALUE_TYPE	optional, defaults to TYPE. Ideally a larger type assigned to variable value for checking the range before the variable is updated
TO_VALUE	expression for converting string (variable containing the key value) to VALUE_TYPE
CHECK_CONVERSION	optional, defaults to true. A boolean expression. Allows to check the range after conversion. Use ELEKTRA_TYPE_CHECK_CONVERSION to check if a conversion using strto*()-functions was successful and ELEKTRA_TYPE_CHECK_CONVERSION_RANGE (RANGE) to check additionally for a specified range.
CHECK_FAIL_BLOCK	optional, defaults to logging a warning in the key. The code to be executed (before returning 0), if CHECK_CONVERSION evaluates to false.
PRE_CHECK_CONVERSION_BLOCK	optional, defaults to empty. Allows to add additional code for pre-conversion checks (e.g. ELEKTRA_TYPE_NEGATIVE_PRE_CHECK_BLOCK)
PRE_CHECK_CONVERSION	optional, defaults to true. A boolean expression to check the contents of string before conversion (e.g. ELEKTRA_TYPE_NEGATIVE_PRE_CHECK).
PRE_CHECK_FAIL_BLOCK	optional, defaults to logging a warning in the key. The code to be executed (before returning 0), if PRE_CHECK_CONVERSION evaluates to false.
DISABLE_UNDEF_PARAMETERS	define to disable undefining of parameters after the macro. Use if parameters are used within another supermacro.
CODE_ONLY	optional, defaults to 0. Set to 1 to only generate the function body. This is useful, if you want to create a function with a custom signature for example.
KEY_PARAM_NAME	must be set, #if CODE_ONLY, will be set to 'key' otherwise. The name of the variable/parameter containing the Key, whose value will be converted
VARIABLE_PARAM_NAME	must be set, #if CODE_ONLY, will be set to 'variable' otherwise. The name of the variable/parameter containing the pointer to where the result should be written

Convert string to TYPE.

The variable is only changed if no conversion error occurred

Example: int variable = 1234; if (!NAME_MACRO (TYPE_NAME) (key, &variable)) { // conversion failed // variable == 1234 } // variable was changed

Parameters

Key	key
variable	pointer to variable

Return values

1	on success
0	on conversion error

◆ elektraKeyToUnsignedLongLong()

int elektraKeyToUnsignedLongLong	(	const Key *	key,
		kdb_unsigned_long_long_t *	variable )

Converts a Key to unsigned_long_long.

The variable pointed to by variable is unchanged, if an error occurs.

Parameters

Key	the key to convert
variable	pointer to the output variable

Return values

1	on success
0	otherwise

Copyright: BSD License (see doc/COPYING or http://www.libelektra.org)

Create key to type conversion function.

This supermacro creates the following functions:

int NAME_MACRO (TYPE_NAME) (Key * key, TYPE * variable)

Parameters

TYPE	valid C type (e.g. int or kdb_short_t)
TYPE_NAME	name suffix for the functions (e.g. Int or UnsignedLong)
VALUE_TYPE	optional, defaults to TYPE. Ideally a larger type assigned to variable value for checking the range before the variable is updated
TO_VALUE	expression for converting string (variable containing the key value) to VALUE_TYPE
CHECK_CONVERSION	optional, defaults to true. A boolean expression. Allows to check the range after conversion. Use ELEKTRA_TYPE_CHECK_CONVERSION to check if a conversion using strto*()-functions was successful and ELEKTRA_TYPE_CHECK_CONVERSION_RANGE (RANGE) to check additionally for a specified range.
CHECK_FAIL_BLOCK	optional, defaults to logging a warning in the key. The code to be executed (before returning 0), if CHECK_CONVERSION evaluates to false.
PRE_CHECK_CONVERSION_BLOCK	optional, defaults to empty. Allows to add additional code for pre-conversion checks (e.g. ELEKTRA_TYPE_NEGATIVE_PRE_CHECK_BLOCK)
PRE_CHECK_CONVERSION	optional, defaults to true. A boolean expression to check the contents of string before conversion (e.g. ELEKTRA_TYPE_NEGATIVE_PRE_CHECK).
PRE_CHECK_FAIL_BLOCK	optional, defaults to logging a warning in the key. The code to be executed (before returning 0), if PRE_CHECK_CONVERSION evaluates to false.
DISABLE_UNDEF_PARAMETERS	define to disable undefining of parameters after the macro. Use if parameters are used within another supermacro.
CODE_ONLY	optional, defaults to 0. Set to 1 to only generate the function body. This is useful, if you want to create a function with a custom signature for example.
KEY_PARAM_NAME	must be set, #if CODE_ONLY, will be set to 'key' otherwise. The name of the variable/parameter containing the Key, whose value will be converted
VARIABLE_PARAM_NAME	must be set, #if CODE_ONLY, will be set to 'variable' otherwise. The name of the variable/parameter containing the pointer to where the result should be written

Convert string to TYPE.

The variable is only changed if no conversion error occurred

Example: int variable = 1234; if (!NAME_MACRO (TYPE_NAME) (key, &variable)) { // conversion failed // variable == 1234 } // variable was changed

Parameters

Key	key
variable	pointer to variable

Return values

1	on success
0	on conversion error

◆ elektraKeyToUnsignedShort()

int elektraKeyToUnsignedShort	(	const Key *	key,
		kdb_unsigned_short_t *	variable )

Converts a Key to unsigned_short.

The variable pointed to by variable is unchanged, if an error occurs.

Parameters

Key	the key to convert
variable	pointer to the output variable

Return values

1	on success
0	otherwise

Copyright: BSD License (see doc/COPYING or http://www.libelektra.org)

Create key to type conversion function.

This supermacro creates the following functions:

int NAME_MACRO (TYPE_NAME) (Key * key, TYPE * variable)

Parameters

TYPE	valid C type (e.g. int or kdb_short_t)
TYPE_NAME	name suffix for the functions (e.g. Int or UnsignedLong)
VALUE_TYPE	optional, defaults to TYPE. Ideally a larger type assigned to variable value for checking the range before the variable is updated
TO_VALUE	expression for converting string (variable containing the key value) to VALUE_TYPE
CHECK_CONVERSION	optional, defaults to true. A boolean expression. Allows to check the range after conversion. Use ELEKTRA_TYPE_CHECK_CONVERSION to check if a conversion using strto*()-functions was successful and ELEKTRA_TYPE_CHECK_CONVERSION_RANGE (RANGE) to check additionally for a specified range.
CHECK_FAIL_BLOCK	optional, defaults to logging a warning in the key. The code to be executed (before returning 0), if CHECK_CONVERSION evaluates to false.
PRE_CHECK_CONVERSION_BLOCK	optional, defaults to empty. Allows to add additional code for pre-conversion checks (e.g. ELEKTRA_TYPE_NEGATIVE_PRE_CHECK_BLOCK)
PRE_CHECK_CONVERSION	optional, defaults to true. A boolean expression to check the contents of string before conversion (e.g. ELEKTRA_TYPE_NEGATIVE_PRE_CHECK).
PRE_CHECK_FAIL_BLOCK	optional, defaults to logging a warning in the key. The code to be executed (before returning 0), if PRE_CHECK_CONVERSION evaluates to false.
DISABLE_UNDEF_PARAMETERS	define to disable undefining of parameters after the macro. Use if parameters are used within another supermacro.
CODE_ONLY	optional, defaults to 0. Set to 1 to only generate the function body. This is useful, if you want to create a function with a custom signature for example.
KEY_PARAM_NAME	must be set, #if CODE_ONLY, will be set to 'key' otherwise. The name of the variable/parameter containing the Key, whose value will be converted
VARIABLE_PARAM_NAME	must be set, #if CODE_ONLY, will be set to 'variable' otherwise. The name of the variable/parameter containing the pointer to where the result should be written

Convert string to TYPE.

The variable is only changed if no conversion error occurred

Example: int variable = 1234; if (!NAME_MACRO (TYPE_NAME) (key, &variable)) { // conversion failed // variable == 1234 } // variable was changed

Parameters

Key	key
variable	pointer to variable

Return values

1	on success
0	on conversion error

◆ elektraLongLongToString()

char * elektraLongLongToString ( kdb_long_long_t value )

Converts a long long to string.

The string is allocated with elektraMalloc() and must be disposed of with elektraFree().

Parameters

value the value to convert

Returns: a new string allocated with elektraMalloc, or 0 on error

◆ elektraLongToString()

char * elektraLongToString ( kdb_long_t value )

Converts a long to string.

The string is allocated with elektraMalloc() and must be disposed of with elektraFree().

Parameters

value the value to convert

Returns: a new string allocated with elektraMalloc, or 0 on error

◆ elektraOctetToString()

char * elektraOctetToString ( kdb_octet_t value )

Converts an octet to string.

The string is allocated with elektraMalloc() and must be disposed of with elektraFree().

Parameters

value the value to convert

Returns: a new string allocated with elektraMalloc, or 0 on error

◆ elektraShortToString()

char * elektraShortToString ( kdb_short_t value )

Converts a short to string.

The string is allocated with elektraMalloc() and must be disposed of with elektraFree().

Parameters

value the value to convert

Returns: a new string allocated with elektraMalloc, or 0 on error

◆ elektraUnsignedLongLongToString()

char * elektraUnsignedLongLongToString ( kdb_unsigned_long_long_t value )

Converts an unsigned long long to string.

The string is allocated with elektraMalloc() and must be disposed of with elektraFree().

Parameters

value the value to convert

Returns: a new string allocated with elektraMalloc, or 0 on error

◆ elektraUnsignedLongToString()

char * elektraUnsignedLongToString ( kdb_unsigned_long_t value )

Converts an unsigned long to string.

The string is allocated with elektraMalloc() and must be disposed of with elektraFree().

Parameters

value the value to convert

Returns: a new string allocated with elektraMalloc, or 0 on error

◆ elektraUnsignedShortToString()

char * elektraUnsignedShortToString ( kdb_unsigned_short_t value )

Converts an unsigned short to string.

The string is allocated with elektraMalloc() and must be disposed of with elektraFree().

Parameters

value the value to convert

Returns: a new string allocated with elektraMalloc, or 0 on error

Functions

Detailed Description

Function Documentation

◆ elektraBooleanToString()

◆ elektraCharToString()

◆ elektraDoubleToString()

◆ elektraFloatToString()

◆ elektraKeyToBoolean()

◆ elektraKeyToChar()

◆ elektraKeyToDouble()

◆ elektraKeyToFloat()

◆ elektraKeyToLong()

◆ elektraKeyToLongLong()

◆ elektraKeyToOctet()

◆ elektraKeyToShort()

◆ elektraKeyToString()

◆ elektraKeyToUnsignedLong()

◆ elektraKeyToUnsignedLongLong()

◆ elektraKeyToUnsignedShort()

◆ elektraLongLongToString()

◆ elektraLongToString()

◆ elektraOctetToString()

◆ elektraShortToString()

◆ elektraUnsignedLongLongToString()

◆ elektraUnsignedLongToString()

◆ elektraUnsignedShortToString()