Commit c94ae3ee authored by Gallacchi Mattia's avatar Gallacchi Mattia
Browse files

Add cpp header 



Signed-off-by: default avatarmattia.gallacchi <mattia.gallacchi@he-arc.ch>
parent 62507ee1

CMakeLists.txt

+2 −2
Original line number Diff line number Diff line 
cmake_minimum_required(VERSION 3.20)



project(rsvp)

project(rsvp LANGUAGES C CXX)



include_directories(src)

add_subdirectory(src)



add_subdirectory(src)

add_subdirectory(tests)
 
 No newline at end of file

src/CMakeLists.txt

+4 −1
Original line number Diff line number Diff line
@@ -5,3 +5,6 @@ project(rsvp) 
file(GLOB SRC *.c)



add_library(${PROJECT_NAME} ${SRC})



file(GLOB SRC *.c *.hpp)

add_library(${PROJECT_NAME}pp ${SRC})
 
 No newline at end of file

src/rsvp.c

+145 −39
Original line number Diff line number Diff line
@@ -3,9 +3,6 @@ 
#include <string.h>

#include "rsvp.h"



static char delimiter = 0x3B; // ;

static char delimiter_vecd = 0x2C; // ,



RSVP_TYPE get_type(char *type)

{

    RSVP_TYPE type_ = STR;
@@ -21,6 +18,19 @@ RSVP_TYPE get_type(char *type) 
    return type_;

}



int count_tokens(char *str, char delimiter)

{

    int counter = 0;

    char *begin = str;



    while ((begin = strchr(begin, delimiter)) != NULL) {

        counter++;

        begin++;

    }



    return counter;  

}



void get_vecd_elem(char *token, rsvp_vecd_elem_t* elem)

{

    char *value = NULL, *begin = token;
@@ -36,6 +46,7 @@ void get_vecd_elem(char *token, rsvp_vecd_elem_t* elem) 
                index++;

                break;

        }

        token++;

    }



    elem->name = (char*)malloc(index);
@@ -44,32 +55,29 @@ void get_vecd_elem(char *token, rsvp_vecd_elem_t* elem) 
    elem->value = strtod(value, NULL);

}



void *get_vecd(char *value, int *elems)

void get_vecd(char *value, rsvp_var_t* var)

{

    char *begin = value, *token;

    int elems_count = 0;

    rsvp_vecd_elem_t *vecd = NULL;



    printf("VECD: %s\n", value);



    while (*value != '\0') {

        if (*value == '=')

            elems_count++;

        value++;

    char *token, delimiter = '=';

    var->len = count_tokens(value, delimiter);

    var->value = (rsvp_vecd_elem_t*)malloc(sizeof(rsvp_vecd_elem_t) * var->len);

    rsvp_vecd_elem_t* begin = (rsvp_vecd_elem_t*)var->value;



    delimiter = ',';

    token = strtok(value, &delimiter);

    for (int i = 0; i < var->len; i++) {

        get_vecd_elem(token, begin++);

        token = strtok(NULL, &delimiter);

    }

    value = begin;



    printf("Vecd count: %d\n", elems_count);

}



    vecd = (rsvp_vecd_elem_t*)malloc(sizeof(rsvp_vecd_elem_t) * elems_count);

    token = strtok(value, &delimiter_vecd);

    for (int i = 0; i < elems_count; i++) {

        get_vecd_elem(token, vecd++);

        strtok(NULL, &delimiter_vecd);

rsvp_vecd_elem_t* rsvp_var_get_vecd_elem(rsvp_var_t* var, int index)

{

    if (index >= var->len) {

        return NULL;

    }



    *elems = elems_count;

    return vecd;

    return (rsvp_vecd_elem_t*)var->value + index;

}



void process_args(char *arg, rsvp_var_t* var)
@@ -78,8 +86,6 @@ void process_args(char *arg, rsvp_var_t* var) 
    char *value = NULL;

    int index = 0, type_start = 0;



    printf("ARG: %s\n", arg);



    // Search for the variable name

    while ((*arg != '\0') && (value == NULL))  {
@@ -119,8 +125,6 @@ void process_args(char *arg, rsvp_var_t* var) 
        arg++;

    }



    printf("Value: %s\n", value);



    switch (var->type) {



        case INT:
@@ -153,8 +157,10 @@ void process_args(char *arg, rsvp_var_t* var) 
        }



        case VECD:

            get_vecd(value, &var->len);

        {

            get_vecd(++value, var);

            break;

        }



        case VECS:
@@ -174,17 +180,22 @@ void process_args(char *arg, rsvp_var_t* var) 


}



rsvp_data_t *rsvp_parse_data(char* data)

rsvp_data_t *rsvp_data_parse(char* data)

{

    char *token;

    rsvp_var_t *current_var;

    char **args;

    char delimiter = ';';

    size_t index = 0;

    rsvp_data_t *rsvp_data = (rsvp_data_t*)malloc(sizeof(rsvp_data_t));



    memset(rsvp_data, 0, sizeof(rsvp_data_t));

    rsvp_data->args_count = count_tokens(data, delimiter);

    args = (char**)malloc(rsvp_data->args_count * sizeof(char*));



    // Get command string

    token = strtok(data, &delimiter);

    rsvp_data->cmd = (char*)malloc(strlen(token) + 1);

    memcpy(rsvp_data->cmd, token, strlen(token) + 1);

    rsvp_data->cmd = (char*)malloc(strlen(token));

    memcpy(rsvp_data->cmd, token, strlen(token));



    // Process args

    while (token != NULL) {
@@ -197,16 +208,20 @@ rsvp_data_t *rsvp_parse_data(char* data) 
#ifdef DEBUG

        printf("*** DBG *** token[%d]: %s\n", rsvp_data->args_count, token);

#endif

        rsvp_data->args_count++;

        current_var = (rsvp_var_t*)malloc(sizeof(rsvp_var_t));

        rsvp_data->args = (rsvp_var_t*)realloc(rsvp_data->args, rsvp_data->args_count * sizeof(rsvp_var_t));

        process_args(token, &rsvp_data->args[rsvp_data->args_count - 1]);

        args[index] = (char*)malloc(strlen(token));

        memcpy(args[index++], token, strlen(token));

    }



    rsvp_data->args = (rsvp_var_t*)malloc(rsvp_data->args_count * sizeof(rsvp_var_t));



#ifdef DEBUG

    rsvp_data_print(rsvp_data);

#endif



    for(int i = 0; i < rsvp_data->args_count; i++) {

        process_args(args[i], &rsvp_data->args[i]);

    }



    return rsvp_data;

}
@@ -228,6 +243,16 @@ void rsvp_var_print(rsvp_var_t *var) 
        printf("%d\n", *(int*)var->value);

        break;

    

    case VECD:

        printf("[");

        for (int i = 0; i < var->len; i++) {

            rsvp_vecd_elem_t* elem = rsvp_var_get_vecd_elem(var, i);

            printf("%s=%f,", elem->name, elem->value);

            elem++;

        }

        printf("]\n");

        break;



    default:

        printf("%s\n", (char*)var->value);

        break;
@@ -255,5 +280,86 @@ void rsvp_data_free(rsvp_data_t *data) 
void rsvp_var_free(rsvp_var_t *var) 

{

    free(var->name);



    switch (var->type)

    {

    case VECD:

        for (int i = 0; i < var->len; i++) {

            rsvp_vecd_elem_t* elem = rsvp_var_get_vecd_elem(var, i);

            free(elem->name);

            elem++;

        }

        break;

    

    default:

        free(var->value);

        break;

    }

}



rsvp_var_t* rsvp_var_init(char *name)

{

    rsvp_var_t *var = (rsvp_var_t*)malloc(sizeof(rsvp_var_t));

    memset(var, 0, sizeof(rsvp_var_t));

    var->name = (char*)malloc(strlen(name));

    memcpy(var->name, name, strlen(name));



    return var;

}



rsvp_var_t* rsvp_var_create_int(char *name, int value)

{

    rsvp_var_t *var = rsvp_var_init(name);

    var->type = INT;

    var->value = malloc(sizeof(int));

    memcpy(var->value, &value, sizeof(int));



    return var;

}



rsvp_var_t* rsvp_var_create_double(char *name, double value)

{

    rsvp_var_t *var = rsvp_var_init(name);

    var->type = DBL;

    var->value = malloc(sizeof(double));

    memcpy(var->value, &value, sizeof(double));



    return var;

}



rsvp_var_t* rsvp_var_create_bool(char *name, int value)

{

    rsvp_var_t *var = rsvp_var_create_int(name, value);

    var->type = BOOL;



    return var;

}



rsvp_var_t* rsvp_var_create_string(char *name, char* value)

{

    rsvp_var_t *var = rsvp_var_init(name);

    var->type = STR;

    var->value = malloc(strlen(value));

    memcpy(var->value, &value, strlen(value));



    return var;

}



rsvp_var_t* rsvp_var_create_vecd(char *name, rsvp_vecd_elem_t *elem, unsigned int count)

{

    rsvp_var_t *var = rsvp_var_init(name);

    var->type = VECD;

    var->value = malloc(count * sizeof(rsvp_vecd_elem_t));

    var->len = count;

    

    for (int i = 0; i < count; i++) {

        // rsvp_vecd_elem_t *elem = rsvp_var_get_vecd_elem(var, i);

        // elem->name = (char*)malloc(strlen(names));

        // memcpy(elem->name, names, strlen(names));

        // names += strlen(names);

        // elem->value = values[i];

    }



    return var;



}
 
 No newline at end of file

src/rsvp.h

+16 −3
Original line number Diff line number Diff line
@@ -27,6 +27,11 @@ struct rsvp_vecd_elem { 
};

typedef struct rsvp_vecd_elem rsvp_vecd_elem_t;



struct rsvp_vecs_elem {

    char *value;

};

typedef struct rsvp_vecs_elem rsvp_vecs_elem_t;



struct rsvp_var {

    char *name;

    int len;
@@ -42,12 +47,20 @@ struct rsvp_data { 
};

typedef struct rsvp_data rsvp_data_t;



extern rsvp_data_t* rsvp_parse_data(char* data);



extern rsvp_data_t* rsvp_data_parse(char* data);

extern char* rsvp_data_to_string(rsvp_data_t* data);

extern rsvp_data_t* rsvp_data_build(char *cmd, ...);

extern void rsvp_data_print(rsvp_data_t* data);

extern void rsvp_data_free(rsvp_data_t *data);



extern rsvp_var_t* rsvp_var_create(char *name, RSVP_TYPE type, void* value);

// Variable creation

extern rsvp_var_t* rsvp_var_create_int(char *name, int value);

extern rsvp_var_t* rsvp_var_create_double(char *name, double value);

extern rsvp_var_t* rsvp_var_create_bool(char *name, int value);

extern rsvp_var_t* rsvp_var_create_string(char *name, char* value);

extern rsvp_var_t* rsvp_var_create_vecd(char *name, rsvp_vecd_elem_t *elem, unsigned int count);



extern rsvp_vecd_elem_t* rsvp_var_get_vecd_elem(rsvp_var_t* var, int index);

extern void rsvp_var_print(rsvp_var_t *var);

extern void rsvp_var_free(rsvp_var_t *var);

src/rsvp.hpp

0 → 100644
+28 −0
Original line number Diff line number Diff line 
#pragma once



#include <vector>

#include <string>



extern "C" {

#include "rsvp.h"

}



class RSVP {



    private:



    public:



    RSVP()

    {

        

    }

    

    static RSVP parse_data(std::string data)

    {

        rsvp_data_t *_data = rsvp_data_parse((char*)data.c_str());





    }



};
 
 No newline at end of file