normalize s_type class

diff --git a/src/instr/instr_interface.cpp b/src/instr/instr_interface.cpp
index 15bfd80..204d359 100644 (file)
--- a/src/instr/instr_interface.cpp
+++ b/src/instr/instr_interface.cpp
@@ -153,7 +153,7 @@ void TRACE_declare_mark(const char *mark_type)
   }
 
   XBT_DEBUG("MARK,declare %s", mark_type);
-  s_type::s_type_event_new(mark_type, PJ_type_get_root());
+  s_type::eventNew(mark_type, PJ_type_get_root());
   declared_marks.insert(mark_type);
 }
 

diff --git a/src/instr/instr_paje_containers.cpp b/src/instr/instr_paje_containers.cpp
index 88c9d5d..a76ed9a 100644 (file)
--- a/src/instr/instr_paje_containers.cpp
+++ b/src/instr/instr_paje_containers.cpp
@@ -88,12 +88,12 @@ container_t PJ_container_new (const char *name, e_container_types kind, containe
     char as_typename[INSTR_DEFAULT_STR_SIZE];
     snprintf (as_typename, INSTR_DEFAULT_STR_SIZE, "L%d", newContainer->level);
     if (newContainer->father){
-      newContainer->type = s_type::s_type_get_or_null (as_typename, newContainer->father->type);
+      newContainer->type = s_type::getOrNull (as_typename, newContainer->father->type);
       if (newContainer->type == nullptr){
-        newContainer->type = s_type::s_type_container_new (as_typename, newContainer->father->type);
+        newContainer->type = s_type::containerNew (as_typename, newContainer->father->type);
       }
     }else{
-      newContainer->type = s_type::s_type_container_new ("0", nullptr);
+      newContainer->type = s_type::containerNew ("0", nullptr);
     }
   }else{
     //otherwise, the name is its kind
@@ -124,9 +124,9 @@ container_t PJ_container_new (const char *name, e_container_types kind, containe
         THROWF (tracing_error, 0, "new container kind is unknown.");
         break;
     }
-    type_t type = s_type::s_type_get_or_null (typeNameBuff, newContainer->father->type);
+    type_t type = s_type::getOrNull (typeNameBuff, newContainer->father->type);
     if (type == nullptr){
-      newContainer->type = s_type::s_type_container_new (typeNameBuff, newContainer->father->type);
+      newContainer->type = s_type::containerNew (typeNameBuff, newContainer->father->type);
     }else{
       newContainer->type = type;
     }

diff --git a/src/instr/instr_paje_types.cpp b/src/instr/instr_paje_types.cpp
index f9d8318..abcc6e5 100644 (file)
--- a/src/instr/instr_paje_types.cpp
+++ b/src/instr/instr_paje_types.cpp
@@ -75,14 +75,14 @@ void recursiveDestroyType (type_t type)
 
 type_t PJ_type_get (const char *name, type_t father)
 {
-  type_t ret = s_type::s_type_get_or_null (name, father);
+  type_t ret = s_type::getOrNull (name, father);
   if (ret == nullptr){
     THROWF (tracing_error, 2, "type with name (%s) not found in father type (%s)", name, father->name);
   }
   return ret;
 }
 
-type_t s_type::s_type_get_or_null (const char *name, type_t father)
+type_t s_type::getOrNull (const char *name, type_t father)
 {
   if (name == nullptr || father == nullptr){
     THROWF (tracing_error, 0, "can't get type with a nullptr name or from a nullptr father");
@@ -104,7 +104,7 @@ type_t s_type::s_type_get_or_null (const char *name, type_t father)
   return ret;
 }
 
-type_t s_type::s_type_container_new (const char *name, type_t father)
+type_t s_type::containerNew (const char *name, type_t father)
 {
   if (name == nullptr){
     THROWF (tracing_error, 0, "can't create a container type with a nullptr name");
@@ -120,7 +120,7 @@ type_t s_type::s_type_container_new (const char *name, type_t father)
   return ret;
 }
 
-type_t s_type::s_type_event_new (const char *name, type_t father)
+type_t s_type::eventNew (const char *name, type_t father)
 {
   if (name == nullptr){
     THROWF (tracing_error, 0, "can't create an event type with a nullptr name");
@@ -132,7 +132,7 @@ type_t s_type::s_type_event_new (const char *name, type_t father)
   return ret;
 }
 
-type_t s_type::s_type_variable_new (const char *name, const char *color, type_t father)
+type_t s_type::variableNew (const char *name, const char *color, type_t father)
 {
   if (name == nullptr){
     THROWF (tracing_error, 0, "can't create a variable type with a nullptr name");
@@ -151,7 +151,7 @@ type_t s_type::s_type_variable_new (const char *name, const char *color, type_t
   return ret;
 }
 
-type_t s_type::s_type_link_new (const char *name, type_t father, type_t source, type_t dest)
+type_t s_type::linkNew (const char *name, type_t father, type_t source, type_t dest)
 {
   if (name == nullptr){
     THROWF (tracing_error, 0, "can't create a link type with a nullptr name");
@@ -168,7 +168,7 @@ type_t s_type::s_type_link_new (const char *name, type_t father, type_t source,
   return ret;
 }
 
-type_t s_type::s_type_state_new (const char *name, type_t father)
+type_t s_type::stateNew (const char *name, type_t father)
 {
   if (name == nullptr){
     THROWF (tracing_error, 0, "can't create a state type with a nullptr name");

diff --git a/src/instr/instr_private.h b/src/instr/instr_private.h
index 799692c..b0ea0ed 100644 (file)
--- a/src/instr/instr_private.h
+++ b/src/instr/instr_private.h
@@ -74,12 +74,12 @@ class s_type : public ess_type {
   xbt_dict_t children;
   xbt_dict_t values; //valid for all types except variable and container
   s_type (const char *typeNameBuff, const char *key, const char *color, e_entity_types kind, type_t father);
-  static type_t s_type_get_or_null (const char *name, type_t father);
-  static type_t s_type_container_new (const char *name, type_t father);
-  static type_t s_type_event_new (const char *name, type_t father);
-  static type_t s_type_variable_new (const char *name, const char *color, type_t father);
-  static type_t s_type_link_new (const char *name, type_t father, type_t source, type_t dest);
-  static type_t s_type_state_new (const char *name, type_t father);
+  static type_t getOrNull (const char *name, type_t father);
+  static type_t containerNew (const char *name, type_t father);
+  static type_t eventNew (const char *name, type_t father);
+  static type_t variableNew (const char *name, const char *color, type_t father);
+  static type_t linkNew (const char *name, type_t father, type_t source, type_t dest);
+  static type_t stateNew (const char *name, type_t father);
 };
 
 //--------------------------------------------------

diff --git a/src/smpi/colls/smpi_automatic_selector.cpp b/src/smpi/colls/smpi_automatic_selector.cpp
index c69f495..b1a272f 100644 (file)
--- a/src/smpi/colls/smpi_automatic_selector.cpp
+++ b/src/smpi/colls/smpi_automatic_selector.cpp
@@ -16,9 +16,9 @@
 
 #define TRACE_AUTO_COLL(cat)                                                                                           \
   if (TRACE_is_enabled()) {                                                                                            \
-    type_t type = s_type::s_type_get_or_null(#cat, PJ_type_get_root());                                                       \
+    type_t type = s_type::getOrNull(#cat, PJ_type_get_root());                                                       \
     if (not type) {                                                                                                    \
-      type = s_type::s_type_event_new(#cat, PJ_type_get_root());                                                              \
+      type = s_type::eventNew(#cat, PJ_type_get_root());                                                              \
     }                                                                                                                  \
     char cont_name[25];                                                                                                \
     snprintf(cont_name, 25, "rank-%d", smpi_process()->index());                                                       \

diff --git a/src/smpi/internals/instr_smpi.cpp b/src/smpi/internals/instr_smpi.cpp
index c95b5d9..5c25d7c 100644 (file)
--- a/src/smpi/internals/instr_smpi.cpp
+++ b/src/smpi/internals/instr_smpi.cpp
@@ -208,8 +208,8 @@ void TRACE_smpi_init(int rank)
      * Check whether this variable already exists or not. Otherwise, it will be created
      * multiple times but only the last one would be used...
      */
-    if (s_type::s_type_get_or_null(it.first.c_str(), container->type) == nullptr) {
-      s_type::s_type_variable_new(it.first.c_str(), nullptr, container->type);
+    if (s_type::getOrNull(it.first.c_str(), container->type) == nullptr) {
+      s_type::variableNew(it.first.c_str(), nullptr, container->type);
     }
   }
 #endif

diff --git a/src/surf/instr_routing.cpp b/src/surf/instr_routing.cpp
index 32d0f0a..e8e5b87 100644 (file)
--- a/src/surf/instr_routing.cpp
+++ b/src/surf/instr_routing.cpp
@@ -105,9 +105,9 @@ static void linkContainers (container_t src, container_t dst, xbt_dict_t filter)
             father->type->name,
             src->type->name, src->type->id,
             dst->type->name, dst->type->id);
-  type_t link_type = s_type::s_type_get_or_null (link_typename, father->type);
+  type_t link_type = s_type::getOrNull (link_typename, father->type);
   if (link_type == nullptr){
-    link_type = s_type::s_type_link_new (link_typename, father->type, src->type, dst->type);
+    link_type = s_type::linkNew (link_typename, father->type, src->type, dst->type);
   }
 
   //register EDGE types for triva configuration
@@ -173,12 +173,12 @@ static void sg_instr_AS_begin(simgrid::s4u::NetZone& netzone)
     PJ_container_set_root (root);
 
     if (TRACE_smpi_is_enabled()) {
-      type_t mpi = s_type::s_type_get_or_null ("MPI", root->type);
+      type_t mpi = s_type::getOrNull ("MPI", root->type);
       if (mpi == nullptr){
-        mpi = s_type::s_type_container_new("MPI", root->type);
+        mpi = s_type::containerNew("MPI", root->type);
         if (not TRACE_smpi_is_grouped())
-          s_type::s_type_state_new ("MPI_STATE", mpi);
-        s_type::s_type_link_new ("MPI_LINK", PJ_type_get_root(), mpi, mpi);
+          s_type::stateNew ("MPI_STATE", mpi);
+        s_type::linkNew ("MPI_LINK", PJ_type_get_root(), mpi, mpi);
       }
     }
 
@@ -214,21 +214,21 @@ static void instr_routing_parse_start_link(simgrid::s4u::Link& link)
   container_t container = PJ_container_new(link.name(), INSTR_LINK, father);
 
   if ((TRACE_categorized() || TRACE_uncategorized() || TRACE_platform()) && (not TRACE_disable_link())) {
-    type_t bandwidth = s_type::s_type_get_or_null("bandwidth", container->type);
+    type_t bandwidth = s_type::getOrNull("bandwidth", container->type);
     if (bandwidth == nullptr) {
-      bandwidth = s_type::s_type_variable_new("bandwidth", nullptr, container->type);
+      bandwidth = s_type::variableNew("bandwidth", nullptr, container->type);
     }
-    type_t latency = s_type::s_type_get_or_null("latency", container->type);
+    type_t latency = s_type::getOrNull("latency", container->type);
     if (latency == nullptr) {
-      latency = s_type::s_type_variable_new("latency", nullptr, container->type);
+      latency = s_type::variableNew("latency", nullptr, container->type);
     }
     new SetVariableEvent(0, container, bandwidth, bandwidth_value);
     new SetVariableEvent(0, container, latency, latency_value);
   }
   if (TRACE_uncategorized()) {
-    type_t bandwidth_used = s_type::s_type_get_or_null("bandwidth_used", container->type);
+    type_t bandwidth_used = s_type::getOrNull("bandwidth_used", container->type);
     if (bandwidth_used == nullptr) {
-      s_type::s_type_variable_new("bandwidth_used", "0.5 0.5 0.5", container->type);
+      s_type::variableNew("bandwidth_used", "0.5 0.5 0.5", container->type);
     }
   }
 }
@@ -239,56 +239,56 @@ static void sg_instr_new_host(simgrid::s4u::Host& host)
   container_t container = PJ_container_new(host.getCname(), INSTR_HOST, father);
 
   if ((TRACE_categorized() || TRACE_uncategorized() || TRACE_platform()) && (not TRACE_disable_speed())) {
-    type_t speed = s_type::s_type_get_or_null ("power", container->type);
+    type_t speed = s_type::getOrNull ("power", container->type);
     if (speed == nullptr){
-      speed = s_type::s_type_variable_new ("power", nullptr, container->type);
+      speed = s_type::variableNew ("power", nullptr, container->type);
     }
 
     double current_speed_state = host.getSpeed();
     new SetVariableEvent (0, container, speed, current_speed_state);
   }
   if (TRACE_uncategorized()){
-    type_t speed_used = s_type::s_type_get_or_null ("power_used", container->type);
+    type_t speed_used = s_type::getOrNull ("power_used", container->type);
     if (speed_used == nullptr){
-      s_type::s_type_variable_new ("power_used", "0.5 0.5 0.5", container->type);
+      s_type::variableNew ("power_used", "0.5 0.5 0.5", container->type);
     }
   }
 
   if (TRACE_smpi_is_enabled() && TRACE_smpi_is_grouped()){
-    type_t mpi = s_type::s_type_get_or_null ("MPI", container->type);
+    type_t mpi = s_type::getOrNull ("MPI", container->type);
     if (mpi == nullptr){
-      mpi = s_type::s_type_container_new("MPI", container->type);
-      s_type::s_type_state_new ("MPI_STATE", mpi);
+      mpi = s_type::containerNew("MPI", container->type);
+      s_type::stateNew ("MPI_STATE", mpi);
     }
   }
 
   if (TRACE_msg_process_is_enabled()) {
-    type_t msg_process = s_type::s_type_get_or_null ("MSG_PROCESS", container->type);
+    type_t msg_process = s_type::getOrNull ("MSG_PROCESS", container->type);
     if (msg_process == nullptr){
-      msg_process = s_type::s_type_container_new("MSG_PROCESS", container->type);
-      type_t state = s_type::s_type_state_new ("MSG_PROCESS_STATE", msg_process);
+      msg_process = s_type::containerNew("MSG_PROCESS", container->type);
+      type_t state = s_type::stateNew ("MSG_PROCESS_STATE", msg_process);
       value PJ_value("suspend", "1 0 1", state);
       value::get_or_new("sleep", "1 1 0", state);
       value::get_or_new("receive", "1 0 0", state);
       value::get_or_new("send", "0 0 1", state);
       value::get_or_new("task_execute", "0 1 1", state);
-      s_type::s_type_link_new ("MSG_PROCESS_LINK", PJ_type_get_root(), msg_process, msg_process);
-      s_type::s_type_link_new ("MSG_PROCESS_TASK_LINK", PJ_type_get_root(), msg_process, msg_process);
+      s_type::linkNew ("MSG_PROCESS_LINK", PJ_type_get_root(), msg_process, msg_process);
+      s_type::linkNew ("MSG_PROCESS_TASK_LINK", PJ_type_get_root(), msg_process, msg_process);
     }
   }
 
   if (TRACE_msg_vm_is_enabled()) {
-    type_t msg_vm = s_type::s_type_get_or_null ("MSG_VM", container->type);
+    type_t msg_vm = s_type::getOrNull ("MSG_VM", container->type);
     if (msg_vm == nullptr){
-      msg_vm = s_type::s_type_container_new("MSG_VM", container->type);
-      type_t state = s_type::s_type_state_new ("MSG_VM_STATE", msg_vm);
+      msg_vm = s_type::containerNew("MSG_VM", container->type);
+      type_t state = s_type::stateNew ("MSG_VM_STATE", msg_vm);
       value PJ_value("suspend", "1 0 1", state);
       value::get_or_new("sleep", "1 1 0", state);
       value::get_or_new("receive", "1 0 0", state);
       value::get_or_new("send", "0 0 1", state);
       value::get_or_new("task_execute", "0 1 1", state);
-      s_type::s_type_link_new ("MSG_VM_LINK", PJ_type_get_root(), msg_vm, msg_vm);
-      s_type::s_type_link_new ("MSG_VM_PROCESS_LINK", PJ_type_get_root(), msg_vm, msg_vm);
+      s_type::linkNew ("MSG_VM_LINK", PJ_type_get_root(), msg_vm, msg_vm);
+      s_type::linkNew ("MSG_VM_PROCESS_LINK", PJ_type_get_root(), msg_vm, msg_vm);
     }
   }
 
@@ -339,17 +339,17 @@ static void recursiveNewVariableType (const char *new_typename, const char *colo
   if (not strcmp(root->name, "HOST")) {
     char tnstr[INSTR_DEFAULT_STR_SIZE];
     snprintf (tnstr, INSTR_DEFAULT_STR_SIZE, "p%s", new_typename);
-    s_type::s_type_variable_new (tnstr, color, root);
+    s_type::variableNew (tnstr, color, root);
   }
   if (not strcmp(root->name, "MSG_VM")) {
     char tnstr[INSTR_DEFAULT_STR_SIZE];
     snprintf (tnstr, INSTR_DEFAULT_STR_SIZE, "p%s", new_typename);
-    s_type::s_type_variable_new (tnstr, color, root);
+    s_type::variableNew (tnstr, color, root);
   }
   if (not strcmp(root->name, "LINK")) {
     char tnstr[INSTR_DEFAULT_STR_SIZE];
     snprintf (tnstr, INSTR_DEFAULT_STR_SIZE, "b%s", new_typename);
-    s_type::s_type_variable_new (tnstr, color, root);
+    s_type::variableNew (tnstr, color, root);
   }
   xbt_dict_cursor_t cursor = nullptr;
   type_t child_type;
@@ -367,7 +367,7 @@ void instr_new_variable_type (const char *new_typename, const char *color)
 static void recursiveNewUserVariableType (const char *father_type, const char *new_typename, const char *color, type_t root)
 {
   if (not strcmp(root->name, father_type)) {
-    s_type::s_type_variable_new (new_typename, color, root);
+    s_type::variableNew (new_typename, color, root);
   }
   xbt_dict_cursor_t cursor = nullptr;
   type_t child_type;
@@ -385,7 +385,7 @@ void instr_new_user_variable_type  (const char *father_type, const char *new_typ
 static void recursiveNewUserStateType (const char *father_type, const char *new_typename, type_t root)
 {
   if (not strcmp(root->name, father_type)) {
-    s_type::s_type_state_new (new_typename, root);
+    s_type::stateNew (new_typename, root);
   }
   xbt_dict_cursor_t cursor = nullptr;
   type_t child_type;