updated transposers to use polymorphic resource allocator interface

psrdada_cpp/dadaflow/pipelines/RFSoC2TAFP.hpp

@@ -61,10 +61,10 @@ public:
     using TAPFTVoltage = RFSoCPFBData<std::span<char2>>;
     using TTAFPVoltage = RFSoCPFBDataTranspose<std::vector<char2>>;
     using AllocatorType = ResourcePool<TTAFPVoltage>;
-    using TransposerType = Transposer<TAPFTVoltage, TTAFPVoltage, AllocatorType>;
+    using TransposerType = Transposer<TAPFTVoltage, TTAFPVoltage>;
 
     RFSoC2TAFPPipeline(key_t input_key, key_t output_key, std::size_t nthreads)
-    : _transpose_allocator(3), _reader_log("RFSoC2TAFPReader") 
+    : _reader_log("RFSoC2TAFPReader") 
     , _writer_log("RFSoC2TAFPWriter")
     {
         auto& dada_source = _graph.add_node(
@@ -83,7 +83,7 @@ public:
                     }
                 )), "DADA reader");
         
-        auto& transposer = _graph.add_node(TransposerType(_transpose_allocator, nthreads), "Transposer");
+        auto& transposer = _graph.add_node(TransposerType(SafeResourcePool<TTAFPVoltage>::create(3), nthreads), "Transposer");
 
         AsyncDadaSink async_sink{
             output_key,
@@ -133,7 +133,6 @@ public:
     Graph& graph() { return _graph; }
 
 private:
-    ResourcePool<TTAFPVoltage> _transpose_allocator;
     MultiLog _reader_log;
     MultiLog _writer_log;
     Graph _graph;

psrdada_cpp/dadaflow/processors/Transposer.hpp

 #pragma once
 #include "psrdada_cpp/dadaflow/DescribedData.hpp"
 #include "psrdada_cpp/dadaflow/Dimensions.hpp"
+#include "psrdada_cpp/dadaflow/ResourceAllocator.hpp"
 #include "psrdada_cpp/common.hpp"
 #include <memory>
 
 
 namespace psrdada_cpp {
 
-template <typename InputT, typename OutputT, typename AllocatorType>
+template <typename InputT, typename OutputT>
 class Transposer;
 
 template <template <typename, typename...> class DD, 
@@ -17,20 +18,18 @@ template <template <typename, typename...> class DD,
           typename A,
           typename P,
           typename F,
-          typename T1,
-          typename AllocatorType>
+          typename T1>
 class Transposer< DD<InputContainer, T0, A, P, F, T1>, 
-                  DD<OutputContainer, T0, T1, A, F, P>,
-                  AllocatorType>
+                  DD<OutputContainer, T0, T1, A, F, P>>
 {
 public:
     using InputType = DD<InputContainer, T0, A, P, F, T1>;
     using OutputType = DD<OutputContainer, T0, T1, A, F, P>;
     using InputPtr = std::shared_ptr<InputType>;
     using OutputPtr = std::shared_ptr<OutputType>;
-    using Allocator = AllocatorType;
+    using Allocator = std::shared_ptr<ResourceAllocatorInterface<OutputType>>;
 
-    Transposer(Allocator& allocator, std::size_t nthreads = 1)
+    Transposer(Allocator const& allocator, std::size_t nthreads = 1)
     : _allocator(allocator), _nthreads(nthreads)
     {}
 
@@ -41,7 +40,7 @@ public:
 
     OutputPtr operator()(InputPtr input_ptr)
     {
-        OutputPtr output_ptr = _allocator.get();
+        OutputPtr output_ptr = _allocator->get();
 
         auto const& input = *input_ptr;
         auto& output = *output_ptr;
@@ -85,8 +84,42 @@ public:
     }
 
 private:
-    AllocatorType& _allocator;
+    Allocator _allocator;
     std::size_t _nthreads;
 };
+/** 
+template <template <typename, typename...> class DD, 
+          typename InputContainer, 
+          typename OutputContainer,
+          typename T0, typename F,
+          typename P, typename A,
+          typename T1, typename T>
+class Transposer< DD<InputContainer, T0, F, P, A, T1>, 
+                  DD<OutputContainer, F, T, P, A>, void>
+{
+    using InputType = DD<InputContainer, T0, F, P, A, T1>;
+    using OutputType = DD<OutputContainer, F, T, P, A>;
+    using InputPtr = std::shared_ptr<InputType>;
+    using OutputPtr = std::shared_ptr<OutputType>;
+    using Allocator = ResourceAllocatorInterface<OutputPtr>;
+
+    Transposer(std::shared_ptr<Allocator> const& allocator)
+    : _allocator(allocator)
+    {}
+
+    Transposer(Transposer const&) = delete;
+    Transposer& operator=(Transposer const&) = delete;
+    Transposer(Transposer&&) = default;
+    Transposer& operator=(Transposer&&) = default;
+
+    OutputPtr operator()(InputPtr input_ptr) {
+
+    }
+
+
+private:
+    std::shared_ptr<Allocator> _allocator;
+};
+*/
 
 }
\ No newline at end of file

psrdada_cpp/dadaflow/test/src/TransposerTester.cpp

@@ -23,8 +23,8 @@ TEST_F(TransposerTester, index_transpose) {
     using F = FrequencyDimension;
     using InputType = DescribedData<ContainerT, T0, A, P, F, T1>;
     using OutputType = DescribedData<ContainerT, T0, T1, A, F, P>;
-    using AllocatorType = ResourcePool<OutputType>;
-    using TransposerType = Transposer<InputType, OutputType, AllocatorType>;
+    using AllocatorType = SafeResourcePool<OutputType>;
+    using TransposerType = Transposer<InputType, OutputType>;
 
     std::size_t n_t0 = 3;
     std::size_t n_t1 = 7;
@@ -50,7 +50,7 @@ TEST_F(TransposerTester, index_transpose) {
         }
     }
 
-    AllocatorType allocator(2);
+    auto allocator = AllocatorType::create(2);
     TransposerType transposer(allocator, 4);
     
     auto output_ptr = transposer(input_ptr);