libsmartcols: Export internally used types to API

We anticipate a need for improved interaction between applications and
the library in certain scenarios. For instance, when a table contains
strings that cannot be readily converted from strings to numbers
(e.g., strings like "15.3MiB") but the application possesses data in a
more suitable format.

Signed-off-by: Karel Zak <kzak@redhat.com>

diff --git a/libsmartcols/src/filter-expr.c b/libsmartcols/src/filter-expr.c
index ddd64370386926d3ef212203da914f96ae72596f..d3229d00eb843a2bc51a6cef161a005188de3984 100644 (file)
--- a/libsmartcols/src/filter-expr.c
+++ b/libsmartcols/src/filter-expr.c
@@ -95,7 +95,7 @@ void filter_dump_expr(struct ul_jsonwrt *json, struct filter_expr *n)
 
 static int cast_node(struct libscols_filter *fltr,
                     struct libscols_line *ln,
-                    enum filter_data type,
+                    int type,
                     struct filter_node *n,
                     struct filter_param **result)
 {
@@ -110,7 +110,7 @@ static int cast_node(struct libscols_filter *fltr,
                if (rc)
                        return rc;
                x = status != 0 ? true : false;
-               pr = filter_new_param(NULL, F_DATA_BOOLEAN, 0, (void *) &x);
+               pr = filter_new_param(NULL, SCOLS_DATA_BOOLEAN, 0, (void *) &x);
                if (!pr)
                        return -ENOMEM;
                rc = filter_cast_param(fltr, ln, type, (struct filter_param *) pr, result);
@@ -126,21 +126,21 @@ static int cast_node(struct libscols_filter *fltr,
        return rc;
 }
 
-static enum filter_data node_get_datatype(struct filter_node *n)
+static int node_get_datatype(struct filter_node *n)
 {
        switch (n->type) {
        case F_NODE_EXPR:
-               return F_DATA_BOOLEAN;
+               return SCOLS_DATA_BOOLEAN;
        case F_NODE_PARAM:
                return filter_param_get_datatype((struct filter_param *) n);
        }
-       return F_DATA_NONE;
+       return SCOLS_DATA_NONE;
 }
 
-static enum filter_data guess_expr_datatype(struct filter_expr *n)
+static int guess_expr_datatype(struct filter_expr *n)
 {
-       enum filter_data type;
-       enum filter_data l = node_get_datatype(n->left),
+       int type;
+       int l = node_get_datatype(n->left),
                         r = node_get_datatype(n->right);
 
        if (l == r)
@@ -171,7 +171,7 @@ int filter_eval_expr(struct libscols_filter *fltr, struct libscols_line *ln,
        int rc = 0;
        struct filter_param *l = NULL, *r = NULL;
        enum filter_etype oper = n->type;
-       enum filter_data type;
+       int type;
 
        /* logical operators */
        switch (oper) {

diff --git a/libsmartcols/src/filter-param.c b/libsmartcols/src/filter-param.c
index 669dbc82559a43e47ba6ee88454d1f30bf97566d..1bcfd8988b5f826749ad37c03e239d9293d9dd7d 100644 (file)
--- a/libsmartcols/src/filter-param.c
+++ b/libsmartcols/src/filter-param.c
@@ -8,7 +8,7 @@
 
 struct filter_param {
        struct filter_node node;
-       enum filter_data type;
+       int type;
        enum filter_holder holder;
 
        union {
@@ -26,27 +26,27 @@ struct filter_param {
        unsigned int has_value :1;
 };
 
-static int cast_param(enum filter_data type, struct filter_param *n);
+static int cast_param(int type, struct filter_param *n);
 
-static inline const char *datatype2str(enum filter_data type)
+static inline const char *datatype2str(int type)
 {
        static const char *types[] = {
-               [F_DATA_NONE] = "none",
-               [F_DATA_STRING] = "string",
-               [F_DATA_NUMBER] = "number",
-               [F_DATA_FLOAT] = "float",
-               [F_DATA_BOOLEAN] = "boolean"
+               [SCOLS_DATA_NONE] = "none",
+               [SCOLS_DATA_STRING] = "string",
+               [SCOLS_DATA_U64] = "u64",
+               [SCOLS_DATA_FLOAT] = "float",
+               [SCOLS_DATA_BOOLEAN] = "boolean"
        };
        return types[type];
 }
-static int param_set_data(struct filter_param *n, enum filter_data type, const void *data)
+static int param_set_data(struct filter_param *n, int type, const void *data)
 {
        const char *p;
 
        /*DBG(FPARAM, ul_debugobj(n, " set %s data", datatype2str(type)));*/
 
        switch (type) {
-       case F_DATA_STRING:
+       case SCOLS_DATA_STRING:
                p = data;
                if (p && *p == '"') {
                        /* remove quotation marks */
@@ -60,13 +60,13 @@ static int param_set_data(struct filter_param *n, enum filter_data type, const v
                if (data && !n->val.str)
                        return -ENOMEM;
                break;
-       case F_DATA_NUMBER:
+       case SCOLS_DATA_U64:
                n->val.num = data ? *((unsigned long long *) data) : 0;
                break;
-       case F_DATA_FLOAT:
+       case SCOLS_DATA_FLOAT:
                n->val.fnum = data ? *((long double *) data) : 0;
                break;
-       case F_DATA_BOOLEAN:
+       case SCOLS_DATA_BOOLEAN:
                n->val.boolean = data ? (*((bool *) data) == 0 ? 0 : 1) : 0;
                break;
        default:
@@ -80,7 +80,7 @@ static int param_set_data(struct filter_param *n, enum filter_data type, const v
 
 struct filter_node *filter_new_param(
                struct libscols_filter *fltr,
-               enum filter_data type,
+               int type,
                enum filter_holder holder,
                void *data)
 {
@@ -143,7 +143,7 @@ static struct filter_param *copy_param(struct filter_param *n)
 
 static void param_reset_data(struct filter_param *n)
 {
-       if (n->type == F_DATA_STRING)
+       if (n->type == SCOLS_DATA_STRING)
                free(n->val.str);
 
        memset(&n->val, 0, sizeof(n->val));
@@ -165,9 +165,9 @@ void filter_free_param(struct filter_param *n)
        free(n);
 }
 
-enum filter_data filter_param_get_datatype(struct filter_param *n)
+int filter_param_get_datatype(struct filter_param *n)
 {
-       return n ? n->type : F_DATA_NONE;
+       return n ? n->type : SCOLS_DATA_NONE;
 }
 
 int is_filter_holder_node(struct filter_node *n)
@@ -182,24 +182,19 @@ void filter_dump_param(struct ul_jsonwrt *json, struct filter_param *n)
 
        if (!n->has_value) {
                ul_jsonwrt_value_boolean(json, "has_value", false);
-               ul_jsonwrt_value_s(json, "type",
-                               n->type == F_DATA_STRING ? "string" :
-                               n->type == F_DATA_NUMBER ? "number" :
-                               n->type == F_DATA_FLOAT  ? "float" :
-                               n->type == F_DATA_BOOLEAN ? "bool" :
-                               "unknown");
+               ul_jsonwrt_value_s(json, "type", datatype2str(n->type));
        } else {
                switch (n->type) {
-               case F_DATA_STRING:
+               case SCOLS_DATA_STRING:
                        ul_jsonwrt_value_s(json, "string", n->val.str);
                        break;
-               case F_DATA_NUMBER:
+               case SCOLS_DATA_U64:
                        ul_jsonwrt_value_u64(json, "number", n->val.num);
                        break;
-               case F_DATA_FLOAT:
+               case SCOLS_DATA_FLOAT:
                        ul_jsonwrt_value_double(json, "float", n->val.fnum);
                        break;
-               case F_DATA_BOOLEAN:
+               case SCOLS_DATA_BOOLEAN:
                        ul_jsonwrt_value_boolean(json, "bool", n->val.boolean);
                        break;
                default:
@@ -225,22 +220,22 @@ int filter_param_reset_holder(struct filter_param *n)
 
        param_reset_data(n);
 
-       if (n->type != F_DATA_NONE)
+       if (n->type != SCOLS_DATA_NONE)
                return 0; /* already set */
 
        switch (n->col->json_type) {
        case SCOLS_JSON_NUMBER:
-               n->type = F_DATA_NUMBER;
+               n->type = SCOLS_DATA_U64;
                break;
        case SCOLS_JSON_BOOLEAN:
-               n->type = F_DATA_BOOLEAN;
+               n->type = SCOLS_DATA_BOOLEAN;
                break;
        case SCOLS_JSON_FLOAT:
-               n->type = F_DATA_FLOAT;
+               n->type = SCOLS_DATA_FLOAT;
                break;
        case SCOLS_JSON_STRING:
        default:
-               n->type = F_DATA_STRING;
+               n->type = SCOLS_DATA_STRING;
                break;
        }
 
@@ -252,7 +247,7 @@ static int fetch_holder_data(struct libscols_filter *fltr __attribute__((__unuse
                        struct filter_param *n, struct libscols_line *ln)
 {
        const char *data;
-       enum filter_data type = n->type;
+       int type = n->type;
        int rc = 0;
 
        if (n->has_value || n->holder != F_HOLDER_COLUMN)
@@ -271,10 +266,10 @@ static int fetch_holder_data(struct libscols_filter *fltr __attribute__((__unuse
 
        /* read column data, use it as string */
        data = scols_line_get_column_data(ln, n->col);
-       rc = param_set_data(n, F_DATA_STRING, data);
+       rc = param_set_data(n, SCOLS_DATA_STRING, data);
 
        /* cast to the wanted type */
-       if (rc == 0 && type != F_DATA_NONE)
+       if (rc == 0 && type != SCOLS_DATA_NONE)
                rc = cast_param(type, n);
        return rc;
 }
@@ -295,16 +290,16 @@ int filter_eval_param(struct libscols_filter *fltr,
        }
 
        switch (n->type) {
-       case F_DATA_STRING:
+       case SCOLS_DATA_STRING:
                *status = n->val.str != NULL && *n->val.str != '\0';
                break;
-       case F_DATA_NUMBER:
+       case SCOLS_DATA_U64:
                *status = n->val.num != 0;
                break;
-       case F_DATA_FLOAT:
+       case SCOLS_DATA_FLOAT:
                *status = n->val.fnum != 0.0;
                break;
-       case F_DATA_BOOLEAN:
+       case SCOLS_DATA_BOOLEAN:
                *status = n->val.boolean != false;
                break;
        default:
@@ -332,7 +327,7 @@ int filter_count_param(struct libscols_filter *fltr,
        if (ct->param) {
                int rc;
 
-               ct->param->type = F_DATA_NUMBER;
+               ct->param->type = SCOLS_DATA_U64;
                rc = fetch_holder_data(fltr, ct->param, ln);
                if (rc)
                        return rc;
@@ -416,7 +411,7 @@ static int string_opers(enum filter_etype oper, struct filter_param *l,
        return 0;
 }
 
-static int number_opers(enum filter_etype oper, struct filter_param *l,
+static int u64_opers(enum filter_etype oper, struct filter_param *l,
                             struct filter_param *r, int *status)
 {
        switch (oper) {
@@ -516,16 +511,16 @@ int filter_compare_params(struct libscols_filter *fltr __attribute__((__unused__
        *status = 0;
 
        switch (l->type) {
-       case F_DATA_STRING:
+       case SCOLS_DATA_STRING:
                rc = string_opers(oper, l, r, status);
                break;
-       case F_DATA_NUMBER:
-               rc = number_opers(oper, l, r, status);
+       case SCOLS_DATA_U64:
+               rc = u64_opers(oper, l, r, status);
                break;
-       case F_DATA_FLOAT:
+       case SCOLS_DATA_FLOAT:
                rc = float_opers(oper, l, r, status);
                break;
-       case F_DATA_BOOLEAN:
+       case SCOLS_DATA_BOOLEAN:
                rc = bool_opers(oper, l, r, status);
                break;
        default:
@@ -536,17 +531,17 @@ int filter_compare_params(struct libscols_filter *fltr __attribute__((__unused__
        return rc;
 }
 
-static int string_cast(enum filter_data type, struct filter_param *n)
+static int string_cast(int type, struct filter_param *n)
 {
        char *str = n->val.str;
 
-       if (type == F_DATA_STRING)
+       if (type == SCOLS_DATA_STRING)
                return 0;
 
        n->val.str = NULL;
 
        switch (type) {
-       case F_DATA_NUMBER:
+       case SCOLS_DATA_U64:
        {
                uint64_t num = 0;
                if (str) {
@@ -557,7 +552,7 @@ static int string_cast(enum filter_data type, struct filter_param *n)
                n->val.num = num;
                break;
        }
-       case F_DATA_FLOAT:
+       case SCOLS_DATA_FLOAT:
        {
                long double num = 0;
                if (str) {
@@ -568,7 +563,7 @@ static int string_cast(enum filter_data type, struct filter_param *n)
                n->val.fnum = num;
                break;
        }
-       case F_DATA_BOOLEAN:
+       case SCOLS_DATA_BOOLEAN:
        {
                bool x = (!str || !*str
                               || strcasecmp(str, "false") == 0
@@ -584,22 +579,22 @@ static int string_cast(enum filter_data type, struct filter_param *n)
        return 0;
 }
 
-static int number_cast(enum filter_data type, struct filter_param *n)
+static int u64_cast(int type, struct filter_param *n)
 {
        unsigned long long num = n->val.num;
 
        switch (type) {
-       case F_DATA_STRING:
+       case SCOLS_DATA_STRING:
                n->val.str = NULL;
                if (asprintf(&n->val.str, "%llu", num) <= 0)
                        return -ENOMEM;
                break;
-       case F_DATA_NUMBER:
+       case SCOLS_DATA_U64:
                break;
-       case F_DATA_FLOAT:
+       case SCOLS_DATA_FLOAT:
                n->val.fnum = num;
                break;
-       case F_DATA_BOOLEAN:
+       case SCOLS_DATA_BOOLEAN:
                n->val.boolean = num > 0 ? true : false;
                break;
        default:
@@ -608,22 +603,22 @@ static int number_cast(enum filter_data type, struct filter_param *n)
        return 0;
 }
 
-static int float_cast(enum filter_data type, struct filter_param *n)
+static int float_cast(int type, struct filter_param *n)
 {
        long double fnum = n->val.fnum;
 
        switch (type) {
-       case F_DATA_STRING:
+       case SCOLS_DATA_STRING:
                n->val.str = NULL;
                if (asprintf(&n->val.str, "%Lg", fnum) <= 0)
                        return -ENOMEM;
                break;
-       case F_DATA_NUMBER:
+       case SCOLS_DATA_U64:
                n->val.num = fnum;
                break;
-       case F_DATA_FLOAT:
+       case SCOLS_DATA_FLOAT:
                break;;
-       case F_DATA_BOOLEAN:
+       case SCOLS_DATA_BOOLEAN:
                n->val.boolean = fnum > 0.0 ? true : false;
                break;
        default:
@@ -632,23 +627,23 @@ static int float_cast(enum filter_data type, struct filter_param *n)
        return 0;
 }
 
-static int bool_cast(enum filter_data type, struct filter_param *n)
+static int bool_cast(int type, struct filter_param *n)
 {
        bool x = n->val.boolean;
 
        switch (type) {
-       case F_DATA_STRING:
+       case SCOLS_DATA_STRING:
                n->val.str = NULL;
                if (asprintf(&n->val.str, "%s", x ? "true" : "false") <= 0)
                        return -ENOMEM;
                break;
-       case F_DATA_NUMBER:
+       case SCOLS_DATA_U64:
                n->val.num = x ? 1 : 0;
                break;
-       case F_DATA_FLOAT:
+       case SCOLS_DATA_FLOAT:
                n->val.fnum = x ? 1.0 : 0.0;
                break;
-       case F_DATA_BOOLEAN:
+       case SCOLS_DATA_BOOLEAN:
                break;;
        default:
                return -EINVAL;
@@ -656,30 +651,30 @@ static int bool_cast(enum filter_data type, struct filter_param *n)
        return 0;
 }
 
-static int cast_param(enum filter_data type, struct filter_param *n)
+static int cast_param(int type, struct filter_param *n)
 {
        int rc;
-       enum filter_data orgtype = n->type;
+       int orgtype = n->type;
 
        if (type == orgtype)
                return 0;
 
-       if (orgtype == F_DATA_STRING)
+       if (orgtype == SCOLS_DATA_STRING)
                DBG(FPARAM, ul_debugobj(n, " casting \"%s\" to %s", n->val.str, datatype2str(type)));
        else
                DBG(FPARAM, ul_debugobj(n, " casting %s to %s", datatype2str(orgtype), datatype2str(type)));
 
        switch (orgtype) {
-       case F_DATA_STRING:
+       case SCOLS_DATA_STRING:
                rc = string_cast(type, n);
                break;
-       case F_DATA_NUMBER:
-               rc = number_cast(type, n);
+       case SCOLS_DATA_U64:
+               rc = u64_cast(type, n);
                break;
-       case F_DATA_FLOAT:
+       case SCOLS_DATA_FLOAT:
                rc = float_cast(type, n);
                break;
-       case F_DATA_BOOLEAN:
+       case SCOLS_DATA_BOOLEAN:
                rc = bool_cast(type, n);
                break;
        default:
@@ -697,12 +692,12 @@ static int cast_param(enum filter_data type, struct filter_param *n)
 
 int filter_cast_param(struct libscols_filter *fltr,
                      struct libscols_line *ln,
-                     enum filter_data type,
+                     int type,
                      struct filter_param *n,
                      struct filter_param **result)
 {
        int rc;
-       enum filter_data orgtype = n->type;
+       int orgtype = n->type;
 
        rc = fetch_holder_data(fltr, n, ln);
        if (rc)

diff --git a/libsmartcols/src/filter-parser.y b/libsmartcols/src/filter-parser.y
index c62aa151597ef143a41249098e983389c47e6597..e1fa48ce03cfcd05efcd71b9cb9c60772dd2cdeb 100644 (file)
--- a/libsmartcols/src/filter-parser.y
+++ b/libsmartcols/src/filter-parser.y
@@ -85,17 +85,17 @@ expr:
 ;
 
 param:
-       T_NUMBER        { $$ = filter_new_param(fltr, F_DATA_NUMBER, 0, (void *) (&$1)); }
-       | T_FLOAT       { $$ = filter_new_param(fltr, F_DATA_FLOAT, 0, (void *) (&$1)); }
-       | T_NAME        { $$ = filter_new_param(fltr, F_DATA_NONE, F_HOLDER_COLUMN, (void *) $1); }
-       | T_STRING      { $$ = filter_new_param(fltr, F_DATA_STRING, 0, (void *) $1); }
+       T_NUMBER        { $$ = filter_new_param(fltr, SCOLS_DATA_U64, 0, (void *) (&$1)); }
+       | T_FLOAT       { $$ = filter_new_param(fltr, SCOLS_DATA_FLOAT, 0, (void *) (&$1)); }
+       | T_NAME        { $$ = filter_new_param(fltr, SCOLS_DATA_NONE, F_HOLDER_COLUMN, (void *) $1); }
+       | T_STRING      { $$ = filter_new_param(fltr, SCOLS_DATA_STRING, 0, (void *) $1); }
        | T_TRUE        {
                bool x = true;
-               $$ = filter_new_param(fltr, F_DATA_BOOLEAN, 0, (void *) &x);
+               $$ = filter_new_param(fltr, SCOLS_DATA_BOOLEAN, 0, (void *) &x);
        }
        | T_FALSE       {
                bool x = false;
-               $$ = filter_new_param(fltr, F_DATA_BOOLEAN, 0, (void *) &x);
+               $$ = filter_new_param(fltr, SCOLS_DATA_BOOLEAN, 0, (void *) &x);
        }
 
 ;

diff --git a/libsmartcols/src/filter.c b/libsmartcols/src/filter.c
index df59f6fa56f7aabe066e2b69409d452860ba12ca..ef28e6fde47d0cbe479060be27c15ff42f162317 100644 (file)
--- a/libsmartcols/src/filter.c
+++ b/libsmartcols/src/filter.c
@@ -280,7 +280,7 @@ int scols_counter_set_param(struct libscols_counter *ct, const char *name)
        }
        if (name) {
                ct->param = (struct filter_param *)
-                               filter_new_param(ct->filter, F_DATA_NUMBER,
+                               filter_new_param(ct->filter, SCOLS_DATA_U64,
                                             F_HOLDER_COLUMN, (void *) name);
                if (!ct->param)
                        return -ENOMEM;

diff --git a/libsmartcols/src/libsmartcols.h.in b/libsmartcols/src/libsmartcols.h.in
index ab585da2233c60689a94f4153ab8a3c45129a9c9..509fe7648a1771beb883ee3cb4d621a6bf9d68df 100644 (file)
--- a/libsmartcols/src/libsmartcols.h.in
+++ b/libsmartcols/src/libsmartcols.h.in
@@ -123,6 +123,17 @@ enum {
        SCOLS_JSON_FLOAT     = 6
 };
 
+/*
+ * Types used by filters and counters
+ */
+enum {
+       SCOLS_DATA_NONE = 0,    /* default */
+       SCOLS_DATA_U64,         /* uint64_t */
+       SCOLS_DATA_BOOLEAN,     /* 0 or 1 */
+       SCOLS_DATA_FLOAT,       /* long double */
+       SCOLS_DATA_STRING
+};
+
 /*
  * Cell flags, see scols_cell_set_flags() before use
  */

diff --git a/libsmartcols/src/smartcolsP.h b/libsmartcols/src/smartcolsP.h
index 0af4021c83870f0a8183e0255065cbea0d150204..fd4dc4134360a652ac496fa5ba428ce7ae3575c7 100644 (file)
--- a/libsmartcols/src/smartcolsP.h
+++ b/libsmartcols/src/smartcolsP.h
@@ -484,15 +484,6 @@ static inline int has_group_children(struct libscols_line *ln)
 /*
  * Filter stuff
  */
-
-enum filter_data {
-       F_DATA_NONE,
-       F_DATA_STRING,
-       F_DATA_NUMBER,
-       F_DATA_FLOAT,
-       F_DATA_BOOLEAN
-};
-
 enum filter_holder {
        F_HOLDER_NONE,
        F_HOLDER_COLUMN         /* column name */
@@ -572,7 +563,7 @@ int filter_eval_param(struct libscols_filter *fltr, struct libscols_line *ln,
                        struct filter_param *n, int *status);
 void filter_free_param(struct filter_param *n);
 int filter_param_reset_holder(struct filter_param *n);
-enum filter_data filter_param_get_datatype(struct filter_param *n);
+int filter_param_get_datatype(struct filter_param *n);
 
 int filter_next_param(struct libscols_filter *fltr,
                         struct libscols_iter *itr, struct filter_param **prm);
@@ -584,7 +575,7 @@ int filter_compare_params(struct libscols_filter *fltr,
                           int *status);
 int filter_cast_param(struct libscols_filter *fltr,
                       struct libscols_line *ln,
-                      enum filter_data type,
+                      int type,
                       struct filter_param *n,
                       struct filter_param **result);
 
@@ -602,7 +593,7 @@ int filter_eval_expr(struct libscols_filter *fltr, struct libscols_line *ln,
 
 /* required by parser */
 struct filter_node *filter_new_param(struct libscols_filter *filter,
-                                 enum filter_data type,
+                                 int type,
                                 enum filter_holder holder,
                                 void *data);
 struct filter_node *filter_new_expr(struct libscols_filter *filter,