Mirror/FairMQ
1
0
Fork 0
mirror of https://github.com/FairRootGroup/FairMQ.git synced 2025-10-13 16:46:47 +00:00
Code Issues Packages Projects Releases Wiki Activity

Replace tools::make_unique with std::make_unique

Browse Source
This commit is contained in:
Alexey Rybalchenko 2021-01-13 13:36:47 +01:00
parent 6815c9c172
commit 751c53171c
15 changed files with 85 additions and 103 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
fairmq/FairMQDevice.cxx
View File

@ -75,7 +75,7 @@ FairMQDevice::FairMQDevice(ProgOptions* config, const tools::Version version)
: fTransportFactory(nullptr) : fTransportFactory(nullptr)
, fTransports() , fTransports()
, fChannels() , fChannels()
, fInternalConfig(config ? nullptr : tools::make_unique<ProgOptions>()) , fInternalConfig(config ? nullptr : make_unique<ProgOptions>())
, fConfig(config ? config : fInternalConfig.get()) , fConfig(config ? config : fInternalConfig.get())
, fId(DefaultId) , fId(DefaultId)
, fDefaultTransportType(DefaultTransportType) , fDefaultTransportType(DefaultTransportType)

3
fairmq/Plugin.h
View File

@ -9,7 +9,6 @@
#ifndef FAIR_MQ_PLUGIN_H #ifndef FAIR_MQ_PLUGIN_H
#define FAIR_MQ_PLUGIN_H #define FAIR_MQ_PLUGIN_H
#include <fairmq/tools/CppSTL.h>
#include <fairmq/tools/Version.h> #include <fairmq/tools/Version.h>
#include <fairmq/PluginServices.h> #include <fairmq/PluginServices.h>
@ -140,7 +139,7 @@ class Plugin
#define REGISTER_FAIRMQ_PLUGIN(KLASS, NAME, VERSION, MAINTAINER, HOMEPAGE, PROGOPTIONS) \ #define REGISTER_FAIRMQ_PLUGIN(KLASS, NAME, VERSION, MAINTAINER, HOMEPAGE, PROGOPTIONS) \
static auto Make_##NAME##_Plugin(fair::mq::PluginServices* pluginServices) -> std::unique_ptr<fair::mq::Plugin> \ static auto Make_##NAME##_Plugin(fair::mq::PluginServices* pluginServices) -> std::unique_ptr<fair::mq::Plugin> \
{ \ { \
return fair::mq::tools::make_unique<KLASS>(std::string{#NAME}, VERSION, std::string{MAINTAINER}, std::string{HOMEPAGE}, pluginServices); \ return std::make_unique<KLASS>(std::string{#NAME}, VERSION, std::string{MAINTAINER}, std::string{HOMEPAGE}, pluginServices); \
} \ } \
BOOST_DLL_ALIAS(Make_##NAME##_Plugin, make_##NAME##_plugin) \ BOOST_DLL_ALIAS(Make_##NAME##_Plugin, make_##NAME##_plugin) \
BOOST_DLL_ALIAS(PROGOPTIONS, get_##NAME##_plugin_progoptions) BOOST_DLL_ALIAS(PROGOPTIONS, get_##NAME##_plugin_progoptions)

3
fairmq/PluginManager.h
View File

@ -11,7 +11,6 @@
#include <fairmq/Plugin.h> #include <fairmq/Plugin.h>
#include <fairmq/PluginServices.h> #include <fairmq/PluginServices.h>
#include <fairmq/tools/CppSTL.h>
#include <fairmq/tools/Strings.h> #include <fairmq/tools/Strings.h>
#define BOOST_FILESYSTEM_VERSION 3 #define BOOST_FILESYSTEM_VERSION 3
@ -80,7 +79,7 @@ class PluginManager
auto ForEachPluginProgOptions(std::function<void (boost::program_options::options_description)> func) const -> void { for(const auto& pair : fPluginProgOptions) { func(pair.second); } } auto ForEachPluginProgOptions(std::function<void (boost::program_options::options_description)> func) const -> void { for(const auto& pair : fPluginProgOptions) { func(pair.second); } }
template<typename... Args> template<typename... Args>
auto EmplacePluginServices(Args&&... args) -> void { fPluginServices = fair::mq::tools::make_unique<PluginServices>(std::forward<Args>(args)...); } auto EmplacePluginServices(Args&&... args) -> void { fPluginServices = std::make_unique<PluginServices>(std::forward<Args>(args)...); }
auto WaitForPluginsToReleaseDeviceControl() -> void { fPluginServices->WaitForReleaseDeviceControl(); } auto WaitForPluginsToReleaseDeviceControl() -> void { fPluginServices->WaitForReleaseDeviceControl(); }

18
fairmq/ofi/Socket.cxx
View File

@ -9,7 +9,7 @@
#include <fairmq/ofi/ControlMessages.h> #include <fairmq/ofi/ControlMessages.h>
#include <fairmq/ofi/Socket.h> #include <fairmq/ofi/Socket.h>
#include <fairmq/ofi/TransportFactory.h> #include <fairmq/ofi/TransportFactory.h>
#include <fairmq/Tools.h> #include <fairmq/tools/Strings.h>
#include <FairMQLogger.h> #include <FairMQLogger.h>
#include <asiofi.hpp> #include <asiofi.hpp>
@ -74,16 +74,16 @@ auto Socket::InitOfi(Address addr) -> void
hints.set_provider("verbs"); hints.set_provider("verbs");
} }
if (fRemoteAddr == addr) { if (fRemoteAddr == addr) {
fOfiInfo = tools::make_unique<asiofi::info>(addr.Ip.c_str(), std::to_string(addr.Port).c_str(), 0, hints); fOfiInfo = make_unique<asiofi::info>(addr.Ip.c_str(), std::to_string(addr.Port).c_str(), 0, hints);
} else { } else {
fOfiInfo = tools::make_unique<asiofi::info>(addr.Ip.c_str(), std::to_string(addr.Port).c_str(), FI_SOURCE, hints); fOfiInfo = make_unique<asiofi::info>(addr.Ip.c_str(), std::to_string(addr.Port).c_str(), FI_SOURCE, hints);
} }
LOG(debug) << "OFI transport (" << fId << "): " << *fOfiInfo; LOG(debug) << "OFI transport (" << fId << "): " << *fOfiInfo;
fOfiFabric = tools::make_unique<asiofi::fabric>(*fOfiInfo); fOfiFabric = make_unique<asiofi::fabric>(*fOfiInfo);
fOfiDomain = tools::make_unique<asiofi::domain>(*fOfiFabric); fOfiDomain = make_unique<asiofi::domain>(*fOfiFabric);
} }
} }
@ -96,7 +96,7 @@ try {
InitOfi(fLocalAddr); InitOfi(fLocalAddr);
fPassiveEndpoint = tools::make_unique<asiofi::passive_endpoint>(fContext.GetIoContext(), *fOfiFabric); fPassiveEndpoint = make_unique<asiofi::passive_endpoint>(fContext.GetIoContext(), *fOfiFabric);
//fPassiveEndpoint->set_local_address(Context::ConvertAddress(fLocalAddr)); //fPassiveEndpoint->set_local_address(Context::ConvertAddress(fLocalAddr));
BindControlEndpoint(); BindControlEndpoint();
@ -128,7 +128,7 @@ auto Socket::BindControlEndpoint() -> void
fPassiveEndpoint->listen([&](asiofi::info&& info) { fPassiveEndpoint->listen([&](asiofi::info&& info) {
LOG(debug) << "OFI transport (" << fId LOG(debug) << "OFI transport (" << fId
<< "): control band connection request received. Accepting ..."; << "): control band connection request received. Accepting ...";
fControlEndpoint = tools::make_unique<asiofi::connected_endpoint>( fControlEndpoint = make_unique<asiofi::connected_endpoint>(
fContext.GetIoContext(), *fOfiDomain, info); fContext.GetIoContext(), *fOfiDomain, info);
fControlEndpoint->enable(); fControlEndpoint->enable();
fControlEndpoint->accept([&]() { fControlEndpoint->accept([&]() {
@ -148,7 +148,7 @@ auto Socket::BindDataEndpoint() -> void
fPassiveEndpoint->listen([&](asiofi::info&& info) { fPassiveEndpoint->listen([&](asiofi::info&& info) {
LOG(debug) << "OFI transport (" << fId LOG(debug) << "OFI transport (" << fId
<< "): data band connection request received. Accepting ..."; << "): data band connection request received. Accepting ...";
fDataEndpoint = tools::make_unique<asiofi::connected_endpoint>( fDataEndpoint = make_unique<asiofi::connected_endpoint>(
fContext.GetIoContext(), *fOfiDomain, info); fContext.GetIoContext(), *fOfiDomain, info);
fDataEndpoint->enable(); fDataEndpoint->enable();
fDataEndpoint->accept([&]() { fDataEndpoint->accept([&]() {
@ -215,7 +215,7 @@ auto Socket::ConnectEndpoint(std::unique_ptr<asiofi::connected_endpoint>& endpoi
std::string band(type == Band::Control ? "control" : "data"); std::string band(type == Band::Control ? "control" : "data");
endpoint = tools::make_unique<asiofi::connected_endpoint>(fContext.GetIoContext(), *fOfiDomain); endpoint = make_unique<asiofi::connected_endpoint>(fContext.GetIoContext(), *fOfiDomain);
endpoint->enable(); endpoint->enable();
LOG(debug) << "OFI transport (" << fId << "): Sending " << band << " band connection request to " << fRemoteAddr; LOG(debug) << "OFI transport (" << fId << "): Sending " << band << " band connection request to " << fRemoteAddr;

4
fairmq/plugins/PMIx/PMIxCommands.h
View File

@ -13,7 +13,7 @@
#include <FairMQLogger.h> #include <FairMQLogger.h>
#include <fairmq/tools/Semaphore.h> #include <fairmq/tools/Semaphore.h>
#include <fairmq/tools/CppSTL.h> #include <memory> // make_unique
#include <string> #include <string>
namespace pmix namespace pmix
@ -156,7 +156,7 @@ class Commands
void Send(const std::string& msg, const std::vector<proc>& destination) void Send(const std::string& msg, const std::vector<proc>& destination)
{ {
std::unique_ptr<Holder> holder = fair::mq::tools::make_unique<Holder>(); std::unique_ptr<Holder> holder = std::make_unique<Holder>();
PMIX_DATA_ARRAY_CREATE(holder->fData, destination.size(), PMIX_PROC); PMIX_DATA_ARRAY_CREATE(holder->fData, destination.size(), PMIX_PROC);
memcpy(holder->fData->array, destination.data(), destination.size() * sizeof(pmix_proc_t)); memcpy(holder->fData->array, destination.data(), destination.size() * sizeof(pmix_proc_t));

34
fairmq/sdk/commands/Commands.cxx
View File

@ -219,37 +219,37 @@ string Cmds::Serialize(const Format type) const
switch (cmd->GetType()) { switch (cmd->GetType()) {
case Type::check_state: { case Type::check_state: {
cmdBuilder = tools::make_unique<FBCommandBuilder>(fbb); cmdBuilder = make_unique<FBCommandBuilder>(fbb);
} }
break; break;
case Type::change_state: { case Type::change_state: {
cmdBuilder = tools::make_unique<FBCommandBuilder>(fbb); cmdBuilder = make_unique<FBCommandBuilder>(fbb);
cmdBuilder->add_transition(GetFBTransition(static_cast<ChangeState&>(*cmd).GetTransition())); cmdBuilder->add_transition(GetFBTransition(static_cast<ChangeState&>(*cmd).GetTransition()));
} }
break; break;
case Type::dump_config: { case Type::dump_config: {
cmdBuilder = tools::make_unique<FBCommandBuilder>(fbb); cmdBuilder = make_unique<FBCommandBuilder>(fbb);
} }
break; break;
break; break;
case Type::subscribe_to_state_change: { case Type::subscribe_to_state_change: {
auto _cmd = static_cast<SubscribeToStateChange&>(*cmd); auto _cmd = static_cast<SubscribeToStateChange&>(*cmd);
cmdBuilder = tools::make_unique<FBCommandBuilder>(fbb); cmdBuilder = make_unique<FBCommandBuilder>(fbb);
cmdBuilder->add_interval(_cmd.GetInterval()); cmdBuilder->add_interval(_cmd.GetInterval());
} }
break; break;
case Type::unsubscribe_from_state_change: { case Type::unsubscribe_from_state_change: {
cmdBuilder = tools::make_unique<FBCommandBuilder>(fbb); cmdBuilder = make_unique<FBCommandBuilder>(fbb);
} }
break; break;
case Type::state_change_exiting_received: { case Type::state_change_exiting_received: {
cmdBuilder = tools::make_unique<FBCommandBuilder>(fbb); cmdBuilder = make_unique<FBCommandBuilder>(fbb);
} }
break; break;
case Type::get_properties: { case Type::get_properties: {
auto _cmd = static_cast<GetProperties&>(*cmd); auto _cmd = static_cast<GetProperties&>(*cmd);
auto query = fbb.CreateString(_cmd.GetQuery()); auto query = fbb.CreateString(_cmd.GetQuery());
cmdBuilder = tools::make_unique<FBCommandBuilder>(fbb); cmdBuilder = make_unique<FBCommandBuilder>(fbb);
cmdBuilder->add_request_id(_cmd.GetRequestId()); cmdBuilder->add_request_id(_cmd.GetRequestId());
cmdBuilder->add_property_query(query); cmdBuilder->add_property_query(query);
} }
@ -263,21 +263,21 @@ string Cmds::Serialize(const Format type) const
propsVector.push_back(CreateFBProperty(fbb, key, val)); propsVector.push_back(CreateFBProperty(fbb, key, val));
} }
auto props = fbb.CreateVector(propsVector); auto props = fbb.CreateVector(propsVector);
cmdBuilder = tools::make_unique<FBCommandBuilder>(fbb); cmdBuilder = make_unique<FBCommandBuilder>(fbb);
cmdBuilder->add_request_id(_cmd.GetRequestId()); cmdBuilder->add_request_id(_cmd.GetRequestId());
cmdBuilder->add_properties(props); cmdBuilder->add_properties(props);
} }
break; break;
case Type::subscription_heartbeat: { case Type::subscription_heartbeat: {
auto _cmd = static_cast<SubscriptionHeartbeat&>(*cmd); auto _cmd = static_cast<SubscriptionHeartbeat&>(*cmd);
cmdBuilder = tools::make_unique<FBCommandBuilder>(fbb); cmdBuilder = make_unique<FBCommandBuilder>(fbb);
cmdBuilder->add_interval(_cmd.GetInterval()); cmdBuilder->add_interval(_cmd.GetInterval());
} }
break; break;
case Type::current_state: { case Type::current_state: {
auto _cmd = static_cast<CurrentState&>(*cmd); auto _cmd = static_cast<CurrentState&>(*cmd);
auto deviceId = fbb.CreateString(_cmd.GetDeviceId()); auto deviceId = fbb.CreateString(_cmd.GetDeviceId());
cmdBuilder = tools::make_unique<FBCommandBuilder>(fbb); cmdBuilder = make_unique<FBCommandBuilder>(fbb);
cmdBuilder->add_device_id(deviceId); cmdBuilder->add_device_id(deviceId);
cmdBuilder->add_current_state(GetFBState(_cmd.GetCurrentState())); cmdBuilder->add_current_state(GetFBState(_cmd.GetCurrentState()));
} }
@ -285,7 +285,7 @@ string Cmds::Serialize(const Format type) const
case Type::transition_status: { case Type::transition_status: {
auto _cmd = static_cast<TransitionStatus&>(*cmd); auto _cmd = static_cast<TransitionStatus&>(*cmd);
auto deviceId = fbb.CreateString(_cmd.GetDeviceId()); auto deviceId = fbb.CreateString(_cmd.GetDeviceId());
cmdBuilder = tools::make_unique<FBCommandBuilder>(fbb); cmdBuilder = make_unique<FBCommandBuilder>(fbb);
cmdBuilder->add_device_id(deviceId); cmdBuilder->add_device_id(deviceId);
cmdBuilder->add_task_id(_cmd.GetTaskId()); cmdBuilder->add_task_id(_cmd.GetTaskId());
cmdBuilder->add_result(GetFBResult(_cmd.GetResult())); cmdBuilder->add_result(GetFBResult(_cmd.GetResult()));
@ -297,7 +297,7 @@ string Cmds::Serialize(const Format type) const
auto _cmd = static_cast<Config&>(*cmd); auto _cmd = static_cast<Config&>(*cmd);
auto deviceId = fbb.CreateString(_cmd.GetDeviceId()); auto deviceId = fbb.CreateString(_cmd.GetDeviceId());
auto config = fbb.CreateString(_cmd.GetConfig()); auto config = fbb.CreateString(_cmd.GetConfig());
cmdBuilder = tools::make_unique<FBCommandBuilder>(fbb); cmdBuilder = make_unique<FBCommandBuilder>(fbb);
cmdBuilder->add_device_id(deviceId); cmdBuilder->add_device_id(deviceId);
cmdBuilder->add_config_string(config); cmdBuilder->add_config_string(config);
} }
@ -305,7 +305,7 @@ string Cmds::Serialize(const Format type) const
case Type::state_change_subscription: { case Type::state_change_subscription: {
auto _cmd = static_cast<StateChangeSubscription&>(*cmd); auto _cmd = static_cast<StateChangeSubscription&>(*cmd);
auto deviceId = fbb.CreateString(_cmd.GetDeviceId()); auto deviceId = fbb.CreateString(_cmd.GetDeviceId());
cmdBuilder = tools::make_unique<FBCommandBuilder>(fbb); cmdBuilder = make_unique<FBCommandBuilder>(fbb);
cmdBuilder->add_device_id(deviceId); cmdBuilder->add_device_id(deviceId);
cmdBuilder->add_task_id(_cmd.GetTaskId()); cmdBuilder->add_task_id(_cmd.GetTaskId());
cmdBuilder->add_result(GetFBResult(_cmd.GetResult())); cmdBuilder->add_result(GetFBResult(_cmd.GetResult()));
@ -314,7 +314,7 @@ string Cmds::Serialize(const Format type) const
case Type::state_change_unsubscription: { case Type::state_change_unsubscription: {
auto _cmd = static_cast<StateChangeUnsubscription&>(*cmd); auto _cmd = static_cast<StateChangeUnsubscription&>(*cmd);
auto deviceId = fbb.CreateString(_cmd.GetDeviceId()); auto deviceId = fbb.CreateString(_cmd.GetDeviceId());
cmdBuilder = tools::make_unique<FBCommandBuilder>(fbb); cmdBuilder = make_unique<FBCommandBuilder>(fbb);
cmdBuilder->add_device_id(deviceId); cmdBuilder->add_device_id(deviceId);
cmdBuilder->add_task_id(_cmd.GetTaskId()); cmdBuilder->add_task_id(_cmd.GetTaskId());
cmdBuilder->add_result(GetFBResult(_cmd.GetResult())); cmdBuilder->add_result(GetFBResult(_cmd.GetResult()));
@ -323,7 +323,7 @@ string Cmds::Serialize(const Format type) const
case Type::state_change: { case Type::state_change: {
auto _cmd = static_cast<StateChange&>(*cmd); auto _cmd = static_cast<StateChange&>(*cmd);
auto deviceId = fbb.CreateString(_cmd.GetDeviceId()); auto deviceId = fbb.CreateString(_cmd.GetDeviceId());
cmdBuilder = tools::make_unique<FBCommandBuilder>(fbb); cmdBuilder = make_unique<FBCommandBuilder>(fbb);
cmdBuilder->add_device_id(deviceId); cmdBuilder->add_device_id(deviceId);
cmdBuilder->add_task_id(_cmd.GetTaskId()); cmdBuilder->add_task_id(_cmd.GetTaskId());
cmdBuilder->add_last_state(GetFBState(_cmd.GetLastState())); cmdBuilder->add_last_state(GetFBState(_cmd.GetLastState()));
@ -342,7 +342,7 @@ string Cmds::Serialize(const Format type) const
propsVector.push_back(prop); propsVector.push_back(prop);
} }
auto props = fbb.CreateVector(propsVector); auto props = fbb.CreateVector(propsVector);
cmdBuilder = tools::make_unique<FBCommandBuilder>(fbb); cmdBuilder = make_unique<FBCommandBuilder>(fbb);
cmdBuilder->add_device_id(deviceId); cmdBuilder->add_device_id(deviceId);
cmdBuilder->add_request_id(_cmd.GetRequestId()); cmdBuilder->add_request_id(_cmd.GetRequestId());
cmdBuilder->add_result(GetFBResult(_cmd.GetResult())); cmdBuilder->add_result(GetFBResult(_cmd.GetResult()));
@ -352,7 +352,7 @@ string Cmds::Serialize(const Format type) const
case Type::properties_set: { case Type::properties_set: {
auto _cmd = static_cast<PropertiesSet&>(*cmd); auto _cmd = static_cast<PropertiesSet&>(*cmd);
auto deviceId = fbb.CreateString(_cmd.GetDeviceId()); auto deviceId = fbb.CreateString(_cmd.GetDeviceId());
cmdBuilder = tools::make_unique<FBCommandBuilder>(fbb); cmdBuilder = make_unique<FBCommandBuilder>(fbb);
cmdBuilder->add_device_id(deviceId); cmdBuilder->add_device_id(deviceId);
cmdBuilder->add_request_id(_cmd.GetRequestId()); cmdBuilder->add_request_id(_cmd.GetRequestId());
cmdBuilder->add_result(GetFBResult(_cmd.GetResult())); cmdBuilder->add_result(GetFBResult(_cmd.GetResult()));

3
fairmq/sdk/commands/Commands.h
View File

@ -10,7 +10,6 @@
#define FAIR_MQ_SDK_COMMANDFACTORY #define FAIR_MQ_SDK_COMMANDFACTORY
#include <fairmq/States.h> #include <fairmq/States.h>
#include <fairmq/tools/CppSTL.h>
#include <vector> #include <vector>
#include <string> #include <string>
@ -354,7 +353,7 @@ struct PropertiesSet : Cmd {
template<typename C, typename... Args> template<typename C, typename... Args>
std::unique_ptr<Cmd> make(Args&&... args) std::unique_ptr<Cmd> make(Args&&... args)
{ {
return fair::mq::tools::make_unique<C>(std::forward<Args>(args)...); return std::make_unique<C>(std::forward<Args>(args)...);
} }
struct Cmds struct Cmds

6
fairmq/shmem/Manager.h
View File

@ -22,7 +22,6 @@
#include <FairMQLogger.h> #include <FairMQLogger.h>
#include <FairMQMessage.h> #include <FairMQMessage.h>
#include <fairmq/ProgOptions.h> #include <fairmq/ProgOptions.h>
#include <fairmq/tools/CppSTL.h>
#include <fairmq/tools/Strings.h> #include <fairmq/tools/Strings.h>
#include <boost/date_time/posix_time/posix_time.hpp> #include <boost/date_time/posix_time/posix_time.hpp>
@ -36,6 +35,7 @@
#include <cstdlib> // getenv #include <cstdlib> // getenv
#include <condition_variable> #include <condition_variable>
#include <memory> // make_unique
#include <mutex> #include <mutex>
#include <set> #include <set>
#include <sstream> #include <sstream>
@ -274,7 +274,7 @@ class Manager
// create region info // create region info
fShmRegions->emplace(id, RegionInfo(path.c_str(), flags, userFlags, fShmVoidAlloc)); fShmRegions->emplace(id, RegionInfo(path.c_str(), flags, userFlags, fShmVoidAlloc));
auto r = fRegions.emplace(id, tools::make_unique<Region>(fShmId, id, size, false, callback, bulkCallback, path, flags)); auto r = fRegions.emplace(id, std::make_unique<Region>(fShmId, id, size, false, callback, bulkCallback, path, flags));
// LOG(debug) << "Created region with id '" << id << "', path: '" << path << "', flags: '" << flags << "'"; // LOG(debug) << "Created region with id '" << id << "', path: '" << path << "', flags: '" << flags << "'";
r.first->second->StartReceivingAcks(); r.first->second->StartReceivingAcks();
@ -312,7 +312,7 @@ class Manager
int flags = regionInfo.fFlags; int flags = regionInfo.fFlags;
// LOG(debug) << "Located remote region with id '" << id << "', path: '" << path << "', flags: '" << flags << "'"; // LOG(debug) << "Located remote region with id '" << id << "', path: '" << path << "', flags: '" << flags << "'";
auto r = fRegions.emplace(id, tools::make_unique<Region>(fShmId, id, 0, true, nullptr, nullptr, path, flags)); auto r = fRegions.emplace(id, std::make_unique<Region>(fShmId, id, 0, true, nullptr, nullptr, path, flags));
return r.first->second.get(); return r.first->second.get();
} catch (std::out_of_range& oor) { } catch (std::out_of_range& oor) {
LOG(error) << "Could not get remote region with id '" << id << "'. Does the region creator run with the same session id?"; LOG(error) << "Could not get remote region with id '" << id << "'. Does the region creator run with the same session id?";

10
fairmq/shmem/Region.h
View File

@ -19,7 +19,6 @@
#include <FairMQLogger.h> #include <FairMQLogger.h>
#include <FairMQUnmanagedRegion.h> #include <FairMQUnmanagedRegion.h>
#include <fairmq/tools/CppSTL.h>
#include <fairmq/tools/Strings.h> #include <fairmq/tools/Strings.h>
#include <boost/filesystem.hpp> #include <boost/filesystem.hpp>
@ -32,6 +31,7 @@
#include <algorithm> // min #include <algorithm> // min
#include <atomic> #include <atomic>
#include <thread> #include <thread>
#include <memory> // make_unique
#include <mutex> #include <mutex>
#include <condition_variable> #include <condition_variable>
#include <unordered_map> #include <unordered_map>
@ -113,9 +113,9 @@ struct Region
using namespace boost::interprocess; using namespace boost::interprocess;
if (fRemote) { if (fRemote) {
fQueue = tools::make_unique<message_queue>(open_only, fQueueName.c_str()); fQueue = std::make_unique<message_queue>(open_only, fQueueName.c_str());
} else { } else {
fQueue = tools::make_unique<message_queue>(create_only, fQueueName.c_str(), 1024, fAckBunchSize * sizeof(RegionBlock)); fQueue = std::make_unique<message_queue>(create_only, fQueueName.c_str(), 1024, fAckBunchSize * sizeof(RegionBlock));
} }
LOG(debug) << "shmem: initialized region queue: " << fQueueName; LOG(debug) << "shmem: initialized region queue: " << fQueueName;
} }
@ -123,7 +123,7 @@ struct Region
void StartSendingAcks() { fAcksSender = std::thread(&Region::SendAcks, this); } void StartSendingAcks() { fAcksSender = std::thread(&Region::SendAcks, this); }
void SendAcks() void SendAcks()
{ {
std::unique_ptr<RegionBlock[]> blocks = tools::make_unique<RegionBlock[]>(fAckBunchSize); std::unique_ptr<RegionBlock[]> blocks = std::make_unique<RegionBlock[]>(fAckBunchSize);
size_t blocksToSend = 0; size_t blocksToSend = 0;
while (true) { while (true) {
@ -165,7 +165,7 @@ struct Region
{ {
unsigned int priority; unsigned int priority;
boost::interprocess::message_queue::size_type recvdSize; boost::interprocess::message_queue::size_type recvdSize;
std::unique_ptr<RegionBlock[]> blocks = tools::make_unique<RegionBlock[]>(fAckBunchSize); std::unique_ptr<RegionBlock[]> blocks = std::make_unique<RegionBlock[]>(fAckBunchSize);
std::vector<fair::mq::RegionBlock> result; std::vector<fair::mq::RegionBlock> result;
result.reserve(fAckBunchSize); result.reserve(fAckBunchSize);

3
fairmq/shmem/Socket.h
View File

@ -20,6 +20,7 @@
#include <zmq.h> #include <zmq.h>
#include <atomic> #include <atomic>
#include <memory> // make_unique
class FairMQTransportFactory; class FairMQTransportFactory;
@ -317,7 +318,7 @@ class Socket final : public fair::mq::Socket
for (size_t m = 0; m < numMessages; m++) { for (size_t m = 0; m < numMessages; m++) {
// create new message (part) // create new message (part)
msgVec.emplace_back(tools::make_unique<Message>(fManager, hdrVec[m], GetTransport())); msgVec.emplace_back(std::make_unique<Message>(fManager, hdrVec[m], GetTransport()));
Message* shmMsg = static_cast<Message*>(msgVec.back().get()); Message* shmMsg = static_cast<Message*>(msgVec.back().get());
totalSize += shmMsg->GetSize(); totalSize += shmMsg->GetSize();
} }

26
fairmq/shmem/TransportFactory.h
View File

@ -25,7 +25,7 @@
#include <zmq.h> #include <zmq.h>
#include <memory> // unique_ptr #include <memory> // unique_ptr, make_unique
#include <string> #include <string>
#include <vector> #include <vector>
@ -86,7 +86,7 @@ class TransportFactory final : public fair::mq::TransportFactory
LOG(error) << "failed configuring context, reason: " << zmq_strerror(errno); LOG(error) << "failed configuring context, reason: " << zmq_strerror(errno);
} }
fManager = tools::make_unique<Manager>(fShmId, fDeviceId, segmentSize, config); fManager = std::make_unique<Manager>(fShmId, fDeviceId, segmentSize, config);
} catch (boost::interprocess::interprocess_exception& e) { } catch (boost::interprocess::interprocess_exception& e) {
LOG(error) << "Could not initialize shared memory transport: " << e.what(); LOG(error) << "Could not initialize shared memory transport: " << e.what();
throw std::runtime_error(tools::ToString("Could not initialize shared memory transport: ", e.what())); throw std::runtime_error(tools::ToString("Could not initialize shared memory transport: ", e.what()));
@ -98,52 +98,52 @@ class TransportFactory final : public fair::mq::TransportFactory
MessagePtr CreateMessage() override MessagePtr CreateMessage() override
{ {
return tools::make_unique<Message>(*fManager, this); return std::make_unique<Message>(*fManager, this);
} }
MessagePtr CreateMessage(Alignment alignment) override MessagePtr CreateMessage(Alignment alignment) override
{ {
return tools::make_unique<Message>(*fManager, alignment, this); return std::make_unique<Message>(*fManager, alignment, this);
} }
MessagePtr CreateMessage(const size_t size) override MessagePtr CreateMessage(const size_t size) override
{ {
return tools::make_unique<Message>(*fManager, size, this); return std::make_unique<Message>(*fManager, size, this);
} }
MessagePtr CreateMessage(const size_t size, Alignment alignment) override MessagePtr CreateMessage(const size_t size, Alignment alignment) override
{ {
return tools::make_unique<Message>(*fManager, size, alignment, this); return std::make_unique<Message>(*fManager, size, alignment, this);
} }
MessagePtr CreateMessage(void* data, const size_t size, fairmq_free_fn* ffn, void* hint = nullptr) override MessagePtr CreateMessage(void* data, const size_t size, fairmq_free_fn* ffn, void* hint = nullptr) override
{ {
return tools::make_unique<Message>(*fManager, data, size, ffn, hint, this); return std::make_unique<Message>(*fManager, data, size, ffn, hint, this);
} }
MessagePtr CreateMessage(UnmanagedRegionPtr& region, void* data, const size_t size, void* hint = 0) override MessagePtr CreateMessage(UnmanagedRegionPtr& region, void* data, const size_t size, void* hint = 0) override
{ {
return tools::make_unique<Message>(*fManager, region, data, size, hint, this); return std::make_unique<Message>(*fManager, region, data, size, hint, this);
} }
SocketPtr CreateSocket(const std::string& type, const std::string& name) override SocketPtr CreateSocket(const std::string& type, const std::string& name) override
{ {
return tools::make_unique<Socket>(*fManager, type, name, GetId(), fZmqCtx, this); return std::make_unique<Socket>(*fManager, type, name, GetId(), fZmqCtx, this);
} }
PollerPtr CreatePoller(const std::vector<FairMQChannel>& channels) const override PollerPtr CreatePoller(const std::vector<FairMQChannel>& channels) const override
{ {
return tools::make_unique<Poller>(channels); return std::make_unique<Poller>(channels);
} }
PollerPtr CreatePoller(const std::vector<FairMQChannel*>& channels) const override PollerPtr CreatePoller(const std::vector<FairMQChannel*>& channels) const override
{ {
return tools::make_unique<Poller>(channels); return std::make_unique<Poller>(channels);
} }
PollerPtr CreatePoller(const std::unordered_map<std::string, std::vector<FairMQChannel>>& channelsMap, const std::vector<std::string>& channelList) const override PollerPtr CreatePoller(const std::unordered_map<std::string, std::vector<FairMQChannel>>& channelsMap, const std::vector<std::string>& channelList) const override
{ {
return tools::make_unique<Poller>(channelsMap, channelList); return std::make_unique<Poller>(channelsMap, channelList);
} }
UnmanagedRegionPtr CreateUnmanagedRegion(const size_t size, RegionCallback callback = nullptr, const std::string& path = "", int flags = 0) override UnmanagedRegionPtr CreateUnmanagedRegion(const size_t size, RegionCallback callback = nullptr, const std::string& path = "", int flags = 0) override
@ -168,7 +168,7 @@ class TransportFactory final : public fair::mq::TransportFactory
UnmanagedRegionPtr CreateUnmanagedRegion(const size_t size, int64_t userFlags, RegionCallback callback, RegionBulkCallback bulkCallback, const std::string& path, int flags) UnmanagedRegionPtr CreateUnmanagedRegion(const size_t size, int64_t userFlags, RegionCallback callback, RegionBulkCallback bulkCallback, const std::string& path, int flags)
{ {
return tools::make_unique<UnmanagedRegion>(*fManager, size, userFlags, callback, bulkCallback, path, flags, this); return std::make_unique<UnmanagedRegion>(*fManager, size, userFlags, callback, bulkCallback, path, flags, this);
} }
void SubscribeToRegionEvents(RegionEventCallback callback) override { fManager->SubscribeToRegionEvents(callback); } void SubscribeToRegionEvents(RegionEventCallback callback) override { fManager->SubscribeToRegionEvents(callback); }

14
fairmq/tools/CppSTL.h
View File

@ -20,20 +20,6 @@ namespace mq
namespace tools namespace tools
{ {
// make_unique implementation, until C++14 is default
template<typename T, typename ...Args>
std::unique_ptr<T> make_unique(Args&& ...args)
{
return std::unique_ptr<T>(new T(std::forward<Args>(args)...));
}
// make_unique implementation (array variant), until C++14 is default
template<typename T>
std::unique_ptr<T> make_unique(std::size_t size)
{
return std::unique_ptr<T>(new typename std::remove_extent<T>::type[size]());
}
// provide an enum hasher to compensate std::hash not supporting enums in C++11 // provide an enum hasher to compensate std::hash not supporting enums in C++11
template<typename Enum> template<typename Enum>
struct HashEnum struct HashEnum

27
fairmq/zeromq/Message.h
View File

@ -9,7 +9,6 @@
#ifndef FAIR_MQ_ZMQ_MESSAGE_H #ifndef FAIR_MQ_ZMQ_MESSAGE_H
#define FAIR_MQ_ZMQ_MESSAGE_H #define FAIR_MQ_ZMQ_MESSAGE_H
#include <fairmq/Tools.h>
#include <fairmq/zeromq/UnmanagedRegion.h> #include <fairmq/zeromq/UnmanagedRegion.h>
#include <FairMQLogger.h> #include <FairMQLogger.h>
#include <FairMQMessage.h> #include <FairMQMessage.h>
@ -20,7 +19,7 @@
#include <cstddef> #include <cstddef>
#include <cstdlib> // malloc #include <cstdlib> // malloc
#include <cstring> #include <cstring>
#include <memory> #include <memory> // make_unique
#include <new> // bad_alloc #include <new> // bad_alloc
#include <string> #include <string>
@ -41,7 +40,7 @@ class Message final : public fair::mq::Message
Message(FairMQTransportFactory* factory = nullptr) Message(FairMQTransportFactory* factory = nullptr)
: fair::mq::Message(factory) : fair::mq::Message(factory)
, fAlignment(0) , fAlignment(0)
, fMsg(tools::make_unique<zmq_msg_t>()) , fMsg(std::make_unique<zmq_msg_t>())
{ {
if (zmq_msg_init(fMsg.get()) != 0) { if (zmq_msg_init(fMsg.get()) != 0) {
LOG(error) << "failed initializing message, reason: " << zmq_strerror(errno); LOG(error) << "failed initializing message, reason: " << zmq_strerror(errno);
@ -51,7 +50,7 @@ class Message final : public fair::mq::Message
Message(Alignment alignment, FairMQTransportFactory* factory = nullptr) Message(Alignment alignment, FairMQTransportFactory* factory = nullptr)
: fair::mq::Message(factory) : fair::mq::Message(factory)
, fAlignment(alignment.alignment) , fAlignment(alignment.alignment)
, fMsg(tools::make_unique<zmq_msg_t>()) , fMsg(std::make_unique<zmq_msg_t>())
{ {
if (zmq_msg_init(fMsg.get()) != 0) { if (zmq_msg_init(fMsg.get()) != 0) {
LOG(error) << "failed initializing message, reason: " << zmq_strerror(errno); LOG(error) << "failed initializing message, reason: " << zmq_strerror(errno);
@ -61,7 +60,7 @@ class Message final : public fair::mq::Message
Message(const size_t size, FairMQTransportFactory* factory = nullptr) Message(const size_t size, FairMQTransportFactory* factory = nullptr)
: fair::mq::Message(factory) : fair::mq::Message(factory)
, fAlignment(0) , fAlignment(0)
, fMsg(tools::make_unique<zmq_msg_t>()) , fMsg(std::make_unique<zmq_msg_t>())
{ {
if (zmq_msg_init_size(fMsg.get(), size) != 0) { if (zmq_msg_init_size(fMsg.get(), size) != 0) {
LOG(error) << "failed initializing message with size, reason: " << zmq_strerror(errno); LOG(error) << "failed initializing message with size, reason: " << zmq_strerror(errno);
@ -85,7 +84,7 @@ class Message final : public fair::mq::Message
Message(const size_t size, Alignment alignment, FairMQTransportFactory* factory = nullptr) Message(const size_t size, Alignment alignment, FairMQTransportFactory* factory = nullptr)
: fair::mq::Message(factory) : fair::mq::Message(factory)
, fAlignment(alignment.alignment) , fAlignment(alignment.alignment)
, fMsg(tools::make_unique<zmq_msg_t>()) , fMsg(std::make_unique<zmq_msg_t>())
{ {
if (fAlignment != 0) { if (fAlignment != 0) {
auto ptrs = AllocateAligned(size, fAlignment); auto ptrs = AllocateAligned(size, fAlignment);
@ -102,7 +101,7 @@ class Message final : public fair::mq::Message
Message(void* data, const size_t size, fairmq_free_fn* ffn, void* hint = nullptr, FairMQTransportFactory* factory = nullptr) Message(void* data, const size_t size, fairmq_free_fn* ffn, void* hint = nullptr, FairMQTransportFactory* factory = nullptr)
: fair::mq::Message(factory) : fair::mq::Message(factory)
, fAlignment(0) , fAlignment(0)
, fMsg(tools::make_unique<zmq_msg_t>()) , fMsg(std::make_unique<zmq_msg_t>())
{ {
if (zmq_msg_init_data(fMsg.get(), data, size, ffn, hint) != 0) { if (zmq_msg_init_data(fMsg.get(), data, size, ffn, hint) != 0) {
LOG(error) << "failed initializing message with data, reason: " << zmq_strerror(errno); LOG(error) << "failed initializing message with data, reason: " << zmq_strerror(errno);
@ -112,7 +111,7 @@ class Message final : public fair::mq::Message
Message(UnmanagedRegionPtr& region, void* data, const size_t size, void* hint = 0, FairMQTransportFactory* factory = nullptr) Message(UnmanagedRegionPtr& region, void* data, const size_t size, void* hint = 0, FairMQTransportFactory* factory = nullptr)
: fair::mq::Message(factory) : fair::mq::Message(factory)
, fAlignment(0) , fAlignment(0)
, fMsg(tools::make_unique<zmq_msg_t>()) , fMsg(std::make_unique<zmq_msg_t>())
{ {
// FIXME: make this zero-copy: // FIXME: make this zero-copy:
// simply taking over the provided buffer can casue premature delete, since region could be // simply taking over the provided buffer can casue premature delete, since region could be
@ -140,7 +139,7 @@ class Message final : public fair::mq::Message
void Rebuild() override void Rebuild() override
{ {
CloseMessage(); CloseMessage();
fMsg = tools::make_unique<zmq_msg_t>(); fMsg = std::make_unique<zmq_msg_t>();
if (zmq_msg_init(fMsg.get()) != 0) { if (zmq_msg_init(fMsg.get()) != 0) {
LOG(error) << "failed initializing message, reason: " << zmq_strerror(errno); LOG(error) << "failed initializing message, reason: " << zmq_strerror(errno);
} }
@ -150,7 +149,7 @@ class Message final : public fair::mq::Message
{ {
CloseMessage(); CloseMessage();
fAlignment = alignment.alignment; fAlignment = alignment.alignment;
fMsg = tools::make_unique<zmq_msg_t>(); fMsg = std::make_unique<zmq_msg_t>();
if (zmq_msg_init(fMsg.get()) != 0) { if (zmq_msg_init(fMsg.get()) != 0) {
LOG(error) << "failed initializing message, reason: " << zmq_strerror(errno); LOG(error) << "failed initializing message, reason: " << zmq_strerror(errno);
} }
@ -159,7 +158,7 @@ class Message final : public fair::mq::Message
void Rebuild(const size_t size) override void Rebuild(const size_t size) override
{ {
CloseMessage(); CloseMessage();
fMsg = tools::make_unique<zmq_msg_t>(); fMsg = std::make_unique<zmq_msg_t>();
if (zmq_msg_init_size(fMsg.get(), size) != 0) { if (zmq_msg_init_size(fMsg.get(), size) != 0) {
LOG(error) << "failed initializing message with size, reason: " << zmq_strerror(errno); LOG(error) << "failed initializing message with size, reason: " << zmq_strerror(errno);
} }
@ -169,7 +168,7 @@ class Message final : public fair::mq::Message
{ {
CloseMessage(); CloseMessage();
fAlignment = alignment.alignment; fAlignment = alignment.alignment;
fMsg = tools::make_unique<zmq_msg_t>(); fMsg = std::make_unique<zmq_msg_t>();
if (fAlignment != 0) { if (fAlignment != 0) {
auto ptrs = AllocateAligned(size, fAlignment); auto ptrs = AllocateAligned(size, fAlignment);
@ -186,7 +185,7 @@ class Message final : public fair::mq::Message
void Rebuild(void* data, const size_t size, fairmq_free_fn* ffn, void* hint = nullptr) override void Rebuild(void* data, const size_t size, fairmq_free_fn* ffn, void* hint = nullptr) override
{ {
CloseMessage(); CloseMessage();
fMsg = tools::make_unique<zmq_msg_t>(); fMsg = std::make_unique<zmq_msg_t>();
if (zmq_msg_init_data(fMsg.get(), data, size, ffn, hint) != 0) { if (zmq_msg_init_data(fMsg.get(), data, size, ffn, hint) != 0) {
LOG(error) << "failed initializing message with data, reason: " << zmq_strerror(errno); LOG(error) << "failed initializing message with data, reason: " << zmq_strerror(errno);
} }
@ -217,7 +216,7 @@ class Message final : public fair::mq::Message
LOG(error) << "cannot set used size higher than original."; LOG(error) << "cannot set used size higher than original.";
return false; return false;
} else { } else {
auto newMsg = tools::make_unique<zmq_msg_t>(); auto newMsg = std::make_unique<zmq_msg_t>();
void* data = GetData(); void* data = GetData();
if (zmq_msg_init_data(newMsg.get(), data, size, [](void* /* data */, void* obj) { if (zmq_msg_init_data(newMsg.get(), data, size, [](void* /* data */, void* obj) {
zmq_msg_close(static_cast<zmq_msg_t*>(obj)); zmq_msg_close(static_cast<zmq_msg_t*>(obj));

7
fairmq/zeromq/Socket.h
View File

@ -19,7 +19,7 @@
#include <zmq.h> #include <zmq.h>
#include <atomic> #include <atomic>
#include <memory> // unique_ptr #include <memory> // unique_ptr, make_unique
namespace fair { namespace fair {
namespace mq { namespace mq {
@ -258,7 +258,7 @@ class Socket final : public fair::mq::Socket
bool repeat = false; bool repeat = false;
do { do {
FairMQMessagePtr part = tools::make_unique<Message>(GetTransport()); FairMQMessagePtr part = std::make_unique<Message>(GetTransport());
int nbytes = zmq_msg_recv(static_cast<Message*>(part.get())->GetMessage(), fSocket, flags); int nbytes = zmq_msg_recv(static_cast<Message*>(part.get())->GetMessage(), fSocket, flags);
if (nbytes >= 0) { if (nbytes >= 0) {
@ -328,8 +328,7 @@ class Socket final : public fair::mq::Socket
{ {
size_t eventsSize = sizeof(uint32_t); size_t eventsSize = sizeof(uint32_t);
if (zmq_getsockopt(fSocket, ZMQ_EVENTS, events, &eventsSize) < 0) { if (zmq_getsockopt(fSocket, ZMQ_EVENTS, events, &eventsSize) < 0) {
throw SocketError( throw SocketError(tools::ToString("failed setting ZMQ_EVENTS, reason: ", zmq_strerror(errno)));
tools::ToString("failed setting ZMQ_EVENTS, reason: ", zmq_strerror(errno)));
} }
} }

28
fairmq/zeromq/TransportFactory.h
View File

@ -18,7 +18,7 @@
#include <FairMQTransportFactory.h> #include <FairMQTransportFactory.h>
#include <fairmq/ProgOptions.h> #include <fairmq/ProgOptions.h>
#include <memory> // unique_ptr #include <memory> // unique_ptr, make_unique
#include <string> #include <string>
#include <vector> #include <vector>
@ -41,10 +41,10 @@ class TransportFactory final : public FairMQTransportFactory
LOG(debug) << "Transport: Using ZeroMQ library, version: " << major << "." << minor << "." << patch; LOG(debug) << "Transport: Using ZeroMQ library, version: " << major << "." << minor << "." << patch;
if (config) { if (config) {
fCtx = tools::make_unique<Context>(config->GetProperty<int>("io-threads", 1)); fCtx = std::make_unique<Context>(config->GetProperty<int>("io-threads", 1));
} else { } else {
LOG(debug) << "fair::mq::ProgOptions not available! Using defaults."; LOG(debug) << "fair::mq::ProgOptions not available! Using defaults.";
fCtx = tools::make_unique<Context>(1); fCtx = std::make_unique<Context>(1);
} }
} }
@ -53,52 +53,52 @@ class TransportFactory final : public FairMQTransportFactory
MessagePtr CreateMessage() override MessagePtr CreateMessage() override
{ {
return tools::make_unique<Message>(this); return std::make_unique<Message>(this);
} }
MessagePtr CreateMessage(Alignment alignment) override MessagePtr CreateMessage(Alignment alignment) override
{ {
return tools::make_unique<Message>(alignment, this); return std::make_unique<Message>(alignment, this);
} }
MessagePtr CreateMessage(const size_t size) override MessagePtr CreateMessage(const size_t size) override
{ {
return tools::make_unique<Message>(size, this); return std::make_unique<Message>(size, this);
} }
MessagePtr CreateMessage(const size_t size, Alignment alignment) override MessagePtr CreateMessage(const size_t size, Alignment alignment) override
{ {
return tools::make_unique<Message>(size, alignment, this); return std::make_unique<Message>(size, alignment, this);
} }
MessagePtr CreateMessage(void* data, const size_t size, fairmq_free_fn* ffn, void* hint = nullptr) override MessagePtr CreateMessage(void* data, const size_t size, fairmq_free_fn* ffn, void* hint = nullptr) override
{ {
return tools::make_unique<Message>(data, size, ffn, hint, this); return std::make_unique<Message>(data, size, ffn, hint, this);
} }
MessagePtr CreateMessage(UnmanagedRegionPtr& region, void* data, const size_t size, void* hint = 0) override MessagePtr CreateMessage(UnmanagedRegionPtr& region, void* data, const size_t size, void* hint = 0) override
{ {
return tools::make_unique<Message>(region, data, size, hint, this); return std::make_unique<Message>(region, data, size, hint, this);
} }
SocketPtr CreateSocket(const std::string& type, const std::string& name) override SocketPtr CreateSocket(const std::string& type, const std::string& name) override
{ {
return tools::make_unique<Socket>(*fCtx, type, name, GetId(), this); return std::make_unique<Socket>(*fCtx, type, name, GetId(), this);
} }
PollerPtr CreatePoller(const std::vector<FairMQChannel>& channels) const override PollerPtr CreatePoller(const std::vector<FairMQChannel>& channels) const override
{ {
return tools::make_unique<Poller>(channels); return std::make_unique<Poller>(channels);
} }
PollerPtr CreatePoller(const std::vector<FairMQChannel*>& channels) const override PollerPtr CreatePoller(const std::vector<FairMQChannel*>& channels) const override
{ {
return tools::make_unique<Poller>(channels); return std::make_unique<Poller>(channels);
} }
PollerPtr CreatePoller(const std::unordered_map<std::string, std::vector<FairMQChannel>>& channelsMap, const std::vector<std::string>& channelList) const override PollerPtr CreatePoller(const std::unordered_map<std::string, std::vector<FairMQChannel>>& channelsMap, const std::vector<std::string>& channelList) const override
{ {
return tools::make_unique<Poller>(channelsMap, channelList); return std::make_unique<Poller>(channelsMap, channelList);
} }
UnmanagedRegionPtr CreateUnmanagedRegion(const size_t size, RegionCallback callback, const std::string& path = "", int flags = 0) override UnmanagedRegionPtr CreateUnmanagedRegion(const size_t size, RegionCallback callback, const std::string& path = "", int flags = 0) override
@ -123,7 +123,7 @@ class TransportFactory final : public FairMQTransportFactory
UnmanagedRegionPtr CreateUnmanagedRegion(const size_t size, const int64_t userFlags, RegionCallback callback, RegionBulkCallback bulkCallback, const std::string&, int) UnmanagedRegionPtr CreateUnmanagedRegion(const size_t size, const int64_t userFlags, RegionCallback callback, RegionBulkCallback bulkCallback, const std::string&, int)
{ {
UnmanagedRegionPtr ptr = tools::make_unique<UnmanagedRegion>(*fCtx, size, userFlags, callback, bulkCallback, this); UnmanagedRegionPtr ptr = std::make_unique<UnmanagedRegion>(*fCtx, size, userFlags, callback, bulkCallback, this);
auto zPtr = static_cast<UnmanagedRegion*>(ptr.get()); auto zPtr = static_cast<UnmanagedRegion*>(ptr.get());
fCtx->AddRegion(false, zPtr->GetId(), zPtr->GetData(), zPtr->GetSize(), zPtr->GetUserFlags(), RegionEvent::created); fCtx->AddRegion(false, zPtr->GetId(), zPtr->GetData(), zPtr->GetSize(), zPtr->GetUserFlags(), RegionEvent::created);
return ptr; return ptr;