+/**
+ * @fn LttvSimpleExpression* lttv_simple_expression_new()
+ *
+ * Constructor for LttvSimpleExpression
+ * @return pointer to new LttvSimpleExpression
+ */
+LttvSimpleExpression*
+lttv_simple_expression_new() {
+
+ LttvSimpleExpression* se = g_new(LttvSimpleExpression,1);
+
+ se->field = LTTV_FILTER_UNDEFINED;
+ se->op = NULL;
+ se->offset = 0;
+
+ return se;
+}
+
+/**
+ * @fn gboolean lttv_simple_expression_assign_field(GPtrArray*,LttvSimpleExpression*)
+ *
+ * Parse through filtering field hierarchy as specified
+ * by user. This function compares each value to
+ * predetermined quarks
+ * @param fp The field path list
+ * @param se current simple expression
+ * @return success/failure of operation
+ */
+gboolean
+lttv_simple_expression_assign_field(GPtrArray* fp, LttvSimpleExpression* se) {
+
+ GString* f = NULL;
+
+ if(fp->len < 2) return FALSE;
+ g_assert((f=g_ptr_array_remove_index(fp,0)));
+
+ /*
+ * Parse through the specified
+ * hardcoded fields.
+ *
+ * Take note however that the
+ * 'event' subfields might change
+ * depending on values specified
+ * in core.xml file. Hence, if
+ * none of the subfields in the
+ * array match the hardcoded
+ * subfields, it will be considered
+ * as a dynamic field
+ */
+ if(!g_strcasecmp(f->str,"trace") ) {
+ /*
+ * Possible values:
+ * trace.name
+ */
+ g_string_free(f,TRUE);
+ f=g_ptr_array_remove_index(fp,0);
+ if(!g_strcasecmp(f->str,"name")) {
+ se->field = LTTV_FILTER_TRACE_NAME;
+ }
+ } else if(!g_strcasecmp(f->str,"traceset") ) {
+ /*
+ * FIXME: not yet implemented !
+ */
+ } else if(!g_strcasecmp(f->str,"tracefile") ) {
+ /*
+ * Possible values:
+ * tracefile.name
+ */
+ g_string_free(f,TRUE);
+ f=g_ptr_array_remove_index(fp,0);
+ if(!g_strcasecmp(f->str,"name")) {
+ se->field = LTTV_FILTER_TRACEFILE_NAME;
+ }
+ } else if(!g_strcasecmp(f->str,"state") ) {
+ /*
+ * Possible values:
+ * state.pid
+ * state.ppid
+ * state.creation_time
+ * state.insertion_time
+ * state.process_name
+ * state.thread_brand
+ * state.execution_mode
+ * state.execution_submode
+ * state.process_status
+ * state.cpu
+ */
+ g_string_free(f,TRUE);
+ f=g_ptr_array_remove_index(fp,0);
+ if(!g_strcasecmp(f->str,"pid") ) {
+ se->field = LTTV_FILTER_STATE_PID;
+ }
+ else if(!g_strcasecmp(f->str,"ppid") ) {
+ se->field = LTTV_FILTER_STATE_PPID;
+ }
+ else if(!g_strcasecmp(f->str,"creation_time") ) {
+ se->field = LTTV_FILTER_STATE_CT;
+ }
+ else if(!g_strcasecmp(f->str,"insertion_time") ) {
+ se->field = LTTV_FILTER_STATE_IT;
+ }
+ else if(!g_strcasecmp(f->str,"process_name") ) {
+ se->field = LTTV_FILTER_STATE_P_NAME;
+ }
+ else if(!g_strcasecmp(f->str,"thread_brand") ) {
+ se->field = LTTV_FILTER_STATE_T_BRAND;
+ }
+ else if(!g_strcasecmp(f->str,"execution_mode") ) {
+ se->field = LTTV_FILTER_STATE_EX_MODE;
+ }
+ else if(!g_strcasecmp(f->str,"execution_submode") ) {
+ se->field = LTTV_FILTER_STATE_EX_SUBMODE;
+ }
+ else if(!g_strcasecmp(f->str,"process_status") ) {
+ se->field = LTTV_FILTER_STATE_P_STATUS;
+ }
+ else if(!g_strcasecmp(f->str,"cpu") ) {
+ se->field = LTTV_FILTER_STATE_CPU;
+ }
+ } else if(!g_strcasecmp(f->str,"event") ) {
+ /*
+ * Possible values:
+ * event.name
+ * event.category
+ * event.time
+ * event.tsc
+ * event.target_pid
+ * event.field
+ */
+ g_string_free(f,TRUE);
+ f=g_ptr_array_remove_index(fp,0);
+ if(!g_strcasecmp(f->str,"name") ) {
+ se->field = LTTV_FILTER_EVENT_NAME;
+ }
+ else if(!g_strcasecmp(f->str,"facility") ) {
+ se->field = LTTV_FILTER_EVENT_FACILITY;
+ }
+ else if(!g_strcasecmp(f->str,"category") ) {
+ /*
+ * FIXME: Category not yet functional in lttv
+ */
+ se->field = LTTV_FILTER_EVENT_CATEGORY;
+ }
+ else if(!g_strcasecmp(f->str,"time") ) {
+ se->field = LTTV_FILTER_EVENT_TIME;
+ }
+ else if(!g_strcasecmp(f->str,"tsc") ) {
+ se->field = LTTV_FILTER_EVENT_TSC;
+ }
+ else if(!g_strcasecmp(f->str,"target_pid") ) {
+ se->field = LTTV_FILTER_EVENT_TARGET_PID;
+ }
+ else if(!g_strcasecmp(f->str,"field") ) {
+ se->field = LTTV_FILTER_EVENT_FIELD;
+ g_string_free(f,TRUE);
+ f=g_ptr_array_remove_index(fp,0);
+
+ } else {
+ g_string_free(f,TRUE);
+ f=g_ptr_array_remove_index(fp,0);
+ g_warning("Unknown event filter subtype %s", f->str);
+ }
+ } else {
+ g_string_free(f,TRUE);
+ f=g_ptr_array_remove_index(fp,0);
+
+ g_warning("Unrecognized field in filter string");
+ }
+
+ /* free memory for last string */
+ g_string_free(f,TRUE);
+
+ /* array should be empty */
+ g_assert(fp->len == 0);
+
+ if(se->field == LTTV_FILTER_UNDEFINED) {
+ g_warning("The specified field was not recognized !");
+ return FALSE;
+ }
+ return TRUE;
+}
+
+/**
+ * @fn gboolean lttv_simple_expression_assign_operator(LttvSimpleExpression*,LttvExpressionOp)
+ *
+ * Sets the function pointer for the current
+ * Simple Expression
+ * @param se current simple expression
+ * @param op current operator
+ * @return success/failure of operation
+ */
+gboolean
+lttv_simple_expression_assign_operator(LttvSimpleExpression* se, LttvExpressionOp op) {
+
+ switch(se->field) {
+ /*
+ * string
+ */
+ case LTTV_FILTER_TRACE_NAME:
+ case LTTV_FILTER_TRACEFILE_NAME:
+ case LTTV_FILTER_STATE_P_NAME:
+ case LTTV_FILTER_STATE_T_BRAND:
+ case LTTV_FILTER_EVENT_NAME:
+ case LTTV_FILTER_EVENT_FACILITY:
+ case LTTV_FILTER_STATE_EX_MODE:
+ case LTTV_FILTER_STATE_EX_SUBMODE:
+ case LTTV_FILTER_STATE_P_STATUS:
+ switch(op) {
+ case LTTV_FIELD_EQ:
+ se->op = lttv_apply_op_eq_quark;
+ break;
+ case LTTV_FIELD_NE:
+ se->op = lttv_apply_op_ne_quark;
+ break;
+ default:
+ g_warning("Error encountered in operator assignment = or != expected");
+ return FALSE;
+ }
+ break;
+ /*
+ * integer
+ */
+ case LTTV_FILTER_EVENT_TSC:
+ switch(op) {
+ case LTTV_FIELD_EQ:
+ se->op = lttv_apply_op_eq_uint64;
+ break;
+ case LTTV_FIELD_NE:
+ se->op = lttv_apply_op_ne_uint64;
+ break;
+ case LTTV_FIELD_LT:
+ se->op = lttv_apply_op_lt_uint64;
+ break;
+ case LTTV_FIELD_LE:
+ se->op = lttv_apply_op_le_uint64;
+ break;
+ case LTTV_FIELD_GT:
+ se->op = lttv_apply_op_gt_uint64;
+ break;
+ case LTTV_FIELD_GE:
+ se->op = lttv_apply_op_ge_uint64;
+ break;
+ default:
+ g_warning("Error encountered in operator assignment");
+ return FALSE;
+ }
+ break;
+ /*
+ * unsigned integers
+ */
+ case LTTV_FILTER_STATE_CPU:
+ case LTTV_FILTER_STATE_PID:
+ case LTTV_FILTER_STATE_PPID:
+ case LTTV_FILTER_EVENT_TARGET_PID:
+ switch(op) {
+ case LTTV_FIELD_EQ:
+ se->op = lttv_apply_op_eq_uint;
+ break;
+ case LTTV_FIELD_NE:
+ se->op = lttv_apply_op_ne_uint;
+ break;
+ case LTTV_FIELD_LT:
+ se->op = lttv_apply_op_lt_uint;
+ break;
+ case LTTV_FIELD_LE:
+ se->op = lttv_apply_op_le_uint;
+ break;
+ case LTTV_FIELD_GT:
+ se->op = lttv_apply_op_gt_uint;
+ break;
+ case LTTV_FIELD_GE:
+ se->op = lttv_apply_op_ge_uint;
+ break;
+ default:
+ g_warning("Error encountered in operator assignment");
+ return FALSE;
+ }
+ break;
+
+ /*
+ * Enums
+ * Entered as string, converted to enum
+ *
+ * can only be compared with 'equal' or 'not equal' operators
+ *
+ * unsigned int of 16 bits are used here since enums
+ * should not go over 2^16-1 values
+ */
+// case /*NOTHING*/:
+// switch(op) {
+// case LTTV_FIELD_EQ:
+// se->op = lttv_apply_op_eq_uint16;
+// break;
+// case LTTV_FIELD_NE:
+// se->op = lttv_apply_op_ne_uint16;
+// break;
+// default:
+// g_warning("Error encountered in operator assignment = or != expected");
+// return FALSE;
+// }
+// break;
+ /*
+ * Ltttime
+ */
+ case LTTV_FILTER_STATE_CT:
+ case LTTV_FILTER_STATE_IT:
+ case LTTV_FILTER_EVENT_TIME:
+ switch(op) {
+ case LTTV_FIELD_EQ:
+ se->op = lttv_apply_op_eq_ltttime;
+ break;
+ case LTTV_FIELD_NE:
+ se->op = lttv_apply_op_ne_ltttime;
+ break;
+ case LTTV_FIELD_LT:
+ se->op = lttv_apply_op_lt_ltttime;
+ break;
+ case LTTV_FIELD_LE:
+ se->op = lttv_apply_op_le_ltttime;
+ break;
+ case LTTV_FIELD_GT:
+ se->op = lttv_apply_op_gt_ltttime;
+ break;
+ case LTTV_FIELD_GE:
+ se->op = lttv_apply_op_ge_ltttime;
+ break;
+ default:
+ g_warning("Error encountered in operator assignment");
+ return FALSE;
+ }
+ break;
+ default:
+ g_warning("Error encountered in operator assignation ! Field type:%i",se->field);
+ return FALSE;
+ }
+
+ return TRUE;
+
+}
+
+/**
+ * @fn gboolean lttv_simple_expression_assign_value(LttvSimpleExpression*,char*)
+ *
+ * Assign the value field to the current LttvSimpleExpression
+ * @param se pointer to the current LttvSimpleExpression
+ * @param value string value for simple expression
+ */
+gboolean
+lttv_simple_expression_assign_value(LttvSimpleExpression* se, char* value) {
+
+ unsigned i;
+ gboolean is_double = FALSE;
+ LttTime t = ltt_time_zero;
+ GString* v;
+ guint string_len;
+
+ switch(se->field) {
+ /*
+ * Strings
+ * entered as strings, converted to Quarks
+ */
+ case LTTV_FILTER_TRACE_NAME:
+ case LTTV_FILTER_TRACEFILE_NAME:
+ case LTTV_FILTER_STATE_P_NAME:
+ case LTTV_FILTER_STATE_T_BRAND:
+ case LTTV_FILTER_EVENT_NAME:
+ case LTTV_FILTER_EVENT_FACILITY:
+ case LTTV_FILTER_STATE_EX_MODE:
+ case LTTV_FILTER_STATE_EX_SUBMODE:
+ case LTTV_FILTER_STATE_P_STATUS:
+ // se->value.v_string = value;
+ se->value.v_quark = g_quark_from_string(value);
+ g_free(value);
+ break;
+ /*
+ * integer -- supposed to be uint64
+ */
+ case LTTV_FILTER_EVENT_TSC:
+ se->value.v_uint64 = atoi(value);
+ g_free(value);
+ break;
+ /*
+ * unsigned integers
+ */
+ case LTTV_FILTER_STATE_PID:
+ case LTTV_FILTER_STATE_PPID:
+ case LTTV_FILTER_STATE_CPU:
+ case LTTV_FILTER_EVENT_TARGET_PID:
+ se->value.v_uint = atoi(value);
+ g_free(value);
+ break;
+ /*
+ * LttTime
+ */
+ case LTTV_FILTER_STATE_CT:
+ case LTTV_FILTER_STATE_IT:
+ case LTTV_FILTER_EVENT_TIME:
+ //se->value.v_double = atof(value);
+ /*
+ * parsing logic could be optimised,
+ * but as for now, simpler this way
+ */
+ v = g_string_new("");
+ string_len = strlen(value);
+ for(i=0;i<string_len;i++) {
+ if(value[i] == '.') {
+ /* cannot specify number with more than one '.' */
+ if(is_double) return FALSE;
+ else is_double = TRUE;
+ t.tv_sec = atoi(v->str);
+ g_string_free(v,TRUE);
+ v = g_string_new("");
+ } else v = g_string_append_c(v,value[i]);
+ }
+ /* number can be integer or double */
+ if(is_double) t.tv_nsec = atoi(v->str);
+ else {
+ t.tv_sec = atoi(v->str);
+ t.tv_nsec = 0;
+ }
+
+ g_string_free(v,TRUE);
+
+ se->value.v_ltttime = t;
+ g_free(value);
+ break;
+ default:
+ g_warning("Error encountered in value assignation ! Field type = %i",se->field);
+ g_free(value);
+ return FALSE;
+ }
+
+ return TRUE;
+
+}
+
+/**
+ * @fn void lttv_simple_expression_destroy(LttvSimpleExpression*)
+ *
+ * Disallocate memory for the current
+ * simple expression
+ * @param se pointer to the current LttvSimpleExpression
+ */
+void
+lttv_simple_expression_destroy(LttvSimpleExpression* se) {
+
+ // g_free(se->value);
+// switch(se->field) {
+// case LTTV_FILTER_TRACE_NAME:
+// case LTTV_FILTER_TRACEFILE_NAME:
+// case LTTV_FILTER_STATE_P_NAME:
+// case LTTV_FILTER_EVENT_NAME:
+// g_free(se->value.v_string);
+// break;
+// }
+ g_free(se);
+
+}
+
+/**
+ * @fn gint lttv_struct_type(gint)
+ *
+ * Finds the structure type depending
+ * on the fields in parameters
+ * @params ft Field of the current structure
+ * @return LttvStructType enum or -1 for error
+ */
+gint
+lttv_struct_type(gint ft) {
+
+ switch(ft) {
+ case LTTV_FILTER_TRACE_NAME:
+ return LTTV_FILTER_TRACE;
+ break;
+ case LTTV_FILTER_TRACEFILE_NAME:
+ return LTTV_FILTER_TRACEFILE;
+ break;
+ case LTTV_FILTER_STATE_PID:
+ case LTTV_FILTER_STATE_PPID:
+ case LTTV_FILTER_STATE_CT:
+ case LTTV_FILTER_STATE_IT:
+ case LTTV_FILTER_STATE_P_NAME:
+ case LTTV_FILTER_STATE_T_BRAND:
+ case LTTV_FILTER_STATE_EX_MODE:
+ case LTTV_FILTER_STATE_EX_SUBMODE:
+ case LTTV_FILTER_STATE_P_STATUS:
+ case LTTV_FILTER_STATE_CPU:
+ return LTTV_FILTER_STATE;
+ break;
+ case LTTV_FILTER_EVENT_NAME:
+ case LTTV_FILTER_EVENT_FACILITY:
+ case LTTV_FILTER_EVENT_CATEGORY:
+ case LTTV_FILTER_EVENT_TIME:
+ case LTTV_FILTER_EVENT_TSC:
+ case LTTV_FILTER_EVENT_TARGET_PID:
+ case LTTV_FILTER_EVENT_FIELD:
+ return LTTV_FILTER_EVENT;
+ break;
+ default:
+ return -1;
+ }
+}
+
+/**
+ * @fn gboolean lttv_apply_op_eq_uint(gpointer,LttvFieldValue)
+ *
+ * Applies the 'equal' operator to the
+ * specified structure and value
+ * @param v1 left member of comparison
+ * @param v2 right member of comparison
+ * @return success/failure of operation
+ */
+gboolean lttv_apply_op_eq_uint(const gpointer v1, LttvFieldValue v2) {
+
+ guint* r = (guint*) v1;
+ return (*r == v2.v_uint);
+
+}
+
+/**
+ * @fn gboolean lttv_apply_op_eq_uint64(gpointer,LttvFieldValue)
+ *
+ * Applies the 'equal' operator to the
+ * specified structure and value
+ * @param v1 left member of comparison
+ * @param v2 right member of comparison
+ * @return success/failure of operation
+ */
+gboolean lttv_apply_op_eq_uint64(const gpointer v1, LttvFieldValue v2) {
+
+ guint64* r = (guint64*) v1;
+ return (*r == v2.v_uint64);
+
+}
+
+/**
+ * @fn gboolean lttv_apply_op_eq_uint32(gpointer,LttvFieldValue)
+ *
+ * Applies the 'equal' operator to the
+ * specified structure and value
+ * @param v1 left member of comparison
+ * @param v2 right member of comparison
+ * @return success/failure of operation
+ */
+gboolean lttv_apply_op_eq_uint32(const gpointer v1, LttvFieldValue v2) {
+ guint32* r = (guint32*) v1;
+ return (*r == v2.v_uint32);
+}
+
+/**
+ * @fn gboolean lttv_apply_op_eq_uint16(gpointer,LttvFieldValue)
+ *
+ * Applies the 'equal' operator to the
+ * specified structure and value
+ * @param v1 left member of comparison
+ * @param v2 right member of comparison
+ * @return success/failure of operation
+ */
+gboolean lttv_apply_op_eq_uint16(const gpointer v1, LttvFieldValue v2) {
+ guint16* r = (guint16*) v1;
+ return (*r == v2.v_uint16);
+}
+
+/**
+ * @fn gboolean lttv_apply_op_eq_double(gpointer,LttvFieldValue)
+ *
+ * Applies the 'equal' operator to the
+ * specified structure and value
+ * @param v1 left member of comparison
+ * @param v2 right member of comparison
+ * @return success/failure of operation
+ */
+gboolean lttv_apply_op_eq_double(const gpointer v1, LttvFieldValue v2) {
+ double* r = (double*) v1;
+ return (*r == v2.v_double);
+}
+
+/**
+ * @fn gboolean lttv_apply_op_eq_string(gpointer,LttvFieldValue)
+ *
+ * Applies the 'equal' operator to the
+ * specified structure and value
+ * @param v1 left member of comparison
+ * @param v2 right member of comparison
+ * @return success/failure of operation
+ */
+gboolean lttv_apply_op_eq_string(const gpointer v1, LttvFieldValue v2) {
+ char* r = (char*) v1;
+ return (!g_strcasecmp(r,v2.v_string));
+}
+
+/**
+ * @fn gboolean lttv_apply_op_eq_quark(gpointer,LttvFieldValue)
+ *
+ * Applies the 'equal' operator to the
+ * specified structure and value
+ * @param v1 left member of comparison
+ * @param v2 right member of comparison
+ * @return success/failure of operation
+ */
+gboolean lttv_apply_op_eq_quark(const gpointer v1, LttvFieldValue v2) {
+ GQuark* r = (GQuark*) v1;
+ return (*r == v2.v_quark);
+}
+
+/**
+ * @fn gboolean lttv_apply_op_eq_ltttime(gpointer,LttvFieldValue)
+ *
+ * Applies the 'equal' operator to the
+ * specified structure and value
+ * @param v1 left member of comparison
+ * @param v2 right member of comparison
+ * @return success/failure of operation
+ */
+gboolean lttv_apply_op_eq_ltttime(const gpointer v1, LttvFieldValue v2) {
+ LttTime* r = (LttTime*) v1;
+ return ltt_time_compare(*r, v2.v_ltttime)==0?1:0;
+}
+
+/**
+ * @fn gboolean lttv_apply_op_ne_uint(gpointer,LttvFieldValue)
+ *
+ * Applies the 'not equal' operator to the
+ * specified structure and value
+ * @param v1 left member of comparison
+ * @param v2 right member of comparison
+ * @return success/failure of operation
+ */
+gboolean lttv_apply_op_ne_uint(const gpointer v1, LttvFieldValue v2) {
+ guint* r = (guint*) v1;
+ return (*r != v2.v_uint);
+}
+
+/**
+ * @fn gboolean lttv_apply_op_ne_uint64(gpointer,LttvFieldValue)
+ *
+ * Applies the 'not equal' operator to the
+ * specified structure and value
+ * @param v1 left member of comparison
+ * @param v2 right member of comparison
+ * @return success/failure of operation
+ */
+gboolean lttv_apply_op_ne_uint64(const gpointer v1, LttvFieldValue v2) {
+ guint64* r = (guint64*) v1;
+ return (*r != v2.v_uint64);
+}
+
+/**
+ * @fn gboolean lttv_apply_op_ne_uint32(gpointer,LttvFieldValue)
+ *
+ * Applies the 'not equal' operator to the
+ * specified structure and value
+ * @param v1 left member of comparison
+ * @param v2 right member of comparison
+ * @return success/failure of operation
+ */
+gboolean lttv_apply_op_ne_uint32(const gpointer v1, LttvFieldValue v2) {
+ guint32* r = (guint32*) v1;
+ return (*r != v2.v_uint32);
+}
+
+/**
+ * @fn gboolean lttv_apply_op_ne_uint16(gpointer,LttvFieldValue)
+ *
+ * Applies the 'not equal' operator to the
+ * specified structure and value
+ * @param v1 left member of comparison
+ * @param v2 right member of comparison
+ * @return success/failure of operation
+ */
+gboolean lttv_apply_op_ne_uint16(const gpointer v1, LttvFieldValue v2) {
+ guint16* r = (guint16*) v1;
+ return (*r != v2.v_uint16);
+}
+
+/**
+ * @fn gboolean lttv_apply_op_ne_double(gpointer,LttvFieldValue)
+ *
+ * Applies the 'not equal' operator to the
+ * specified structure and value
+ * @param v1 left member of comparison
+ * @param v2 right member of comparison
+ * @return success/failure of operation
+ */
+gboolean lttv_apply_op_ne_double(const gpointer v1, LttvFieldValue v2) {
+ double* r = (double*) v1;
+ return (*r != v2.v_double);
+}
+
+/**
+ * @fn gboolean lttv_apply_op_ne_string(gpointer,LttvFieldValue)
+ *
+ * Applies the 'not equal' operator to the
+ * specified structure and value
+ * @param v1 left member of comparison
+ * @param v2 right member of comparison
+ * @return success/failure of operation
+ */
+gboolean lttv_apply_op_ne_string(const gpointer v1, LttvFieldValue v2) {
+ char* r = (char*) v1;
+ return (g_strcasecmp(r,v2.v_string));
+}
+
+/**
+ * @fn gboolean lttv_apply_op_ne_quark(gpointer,LttvFieldValue)
+ *
+ * Applies the 'not equal' operator to the
+ * specified structure and value
+ * @param v1 left member of comparison
+ * @param v2 right member of comparison
+ * @return success/failure of operation
+ */
+gboolean lttv_apply_op_ne_quark(const gpointer v1, LttvFieldValue v2) {
+ GQuark* r = (GQuark*) v1;
+ return (*r != v2.v_quark);
+}
+
+
+/**
+ * @fn gboolean lttv_apply_op_ne_ltttime(gpointer,LttvFieldValue)
+ *
+ * Applies the 'not equal' operator to the
+ * specified structure and value
+ * @param v1 left member of comparison
+ * @param v2 right member of comparison
+ * @return success/failure of operation
+ */
+gboolean lttv_apply_op_ne_ltttime(const gpointer v1, LttvFieldValue v2) {
+ LttTime* r = (LttTime*) v1;
+ return ltt_time_compare(*r, v2.v_ltttime)!=0?1:0;
+}
+
+/**
+ * @fn gboolean lttv_apply_op_lt_uint(gpointer,LttvFieldValue)
+ *
+ * Applies the 'lower than' operator to the
+ * specified structure and value
+ * @param v1 left member of comparison
+ * @param v2 right member of comparison
+ * @return success/failure of operation
+ */
+gboolean lttv_apply_op_lt_uint(const gpointer v1, LttvFieldValue v2) {
+ guint* r = (guint*) v1;
+ return (*r < v2.v_uint);
+}
+
+/**
+ * @fn gboolean lttv_apply_op_lt_uint64(gpointer,LttvFieldValue)
+ *
+ * Applies the 'lower than' operator to the
+ * specified structure and value
+ * @param v1 left member of comparison
+ * @param v2 right member of comparison
+ * @return success/failure of operation
+ */
+gboolean lttv_apply_op_lt_uint64(const gpointer v1, LttvFieldValue v2) {
+ guint64* r = (guint64*) v1;
+ return (*r < v2.v_uint64);
+}
+
+/**
+ * @fn gboolean lttv_apply_op_lt_uint32(gpointer,LttvFieldValue)
+ *
+ * Applies the 'lower than' operator to the
+ * specified structure and value
+ * @param v1 left member of comparison
+ * @param v2 right member of comparison
+ * @return success/failure of operation
+ */
+gboolean lttv_apply_op_lt_uint32(const gpointer v1, LttvFieldValue v2) {
+ guint32* r = (guint32*) v1;
+ return (*r < v2.v_uint32);
+}
+
+/**
+ * @fn gboolean lttv_apply_op_lt_uint16(gpointer,LttvFieldValue)
+ *
+ * Applies the 'lower than' operator to the
+ * specified structure and value
+ * @param v1 left member of comparison
+ * @param v2 right member of comparison
+ * @return success/failure of operation
+ */
+gboolean lttv_apply_op_lt_uint16(const gpointer v1, LttvFieldValue v2) {
+ guint16* r = (guint16*) v1;
+ return (*r < v2.v_uint16);
+}
+
+/**
+ * @fn gboolean lttv_apply_op_lt_double(gpointer,LttvFieldValue)
+ *
+ * Applies the 'lower than' operator to the
+ * specified structure and value
+ * @param v1 left member of comparison
+ * @param v2 right member of comparison
+ * @return success/failure of operation
+ */
+gboolean lttv_apply_op_lt_double(const gpointer v1, LttvFieldValue v2) {
+ double* r = (double*) v1;
+ return (*r < v2.v_double);
+}
+
+/**
+ * @fn gboolean lttv_apply_op_lt_ltttime(gpointer,LttvFieldValue)
+ *
+ * Applies the 'lower than' operator to the
+ * specified structure and value
+ * @param v1 left member of comparison
+ * @param v2 right member of comparison
+ * @return success/failure of operation
+ */
+gboolean lttv_apply_op_lt_ltttime(const gpointer v1, LttvFieldValue v2) {
+ LttTime* r = (LttTime*) v1;
+// return ((r->tv_sec < v2.v_ltttime.tv_sec) || ((r->tv_sec == v2.v_ltttime.tv_sec) && (r->tv_nsec < v2.v_ltttime.tv_nsec)));
+ return ltt_time_compare(*r, v2.v_ltttime)==-1?1:0;
+}
+
+/**
+ * @fn gboolean lttv_apply_op_le_uint(gpointer,LttvFieldValue)
+ *
+ * Applies the 'lower or equal' operator to the
+ * specified structure and value
+ * @param v1 left member of comparison
+ * @param v2 right member of comparison
+ * @return success/failure of operation
+ */
+gboolean lttv_apply_op_le_uint(const gpointer v1, LttvFieldValue v2) {
+ guint* r = (guint*) v1;
+ return (*r <= v2.v_uint);
+}
+
+/**
+ * @fn gboolean lttv_apply_op_le_uint64(gpointer,LttvFieldValue)
+ *
+ * Applies the 'lower or equal' operator to the
+ * specified structure and value
+ * @param v1 left member of comparison
+ * @param v2 right member of comparison
+ * @return success/failure of operation
+ */
+gboolean lttv_apply_op_le_uint64(const gpointer v1, LttvFieldValue v2) {
+ guint64* r = (guint64*) v1;
+ return (*r <= v2.v_uint64);
+}
+
+/**
+ * @fn gboolean lttv_apply_op_le_uint32(gpointer,LttvFieldValue)
+ *
+ * Applies the 'lower or equal' operator to the
+ * specified structure and value
+ * @param v1 left member of comparison
+ * @param v2 right member of comparison
+ * @return success/failure of operation
+ */
+gboolean lttv_apply_op_le_uint32(const gpointer v1, LttvFieldValue v2) {
+ guint32* r = (guint32*) v1;
+ return (*r <= v2.v_uint32);
+}
+
+/**
+ * @fn gboolean lttv_apply_op_le_uint16(gpointer,LttvFieldValue)
+ *
+ * Applies the 'lower or equal' operator to the
+ * specified structure and value
+ * @param v1 left member of comparison
+ * @param v2 right member of comparison
+ * @return success/failure of operation
+ */
+gboolean lttv_apply_op_le_uint16(const gpointer v1, LttvFieldValue v2) {
+ guint16* r = (guint16*) v1;
+ return (*r <= v2.v_uint16);
+}
+
+/**
+ * @fn gboolean lttv_apply_op_le_double(gpointer,LttvFieldValue)
+ *
+ * Applies the 'lower or equal' operator to the
+ * specified structure and value
+ * @param v1 left member of comparison
+ * @param v2 right member of comparison
+ * @return success/failure of operation
+ */
+gboolean lttv_apply_op_le_double(const gpointer v1, LttvFieldValue v2) {
+ double* r = (double*) v1;
+ return (*r <= v2.v_double);
+}
+
+/**
+ * @fn gboolean lttv_apply_op_le_ltttime(gpointer,LttvFieldValue)
+ *
+ * Applies the 'lower or equal' operator to the
+ * specified structure and value
+ * @param v1 left member of comparison
+ * @param v2 right member of comparison
+ * @return success/failure of operation
+ */
+gboolean lttv_apply_op_le_ltttime(const gpointer v1, LttvFieldValue v2) {
+ LttTime* r = (LttTime*) v1;
+// return ((r->tv_sec < v2.v_ltttime.tv_sec) || ((r->tv_sec == v2.v_ltttime.tv_sec) && (r->tv_nsec <= v2.v_ltttime.tv_nsec)));
+ return ltt_time_compare(*r, v2.v_ltttime)<1?1:0;
+}