Compile against FairMQ 1.3.6

Author: mkrzewic

DataFormats/MemoryResources/include/MemoryResources/MemoryResources.h

@@ -58,7 +58,7 @@ class FairMQMemoryResource : public boost::container::pmr::memory_resource
   /// return nullptr if returning a message does not make sense!
   virtual FairMQMessagePtr getMessage(void* p) = 0;
   virtual void* setMessage(FairMQMessagePtr) = 0;
-  virtual const FairMQTransportFactory* getTransportFactory() const noexcept = 0;
+  virtual FairMQTransportFactory* getTransportFactory() noexcept = 0;
   virtual size_t getNumberOfMessages() const noexcept = 0;
 };
 
@@ -69,14 +69,14 @@ class FairMQMemoryResource : public boost::container::pmr::memory_resource
 class ChannelResource : public FairMQMemoryResource
 {
  protected:
-  const FairMQTransportFactory* factory{ nullptr };
+  FairMQTransportFactory* factory{ nullptr };
   // TODO: for now a map to keep track of allocations, something else would probably be faster, but for now this does
   // not need to be fast.
   boost::container::flat_map<void*, FairMQMessagePtr> messageMap;
 
  public:
   ChannelResource() = delete;
-  ChannelResource(const FairMQTransportFactory* _factory) : FairMQMemoryResource(), factory(_factory), messageMap()
+  ChannelResource(FairMQTransportFactory* _factory) : FairMQMemoryResource(), factory(_factory), messageMap()
   {
     if (!factory) {
       throw std::runtime_error("Tried to construct from a nullptr FairMQTransportFactory");
@@ -94,7 +94,7 @@ class ChannelResource : public FairMQMemoryResource
     messageMap[addr] = std::move(message);
     return addr;
   }
-  const FairMQTransportFactory* getTransportFactory() const noexcept override { return factory; }
+  FairMQTransportFactory* getTransportFactory() noexcept override { return factory; }
 
   size_t getNumberOfMessages() const noexcept override { return messageMap.size(); }
 
@@ -130,7 +130,7 @@ class SpectatorMessageResource : public FairMQMemoryResource
   SpectatorMessageResource() = default;
   SpectatorMessageResource(const FairMQMessage* _message) : message(_message){};
   FairMQMessagePtr getMessage(void* p) override { return nullptr; }
-  const FairMQTransportFactory* getTransportFactory() const noexcept override { return nullptr; }
+  FairMQTransportFactory* getTransportFactory() noexcept override { return nullptr; }
   size_t getNumberOfMessages() const noexcept override { return 0; }
   void* setMessage(FairMQMessagePtr) override { return nullptr; }
 
@@ -189,7 +189,7 @@ class MessageResource : public FairMQMemoryResource
   }
   FairMQMessagePtr getMessage(void* p) override { return mUpstream->getMessage(p); }
   void* setMessage(FairMQMessagePtr message) override { return mUpstream->setMessage(std::move(message)); }
-  const FairMQTransportFactory* getTransportFactory() const noexcept override { return nullptr; }
+  FairMQTransportFactory* getTransportFactory() noexcept override { return nullptr; }
   size_t getNumberOfMessages() const noexcept override { return mMessageData ? 1 : 0; }
 
  protected:
@@ -397,20 +397,20 @@ class TransportAllocatorMap
     static TransportAllocatorMap S;
     return S;
   }
-  ChannelResource* operator[](const FairMQTransportFactory* factory)
+  ChannelResource* operator[](FairMQTransportFactory* factory)
   {
     return std::addressof(map.emplace(factory, factory).first->second);
   }
 
  private:
-  std::unordered_map<const FairMQTransportFactory*, ChannelResource> map{};
+  std::unordered_map<FairMQTransportFactory*, ChannelResource> map{};
   TransportAllocatorMap(){};
 };
 }
 
 //__________________________________________________________________________________________________
 /// Get the allocator associated to a transport factory
-inline static ChannelResource* getTransportAllocator(const FairMQTransportFactory* factory)
+inline static ChannelResource* getTransportAllocator(FairMQTransportFactory* factory)
 {
   return internal::TransportAllocatorMap::Instance()[factory];
 }

DataFormats/TimeFrame/test/TimeFrameTest.cxx

@@ -67,7 +67,7 @@ inline static void SimpleMsgCleanup(void* /*data*/, void* obj)
 }
 
 template<typename Factory, typename T>
-inline static FairMQMessagePtr NewSimpleMessage(Factory const &f, const T& data)
+inline static FairMQMessagePtr NewSimpleMessage(Factory &f, const T& data)
 {
   auto* dataCopy = new T(data);
   return f.CreateMessage(dataCopy, sizeof(T), SimpleMsgCleanup<T>, dataCopy);

Framework/Core/include/Framework/Dispatcher.h

@@ -47,7 +47,7 @@ class Dispatcher : public Task
 
  private:
   void send(DataAllocator& dataAllocator, const DataRef& inputData, const Output& output) const;
-  void sendFairMQ(const FairMQDevice* device, const DataRef& inputData, const std::string& fairMQChannel) const;
+  void sendFairMQ(FairMQDevice* device, const DataRef& inputData, const std::string& fairMQChannel) const;
 
   std::string mName;
   std::string mReconfigurationSource;

Framework/Core/include/Framework/FairMQDeviceProxy.h

@@ -37,8 +37,8 @@ class FairMQDeviceProxy
   }
 
   /// Looks like what we really need in the headers is just the transport.
-  const FairMQTransportFactory* getTransport();
-  const FairMQTransportFactory* getTransport(const std::string& channel, int index);
+  FairMQTransportFactory* getTransport();
+  FairMQTransportFactory* getTransport(const std::string& channel, int index);
   std::unique_ptr<FairMQMessage> createMessage() const;
   std::unique_ptr<FairMQMessage> createMessage(const size_t size) const;
 private:

Framework/Core/src/Dispatcher.cxx

@@ -91,7 +91,7 @@ void Dispatcher::send(DataAllocator& dataAllocator, const DataRef& inputData, co
 }
 
 // ideally this should be in a separate proxy device or use Lifetime::External
-void Dispatcher::sendFairMQ(const FairMQDevice* device, const DataRef& inputData, const std::string& fairMQChannel) const
+void Dispatcher::sendFairMQ(FairMQDevice* device, const DataRef& inputData, const std::string& fairMQChannel) const
 {
   const auto* dh = header::get<header::DataHeader*>(inputData.header);
   assert(dh);

Framework/Core/src/FairMQDeviceProxy.cxx

@@ -17,11 +17,11 @@ namespace o2
 {
 namespace framework
 {
-const FairMQTransportFactory *FairMQDeviceProxy::getTransport() {
+FairMQTransportFactory *FairMQDeviceProxy::getTransport() {
   return mDevice->Transport();
 }
 
-const FairMQTransportFactory* FairMQDeviceProxy::getTransport(const std::string& channel, int index)
+FairMQTransportFactory* FairMQDeviceProxy::getTransport(const std::string& channel, int index)
 {
   return mDevice->GetChannel(channel, index).Transport();
 }