Made a phony zero-copy interface for those interfaces that are actual copy-interfaces.

Using interface in the udp asio transport.

2 files changed, 145 insertions, 85 deletions

diff --git a/host/include/uhd/transport/udp_zero_copy.hpp b/host/include/uhd/transport/udp_zero_copy.hpp
index 525606a9f..818709973 100644
--- a/host/include/uhd/transport/udp_zero_copy.hpp
+++ b/host/include/uhd/transport/udp_zero_copy.hpp
@@ -34,7 +34,7 @@ namespace uhd{ namespace transport{
  * If no platform specific solution is available, make returns a boost asio
  * implementation that wraps the functionality around a standard send/recv calls.
  */
-class UHD_API udp_zero_copy : public zero_copy_if{
+class UHD_API udp_zero_copy : public virtual zero_copy_if{
 public:
     typedef boost::shared_ptr<udp_zero_copy> sptr;
 
diff --git a/host/include/uhd/transport/zero_copy.hpp b/host/include/uhd/transport/zero_copy.hpp
index 52c6d4143..2efabaccf 100644
--- a/host/include/uhd/transport/zero_copy.hpp
+++ b/host/include/uhd/transport/zero_copy.hpp
@@ -25,109 +25,169 @@
 
 namespace uhd{ namespace transport{
 
-/*!
- * A managed receive buffer:
- * Contains a reference to transport-managed memory,
- * and a method to release the memory after reading.
- */
-class UHD_API managed_recv_buffer : boost::noncopyable{
-public:
-    typedef boost::shared_ptr<managed_recv_buffer> sptr;
-
     /*!
-     * Managed recv buffer destructor:
-     * Signal to the transport that we are done with the buffer.
-     * This should be called to release the buffer to the transport.
-     * After calling, the referenced memory should be considered invalid.
+     * A managed receive buffer:
+     * Contains a reference to transport-managed memory,
+     * and a method to release the memory after reading.
      */
-    virtual ~managed_recv_buffer(void){};
+    class UHD_API managed_recv_buffer : boost::noncopyable{
+    public:
+        typedef boost::shared_ptr<managed_recv_buffer> sptr;
+
+        /*!
+         * Managed recv buffer destructor:
+         * Signal to the transport that we are done with the buffer.
+         * This should be called to release the buffer to the transport.
+         * After calling, the referenced memory should be considered invalid.
+         */
+        virtual ~managed_recv_buffer(void) = 0;
+
+        /*!
+         * Get the size of the underlying buffer.
+         * \return the number of bytes
+         */
+        size_t size(void) const{
+            return boost::asio::buffer_size(this->get());
+        }
+
+        /*!
+         * Get a pointer to the underlying buffer.
+         * \return a pointer into memory
+         */
+        template <class T> T cast(void) const{
+            return boost::asio::buffer_cast<T>(this->get());
+        }
+
+    private:
+        /*!
+         * Get a reference to the internal const buffer.
+         * The buffer has a reference to memory and a size.
+         * \return a boost asio const buffer
+         */
+        virtual const boost::asio::const_buffer &get(void) const = 0;
+    };
 
     /*!
-     * Get the size of the underlying buffer.
-     * \return the number of bytes
+     * A managed send buffer:
+     * Contains a reference to transport-managed memory,
+     * and a method to release the memory after writing.
      */
-    size_t size(void) const{
-        return boost::asio::buffer_size(this->get());
-    }
+    class UHD_API managed_send_buffer : boost::noncopyable{
+    public:
+        typedef boost::shared_ptr<managed_send_buffer> sptr;
+
+        /*!
+         * Signal to the transport that we are done with the buffer.
+         * This should be called to commit the write to the transport object.
+         * After calling, the referenced memory should be considered invalid.
+         * \param num_bytes the number of bytes written into the buffer
+         */
+        virtual void commit(size_t num_bytes) = 0;
+
+        /*!
+         * Get the size of the underlying buffer.
+         * \return the number of bytes
+         */
+        size_t size(void) const{
+            return boost::asio::buffer_size(this->get());
+        }
+
+        /*!
+         * Get a pointer to the underlying buffer.
+         * \return a pointer into memory
+         */
+        template <class T> T cast(void) const{
+            return boost::asio::buffer_cast<T>(this->get());
+        }
+
+    private:
+        /*!
+         * Get a reference to the internal mutable buffer.
+         * The buffer has a reference to memory and a size.
+         * \return a boost asio mutable buffer
+         */
+        virtual const boost::asio::mutable_buffer &get(void) const = 0;
+    };
 
     /*!
-     * Get a pointer to the underlying buffer.
-     * \return a pointer into memory
+     * A zero-copy interface for transport objects.
+     * Provides a way to get send and receive buffers
+     * with memory managed by the transport object.
      */
-    template <class T> T cast(void) const{
-        return boost::asio::buffer_cast<T>(this->get());
-    }
+    class UHD_API zero_copy_if : boost::noncopyable{
+    public:
+        typedef boost::shared_ptr<zero_copy_if> sptr;
 
-private:
-    /*!
-     * Get a reference to the internal const buffer.
-     * The buffer has a reference to memory and a size.
-     * \return a boost asio const buffer
-     */
-    virtual const boost::asio::const_buffer &get(void) const = 0;
-};
-
-/*!
- * A managed send buffer:
- * Contains a reference to transport-managed memory,
- * and a method to release the memory after writing.
- */
-class UHD_API managed_send_buffer : boost::noncopyable{
-public:
-    typedef boost::shared_ptr<managed_send_buffer> sptr;
+        /*!
+         * Get a new receive buffer from this transport object.
+         */
+        virtual managed_recv_buffer::sptr get_recv_buff(void) = 0;
 
-    /*!
-     * Signal to the transport that we are done with the buffer.
-     * This should be called to commit the write to the transport object.
-     * After calling, the referenced memory should be considered invalid.
-     * \param num_bytes the number of bytes written into the buffer
-     */
-    virtual void commit(size_t num_bytes) = 0;
+        /*!
+         * Get a new send buffer from this transport object.
+         */
+        virtual managed_send_buffer::sptr get_send_buff(void) = 0;
+    };
 
     /*!
-     * Get the size of the underlying buffer.
-     * \return the number of bytes
+     * A phony-zero-copy interface for transport objects that
+     * provides a zero-copy interface on top of copying transport.
+     * This interface implements the get managed recv buffer,
+     * the base class must implement the private recv method.
      */
-    size_t size(void) const{
-        return boost::asio::buffer_size(this->get());
-    }
+    class UHD_API phony_zero_copy_recv_if : public virtual zero_copy_if{
+    public:
 
-    /*!
-     * Get a pointer to the underlying buffer.
-     * \return a pointer into memory
-     */
-    template <class T> T cast(void) const{
-        return boost::asio::buffer_cast<T>(this->get());
-    }
+        //! structors
+        phony_zero_copy_recv_if(size_t max_buff_size);
+        ~phony_zero_copy_recv_if(void);
 
-private:
-    /*!
-     * Get a reference to the internal mutable buffer.
-     * The buffer has a reference to memory and a size.
-     * \return a boost asio mutable buffer
-     */
-    virtual const boost::asio::mutable_buffer &get(void) const = 0;
-};
-
-/*!
- * A zero-copy interface for transport objects.
- * Provides a way to get send and receive buffers
- * with memory managed by the transport object.
- */
-class UHD_API zero_copy_if : boost::noncopyable{
-public:
-    typedef boost::shared_ptr<zero_copy_if> sptr;
+        /*!
+         * Get a new receive buffer from this transport object.
+         */
+        managed_recv_buffer::sptr get_recv_buff(void);
 
-    /*!
-     * Get a new receive buffer from this transport object.
-     */
-    virtual managed_recv_buffer::sptr get_recv_buff(void) = 0;
+    private:
+
+        /*!
+         * Perform a private copying recv.
+         * \param buff the buffer to write data into
+         * \return the number of bytes written to buff
+         */
+        virtual size_t recv(const boost::asio::mutable_buffer &buff) = 0;
+
+        struct impl; impl *_impl; //private implementation details
+    };
 
     /*!
-     * Get a new send buffer from this transport object.
+     * A phony-zero-copy interface for transport objects that
+     * provides a zero-copy interface on top of copying transport.
+     * This interface implements the get managed send buffer,
+     * the base class must implement the private send method.
      */
-    virtual managed_send_buffer::sptr get_send_buff(void) = 0;
-};
+    class UHD_API phony_zero_copy_send_if : public virtual zero_copy_if{
+    public:
+
+        //! structors
+        phony_zero_copy_send_if(size_t max_buff_size);
+        ~phony_zero_copy_send_if(void);
+
+        /*!
+         * Get a new send buffer from this transport object.
+         */
+        managed_send_buffer::sptr get_send_buff(void);
+
+    private:
+
+        /*!
+         * Perform a private copying send.
+         * \param buff the buffer to read data from
+         * \return the number of bytes read from buff
+         */
+        virtual size_t send(const boost::asio::const_buffer &buff) = 0;
+
+        struct impl; impl *_impl; //private implementation details
+    };
 
 }} //namespace