Revision 11:bfcf1356027b, committed 2014-01-31

Comitter:

johnb

Date:

Fri Jan 31 23:53:16 2014 +0000

Parent:

10:0d084d0253a7

Child:

12:58319a467943

Commit message:

Switch to using macros to implement the access functions in XBeeApiCmdAtBlocking.; Implement XBeeApiCmdAtBlocking::setChannel()

Changed in this revision

--- a/Utility/XBeeApiCmdAt.cpp	Fri Jan 31 09:29:28 2014 +0000
+++ b/Utility/XBeeApiCmdAt.cpp	Fri Jan 31 23:53:16 2014 +0000
@@ -150,89 +150,107 @@
 
 extern Serial pc;
 
-
-template<typename par>
-bool blockingGet( XBeeApiCmdAtBlocking* p_t, 
-                  bool (XBeeApiCmdAtBlocking::*p_req)( void ), 
-                  bool (XBeeApiCmdAtBlocking::*p_get)( par* const ), 
-                  par* const p_par, 
-                  uint16_t p_timeout, 
-                  uint16_t p_slice )
-{
-    bool ret_val = false;
-    uint16_t counter = p_timeout;
-
-    if( (p_t->*p_get)( p_par ) )
-    {
-        ret_val = true;
-    } 
-    else if( (p_t->*p_req)() )
-    {
-        bool cont = false;
+/** 
+   Macro to wrap around the "requestXXX" & "getXXX" methods and implement a blocking call.
+   This macro is used as the basis for getXXX functions in XBeeApiCmdAtBlocking.
 
-        do{
-            wait_ms( p_slice );
-            if( (p_t->*p_get)( p_par ) )
-            {
-                ret_val = true;
-            }
-            else if( counter > p_slice ) {
-                counter -= p_slice;    
-                cont = true;
-            } 
-        } while( cont );
-    }
-    
+   Originally looked to achieve this using a template function passing method pointers, however 
+   there's no way to get a method pointer to the parent class implementation as opposed to the 
+   implementation in this class, meaning that the result was a recursive method call.  The joys of 
+   polymorphism.
+          
+   e.g. We pass a pointer to method getHardwareVersion().  The function receiving the pointer
+        uses it to make a function call.  The actual function that's called is (correctly)
+        the one implemented in this class, however what we actually wanted in this case
+        was to call the implementation in the base class.  Using static_cast<> doesn't have
+        any effect and taking the address of XBeeApiCmdAt::getHardwareVersion ends up with
+        XBeeApiCmdAtBlocking::getHardwareVersion being called due to polymorphism. */
+#define BLOCKING_GET( _REQ_FN, _GET_FN, _VAR ) \
+    bool ret_val = false; \
+    uint16_t counter = m_timeout; \
+\
+    if( _GET_FN( _VAR ) )\
+    {\
+        ret_val = true;\
+    } \
+    else if( _REQ_FN() )\
+    {\
+        bool cont = false;\
+\
+        do{\
+            wait_ms( m_slice );\
+            if( _GET_FN( _VAR ) )\
+            {\
+                ret_val = true;\
+            }\
+            else if( counter > m_slice ) {\
+                counter -= m_slice;    \
+                cont = true;\
+            } \
+        } while( cont );\
+    }\
+    \
     return( ret_val );
-}
 
-bool XBeeApiCmdAtBlocking::getHardwareVersionS( uint16_t* const p_ver )
-{
-    return XBeeApiCmdAt::getHardwareVersion( p_ver );
-}
+/** 
+   Macro to wrap around the "setXXX" & "getXXX" methods and implement a blocking call.
+   This macro is used as the basis for setXXX functions in XBeeApiCmdAtBlocking.
+*/
+#define BLOCKING_SET( _SET_FN, _GET_FN, _VAR, _TYPE ) \
+    bool ret_val = false; \
+    uint16_t counter = m_timeout; \
+    _TYPE readback; \
+\
+    if( _SET_FN( _VAR ) )\
+    {\
+        bool cont = false;\
+\
+        do{\
+            wait_ms( m_slice );\
+            if( _GET_FN( &readback ) &&\
+               ( readback == p_chan ))\
+            {\
+                ret_val = true;\
+            }\
+            else if( counter > m_slice ) {\
+                counter -= m_slice;    \
+                cont = true;\
+            } \
+        } while( cont );\
+    }\
+    \
+    return( ret_val );
 
-bool XBeeApiCmdAtBlocking::getFirmwareVersionS( uint16_t* const p_ver )
-{
-    return XBeeApiCmdAt::getFirmwareVersion( p_ver );
-}
-
-bool XBeeApiCmdAtBlocking::getChannelS( uint8_t* const p_chan )
-{
-    return XBeeApiCmdAt::getChannel( p_chan );
-}
-
+    
 bool XBeeApiCmdAtBlocking::getHardwareVersion( uint16_t* const p_ver )
 {
-    return blockingGet( this,
-                        &XBeeApiCmdAtBlocking::requestHardwareVersion,
-                        &XBeeApiCmdAtBlocking::getHardwareVersionS,
-                         p_ver,
-                         m_timeout, m_slice );
+    BLOCKING_GET( XBeeApiCmdAt::requestHardwareVersion, 
+                  XBeeApiCmdAt::getHardwareVersion,  
+                  p_ver );
 }
 
 bool XBeeApiCmdAtBlocking::getFirmwareVersion( uint16_t* const p_ver )
 {
-    return blockingGet( this,
-                        &XBeeApiCmdAtBlocking::requestFirmwareVersion,
-                        &XBeeApiCmdAtBlocking::getFirmwareVersionS,
-                        p_ver,
-                        m_timeout, m_slice );
+    BLOCKING_GET( XBeeApiCmdAtBlocking::requestFirmwareVersion,
+                  XBeeApiCmdAtBlocking::getFirmwareVersion,
+                  p_ver );
 }
 
 bool XBeeApiCmdAtBlocking::getChannel( uint8_t* const p_chan )
 {
-    return blockingGet( this,
-                        &XBeeApiCmdAtBlocking::requestChannel,
-                        &XBeeApiCmdAtBlocking::getChannelS,
-                        p_chan,
-                        m_timeout, m_slice );
+    BLOCKING_GET( XBeeApiCmdAtBlocking::requestChannel,
+                  XBeeApiCmdAtBlocking::getChannel,
+                  p_chan );
 }
        
 bool XBeeApiCmdAtBlocking::setChannel( uint8_t const p_chan )
 {
+    BLOCKING_SET( XBeeApiCmdAtBlocking::setChannel,
+                  XBeeApiCmdAtBlocking::getChannel,
+                  p_chan,
+                  uint8_t );    
 }
 
-
 XBeeApiCmdAt::XBeeApiCmdAtFirmwareVersionRequest::XBeeApiCmdAtFirmwareVersionRequest( void ) : XBeeApiFrame( )
 {
      m_apiId = XBEE_CMD_AT_CMD;

--- a/Utility/XBeeApiCmdAt.hpp	Fri Jan 31 09:29:28 2014 +0000
+++ b/Utility/XBeeApiCmdAt.hpp	Fri Jan 31 23:53:16 2014 +0000
@@ -99,23 +99,6 @@
         uint16_t m_timeout;
         uint16_t m_slice;
 
-       /* The following are "shadow" methods which allow access to the methods in the base class
-          which we're overriding.  We need these as we need to be able to pass a method pointer
-          (e.g. to getHardwareVersion() ) and there's no way to get a method pointer to the parent 
-          class implementation as opposed to the implementation in this class.  The joys of 
-          polymorphism.
-          
-          e.g. We pass a pointer to method getHardwareVersion().  The function receiving the pointer
-               uses it to make a function call.  The actual function that's called is (correctly)
-               the one implemented in this class, however what we actually wanted in this case
-               was to call the implementation in the base class.  Using static_cast<> doesn't have
-               any effect and taking the address of XBeeApiCmdAt::getHardwareVersion ends up with
-               XBeeApiCmdAtBlocking::getHardwareVersion being called due to polymorphism. */
-
-       bool getHardwareVersionS( uint16_t* const p_ver );
-       bool getFirmwareVersionS( uint16_t* const p_ver );
-       bool getChannelS( uint8_t* const p_chan );
-
     public:
        XBeeApiCmdAtBlocking( const uint16_t p_timeout = 1000, const uint16_t p_slice = 100);