add some message box

[lttv.git] / ltt / branches / poly / lttv / modules / gui / lttvwindow / lttvwindow / lttvwindowtraces.h

diff --git a/ltt/branches/poly/lttv/modules/gui/lttvwindow/lttvwindow/lttvwindowtraces.h b/ltt/branches/poly/lttv/modules/gui/lttvwindow/lttvwindow/lttvwindowtraces.h
index f490995ec1d5566a99443f6f57fdf230ef4041c9..1d21a577fd789a1fea9df963c2b78d713533728b 100644 (file)
--- a/ltt/branches/poly/lttv/modules/gui/lttvwindow/lttvwindow/lttvwindowtraces.h
+++ b/ltt/branches/poly/lttv/modules/gui/lttvwindow/lttvwindow/lttvwindowtraces.h
@@ -18,6 +18,53 @@
 
 /* This file is the API used to launch any background computation on a trace */
 
+/* lttvwindowtraces
+ *
+ * This API consists in two main parts. The first one is for the background
+ * computation provider and the second is for the viewer which needs this
+ * information.
+ *
+ * A computation provider, i.e. a statistics computation module or a state
+ * computation module, have two things in common : they append data to a trace
+ * in an extensible container (LttvAttributes). This extended information, once
+ * computed, can be kept all along with the trace and does not need to be
+ * recomputed : a computation done on a trace must result in a identical result
+ * each time it is done.
+ *
+ * This API provides functions for computation provider to register their
+ * computation functions (or computation functions insertion and removal
+ * functions). Once the computation provider is registered with its module name,
+ * extended computation for a trace can be requested by any viewer by specifying
+ * the module name, as we will describe in a moment.
+ *
+ * A viewer which needs extended information about a trace must ask for it to be
+ * computed by doing a background computation request. It may also ask to be
+ * notified of the completion of its request by doing a notify request.
+ *
+ * Before asking for the computation, it must check for its readiness. If it is
+ * ready, the information has already been computed, so it is ready to use. If
+ * the information is not ready, in must check whether or not the processing of
+ * this task is in progress. If it is, it must not do any background computation
+ * request. It must only do a background notification request of the current
+ * processing to be informed of its completion. If the information is not ready
+ * and not being processed, then the viewer may do a background computation
+ * request and add a notify request to the notify queue.
+ *
+ * When a context takes control of a trace, it must lock the trace. This is a
+ * way of ensuring that not conflict will occur between two traceset contexts
+ * and shared traces. It will generate an error if a context try to get a lock
+ * on a trace what is not unlocked. Upon every trace locking,
+ * lttv_process_traceset_synchronize_tracefiles should be used to resynchronize
+ * the traces with the trace context information.
+ *
+ * The usefulness of the lock in this framework can be questionable in a
+ * single threaded environment, but can be great in the eventuality of
+ * multiple threads.
+ * 
+ */
+
+
+
 #ifndef LTTVWINDOWTRACES_H
 #define LTTVWINDOWTRACES_H
 
@@ -34,6 +81,7 @@ extern LttvTraceInfo LTTV_TRACES,
               LTTV_NOTIFY_CURRENT,
               LTTV_COMPUTATION_TRACESET,
               LTTV_COMPUTATION_TRACESET_CONTEXT,
+              LTTV_COMPUTATION_SYNC_POSITION,
               LTTV_BEFORE_CHUNK_TRACESET,
               LTTV_BEFORE_CHUNK_TRACE,
               LTTV_BEFORE_CHUNK_TRACEFILE,
@@ -44,8 +92,11 @@ extern LttvTraceInfo LTTV_TRACES,
               LTTV_AFTER_REQUEST,
               LTTV_EVENT_HOOK,
               LTTV_EVENT_HOOK_BY_ID,
+              LTTV_HOOK_ADDER,
+              LTTV_HOOK_REMOVER,
               LTTV_IN_PROGRESS,
-              LTTV_READY;
+              LTTV_READY,
+              LTTV_LOCK;
               
 
 
@@ -108,6 +159,16 @@ void lttvwindowtraces_background_request_queue
 void lttvwindowtraces_background_request_remove
                      (LttvTrace *trace, gchar *module_name);
                      
+
+                     
+/**
+ * Find a background request in a trace
+ *
+ */
+
+gboolean lttvwindowtraces_background_request_find
+                     (LttvTrace *trace, gchar *module_name);
+                     
 /**
  * Register a callback to be called when requested data is passed in the next
  * queued background processing.
@@ -200,7 +261,9 @@ void lttvwindowtraces_register_computation_hooks(LttvAttributeName module_name,
                                           LttvHooks *before_request,
                                           LttvHooks *after_request,
                                           LttvHooks *event_hook,
-                                          LttvHooksById *event_hook_by_id);
+                                          LttvHooksById *event_hook_by_id,
+                                          LttvHooks *hook_adder,
+                                          LttvHooks *hook_remover);
 /**
  * Unregister the background computation hooks for a specific module.
  *
@@ -227,4 +290,30 @@ void lttvwindowtraces_unregister_computation_hooks
 void lttvwindowtraces_unregister_requests(LttvAttributeName module_name);
 
 
+/**
+ * Lock a trace so no other instance can use it.
+ *
+ * @param trace The trace to lock.
+ * @return 0 on success, -1 if cannot get lock.
+ */
+gint lttvwindowtraces_lock(LttvTrace *trace);
+
+
+/**
+ * Unlock a trace.
+ *
+ * @param trace The trace to unlock.
+ * @return 0 on success, -1 if cannot unlock (not locked ?).
+ */
+gint lttvwindowtraces_unlock(LttvTrace *trace);
+
+/**
+ * Verify if a trace is locked.
+ *
+ * @param trace The trace to verify.
+ * @return TRUE if locked, FALSE is unlocked.
+ */
+gint lttvwindowtraces_get_lock_state(LttvTrace *trace);
+
+
 #endif //LTTVWINDOWTRACES_H