dav: comparison ucx/cx/properties.h

-:26541c37b619
+:42cdbf9bbd49
 typedef struct cx_properties_config_s CxPropertiesConfig;
 /**
 * Default properties configuration.
 */
-cx_attr_export
+CX_EXPORT extern const CxPropertiesConfig cx_properties_config_default;
-extern const CxPropertiesConfig cx_properties_config_default;
 /**
 * Status codes for the properties interface.
 */
 enum cx_properties_status {
 * Not used as a status and never returned by any function.
 *
 * You can use this enumerator to check for all "good" status results
 * by checking if the status is less than @c CX_PROPERTIES_OK.
 *
-* A "good" status means, that you can refill data and continue parsing.
+* A "good" status means that you can refill data and continue parsing.
 */
 CX_PROPERTIES_OK,
 /**
 * Input buffer is @c NULL.
 */
 CX_PROPERTIES_NULL_INPUT,
 /**
-* The line contains a delimiter, but no key.
+* The line contains a delimiter but no key.
 */
 CX_PROPERTIES_INVALID_EMPTY_KEY,
 /**
-* The line contains data, but no delimiter.
+* The line contains data but no delimiter.
 */
 CX_PROPERTIES_INVALID_MISSING_DELIMITER,
 /**
 * More internal buffer was needed, but could not be allocated.
 */
 typedef struct cx_properties_sink_s CxPropertiesSink;
 /**
 * A function that consumes a k/v-pair in a sink.
 *
-* The sink could be e.g. a map and the sink function would be calling
+* The sink could be a map, and the sink function would be calling
 * a map function to store the k/v-pair.
 *
 * @param prop the properties interface that wants to sink a k/v-pair
 * @param sink the sink
 * @param key the key
 * @param value the value
 * @retval zero success
 * @retval non-zero sinking the k/v-pair failed
 */
-cx_attr_nonnull
 typedef int(*cx_properties_sink_func)(
 CxProperties *prop,
 CxPropertiesSink *sink,
 cxstring key,
 cxstring value
 * @param src the source
 * @param target a string buffer where the read data shall be stored
 * @retval zero success
 * @retval non-zero reading the data failed
 */
-cx_attr_nonnull
 typedef int(*cx_properties_read_func)(
 CxProperties *prop,
 CxPropertiesSource *src,
 cxstring *target
 );
 * @param prop the properties interface that wants to read from the source
 * @param src the source
 * @retval zero initialization was successful
 * @retval non-zero otherwise
 */
-cx_attr_nonnull
 typedef int(*cx_properties_read_init_func)(
 CxProperties *prop,
 CxPropertiesSource *src
 );
 * A function that cleans memory initialized by the read_init_func.
 *
 * @param prop the properties interface that wants to read from the source
 * @param src the source
 */
-cx_attr_nonnull
 typedef void(*cx_properties_read_clean_func)(
 CxProperties *prop,
 CxPropertiesSource *src
 );
 */
 struct cx_properties_source_s {
 /**
 * The source object.
 *
-* For example a file stream or a string.
+* For example, a file stream or a string.
 */
 void *src;
 /**
 * Optional additional data pointer.
 */
 * @param prop the properties interface
 * @param config the properties configuration
 * @see cxPropertiesInitDefault()
 */
 cx_attr_nonnull
-cx_attr_export
+CX_EXPORT void cxPropertiesInit(CxProperties *prop, CxPropertiesConfig config);
-void cxPropertiesInit(CxProperties *prop, CxPropertiesConfig config);
 /**
 * Destroys the properties interface.
 *
 * @note Even when you are certain that you did not use the interface in a
 * way that caused a memory allocation, you should call this function anyway.
-* Future versions of the library might add features that need additional memory
+* Future versions of the library might add features that need additional memory,
-* and you really don't want to search the entire code where you might need
+* and you really don't want to search the entire code where you might need to
-* add call to this function.
+* add a call to this function.
 *
 * @param prop the properties interface
 */
 cx_attr_nonnull
-cx_attr_export
+CX_EXPORT void cxPropertiesDestroy(CxProperties *prop);
-void cxPropertiesDestroy(CxProperties *prop);
 /**
 * Destroys and re-initializes the properties interface.
 *
-* You might want to use this, to reset the parser after
+* You might want to use this to reset the parser after
 * encountering a syntax error.
 *
 * @param prop the properties interface
 */
 cx_attr_nonnull
-static inline void cxPropertiesReset(CxProperties *prop) {
+CX_EXPORT void cxPropertiesReset(CxProperties *prop);
-CxPropertiesConfig config = prop->config;
-cxPropertiesDestroy(prop);
-cxPropertiesInit(prop, config);
-}
 /**
 * Initialize a properties parser with the default configuration.
 *
 * @param prop (@c CxProperties*) the properties interface
 * @see cxPropertiesInit()
 */
 #define cxPropertiesInitDefault(prop) \
 cxPropertiesInit(prop, cx_properties_config_default)
 /**
 * Fills the input buffer with data.
 *
 * After calling this function, you can parse the data by calling
 * @param len the length of the data
 * @retval zero success
 * @retval non-zero a memory allocation was necessary but failed
 * @see cxPropertiesFill()
 */
+cx_attr_nonnull cx_attr_access_r(2, 3)
+CX_EXPORT int cxPropertiesFilln(CxProperties *prop, const char *buf, size_t len);
+/**
+* Internal function, do not use.
+*
+* @param prop the properties interface
+* @param str the text to fill in
+* @retval zero success
+* @retval non-zero a memory allocation was necessary but failed
+*/
 cx_attr_nonnull
-cx_attr_access_r(2, 3)
+CX_INLINE int cx_properties_fill(CxProperties *prop, cxstring str) {
-cx_attr_export
-int cxPropertiesFilln(
-CxProperties *prop,
-const char *buf,
-size_t len
-);
-#ifdef __cplusplus
-} // extern "C"
-cx_attr_nonnull
-static inline int cxPropertiesFill(
-CxProperties *prop,
-cxstring str
-) {
 return cxPropertiesFilln(prop, str.ptr, str.length);
 }
-cx_attr_nonnull
-static inline int cxPropertiesFill(
-CxProperties *prop,
-cxmutstr str
-) {
-return cxPropertiesFilln(prop, str.ptr, str.length);
-}
-cx_attr_nonnull
-cx_attr_cstr_arg(2)
-static inline int cxPropertiesFill(
-CxProperties *prop,
-const char *str
-) {
-return cxPropertiesFilln(prop, str, strlen(str));
-}
-extern "C" {
-#else // __cplusplus
 /**
 * Fills the input buffer with data.
 *
 * After calling this function, you can parse the data by calling
 * cxPropertiesNext().
 * @param str the text to fill in
 * @retval zero success
 * @retval non-zero a memory allocation was necessary but failed
 * @see cxPropertiesFilln()
 */
-#define cxPropertiesFill(prop, str) _Generic((str), \
+#define cxPropertiesFill(prop, str) cx_properties_fill(prop, cx_strcast(str))
-cxstring: cx_properties_fill_cxstr,             \
-cxmutstr: cx_properties_fill_mutstr,            \
+/**
-char*: cx_properties_fill_str,                  \
+* Specifies stack memory that shall be used as an internal buffer.
-const char*: cx_properties_fill_str)            \
-(prop, str)
-/**
-* @copydoc cxPropertiesFill()
-*/
-cx_attr_nonnull
-static inline int cx_properties_fill_cxstr(
-CxProperties *prop,
-cxstring str
-) {
-return cxPropertiesFilln(prop, str.ptr, str.length);
-}
-/**
-* @copydoc cxPropertiesFill()
-*/
-cx_attr_nonnull
-static inline int cx_properties_fill_mutstr(
-CxProperties *prop,
-cxmutstr str
-) {
-return cxPropertiesFilln(prop, str.ptr, str.length);
-}
-/**
-* @copydoc cxPropertiesFill()
-*/
-cx_attr_nonnull
-cx_attr_cstr_arg(2)
-static inline int cx_properties_fill_str(
-CxProperties *prop,
-const char *str
-) {
-return cxPropertiesFilln(prop, str, strlen(str));
-}
-#endif
-/**
-* Specifies stack memory that shall be used as internal buffer.
 *
 * @param prop the properties interface
 * @param buf a pointer to stack memory
 * @param capacity the capacity of the stack memory
 */
 cx_attr_nonnull
-cx_attr_export
+CX_EXPORT void cxPropertiesUseStack(CxProperties *prop, char *buf, size_t capacity);
-void cxPropertiesUseStack(
-CxProperties *prop,
-char *buf,
-size_t capacity
-);
 /**
 * Retrieves the next key/value-pair.
 *
 * This function returns zero as long as there are key/value-pairs found.
 * @retval CX_PROPERTIES_NULL_INPUT the input buffer was never filled
 * @retval CX_PROPERTIES_INVALID_EMPTY_KEY the properties data contains an illegal empty key
 * @retval CX_PROPERTIES_INVALID_MISSING_DELIMITER the properties data contains a line without delimiter
 * @retval CX_PROPERTIES_BUFFER_ALLOC_FAILED an internal allocation was necessary but failed
 */
-cx_attr_nonnull
+cx_attr_nonnull cx_attr_nodiscard
-cx_attr_nodiscard
+CX_EXPORT CxPropertiesStatus cxPropertiesNext(CxProperties *prop, cxstring *key, cxstring *value);
-cx_attr_export
-CxPropertiesStatus cxPropertiesNext(
-CxProperties *prop,
-cxstring *key,
-cxstring *value
-);
 /**
 * Creates a properties sink for an UCX map.
 *
 * The values stored in the map will be pointers to freshly allocated,
 *
 * @param map the map that shall consume the k/v-pairs.
 * @return the sink
 * @see cxPropertiesLoad()
 */
-cx_attr_nonnull
+cx_attr_nonnull cx_attr_nodiscard
-cx_attr_nodiscard
+CX_EXPORT CxPropertiesSink cxPropertiesMapSink(CxMap *map);
-cx_attr_export
-CxPropertiesSink cxPropertiesMapSink(CxMap *map);
 /**
 * Creates a properties source based on an UCX string.
 *
 * @param str the string
 * @return the properties source
 * @see cxPropertiesLoad()
 */
 cx_attr_nodiscard
-cx_attr_export
+CX_EXPORT CxPropertiesSource cxPropertiesStringSource(cxstring str);
-CxPropertiesSource cxPropertiesStringSource(cxstring str);
 /**
 * Creates a properties source based on C string with the specified length.
 *
 * @param str the string
 * @param len the length
 * @return the properties source
 * @see cxPropertiesLoad()
 */
-cx_attr_nonnull
+cx_attr_nonnull cx_attr_nodiscard cx_attr_access_r(1, 2)
-cx_attr_nodiscard
+CX_EXPORT CxPropertiesSource cxPropertiesCstrnSource(const char *str, size_t len);
-cx_attr_access_r(1, 2)
-cx_attr_export
-CxPropertiesSource cxPropertiesCstrnSource(const char *str, size_t len);
 /**
 * Creates a properties source based on a C string.
 *
 * The length will be determined with strlen(), so the string MUST be
 *
 * @param str the string
 * @return the properties source
 * @see cxPropertiesLoad()
 */
-cx_attr_nonnull
+cx_attr_nonnull cx_attr_nodiscard cx_attr_cstr_arg(1)
-cx_attr_nodiscard
+CX_EXPORT CxPropertiesSource cxPropertiesCstrSource(const char *str);
-cx_attr_cstr_arg(1)
-cx_attr_export
-CxPropertiesSource cxPropertiesCstrSource(const char *str);
 /**
 * Creates a properties source based on an FILE.
 *
 * @param file the file
 * @param chunk_size how many bytes may be read in one operation
 *
 * @return the properties source
 * @see cxPropertiesLoad()
 */
-cx_attr_nonnull
+cx_attr_nonnull cx_attr_nodiscard cx_attr_access_r(1)
-cx_attr_nodiscard
+CX_EXPORT CxPropertiesSource cxPropertiesFileSource(FILE *file, size_t chunk_size);
-cx_attr_access_r(1)
-cx_attr_export
-CxPropertiesSource cxPropertiesFileSource(FILE *file, size_t chunk_size);
 /**
 * Loads properties data from a source and transfers it to a sink.
 *
 * @retval CX_PROPERTIES_INVALID_EMPTY_KEY the properties data contains an illegal empty key
 * @retval CX_PROPERTIES_INVALID_MISSING_DELIMITER the properties data contains a line without delimiter
 * @retval CX_PROPERTIES_BUFFER_ALLOC_FAILED an internal allocation was necessary but failed
 */
 cx_attr_nonnull
-cx_attr_export
+CX_EXPORT CxPropertiesStatus cxPropertiesLoad(CxProperties *prop,
-CxPropertiesStatus cxPropertiesLoad(
+CxPropertiesSink sink, CxPropertiesSource source);
-CxProperties *prop,
-CxPropertiesSink sink,
-CxPropertiesSource source
-);
 #ifdef __cplusplus
 } // extern "C"
 #endif

Mercurial > hg > dav / file comparison

comparison: ucx/cx/properties.h

ucx/cx/properties.h