Transfer buffering system detemplatized; compiles but tests are failing

libuavcan/include/uavcan/node/generic_subscriber.hpp

@@ -100,9 +100,9 @@ protected:
 
     ~GenericSubscriberBase() { }
 
-    int genericStart(TransferListenerBase* listener, bool (Dispatcher::*registration_method)(TransferListenerBase*));
+    int genericStart(TransferListener* listener, bool (Dispatcher::*registration_method)(TransferListener*));
 
-    void stop(TransferListenerBase* listener);
+    void stop(TransferListener* listener);
 
 public:
     /**
@@ -115,22 +115,6 @@ public:
     INode& getNode() const { return node_; }
 };
 
-/**
- * This helper class does some compile-time magic on the transport layer machinery. For authorized personnel only.
- */
-template <typename DataStruct_,
-          template<unsigned> class TransferListenerTemplate = TransferListener
-         >
-class UAVCAN_EXPORT TransferListenerInstantiationHelper
-{
-    enum { DataTypeMaxByteLen = BitLenToByteLen<DataStruct_::MaxBitLen>::Result };
-    enum { NeedsBuffer = int(DataTypeMaxByteLen) > int(GuaranteedPayloadLenPerFrame) };
-    enum { BufferSize = NeedsBuffer ? DataTypeMaxByteLen : 0 };
-
-public:
-    typedef TransferListenerTemplate<BufferSize> Type;
-};
-
 /**
  * Please note that the reference passed to the RX callback points to a stack-allocated object, which means
  * that it gets invalidated shortly after the callback returns.
@@ -151,9 +135,15 @@ class UAVCAN_EXPORT GenericSubscriber : public GenericSubscriberBase
         }
 
     public:
-        TransferForwarder(SelfType& obj, const DataTypeDescriptor& data_type, IPoolAllocator& allocator)
-            : TransferListenerType(obj.node_.getDispatcher().getTransferPerfCounter(), data_type, allocator)
-            , obj_(obj)
+        TransferForwarder(SelfType& obj,
+                          const DataTypeDescriptor& data_type,
+                          uint16_t max_buffer_size,
+                          IPoolAllocator& allocator) :
+            TransferListenerType(obj.node_.getDispatcher().getTransferPerfCounter(),
+                                 data_type,
+                                 max_buffer_size,
+                                 allocator),
+            obj_(obj)
         { }
     };
 
@@ -163,20 +153,19 @@ class UAVCAN_EXPORT GenericSubscriber : public GenericSubscriberBase
 
     void handleIncomingTransfer(IncomingTransfer& transfer);
 
-    int genericStart(bool (Dispatcher::*registration_method)(TransferListenerBase*));
+    int genericStart(bool (Dispatcher::*registration_method)(TransferListener*));
 
 protected:
     struct ReceivedDataStructureSpec : public ReceivedDataStructure<DataStruct>
     {
         ReceivedDataStructureSpec() { }
 
-        ReceivedDataStructureSpec(const IncomingTransfer* arg_transfer)
-            : ReceivedDataStructure<DataStruct>(arg_transfer)
+        ReceivedDataStructureSpec(const IncomingTransfer* arg_transfer) :
+            ReceivedDataStructure<DataStruct>(arg_transfer)
         { }
     };
 
-    explicit GenericSubscriber(INode& node)
-        : GenericSubscriberBase(node)
+    explicit GenericSubscriber(INode& node) : GenericSubscriberBase(node)
     { }
 
     virtual ~GenericSubscriber() { stop(); }
@@ -247,8 +236,10 @@ int GenericSubscriber<DataSpec, DataStruct, TransferListenerType>::checkInit()
         return -ErrUnknownDataType;
     }
 
-    forwarder_.template construct<SelfType&, const DataTypeDescriptor&, IPoolAllocator&>
-        (*this, *descr, node_.getAllocator());
+    static const uint16_t MaxBufferSize = BitLenToByteLen<DataStruct::MaxBitLen>::Result;
+
+    forwarder_.template construct<SelfType&, const DataTypeDescriptor&, uint16_t, IPoolAllocator&>
+        (*this, *descr, MaxBufferSize, node_.getAllocator());
 
     return 0;
 }
@@ -286,7 +277,7 @@ void GenericSubscriber<DataSpec, DataStruct, TransferListenerType>::handleIncomi
 
 template <typename DataSpec, typename DataStruct, typename TransferListenerType>
 int GenericSubscriber<DataSpec, DataStruct, TransferListenerType>::
-genericStart(bool (Dispatcher::*registration_method)(TransferListenerBase*))
+genericStart(bool (Dispatcher::*registration_method)(TransferListener*))
 {
     const int res = checkInit();
     if (res < 0)

libuavcan/include/uavcan/node/service_client.hpp

@@ -20,15 +20,6 @@
 
 namespace uavcan
 {
-
-template <typename ServiceDataType>
-class UAVCAN_EXPORT ServiceResponseTransferListenerInstantiationHelper
-{
-public:
-    typedef typename TransferListenerInstantiationHelper<typename ServiceDataType::Response,
-                                                         TransferListenerWithFilter>::Type Type;
-};
-
 /**
  * This struct describes a pending service call.
  * Refer to @ref ServiceClient to learn more about service calls.
@@ -225,8 +216,7 @@ template <typename DataType_,
           >
 class UAVCAN_EXPORT ServiceClient
     : public GenericSubscriber<DataType_,
-                               typename DataType_::Response,
-                               typename ServiceResponseTransferListenerInstantiationHelper<DataType_>::Type>
+                               typename DataType_::Response, TransferListenerWithFilter>
     , public ServiceClientBase
 {
 public:
@@ -239,8 +229,7 @@ public:
 private:
     typedef ServiceClient<DataType, Callback> SelfType;
     typedef GenericPublisher<DataType, RequestType> PublisherType;
-    typedef typename ServiceResponseTransferListenerInstantiationHelper<DataType>::Type TransferListenerType;
-    typedef GenericSubscriber<DataType, ResponseType, TransferListenerType> SubscriberType;
+    typedef GenericSubscriber<DataType, ResponseType, TransferListenerWithFilter> SubscriberType;
 
     typedef Multiset<CallState> CallRegistry;
 
@@ -537,7 +526,7 @@ int ServiceClient<DataType_, Callback_>::call(NodeID server_node_id, const Reque
      * Configuring the listener so it will accept only the matching responses
      * TODO move to init(), but this requires to somewhat refactor GenericSubscriber<> (remove TransferForwarder)
      */
-    TransferListenerType* const tl = SubscriberType::getTransferListener();
+    TransferListenerWithFilter* const tl = SubscriberType::getTransferListener();
     if (tl == NULL)
     {
         UAVCAN_ASSERT(0);  // Must have been created

libuavcan/include/uavcan/node/service_server.hpp

@@ -88,8 +88,7 @@ template <typename DataType_,
 #endif
           >
 class UAVCAN_EXPORT ServiceServer
-    : public GenericSubscriber<DataType_, typename DataType_::Request,
-                               typename TransferListenerInstantiationHelper<typename DataType_::Request>::Type>
+    : public GenericSubscriber<DataType_, typename DataType_::Request, TransferListener>
 {
 public:
     typedef DataType_ DataType;
@@ -98,8 +97,7 @@ public:
     typedef Callback_ Callback;
 
 private:
-    typedef typename TransferListenerInstantiationHelper<RequestType>::Type TransferListenerType;
-    typedef GenericSubscriber<DataType, RequestType, TransferListenerType> SubscriberType;
+    typedef GenericSubscriber<DataType, RequestType, TransferListener> SubscriberType;
     typedef GenericPublisher<DataType, ResponseType> PublisherType;
 
     PublisherType publisher_;

libuavcan/include/uavcan/node/subscriber.hpp

@@ -43,15 +43,13 @@ template <typename DataType_,
 #endif
           >
 class UAVCAN_EXPORT Subscriber
-    : public GenericSubscriber<DataType_, DataType_,
-                               typename TransferListenerInstantiationHelper<DataType_>::Type>
+    : public GenericSubscriber<DataType_, DataType_, TransferListener>
 {
 public:
     typedef Callback_ Callback;
 
 private:
-    typedef typename TransferListenerInstantiationHelper<DataType_>::Type TransferListenerType;
-    typedef GenericSubscriber<DataType_, DataType_, TransferListenerType> BaseType;
+    typedef GenericSubscriber<DataType_, DataType_, TransferListener> BaseType;
 
     Callback callback_;