Update Clang-format

src/.clang-format

+#
+# Copyright (c) 2015, EURECOM (www.eurecom.fr)
+# All rights reserved.
+#
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions are met:
+#
+# 1. Redistributions of source code must retain the above copyright notice, this
+#    list of conditions and the following disclaimer.
+# 2. Redistributions in binary form must reproduce the above copyright notice,
+#    this list of conditions and the following disclaimer in the documentation
+#    and/or other materials provided with the distribution.
+#
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+# ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+# WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+# DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
+# ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+# (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+# LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+# ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+# SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+#
+# The views and conclusions contained in the software and documentation are those
+# of the authors and should not be interpreted as representing official policies,
+# either expressed or implied, of the FreeBSD Project.
+#
+
+# see https://clang.llvm.org/docs/ClangFormatStyleOptions.html for explanation
+# of style options
+
+BasedOnStyle: Google
+Language: Cpp
+IndentWidth: 2
+ColumnLimit: 80
+
+IncludeBlocks: Preserve
+SortIncludes: false
+
+# alignment
+AlignAfterOpenBracket: AlwaysBreak
+AlignConsecutiveAssignments: true
+AlignConsecutiveDeclarations: false
+AlignEscapedNewlines: Right
+AlignOperands: true
+AlignTrailingComments: true
+DerivePointerAlignment: false
+PointerAlignment: Left
+
+# function style
+AllowAllParametersOfDeclarationOnNextLine: false
+AllowShortFunctionsOnASingleLine: Inline
+AlwaysBreakAfterReturnType: None
+IndentWrappedFunctionNames: false
+
+# template style
+AlwaysBreakTemplateDeclarations: Yes
+
+# preprocessor style
+IndentPPDirectives: None
+
+# block style
+AllowShortBlocksOnASingleLine: false
+KeepEmptyLinesAtTheStartOfBlocks: false
+
+# break style
+BreakBeforeBinaryOperators: None
+BreakBeforeBraces: Attach
+BreakBeforeTernaryOperators: false
+BreakStringLiterals: true
+CompactNamespaces: false
+ContinuationIndentWidth: 4
+MaxEmptyLinesToKeep: 1
+ReflowComments: true
+
+# spacing style
+UseTab: Never
+SpaceAfterCStyleCast: true
+SpaceAfterTemplateKeyword: false
+SpaceBeforeAssignmentOperators: true
+SpaceBeforeInheritanceColon: true
+SpaceBeforeParens: ControlStatements
+SpaceBeforeRangeBasedForLoopColon: true
+SpaceInEmptyParentheses: false
+SpacesBeforeTrailingComments: 2
+SpacesInAngles: false
+SpacesInCStyleCastParentheses: false
+SpacesInContainerLiterals: false
+SpacesInParentheses: false
+SpacesInSquareBrackets: false
+
+# class style
+BreakConstructorInitializers: BeforeColon
+BreakInheritanceList: BeforeColon
+ConstructorInitializerAllOnOneLineOrOnePerLine: true
+ConstructorInitializerIndentWidth: 4
+
+# case statements
+IndentCaseLabels: true
+
+# cpp
+Cpp11BracedListStyle: true
+FixNamespaceComments: true
+NamespaceIndentation: None
+SortUsingDeclarations: true
+
+# todo
+# AlwaysBreakBeforeMultilineStrings: bool
+# PenaltyBreakAssignment (unsigned)
+# PenaltyBreakBeforeFirstCallParameter (unsigned)
+# PenaltyBreakComment (unsigned)
+# PenaltyBreakFirstLessLess (unsigned)
+# PenaltyBreakString (unsigned)
+# PenaltyBreakTemplateDeclaration (unsigned)
+# PenaltyExcessCharacter (unsigned)
+# PenaltyReturnTypeOnItsOwnLine (unsigned)

src/common/nrf.h

@@ -24,7 +24,7 @@
 
 #define HEART_BEAT_TIMER 10
 
-#define _unused(x) ((void)(x))
+#define _unused(x) ((void) (x))
 
 typedef enum nf_type_s {
   NF_TYPE_NRF     = 0,
@@ -73,14 +73,14 @@ static const std::vector<std::string> patch_op_type_e2str = {
 typedef uint32_t evsub_id_t;
 #define EVSUB_ID_FMT "0x%" PRIx32
 #define EVSUB_ID_SCAN_FMT SCNx32
-#define INVALID_EVSUB_ID ((evsub_id_t)0x00000000)
-#define UNASSIGNED_EVSUB_ID ((evsub_id_t)0x00000000)
+#define INVALID_EVSUB_ID ((evsub_id_t) 0x00000000)
+#define UNASSIGNED_EVSUB_ID ((evsub_id_t) 0x00000000)
 
 #define NNRF_NFM_BASE "/nnrf-nfm/"
 #define NNRF_NFM_NF_INSTANCE "/nf-instances/"
 
 #define NF_CURL_TIMEOUT_MS 1000L
 
-#define MAX_WAIT_MSECS 20000 //1 second
+#define MAX_WAIT_MSECS 20000  // 1 second
 
 #endif

src/nrf_app/nrf_client.cpp

@@ -45,20 +45,20 @@ using namespace Pistache::Http::Mime;
 using namespace oai::nrf::app;
 using json = nlohmann::json;
 
-extern nrf_client *nrf_client_inst;
+extern nrf_client* nrf_client_inst;
 extern nrf_config nrf_cfg;
 
 //------------------------------------------------------------------------------
 // To read content of the response from NF
-static std::size_t callback(const char *in, std::size_t size, std::size_t num,
-                            std::string *out) {
+static std::size_t callback(
+    const char* in, std::size_t size, std::size_t num, std::string* out) {
   const std::size_t totalBytes(size * num);
   out->append(in, totalBytes);
   return totalBytes;
 }
 
 //------------------------------------------------------------------------------
-nrf_client::nrf_client(nrf_event &ev) : m_event_sub(ev) {
+nrf_client::nrf_client(nrf_event& ev) : m_event_sub(ev) {
   curl_global_init(CURL_GLOBAL_DEFAULT);
   curl_multi = curl_multi_init();
   handles    = {};
@@ -87,11 +87,11 @@ nrf_client::~nrf_client() {
 }
 
 //------------------------------------------------------------------------------
-CURL *nrf_client::curl_create_handle(const std::string &uri,
-                                     const std::string &data,
-                                     std::string &response_data) {
+CURL* nrf_client::curl_create_handle(
+    const std::string& uri, const std::string& data,
+    std::string& response_data) {
   // create handle for a curl request
-  CURL *curl = curl_easy_init();
+  CURL* curl = curl_easy_init();
 
   if (curl) {
     curl_easy_setopt(curl, CURLOPT_HTTPHEADER, headers);
@@ -111,12 +111,12 @@ CURL *nrf_client::curl_create_handle(const std::string &uri,
 }
 
 //------------------------------------------------------------------------------
-void nrf_client::send_curl_multi(const std::string &uri,
-                                 const std::string &data,
-                                 std::string &response_data) {
+void nrf_client::send_curl_multi(
+    const std::string& uri, const std::string& data,
+    std::string& response_data) {
   // create a new handle and add to the multi handle
   // the curl will actually be sent in perform_curl_multi
-  CURL *tmp = curl_create_handle(uri, data, response_data);
+  CURL* tmp = curl_create_handle(uri, data, response_data);
   curl_multi_add_handle(curl_multi, tmp);
   handles.push_back(tmp);
 }
@@ -159,8 +159,8 @@ void nrf_client::wait_curl_end() {
 
 //------------------------------------------------------------------------------
 void nrf_client::curl_release_handles() {
-  CURLMsg *curl_msg = nullptr;
-  CURL *curl = nullptr;
+  CURLMsg* curl_msg = nullptr;
+  CURL* curl        = nullptr;
   CURLcode code     = {};
   int http_code     = 0;
   int msgs_left     = 0;
@@ -183,7 +183,7 @@ void nrf_client::curl_release_handles() {
       curl_multi_remove_handle(curl_multi, curl);
       curl_easy_cleanup(curl);
 
-      std::vector<CURL *>::iterator it;
+      std::vector<CURL*>::iterator it;
       it = find(handles.begin(), handles.end(), curl);
       if (it != handles.end()) {
         handles.erase(it);
@@ -195,7 +195,7 @@ void nrf_client::curl_release_handles() {
       curl_multi_remove_handle(curl_multi, curl);
       curl_easy_cleanup(curl);
 
-      std::vector<CURL *>::iterator it;
+      std::vector<CURL*>::iterator it;
       it = find(handles.begin(), handles.end(), curl);
       if (it != handles.end()) {
         handles.erase(it);
@@ -208,8 +208,8 @@ void nrf_client::curl_release_handles() {
 
 //------------------------------------------------------------------------------
 void nrf_client::notify_subscribed_event(
-    const std::shared_ptr<nrf_profile> &profile, const uint8_t &event_type,
-    const std::vector<std::string> &uris) {
+    const std::shared_ptr<nrf_profile>& profile, const uint8_t& event_type,
+    const std::vector<std::string>& uris) {
   Logger::nrf_app().debug(
       "Send notification for the subscribed event to the subscriptions");
 
@@ -222,7 +222,7 @@ void nrf_client::notify_subscribed_event(
   profile.get()->get_nf_ipv4_addresses(instance_addrs);
   // TODO: use the first IPv4 addr for now
   std::string instance_uri =
-      std::string(inet_ntoa(*((struct in_addr *)&(instance_addrs[0]))));
+      std::string(inet_ntoa(*((struct in_addr*) &(instance_addrs[0]))));
   Logger::nrf_app().debug("NF instance URI: %s", instance_uri.c_str());
   json_data["nfInstanceUri"] = instance_uri;
 
@@ -243,7 +243,9 @@ void nrf_client::notify_subscribed_event(
         std::static_pointer_cast<upf_profile>(profile).get()->to_json(
             json_profile);
       } break;
-      default: { profile.get()->to_json(json_profile); }
+      default: {
+        profile.get()->to_json(json_profile);
+      }
     }
     json_data["nfProfile"] = json_profile;
   }
@@ -262,18 +264,18 @@ void nrf_client::notify_subscribed_event(
 
 //------------------------------------------------------------------------------
 void nrf_client::notify_subscribed_event_multi(
-    const std::shared_ptr<nrf_profile> &profile, const uint8_t &event_type,
-    const std::vector<std::string> &uris) {
+    const std::shared_ptr<nrf_profile>& profile, const uint8_t& event_type,
+    const std::vector<std::string>& uris) {
   Logger::nrf_app().debug(
       "Send notification for the subscribed event to the subscriptions");
 
   int still_running = 0, numfds = 0, res = 0, msgs_left = 0;
-  CURLMsg *curl_msg = nullptr;
-  CURL *curl = nullptr;
+  CURLMsg* curl_msg    = nullptr;
+  CURL* curl           = nullptr;
   CURLcode return_code = {};
   int http_status_code = 0;
   int index            = 0;
-  char *curl_url = nullptr;
+  char* curl_url       = nullptr;
   std::unique_ptr<std::string> httpData(new std::string());
   // Fill the json part
   nlohmann::json json_data = {};
@@ -283,7 +285,7 @@ void nrf_client::notify_subscribed_event_multi(
   profile.get()->get_nf_ipv4_addresses(instance_addrs);
   // TODO: use the first IPv4 addr for now
   std::string instance_uri =
-      std::string(inet_ntoa(*((struct in_addr *)&(instance_addrs[0]))));
+      std::string(inet_ntoa(*((struct in_addr*) &(instance_addrs[0]))));
   Logger::nrf_app().debug("NF instance URI: %s", instance_uri.c_str());
   json_data["nfInstanceUri"] = instance_uri;
 
@@ -304,7 +306,9 @@ void nrf_client::notify_subscribed_event_multi(
         std::static_pointer_cast<upf_profile>(profile).get()->to_json(
             json_profile);
       } break;
-      default: { profile.get()->to_json(json_profile); }
+      default: {
+        profile.get()->to_json(json_profile);
+      }
     }
     json_data["nfProfile"] = json_profile;
   }
@@ -315,8 +319,8 @@ void nrf_client::notify_subscribed_event_multi(
   for (auto uri : uris) {
     curl = curl_easy_init();
     if (curl) {
-      Logger::nrf_app().debug("Send notification to NF with URI: %s",
-                              uri.c_str());
+      Logger::nrf_app().debug(
+          "Send notification to NF with URI: %s", uri.c_str());
       curl_easy_setopt(curl, CURLOPT_HTTPHEADER, headers);
       curl_easy_setopt(curl, CURLOPT_URL, uri.c_str());
       curl_easy_setopt(curl, CURLOPT_HTTPPOST, 1);
@@ -366,7 +370,7 @@ void nrf_client::notify_subscribed_event_multi(
       curl_multi_remove_handle(curl_multi, curl);
       curl_easy_cleanup(curl);
 
-      std::vector<CURL *>::iterator it;
+      std::vector<CURL*>::iterator it;
       it = find(handles.begin(), handles.end(), curl);
       if (it != handles.end()) {
         handles.erase(it);
@@ -375,8 +379,8 @@ void nrf_client::notify_subscribed_event_multi(
       }
 
     } else {
-      Logger::nrf_app().debug("Error after curl_multi_info_read(), CURLMsg %s",
-                              curl_msg->msg);
+      Logger::nrf_app().debug(
+          "Error after curl_multi_info_read(), CURLMsg %s", curl_msg->msg);
     }
   }
 
@@ -392,9 +396,9 @@ void nrf_client::notify_subscribed_event_multi(
 
 //------------------------------------------------------------------------------
 void nrf_client::notify_subscribed_event(
-    const std::shared_ptr<nrf_profile> &profile, const std::string &uri) {
-  Logger::nrf_app().debug("Send notification to the subscribed NF (URI %s)",
-                          uri.c_str());
+    const std::shared_ptr<nrf_profile>& profile, const std::string& uri) {
+  Logger::nrf_app().debug(
+      "Send notification to the subscribed NF (URI %s)", uri.c_str());
 
   // Fill the json part
   nlohmann::json json_data = {};
@@ -404,14 +408,14 @@ void nrf_client::notify_subscribed_event(
   profile.get()->get_nf_ipv4_addresses(instance_addrs);
   // TODO: use the first IPv4 addr for now
   std::string instance_uri =
-      std::string(inet_ntoa(*((struct in_addr *)&(instance_addrs[0]))));
+      std::string(inet_ntoa(*((struct in_addr*) &(instance_addrs[0]))));
   Logger::nrf_app().debug("NF instance URI: %s", instance_uri.c_str());
   json_data["nfInstanceUri"] = instance_uri;
   std::string body           = json_data.dump();
 
   curl_global_init(CURL_GLOBAL_ALL);
-  CURL *curl = curl = curl_easy_init();
-  struct curl_slist *headers = nullptr;
+  CURL* curl = curl          = curl_easy_init();
+  struct curl_slist* headers = nullptr;
 
   if (curl) {
     CURLcode res = {};
@@ -440,7 +444,7 @@ void nrf_client::notify_subscribed_event(
       json response_data = {};
       try {
         response_data = json::parse(*httpData.get());
-      } catch (json::exception &e) {
+      } catch (json::exception& e) {
         Logger::nrf_app().warn("Could not get the cause from the response");
       }
 

src/nrf_app/nrf_client.hpp

@@ -41,19 +41,19 @@ namespace app {
 
 class nrf_client {
  private:
-  CURLM *curl_multi;
-  std::vector<CURL *> handles;
-  struct curl_slist *headers;
-  nrf_event &m_event_sub;
+  CURLM* curl_multi;
+  std::vector<CURL*> handles;
+  struct curl_slist* headers;
+  nrf_event& m_event_sub;
   bs2::connection
       task_connection;  // connection for performing curl_multi every 1ms
 
  public:
-  nrf_client(nrf_event &ev);
+  nrf_client(nrf_event& ev);
   virtual ~nrf_client();
 
-  nrf_client(nrf_client const &) = delete;
-  void operator=(nrf_client const &) = delete;
+  nrf_client(nrf_client const&) = delete;
+  void operator=(nrf_client const&) = delete;
 
   /*
    * Send Notification for the associated event to the subscriber
@@ -61,8 +61,8 @@ class nrf_client {
    * @param [const std::string &] uri: URI of the subscribed NF
    * @return void
    */
-  void notify_subscribed_event(const std::shared_ptr<nrf_profile> &profile,
-                               const std::string &uri);
+  void notify_subscribed_event(
+      const std::shared_ptr<nrf_profile>& profile, const std::string& uri);
 
   /*
    * Send Notification for the associated event to the subscriber
@@ -71,8 +71,8 @@ class nrf_client {
    * @return void
    */
   void notify_subscribed_event_multi(
-      const std::shared_ptr<nrf_profile> &profile, const uint8_t &event_type,
-      const std::vector<std::string> &uris);
+      const std::shared_ptr<nrf_profile>& profile, const uint8_t& event_type,
+      const std::vector<std::string>& uris);
 
   /*
    * Send Notification for the associated event to the subscribers
@@ -81,9 +81,9 @@ class nrf_client {
    * @param [const std::vector<std::string> &] uris: list of subscribed NFs' URI
    * @return void
    */
-  void notify_subscribed_event(const std::shared_ptr<nrf_profile> &profile,
-                               const uint8_t &event_type,
-                               const std::vector<std::string> &uris);
+  void notify_subscribed_event(
+      const std::shared_ptr<nrf_profile>& profile, const uint8_t& event_type,
+      const std::vector<std::string>& uris);
 
   /*
    * Create Curl handle for multi curl
@@ -92,8 +92,9 @@ class nrf_client {
    * @param [std::string &] response_data: response data
    * @return pointer to the created curl
    */
-  CURL *curl_create_handle(const std::string &uri, const std::string &data,
-		  std::string &response_data);
+  CURL* curl_create_handle(
+      const std::string& uri, const std::string& data,
+      std::string& response_data);
 
   /*
    * Prepare to send a request using curl multi
@@ -102,8 +103,9 @@ class nrf_client {
    * @param [std::string &] response_data: response data
    * @return void
    */
-  void send_curl_multi(const std::string &uri, const std::string &data,
-		  std::string &response_data);
+  void send_curl_multi(
+      const std::string& uri, const std::string& data,
+      std::string& response_data);
 
   /*
    * Perform curl multi to actually process the available data

src/nrf_app/nrf_config.cpp

@@ -58,7 +58,7 @@ using namespace oai::nrf::app;
 extern nrf_config nrf_cfg;
 
 //------------------------------------------------------------------------------
-int nrf_config::load_interface(const Setting &if_cfg, interface_cfg_t &cfg) {
+int nrf_config::load_interface(const Setting& if_cfg, interface_cfg_t& cfg) {
   if_cfg.lookupValue(NRF_CONFIG_STRING_INTERFACE_NAME, cfg.if_name);
   util::trim(cfg.if_name);
   if (not boost::iequals(cfg.if_name, "none")) {
@@ -66,19 +66,19 @@ int nrf_config::load_interface(const Setting &if_cfg, interface_cfg_t &cfg) {
     if_cfg.lookupValue(NRF_CONFIG_STRING_IPV4_ADDRESS, address);
     util::trim(address);
     if (boost::iequals(address, "read")) {
-      if (get_inet_addr_infos_from_iface(cfg.if_name, cfg.addr4, cfg.network4,
-                                         cfg.mtu)) {
+      if (get_inet_addr_infos_from_iface(
+              cfg.if_name, cfg.addr4, cfg.network4, cfg.mtu)) {
         Logger::nrf_app().error(
             "Could not read %s network interface configuration", cfg.if_name);
         return RETURNerror;
       }
     } else {
       std::vector<std::string> words;
-      boost::split(words, address, boost::is_any_of("/"),
-                   boost::token_compress_on);
+      boost::split(
+          words, address, boost::is_any_of("/"), boost::token_compress_on);
       if (words.size() != 2) {
-        Logger::nrf_app().error("Bad value " NRF_CONFIG_STRING_IPV4_ADDRESS
-                                " = %s in config file",
+        Logger::nrf_app().error(
+            "Bad value " NRF_CONFIG_STRING_IPV4_ADDRESS " = %s in config file",
             address.c_str());
         return RETURNerror;
       }
@@ -93,8 +93,8 @@ int nrf_config::load_interface(const Setting &if_cfg, interface_cfg_t &cfg) {
             util::trim(words.at(0)).c_str());
         return RETURNerror;
       }
-      cfg.network4.s_addr =
-          htons(ntohs(cfg.addr4.s_addr) &
+      cfg.network4.s_addr = htons(
+          ntohs(cfg.addr4.s_addr) &
           0xFFFFFFFF << (32 - std::stoi(util::trim(words.at(1)))));
     }
     if_cfg.lookupValue(NRF_CONFIG_STRING_PORT, cfg.port);
@@ -103,67 +103,69 @@ int nrf_config::load_interface(const Setting &if_cfg, interface_cfg_t &cfg) {
 }
 
 //------------------------------------------------------------------------------
-int nrf_config::load(const string &config_file) {
+int nrf_config::load(const string& config_file) {
   Config cfg;
   unsigned char buf_in6_addr[sizeof(struct in6_addr)];
 
   // Read the file. If there is an error, report it and exit.
   try {
     cfg.readFile(config_file.c_str());
-  } catch (const FileIOException &fioex) {
-    Logger::nrf_app().error("I/O error while reading file %s - %s",
-                            config_file.c_str(), fioex.what());
+  } catch (const FileIOException& fioex) {
+    Logger::nrf_app().error(
+        "I/O error while reading file %s - %s", config_file.c_str(),
+        fioex.what());
     throw;
-  } catch (const ParseException &pex) {
-    Logger::nrf_app().error("Parse error at %s:%d - %s", pex.getFile(),
-                            pex.getLine(), pex.getError());
+  } catch (const ParseException& pex) {
+    Logger::nrf_app().error(
+        "Parse error at %s:%d - %s", pex.getFile(), pex.getLine(),
+        pex.getError());
     throw;
   }
 
-  const Setting &root = cfg.getRoot();
+  const Setting& root = cfg.getRoot();
 
   try {
-    const Setting &nrf_cfg = root[NRF_CONFIG_STRING_NRF_CONFIG];
-  } catch (const SettingNotFoundException &nfex) {
+    const Setting& nrf_cfg = root[NRF_CONFIG_STRING_NRF_CONFIG];
+  } catch (const SettingNotFoundException& nfex) {
     Logger::nrf_app().error("%s : %s", nfex.what(), nfex.getPath());
     return RETURNerror;
   }
 
-  const Setting &nrf_cfg = root[NRF_CONFIG_STRING_NRF_CONFIG];
+  const Setting& nrf_cfg = root[NRF_CONFIG_STRING_NRF_CONFIG];
 
   try {
     nrf_cfg.lookupValue(NRF_CONFIG_STRING_INSTANCE, instance);
-  } catch (const SettingNotFoundException &nfex) {
-    Logger::nrf_app().info("%s : %s, using defaults", nfex.what(),
-                           nfex.getPath());
+  } catch (const SettingNotFoundException& nfex) {
+    Logger::nrf_app().info(
+        "%s : %s, using defaults", nfex.what(), nfex.getPath());
   }
 
   try {
     nrf_cfg.lookupValue(NRF_CONFIG_STRING_PID_DIRECTORY, pid_dir);
-  } catch (const SettingNotFoundException &nfex) {
-    Logger::nrf_app().info("%s : %s, using defaults", nfex.what(),
-                           nfex.getPath());
+  } catch (const SettingNotFoundException& nfex) {
+    Logger::nrf_app().info(
+        "%s : %s, using defaults", nfex.what(), nfex.getPath());
   }
 
   try {
-    const Setting &sbi_cfg = nrf_cfg[NRF_CONFIG_STRING_INTERFACE_SBI];
+    const Setting& sbi_cfg = nrf_cfg[NRF_CONFIG_STRING_INTERFACE_SBI];
     load_interface(sbi_cfg, sbi);
 
     // HTTP2 port
-    if (!(sbi_cfg.lookupValue(NRF_CONFIG_STRING_SBI_HTTP2_PORT,
-                              sbi_http2_port))) {
+    if (!(sbi_cfg.lookupValue(
+            NRF_CONFIG_STRING_SBI_HTTP2_PORT, sbi_http2_port))) {
       Logger::nrf_app().error(NRF_CONFIG_STRING_SBI_HTTP2_PORT "failed");
       throw(NRF_CONFIG_STRING_SBI_HTTP2_PORT "failed");
     }
 
     // SBI API VERSION
-    if (!(sbi_cfg.lookupValue(NRF_CONFIG_STRING_API_VERSION,
-                              sbi_api_version))) {
+    if (!(sbi_cfg.lookupValue(
+            NRF_CONFIG_STRING_API_VERSION, sbi_api_version))) {
       Logger::nrf_app().error(NRF_CONFIG_STRING_API_VERSION "failed");
       throw(NRF_CONFIG_STRING_API_VERSION "failed");
     }
 
-  } catch (const SettingNotFoundException &nfex) {
+  } catch (const SettingNotFoundException& nfex) {
     Logger::nrf_app().error("%s : %s", nfex.what(), nfex.getPath());
     return RETURNerror;
   }
@@ -173,8 +175,8 @@ int nrf_config::load(const string &config_file) {
 
 //------------------------------------------------------------------------------
 void nrf_config::display() {
-  Logger::nrf_app().info("==== EURECOM %s v%s ====", PACKAGE_NAME,
-                         PACKAGE_VERSION);
+  Logger::nrf_app().info(
+      "==== EURECOM %s v%s ====", PACKAGE_NAME, PACKAGE_VERSION);
   Logger::nrf_app().info("Configuration NRF:");
   Logger::nrf_app().info("- Instance ..............: %d\n", instance);
   Logger::nrf_app().info("- PID dir ...............: %s\n", pid_dir.c_str());
@@ -184,8 +186,8 @@ void nrf_config::display() {
   Logger::nrf_app().info("    IPv4 Addr ...........: %s", inet_ntoa(sbi.addr4));
   Logger::nrf_app().info("    Port ................: %d", sbi.port);
   Logger::nrf_app().info("    HTTP2 port ..........: %d", sbi_http2_port);
-  Logger::nrf_app().info("    API version..........: %s",
-                         sbi_api_version.c_str());
+  Logger::nrf_app().info(
+      "    API version..........: %s", sbi_api_version.c_str());
 }
 
 //------------------------------------------------------------------------------

src/nrf_app/nrf_config.hpp

@@ -63,7 +63,7 @@ typedef struct interface_cfg_s {
 
 class nrf_config {
  private:
-  int load_interface(const libconfig::Setting &if_cfg, interface_cfg_t &cfg);
+  int load_interface(const libconfig::Setting& if_cfg, interface_cfg_t& cfg);
 
  public:
   /* Reader/writer lock for this configuration */
@@ -85,7 +85,7 @@ class nrf_config {
   virtual ~nrf_config();
   void lock() { m_rw_lock.lock(); };
   void unlock() { m_rw_lock.unlock(); };
-  int load(const std::string &config_file);
+  int load(const std::string& config_file);
   void display();
 };
 

src/nrf_app/nrf_event.cpp

@@ -35,9 +35,8 @@
 using namespace oai::nrf::app;
 
 //------------------------------------------------------------------------------
-bs2::connection nrf_event::subscribe_task_tick(const task_sig_t::slot_type &sig,
-                                               uint64_t period,
-                                               uint64_t start) {
+bs2::connection nrf_event::subscribe_task_tick(
+    const task_sig_t::slot_type& sig, uint64_t period, uint64_t start) {
   /* Wrap the actual callback in a lambda. The latter checks whether the
    * current time is after start time, and ensures that the callback is only
    * called every X ms with X being the period time. This way, it is possible
@@ -51,14 +50,14 @@ bs2::connection nrf_event::subscribe_task_tick(const task_sig_t::slot_type &sig,
 
 //------------------------------------------------------------------------------
 bs2::connection nrf_event::subscribe_task_tick_extended(
-    const task_sig_t::extended_slot_type &sig, uint64_t period,
+    const task_sig_t::extended_slot_type& sig, uint64_t period,
     uint64_t start) {
   /* Wrap the actual callback in a lambda. The latter checks whether the
    * current time is after start time, and ensures that the callback is only
    * called every X ms with X being the period time. This way, it is possible
    * to register to be notified every X ms instead of every ms, which provides
    * greater freedom to implementations. */
-  auto f = [period, start, sig](const bs2::connection &c, uint64_t t) {
+  auto f = [period, start, sig](const bs2::connection& c, uint64_t t) {
     if (t >= start && (t - start) % period == 0) sig(c, t);
   };
   return task_tick.connect_extended(f);
@@ -66,24 +65,24 @@ bs2::connection nrf_event::subscribe_task_tick_extended(
 
 //------------------------------------------------------------------------------
 bs2::connection nrf_event::subscribe_nf_status_change(
-    const nf_status_change_sig_t::slot_type &sig) {
+    const nf_status_change_sig_t::slot_type& sig) {
   return nf_status_change.connect(sig);
 }
 
 //------------------------------------------------------------------------------
 bs2::connection nrf_event::subscribe_nf_status_registered(
-    const nf_status_sig_t::slot_type &sig) {
+    const nf_status_sig_t::slot_type& sig) {
   return nf_status_registered.connect(sig);
 }
 
 //------------------------------------------------------------------------------
 bs2::connection nrf_event::subscribe_nf_status_deregistered(
-    const nf_deregistered_sig_t::slot_type &sig) {
+    const nf_deregistered_sig_t::slot_type& sig) {
   return nf_status_deregistered.connect(sig);
 }
 
 //------------------------------------------------------------------------------
 bs2::connection nrf_event::subscribe_nf_status_profile_changed(
-    const nf_status_sig_t::slot_type &sig) {
+    const nf_status_sig_t::slot_type& sig) {
   return nf_status_profile_changed.connect(sig);
 }

src/nrf_app/nrf_event.hpp

@@ -47,10 +47,10 @@ class task_manager;
 class nrf_event {
  public:
   nrf_event(){};
-  nrf_event(nrf_event const &) = delete;
-  void operator=(nrf_event const &) = delete;
+  nrf_event(nrf_event const&) = delete;
+  void operator=(nrf_event const&) = delete;
 
-  static nrf_event &get_instance() {
+  static nrf_event& get_instance() {
     static nrf_event instance;
     return instance;
   }
@@ -67,8 +67,8 @@ class nrf_event {
    * @param [uint64_t] start:
    * @return void
    */
-  bs2::connection subscribe_task_tick(const task_sig_t::slot_type &sig,
-                                      uint64_t period, uint64_t start = 0);
+  bs2::connection subscribe_task_tick(
+      const task_sig_t::slot_type& sig, uint64_t period, uint64_t start = 0);
 
   /*
    * Subscribe to the extended task tick event
@@ -78,7 +78,7 @@ class nrf_event {
    * @return void
    */
   bs2::connection subscribe_task_tick_extended(
-      const task_sig_t::extended_slot_type &sig, uint64_t period,
+      const task_sig_t::extended_slot_type& sig, uint64_t period,
       uint64_t start = 0);
 
   /*
@@ -89,16 +89,16 @@ class nrf_event {
    * @return void
    */
   bs2::connection subscribe_nf_status_change(
-      const nf_status_change_sig_t::slot_type &sig);
+      const nf_status_change_sig_t::slot_type& sig);
 
   bs2::connection subscribe_nf_status_registered(
-      const nf_status_sig_t::slot_type &sig);
+      const nf_status_sig_t::slot_type& sig);
 
   bs2::connection subscribe_nf_status_deregistered(
-      const nf_deregistered_sig_t::slot_type &sig);
+      const nf_deregistered_sig_t::slot_type& sig);
 
   bs2::connection subscribe_nf_status_profile_changed(
-      const nf_status_sig_t::slot_type &sig);
+      const nf_status_sig_t::slot_type& sig);
 
  private:
   task_sig_t task_tick;

src/nrf_app/nrf_event_sig.hpp

@@ -40,23 +40,23 @@ namespace app {
 
 class nrf_profile;
 
-typedef bs2::signal_type<void(uint64_t),
-                         bs2::keywords::mutex_type<bs2::dummy_mutex>>::type
+typedef bs2::signal_type<
+    void(uint64_t), bs2::keywords::mutex_type<bs2::dummy_mutex>>::type
     task_sig_t;
 
 // Signal for NF Status
 // Subscription ID, NF Status
-typedef bs2::signal_type<void(const std::string &),
-                         bs2::keywords::mutex_type<bs2::dummy_mutex>>::type
+typedef bs2::signal_type<
+    void(const std::string&), bs2::keywords::mutex_type<bs2::dummy_mutex>>::type
     nf_status_sig_t;
 
-typedef bs2::signal_type<void(const std::shared_ptr<nrf_profile> &p),
-                         bs2::keywords::mutex_type<bs2::dummy_mutex>>::type
-    nf_deregistered_sig_t;
+typedef bs2::signal_type<
+    void(const std::shared_ptr<nrf_profile>& p),
+    bs2::keywords::mutex_type<bs2::dummy_mutex>>::type nf_deregistered_sig_t;
 
-typedef bs2::signal_type<void(const std::shared_ptr<nrf_profile> &p),
-                         bs2::keywords::mutex_type<bs2::dummy_mutex>>::type
-    nf_status_change_sig_t;
+typedef bs2::signal_type<
+    void(const std::shared_ptr<nrf_profile>& p),
+    bs2::keywords::mutex_type<bs2::dummy_mutex>>::type nf_status_change_sig_t;
 
 }  // namespace app
 }  // namespace nrf

src/nrf_app/nrf_jwt.cpp

@@ -36,12 +36,10 @@
 using namespace oai::nrf::app;
 
 //------------------------------------------------------------------------------
-bool nrf_jwt::generate_signature(const std::string &nf_consumer_id,
-                                 const std::string &scope,
-                                 const std::string &nf_type,
-                                 const std::string &target_nf_type,
-                                 const std::string &nrf_instance_id,
-                                 std::string &signature) const {
+bool nrf_jwt::generate_signature(
+    const std::string& nf_consumer_id, const std::string& scope,
+    const std::string& nf_type, const std::string& target_nf_type,
+    const std::string& nrf_instance_id, std::string& signature) const {
   std::string key;
   get_secret_key(scope, nf_type, target_nf_type, key);
   // Create JWT object
@@ -59,11 +57,10 @@ bool nrf_jwt::generate_signature(const std::string &nf_consumer_id,
 }
 
 //------------------------------------------------------------------------------
-bool nrf_jwt::generate_signature(const std::string &nf_consumer_id,
-                                 const std::string &scope,
-                                 const std::string &target_nf_instance_Id,
-                                 const std::string &nrf_instance_id,
-                                 std::string &signature) const {
+bool nrf_jwt::generate_signature(
+    const std::string& nf_consumer_id, const std::string& scope,
+    const std::string& target_nf_instance_Id,
+    const std::string& nrf_instance_id, std::string& signature) const {
   std::string key;
   get_secret_key(scope, target_nf_instance_Id, key);
   // Create JWT object
@@ -81,18 +78,17 @@ bool nrf_jwt::generate_signature(const std::string &nf_consumer_id,
 }
 
 //------------------------------------------------------------------------------
-bool nrf_jwt::get_secret_key(const std::string &scope,
-                             const std::string &nf_type,
-                             const std::string &target_nf_type,
-                             std::string &key) const {
+bool nrf_jwt::get_secret_key(
+    const std::string& scope, const std::string& nf_type,
+    const std::string& target_nf_type, std::string& key) const {
   // TODO:
   key = "secret";
 }
 
 //------------------------------------------------------------------------------
-bool nrf_jwt::get_secret_key(const std::string &scope,
-                             const std::string &target_nf_instance_Id,
-                             std::string &key) const {
+bool nrf_jwt::get_secret_key(
+    const std::string& scope, const std::string& target_nf_instance_Id,
+    std::string& key) const {
   // TODO:
   key = "secret";
 }

src/nrf_app/nrf_jwt.hpp

@@ -53,11 +53,10 @@ class nrf_jwt {
    * @param [std::string &] signature: generated signature
    * @return void
    */
-  bool generate_signature(const std::string &nf_consumer_id,
-                          const std::string &scope, const std::string &nf_type,
-                          const std::string &target_nf_type,
-                          const std::string &nrf_instance_id,
-                          std::string &signature) const;
+  bool generate_signature(
+      const std::string& nf_consumer_id, const std::string& scope,
+      const std::string& nf_type, const std::string& target_nf_type,
+      const std::string& nrf_instance_id, std::string& signature) const;
 
   /*
    * Generate signature for the requested consumer
@@ -70,11 +69,10 @@ class nrf_jwt {
    * @param [std::string &] signature: generated signature
    * @return void
    */
-  bool generate_signature(const std::string &nf_consumer_id,
-                          const std::string &scope,
-                          const std::string &target_nf_instance_Id,
-                          const std::string &nrf_instance_id,
-                          std::string &signature) const;
+  bool generate_signature(
+      const std::string& nf_consumer_id, const std::string& scope,
+      const std::string& target_nf_instance_Id,
+      const std::string& nrf_instance_id, std::string& signature) const;
 
   /*
    * Get the secret key
@@ -85,9 +83,9 @@ class nrf_jwt {
    * @param [std::string &] key: secret key
    * @return void
    */
-  bool get_secret_key(const std::string &scope, const std::string &nf_type,
-                      const std::string &target_nf_type,
-                      std::string &key) const;
+  bool get_secret_key(
+      const std::string& scope, const std::string& nf_type,
+      const std::string& target_nf_type, std::string& key) const;
 
   /*
    * Get the secret key
@@ -98,9 +96,9 @@ class nrf_jwt {
    * @param [std::string &] key: secret key
    * @return void
    */
-  bool get_secret_key(const std::string &scope,
-                      const std::string &target_nf_instance_Id,
-                      std::string &key) const;
+  bool get_secret_key(
+      const std::string& scope, const std::string& target_nf_instance_Id,
+      std::string& key) const;
 };
 
 }  // namespace app

src/nrf_app/nrf_search_result.cpp

@@ -36,29 +36,35 @@
 using namespace oai::nrf::app;
 
 //------------------------------------------------------------------------------
-void nrf_search_result::set_search_id(const std::string &id) { search_id = id; }
+void nrf_search_result::set_search_id(const std::string& id) {
+  search_id = id;
+}
 
 //------------------------------------------------------------------------------
-void nrf_search_result::get_search_id(std::string &id) const { id = search_id; }
+void nrf_search_result::get_search_id(std::string& id) const {
+  id = search_id;
+}
 
 //------------------------------------------------------------------------------
-std::string nrf_search_result::get_search_id() const { return search_id; }
+std::string nrf_search_result::get_search_id() const {
+  return search_id;
+}
 
 //------------------------------------------------------------------------------
 void nrf_search_result::set_nf_instances(
-    const std::vector<std::shared_ptr<nrf_profile>> &instances) {
+    const std::vector<std::shared_ptr<nrf_profile>>& instances) {
   nf_instances = instances;
 }
 
 //------------------------------------------------------------------------------
 void nrf_search_result::add_nf_instance(
-    const std::shared_ptr<nrf_profile> &instance) {
+    const std::shared_ptr<nrf_profile>& instance) {
   nf_instances.push_back(instance);
 }
 
 //------------------------------------------------------------------------------
 void nrf_search_result::get_nf_instances(
-    std::vector<std::shared_ptr<nrf_profile>> &instances) const {
+    std::vector<std::shared_ptr<nrf_profile>>& instances) const {
   instances = nf_instances;
 }
 
@@ -69,12 +75,12 @@ std::vector<std::shared_ptr<nrf_profile>> nrf_search_result::get_nf_instances()
 }
 
 //------------------------------------------------------------------------------
-void nrf_search_result::set_validity_period(const uint64_t &p) {
+void nrf_search_result::set_validity_period(const uint64_t& p) {
   validity_period = p;
 }
 
 //------------------------------------------------------------------------------
-void nrf_search_result::get_validity_period(uint64_t &p) const {
+void nrf_search_result::get_validity_period(uint64_t& p) const {
   p = validity_period;
 }
 
@@ -84,22 +90,22 @@ uint64_t nrf_search_result::get_validity_period() const {
 }
 
 //------------------------------------------------------------------------------
-void nrf_search_result::set_num_nf_inst_complete(const uint32_t &n) {
+void nrf_search_result::set_num_nf_inst_complete(const uint32_t& n) {
   num_nf_inst_complete = n;
 }
 
 //------------------------------------------------------------------------------
-void nrf_search_result::get_num_nf_inst_complete(uint32_t &n) const {
+void nrf_search_result::get_num_nf_inst_complete(uint32_t& n) const {
   n = num_nf_inst_complete;
 }
 
 //------------------------------------------------------------------------------
-void nrf_search_result::set_limit_nf_instances(const uint32_t &l) {
+void nrf_search_result::set_limit_nf_instances(const uint32_t& l) {
   limit_nf_instances = l;
 }
 
 //------------------------------------------------------------------------------
-void nrf_search_result::get_limit_nf_instances(uint32_t &l) const {
+void nrf_search_result::get_limit_nf_instances(uint32_t& l) const {
   l = limit_nf_instances;
 }
 
@@ -121,8 +127,8 @@ void nrf_search_result::display() {
 }
 
 //------------------------------------------------------------------------------
-void nrf_search_result::to_json(nlohmann::json &data,
-                                const uint32_t &limit_nfs) const {
+void nrf_search_result::to_json(
+    nlohmann::json& data, const uint32_t& limit_nfs) const {
   data = {};
 
   data["validityPeriod"] = validity_period;

src/nrf_app/nrf_search_result.hpp

@@ -44,27 +44,27 @@ class nrf_search_result {
   nrf_search_result() {
     limit_nf_instances = 10;  // default value, TODO: to be removed
   };
-  nrf_search_result(nrf_search_result const &) = delete;
+  nrf_search_result(nrf_search_result const&) = delete;
 
   virtual ~nrf_search_result() {
     Logger::nrf_app().debug("Delete NRF Subscription instance...");
   }
 
-  void operator=(nrf_search_result const &) = delete;
+  void operator=(nrf_search_result const&) = delete;
 
   /*
    * Set the search id
    * @param [const std::string &]: id: Search id
    * @return void
    */
-  void set_search_id(const std::string &id);
+  void set_search_id(const std::string& id);
 
   /*
    * Get the search id
    * @param [std::string &]: id: search id
    * @return void
    */
-  void get_search_id(std::string &id) const;
+  void get_search_id(std::string& id) const;
 
   /*
    * Get the search id
@@ -80,7 +80,7 @@ class nrf_search_result {
    * @return void
    */
   void set_nf_instances(
-      const std::vector<std::shared_ptr<nrf_profile>> &instances);
+      const std::vector<std::shared_ptr<nrf_profile>>& instances);
 
   /*
    * Add an nf instance to the list of nrf profile instances
@@ -88,7 +88,7 @@ class nrf_search_result {
    * instance
    * @return void
    */
-  void add_nf_instance(const std::shared_ptr<nrf_profile> &instance);
+  void add_nf_instance(const std::shared_ptr<nrf_profile>& instance);
 
   /*
    * Get the nf instances
@@ -97,7 +97,7 @@ class nrf_search_result {
    * @return void
    */
   void get_nf_instances(
-      std::vector<std::shared_ptr<nrf_profile>> &instances) const;
+      std::vector<std::shared_ptr<nrf_profile>>& instances) const;
 
   /*
    * Get the nf instances
@@ -112,14 +112,14 @@ class nrf_search_result {
    * @param [const uint64_t &] p: validity period
    * @return
    */
-  void set_validity_period(const uint64_t &v);
+  void set_validity_period(const uint64_t& v);
 
   /*
    * Get the validity period
    * @param [uint64_t &]p:  validity period
    * @return
    */
-  void get_validity_period(uint64_t &p) const;
+  void get_validity_period(uint64_t& p) const;
 
   /*
    * Get the validity period
@@ -133,14 +133,14 @@ class nrf_search_result {
    * @param [const uint32_t &] n: the total number of NF Instances found by NRF
    * @return void
    */
-  void set_num_nf_inst_complete(const uint32_t &n);
+  void set_num_nf_inst_complete(const uint32_t& n);
 
   /*
    * Get the the total number of NF Instances found by NRF
    * @param [uint32_t &] n: the total number of NF Instances found by NRF
    * @return void
    */
-  void get_num_nf_inst_complete(uint32_t &n) const;
+  void get_num_nf_inst_complete(uint32_t& n) const;
 
   /*
    * Set the maximum number of NFProfiles to be returned in the response
@@ -148,7 +148,7 @@ class nrf_search_result {
    * returned in the response
    * @return void
    */
-  void set_limit_nf_instances(const uint32_t &l);
+  void set_limit_nf_instances(const uint32_t& l);
 
   /*
    * Get the maximum number of NFProfiles to be returned in the response
@@ -156,7 +156,7 @@ class nrf_search_result {
    * the response
    * @return void
    */
-  void get_limit_nf_instances(uint32_t &l) const;
+  void get_limit_nf_instances(uint32_t& l) const;
 
   /*
    * Get the maximum number of NFProfiles to be returned in the response
@@ -179,7 +179,7 @@ class nrf_search_result {
    * json data 0, means without any restriction
    * @return void
    */
-  void to_json(nlohmann::json &data, const uint32_t &limit_nfs) const;
+  void to_json(nlohmann::json& data, const uint32_t& limit_nfs) const;
 
  private:
   std::vector<std::shared_ptr<nrf_profile>> nf_instances;

src/nrf_app/nrf_subscription.cpp

@@ -37,12 +37,12 @@
 using namespace oai::nrf::app;
 
 //------------------------------------------------------------------------------
-void nrf_subscription::set_subscription_id(const std::string &sub) {
+void nrf_subscription::set_subscription_id(const std::string& sub) {
   subscription_id = sub;
 }
 
 //------------------------------------------------------------------------------
-void nrf_subscription::get_subscription_id(std::string &sub) const {
+void nrf_subscription::get_subscription_id(std::string& sub) const {
   sub = subscription_id;
 }
 
@@ -53,23 +53,23 @@ std::string nrf_subscription::get_subscription_id() const {
 
 //------------------------------------------------------------------------------
 void nrf_subscription::set_notification_uri(
-    const std::string &notification_uri) {
+    const std::string& notification_uri) {
   nf_status_notification_uri = notification_uri;
 }
 
 //------------------------------------------------------------------------------
 void nrf_subscription::get_notification_uri(
-    std::string &notification_uri) const {
+    std::string& notification_uri) const {
   notification_uri = nf_status_notification_uri;
 }
 
 //------------------------------------------------------------------------------
-void nrf_subscription::set_sub_condition(const subscription_condition_t &c) {
+void nrf_subscription::set_sub_condition(const subscription_condition_t& c) {
   sub_condition = c;
 }
 
 //------------------------------------------------------------------------------
-void nrf_subscription::get_sub_condition(subscription_condition_t &c) const {
+void nrf_subscription::get_sub_condition(subscription_condition_t& c) const {
   c = sub_condition;
 }
 
@@ -81,17 +81,17 @@ subscription_condition_t nrf_subscription::get_sub_condition() const {
 */
 
 //------------------------------------------------------------------------------
-void nrf_subscription::set_notif_events(const std::vector<uint8_t> &ev_types) {
+void nrf_subscription::set_notif_events(const std::vector<uint8_t>& ev_types) {
   notif_events = ev_types;
 }
 
 //------------------------------------------------------------------------------
-void nrf_subscription::add_notif_event(const uint8_t &ev_type) {
+void nrf_subscription::add_notif_event(const uint8_t& ev_type) {
   notif_events.push_back(ev_type);
 }
 
 //------------------------------------------------------------------------------
-void nrf_subscription::get_notif_events(std::vector<uint8_t> &ev_types) const {
+void nrf_subscription::get_notif_events(std::vector<uint8_t>& ev_types) const {
   ev_types = notif_events;
 }
 
@@ -101,12 +101,12 @@ std::vector<uint8_t> nrf_subscription::get_notif_events() const {
 }
 
 //------------------------------------------------------------------------------
-void nrf_subscription::set_validity_time(const boost::posix_time::ptime &t) {
+void nrf_subscription::set_validity_time(const boost::posix_time::ptime& t) {
   validity_time = t;
 }
 
 //------------------------------------------------------------------------------
-void nrf_subscription::get_validity_time(boost::posix_time::ptime &t) const {
+void nrf_subscription::get_validity_time(boost::posix_time::ptime& t) const {
   t = validity_time;
 }
 
@@ -120,18 +120,18 @@ void nrf_subscription::display() {
   Logger::nrf_app().debug("Subscription information");
   Logger::nrf_app().debug("\tSub ID: %s", subscription_id.c_str());
 
-  Logger::nrf_app().debug("\tNotification URI: %s",
-                          nf_status_notification_uri.c_str());
-  Logger::nrf_app().debug("\tSubscription condition: %s",
-                          sub_condition.to_string().c_str());
+  Logger::nrf_app().debug(
+      "\tNotification URI: %s", nf_status_notification_uri.c_str());
+  Logger::nrf_app().debug(
+      "\tSubscription condition: %s", sub_condition.to_string().c_str());
 
   std::string notif_events_str = {};
   for (auto n : notif_events) {
     notif_events_str.append(notification_event_type_e2str[n]);
     notif_events_str.append(", ");
   }
-  Logger::nrf_app().debug("\tNotification Events: %s",
-                          notif_events_str.c_str());
+  Logger::nrf_app().debug(
+      "\tNotification Events: %s", notif_events_str.c_str());
   Logger::nrf_app().debug(
       "\tValidity time: %s",
       boost::posix_time::to_iso_string(validity_time).c_str());
@@ -142,13 +142,13 @@ void nrf_subscription::subscribe_nf_status_registered() {
   Logger::nrf_app().debug("Subscribe to NF status change event");
   ev_connection =
       m_event_sub.subscribe_nf_status_change(  // TODO: To be updated
-          boost::bind(&nrf_subscription::handle_nf_status_registered, this,
-                      _1));
+          boost::bind(
+              &nrf_subscription::handle_nf_status_registered, this, _1));
 }
 
 //------------------------------------------------------------------------------
 void nrf_subscription::handle_nf_status_registered(
-    const std::shared_ptr<nrf_profile> &profile) {
+    const std::shared_ptr<nrf_profile>& profile) {
   std::string nf_instance_id;
   profile.get()->get_nf_instance_id(nf_instance_id);
   Logger::nrf_app().info(

src/nrf_app/nrf_subscription.hpp

@@ -44,32 +44,32 @@ using namespace std;
 
 class nrf_subscription {
  public:
-  nrf_subscription(nrf_event &ev) : m_event_sub(ev) {
+  nrf_subscription(nrf_event& ev) : m_event_sub(ev) {
     validity_time = boost::posix_time::from_iso_string("20991231T235959Z");
   };
 
-  nrf_subscription(nrf_subscription const &) = delete;
+  nrf_subscription(nrf_subscription const&) = delete;
 
   virtual ~nrf_subscription() {
     Logger::nrf_app().debug("Delete NRF Subscription instance...");
     if (ev_connection.connected()) ev_connection.disconnect();
   }
 
-  void operator=(nrf_subscription const &) = delete;
+  void operator=(nrf_subscription const&) = delete;
 
   /*
    * Set the subscription id
    * @param [const std::string &]: sub_id: Subscription id
    * @return void
    */
-  void set_subscription_id(const std::string &sub_id);
+  void set_subscription_id(const std::string& sub_id);
 
   /*
    * Get the subscription id
    * @param [std::string &]: sub_id: Subscription id
    * @return void
    */
-  void get_subscription_id(std::string &sub_id) const;
+  void get_subscription_id(std::string& sub_id) const;
 
   /*
    * Get the subscription id
@@ -83,28 +83,28 @@ class nrf_subscription {
    * @param [const std::string &]: notification_uri: Notification URI
    * @return void
    */
-  void set_notification_uri(const std::string &notification_uri);
+  void set_notification_uri(const std::string& notification_uri);
 
   /*
    * Get the notification URI (URI where the notification will be sent to)
    * @param [std::string &]: notification_uri: Notification URI
    * @return void
    */
-  void get_notification_uri(std::string &notification_uri) const;
+  void get_notification_uri(std::string& notification_uri) const;
 
   /*
    * Set the subscription condition
    * @param [const subscription_condition_t &]: c: Subscription condition
    * @return void
    */
-  void set_sub_condition(const subscription_condition_t &c);
+  void set_sub_condition(const subscription_condition_t& c);
 
   /*
    * Get the subscription condition
    * @param [const subscription_condition_t &]: c: Subscription condition
    * @return void
    */
-  void get_sub_condition(subscription_condition_t &c) const;
+  void get_sub_condition(subscription_condition_t& c) const;
   // subscription_condition_t get_sub_condition() const;
 
   /*
@@ -113,14 +113,14 @@ class nrf_subscription {
    * event types
    * @return void
    */
-  void set_notif_events(const std::vector<uint8_t> &ev_types);
+  void set_notif_events(const std::vector<uint8_t>& ev_types);
 
   /*
    * Add a notification type to the list of notification events
    * @param [const uint8_t &]: ev_type: A notification type
    * @return void
    */
-  void add_notif_event(const uint8_t &ev_type);
+  void add_notif_event(const uint8_t& ev_type);
 
   /*
    * Get the notification events
@@ -128,7 +128,7 @@ class nrf_subscription {
    * types
    * @return void
    */
-  void get_notif_events(std::vector<uint8_t> &ev_types) const;
+  void get_notif_events(std::vector<uint8_t>& ev_types) const;
 
   /*
    * Get the notification events
@@ -142,14 +142,14 @@ class nrf_subscription {
    * @param [const boost::posix_time::ptime &]t:  validity time
    * @return
    */
-  void set_validity_time(const boost::posix_time::ptime &t);
+  void set_validity_time(const boost::posix_time::ptime& t);
 
   /*
    * Get the validity time
    * @param [boost::posix_time::ptime &]t:  validity time
    * @return
    */
-  void get_validity_time(boost::posix_time::ptime &t) const;
+  void get_validity_time(boost::posix_time::ptime& t) const;
 
   /*
    * Get the validity time
@@ -171,7 +171,7 @@ class nrf_subscription {
    * registered NF profile
    * @return void
    */
-  void handle_nf_status_registered(const std::shared_ptr<nrf_profile> &profile);
+  void handle_nf_status_registered(const std::shared_ptr<nrf_profile>& profile);
 
   /*
    * Display all the members of a subscription
@@ -185,7 +185,7 @@ class nrf_subscription {
   std::string subscription_id;
   subscription_condition_t sub_condition;
   std::vector<uint8_t> notif_events;
-  nrf_event &m_event_sub;
+  nrf_event& m_event_sub;
   bs2::connection ev_connection;
   boost::posix_time::ptime validity_time;
 };

src/nrf_app/task_manager.cpp

@@ -38,7 +38,7 @@
 using namespace oai::nrf::app;
 
 //------------------------------------------------------------------------------
-task_manager::task_manager(nrf_event &ev) : event_sub_(ev) {
+task_manager::task_manager(nrf_event& ev) : event_sub_(ev) {
   struct itimerspec its;
 
   sfd = timerfd_create(CLOCK_MONOTONIC, 0);
@@ -55,7 +55,9 @@ task_manager::task_manager(nrf_event &ev) : event_sub_(ev) {
 }
 
 //------------------------------------------------------------------------------
-void task_manager::run() { manage_tasks(); }
+void task_manager::run() {
+  manage_tasks();
+}
 
 //------------------------------------------------------------------------------
 void task_manager::manage_tasks() {