Scope hiding fixes

libuavcan/include/uavcan/driver/can.hpp

@@ -38,13 +38,13 @@ struct UAVCAN_EXPORT CanFrame
         std::fill(data, data + MaxDataLen, 0);
     }
 
-    CanFrame(uint32_t id, const uint8_t* data, uint8_t data_len)
-        : id(id)
+    CanFrame(uint32_t arg_id, const uint8_t* arg_data, uint8_t data_len)
+        : id(arg_id)
         , dlc((data_len > MaxDataLen) ? MaxDataLen : data_len)
     {
-        assert(data != NULL);
+        assert(arg_data != NULL);
         assert(data_len == dlc);
-        std::copy(data, data + dlc, this->data);
+        (void)std::copy(arg_data, arg_data + dlc, this->data);
     }
 
     bool operator!=(const CanFrame& rhs) const { return !operator==(rhs); }

libuavcan/include/uavcan/map.hpp

@@ -32,9 +32,9 @@ class UAVCAN_EXPORT MapBase : Noncopyable
         Key key;
         Value value;
         KVPair() { }
-        KVPair(const Key& key, const Value& value)
-            : key(key)
-            , value(value)
+        KVPair(const Key& arg_key, const Value& arg_value)
+            : key(arg_key)
+            , value(arg_value)
         { }
         bool match(const Key& rhs) const { return rhs == key; }
     };

libuavcan/include/uavcan/node/service_client.hpp

@@ -39,10 +39,10 @@ struct UAVCAN_EXPORT ServiceCallResult
     NodeID server_node_id;
     ResponseFieldType& response;      ///< Either response contents or unspecified response structure
 
-    ServiceCallResult(Status status, NodeID server_node_id, ResponseFieldType& response)
-        : status(status)
-        , server_node_id(server_node_id)
-        , response(response)
+    ServiceCallResult(Status arg_status, NodeID arg_server_node_id, ResponseFieldType& arg_response)
+        : status(arg_status)
+        , server_node_id(arg_server_node_id)
+        , response(arg_response)
     {
         assert(server_node_id.isUnicast());
         assert(status == Success || status == ErrorTimeout);

libuavcan/include/uavcan/node/timer.hpp

@@ -30,9 +30,9 @@ struct UAVCAN_EXPORT TimerEvent
     MonotonicTime scheduled_time;
     MonotonicTime real_time;
 
-    TimerEvent(MonotonicTime scheduled_time, MonotonicTime real_time)
-        : scheduled_time(scheduled_time)
-        , real_time(real_time)
+    TimerEvent(MonotonicTime arg_scheduled_time, MonotonicTime arg_real_time)
+        : scheduled_time(arg_scheduled_time)
+        , real_time(arg_real_time)
     { }
 };
 

libuavcan/include/uavcan/protocol/global_time_sync_master.hpp

@@ -21,7 +21,7 @@ class UAVCAN_EXPORT GlobalTimeSyncMaster : protected LoopbackFrameListenerBase
     class IfaceMaster
     {
         Publisher<protocol::GlobalTimeSync> pub_;
-        MonotonicTime prev_pub_mono_;
+        MonotonicTime iface_prev_pub_mono_;
         UtcTime prev_tx_utc_;
         const uint8_t iface_index_;
 

libuavcan/include/uavcan/transport/can_io.hpp

@@ -50,11 +50,11 @@ public:
         uint8_t qos;
         CanIOFlags flags;
 
-        Entry(const CanFrame& frame, MonotonicTime deadline, Qos qos, CanIOFlags flags)
-            : deadline(deadline)
-            , frame(frame)
-            , qos(uint8_t(qos))
-            , flags(flags)
+        Entry(const CanFrame& arg_frame, MonotonicTime arg_deadline, Qos arg_qos, CanIOFlags arg_flags)
+            : deadline(arg_deadline)
+            , frame(arg_frame)
+            , qos(uint8_t(arg_qos))
+            , flags(arg_flags)
         {
             assert((qos == Volatile) || (qos == Persistent));
             IsDynamicallyAllocatable<Entry>::check();

libuavcan/include/uavcan/transport/transfer_listener.hpp

@@ -97,12 +97,12 @@ class UAVCAN_EXPORT TransferListenerBase : public LinkedListNode<TransferListene
     class TimedOutReceiverPredicate
     {
         const MonotonicTime ts_;
-        ITransferBufferManager& bufmgr_;
+        ITransferBufferManager& parent_bufmgr_;
 
     public:
-        TimedOutReceiverPredicate(MonotonicTime ts, ITransferBufferManager& bufmgr)
-            : ts_(ts)
-            , bufmgr_(bufmgr)
+        TimedOutReceiverPredicate(MonotonicTime arg_ts, ITransferBufferManager& arg_bufmgr)
+            : ts_(arg_ts)
+            , parent_bufmgr_(arg_bufmgr)
         { }
 
         bool operator()(const TransferBufferManagerKey& key, const TransferReceiver& value) const;
@@ -186,9 +186,9 @@ public:
             assert(!src_node_id.isValid());
         }
 
-        ExpectedResponseParams(NodeID src_node_id, TransferID transfer_id)
-            : src_node_id(src_node_id)
-            , transfer_id(transfer_id)
+        ExpectedResponseParams(NodeID arg_src_node_id, TransferID arg_transfer_id)
+            : src_node_id(arg_src_node_id)
+            , transfer_id(arg_transfer_id)
         {
             assert(src_node_id.isUnicast());
         }