1 files changed, 54 insertions, 45 deletions

diff --git a/implementation/service_discovery/src/service_discovery_fsm.cpp b/implementation/service_discovery/src/service_discovery_fsm.cpp
index 8b2cb17..d2428dd 100644
--- a/implementation/service_discovery/src/service_discovery_fsm.cpp
+++ b/implementation/service_discovery/src/service_discovery_fsm.cpp
@@ -6,12 +6,11 @@
 #include <boost/random/mersenne_twister.hpp>
 #include <boost/random/uniform_int_distribution.hpp>
 
-#include <vsomeip/configuration.hpp>
-#include <vsomeip/logger.hpp>
-
 #include "../include/defines.hpp"
 #include "../include/service_discovery.hpp"
 #include "../include/service_discovery_fsm.hpp"
+#include "../../configuration/include/configuration.hpp"
+#include "../../logging/include/logger.hpp"
 
 namespace vsomeip {
 namespace sd {
@@ -48,12 +47,14 @@ inactive::inactive(my_context context)
     std::shared_ptr < service_discovery_fsm > fsm =
             outermost_context().fsm_.lock();
     if (fsm) {
-        VSOMEIP_TRACE << "sd<" << fsm->get_name() << ">::inactive";
+        VSOMEIP_TRACE << "sd::inactive";
         outermost_context().run_ = 0;
     }
 }
 
 sc::result inactive::react(const ev_none &_event) {
+    (void)_event;
+
     if (outermost_context().is_up_) {
         return transit<active>();
     }
@@ -62,6 +63,8 @@ sc::result inactive::react(const ev_none &_event) {
 }
 
 sc::result inactive::react(const ev_status_change &_event) {
+    (void)_event;
+
     outermost_context().is_up_ = _event.is_up_;
     if (outermost_context().is_up_) {
         return transit<active>();
@@ -78,7 +81,7 @@ active::active(my_context _context)
     std::shared_ptr < service_discovery_fsm > fsm =
             outermost_context().fsm_.lock();
     if (fsm) {
-        VSOMEIP_TRACE << "sd<" << fsm->get_name() << ">::active";
+        VSOMEIP_TRACE << "sd::active";
     }
 }
 
@@ -86,6 +89,8 @@ active::~active() {
 }
 
 sc::result active::react(const ev_status_change &_event) {
+    (void)_event;
+
     outermost_context().stop_timer();
     outermost_context().is_up_ = _event.is_up_;
     if (!outermost_context().is_up_)
@@ -102,12 +107,13 @@ initial::initial(my_context _context)
     std::shared_ptr < service_discovery_fsm > fsm =
             outermost_context().fsm_.lock();
     if (fsm) {
-        VSOMEIP_TRACE << "sd<" << fsm->get_name() << ">::active.initial";
+        VSOMEIP_TRACE << "sd::active.initial";
         outermost_context().start_timer(outermost_context().initial_delay_);
     }
 }
 
 sc::result initial::react(const ev_timeout &_event) {
+    (void)_event;
     return transit<repeat>();
 }
 
@@ -119,8 +125,8 @@ repeat::repeat(my_context _context)
     std::shared_ptr < service_discovery_fsm > fsm =
             outermost_context().fsm_.lock();
     if (fsm) {
-        VSOMEIP_TRACE << "sd<" << fsm->get_name() << ">::active.repeat";
-        uint32_t its_timeout = (outermost_context().repetition_base_delay_
+        VSOMEIP_TRACE << "sd::active.repeat";
+        uint32_t its_timeout = (outermost_context().repetitions_base_delay_
                 << outermost_context().run_);
         outermost_context().run_++;
         fsm->send(false);
@@ -129,13 +135,16 @@ repeat::repeat(my_context _context)
 }
 
 sc::result repeat::react(const ev_timeout &_event) {
-    if (outermost_context().run_ < outermost_context().repetition_max_)
+    (void)_event;
+
+    if (outermost_context().run_ < outermost_context().repetitions_max_)
         return transit<repeat>();
 
     return transit<announce>();
 }
 
 sc::result repeat::react(const ev_find_service &_event) {
+    (void)_event;
     return discard_event();
 }
 
@@ -147,7 +156,7 @@ announce::announce(my_context _context)
     std::shared_ptr < service_discovery_fsm > fsm =
             outermost_context().fsm_.lock();
     if (fsm) {
-        VSOMEIP_TRACE << "sd<" << fsm->get_name() << ">::active.announce";
+        VSOMEIP_TRACE << "sd::active.announce";
         outermost_context().start_timer(
                 outermost_context().cyclic_offer_delay_);
         fsm->send(true);
@@ -155,14 +164,17 @@ announce::announce(my_context _context)
 }
 
 sc::result announce::react(const ev_timeout &_event) {
+    (void)_event;
     return transit<announce>();
 }
 
 sc::result announce::react(const ev_find_service &_event) {
+    (void)_event;
     return discard_event();
 }
 
 sc::result announce::react(const ev_offer_change &_event) {
+    (void)_event;
     return transit<announce>();
 }
 
@@ -171,9 +183,9 @@ sc::result announce::react(const ev_offer_change &_event) {
 ///////////////////////////////////////////////////////////////////////////////
 // Interface
 ///////////////////////////////////////////////////////////////////////////////
-service_discovery_fsm::service_discovery_fsm(const std::string &_name,
+service_discovery_fsm::service_discovery_fsm(
         std::shared_ptr<service_discovery> _discovery)
-        : name_(_name), discovery_(_discovery), fsm_(
+        : discovery_(_discovery), fsm_(
                 std::make_shared < _sd::fsm > (_discovery->get_io())) {
 
     std::shared_ptr < service_discovery > discovery = discovery_.lock();
@@ -181,57 +193,54 @@ service_discovery_fsm::service_discovery_fsm(const std::string &_name,
         std::shared_ptr < configuration > its_configuration =
                 discovery->get_configuration();
 
-        int32_t its_min_initial_delay =
-                its_configuration->get_min_initial_delay(name_);
-        if (its_min_initial_delay < 0)
-            its_min_initial_delay = VSOMEIP_SD_DEFAULT_MIN_INITIAL_DELAY;
+        int32_t its_initial_delay_min
+            = its_configuration->get_sd_initial_delay_min();
+        if (its_initial_delay_min < 0)
+            its_initial_delay_min = VSOMEIP_SD_DEFAULT_INITIAL_DELAY_MIN;
 
-        int32_t its_max_initial_delay =
-                its_configuration->get_max_initial_delay(name_);
-        if (its_max_initial_delay <= 0)
-                its_max_initial_delay = VSOMEIP_SD_DEFAULT_MAX_INITIAL_DELAY;
+        int32_t its_initial_delay_max
+            = its_configuration->get_sd_initial_delay_max();
+        if (its_initial_delay_max <= 0)
+            its_initial_delay_max = VSOMEIP_SD_DEFAULT_INITIAL_DELAY_MAX;
 
-        if (its_min_initial_delay > its_max_initial_delay) {
-            int32_t tmp_initial_delay = its_min_initial_delay;
-            its_min_initial_delay = its_max_initial_delay;
-            its_max_initial_delay = its_min_initial_delay;
+        if (its_initial_delay_min > its_initial_delay_max) {
+            int32_t tmp_initial_delay = its_initial_delay_min;
+            its_initial_delay_min = its_initial_delay_max;
+            its_initial_delay_max = tmp_initial_delay;
         }
 
-        VSOMEIP_TRACE << "Inital delay [" << its_min_initial_delay << ", "
-                << its_max_initial_delay << "]";
+        VSOMEIP_TRACE << "Inital delay [" << its_initial_delay_min << ", "
+                << its_initial_delay_max << "]";
 
         boost::random::mt19937 its_generator;
         boost::random::uniform_int_distribution<> its_distribution(
-                its_min_initial_delay, its_max_initial_delay);
+                its_initial_delay_min, its_initial_delay_max);
         fsm_->initial_delay_ = its_distribution(its_generator);
 
-        fsm_->repetition_base_delay_ =
-                its_configuration->get_repetition_base_delay(name_);
-        if (fsm_->repetition_base_delay_ <= 0)
-                fsm_->repetition_base_delay_
-                    = VSOMEIP_SD_DEFAULT_REPETITION_BASE_DELAY;
-        fsm_->repetition_max_ = its_configuration->get_repetition_max(name_);
-        if (fsm_->repetition_max_ <= 0)
-            fsm_->repetition_max_ = VSOMEIP_SD_DEFAULT_REPETITION_MAX;
-
-        fsm_->cyclic_offer_delay_ =
-                its_configuration->get_cyclic_offer_delay(name_);
+        fsm_->repetitions_base_delay_
+            = its_configuration->get_sd_repetitions_base_delay();
+        if (fsm_->repetitions_base_delay_ <= 0)
+                fsm_->repetitions_base_delay_
+                    = VSOMEIP_SD_DEFAULT_REPETITIONS_BASE_DELAY;
+        fsm_->repetitions_max_
+            = its_configuration->get_sd_repetitions_max();
+        if (fsm_->repetitions_max_ <= 0)
+            fsm_->repetitions_max_ = VSOMEIP_SD_DEFAULT_REPETITIONS_MAX;
+
+        fsm_->cyclic_offer_delay_
+            = its_configuration->get_sd_cyclic_offer_delay();
         if (fsm_->cyclic_offer_delay_ <= 0)
             fsm_->cyclic_offer_delay_ = VSOMEIP_SD_DEFAULT_CYCLIC_OFFER_DELAY;
 
         VSOMEIP_INFO << "SD configuration [" << fsm_->initial_delay_ << ":"
-                << fsm_->repetition_base_delay_ << ":"
-                << (int) fsm_->repetition_max_ << ":"
+                << fsm_->repetitions_base_delay_ << ":"
+                << (int) fsm_->repetitions_max_ << ":"
                 << fsm_->cyclic_offer_delay_ << "]";
     } else {
         VSOMEIP_ERROR << "SD initialization failed";
     }
 }
 
-const std::string & service_discovery_fsm::get_name() const {
-    return name_;
-}
-
 void service_discovery_fsm::start() {
     fsm_->set_fsm(shared_from_this());
     fsm_->initiate();
@@ -243,7 +252,7 @@ void service_discovery_fsm::stop() {
 void service_discovery_fsm::send(bool _is_announcing) {
     std::shared_ptr < service_discovery > discovery = discovery_.lock();
     if (discovery)
-        discovery->send(name_, _is_announcing);
+        discovery->send(_is_announcing);
 }
 
 } // namespace sd