Split a string into a composite type

Collaboration diagram for Split a string into a composite type:

Typedefs
typedef enum _amxc_string_split_status	amxc_string_split_status_t
	The possible string split errors. More...
typedef amxc_string_split_status_t(*	amxc_string_split_builder_t) (amxc_llist_t *all, amxc_var_t *var)
	Callback function definition. More...

Enumerations
enum	_amxc_string_split_status {   AMXC_STRING_SPLIT_OK , AMXC_ERROR_STRING_SPLIT_INVALID_INPUT , AMXC_ERROR_STRING_MISSING_DQUOTE , AMXC_ERROR_STRING_MISSING_SQUOTE ,   AMXC_ERROR_STRING_MISSING_RBRACKET , AMXC_ERROR_STRING_MISSING_SBRACKET , AMXC_ERROR_STRING_MISSING_CBRACKET }
	The possible string split errors. More...

Functions
amxc_string_t *	amxc_string_get_from_llist (const amxc_llist_t *const llist, const unsigned int index)
	Helper function to be used with amxc_string_split_llist. More...
const char *	amxc_string_get_text_from_llist (const amxc_llist_t *const llist, const unsigned int index)
	Helper function to be used with amxc_string_split_llist. More...
amxc_string_split_status_t	amxc_string_split_word (const amxc_string_t *const string, amxc_llist_t *list, const char **reason)
	Split a string in individual words or punctuation signs. More...
amxc_string_split_status_t	amxc_string_split (const amxc_string_t *const string, amxc_var_t *var, amxc_string_split_builder_t fn, const char **reason)
	Split a string in individual words or punctuation signs. More...
amxc_string_split_status_t	amxc_string_csv_to_var (const amxc_string_t *const string, amxc_var_t *var, const char **reason)
	Split a string in individual parts assuming that the string contains comma separated values. More...
amxc_string_split_status_t	amxc_string_ssv_to_var (const amxc_string_t *const string, amxc_var_t *var, const char **reason)
	Split a string in individual parts assuming that the string contains space separated values. More...
amxc_string_split_status_t	amxc_string_split_to_llist (const amxc_string_t *const string, amxc_llist_t *list, const char separator)
	Simple split function using a single character separator. More...

Detailed Description

Often string parsing is needed. Either parsing a string is simple, like splitting it on each occurrence of separator, or more complex, like taking into account quotes and brackets.

Using these functions may help in parsing a string.

Typedef Documentation

amxc_string_split_builder_t

typedef amxc_string_split_status_t(* amxc_string_split_builder_t) (amxc_llist_t *all, amxc_var_t *var)

Callback function definition.

When using Split a string into a composite type to split a string, a filter/builder callback function can be provided.

The string is splitted into parts as describe in amxc_string_split_word, where each part is added to a linked list.

The filter/builder callback function can then combine parts or filter them out before adding them the variant which contains a linked list of variants.

Parameters

all	linked list containing all string parts
var	var the result variant.

Returns

One of the amxc_string_split_status_t status ids.

Definition at line 112 of file amxc_string_split.h.

amxc_string_split_status_t

typedef enum _amxc_string_split_status amxc_string_split_status_t

The possible string split errors.

Enumeration Type Documentation

_amxc_string_split_status

enum _amxc_string_split_status

The possible string split errors.

Enumerator
AMXC_STRING_SPLIT_OK	No error, all ok
AMXC_ERROR_STRING_SPLIT_INVALID_INPUT	Invalid input
AMXC_ERROR_STRING_MISSING_DQUOTE	Missing double quote
AMXC_ERROR_STRING_MISSING_SQUOTE	Missing single quote
AMXC_ERROR_STRING_MISSING_RBRACKET	Missing round bracket
AMXC_ERROR_STRING_MISSING_SBRACKET	Missing square bracket
AMXC_ERROR_STRING_MISSING_CBRACKET	Missing curly bracket

Definition at line 82 of file amxc_string_split.h.

                                       {
    AMXC_STRING_SPLIT_OK,                   
    AMXC_ERROR_STRING_SPLIT_INVALID_INPUT,  
    AMXC_ERROR_STRING_MISSING_DQUOTE,       
    AMXC_ERROR_STRING_MISSING_SQUOTE,       
    AMXC_ERROR_STRING_MISSING_RBRACKET,     
    AMXC_ERROR_STRING_MISSING_SBRACKET,     
    AMXC_ERROR_STRING_MISSING_CBRACKET,     
} amxc_string_split_status_t;

Function Documentation

amxc_string_csv_to_var()

amxc_string_split_status_t amxc_string_csv_to_var	(	const amxc_string_t *const	string,
		amxc_var_t *	var,
		const char **	reason
	)

Split a string in individual parts assuming that the string contains comma separated values.

Calls Split a string into a composite type.

This function takes into account square brackets (for lists in lists), double and single quotes. When a ',' is between double or single quotes it is considered as part of the string and not as a separator.

The provided variant will be initialized to a variant containing a linked list of variants where each item in the list is a variant containing a string.

Parameters

string	The string that needs to be splitted
var	the top level variant, will be initiated to a variant containing a linked list of variants.
reason	when provided and parsing fails, will get filled with a human readable error string

Returns

one of the amxc_string_split_status_t statuses

Definition at line 555 of file amxc_string_split.c.

                                            {
    return amxc_string_split(string, var, amxc_build_csv_var_list, reason);
}

amxc_string_get_from_llist()

amxc_string_t* amxc_string_get_from_llist	(	const amxc_llist_t *const	llist,
		const unsigned int	index
	)

Helper function to be used with amxc_string_split_llist.

It gets the reference to amxc_string_t object from an amxc_llist_t, it's not a copy.

The element is free'd when the list is deleted.

Taking a copy is the programmer's responsibility!

Parameters

llist	a pointer to the linked list structure
index	the position in the list

Returns

A pointer to the string (amxc_string_t) at the index of the llist, when successful. NULL when failed to to index the llist

Definition at line 641 of file amxc_string_split.c.

                                                                    {
    amxc_string_t* retval = NULL;
    amxc_llist_it_t* it = NULL;
 
    when_null(llist, exit);
 
    it = amxc_llist_get_at(llist, index);
    when_null(it, exit);
 
    retval = amxc_string_from_llist_it(it);
exit:
    return retval;
}

amxc_string_get_text_from_llist()

const char* amxc_string_get_text_from_llist	(	const amxc_llist_t *const	llist,
		const unsigned int	index
	)

Helper function to be used with amxc_string_split_llist.

It gets the reference to the amxc_string_t object from an amxc_llist_t, it's not a copy.

The element is free'd when the list is deleted.

Taking a copy is the programmer's responsibility!

Parameters

llist	a pointer to the linked list structure
index	the position in the list

Returns

Pointer to the string buffer at the index of the llist, when successful. NULL when failed to point to index the llist.

Definition at line 656 of file amxc_string_split.c.

                                                                      {
    const char* retval = NULL;
    amxc_string_t* var_str = NULL;
 
    var_str = amxc_string_get_from_llist(llist, index);
    when_null(var_str, exit);
 
    retval = amxc_string_get(var_str, 0);
exit:
    return retval;
}

amxc_string_split()

amxc_string_split_status_t amxc_string_split	(	const amxc_string_t *const	string,
		amxc_var_t *	var,
		amxc_string_split_builder_t	fn,
		const char **	reason
	)

Split a string in individual words or punctuation signs.

This functions behaves exactly the same as amxc_string_split_word, with following differences:

• instead of building a linked list of strings it builds a variant containing a linked list of variants where each item is a variant containing a string.
• Provides the possibility to provide a callback function that can filter out or modify the items that are put in the list. See amxc_string_split_builder_t

Parameters

string	The string that needs to be splitted
var	the top level variant, will be initiated to a variant containing a linked list of variants.
fn	a filter/build callback function or NULL
reason	when provided and parsing fails, will get filled with a human readable error string

Returns

one of the amxc_string_split_status_t statuses

Definition at line 521 of file amxc_string_split.c.

                                       {
    amxc_string_split_status_t retval = AMXC_ERROR_STRING_SPLIT_INVALID_INPUT;
    amxc_llist_t all_parts;
 
    amxc_llist_init(&all_parts);
    when_null(string, exit);
    when_null(var, exit);
 
    retval = amxc_string_split_words_internal(string,
                                              &all_parts,
                                              amxc_string_create_part,
                                              amxc_need_to_add_delimiter,
                                              reason);
 
    if(fn != NULL) {
        fn(&all_parts, var);
    } else {
        amxc_var_set_type(var, AMXC_VAR_ID_LIST);
        amxc_llist_for_each(it, (&all_parts)) {
            amxc_string_t* part = amxc_string_from_llist_it(it);
            amxc_var_add(cstring_t, var, amxc_string_get(part, 0));
            amxc_string_delete(&part);
        }
    }
 
exit:
    amxc_llist_clean(&all_parts, amxc_string_list_it_free);
    return retval;
}

amxc_string_split_to_llist()

amxc_string_split_status_t amxc_string_split_to_llist	(	const amxc_string_t *const	string,
		amxc_llist_t *	list,
		const char	separator
	)

Simple split function using a single character separator.

Splits a string into parts using a single character separator. A separator must be a punctuation sign except '[' or ']'. Alphanumeric characters are not allowed as a separator.

Parameters

string	The string that needs to be splitted
list	the result list
separator	the single character separator sign

Returns

one of the amxc_string_split_status_t statuses

Definition at line 569 of file amxc_string_split.c.

                                                 {
    amxc_string_split_status_t retval = AMXC_ERROR_STRING_SPLIT_INVALID_INPUT;
    amxc_string_t* current = NULL;
    amxc_llist_t parts_list;
    bool in_sbrackets = false;
 
    amxc_llist_init(&parts_list);
    when_null(string, exit);
    when_null(list, exit);
    when_true(isalnum(separator) != 0, exit);
    when_true(separator == '[' || separator == ']', exit);
 
    retval = amxc_string_split_word(string, &parts_list, NULL);
    when_failed(retval, exit);
    amxc_trim_llist(&parts_list);
 
    amxc_llist_for_each(it, (&parts_list)) {
        amxc_string_t* part = amxc_string_from_llist_it(it);
        const char* txt_part = amxc_string_get(part, 0);
        amxc_llist_append(list, &part->it);
        if(amxc_string_text_length(part) == 1) {
            if((separator == txt_part[0]) && !in_sbrackets) {
                amxc_string_reset(part);
                if(amxc_llist_it_get_previous(it) != NULL) {
                    current = part;
                }
                continue;
            }
            if(txt_part[0] == '[') {
                if((amxc_string_text_length(current) > 0) && (isspace(separator) == 0)) {
                    amxc_string_append(current, txt_part, amxc_string_text_length(part));
                    amxc_string_delete(&part);
                    continue;
                } else {
                    if(amxc_string_is_empty(current)) {
                        amxc_string_delete(&current);
                    }
                    current = part;
                    in_sbrackets = !in_sbrackets;
                    continue;
                }
            }
            if((txt_part[0] == ']') && in_sbrackets) {
                amxc_string_append(current, txt_part, amxc_string_text_length(part));
                amxc_string_delete(&part);
                in_sbrackets = !in_sbrackets;
                current = NULL;
                continue;
            }
            if(isspace(txt_part[0]) && !in_sbrackets) {
                if(!amxc_string_is_empty(current)) {
                    amxc_string_append(current, txt_part, amxc_string_text_length(part));
                }
                amxc_string_delete(&part);
                continue;
            }
        }
        if(current == NULL) {
            current = part;
        } else {
            amxc_string_append(current, txt_part, amxc_string_text_length(part));
            amxc_string_delete(&part);
        }
    }
 
exit:
    amxc_llist_clean(&parts_list, amxc_string_list_it_free);
    return retval;
}

amxc_string_split_word()

amxc_string_split_status_t amxc_string_split_word	(	const amxc_string_t *const	string,
		amxc_llist_t *	list,
		const char **	reason
	)

Split a string in individual words or punctuation signs.

This function splits a string in individual words or punctuation signs and puts each individual part in a list. Each part in the list will be a amxc_string_t

A sequence of characters the only consists out of alfa numeric symbols [0-9a-zA-Z] is considered as one single word.

When multiple space characters are encountered after each other only one single space is added to the list.

All space characters are always converted to ' '. So when a tab or new-line character is encountered it will be added to the list as a single ' '.

Brackets and quotes are taken into account, parsing fails when there are missing quotes or brackets.

Parameters

string	The string that needs to be splitted
list	the linked list that gets filled
reason	when provided and parsing fails, will get filled with a human readable error string

Returns

one of the amxc_string_split_status_t statuses

Definition at line 499 of file amxc_string_split.c.

                                            {
    amxc_string_split_status_t retval = AMXC_ERROR_STRING_SPLIT_INVALID_INPUT;
 
    when_null(list, exit);
    when_null(string, exit);
 
    retval = amxc_string_split_words_internal(string,
                                              list,
                                              amxc_string_create_part,
                                              amxc_need_to_add_delimiter,
                                              reason);
    if(retval != 0) {
        amxc_llist_clean(list, amxc_string_list_it_free);
    }
 
exit:
    return retval;
}

amxc_string_ssv_to_var()

amxc_string_split_status_t amxc_string_ssv_to_var	(	const amxc_string_t *const	string,
		amxc_var_t *	var,
		const char **	reason
	)

Split a string in individual parts assuming that the string contains space separated values.

Calls Split a string into a composite type.

This function takes into account square brackets (for lists in lists), double and single quotes. When a ' ' is between double or single quotes it is considered as part of the string and not as a separator.

The provided variant will be initialized to a variant containing a linked list of variants where each item in the list is a variant containing a string.

Parameters

string	The string that needs to be splitted
var	the top level variant, will be initiated to a variant containing a linked list of variants.
reason	when provided and parsing fails, will get filled with a human readable error string

Returns

one of the amxc_string_split_status_t statuses

Definition at line 562 of file amxc_string_split.c.

                                            {
    return amxc_string_split(string, var, amxc_build_ssv_var_list, reason);
}