add LTT_TIME_MAX and LTT_TIME_MIN

[lttv.git] / ltt / branches / poly / ltt / event.c

diff --git a/ltt/branches/poly/ltt/event.c b/ltt/branches/poly/ltt/event.c
index 68920d22099082ba140603008192daa6e39eea7a..3bc93857f51954da565fbdd77e888189ea272c7a 100644 (file)
--- a/ltt/branches/poly/ltt/event.c
+++ b/ltt/branches/poly/ltt/event.c
@@ -26,12 +26,24 @@
 #include <ltt/event.h>
 #include <ltt/trace.h>
 
+
+LttEvent *ltt_event_new()
+{
+  return g_new(LttEvent, 1);
+}
+
+void ltt_event_destroy(LttEvent *event)
+{
+  g_free(event);
+}
+
+
 /*****************************************************************************
  *Function name
  *    ltt_event_refresh_fields   : refresh fields of an event 
  *Input params
  *    offsetRoot      : offset from the root
- *    offsetParent    : offset from the parrent
+ *    offsetParent    : offset from the parent
  *    fld             : field
  *    evD             : event data
  *Return value
@@ -217,9 +229,17 @@ void ltt_event_position(LttEvent *e, LttEventPosition *ep)
   ep->event_time        = e->event_time;
   ep->event_cycle_count = e->event_cycle_count;
   ep->heart_beat_number = e->tracefile->cur_heart_beat_number;
-  ep->old_position      = FALSE;
+  ep->old_position      = TRUE;
   ep->event_offset      = e->data - e->tracefile->buffer - EVENT_HEADER_SIZE ;
   ep->tf                = e->tracefile;
+
+  /* This is a workaround for fast position seek */
+  ep->last_event_pos = e->last_event_pos;
+  ep->prev_block_end_time = e->prev_block_end_time;
+  ep->prev_event_time = e->prev_event_time;
+  ep->pre_cycle_count = e->pre_cycle_count;
+  ep->count = e->count;
+  /* end of workaround */
 }
 
 LttEventPosition * ltt_event_position_new()
@@ -247,6 +267,8 @@ void ltt_event_position_get(LttEventPosition *ep,
 /*****************************************************************************
  *Function name
  *    ltt_event_position_set : set the block number and index of the event
+ *    It does put the old_position gboolean to FALSE, as it is impossible
+ *    to know the quick position to seek in the tracefile.
  *Input params
  *    ep                     : a pointer to event's position structure
  *    block_number           : the block number of the event
@@ -256,13 +278,18 @@ void ltt_event_position_get(LttEventPosition *ep,
 void ltt_event_position_set(LttEventPosition *ep,
     unsigned block_number, unsigned index_in_block)
 {
+  if(ep->block_num != block_number || ep->event_num != index_in_block)
+    ep->old_position = FALSE;
+
   ep->block_num = block_number;
-  ep->event_num = index_in_block;  
+  ep->event_num = index_in_block;
+  
 }
 
 /*****************************************************************************
  * Function name
  *    ltt_event_position_compare : compare two positions
+ *    A NULL value is infinite.
  * Input params
  *    ep1                    : a pointer to event's position structure
  *    ep2                    : a pointer to event's position structure
@@ -278,6 +305,13 @@ gint ltt_event_position_compare(const LttEventPosition *ep1,
 {
   if(ep1->tf != ep2->tf)
     g_error("ltt_event_position_compare on different tracefiles makes no sense");
+  if(ep1 == NULL && ep2 == NULL)
+      return 0;
+  if(ep1 != NULL && ep2 == NULL)
+      return -1;
+  if(ep1 == NULL && ep2 != NULL)
+      return 1;
+    
   if(ep1->block_num < ep2->block_num)
     return -1;
   if(ep1->block_num > ep2->block_num)
@@ -305,8 +339,15 @@ gint ltt_event_position_compare(const LttEventPosition *ep1,
 gint ltt_event_event_position_compare(const LttEvent *event,
                                       const LttEventPosition *ep)
 {
-  if(event->tracefile != ep->tf)
-    g_error("ltt_event_position_compare on different tracefiles makes no sense");
+  if(event == NULL && ep == NULL)
+      return 0;
+  if(event != NULL && ep == NULL)
+      return -1;
+  if(event == NULL && ep != NULL)
+      return 1;
+
+  g_assert(event->tracefile == ep->tf);
+ 
   if(event->which_block < ep->block_num)
     return -1;
   if(event->which_block > ep->block_num)
@@ -318,6 +359,23 @@ gint ltt_event_event_position_compare(const LttEvent *event,
   return 0;
 }
 
+/*****************************************************************************
+ * Function name
+ *    ltt_event_position_copy : copy position
+ * Input params
+ *    src                    : a pointer to event's position structure source
+ *    dest                   : a pointer to event's position structure dest
+ * Return
+ *    void
+ ****************************************************************************/
+void ltt_event_position_copy(LttEventPosition *dest,
+                             const LttEventPosition *src)
+{
+  if(src == NULL)
+    dest = NULL;
+  else
+    *dest = *src;
+}
 
 
 /*****************************************************************************
@@ -434,8 +492,7 @@ unsigned ltt_event_get_unsigned(LttEvent *e, LttField *f)
                 e->tracefile->trace->system_description->endian ? 0:1;
   LttTypeEnum t = f->field_type->type_class;
 
-  if(t != LTT_UINT && t != LTT_ENUM)
-    g_error("The type of the field is not unsigned int\n");
+  g_assert(t == LTT_UINT || t == LTT_ENUM);
 
   if(f->field_size == 1){
     guint8 x = *(guint8 *)(e->data + f->offset_root);
@@ -466,8 +523,7 @@ int ltt_event_get_int(LttEvent *e, LttField *f)
   int revFlag = e->tracefile->trace->my_arch_endian == 
                 e->tracefile->trace->system_description->endian ? 0:1;
 
-  if(f->field_type->type_class != LTT_INT)
-    g_error("The type of the field is not int\n");
+  g_assert(f->field_type->type_class == LTT_INT);
 
   if(f->field_size == 1){
     gint8 x = *(gint8 *)(e->data + f->offset_root);
@@ -499,8 +555,7 @@ unsigned long ltt_event_get_long_unsigned(LttEvent *e, LttField *f)
                 e->tracefile->trace->system_description->endian ? 0:1;
   LttTypeEnum t = f->field_type->type_class;
 
-  if(t != LTT_UINT && t != LTT_ENUM)
-    g_error("The type of the field is not unsigned long\n");
+  g_assert(t == LTT_UINT || t == LTT_ENUM);
 
   if(f->field_size == 1){
     guint8 x = *(guint8 *)(e->data + f->offset_root);
@@ -531,8 +586,7 @@ long int ltt_event_get_long_int(LttEvent *e, LttField *f)
   int revFlag = e->tracefile->trace->my_arch_endian == 
                 e->tracefile->trace->system_description->endian ? 0:1;
 
-  if( f->field_type->type_class != LTT_INT)
-    g_error("The type of the field is not long int\n");
+  g_assert( f->field_type->type_class == LTT_INT);
 
   if(f->field_size == 1){
     gint8 x = *(gint8 *)(e->data + f->offset_root);
@@ -563,9 +617,7 @@ float ltt_event_get_float(LttEvent *e, LttField *f)
   int revFlag = e->tracefile->trace->my_arch_endian == 
                 e->tracefile->trace->system_description->endian ? 0:1;
 
-  if(f->field_type->type_class != LTT_FLOAT || 
-     (f->field_type->type_class == LTT_FLOAT && f->field_size != 4))
-    g_error("The type of the field is not float\n");
+  g_assert(f->field_type->type_class == LTT_FLOAT && f->field_size == 4);
 
   if(revFlag == 0) return *(float *)(e->data + f->offset_root);
   else{
@@ -581,9 +633,7 @@ double ltt_event_get_double(LttEvent *e, LttField *f)
   int revFlag = e->tracefile->trace->my_arch_endian == 
                 e->tracefile->trace->system_description->endian ? 0:1;
 
-  if(f->field_type->type_class != LTT_FLOAT || 
-     (f->field_type->type_class == LTT_FLOAT && f->field_size != 8))
-    g_error("The type of the field is not double\n");
+  g_assert(f->field_type->type_class == LTT_FLOAT && f->field_size == 8);
 
   if(revFlag == 0) return *(double *)(e->data + f->offset_root);
   else{
@@ -601,7 +651,7 @@ double ltt_event_get_double(LttEvent *e, LttField *f)
 
 char *ltt_event_get_string(LttEvent *e, LttField *f)
 {
-  if(f->field_type->type_class != LTT_STRING)
-    g_error("The field contains no string\n");
+  g_assert(f->field_type->type_class == LTT_STRING);
+
   return (char*)g_strdup((char*)(e->data + f->offset_root));
 }