normalize s_type class part 2

diff --git a/src/instr/instr_interface.cpp b/src/instr/instr_interface.cpp
index 204d359..b75c053 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::eventNew(mark_type, PJ_type_get_root());
+  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 a76ed9a..d92944f 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::getOrNull (as_typename, newContainer->father->type);
+      newContainer->type = Type::getOrNull (as_typename, newContainer->father->type);
       if (newContainer->type == nullptr){
-        newContainer->type = s_type::containerNew (as_typename, newContainer->father->type);
+        newContainer->type = Type::containerNew (as_typename, newContainer->father->type);
       }
     }else{
-      newContainer->type = s_type::containerNew ("0", nullptr);
+      newContainer->type = 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::getOrNull (typeNameBuff, newContainer->father->type);
+    type_t type = Type::getOrNull (typeNameBuff, newContainer->father->type);
     if (type == nullptr){
-      newContainer->type = s_type::containerNew (typeNameBuff, newContainer->father->type);
+      newContainer->type = 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 abcc6e5..aa29a39 100644 (file)
--- a/src/instr/instr_paje_types.cpp
+++ b/src/instr/instr_paje_types.cpp
@@ -20,7 +20,7 @@ type_t PJ_type_get_root ()
   return rootType;
 }
 
-s_type::s_type (const char *typeNameBuff, const char *key, const char *color, e_entity_types kind, type_t father)
+Type::Type (const char *typeNameBuff, const char *key, const char *color, e_entity_types kind, type_t father)
 {
   if (typeNameBuff == nullptr || key == nullptr){
     THROWF(tracing_error, 0, "can't create a new type with name or key equal nullptr");
@@ -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::getOrNull (name, father);
+  type_t ret = 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::getOrNull (const char *name, type_t father)
+type_t 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,13 +104,13 @@ type_t s_type::getOrNull (const char *name, type_t father)
   return ret;
 }
 
-type_t s_type::containerNew (const char *name, type_t father)
+type_t 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");
   }
 
-  type_t ret = new s_type (name, name, nullptr, TYPE_CONTAINER, father);
+  type_t ret = new Type (name, name, nullptr, TYPE_CONTAINER, father);
   if (father == nullptr) {
     rootType = ret;
   } else {
@@ -120,19 +120,19 @@ type_t s_type::containerNew (const char *name, type_t father)
   return ret;
 }
 
-type_t s_type::eventNew (const char *name, type_t father)
+type_t 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");
   }
 
-  type_t ret = new s_type (name, name, nullptr, TYPE_EVENT, father);
+  type_t ret = new Type (name, name, nullptr, TYPE_EVENT, father);
   XBT_DEBUG("EventType %s(%s), child of %s(%s)", ret->name, ret->id, father->name, father->id);
   LogDefineEventType(ret);
   return ret;
 }
 
-type_t s_type::variableNew (const char *name, const char *color, type_t father)
+type_t 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");
@@ -142,16 +142,16 @@ type_t s_type::variableNew (const char *name, const char *color, type_t father)
 
   if (not color) {
     char white[INSTR_DEFAULT_STR_SIZE] = "1 1 1";
-    ret = new s_type (name, name, white, TYPE_VARIABLE, father);
+    ret = new Type (name, name, white, TYPE_VARIABLE, father);
   }else{
-    ret = new s_type (name, name, color, TYPE_VARIABLE, father);
+    ret = new Type (name, name, color, TYPE_VARIABLE, father);
   }
   XBT_DEBUG("VariableType %s(%s), child of %s(%s)", ret->name, ret->id, father->name, father->id);
   LogVariableTypeDefinition (ret);
   return ret;
 }
 
-type_t s_type::linkNew (const char *name, type_t father, type_t source, type_t dest)
+type_t 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");
@@ -161,14 +161,14 @@ type_t s_type::linkNew (const char *name, type_t father, type_t source, type_t d
 
   char key[INSTR_DEFAULT_STR_SIZE];
   snprintf (key, INSTR_DEFAULT_STR_SIZE, "%s-%s-%s", name, source->id, dest->id);
-  ret = new s_type (name, key, nullptr, TYPE_LINK, father);
+  ret = new Type (name, key, nullptr, TYPE_LINK, father);
   XBT_DEBUG("LinkType %s(%s), child of %s(%s)  %s(%s)->%s(%s)", ret->name, ret->id, father->name, father->id,
             source->name, source->id, dest->name, dest->id);
   LogLinkTypeDefinition(ret, source, dest);
   return ret;
 }
 
-type_t s_type::stateNew (const char *name, type_t father)
+type_t 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");
@@ -176,7 +176,7 @@ type_t s_type::stateNew (const char *name, type_t father)
 
   type_t ret = nullptr;
 
-  ret = new s_type (name, name, nullptr, TYPE_STATE, father);
+  ret = new Type (name, name, nullptr, TYPE_STATE, father);
   XBT_DEBUG("StateType %s(%s), child of %s(%s)", ret->name, ret->id, father->name, father->id);
   LogStateTypeDefinition(ret);
   return ret;

diff --git a/src/instr/instr_private.h b/src/instr/instr_private.h
index b0ea0ed..e9ce033 100644 (file)
--- a/src/instr/instr_private.h
+++ b/src/instr/instr_private.h
@@ -65,15 +65,15 @@ class ess_type {
   char *color;
 };
 
-class s_type;
-typedef s_type *type_t;
-class s_type : public ess_type {
+class Type;
+typedef Type *type_t;
+class Type : public ess_type {
   public:
   e_entity_types kind;
-  s_type *father;
+  Type *father;
   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);
+  Type (const char *typeNameBuff, const char *key, const char *color, e_entity_types kind, 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);

diff --git a/src/smpi/colls/smpi_automatic_selector.cpp b/src/smpi/colls/smpi_automatic_selector.cpp
index b1a272f..e4ed65a 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::getOrNull(#cat, PJ_type_get_root());                                                       \
+    type_t type = Type::getOrNull(#cat, PJ_type_get_root());                                                       \
     if (not type) {                                                                                                    \
-      type = s_type::eventNew(#cat, PJ_type_get_root());                                                              \
+      type = 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 5c25d7c..52133eb 100644 (file)
--- a/src/smpi/internals/instr_smpi.cpp
+++ b/src/smpi/internals/instr_smpi.cpp
@@ -209,7 +209,7 @@ void TRACE_smpi_init(int rank)
      * multiple times but only the last one would be used...
      */
     if (s_type::getOrNull(it.first.c_str(), container->type) == nullptr) {
-      s_type::variableNew(it.first.c_str(), nullptr, container->type);
+      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 e8e5b87..185bb86 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::getOrNull (link_typename, father->type);
+  type_t link_type = Type::getOrNull (link_typename, father->type);
   if (link_type == nullptr){
-    link_type = s_type::linkNew (link_typename, father->type, src->type, dst->type);
+    link_type = 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::getOrNull ("MPI", root->type);
+      type_t mpi = Type::getOrNull ("MPI", root->type);
       if (mpi == nullptr){
-        mpi = s_type::containerNew("MPI", root->type);
+        mpi = Type::containerNew("MPI", root->type);
         if (not TRACE_smpi_is_grouped())
-          s_type::stateNew ("MPI_STATE", mpi);
-        s_type::linkNew ("MPI_LINK", PJ_type_get_root(), mpi, mpi);
+          Type::stateNew ("MPI_STATE", mpi);
+        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::getOrNull("bandwidth", container->type);
+    type_t bandwidth = Type::getOrNull("bandwidth", container->type);
     if (bandwidth == nullptr) {
-      bandwidth = s_type::variableNew("bandwidth", nullptr, container->type);
+      bandwidth = Type::variableNew("bandwidth", nullptr, container->type);
     }
-    type_t latency = s_type::getOrNull("latency", container->type);
+    type_t latency = Type::getOrNull("latency", container->type);
     if (latency == nullptr) {
-      latency = s_type::variableNew("latency", nullptr, container->type);
+      latency = 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::getOrNull("bandwidth_used", container->type);
+    type_t bandwidth_used = Type::getOrNull("bandwidth_used", container->type);
     if (bandwidth_used == nullptr) {
-      s_type::variableNew("bandwidth_used", "0.5 0.5 0.5", container->type);
+      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::getOrNull ("power", container->type);
+    type_t speed = Type::getOrNull ("power", container->type);
     if (speed == nullptr){
-      speed = s_type::variableNew ("power", nullptr, container->type);
+      speed = 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::getOrNull ("power_used", container->type);
+    type_t speed_used = Type::getOrNull ("power_used", container->type);
     if (speed_used == nullptr){
-      s_type::variableNew ("power_used", "0.5 0.5 0.5", container->type);
+      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::getOrNull ("MPI", container->type);
+    type_t mpi = Type::getOrNull ("MPI", container->type);
     if (mpi == nullptr){
-      mpi = s_type::containerNew("MPI", container->type);
-      s_type::stateNew ("MPI_STATE", mpi);
+      mpi = Type::containerNew("MPI", container->type);
+      Type::stateNew ("MPI_STATE", mpi);
     }
   }
 
   if (TRACE_msg_process_is_enabled()) {
-    type_t msg_process = s_type::getOrNull ("MSG_PROCESS", container->type);
+    type_t msg_process = Type::getOrNull ("MSG_PROCESS", container->type);
     if (msg_process == nullptr){
-      msg_process = s_type::containerNew("MSG_PROCESS", container->type);
-      type_t state = s_type::stateNew ("MSG_PROCESS_STATE", msg_process);
+      msg_process = Type::containerNew("MSG_PROCESS", container->type);
+      type_t state = 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::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);
+      Type::linkNew ("MSG_PROCESS_LINK", PJ_type_get_root(), msg_process, msg_process);
+      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::getOrNull ("MSG_VM", container->type);
+    type_t msg_vm = Type::getOrNull ("MSG_VM", container->type);
     if (msg_vm == nullptr){
-      msg_vm = s_type::containerNew("MSG_VM", container->type);
-      type_t state = s_type::stateNew ("MSG_VM_STATE", msg_vm);
+      msg_vm = Type::containerNew("MSG_VM", container->type);
+      type_t state = 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::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);
+      Type::linkNew ("MSG_VM_LINK", PJ_type_get_root(), msg_vm, msg_vm);
+      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::variableNew (tnstr, color, root);
+    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::variableNew (tnstr, color, root);
+    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::variableNew (tnstr, color, root);
+    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::variableNew (new_typename, color, root);
+    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::stateNew (new_typename, root);
+    Type::stateNew (new_typename, root);
   }
   xbt_dict_cursor_t cursor = nullptr;
   type_t child_type;