BLE: Address code formating issue in CordioPalGap implementation.

features/FEATURE_BLE/targets/TARGET_CORDIO/source/CordioPalGap.cpp

@@ -25,27 +25,33 @@ namespace cordio {
 
 bool Gap::is_feature_supported(
     ble::controller_supported_features_t feature
-) {
+)
+{
     return (HciGetLeSupFeat() & (1 << feature.value()));
 }
 
-ble_error_t Gap::initialize() {
+ble_error_t Gap::initialize()
+{
     return BLE_ERROR_NONE;
 }
 
-ble_error_t Gap::terminate() {
+ble_error_t Gap::terminate()
+{
     return BLE_ERROR_NONE;
 }
 
-address_t Gap::get_device_address() {
+address_t Gap::get_device_address()
+{
     return address_t(HciGetBdAddr());
 }
 
-address_t Gap::get_random_address() {
+address_t Gap::get_random_address()
+{
     return device_random_address;
 }
 
-ble_error_t Gap::set_random_address(const address_t& address) {
+ble_error_t Gap::set_random_address(const address_t &address)
+{
     device_random_address = address;
     DmDevSetRandAddr(const_cast<uint8_t *>(address.data()));
     return BLE_ERROR_NONE;
@@ -60,7 +66,8 @@ ble_error_t Gap::set_advertising_parameters(
     const address_t &peer_address,
     advertising_channel_map_t advertising_channel_map,
     advertising_filter_policy_t advertising_filter_policy
-) {
+)
+{
     DmAdvSetInterval(
         DM_ADV_HANDLE_DEFAULT,
         advertising_interval_min,
@@ -92,7 +99,8 @@ ble_error_t Gap::set_advertising_parameters(
 ble_error_t Gap::set_advertising_data(
     uint8_t advertising_data_length,
     const advertising_data_t &advertising_data
-) {
+)
+{
     DmAdvSetData(
         DM_ADV_HANDLE_DEFAULT,
         HCI_ADV_DATA_OP_COMP_FRAG,
@@ -106,7 +114,8 @@ ble_error_t Gap::set_advertising_data(
 ble_error_t Gap::set_scan_response_data(
     uint8_t scan_response_data_length,
     const advertising_data_t &scan_response_data
-) {
+)
+{
     DmAdvSetData(
         DM_ADV_HANDLE_DEFAULT,
         HCI_ADV_DATA_OP_COMP_FRAG,
@@ -117,7 +126,8 @@ ble_error_t Gap::set_scan_response_data(
     return BLE_ERROR_NONE;
 }
 
-ble_error_t Gap::advertising_enable(bool enable) {
+ble_error_t Gap::advertising_enable(bool enable)
+{
     if (enable) {
         uint8_t adv_handles[] = {DM_ADV_HANDLE_DEFAULT};
         uint16_t adv_durations[] = { /* infinite */ 0};
@@ -136,7 +146,8 @@ ble_error_t Gap::set_scan_parameters(
     uint16_t scan_window,
     own_address_type_t own_address_type,
     scanning_filter_policy_t filter_policy
-) {
+)
+{
     use_active_scanning = active_scanning;
     DmScanSetInterval(HCI_INIT_PHY_LE_1M_BIT, &scan_interval, &scan_window);
     DmScanSetAddrType(own_address_type.value());
@@ -150,7 +161,8 @@ ble_error_t Gap::set_scan_parameters(
 ble_error_t Gap::scan_enable(
     bool enable,
     bool filter_duplicates
-) {
+)
+{
     if (enable) {
         uint8_t scanType = use_active_scanning ? DM_SCAN_TYPE_ACTIVE : DM_SCAN_TYPE_PASSIVE;
         DmScanStart(
@@ -180,7 +192,8 @@ ble_error_t Gap::create_connection(
     uint16_t supervision_timeout,
     uint16_t minimum_connection_event_length,
     uint16_t maximum_connection_event_length
-) {
+)
+{
     DmConnSetScanInterval(scan_interval, scan_window);
     DmDevSetFilterPolicy(DM_FILT_POLICY_MODE_INIT, initiator_policy.value());
     DmConnSetAddrType(own_address_type.value());
@@ -209,7 +222,8 @@ ble_error_t Gap::create_connection(
     return BLE_ERROR_NONE;
 }
 
-ble_error_t Gap::cancel_connection_creation() {
+ble_error_t Gap::cancel_connection_creation()
+{
     DmConnClose(
         DM_CLIENT_ID_APP,
         /* connection handle - invalid */ DM_CONN_ID_NONE,
@@ -218,11 +232,13 @@ ble_error_t Gap::cancel_connection_creation() {
     return BLE_ERROR_NONE;
 }
 
-uint8_t Gap::read_white_list_capacity() {
+uint8_t Gap::read_white_list_capacity()
+{
     return HciGetWhiteListSize();
 }
 
-ble_error_t Gap::clear_whitelist() {
+ble_error_t Gap::clear_whitelist()
+{
     DmDevWhiteListClear();
     return BLE_ERROR_NONE;
 }
@@ -230,7 +246,8 @@ ble_error_t Gap::clear_whitelist() {
 ble_error_t Gap::add_device_to_whitelist(
     whitelist_address_type_t address_type,
     address_t address
-) {
+)
+{
     DmDevWhiteListAdd(
         address_type.value(),
         const_cast<uint8_t *>(address.data())
@@ -241,7 +258,8 @@ ble_error_t Gap::add_device_to_whitelist(
 ble_error_t Gap::remove_device_from_whitelist(
     whitelist_address_type_t address_type,
     address_t address
-) {
+)
+{
     DmDevWhiteListRemove(
         address_type.value(),
         const_cast<uint8_t *>(address.data())
@@ -257,7 +275,8 @@ ble_error_t Gap::connection_parameters_update(
     uint16_t supervision_timeout,
     uint16_t minimum_connection_event_length,
     uint16_t maximum_connection_event_length
-) {
+)
+{
     if (DmConnCheckIdle(connection) != 0) {
         return BLE_ERROR_INVALID_STATE;
     }
@@ -286,7 +305,8 @@ ble_error_t Gap::accept_connection_parameter_request(
     uint16_t supervision_timeout,
     uint16_t minimum_connection_event_length,
     uint16_t maximum_connection_event_length
-) {
+)
+{
     hciConnSpec_t connection_spec = {
         interval_min,
         interval_max,
@@ -302,7 +322,8 @@ ble_error_t Gap::accept_connection_parameter_request(
 ble_error_t Gap::reject_connection_parameter_request(
     connection_handle_t connection_handle,
     hci_error_code_t rejection_reason
-) {
+)
+{
     DmRemoteConnParamReqNegReply(
         connection_handle,
         rejection_reason.value()
@@ -313,7 +334,8 @@ ble_error_t Gap::reject_connection_parameter_request(
 ble_error_t Gap::disconnect(
     connection_handle_t connection,
     disconnection_reason_t disconnection_reason
-) {
+)
+{
     DmConnClose(
         DM_CLIENT_ID_APP,
         connection,
@@ -322,19 +344,22 @@ ble_error_t Gap::disconnect(
     return BLE_ERROR_NONE;
 }
 
-bool Gap::is_privacy_supported() {
+bool Gap::is_privacy_supported()
+{
     // We only support controller-based privacy, so return whether the controller supports it
     return HciLlPrivacySupported();
 }
 
 ble_error_t Gap::set_address_resolution(
     bool enable
-) {
+)
+{
     DmPrivSetAddrResEnable(enable);
     return BLE_ERROR_NONE;
 }
 
-ble_error_t Gap::read_phy(connection_handle_t connection) {
+ble_error_t Gap::read_phy(connection_handle_t connection)
+{
     if (is_feature_supported(controller_supported_features_t::LE_2M_PHY)
         || is_feature_supported(controller_supported_features_t::LE_CODED_PHY)) {
         DmReadPhy(connection);
@@ -346,7 +371,8 @@ ble_error_t Gap::read_phy(connection_handle_t connection) {
 ble_error_t Gap::set_preferred_phys(
     const phy_set_t &tx_phys,
     const phy_set_t &rx_phys
-) {
+)
+{
     DmSetDefaultPhy(
         create_all_phys_value(tx_phys, rx_phys),
         tx_phys.value(),
@@ -361,7 +387,8 @@ ble_error_t Gap::set_phy(
     const phy_set_t &tx_phys,
     const phy_set_t &rx_phys,
     coded_symbol_per_bit_t coded_symbol
-) {
+)
+{
     /* if phy set is empty set corresponding all_phys bit to 1 */
     uint8_t all_phys = 0;
     if (tx_phys.value() == 0) {
@@ -383,7 +410,8 @@ ble_error_t Gap::set_phy(
 }
 
 // singleton of the ARM Cordio client
-Gap& Gap::get_gap() {
+Gap &Gap::get_gap()
+{
     static Gap _gap;
     return _gap;
 }
@@ -391,7 +419,8 @@ Gap& Gap::get_gap() {
 /**
  * Callback which handle wsfMsgHdr_t and forward them to emit_gap_event.
  */
-void Gap::gap_handler(const wsfMsgHdr_t* msg) {
+void Gap::gap_handler(const wsfMsgHdr_t *msg)
+{
     typedef bool (*event_handler_t)(const wsfMsgHdr_t *msg);
 
     if (msg == NULL) {
@@ -415,7 +444,8 @@ void Gap::gap_handler(const wsfMsgHdr_t* msg) {
                 (ble::phy_t::type) evt->txPhy,
                 (ble::phy_t::type) evt->rxPhy
             );
-        } break;
+        }
+        break;
 
         case DM_PHY_UPDATE_IND: {
             if (!handler) {
@@ -430,7 +460,8 @@ void Gap::gap_handler(const wsfMsgHdr_t* msg) {
                 (ble::phy_t::type) evt->txPhy,
                 (ble::phy_t::type) evt->rxPhy
             );
-        } break;
+        }
+        break;
 
         case DM_PER_ADV_SYNC_EST_IND: {
             if (!handler) {
@@ -449,7 +480,8 @@ void Gap::gap_handler(const wsfMsgHdr_t* msg) {
                 evt->perAdvInterval,
                 clock_accuracy_t(evt->clockAccuracy)
             );
-        } break;
+        }
+        break;
 
         case DM_PER_ADV_REPORT_IND: {
             if (!handler) {
@@ -466,7 +498,8 @@ void Gap::gap_handler(const wsfMsgHdr_t* msg) {
                 evt->len,
                 evt->pData
             );
-        } break;
+        }
+        break;
 
         case DM_PER_ADV_SYNC_LOST_IND: {
             if (!handler) {
@@ -475,7 +508,8 @@ void Gap::gap_handler(const wsfMsgHdr_t* msg) {
 
             const hciLePerAdvSyncLostEvt_t *evt = (const hciLePerAdvSyncLostEvt_t *) msg;
             handler->on_periodic_advertising_sync_loss(evt->syncHandle);
-        }  break;
+        }
+        break;
 
         case DM_CONN_OPEN_IND: {
             if (!handler) {
@@ -497,7 +531,8 @@ void Gap::gap_handler(const wsfMsgHdr_t* msg) {
                 evt->supTimeout,
                 clock_accuracy_t(evt->clockAccuracy)
             );
-        } break;
+        }
+        break;
 
         case DM_SCAN_REQ_RCVD_IND: {
             if (!handler) {
@@ -510,7 +545,8 @@ void Gap::gap_handler(const wsfMsgHdr_t* msg) {
                 connection_peer_address_type_t(evt->scanAddrType),
                 evt->scanAddr
             );
-        } break;
+        }
+        break;
 
         case DM_ADV_SET_STOP_IND: {
             if (!handler) {
@@ -524,7 +560,8 @@ void Gap::gap_handler(const wsfMsgHdr_t* msg) {
                 evt->handle,
                 evt->numComplEvts
             );
-        } break;
+        }
+        break;
 
         case DM_EXT_SCAN_STOP_IND: {
             if (!handler) {
@@ -533,7 +570,8 @@ void Gap::gap_handler(const wsfMsgHdr_t* msg) {
 
             const hciLeScanTimeoutEvt_t *evt = (const hciLeScanTimeoutEvt_t *) msg;
             handler->on_scan_timeout();
-        } break;
+        }
+        break;
 
         case DM_EXT_SCAN_REPORT_IND: {
             if (!handler) {
@@ -559,7 +597,8 @@ void Gap::gap_handler(const wsfMsgHdr_t* msg) {
                 evt->len,
                 evt->pData
             );
-        } break;
+        }
+        break;
 
         case DM_CONN_UPDATE_IND: {
             if (!handler) {
@@ -574,7 +613,8 @@ void Gap::gap_handler(const wsfMsgHdr_t* msg) {
                 evt->connLatency,
                 evt->supTimeout
             );
-        } break;
+        }
+        break;
 
         case DM_REM_CONN_PARAM_REQ_IND: {
             if (!handler) {
@@ -589,7 +629,8 @@ void Gap::gap_handler(const wsfMsgHdr_t* msg) {
                 evt->latency,
                 evt->timeout
             );
-        } break;
+        }
+        break;
     }
 
     // all handlers are stored in a static array
@@ -616,7 +657,8 @@ void Gap::gap_handler(const wsfMsgHdr_t* msg) {
  * T shall define a can_convert and convert function and a type
  */
 template<typename T>
-bool Gap::event_handler(const wsfMsgHdr_t* msg) {
+bool Gap::event_handler(const wsfMsgHdr_t *msg)
+{
     if (T::can_convert(msg)) {
         get_gap().emit_gap_event(T::convert((const typename T::type *) msg));
         return true;