Program Listing for File RTPSParticipantAttributes.h
↰ Return to documentation for file (/tmp/ws/src/fastrtps/include/fastdds/rtps/attributes/RTPSParticipantAttributes.h
)
// Copyright 2016 Proyectos y Sistemas de Mantenimiento SL (eProsima).
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
#ifndef _FASTDDS_RTPSPARTICIPANTPARAMETERS_H_
#define _FASTDDS_RTPSPARTICIPANTPARAMETERS_H_
#include <fastdds/rtps/attributes/ExternalLocators.hpp>
#include <fastdds/rtps/attributes/PropertyPolicy.h>
#include <fastdds/rtps/attributes/RTPSParticipantAllocationAttributes.hpp>
#include <fastdds/rtps/attributes/ServerAttributes.h>
#include <fastdds/rtps/common/Locator.h>
#include <fastdds/rtps/common/PortParameters.h>
#include <fastdds/rtps/common/Time_t.h>
#include <fastdds/rtps/flowcontrol/FlowControllerDescriptor.hpp>
#include <fastdds/rtps/flowcontrol/ThroughputControllerDescriptor.h>
#include <fastdds/rtps/resources/ResourceManagement.h>
#include <fastdds/rtps/transport/TransportInterface.h>
#include <fastrtps/utils/fixed_size_string.hpp>
#include <memory>
#include <sstream>
namespace eprosima {
namespace fastdds {
namespace rtps {
struct ParticipantType
{
static constexpr const char* SIMPLE = "SIMPLE";
static constexpr const char* SERVER = "SERVER";
static constexpr const char* CLIENT = "CLIENT";
static constexpr const char* SUPER_CLIENT = "SUPER_CLIENT";
static constexpr const char* BACKUP = "BACKUP";
static constexpr const char* NONE = "NONE";
static constexpr const char* EXTERNAL = "EXTERNAL";
static constexpr const char* UNKNOWN = "UNKNOWN";
};
} /* namespace rtps */
} /* namespace fastdds */
namespace fastrtps {
namespace rtps {
typedef enum DiscoveryProtocol
{
NONE,
SIMPLE,
EXTERNAL,
CLIENT,
SERVER,
BACKUP,
SUPER_CLIENT
} DiscoveryProtocol_t;
inline std::ostream& operator <<(
std::ostream& output,
const DiscoveryProtocol& discovery_protocol)
{
switch (discovery_protocol)
{
case DiscoveryProtocol::NONE:
output << fastdds::rtps::ParticipantType::NONE;
break;
case DiscoveryProtocol::SIMPLE:
output << fastdds::rtps::ParticipantType::SIMPLE;
break;
case DiscoveryProtocol::EXTERNAL:
output << fastdds::rtps::ParticipantType::EXTERNAL;
break;
case DiscoveryProtocol::CLIENT:
output << fastdds::rtps::ParticipantType::CLIENT;
break;
case DiscoveryProtocol::SUPER_CLIENT:
output << fastdds::rtps::ParticipantType::SUPER_CLIENT;
break;
case DiscoveryProtocol::SERVER:
output << fastdds::rtps::ParticipantType::SERVER;
break;
case DiscoveryProtocol::BACKUP:
output << fastdds::rtps::ParticipantType::BACKUP;
break;
default:
output << fastdds::rtps::ParticipantType::UNKNOWN;
}
return output;
}
typedef enum ParticipantFilteringFlags : uint32_t
{
NO_FILTER = 0,
FILTER_DIFFERENT_HOST = 0x1,
FILTER_DIFFERENT_PROCESS = 0x2,
FILTER_SAME_PROCESS = 0x4
} ParticipantFilteringFlags_t;
#define BUILTIN_DATA_MAX_SIZE 512
class PDP;
class BuiltinProtocols;
typedef struct _PDPFactory
{
// Pointer to the PDP creator
PDP* (*CreatePDPInstance)(BuiltinProtocols*);
// Pointer to the PDP destructor
void (* ReleasePDPInstance)(
PDP*);
bool operator ==(
const struct _PDPFactory& e) const
{
return (CreatePDPInstance == e.CreatePDPInstance)
&& (ReleasePDPInstance == e.ReleasePDPInstance);
}
} PDPFactory;
class SimpleEDPAttributes
{
public:
bool use_PublicationWriterANDSubscriptionReader;
bool use_PublicationReaderANDSubscriptionWriter;
#if HAVE_SECURITY
bool enable_builtin_secure_publications_writer_and_subscriptions_reader;
bool enable_builtin_secure_subscriptions_writer_and_publications_reader;
#endif // if HAVE_SECURITY
SimpleEDPAttributes()
: use_PublicationWriterANDSubscriptionReader(true)
, use_PublicationReaderANDSubscriptionWriter(true)
#if HAVE_SECURITY
, enable_builtin_secure_publications_writer_and_subscriptions_reader(true)
, enable_builtin_secure_subscriptions_writer_and_publications_reader(true)
#endif // if HAVE_SECURITY
{
}
bool operator ==(
const SimpleEDPAttributes& b) const
{
return (this->use_PublicationWriterANDSubscriptionReader == b.use_PublicationWriterANDSubscriptionReader) &&
#if HAVE_SECURITY
(this->enable_builtin_secure_publications_writer_and_subscriptions_reader ==
b.enable_builtin_secure_publications_writer_and_subscriptions_reader) &&
(this->enable_builtin_secure_subscriptions_writer_and_publications_reader ==
b.enable_builtin_secure_subscriptions_writer_and_publications_reader) &&
#endif // if HAVE_SECURITY
(this->use_PublicationReaderANDSubscriptionWriter == b.use_PublicationReaderANDSubscriptionWriter);
}
};
struct InitialAnnouncementConfig
{
uint32_t count = 5u;
Duration_t period = { 0, 100000000u };
bool operator ==(
const InitialAnnouncementConfig& b) const
{
return (count == b.count) && (period == b.period);
}
};
class DiscoverySettings
{
public:
DiscoveryProtocol_t discoveryProtocol = DiscoveryProtocol_t::SIMPLE;
bool use_SIMPLE_EndpointDiscoveryProtocol = true;
bool use_STATIC_EndpointDiscoveryProtocol = false;
Duration_t leaseDuration = { 20, 0 };
Duration_t leaseDuration_announcementperiod = { 3, 0 };
InitialAnnouncementConfig initial_announcements;
SimpleEDPAttributes m_simpleEDP;
PDPFactory m_PDPfactory{};
Duration_t discoveryServer_client_syncperiod = { 0, 450 * 1000000}; // 450 milliseconds
eprosima::fastdds::rtps::RemoteServerList_t m_DiscoveryServers;
ParticipantFilteringFlags_t ignoreParticipantFlags = ParticipantFilteringFlags::NO_FILTER;
DiscoverySettings() = default;
bool operator ==(
const DiscoverySettings& b) const
{
return (this->discoveryProtocol == b.discoveryProtocol) &&
(this->use_SIMPLE_EndpointDiscoveryProtocol == b.use_SIMPLE_EndpointDiscoveryProtocol) &&
(this->use_STATIC_EndpointDiscoveryProtocol == b.use_STATIC_EndpointDiscoveryProtocol) &&
(this->discoveryServer_client_syncperiod == b.discoveryServer_client_syncperiod) &&
(this->m_PDPfactory == b.m_PDPfactory) &&
(this->leaseDuration == b.leaseDuration) &&
(this->leaseDuration_announcementperiod == b.leaseDuration_announcementperiod) &&
(this->initial_announcements == b.initial_announcements) &&
(this->m_simpleEDP == b.m_simpleEDP) &&
(this->static_edp_xml_config_ == b.static_edp_xml_config_) &&
(this->m_DiscoveryServers == b.m_DiscoveryServers) &&
(this->ignoreParticipantFlags == b.ignoreParticipantFlags);
}
FASTRTPS_DEPRECATED("Use static_edp_xml_config()")
const char* getStaticEndpointXMLFilename() const
{
return static_edp_xml_config();
}
FASTRTPS_DEPRECATED("Use static_edp_xml_config()")
void setStaticEndpointXMLFilename(
const char* str)
{
static_edp_xml_config_ = "file://" + std::string(str);
}
void static_edp_xml_config(
const char* str)
{
static_edp_xml_config_ = str;
}
const char* static_edp_xml_config() const
{
return static_edp_xml_config_.c_str();
}
private:
std::string static_edp_xml_config_ = "";
};
class TypeLookupSettings
{
public:
bool use_client = false;
bool use_server = false;
};
class BuiltinAttributes
{
public:
DiscoverySettings discovery_config;
bool use_WriterLivelinessProtocol = true;
TypeLookupSettings typelookup_config;
LocatorList_t metatrafficUnicastLocatorList;
LocatorList_t metatrafficMulticastLocatorList;
fastdds::rtps::ExternalLocators metatraffic_external_unicast_locators;
LocatorList_t initialPeersList;
MemoryManagementPolicy_t readerHistoryMemoryPolicy =
MemoryManagementPolicy_t::PREALLOCATED_WITH_REALLOC_MEMORY_MODE;
uint32_t readerPayloadSize = BUILTIN_DATA_MAX_SIZE;
MemoryManagementPolicy_t writerHistoryMemoryPolicy =
MemoryManagementPolicy_t::PREALLOCATED_WITH_REALLOC_MEMORY_MODE;
uint32_t writerPayloadSize = BUILTIN_DATA_MAX_SIZE;
uint32_t mutation_tries = 100u;
bool avoid_builtin_multicast = true;
BuiltinAttributes() = default;
virtual ~BuiltinAttributes() = default;
bool operator ==(
const BuiltinAttributes& b) const
{
return (this->discovery_config == b.discovery_config) &&
(this->use_WriterLivelinessProtocol == b.use_WriterLivelinessProtocol) &&
(typelookup_config.use_client == b.typelookup_config.use_client) &&
(typelookup_config.use_server == b.typelookup_config.use_server) &&
(this->metatrafficUnicastLocatorList == b.metatrafficUnicastLocatorList) &&
(this->metatrafficMulticastLocatorList == b.metatrafficMulticastLocatorList) &&
(this->metatraffic_external_unicast_locators == b.metatraffic_external_unicast_locators) &&
(this->initialPeersList == b.initialPeersList) &&
(this->readerHistoryMemoryPolicy == b.readerHistoryMemoryPolicy) &&
(this->readerPayloadSize == b.readerPayloadSize) &&
(this->writerHistoryMemoryPolicy == b.writerHistoryMemoryPolicy) &&
(this->writerPayloadSize == b.writerPayloadSize) &&
(this->mutation_tries == b.mutation_tries) &&
(this->avoid_builtin_multicast == b.avoid_builtin_multicast);
}
};
class RTPSParticipantAttributes
{
using FlowControllerDescriptorList = std::vector<std::shared_ptr<fastdds::rtps::FlowControllerDescriptor>>;
public:
RTPSParticipantAttributes()
{
setName("RTPSParticipant");
sendSocketBufferSize = 0;
listenSocketBufferSize = 0;
participantID = -1;
useBuiltinTransports = true;
}
virtual ~RTPSParticipantAttributes()
{
}
bool operator ==(
const RTPSParticipantAttributes& b) const
{
return (this->name == b.name) &&
(this->defaultUnicastLocatorList == b.defaultUnicastLocatorList) &&
(this->defaultMulticastLocatorList == b.defaultMulticastLocatorList) &&
(this->default_external_unicast_locators == b.default_external_unicast_locators) &&
(this->ignore_non_matching_locators == b.ignore_non_matching_locators) &&
(this->sendSocketBufferSize == b.sendSocketBufferSize) &&
(this->listenSocketBufferSize == b.listenSocketBufferSize) &&
(this->builtin == b.builtin) &&
(this->port == b.port) &&
(this->userData == b.userData) &&
(this->participantID == b.participantID) &&
(this->throughputController == b.throughputController) &&
(this->useBuiltinTransports == b.useBuiltinTransports) &&
(this->properties == b.properties) &&
(this->prefix == b.prefix) &&
(this->flow_controllers == b.flow_controllers);
}
LocatorList_t defaultUnicastLocatorList;
LocatorList_t defaultMulticastLocatorList;
fastdds::rtps::ExternalLocators default_external_unicast_locators;
bool ignore_non_matching_locators = false;
uint32_t sendSocketBufferSize;
uint32_t listenSocketBufferSize;
GuidPrefix_t prefix;
RTPS_DllAPI inline bool ReadguidPrefix(
const char* pfx)
{
return bool(std::istringstream(pfx) >> prefix);
}
BuiltinAttributes builtin;
PortParameters port;
std::vector<octet> userData;
int32_t participantID;
ThroughputControllerDescriptor throughputController;
std::vector<std::shared_ptr<fastdds::rtps::TransportDescriptorInterface>> userTransports;
bool useBuiltinTransports;
RTPSParticipantAllocationAttributes allocation;
PropertyPolicy properties;
inline void setName(
const char* nam)
{
name = nam;
}
inline const char* getName() const
{
return name.c_str();
}
FlowControllerDescriptorList flow_controllers;
private:
string_255 name;
};
} /* namespace rtps */
} /* namespace fastrtps */
} /* namespace eprosima */
#endif /* _FASTDDS_RTPSPARTICIPANTPARAMETERS_H_ */