use virtual methods instead of function pointers (#1726)

src/core/coap/coap_base.cpp

@@ -78,8 +78,8 @@ ThreadError CoapBase::Stop(void)
 
 void CoapBase::HandleUdpReceive(void *aContext, otMessage *aMessage, const otMessageInfo *aMessageInfo)
 {
-    static_cast<CoapBase *>(aContext)->mReceiver(aContext, *static_cast<Message *>(aMessage),
+    static_cast<CoapBase *>(aContext)->Receive(*static_cast<Message *>(aMessage),
-                                                 *static_cast<const Ip6::MessageInfo *>(aMessageInfo));
+                                               *static_cast<const Ip6::MessageInfo *>(aMessageInfo));
 }
 
 ThreadError CoapBase::SendEmptyMessage(Header::Type aType, const Header &aRequestHeader,
@@ -96,7 +96,7 @@ ThreadError CoapBase::SendEmptyMessage(Header::Type aType, const Header &aReques
 
     VerifyOrExit((message = NewMessage(responseHeader)) != NULL, error = kThreadError_NoBufs);
 
-    SuccessOrExit(error = mSender(this, *message, aMessageInfo));
+    SuccessOrExit(error = Send(*message, aMessageInfo));
 
 exit:
 

src/core/coap/coap_base.hpp

@@ -85,26 +85,6 @@ class CoapBase
 {
 public:
 
-    /**
-     * This function pointer is called when CoAP client/server wants to send a message.
-     *
-     * @param[in]  aContext      A pointer to arbitrary context information.
-     * @param[in]  aMessage      A reference to the message to send.
-     * @param[in]  aMessageInfo  A reference to the message info associated with @p aMessage.
-     *
-     */
-    typedef ThreadError(* SenderFunction)(void *aContext, Message &aMessage, const Ip6::MessageInfo &aMessageInfo);
-
-    /**
-     * This function pointer is called when CoAP client/server receives a message.
-     *
-     * @param[in]  aContext      A pointer to arbitrary context information.
-     * @param[in]  aMessage      A reference to the received message.
-     * @param[in]  aMessageInfo  A reference to the message info associated with @p aMessage.
-     *
-     */
-    typedef void (* ReceiverFunction)(void *aContext, Message &aMessage, const Ip6::MessageInfo &aMessageInfo);
-
     /**
      * This constructor initializes the object.
      *
@@ -113,10 +93,8 @@ public:
      * @param[in]  aReceiver A pointer to a function for handling received messages.
      *
      */
-    CoapBase(Ip6::Udp &aUdp, SenderFunction aSender, ReceiverFunction aReceiver):
+    CoapBase(Ip6::Udp &aUdp) :
-        mSocket(aUdp),
+        mSocket(aUdp) {};
-        mSender(aSender),
-        mReceiver(aReceiver) {};
 
     /**
      * This method creates a new message with a CoAP header.
@@ -171,9 +149,27 @@ protected:
     ThreadError Start(const Ip6::SockAddr &aSockAddr);
     ThreadError Stop(void);
 
+    /**
+     * This method send a message.
+     *
+     * @param[in]  aContext      A pointer to arbitrary context information.
+     * @param[in]  aMessage      A reference to the message to send.
+     * @param[in]  aMessageInfo  A reference to the message info associated with @p aMessage.
+     *
+     */
+    virtual ThreadError Send(Message &aMessage, const Ip6::MessageInfo &aMessageInfo) = 0;
+
+    /**
+     * This method receives a message.
+     *
+     * @param[in]  aContext      A pointer to arbitrary context information.
+     * @param[in]  aMessage      A reference to the received message.
+     * @param[in]  aMessageInfo  A reference to the message info associated with @p aMessage.
+     *
+     */
+    virtual void Receive(Message &aMessage, const Ip6::MessageInfo &aMessageInfo) = 0;
+
     Ip6::UdpSocket mSocket;
-    SenderFunction mSender;
-    ReceiverFunction mReceiver;
 
 private:
     /**

src/core/coap/coap_client.cpp

@@ -50,8 +50,8 @@
 namespace ot {
 namespace Coap {
 
-Client::Client(Ip6::Netif &aNetif, SenderFunction aSender, ReceiverFunction aReceiver):
+Client::Client(Ip6::Netif &aNetif):
-    CoapBase(aNetif.GetIp6().mUdp, aSender, aReceiver),
+    CoapBase(aNetif.GetIp6().mUdp),
     mRetransmissionTimer(aNetif.GetIp6().mTimerScheduler, &Client::HandleRetransmissionTimer, this)
 {
     mMessageId = static_cast<uint16_t>(otPlatRandomGet());
@@ -120,7 +120,7 @@ ThreadError Client::SendMessage(Message &aMessage, const Ip6::MessageInfo &aMess
                      error = kThreadError_NoBufs);
     }
 
-    SuccessOrExit(error = mSender(this, aMessage, aMessageInfo));
+    SuccessOrExit(error = Send(aMessage, aMessageInfo));
 
 exit:
 
@@ -223,7 +223,7 @@ ThreadError Client::SendCopy(const Message &aMessage, const Ip6::MessageInfo &aM
                  error = kThreadError_NoBufs);
 
     // Send the copy.
-    SuccessOrExit(error = mSender(this, *messageCopy, aMessageInfo));
+    SuccessOrExit(error = Send(*messageCopy, aMessageInfo));
 
 exit:
 
@@ -360,7 +360,7 @@ void Client::FinalizeCoapTransaction(Message &aRequest, const RequestMetadata &a
     }
 }
 
-void Client::ProcessReceivedMessage(Message &aMessage, const Ip6::MessageInfo &aMessageInfo)
+void Client::Receive(Message &aMessage, const Ip6::MessageInfo &aMessageInfo)
 {
     Header responseHeader;
     Header requestHeader;

src/core/coap/coap_client.hpp

@@ -171,7 +171,7 @@ public:
      * @param[in]  aReceiver A pointer to a function for handling received messages.
      *
      */
-    Client(Ip6::Netif &aNetif, SenderFunction aSender = &Client::Send, ReceiverFunction aReceiver = &Client::Receive);
+    Client(Ip6::Netif &aNetif);
 
     /**
      * This method starts the CoAP client.
@@ -229,7 +229,12 @@ public:
     const MessageQueue &GetRequestMessages(void) const { return mPendingRequests; }
 
 protected:
-    void ProcessReceivedMessage(Message &aMessage, const Ip6::MessageInfo &aMessageInfo);
+    virtual void Receive(Message &aMessage, const Ip6::MessageInfo &aMessageInfo);
+
+    ThreadError Send(Message &aMessage, const Ip6::MessageInfo &aMessageInfo) {
+        return mSocket.SendTo(aMessage, aMessageInfo);
+    }
+
 
 private:
     Message *CopyAndEnqueueMessage(const Message &aMessage, uint16_t aCopyLength,
@@ -244,14 +249,6 @@ private:
     static void HandleRetransmissionTimer(void *aContext);
     void HandleRetransmissionTimer(void);
 
-    static ThreadError Send(void *aContext, Message &aMessage, const Ip6::MessageInfo &aMessageInfo) {
-        return (static_cast<Client *>(aContext))->mSocket.SendTo(aMessage, aMessageInfo);
-    }
-
-    static void Receive(void *aContext, Message &aMessage, const Ip6::MessageInfo &aMessageInfo) {
-        (static_cast<Client *>(aContext))->ProcessReceivedMessage(aMessage, aMessageInfo);
-    }
-
     MessageQueue mPendingRequests;
     uint16_t mMessageId;
     Timer mRetransmissionTimer;

src/core/coap/coap_server.cpp

@@ -45,8 +45,8 @@
 namespace ot {
 namespace Coap {
 
-Server::Server(Ip6::Netif &aNetif, uint16_t aPort, SenderFunction aSender, ReceiverFunction aReceiver):
+Server::Server(Ip6::Netif &aNetif, uint16_t aPort) :
-    CoapBase(aNetif.GetIp6().mUdp, aSender, aReceiver),
+    CoapBase(aNetif.GetIp6().mUdp),
     mResponsesQueue(aNetif)
 {
     mPort = aPort;
@@ -111,7 +111,7 @@ ThreadError Server::SendMessage(Message &aMessage, const Ip6::MessageInfo &aMess
 {
     mResponsesQueue.EnqueueResponse(aMessage, aMessageInfo);
 
-    return mSender(this, aMessage, aMessageInfo);
+    return Send(aMessage, aMessageInfo);
 }
 
 ThreadError Server::SendEmptyAck(const Header &aRequestHeader, const Ip6::MessageInfo &aMessageInfo)
@@ -138,7 +138,7 @@ exit:
     return error;
 }
 
-void Server::ProcessReceivedMessage(Message &aMessage, const Ip6::MessageInfo &aMessageInfo)
+void Server::Receive(Message &aMessage, const Ip6::MessageInfo &aMessageInfo)
 {
     Header header;
     char uriPath[Resource::kMaxReceivedUriPath] = "";

src/core/coap/coap_server.hpp

@@ -310,8 +310,7 @@ public:
      * @param[in]  aReceiver A pointer to a function for handling received messages.
      *
      */
-    Server(Ip6::Netif &aNetif, uint16_t aPort, SenderFunction aSender = &Server::Send,
+    Server(Ip6::Netif &aNetif, uint16_t aPort);
-           ReceiverFunction aReceiver = &Server::Receive);
 
     /**
      * This method starts the CoAP server.
@@ -396,17 +395,13 @@ public:
     }
 
 protected:
-    void ProcessReceivedMessage(Message &aMessage, const Ip6::MessageInfo &aMessageInfo);
+    virtual void Receive(Message &aMessage, const Ip6::MessageInfo &aMessageInfo);
+
+    virtual ThreadError Send(Message &aMessage, const Ip6::MessageInfo &aMessageInfo) {
+        return mSocket.SendTo(aMessage, aMessageInfo);
+    }
 
 private:
-    static ThreadError Send(void *aContext, Message &aMessage, const Ip6::MessageInfo &aMessageInfo) {
-        return (static_cast<Server *>(aContext))->mSocket.SendTo(aMessage, aMessageInfo);
-    }
-
-    static void Receive(void *aContext, Message &aMessage, const Ip6::MessageInfo &aMessageInfo) {
-        (static_cast<Server *>(aContext))->ProcessReceivedMessage(aMessage, aMessageInfo);
-    }
-
     uint16_t mPort;
     Resource *mResources;
 

src/core/coap/secure_coap_client.cpp

@@ -51,7 +51,7 @@ namespace ot {
 namespace Coap {
 
 SecureClient::SecureClient(ThreadNetif &aNetif):
-    Client(aNetif, &SecureClient::Send, &SecureClient::Receive),
+    Client(aNetif),
     mConnectedCallback(NULL),
     mContext(NULL),
     mNetif(aNetif),
@@ -121,22 +121,12 @@ exit:
     return error;
 }
 
-ThreadError SecureClient::Send(void *aContext, Message &aMessage, const Ip6::MessageInfo &aMessageInfo)
-{
-    return static_cast<SecureClient *>(aContext)->Send(aMessage, aMessageInfo);
-}
-
 ThreadError SecureClient::Send(Message &aMessage, const Ip6::MessageInfo &aMessageInfo)
 {
     (void)aMessageInfo;
     return mNetif.GetDtls().Send(aMessage, aMessage.GetLength());
 }
 
-void SecureClient::Receive(void *aContext, Message &aMessage, const Ip6::MessageInfo &aMessageInfo)
-{
-    return static_cast<SecureClient *>(aContext)->Receive(aMessage, aMessageInfo);
-}
-
 void SecureClient::Receive(Message &aMessage, const Ip6::MessageInfo &aMessageInfo)
 {
     otLogFuncEntry();
@@ -177,7 +167,7 @@ void SecureClient::HandleDtlsReceive(uint8_t *aBuf, uint16_t aLength)
     VerifyOrExit((message = mNetif.GetIp6().mMessagePool.New(Message::kTypeIp6, 0)) != NULL);
     SuccessOrExit(message->Append(aBuf, aLength));
 
-    ProcessReceivedMessage(*message, mPeerAddress);
+    Client::Receive(*message, mPeerAddress);
 
 exit:
 

src/core/coap/secure_coap_client.hpp

@@ -135,10 +135,8 @@ public:
     ThreadError SendMessage(Message &aMessage, otCoapResponseHandler aHandler = NULL, void *aContext = NULL);
 
 private:
-    static ThreadError Send(void *aContext, Message &aMessage, const Ip6::MessageInfo &aMessageInfo);
     ThreadError Send(Message &aMessage, const Ip6::MessageInfo &aMessageInfo);
 
-    static void Receive(void *aContext, Message &aMessage, const Ip6::MessageInfo &aMessageInfo);
     void Receive(Message &aMessage, const Ip6::MessageInfo &aMessageInfo);
 
     static void HandleDtlsConnected(void *aContext, bool aConnected);

src/core/coap/secure_coap_server.cpp

@@ -51,7 +51,7 @@ namespace ot {
 namespace Coap {
 
 SecureServer::SecureServer(ThreadNetif &aNetif, uint16_t aPort):
-    Server(aNetif, aPort, &SecureServer::Send, &SecureServer::Receive),
+    Server(aNetif, aPort),
     mTransmitCallback(NULL),
     mContext(NULL),
     mNetif(aNetif),
@@ -102,22 +102,12 @@ bool SecureServer::IsConnectionActive(void)
     return mNetif.GetDtls().IsStarted();
 };
 
-ThreadError SecureServer::Send(void *aContext, Message &aMessage, const Ip6::MessageInfo &aMessageInfo)
-{
-    return static_cast<SecureServer *>(aContext)->Send(aMessage, aMessageInfo);
-}
-
 ThreadError SecureServer::Send(Message &aMessage, const Ip6::MessageInfo &aMessageInfo)
 {
     (void)aMessageInfo;
     return mNetif.GetDtls().Send(aMessage, aMessage.GetLength());
 }
 
-void SecureServer::Receive(void *aContext, Message &aMessage, const Ip6::MessageInfo &aMessageInfo)
-{
-    return static_cast<SecureServer *>(aContext)->Receive(aMessage, aMessageInfo);
-}
-
 void SecureServer::Receive(Message &aMessage, const Ip6::MessageInfo &aMessageInfo)
 {
     otLogFuncEntry();
@@ -185,7 +175,7 @@ void SecureServer::HandleDtlsReceive(uint8_t *aBuf, uint16_t aLength)
     VerifyOrExit((message = mNetif.GetIp6().mMessagePool.New(Message::kTypeIp6, 0)) != NULL);
     SuccessOrExit(message->Append(aBuf, aLength));
 
-    ProcessReceivedMessage(*message, mPeerAddress);
+    Server::Receive(*message, mPeerAddress);
 
 exit:
 

src/core/coap/secure_coap_server.hpp

@@ -114,12 +114,10 @@ public:
      */
     ThreadError SetPsk(const uint8_t *aPsk, uint8_t aPskLength);
 
+protected:
+    virtual ThreadError Send(Message &aMessage, const Ip6::MessageInfo &aMessageInfo);
+
 private:
-    static ThreadError Send(void *aContext, Message &aMessage, const Ip6::MessageInfo &aMessageInfo);
-    ThreadError Send(Message &aMessage, const Ip6::MessageInfo &aMessageInfo);
-
-    static void Receive(void *aContext, Message &aMessage, const Ip6::MessageInfo &aMessageInfo);
-
     static void HandleDtlsConnected(void *aContext, bool aConnected);
     void HandleDtlsConnected(bool aConnected);