+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_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:
+ 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;
+
+ 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_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:
+ 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("");
+ for(i=0;i<strlen(value);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 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);
+
+ 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_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_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;
+}
+
+
+/**
+ * @fn gboolean lttv_apply_op_gt_uint(gpointer,LttvFieldValue)
+ *
+ * Applies the 'greater 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_gt_uint(const gpointer v1, LttvFieldValue v2) {
+ guint* r = (guint*) v1;
+ return (*r > v2.v_uint);
+}
+
+/**
+ * @fn gboolean lttv_apply_op_gt_uint64(gpointer,LttvFieldValue)
+ *
+ * Applies the 'greater 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_gt_uint64(const gpointer v1, LttvFieldValue v2) {
+ guint64* r = (guint64*) v1;
+ return (*r > v2.v_uint64);
+}
+
+/**
+ * @fn gboolean lttv_apply_op_gt_uint32(gpointer,LttvFieldValue)
+ *
+ * Applies the 'greater 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_gt_uint32(const gpointer v1, LttvFieldValue v2) {
+ guint32* r = (guint32*) v1;
+ return (*r > v2.v_uint32);
+}
+
+/**
+ * @fn gboolean lttv_apply_op_gt_uint16(gpointer,LttvFieldValue)
+ *
+ * Applies the 'greater 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_gt_uint16(const gpointer v1, LttvFieldValue v2) {
+ guint16* r = (guint16*) v1;
+ return (*r > v2.v_uint16);
+}
+
+/**
+ * @fn gboolean lttv_apply_op_gt_double(gpointer,LttvFieldValue)
+ *
+ * Applies the 'greater 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_gt_double(const gpointer v1, LttvFieldValue v2) {
+ double* r = (double*) v1;
+ return (*r > v2.v_double);
+}
+
+/**
+ * @fn gboolean lttv_apply_op_gt_ltttime(gpointer,LttvFieldValue)
+ *
+ * Applies the 'greater 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_gt_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_ge_uint(gpointer,LttvFieldValue)
+ *
+ * Applies the 'greater 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_ge_uint(const gpointer v1, LttvFieldValue v2) {
+ guint* r = (guint*) v1;
+ return (*r >= v2.v_uint);
+}
+
+/**
+ * @fn gboolean lttv_apply_op_ge_uint64(gpointer,LttvFieldValue)
+ *
+ * Applies the 'greater 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_ge_uint64(const gpointer v1, LttvFieldValue v2) {
+ guint64* r = (guint64*) v1;
+ return (*r >= v2.v_uint64);
+}
+
+/**
+ * @fn gboolean lttv_apply_op_ge_uint32(gpointer,LttvFieldValue)
+ *
+ * Applies the 'greater 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_ge_uint32(const gpointer v1, LttvFieldValue v2) {
+ guint32* r = (guint32*) v1;
+ return (*r >= v2.v_uint32);
+}