nanostack mesh: fix coding style

0xc0170 · 0xc0170 · commit 3aab38140aec · 2018-11-15T07:20:12.000Z
diff --git a/features/nanostack/mbed-mesh-api/mbed-mesh-api/MeshInterfaceNanostack.h b/features/nanostack/mbed-mesh-api/mbed-mesh-api/MeshInterfaceNanostack.h
@@ -32,23 +32,35 @@ class Nanostack::Interface : public OnboardNetworkStack::Interface, private mbed
     virtual void attach(mbed::Callback<void(nsapi_event_t, intptr_t)> status_cb);
     virtual nsapi_connection_status_t get_connection_status() const;
 
-    void get_mac_address(uint8_t *buf) const { interface_phy.get_mac_address(buf); }
+    void get_mac_address(uint8_t *buf) const
+    {
+        interface_phy.get_mac_address(buf);
+    }
 
     /**
      * \brief Callback from C-layer
      * \param status state of the network
      * */
     void network_handler(mesh_connection_status_t status);
 
-    int8_t get_interface_id() const { return interface_id; }
-    int8_t get_driver_id() const { return _device_id; }
+    int8_t get_interface_id() const
+    {
+        return interface_id;
+    }
+    int8_t get_driver_id() const
+    {
+        return _device_id;
+    }
 
 private:
     NanostackPhy &interface_phy;
 protected:
     Interface(NanostackPhy &phy);
     virtual nsapi_error_t register_phy();
-    NanostackPhy &get_phy() const { return interface_phy; }
+    NanostackPhy &get_phy() const
+    {
+        return interface_phy;
+    }
     int8_t interface_id;
     int8_t _device_id;
     rtos::Semaphore connect_semaphore;
@@ -62,7 +74,10 @@ class Nanostack::Interface : public OnboardNetworkStack::Interface, private mbed
 class Nanostack::MeshInterface : public Nanostack::Interface {
 protected:
     MeshInterface(NanostackRfPhy &phy) : Interface(phy) { }
-    NanostackRfPhy &get_phy() const { return static_cast<NanostackRfPhy &>(Interface::get_phy()); }
+    NanostackRfPhy &get_phy() const
+    {
+        return static_cast<NanostackRfPhy &>(Interface::get_phy());
+    }
 };
 
 
@@ -116,12 +131,18 @@ class InterfaceNanostack : public virtual NetworkInterface {
     /** Get the interface ID
     /return     Interface identifier
     */
-    int8_t get_interface_id() const { return _interface->get_interface_id(); }
+    int8_t get_interface_id() const
+    {
+        return _interface->get_interface_id();
+    }
 
 protected:
     InterfaceNanostack();
     virtual Nanostack *get_stack(void);
-    Nanostack::Interface *get_interface() const { return _interface; }
+    Nanostack::Interface *get_interface() const
+    {
+        return _interface;
+    }
     virtual nsapi_error_t do_initialize() = 0;
 
     Nanostack::Interface *_interface;
@@ -147,7 +168,10 @@ class MeshInterfaceNanostack : public InterfaceNanostack, public MeshInterface,
 protected:
     MeshInterfaceNanostack() : _phy(NULL) { }
     MeshInterfaceNanostack(NanostackRfPhy *phy) : _phy(phy) { }
-    Nanostack::MeshInterface *get_interface() const { return static_cast<Nanostack::MeshInterface *>(_interface); }
+    Nanostack::MeshInterface *get_interface() const
+    {
+        return static_cast<Nanostack::MeshInterface *>(_interface);
+    }
     NanostackRfPhy *_phy;
 };
 
diff --git a/features/nanostack/mbed-mesh-api/mbed-mesh-api/NanostackEthernetInterface.h b/features/nanostack/mbed-mesh-api/mbed-mesh-api/NanostackEthernetInterface.h
@@ -35,7 +35,10 @@ class Nanostack::EthernetInterface : public Nanostack::Interface {
     EthernetInterface(NanostackEthernetPhy &phy) : Interface(phy) {}
     nsapi_error_t initialize();
 protected:
-    NanostackEthernetPhy &get_phy() const { return static_cast<NanostackEthernetPhy &>(Interface::get_phy()); }
+    NanostackEthernetPhy &get_phy() const
+    {
+        return static_cast<NanostackEthernetPhy &>(Interface::get_phy());
+    }
 };
 
 /** Ethernet interface for Nanostack.
@@ -50,7 +53,10 @@ class NanostackEthernetInterface : public InterfaceNanostack, public EthInterfac
     nsapi_error_t initialize(NanostackEthernetPhy *phy);
 
 protected:
-    Nanostack::EthernetInterface *get_interface() const { return static_cast<Nanostack::EthernetInterface *>(_interface); }
+    Nanostack::EthernetInterface *get_interface() const
+    {
+        return static_cast<Nanostack::EthernetInterface *>(_interface);
+    }
     virtual nsapi_error_t do_initialize();
 
 };
diff --git a/features/nanostack/mbed-mesh-api/source/LoWPANNDInterface.cpp b/features/nanostack/mbed-mesh-api/source/LoWPANNDInterface.cpp
@@ -8,8 +8,7 @@
 #include "ns_trace.h"
 #define TRACE_GROUP "nslp"
 
-class Nanostack::LoWPANNDInterface : public Nanostack::MeshInterface
-{
+class Nanostack::LoWPANNDInterface : public Nanostack::MeshInterface {
 public:
     virtual nsapi_error_t bringup(bool dhcp, const char *ip,
                                   const char *netmask, const char *gw,
@@ -29,7 +28,7 @@ class Nanostack::LoWPANNDInterface : public Nanostack::MeshInterface
 
 Nanostack::LoWPANNDInterface *LoWPANNDInterface::get_interface() const
 {
-    return static_cast<Nanostack::LoWPANNDInterface*>(_interface);
+    return static_cast<Nanostack::LoWPANNDInterface *>(_interface);
 }
 
 nsapi_error_t LoWPANNDInterface::do_initialize()
diff --git a/features/nanostack/mbed-mesh-api/source/MeshInterfaceNanostack.cpp b/features/nanostack/mbed-mesh-api/source/MeshInterfaceNanostack.cpp
@@ -69,7 +69,7 @@ void Nanostack::Interface::attach(
 }
 
 Nanostack::Interface::Interface(NanostackPhy &phy) : interface_phy(phy), interface_id(-1), _device_id(-1),
-      _connect_status(NSAPI_STATUS_DISCONNECTED), _previous_connection_status(NSAPI_STATUS_DISCONNECTED), _blocking(true)
+    _connect_status(NSAPI_STATUS_DISCONNECTED), _previous_connection_status(NSAPI_STATUS_DISCONNECTED), _blocking(true)
 {
     mesh_system_init();
 }
@@ -119,7 +119,7 @@ nsapi_error_t MeshInterfaceNanostack::initialize(NanostackRfPhy *phy)
 void Nanostack::Interface::network_handler(mesh_connection_status_t status)
 {
     if ((status == MESH_CONNECTED || status == MESH_CONNECTED_LOCAL ||
-         status == MESH_CONNECTED_GLOBAL) && _blocking) {
+            status == MESH_CONNECTED_GLOBAL) && _blocking) {
         connect_semaphore.release();
     }
 
@@ -131,10 +131,10 @@ void Nanostack::Interface::network_handler(mesh_connection_status_t status)
             _connect_status = NSAPI_STATUS_LOCAL_UP;
         }
         if (arm_net_address_get(interface_id, ADDR_IPV6_GP, temp_ipv6_global) == 0
-            && (memcmp(temp_ipv6_global, temp_ipv6_local, 16) != 0)) {
+                && (memcmp(temp_ipv6_global, temp_ipv6_local, 16) != 0)) {
             _connect_status = NSAPI_STATUS_GLOBAL_UP;
         }
-    } else if (status == MESH_CONNECTED_LOCAL ) {
+    } else if (status == MESH_CONNECTED_LOCAL) {
         _connect_status = NSAPI_STATUS_LOCAL_UP;
     } else if (status == MESH_CONNECTED_GLOBAL) {
         _connect_status = NSAPI_STATUS_GLOBAL_UP;
diff --git a/features/nanostack/mbed-mesh-api/source/NanostackEMACInterface.cpp b/features/nanostack/mbed-mesh-api/source/NanostackEMACInterface.cpp
@@ -8,16 +8,15 @@
 #include "arm_hal_phy.h"
 #include "EMAC.h"
 
-class EMACPhy : public NanostackEthernetPhy
-{
+class EMACPhy : public NanostackEthernetPhy {
 public:
     EMACPhy(NanostackMemoryManager &mem, EMAC &m);
     virtual int8_t phy_register();
     virtual void get_mac_address(uint8_t *mac);
     virtual void set_mac_address(uint8_t *mac);
 
-    int8_t address_write(phy_address_type_e , uint8_t *);
-    int8_t tx(uint8_t *data_ptr, uint16_t data_len, uint8_t tx_handle,data_protocol_e data_flow);
+    int8_t address_write(phy_address_type_e, uint8_t *);
+    int8_t tx(uint8_t *data_ptr, uint16_t data_len, uint8_t tx_handle, data_protocol_e data_flow);
 
     void emac_phy_rx(emac_mem_buf_t *mem);
 
@@ -34,65 +33,65 @@ static EMACPhy *single_phy;
 
 extern "C"
 {
-static int8_t emac_phy_address_write(phy_address_type_e address_type, uint8_t *address_ptr)
-{
-    return single_phy->address_write(address_type, address_ptr);
-}
+    static int8_t emac_phy_address_write(phy_address_type_e address_type, uint8_t *address_ptr)
+    {
+        return single_phy->address_write(address_type, address_ptr);
+    }
 
-static int8_t emac_phy_interface_state_control(phy_interface_state_e, uint8_t)
-{
-    return -1;
-}
+    static int8_t emac_phy_interface_state_control(phy_interface_state_e, uint8_t)
+    {
+        return -1;
+    }
 
-static int8_t emac_phy_tx(uint8_t *data_ptr, uint16_t data_len, uint8_t tx_handle,data_protocol_e data_flow)
-{
-    return single_phy->tx(data_ptr, data_len, tx_handle, data_flow);
-}
+    static int8_t emac_phy_tx(uint8_t *data_ptr, uint16_t data_len, uint8_t tx_handle, data_protocol_e data_flow)
+    {
+        return single_phy->tx(data_ptr, data_len, tx_handle, data_flow);
+    }
 
-EMACPhy::EMACPhy(NanostackMemoryManager &mem, EMAC &m) : memory_manager(mem), emac(m), device_id(-1)
-{
-    /* Same default address logic as lwIP glue uses */
+    EMACPhy::EMACPhy(NanostackMemoryManager &mem, EMAC &m) : memory_manager(mem), emac(m), device_id(-1)
+    {
+        /* Same default address logic as lwIP glue uses */
 #if (MBED_MAC_ADDRESS_SUM != MBED_MAC_ADDR_INTERFACE)
-    mac_addr[0] = MBED_MAC_ADDR_0;
-    mac_addr[1] = MBED_MAC_ADDR_1;
-    mac_addr[2] = MBED_MAC_ADDR_2;
-    mac_addr[3] = MBED_MAC_ADDR_3;
-    mac_addr[4] = MBED_MAC_ADDR_4;
-    mac_addr[5] = MBED_MAC_ADDR_5;
+        mac_addr[0] = MBED_MAC_ADDR_0;
+        mac_addr[1] = MBED_MAC_ADDR_1;
+        mac_addr[2] = MBED_MAC_ADDR_2;
+        mac_addr[3] = MBED_MAC_ADDR_3;
+        mac_addr[4] = MBED_MAC_ADDR_4;
+        mac_addr[5] = MBED_MAC_ADDR_5;
 #else
-    mbed_mac_address((char *) mac_addr);
+        mbed_mac_address((char *) mac_addr);
 #endif
-    /* We have a default MAC address, so do don't force them to supply one */
-    /* They may or may not update hwaddr with their address */
-    emac.get_hwaddr(mac_addr);
-}
+        /* We have a default MAC address, so do don't force them to supply one */
+        /* They may or may not update hwaddr with their address */
+        emac.get_hwaddr(mac_addr);
+    }
 
 
-void EMACPhy::emac_phy_rx(emac_mem_buf_t *mem)
-{
-    const uint8_t *ptr = NULL;
-    uint8_t *tmpbuf = NULL;
-    uint32_t total_len;
-
-    if (memory_manager.get_next(mem) == NULL) {
-        // Easy contiguous case
-        ptr = static_cast<const uint8_t*>(memory_manager.get_ptr(mem));
-        total_len = memory_manager.get_len(mem);
-    } else {
-        // Nanostack can't accept chunked data - make temporary contiguous copy
-        total_len = memory_manager.get_total_len(mem);
-        ptr = tmpbuf = static_cast<uint8_t *>(ns_dyn_mem_temporary_alloc(total_len));
-        if (tmpbuf) {
-            memory_manager.copy_from_buf(tmpbuf, total_len, mem);
+    void EMACPhy::emac_phy_rx(emac_mem_buf_t *mem)
+    {
+        const uint8_t *ptr = NULL;
+        uint8_t *tmpbuf = NULL;
+        uint32_t total_len;
+
+        if (memory_manager.get_next(mem) == NULL) {
+            // Easy contiguous case
+            ptr = static_cast<const uint8_t *>(memory_manager.get_ptr(mem));
+            total_len = memory_manager.get_len(mem);
+        } else {
+            // Nanostack can't accept chunked data - make temporary contiguous copy
+            total_len = memory_manager.get_total_len(mem);
+            ptr = tmpbuf = static_cast<uint8_t *>(ns_dyn_mem_temporary_alloc(total_len));
+            if (tmpbuf) {
+                memory_manager.copy_from_buf(tmpbuf, total_len, mem);
+            }
         }
-    }
 
-    if (ptr && phy.phy_rx_cb) {
-        phy.phy_rx_cb(ptr, total_len, 0xff, 0, device_id);
+        if (ptr && phy.phy_rx_cb) {
+            phy.phy_rx_cb(ptr, total_len, 0xff, 0, device_id);
+        }
+        ns_dyn_mem_free(tmpbuf);
+        memory_manager.free(mem);
     }
-    ns_dyn_mem_free(tmpbuf);
-    memory_manager.free(mem);
-}
 
 } // extern "C"
 
@@ -106,7 +105,7 @@ int8_t EMACPhy::address_write(phy_address_type_e address_type, uint8_t *address_
     return 0;
 }
 
-int8_t EMACPhy::tx(uint8_t *data_ptr, uint16_t data_len, uint8_t tx_handle,data_protocol_e data_flow)
+int8_t EMACPhy::tx(uint8_t *data_ptr, uint16_t data_len, uint8_t tx_handle, data_protocol_e data_flow)
 {
     emac_mem_buf_t *mem = memory_manager.alloc_pool(data_len, 0);
     if (!mem) {
@@ -126,7 +125,7 @@ int8_t EMACPhy::phy_register()
 
         phy.PHY_MAC = mac_addr;
         phy.address_write = emac_phy_address_write;
-        phy.driver_description = const_cast<char*>("ETH");
+        phy.driver_description = const_cast<char *>("ETH");
         phy.link_type = PHY_LINK_ETHERNET_TYPE;
         phy.phy_MTU = 0;
         phy.phy_header_length = 0;
@@ -153,9 +152,9 @@ int8_t EMACPhy::phy_register()
         emac.set_all_multicast(true);
 
         device_id = arm_net_phy_register(&phy);
-       // driver_readiness_status_callback = driver_status_cb;
+        // driver_readiness_status_callback = driver_status_cb;
 
-        if (device_id < 0){
+        if (device_id < 0) {
             //tr_error("Ethernet Driver failed to register with Stack. RetCode=%i", eth_driver_enabled);
             //driver_readiness_status_callback(0, eth_interface_id);
             emac.power_down();
@@ -188,7 +187,7 @@ nsapi_error_t Nanostack::add_ethernet_interface(EMAC &emac, bool default_if, Nan
     }
 
     if (mac_addr) {
-        single_phy->set_mac_address(const_cast<uint8_t*>(mac_addr));
+        single_phy->set_mac_address(const_cast<uint8_t *>(mac_addr));
     }
 
     Nanostack::EthernetInterface *interface;
diff --git a/features/nanostack/mbed-mesh-api/source/NanostackEthernetInterface.cpp b/features/nanostack/mbed-mesh-api/source/NanostackEthernetInterface.cpp
@@ -44,11 +44,11 @@ nsapi_error_t NanostackEthernetInterface::initialize(NanostackEthernetPhy *phy)
     }
 
     return get_interface()->initialize();
- }
+}
 
 nsapi_error_t Nanostack::EthernetInterface::bringup(bool dhcp, const char *ip,
-                      const char *netmask, const char *gw,
-                      nsapi_ip_stack_t stack, bool blocking)
+                                                    const char *netmask, const char *gw,
+                                                    nsapi_ip_stack_t stack, bool blocking)
 {
     if (stack == IPV4_STACK) {
         return NSAPI_ERROR_UNSUPPORTED;
diff --git a/features/nanostack/mbed-mesh-api/source/NanostackMemoryManager.cpp b/features/nanostack/mbed-mesh-api/source/NanostackMemoryManager.cpp
@@ -19,8 +19,7 @@
 #include "mbed_assert.h"
 #include "NanostackMemoryManager.h"
 
-struct ns_stack_mem_t
-{
+struct ns_stack_mem_t {
     ns_stack_mem_t *next;
     void *payload;
     uint32_t len;
diff --git a/features/nanostack/mbed-mesh-api/source/ThreadInterface.cpp b/features/nanostack/mbed-mesh-api/source/ThreadInterface.cpp
@@ -7,8 +7,7 @@
 #include "ns_trace.h"
 #define TRACE_GROUP "nsth"
 
-class Nanostack::ThreadInterface : public Nanostack::MeshInterface
-{
+class Nanostack::ThreadInterface : public Nanostack::MeshInterface {
 public:
     virtual nsapi_error_t bringup(bool dhcp, const char *ip,
                                   const char *netmask, const char *gw,
@@ -73,7 +72,7 @@ class Nanostack::ThreadInterface : public Nanostack::MeshInterface
 
 Nanostack::ThreadInterface *ThreadInterface::get_interface() const
 {
-    return static_cast<Nanostack::ThreadInterface*>(_interface);
+    return static_cast<Nanostack::ThreadInterface *>(_interface);
 }
 
 nsapi_error_t ThreadInterface::do_initialize()
diff --git a/features/nanostack/mbed-mesh-api/source/ethernet_tasklet.c b/features/nanostack/mbed-mesh-api/source/ethernet_tasklet.c
diff --git a/features/nanostack/mbed-mesh-api/source/mesh_system.c b/features/nanostack/mbed-mesh-api/source/mesh_system.c
diff --git a/features/nanostack/mbed-mesh-api/source/nd_tasklet.c b/features/nanostack/mbed-mesh-api/source/nd_tasklet.c
diff --git a/features/nanostack/mbed-mesh-api/source/thread_tasklet.c b/features/nanostack/mbed-mesh-api/source/thread_tasklet.c

Original file line number	Diff line number	Diff line change
`@@ -69,7 +69,7 @@ void Nanostack::Interface::attach(`
`69`	`69`	`}`
`70`	`70`
`71`	`71`	`Nanostack::Interface::Interface(NanostackPhy &phy) : interface_phy(phy), interface_id(-1), _device_id(-1),`
`72`		`- _connect_status(NSAPI_STATUS_DISCONNECTED), _previous_connection_status(NSAPI_STATUS_DISCONNECTED), _blocking(true)`
	`72`	`+ _connect_status(NSAPI_STATUS_DISCONNECTED), _previous_connection_status(NSAPI_STATUS_DISCONNECTED), _blocking(true)`
`73`	`73`	`{`
`74`	`74`	`mesh_system_init();`
`75`	`75`	`}`
`@@ -119,7 +119,7 @@ nsapi_error_t MeshInterfaceNanostack::initialize(NanostackRfPhy *phy)`
`119`	`119`	`void Nanostack::Interface::network_handler(mesh_connection_status_t status)`
`120`	`120`	`{`
`121`	`121`	`if ((status == MESH_CONNECTED \|\| status == MESH_CONNECTED_LOCAL \|\|`
`122`		`- status == MESH_CONNECTED_GLOBAL) && _blocking) {`
	`122`	`+ status == MESH_CONNECTED_GLOBAL) && _blocking) {`
`123`	`123`	`connect_semaphore.release();`
`124`	`124`	`}`
`125`	`125`
`@@ -131,10 +131,10 @@ void Nanostack::Interface::network_handler(mesh_connection_status_t status)`
`131`	`131`	`_connect_status = NSAPI_STATUS_LOCAL_UP;`
`132`	`132`	`}`
`133`	`133`	`if (arm_net_address_get(interface_id, ADDR_IPV6_GP, temp_ipv6_global) == 0`
`134`		`- && (memcmp(temp_ipv6_global, temp_ipv6_local, 16) != 0)) {`
	`134`	`+ && (memcmp(temp_ipv6_global, temp_ipv6_local, 16) != 0)) {`
`135`	`135`	`_connect_status = NSAPI_STATUS_GLOBAL_UP;`
`136`	`136`	`}`
`137`		`- } else if (status == MESH_CONNECTED_LOCAL ) {`
	`137`	`+ } else if (status == MESH_CONNECTED_LOCAL) {`
`138`	`138`	`_connect_status = NSAPI_STATUS_LOCAL_UP;`
`139`	`139`	`} else if (status == MESH_CONNECTED_GLOBAL) {`
`140`	`140`	`_connect_status = NSAPI_STATUS_GLOBAL_UP;`
Original file line number	Diff line number	Diff line change
`@@ -44,11 +44,11 @@ nsapi_error_t NanostackEthernetInterface::initialize(NanostackEthernetPhy *phy)`
`44`	`44`	`}`
`45`	`45`
`46`	`46`	`return get_interface()->initialize();`
`47`		`- }`
	`47`	`+}`
`48`	`48`
`49`	`49`	`nsapi_error_t Nanostack::EthernetInterface::bringup(bool dhcp, const char *ip,`
`50`		`- const char netmask, const char gw,`
`51`		`- nsapi_ip_stack_t stack, bool blocking)`
	`50`	`+ const char netmask, const char gw,`
	`51`	`+ nsapi_ip_stack_t stack, bool blocking)`
`52`	`52`	`{`
`53`	`53`	`if (stack == IPV4_STACK) {`
`54`	`54`	`return NSAPI_ERROR_UNSUPPORTED;`