| Fast DDS Version 3.3.0 Fast DDS

Loading...
Searching...
No Matches
QosPolicies.hpp
1// Copyright 2016 Proyectos y Sistemas de Mantenimiento SL (eProsima).
2//
3// Licensed under the Apache License, Version 2.0 (the "License");
4// you may not use this file except in compliance with the License.
5// You may obtain a copy of the License at
6//
7// http://www.apache.org/licenses/LICENSE-2.0
8//
9// Unless required by applicable law or agreed to in writing, software
10// distributed under the License is distributed on an "AS IS" BASIS,
11// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12// See the License for the specific language governing permissions and
13// limitations under the License.
14
19
20#ifndef FASTDDS_DDS_CORE_POLICY__QOSPOLICIES_HPP
21#define FASTDDS_DDS_CORE_POLICY__QOSPOLICIES_HPP
22
23#include <bitset>
24#include <vector>
25
26#include <fastdds/dds/core/detail/DDSReturnCode.hpp>
27#include <fastdds/dds/core/policy/ParameterTypes.hpp>
28#include <fastdds/dds/core/Types.hpp>
29#include <fastdds/dds/xtypes/type_representation/detail/dds_xtypes_typeobject.hpp>
30#include <fastdds/rtps/attributes/ExternalLocators.hpp>
31#include <fastdds/rtps/attributes/PropertyPolicy.hpp>
32#include <fastdds/rtps/attributes/ResourceManagement.hpp>
33#include <fastdds/rtps/attributes/RTPSParticipantAllocationAttributes.hpp>
34#include <fastdds/rtps/attributes/RTPSParticipantAttributes.hpp>
35#include <fastdds/rtps/attributes/ThreadSettings.hpp>
36#include <fastdds/rtps/common/LocatorList.hpp>
37#include <fastdds/rtps/common/Time_t.hpp>
38#include <fastdds/rtps/common/Types.hpp>
39#include <fastdds/rtps/flowcontrol/FlowControllerConsts.hpp>
40#include <fastdds/rtps/transport/network/NetmaskFilterKind.hpp>
41
42#include <fastdds/utils/collections/ResourceLimitedVector.hpp>
43
44 namespace eprosima {
45 namespace fastdds {
46 namespace dds {
47
55 enum QosPolicyId_t : uint32_t
56{
57 INVALID_QOS_POLICY_ID = 0, //< Does not refer to any valid QosPolicy
58
59 // Standard QosPolicies
60 USERDATA_QOS_POLICY_ID = 1, //< UserDataQosPolicy
61 DURABILITY_QOS_POLICY_ID = 2, //< DurabilityQosPolicy
62 PRESENTATION_QOS_POLICY_ID = 3, //< PresentationQosPolicy
63 DEADLINE_QOS_POLICY_ID = 4, //< DeadlineQosPolicy
64 LATENCYBUDGET_QOS_POLICY_ID = 5, //< LatencyBudgetQosPolicy
65 OWNERSHIP_QOS_POLICY_ID = 6, //< OwnershipQosPolicy
66 OWNERSHIPSTRENGTH_QOS_POLICY_ID = 7, //< OwnershipStrengthQosPolicy
67 LIVELINESS_QOS_POLICY_ID = 8, //< LivelinessQosPolicy
68 TIMEBASEDFILTER_QOS_POLICY_ID = 9, //< TimeBasedFilterQosPolicy
69 PARTITION_QOS_POLICY_ID = 10, //< PartitionQosPolicy
70 RELIABILITY_QOS_POLICY_ID = 11, //< ReliabilityQosPolicy
71 DESTINATIONORDER_QOS_POLICY_ID = 12, //< DestinationOrderQosPolicy
72 HISTORY_QOS_POLICY_ID = 13, //< HistoryQosPolicy
73 RESOURCELIMITS_QOS_POLICY_ID = 14, //< ResourceLimitsQosPolicy
74 ENTITYFACTORY_QOS_POLICY_ID = 15, //< EntityFactoryQosPolicy
75 WRITERDATALIFECYCLE_QOS_POLICY_ID = 16, //< WriterDataLifecycleQosPolicy
76 READERDATALIFECYCLE_QOS_POLICY_ID = 17, //< ReaderDataLifecycleQosPolicy
77 TOPICDATA_QOS_POLICY_ID = 18, //< TopicDataQosPolicy
78 GROUPDATA_QOS_POLICY_ID = 19, //< GroupDataQosPolicy
79 TRANSPORTPRIORITY_QOS_POLICY_ID = 20, //< TransportPriorityQosPolicy
80 LIFESPAN_QOS_POLICY_ID = 21, //< LifespanQosPolicy
81 DURABILITYSERVICE_QOS_POLICY_ID = 22, //< DurabilityServiceQosPolicy
82
83 //XTypes extensions
84 DATAREPRESENTATION_QOS_POLICY_ID = 23, //< DataRepresentationQosPolicy
85 TYPECONSISTENCYENFORCEMENT_QOS_POLICY_ID = 24, //< TypeConsistencyEnforcementQosPolicy
86
87 //eProsima Extensions
88 DISABLEPOSITIVEACKS_QOS_POLICY_ID = 25, //< DisablePositiveACKsQosPolicy
89 PARTICIPANTRESOURCELIMITS_QOS_POLICY_ID = 26, //< ParticipantResourceLimitsQos
90 PROPERTYPOLICY_QOS_POLICY_ID = 27, //< PropertyPolicyQos
91 PUBLISHMODE_QOS_POLICY_ID = 28, //< PublishModeQosPolicy
92 READERRESOURCELIMITS_QOS_POLICY_ID = 29, //< Reader ResourceLimitsQos
93 RTPSENDPOINT_QOS_POLICY_ID = 30, //< RTPSEndpointQos
94 RTPSRELIABLEREADER_QOS_POLICY_ID = 31, //< RTPSReliableReaderQos
95 RTPSRELIABLEWRITER_QOS_POLICY_ID = 32, //< RTPSReliableWriterQos
96 TRANSPORTCONFIG_QOS_POLICY_ID = 33, //< TransportConfigQos
97 TYPECONSISTENCY_QOS_POLICY_ID = 34, //< TipeConsistencyQos
98 WIREPROTOCOLCONFIG_QOS_POLICY_ID = 35, //< WireProtocolConfigQos
99 WRITERRESOURCELIMITS_QOS_POLICY_ID = 36, //< WriterResourceLimitsQos
100
101 NEXT_QOS_POLICY_ID //< Keep always the last element. For internal use only
102};
103
104 using PolicyMask = std::bitset<NEXT_QOS_POLICY_ID>;
105
109 FASTDDS_TODO_BEFORE(4, 0, "Remove 'hasChanged' and 'send_always_' as they were replaced by 'should_be_sent'.");
110 class QosPolicy
111{
112 public:
113
115 bool hasChanged;
116
120 QosPolicy()
121 : hasChanged(false)
122 , send_always_(false)
123 {
124 }
125
131 explicit QosPolicy(
132 bool send_always)
133 : hasChanged(false)
134 , send_always_(send_always)
135 {
136 }
137
143 QosPolicy(
144 const QosPolicy& b) = default;
145
149 virtual ~QosPolicy() = default;
150
151 bool operator ==(
152 const QosPolicy& b) const
153 {
154 // hasChanged field isn't needed to be compared to being equal two QosPolicy objects.
155 return (this->send_always_ == b.send_always_);
156 }
157
158 QosPolicy& operator =(
159 const QosPolicy& b) = default;
160
166 virtual bool send_always() const
167 {
168 return send_always_;
169 }
170
174 virtual inline void clear() = 0;
175
176 protected:
177
179 bool send_always_;
180};
181
188 class EntityFactoryQosPolicy
189{
190 public:
191
197 bool autoenable_created_entities;
198
202 FASTDDS_EXPORTED_API EntityFactoryQosPolicy()
203 : autoenable_created_entities(true)
204 {
205 }
206
212 FASTDDS_EXPORTED_API EntityFactoryQosPolicy(
213 bool autoenable)
214 : autoenable_created_entities(autoenable)
215 {
216 }
217
221 virtual FASTDDS_EXPORTED_API ~EntityFactoryQosPolicy()
222 {
223 }
224
225 bool operator ==(
226 const EntityFactoryQosPolicy& b) const
227 {
228 return
229 (this->autoenable_created_entities == b.autoenable_created_entities);
230 }
231
232 inline void clear()
233 {
234 EntityFactoryQosPolicy reset = EntityFactoryQosPolicy();
235 std::swap(*this, reset);
236 }
237
238};
239
243 typedef enum DurabilityQosPolicyKind : fastdds::rtps::octet
244{
250 VOLATILE_DURABILITY_QOS,
255 TRANSIENT_LOCAL_DURABILITY_QOS,
260 TRANSIENT_DURABILITY_QOS,
266 PERSISTENT_DURABILITY_QOS
267} DurabilityQosPolicyKind_t;
268
269#define PARAMETER_KIND_LENGTH 4
270#define PARAMETER_BOOL_LENGTH 4
271
277 class DurabilityQosPolicy : public Parameter_t, public QosPolicy
278{
279 public:
280
284 FASTDDS_EXPORTED_API DurabilityQosPolicy()
285 : Parameter_t(PID_DURABILITY, PARAMETER_KIND_LENGTH)
286 , QosPolicy(true)
287 , kind(VOLATILE_DURABILITY_QOS)
288 {
289 }
290
294 virtual FASTDDS_EXPORTED_API ~DurabilityQosPolicy() = default;
295
301 inline fastdds::rtps::DurabilityKind_t durabilityKind() const
302 {
303 switch (kind)
304 {
305 default:
306 case VOLATILE_DURABILITY_QOS: return fastdds::rtps::VOLATILE;
307 case TRANSIENT_LOCAL_DURABILITY_QOS: return fastdds::rtps::TRANSIENT_LOCAL;
308 case TRANSIENT_DURABILITY_QOS: return fastdds::rtps::TRANSIENT;
309 case PERSISTENT_DURABILITY_QOS: return fastdds::rtps::PERSISTENT;
310 }
311 }
312
313 bool operator ==(
314 const DurabilityQosPolicy& b) const
315 {
316 return (this->kind == b.kind) &&
317 Parameter_t::operator ==(b) &&
318 QosPolicy::operator ==(b);
319 }
320
326 inline void durabilityKind(
327 const fastdds::rtps::DurabilityKind_t new_kind)
328 {
329 switch (new_kind)
330 {
331 default:
332 case fastdds::rtps::VOLATILE: kind = VOLATILE_DURABILITY_QOS; break;
333 case fastdds::rtps::TRANSIENT_LOCAL: kind = TRANSIENT_LOCAL_DURABILITY_QOS; break;
334 case fastdds::rtps::TRANSIENT: kind = TRANSIENT_DURABILITY_QOS; break;
335 case fastdds::rtps::PERSISTENT: kind = PERSISTENT_DURABILITY_QOS; break;
336 }
337
338 }
339
340 inline void clear() override
341 {
342 DurabilityQosPolicy reset = DurabilityQosPolicy();
343 std::swap(*this, reset);
344 }
345
346 public:
347
352 DurabilityQosPolicyKind_t kind;
353};
354
362 class DeadlineQosPolicy : public Parameter_t, public QosPolicy
363{
364 public:
365
369 FASTDDS_EXPORTED_API DeadlineQosPolicy()
370 : Parameter_t(PID_DEADLINE, PARAMETER_TIME_LENGTH)
371 , QosPolicy(true)
372 , period(TIME_T_INFINITE_SECONDS, TIME_T_INFINITE_NANOSECONDS)
373 {
374 }
375
379 virtual FASTDDS_EXPORTED_API ~DeadlineQosPolicy() = default;
380
381 bool operator ==(
382 const DeadlineQosPolicy& b) const
383 {
384 return (this->period == b.period) &&
385 Parameter_t::operator ==(b) &&
386 QosPolicy::operator ==(b);
387 }
388
389 inline void clear() override
390 {
391 DeadlineQosPolicy reset = DeadlineQosPolicy();
392 std::swap(*this, reset);
393 }
394
395 public:
396
403 fastdds::dds::Duration_t period;
404};
405
415 class LatencyBudgetQosPolicy : public Parameter_t, public QosPolicy
416{
417 public:
418
422 FASTDDS_EXPORTED_API LatencyBudgetQosPolicy()
423 : Parameter_t(PID_LATENCY_BUDGET, PARAMETER_TIME_LENGTH)
424 , QosPolicy(true)
425 , duration(0, 0)
426 {
427 }
428
432 virtual FASTDDS_EXPORTED_API ~LatencyBudgetQosPolicy() = default;
433
434 bool operator ==(
435 const LatencyBudgetQosPolicy& b) const
436 {
437 return (this->duration == b.duration) &&
438 Parameter_t::operator ==(b) &&
439 QosPolicy::operator ==(b);
440 }
441
442 inline void clear() override
443 {
444 LatencyBudgetQosPolicy reset = LatencyBudgetQosPolicy();
445 std::swap(*this, reset);
446 }
447
448 public:
449
451 fastdds::dds::Duration_t duration;
452};
453
457 typedef enum LivelinessQosPolicyKind : fastdds::rtps::octet
458{
462 AUTOMATIC_LIVELINESS_QOS,
467 MANUAL_BY_PARTICIPANT_LIVELINESS_QOS,
471 MANUAL_BY_TOPIC_LIVELINESS_QOS
472
473} LivelinessQosPolicyKind;
474
487 class LivelinessQosPolicy : public Parameter_t, public QosPolicy
488{
489 public:
490
494 FASTDDS_EXPORTED_API LivelinessQosPolicy()
495 : Parameter_t(PID_LIVELINESS, PARAMETER_KIND_LENGTH + PARAMETER_TIME_LENGTH)
496 , QosPolicy(true)
497 , kind(AUTOMATIC_LIVELINESS_QOS)
498 , lease_duration(TIME_T_INFINITE_SECONDS, TIME_T_INFINITE_NANOSECONDS)
499 , announcement_period(TIME_T_INFINITE_SECONDS, TIME_T_INFINITE_NANOSECONDS)
500 {
501 }
502
506 virtual FASTDDS_EXPORTED_API ~LivelinessQosPolicy() = default;
507
508 bool operator ==(
509 const LivelinessQosPolicy& b) const
510 {
511 return (this->kind == b.kind) &&
512 (this->lease_duration == b.lease_duration) &&
513 (this->announcement_period == b.announcement_period) &&
514 Parameter_t::operator ==(b) &&
515 QosPolicy::operator ==(b);
516 }
517
518 inline void clear() override
519 {
520 LivelinessQosPolicy reset = LivelinessQosPolicy();
521 std::swap(*this, reset);
522 }
523
524 public:
525
527 LivelinessQosPolicyKind kind;
534 fastdds::dds::Duration_t lease_duration;
541 fastdds::dds::Duration_t announcement_period;
542};
543
547 typedef enum ReliabilityQosPolicyKind : fastdds::rtps::octet
548{
553 BEST_EFFORT_RELIABILITY_QOS = 0x01,
561 RELIABLE_RELIABILITY_QOS = 0x02
562} ReliabilityQosPolicyKind;
563
569 class ReliabilityQosPolicy : public Parameter_t, public QosPolicy
570{
571 public:
572
576 FASTDDS_EXPORTED_API ReliabilityQosPolicy()
577 : Parameter_t(PID_RELIABILITY, PARAMETER_KIND_LENGTH + PARAMETER_TIME_LENGTH)
578 , QosPolicy(true) //indicate send always
579 , kind(BEST_EFFORT_RELIABILITY_QOS)
580 , max_blocking_time{0, 100000000} // max_blocking_time = 100ms
581 {
582 }
583
587 virtual FASTDDS_EXPORTED_API ~ReliabilityQosPolicy() = default;
588
589 bool operator ==(
590 const ReliabilityQosPolicy& b) const
591 {
592 return (this->kind == b.kind) &&
593 (this->max_blocking_time == b.max_blocking_time) &&
594 Parameter_t::operator ==(b) &&
595 QosPolicy::operator ==(b);
596 }
597
598 inline void clear() override
599 {
600 ReliabilityQosPolicy reset = ReliabilityQosPolicy();
601 std::swap(*this, reset);
602 }
603
604 public:
605
610 ReliabilityQosPolicyKind kind;
611
622 fastdds::dds::Duration_t max_blocking_time;
623};
624
625
626
630 enum OwnershipQosPolicyKind : fastdds::rtps::octet
631{
636 SHARED_OWNERSHIP_QOS,
642 EXCLUSIVE_OWNERSHIP_QOS
643};
644
651 class OwnershipQosPolicy : public Parameter_t, public QosPolicy
652{
653 public:
654
658 FASTDDS_EXPORTED_API OwnershipQosPolicy()
659 : Parameter_t(PID_OWNERSHIP, PARAMETER_KIND_LENGTH)
660 , QosPolicy(true)
661 , kind(SHARED_OWNERSHIP_QOS)
662 {
663 }
664
668 virtual FASTDDS_EXPORTED_API ~OwnershipQosPolicy() = default;
669
670 bool operator ==(
671 const OwnershipQosPolicy& b) const
672 {
673 return (this->kind == b.kind) &&
674 Parameter_t::operator ==(b) &&
675 QosPolicy::operator ==(b);
676 }
677
678 inline void clear() override
679 {
680 OwnershipQosPolicy reset = OwnershipQosPolicy();
681 std::swap(*this, reset);
682 }
683
684 public:
685
687 OwnershipQosPolicyKind kind;
688};
689
693 enum DestinationOrderQosPolicyKind : fastdds::rtps::octet
694{
700 BY_RECEPTION_TIMESTAMP_DESTINATIONORDER_QOS,
705 BY_SOURCE_TIMESTAMP_DESTINATIONORDER_QOS
706};
707
708
709
718 class DestinationOrderQosPolicy : public Parameter_t, public QosPolicy
719{
720 public:
721
725 FASTDDS_EXPORTED_API DestinationOrderQosPolicy()
726 : Parameter_t(PID_DESTINATION_ORDER, PARAMETER_KIND_LENGTH)
727 , QosPolicy(true)
728 , kind(BY_RECEPTION_TIMESTAMP_DESTINATIONORDER_QOS)
729 {
730 }
731
735 virtual FASTDDS_EXPORTED_API ~DestinationOrderQosPolicy() = default;
736
737 bool operator ==(
738 const DestinationOrderQosPolicy& b) const
739 {
740 return (this->kind == b.kind) &&
741 Parameter_t::operator ==(b) &&
742 QosPolicy::operator ==(b);
743 }
744
745 inline void clear() override
746 {
747 DestinationOrderQosPolicy reset = DestinationOrderQosPolicy();
748 std::swap(*this, reset);
749 }
750
751 public:
752
754 DestinationOrderQosPolicyKind kind;
755};
756
757
761 class GenericDataQosPolicy : public Parameter_t, public QosPolicy,
762 public fastdds::ResourceLimitedVector<fastdds::rtps::octet>
763{
764 using ResourceLimitedOctetVector = fastdds::ResourceLimitedVector<fastdds::rtps::octet>;
765
766 public:
767
768 FASTDDS_EXPORTED_API GenericDataQosPolicy(
769 ParameterId_t pid)
770 : Parameter_t(pid, 0)
771 , QosPolicy(false)
772 , ResourceLimitedOctetVector()
773 {
774 }
775
776 FASTDDS_EXPORTED_API GenericDataQosPolicy(
777 ParameterId_t pid,
778 uint16_t in_length)
779 : Parameter_t(pid, in_length)
780 , QosPolicy(false)
781 , ResourceLimitedOctetVector()
782 {
783 }
784
793 FASTDDS_EXPORTED_API GenericDataQosPolicy(
794 const GenericDataQosPolicy& data)
795 : Parameter_t(data.Pid, data.length)
796 , QosPolicy(false)
797 , ResourceLimitedOctetVector(data)
798 {
799 }
800
810 FASTDDS_EXPORTED_API GenericDataQosPolicy(
811 ParameterId_t pid,
812 const collection_type& data)
813 : Parameter_t(pid, 0)
814 , QosPolicy(false)
815 , ResourceLimitedOctetVector()
816 {
817 assign(data.begin(), data.end());
818 length = static_cast<uint16_t>((size() + 7u) & ~3u);
819 }
820
821 virtual FASTDDS_EXPORTED_API ~GenericDataQosPolicy() = default;
822
834 GenericDataQosPolicy& operator =(
835 const collection_type& b)
836 {
837 if (collection_ != b)
838 {
839 //If the object is size limited, already has max_size() allocated
840 //assign() will always stop copying when reaching max_size()
841 assign(b.begin(), b.end());
842 length = static_cast<uint16_t>((size() + 7u) & ~3u);
843 hasChanged = true;
844 }
845 return *this;
846 }
847
857 GenericDataQosPolicy& operator =(
858 const GenericDataQosPolicy& b)
859 {
860 QosPolicy::operator =(b);
861 Parameter_t::operator =(b);
862 configuration_ = b.configuration_;
863 collection_.reserve(b.collection_.capacity());
864 collection_.assign(b.collection_.begin(), b.collection_.end());
865 return *this;
866 }
867
868 bool operator ==(
869 const GenericDataQosPolicy& b) const
870 {
871 return collection_ == b.collection_ &&
872 Parameter_t::operator ==(b) &&
873 QosPolicy::operator ==(b);
874 }
875
876 bool operator ==(
877 const collection_type& b) const
878 {
879 return collection_ == b;
880 }
881
887 void set_max_size (
888 size_t size)
889 {
890 if (size > 0)
891 {
892 configuration_ = fastdds::ResourceLimitedContainerConfig::fixed_size_configuration(size);
893 collection_.reserve(configuration_.maximum);
894 }
895 else
896 {
897 configuration_ = fastdds::ResourceLimitedContainerConfig::dynamic_allocation_configuration();
898 }
899 }
900
901 void resize(
902 size_t new_size)
903 {
904 collection_.resize(new_size);
905 }
906
910 inline const collection_type& dataVec() const
911 {
912 return collection_;
913 }
914
915 inline void clear() override
916 {
917 ResourceLimitedOctetVector::clear();
918 hasChanged = false;
919 }
920
926 FASTDDS_EXPORTED_API inline const collection_type& data_vec() const
927 {
928 return collection_;
929 }
930
936 FASTDDS_EXPORTED_API inline collection_type& data_vec()
937 {
938 return collection_;
939 }
940
946 FASTDDS_EXPORTED_API inline void data_vec(
947 const collection_type& vec)
948 {
949 if (collection_ != vec)
950 {
951 assign(vec.begin(), vec.end());
952 length = static_cast<uint16_t>((size() + 7u) & ~3u);
953 hasChanged = true;
954 }
955 }
956
962 FASTDDS_EXPORTED_API inline const collection_type& getValue() const
963 {
964 return collection_;
965 }
966
972 FASTDDS_EXPORTED_API inline void setValue(
973 const collection_type& vec)
974 {
975 data_vec(vec);
976 }
977
978};
979
987// *INDENT-OFF* (uncrustify seems to have problems with this macro)
988#define TEMPLATE_DATA_QOS_POLICY(TClassName, TPid) \
989 class TClassName : public GenericDataQosPolicy \
990 { \
991 public: \
992 \
993 FASTDDS_EXPORTED_API TClassName() \
994 : GenericDataQosPolicy(TPid) \
995 { \
996 } \
997 \
998 FASTDDS_EXPORTED_API TClassName( \
999 uint16_t in_length) \
1000 : GenericDataQosPolicy(TPid, in_length) \
1001 { \
1002 } \
1003 \
1004 \
1012 FASTDDS_EXPORTED_API TClassName( \
1013 const TClassName &data) = default; \
1014 \
1015 \
1023 FASTDDS_EXPORTED_API TClassName( \
1024 const collection_type &data) \
1025 : GenericDataQosPolicy(TPid, data) \
1026 { \
1027 } \
1028 \
1029 virtual FASTDDS_EXPORTED_API ~TClassName() = default; \
1030 \
1031 \
1040 TClassName& operator =( \
1041 const TClassName& b) = default; \
1042 };
1043// *INDENT-ON*
1044
1045//Variable used to generate the doxygen documentation for this QoS Policies
1046#ifdef DOXYGEN_DOCUMENTATION
1057 class UserDataQosPolicy : public GenericDataQosPolicy
1058{
1059};
1070 class TopicDataQosPolicy : public GenericDataQosPolicy
1071{
1072};
1081 * implement matching policies similar to those of the PARTITION QoS except the decision can be made based on an
1082 * application-defined policy.
1083 */
1084 class GroupDataQosPolicy : public GenericDataQosPolicy
1085{
1086};
1087#endif // DOXYGEN_DOCUMENTATION
1088
1089TEMPLATE_DATA_QOS_POLICY(UserDataQosPolicy, PID_USER_DATA)
1090TEMPLATE_DATA_QOS_POLICY(TopicDataQosPolicy, PID_TOPIC_DATA)
1091TEMPLATE_DATA_QOS_POLICY(GroupDataQosPolicy, PID_GROUP_DATA)
1092
1093
1094
1100 *
1101 * @note Mutable Qos Policy
1102 */
1103class TimeBasedFilterQosPolicy : public Parameter_t, public QosPolicy
1104{
1105 public:
1106
1107
1108 * @brief Constructor
1109 */
1110 FASTDDS_EXPORTED_API TimeBasedFilterQosPolicy()
1111 : Parameter_t(PID_TIME_BASED_FILTER, PARAMETER_TIME_LENGTH)
1112 , QosPolicy(false)
1113 , minimum_separation(0, 0)
1114 {
1115 }
1116
1119
1120 virtual FASTDDS_EXPORTED_API ~TimeBasedFilterQosPolicy() = default;
1121
1122 bool operator ==(
1123 const TimeBasedFilterQosPolicy& b) const
1124 {
1125 return (this->minimum_separation == b.minimum_separation) &&
1126 Parameter_t::operator ==(b) &&
1127 QosPolicy::operator ==(b);
1128 }
1129
1130 inline void clear() override
1131 {
1132 TimeBasedFilterQosPolicy reset = TimeBasedFilterQosPolicy();
1133 std::swap(*this, reset);
1134 }
1135
1136 public:
1137
1139 fastdds::dds::Duration_t minimum_separation;
1140};
1141
1145 enum PresentationQosPolicyAccessScopeKind : fastdds::rtps::octet
1146{
1152 INSTANCE_PRESENTATION_QOS,
1155 * DataWriter (or DataReader).
1156 */
1157 TOPIC_PRESENTATION_QOS,
1161 GROUP_PRESENTATION_QOS
1162};
1163
1164#define PARAMETER_PRESENTATION_LENGTH 8
1165
1170
1176 */
1177 class PresentationQosPolicy : public Parameter_t, public QosPolicy
1178{
1179 public:
1180
1184 FASTDDS_EXPORTED_API PresentationQosPolicy()
1185 : Parameter_t(PID_PRESENTATION, PARAMETER_PRESENTATION_LENGTH)
1186 , QosPolicy(false)
1187 , access_scope(INSTANCE_PRESENTATION_QOS)
1188 , coherent_access(false)
1189 , ordered_access(false)
1190 {
1191 }
1192
1196 virtual FASTDDS_EXPORTED_API ~PresentationQosPolicy() = default;
1197
1198 bool operator ==(
1199 const PresentationQosPolicy& b) const
1200 {
1201 return (this->access_scope == b.access_scope) &&
1202 (this->coherent_access == b.coherent_access) &&
1203 (this->ordered_access == b.ordered_access) &&
1204 Parameter_t::operator ==(b) &&
1205 QosPolicy::operator ==(b);
1206 }
1207
1208 inline void clear() override
1209 {
1210 PresentationQosPolicy reset = PresentationQosPolicy();
1211 std::swap(*this, reset);
1212 }
1213
1214 public:
1215
1217 PresentationQosPolicyAccessScopeKind access_scope;
1223 bool coherent_access;
1229 bool ordered_access;
1230};
1231
1232
1233 class Partition_t
1234{
1235
1236 friend class PartitionQosPolicy;
1237
1238 private:
1239
1240 const char* partition_;
1241
1242 private:
1243
1244 Partition_t()
1245 {
1246 partition_ = nullptr;
1247 }
1248
1249 public:
1250
1252
1256 explicit Partition_t(
1257 const void* ptr)
1258 {
1259 partition_ = (char*)ptr;
1260 }
1261
1262 bool operator ==(
1263 const Partition_t& rhs) const
1264 {
1265 return (size() == rhs.size() &&
1266 (size() == 0 || strcmp(partition_ + 4, rhs.partition_ + 4)));
1267 }
1268
1269 bool operator !=(
1270 const Partition_t& rhs) const
1271 {
1272 return !(*this == rhs);
1273 }
1274
1280 uint32_t size() const
1281 {
1282 return *(uint32_t*)partition_;
1283 }
1284
1285 /**
1286 * @brief Getter for the partition name
1287 *
1288 * @return name
1289 */
1290 const char* name() const
1291 {
1292 return partition_ + 4;
1293 }
1294
1295};
1296
1305 * @note Mutable Qos Policy
1306 */
1307 class PartitionQosPolicy : public Parameter_t, public QosPolicy
1308{
1309 public:
1310
1311 class const_iterator
1312 {
1313 public:
1314
1315 typedef const_iterator self_type;
1316 typedef const Partition_t value_type;
1317 typedef const Partition_t reference;
1318 typedef const Partition_t* pointer;
1319 typedef size_t difference_type;
1320 typedef std::forward_iterator_tag iterator_category;
1321
1325
1326 */
1327 const_iterator(
1328 const fastdds::rtps::octet* ptr)
1329 : ptr_(ptr)
1330 , value_ (ptr_)
1331 {
1332 }
1333
1334 self_type operator ++()
1335 {
1336 self_type tmp = *this;
1337 advance();
1338 return tmp;
1339 }
1340
1341 self_type operator ++(
1342 int)
1343 {
1344 advance();
1345 return *this;
1346 }
1347
1348 reference operator *()
1349 {
1350 return value_;
1351 }
1352
1353 pointer operator ->()
1354 {
1355 return &value_;
1356 }
1357
1358 bool operator ==(
1359 const self_type& rhs) const
1360 {
1361 return ptr_ == rhs.ptr_;
1362 }
1363
1364 bool operator !=(
1365 const self_type& rhs) const
1366 {
1367 return ptr_ != rhs.ptr_;
1368 }
1369
1370 protected:
1371
1375 void advance()
1376 {
1377 //Size of the element (with alignment)
1378 uint32_t size = *(uint32_t*)ptr_;
1379 ptr_ += (4u + ((size + 3u) & ~3u));
1380 value_ = Partition_t(ptr_);
1381 }
1382
1383 private:
1384
1386 const fastdds::rtps::octet* ptr_;
1388 Partition_t value_;
1389
1390 };
1391
1392 public:
1393
1397 FASTDDS_EXPORTED_API PartitionQosPolicy()
1398 : Parameter_t(PID_PARTITION, 0)
1399 , QosPolicy(false)
1400 , max_size_ (0)
1401 , Npartitions_ (0)
1402 {
1403 }
1404
1410 FASTDDS_EXPORTED_API PartitionQosPolicy(
1411 uint16_t in_length)
1412 : Parameter_t(PID_PARTITION, in_length)
1413 , QosPolicy(false)
1414 , max_size_ (in_length)
1415 , partitions_(in_length)
1416 , Npartitions_ (0)
1417 {
1418 }
1419
1421 * @brief Copy constructor
1422 *
1423 * @param b Another PartitionQosPolicy instance
1424 */
1425 FASTDDS_EXPORTED_API PartitionQosPolicy(
1426 const PartitionQosPolicy& b)
1427 : Parameter_t(b)
1428 , QosPolicy(b)
1429 , max_size_ (b.max_size_)
1430 , partitions_(b.max_size_ != 0 ?
1431 b.partitions_.max_size :
1432 b.partitions_.length)
1433 , Npartitions_ (b.Npartitions_)
1434 {
1435 partitions_.copy(&b.partitions_, b.max_size_ != 0);
1436 }
1437
1441 virtual FASTDDS_EXPORTED_API ~PartitionQosPolicy() = default;
1442
1443 bool operator ==(
1444 const PartitionQosPolicy& b) const
1445 {
1446 return (this->max_size_ == b.max_size_) &&
1447 (this->Npartitions_ == b.Npartitions_) &&
1448 (this->partitions_ == b.partitions_) &&
1449 Parameter_t::operator ==(b) &&
1450 QosPolicy::operator ==(b);
1451 }
1452
1453 PartitionQosPolicy& operator =(
1454 const PartitionQosPolicy& b)
1455 {
1456 QosPolicy::operator =(b);
1457 Parameter_t::operator =(b);
1458 max_size_ = b.max_size_;
1459 partitions_.reserve(max_size_ != 0 ?
1460 b.partitions_.max_size :
1461 b.partitions_.length);
1462 partitions_.copy(&b.partitions_, b.max_size_ != 0);
1463 Npartitions_ = b.Npartitions_;
1464
1465 return *this;
1466 }
1467
1471 * @return const_iterator
1472 */
1473 const_iterator begin() const
1474 {
1475 return const_iterator(partitions_.data);
1476 }
1477
1481 * @return const_iterator
1482 */
1483 const_iterator end() const
1484 {
1485 return const_iterator(partitions_.data + partitions_.length);
1486 }
1487
1491 * @return uint32_t with the size
1492 */
1493 uint32_t size() const
1494 {
1495 return Npartitions_;
1496 }
1497
1503 uint32_t empty() const
1504 {
1505 return Npartitions_ == 0;
1506 }
1507
1513 void set_max_size (
1514 uint32_t size)
1515 {
1516 partitions_.reserve(size);
1517 max_size_ = size;
1518 }
1519
1525 uint32_t max_size () const
1526 {
1527 return max_size_;
1528 }
1529
1535 FASTDDS_EXPORTED_API inline void push_back(
1536 const char* name)
1537 {
1538 //Realloc if needed;
1539 uint32_t size = (uint32_t)strlen(name) + 1;
1540 uint32_t alignment = ((size + 3u) & ~3u) - size;
1541
1542 if (max_size_ != 0 && (partitions_.max_size < partitions_.length +
1543 size + alignment + 4))
1544 {
1545 return;
1546 }
1547
1548 partitions_.reserve(partitions_.length + size + alignment + 4);
1549
1550 fastdds::rtps::octet* o = (fastdds::rtps::octet*)&size;
1551 memcpy(partitions_.data + partitions_.length, o, 4);
1552 partitions_.length += 4;
1553
1554 memcpy(partitions_.data + partitions_.length, name, size);
1555 partitions_.length += size;
1556
1557 memset(partitions_.data + partitions_.length, 0, alignment);
1558 partitions_.length += alignment;
1559
1560 ++Npartitions_;
1561 hasChanged = true;
1562 }
1563
1567 FASTDDS_EXPORTED_API inline void clear() override
1568 {
1569 partitions_.length = 0;
1570 Npartitions_ = 0;
1571 hasChanged = false;
1572 }
1573
1578 */
1579 FASTDDS_EXPORTED_API inline const std::vector<std::string> getNames() const
1580 {
1581 return names();
1582 }
1583
1589 FASTDDS_EXPORTED_API inline void setNames(
1590 std::vector<std::string>& nam)
1591 {
1592 names(nam);
1593 }
1594
1596 * Returns partition names.
1597 *
1598 * @return Vector of partition name strings.
1599 */
1600 FASTDDS_EXPORTED_API inline const std::vector<std::string> names() const
1601 {
1602 std::vector<std::string> names;
1603 if (Npartitions_ > 0)
1604 {
1605 for (auto it = begin(); it != end(); ++it)
1606 {
1607 names.push_back(it->name());
1608 }
1609 }
1610 return names;
1611 }
1612
1616
1618 FASTDDS_EXPORTED_API inline void names(
1619 std::vector<std::string>& nam)
1620 {
1621 clear();
1622 for (auto it = nam.begin(); it != nam.end(); ++it)
1623 {
1624 push_back(it->c_str());
1625 }
1626 hasChanged = true;
1627 }
1628
1629 private:
1630
1632 uint32_t max_size_;
1634 fastdds::rtps::SerializedPayload_t partitions_;
1636 uint32_t Npartitions_;
1637};
1638
1642 enum HistoryQosPolicyKind : fastdds::rtps::octet
1643{
1650 KEEP_LAST_HISTORY_QOS,
1657 */
1658 KEEP_ALL_HISTORY_QOS
1659};
1660
1664
1670 * @note Immutable Qos Policy
1671 */
1672 class HistoryQosPolicy : public Parameter_t, public QosPolicy
1673{
1674 public:
1675
1678
1679 FASTDDS_EXPORTED_API HistoryQosPolicy()
1680 : Parameter_t(PID_HISTORY, PARAMETER_KIND_LENGTH + 4)
1681 , QosPolicy(true)
1682 , kind(KEEP_LAST_HISTORY_QOS)
1683 , depth(1)
1684 {
1685 }
1686
1690 virtual FASTDDS_EXPORTED_API ~HistoryQosPolicy() = default;
1691
1692 bool operator ==(
1693 const HistoryQosPolicy& b) const
1694 {
1695 return (this->kind == b.kind) &&
1696 (this->depth == b.depth) &&
1697 Parameter_t::operator ==(b) &&
1698 QosPolicy::operator ==(b);
1699 }
1700
1701 inline void clear() override
1702 {
1703 HistoryQosPolicy reset = HistoryQosPolicy();
1704 std::swap(*this, reset);
1705 }
1706
1707 public:
1708
1710 HistoryQosPolicyKind kind;
1716 int32_t depth;
1717};
1718
1724 class ResourceLimitsQosPolicy : public Parameter_t, public QosPolicy
1725{
1726 public:
1727
1736 int32_t max_samples;
1743 int32_t max_instances;
1750 int32_t max_samples_per_instance;
1753
1755 int32_t allocated_samples;
1759 */
1760 int32_t extra_samples;
1761
1765 FASTDDS_EXPORTED_API ResourceLimitsQosPolicy()
1766 : Parameter_t(PID_RESOURCE_LIMITS, 4 * 5)
1767 , QosPolicy(false)
1768 , max_samples(5000)
1769 , max_instances(10)
1770 , max_samples_per_instance(400)
1771 , allocated_samples(100)
1772 , extra_samples(1)
1773 {
1774 }
1775
1777
1779 virtual FASTDDS_EXPORTED_API ~ResourceLimitsQosPolicy() = default;
1780
1781 bool operator ==(
1782 const ResourceLimitsQosPolicy& b) const
1783 {
1784 return (this->max_samples == b.max_samples) &&
1785 (this->max_instances == b.max_instances) &&
1786 (this->max_samples_per_instance == b.max_samples_per_instance) &&
1787 (this->allocated_samples == b.allocated_samples) &&
1788 Parameter_t::operator ==(b) &&
1789 QosPolicy::operator ==(b);
1790 }
1791
1792 inline void clear() override
1793 {
1794 ResourceLimitsQosPolicy reset = ResourceLimitsQosPolicy();
1795 std::swap(*this, reset);
1796 }
1797
1798};
1799
1800
1801
1805
1810 class DurabilityServiceQosPolicy : public Parameter_t, public QosPolicy
1811{
1812 public:
1813
1817 FASTDDS_EXPORTED_API DurabilityServiceQosPolicy()
1818 : Parameter_t(PID_DURABILITY_SERVICE, PARAMETER_TIME_LENGTH + PARAMETER_KIND_LENGTH + 4 + 4 + 4 + 4)
1819 , QosPolicy(false)
1820 , history_kind(KEEP_LAST_HISTORY_QOS)
1821 , history_depth(1)
1822 , max_samples(LENGTH_UNLIMITED)
1823 , max_instances(LENGTH_UNLIMITED)
1824 , max_samples_per_instance(LENGTH_UNLIMITED)
1825 {
1826 }
1827
1828
1831 virtual FASTDDS_EXPORTED_API ~DurabilityServiceQosPolicy() = default;
1832
1833 bool operator ==(
1834 const DurabilityServiceQosPolicy& b) const
1835 {
1836 return (this->history_kind == b.history_kind) &&
1837 (this->history_depth == b.history_depth) &&
1838 (this->max_samples == b.max_samples) &&
1839 (this->max_instances == b.max_instances) &&
1840 (this->max_samples_per_instance == b.max_samples_per_instance) &&
1841 Parameter_t::operator ==(b) &&
1842 QosPolicy::operator ==(b);
1843 }
1844
1845 inline void clear() override
1846 {
1847 DurabilityServiceQosPolicy reset = DurabilityServiceQosPolicy();
1848 std::swap(*this, reset);
1849 }
1850
1851 public:
1852
1857 fastdds::dds::Duration_t service_cleanup_delay;
1863 HistoryQosPolicyKind history_kind;
1869 int32_t history_depth;
1870
1876 */
1877 int32_t max_samples;
1883 int32_t max_instances;
1889
1890 int32_t max_samples_per_instance;
1891};
1892
1895 *
1896 * @note Mutable Qos Policy
1897 */
1898 class LifespanQosPolicy : public Parameter_t, public QosPolicy
1899{
1900 public:
1901
1902
1903 * @brief Constructor
1904 */
1905 FASTDDS_EXPORTED_API LifespanQosPolicy()
1906 : Parameter_t(PID_LIFESPAN, PARAMETER_TIME_LENGTH)
1907 , QosPolicy(true)
1908 , duration(TIME_T_INFINITE_SECONDS, TIME_T_INFINITE_NANOSECONDS)
1909 {
1910 }
1911
1914
1915 virtual FASTDDS_EXPORTED_API ~LifespanQosPolicy() = default;
1916
1917 bool operator ==(
1918 const LifespanQosPolicy& b) const
1919 {
1920 return (this->duration == b.duration) &&
1921 Parameter_t::operator ==(b) &&
1922 QosPolicy::operator ==(b);
1923 }
1924
1925 inline void clear() override
1926 {
1927 LifespanQosPolicy reset = LifespanQosPolicy();
1928 std::swap(*this, reset);
1929 }
1930
1931 public:
1932
1934 fastdds::dds::Duration_t duration;
1935};
1936
1941 *
1942 * @note Mutable Qos Policy
1943 */
1944 class OwnershipStrengthQosPolicy : public Parameter_t, public QosPolicy
1945{
1946 public:
1947
1948
1949 * @brief Constructor
1950 */
1951 FASTDDS_EXPORTED_API OwnershipStrengthQosPolicy()
1952 : Parameter_t(PID_OWNERSHIP_STRENGTH, 4)
1953 , QosPolicy(false)
1954 , value(0)
1955 {
1956 }
1957
1960
1961 virtual FASTDDS_EXPORTED_API ~OwnershipStrengthQosPolicy() = default;
1962
1963 bool operator ==(
1964 const OwnershipStrengthQosPolicy& b) const
1965 {
1966 return (this->value == b.value) &&
1967 Parameter_t::operator ==(b) &&
1968 QosPolicy::operator ==(b);
1969 }
1970
1971 inline void clear() override
1972 {
1973 OwnershipStrengthQosPolicy reset = OwnershipStrengthQosPolicy();
1974 std::swap(*this, reset);
1975 }
1976
1977 public:
1978
1979 //! Strength <br> By default, 0.
1980 uint32_t value;
1981};
1982
1983
1985
1991 class TransportPriorityQosPolicy : public Parameter_t, public QosPolicy
1992{
1993 public:
1994
1996 uint32_t value;
1997
1998
1999 * @brief Constructor
2000 */
2001 FASTDDS_EXPORTED_API TransportPriorityQosPolicy()
2002 : Parameter_t(PID_TRANSPORT_PRIORITY, 4)
2003 , QosPolicy(false)
2004 , value(0)
2005 {
2006 }
2007
2010 */
2011 virtual FASTDDS_EXPORTED_API ~TransportPriorityQosPolicy() = default;
2012
2013 bool operator ==(
2014 const TransportPriorityQosPolicy& b) const
2015 {
2016 return (this->value == b.value) &&
2017 Parameter_t::operator ==(b) &&
2018 QosPolicy::operator ==(b);
2019 }
2020
2021 inline void clear() override
2022 {
2023 TransportPriorityQosPolicy reset = TransportPriorityQosPolicy();
2024 std::swap(*this, reset);
2025 }
2026
2027};
2028
2032 typedef enum PublishModeQosPolicyKind : fastdds::rtps::octet
2033{
2034 SYNCHRONOUS_PUBLISH_MODE,
2035 ASYNCHRONOUS_PUBLISH_MODE
2036} PublishModeQosPolicyKind_t;
2037
2038/**
2039 * Class PublishModeQosPolicy, defines the publication mode for a specific writer.
2040 */
2041 class PublishModeQosPolicy : public QosPolicy
2042{
2043 public:
2044
2045
2046 PublishModeQosPolicyKind kind = SYNCHRONOUS_PUBLISH_MODE;
2047
2051 */
2052 std::string flow_controller_name = fastdds::rtps::FASTDDS_FLOW_CONTROLLER_DEFAULT;
2053
2054 inline void clear() override
2055 {
2056 PublishModeQosPolicy reset = PublishModeQosPolicy();
2057 std::swap(*this, reset);
2058 }
2059
2060 bool operator ==(
2061 const PublishModeQosPolicy& b) const
2062 {
2063 return (this->kind == b.kind) &&
2064 flow_controller_name == b.flow_controller_name.c_str() &&
2065 QosPolicy::operator ==(b);
2066 }
2067
2068};
2069
2071 * Enum DataRepresentationId, different kinds of topic data representation
2072 */
2073 typedef enum DataRepresentationId : int16_t
2074{
2075 XCDR_DATA_REPRESENTATION = 0,
2076 XML_DATA_REPRESENTATION = 1,
2077 XCDR2_DATA_REPRESENTATION = 2
2078} DataRepresentationId_t;
2079
2081 constexpr DataRepresentationId_t DEFAULT_DATA_REPRESENTATION {DataRepresentationId_t::XCDR_DATA_REPRESENTATION};
2082
2086
2093 class DataRepresentationQosPolicy : public Parameter_t, public QosPolicy
2094{
2095 public:
2096
2098 std::vector<DataRepresentationId_t> m_value;
2099
2103 FASTDDS_EXPORTED_API DataRepresentationQosPolicy()
2104 : Parameter_t(PID_DATA_REPRESENTATION, 0)
2105 , QosPolicy(false)
2106 {
2107 }
2108
2111
2112 virtual FASTDDS_EXPORTED_API ~DataRepresentationQosPolicy() override = default;
2113
2114 /**
2115 * Compares the given policy to check if it's equal.
2116 *
2117 * @param b QoS Policy.
2118 * @return True if the policy is equal.
2119 */
2120 bool operator ==(
2121 const DataRepresentationQosPolicy& b) const
2122 {
2123 return (this->m_value == b.m_value) &&
2124 Parameter_t::operator ==(b) &&
2125 QosPolicy::operator ==(b);
2126 }
2127
2128 inline void clear() override
2129 {
2130 DataRepresentationQosPolicy reset = DataRepresentationQosPolicy();
2131 std::swap(*this, reset);
2132 }
2133
2134};
2135
2136 enum TypeConsistencyKind : uint16_t
2137{
2141 DISALLOW_TYPE_COERCION,
2146 ALLOW_TYPE_COERCION
2147};
2148
2155 class TypeConsistencyEnforcementQosPolicy : public Parameter_t, public QosPolicy
2156{
2157 public:
2158
2160 TypeConsistencyKind m_kind;
2169 bool m_ignore_sequence_bounds;
2178 bool m_ignore_string_bounds;
2180 * @brief This option controls whether member names are taken into consideration for type assignability. If the option
2181 * is set to TRUE, member names are considered as part of assignability in addition to member IDs (so that members with
2182 * the same ID also have the same name). If the option is set to FALSE, then member names are not ignored. <br>
2183 * By default, false.
2184 */
2185 bool m_ignore_member_names;
2191 bool m_prevent_type_widening;
2197 bool m_force_type_validation;
2198
2202 FASTDDS_EXPORTED_API TypeConsistencyEnforcementQosPolicy()
2203 : Parameter_t(PID_TYPE_CONSISTENCY_ENFORCEMENT, 8) // 2 + 5 + 1 alignment byte
2204 , QosPolicy(true)
2205 {
2206 m_kind = ALLOW_TYPE_COERCION;
2207 m_ignore_sequence_bounds = true;
2208 m_ignore_string_bounds = true;
2209 m_ignore_member_names = false;
2210 m_prevent_type_widening = false;
2211 m_force_type_validation = false;
2212 }
2213
2215
2217 virtual FASTDDS_EXPORTED_API ~TypeConsistencyEnforcementQosPolicy() override = default;
2218
2219 bool operator ==(
2220 const TypeConsistencyEnforcementQosPolicy& b) const
2221 {
2222 return m_kind == b.m_kind &&
2223 m_ignore_sequence_bounds == b.m_ignore_sequence_bounds &&
2224 m_ignore_string_bounds == b.m_ignore_string_bounds &&
2225 m_ignore_member_names == b.m_ignore_member_names &&
2226 m_prevent_type_widening == b.m_prevent_type_widening &&
2227 m_force_type_validation == b.m_force_type_validation &&
2228 Parameter_t::operator ==(b) &&
2229 QosPolicy::operator ==(b);
2230 }
2231
2232 inline void clear() override
2233 {
2234 TypeConsistencyEnforcementQosPolicy reset = TypeConsistencyEnforcementQosPolicy();
2235 std::swap(*this, reset);
2236 }
2237
2238};
2239
2243 * @note Immutable Qos Policy
2244 */
2245 class DisablePositiveACKsQosPolicy : public Parameter_t, public QosPolicy
2246{
2247 public:
2248
2251
2252 FASTDDS_EXPORTED_API DisablePositiveACKsQosPolicy()
2253 : Parameter_t(PID_DISABLE_POSITIVE_ACKS, PARAMETER_BOOL_LENGTH)
2254 , QosPolicy(true)
2255 , enabled(false)
2256 , duration(TIME_T_INFINITE_SECONDS, TIME_T_INFINITE_NANOSECONDS)
2257 {
2258 }
2259
2263 virtual FASTDDS_EXPORTED_API ~DisablePositiveACKsQosPolicy() = default;
2264
2265 bool operator ==(
2266 const DisablePositiveACKsQosPolicy& b) const
2267 {
2268 return enabled == b.enabled &&
2269 duration == b.duration &&
2270 Parameter_t::operator ==(b) &&
2271 QosPolicy::operator ==(b);
2272 }
2273
2274 inline void clear() override
2275 {
2276 DisablePositiveACKsQosPolicy reset = DisablePositiveACKsQosPolicy();
2277 std::swap(*this, reset);
2278 }
2279
2280 public:
2281
2283 bool enabled;
2285 fastdds::dds::Duration_t duration;
2286};
2287
2291 class TypeIdV1 : public Parameter_t, public QosPolicy
2292{
2293 public:
2294
2296 xtypes::TypeIdentifier m_type_identifier;
2297
2298
2299
2302 FASTDDS_EXPORTED_API TypeIdV1()
2303 : Parameter_t(PID_TYPE_IDV1, 0)
2304 , QosPolicy(false)
2305 , m_type_identifier()
2306 {
2307 }
2308
2312
2314 FASTDDS_EXPORTED_API TypeIdV1(
2315 const TypeIdV1& type)
2316 : Parameter_t(type.Pid, type.length)
2317 , QosPolicy(type.send_always_)
2318 , m_type_identifier(type.m_type_identifier)
2319 {
2320 }
2321
2325
2326 */
2327 FASTDDS_EXPORTED_API TypeIdV1(
2328 const xtypes::TypeIdentifier& identifier)
2329 : Parameter_t(PID_TYPE_IDV1, 0)
2330 , QosPolicy(false)
2331 , m_type_identifier(identifier)
2332 {
2333 }
2334
2337
2338 * @param type Another instance of TypeIdV1
2339 */
2340 FASTDDS_EXPORTED_API TypeIdV1(
2341 TypeIdV1&& type)
2342 : Parameter_t(type.Pid, type.length)
2343 , QosPolicy(type.send_always_)
2344 , m_type_identifier(std::move(type.m_type_identifier))
2345 {
2346 }
2347
2348 FASTDDS_EXPORTED_API TypeIdV1& operator =(
2349 const TypeIdV1& type)
2350 {
2351 Pid = type.Pid;
2352 length = type.length;
2353 send_always_ = type.send_always_;
2354
2355 m_type_identifier = type.m_type_identifier;
2356
2357 return *this;
2358 }
2359
2360 FASTDDS_EXPORTED_API TypeIdV1& operator =(
2361 TypeIdV1&& type)
2362 {
2363 Pid = type.Pid;
2364 length = type.length;
2365 send_always_ = type.send_always_;
2366
2367 m_type_identifier = std::move(type.m_type_identifier);
2368
2369 return *this;
2370 }
2371
2372 /**
2373 * @brief Destructor
2374 */
2375 virtual FASTDDS_EXPORTED_API ~TypeIdV1() override = default;
2376
2377 inline void clear() override
2378 {
2379 *this = TypeIdV1();
2380 }
2381
2382 FASTDDS_EXPORTED_API TypeIdV1& operator =(
2383 const xtypes::TypeIdentifier& type_id)
2384 {
2385 m_type_identifier = type_id;
2386 return *this;
2387 }
2388
2392 * @return TypeIdentifier reference
2393 */
2394 FASTDDS_EXPORTED_API const xtypes::TypeIdentifier& get() const
2395 {
2396 return m_type_identifier;
2397 }
2398
2399};
2400
2404 class TypeObjectV1 : public Parameter_t, public QosPolicy
2405{
2406 public:
2407
2409 xtypes::TypeObject m_type_object;
2410
2411
2414 FASTDDS_EXPORTED_API TypeObjectV1()
2415 : Parameter_t(PID_TYPE_OBJECTV1, 0)
2416 , QosPolicy(false)
2417 , m_type_object()
2418 {
2419 }
2420
2424
2426 FASTDDS_EXPORTED_API TypeObjectV1(
2427 const TypeObjectV1& type)
2428 : Parameter_t(type.Pid, type.length)
2429 , QosPolicy(type.send_always_)
2430 , m_type_object(type.m_type_object)
2431 {
2432 }
2433
2437
2438 */
2439 FASTDDS_EXPORTED_API TypeObjectV1(
2440 const xtypes::TypeObject& type)
2441 : Parameter_t(PID_TYPE_OBJECTV1, 0)
2442 , QosPolicy(false)
2443 , m_type_object(type)
2444 {
2445 }
2446
2449
2450 * @param type Another instance of TypeObjectV1
2451 */
2452 FASTDDS_EXPORTED_API TypeObjectV1(
2453 TypeObjectV1&& type)
2454 : Parameter_t(type.Pid, type.length)
2455 , QosPolicy(type.send_always_)
2456 , m_type_object(std::move(type.m_type_object))
2457 {
2458 }
2459
2460 FASTDDS_EXPORTED_API TypeObjectV1& operator =(
2461 const TypeObjectV1& type)
2462 {
2463 Pid = type.Pid;
2464 length = type.length;
2465 send_always_ = type.send_always_;
2466
2467 m_type_object = type.m_type_object;
2468
2469 return *this;
2470 }
2471
2472 FASTDDS_EXPORTED_API TypeObjectV1& operator =(
2473 TypeObjectV1&& type)
2474 {
2475 Pid = type.Pid;
2476 length = type.length;
2477 send_always_ = type.send_always_;
2478
2479 m_type_object = std::move(type.m_type_object);
2480
2481 return *this;
2482 }
2483
2484 /**
2485 * @brief Destructor
2486 */
2487 virtual FASTDDS_EXPORTED_API ~TypeObjectV1() override = default;
2488
2489 inline void clear() override
2490 {
2491 *this = TypeObjectV1();
2492 }
2493
2494 FASTDDS_EXPORTED_API TypeObjectV1& operator =(
2495 const xtypes::TypeObject& type_object)
2496 {
2497 m_type_object = type_object;
2498 return *this;
2499 }
2500
2506 FASTDDS_EXPORTED_API const xtypes::TypeObject& get() const
2507 {
2508 return m_type_object;
2509 }
2510
2511};
2512
2513 namespace xtypes {
2514
2518 class TypeInformationParameter : public Parameter_t, public QosPolicy
2519{
2520 public:
2521
2523 eprosima::fastdds::dds::xtypes::TypeInformation type_information;
2524
2527
2528 FASTDDS_EXPORTED_API TypeInformationParameter()
2529 : Parameter_t(PID_TYPE_INFORMATION, 0)
2530 , QosPolicy(false)
2531 , type_information()
2532 , assigned_(false)
2533 {
2534 }
2535
2541 FASTDDS_EXPORTED_API TypeInformationParameter(
2542 const TypeInformationParameter& type)
2543 : Parameter_t(type.Pid, type.length)
2544 , QosPolicy(type.send_always_)
2545 , type_information(type.type_information)
2546 , assigned_(type.assigned_)
2547 {
2548 }
2549
2555 FASTDDS_EXPORTED_API TypeInformationParameter(
2556 const eprosima::fastdds::dds::xtypes::TypeInformation& info)
2557 : Parameter_t(PID_TYPE_INFORMATION, 0)
2558 , QosPolicy(false)
2559 , type_information(info)
2560 , assigned_(true)
2561 {
2562 }
2563
2568
2569 FASTDDS_EXPORTED_API TypeInformationParameter(
2570 TypeInformationParameter&& type)
2571 : Parameter_t(type.Pid, type.length)
2572 , QosPolicy(type.send_always_)
2573 , type_information(std::move(type.type_information))
2574 , assigned_(type.assigned_)
2575 {
2576 }
2577
2578 FASTDDS_EXPORTED_API TypeInformationParameter& operator =(
2579 const TypeInformationParameter& type)
2580 {
2581 Pid = type.Pid;
2582 length = type.length;
2583 send_always_ = type.send_always_;
2584
2585 type_information = type.type_information;
2586 assigned_ = type.assigned_;
2587
2588 return *this;
2589 }
2590
2591 FASTDDS_EXPORTED_API TypeInformationParameter& operator =(
2592 TypeInformationParameter&& type)
2593 {
2594 Pid = type.Pid;
2595 length = type.length;
2596 send_always_ = type.send_always_;
2597
2598 type_information = std::move(type.type_information);
2599 assigned_ = type.assigned_;
2600
2601 return *this;
2602 }
2603
2607 virtual FASTDDS_EXPORTED_API ~TypeInformationParameter() override = default;
2608
2609 inline void clear() override
2610 {
2611 *this = TypeInformationParameter();
2612 }
2613
2619 FASTDDS_EXPORTED_API bool assigned() const
2620 {
2621 return assigned_;
2622 }
2623
2626
2628
2629 FASTDDS_EXPORTED_API void assigned(
2630 bool value)
2631 {
2632 assigned_ = value;
2633 }
2634
2635 FASTDDS_EXPORTED_API TypeInformationParameter& operator =(
2636 const TypeInformation& type_info)
2637 {
2638 type_information = type_info;
2639 assigned_ = true;
2640 return *this;
2641 }
2642
2643 private:
2644
2646 bool assigned_;
2647};
2648
2649} // namespace xtypes
2650
2652 using ParticipantResourceLimitsQos = fastdds::rtps::RTPSParticipantAllocationAttributes;
2653
2655 using PropertyPolicyQos = fastdds::rtps::PropertyPolicy;
2656
2658 class WireProtocolConfigQos : public QosPolicy
2659{
2660
2661 public:
2662
2666 FASTDDS_EXPORTED_API WireProtocolConfigQos()
2667 : QosPolicy(false)
2668 , participant_id(-1)
2669 , easy_mode_("")
2670 {
2671 }
2672
2676 virtual FASTDDS_EXPORTED_API ~WireProtocolConfigQos() = default;
2677
2678 bool operator ==(
2679 const WireProtocolConfigQos& b) const
2680 {
2681 return (this->prefix == b.prefix) &&
2682 (this->participant_id == b.participant_id) &&
2683 (this->builtin == b.builtin) &&
2684 (this->port == b.port) &&
2685 (this->default_unicast_locator_list == b.default_unicast_locator_list) &&
2686 (this->default_multicast_locator_list == b.default_multicast_locator_list) &&
2687 (this->default_external_unicast_locators == b.default_external_unicast_locators) &&
2688 (this->ignore_non_matching_locators == b.ignore_non_matching_locators) &&
2689 (this->easy_mode_ == b.easy_mode()) &&
2690 QosPolicy::operator ==(b);
2691 }
2692
2693 inline void clear() override
2694 {
2695 WireProtocolConfigQos reset = WireProtocolConfigQos();
2696 std::swap(*this, reset);
2697 }
2698
2700 fastdds::rtps::GuidPrefix_t prefix;
2701
2703 int32_t participant_id;
2704
2706 fastdds::rtps::BuiltinAttributes builtin;
2707
2709 fastdds::rtps::PortParameters port;
2710
2715 rtps::LocatorList default_unicast_locator_list;
2716
2720 */
2721 rtps::LocatorList default_multicast_locator_list;
2722
2726 rtps::ExternalLocators default_external_unicast_locators;
2727
2731 bool ignore_non_matching_locators = false;
2732
2740
2742 ReturnCode_t easy_mode(
2743 const std::string& ip)
2744 {
2745 // Check if the input is empty
2746 if (!ip.empty())
2747 {
2748 // Check if the input is a valid IP
2749 if (!rtps::IPLocator::isIPv4(ip))
2750 {
2751 EPROSIMA_LOG_ERROR(
2752 WIREPROTOCOLQOS, "Invalid IP address format for ROS 2 Easy Mode. It must be an IPv4 address.");
2753
2754 return RETCODE_BAD_PARAMETER;
2755 }
2756 }
2757
2758 easy_mode_ = ip;
2759
2760 return RETCODE_OK;
2761 }
2762
2765 *
2766 * @return IP address if set, empty string otherwise
2767 */
2768 const std::string& easy_mode() const
2769 {
2770 return easy_mode_;
2771 }
2772
2773 private:
2774
2776 std::string easy_mode_;
2777};
2778
2780 class TransportConfigQos : public QosPolicy
2781{
2782 public:
2783
2787 FASTDDS_EXPORTED_API TransportConfigQos()
2788 : QosPolicy(false)
2789 , use_builtin_transports(true)
2790 , send_socket_buffer_size(0)
2791 , listen_socket_buffer_size(0)
2792 , max_msg_size_no_frag(0)
2793 , netmask_filter(fastdds::rtps::NetmaskFilterKind::AUTO)
2794 {
2795 }
2796
2798
2800 virtual FASTDDS_EXPORTED_API ~TransportConfigQos() = default;
2801
2802 bool operator ==(
2803 const TransportConfigQos& b) const
2804 {
2805 return (this->user_transports == b.user_transports) &&
2806 (this->use_builtin_transports == b.use_builtin_transports) &&
2807 (this->send_socket_buffer_size == b.send_socket_buffer_size) &&
2808 (this->listen_socket_buffer_size == b.listen_socket_buffer_size) &&
2809 (this->builtin_transports_reception_threads_ == b.builtin_transports_reception_threads_) &&
2810 (this->max_msg_size_no_frag == b.max_msg_size_no_frag) &&
2811 (this->netmask_filter == b.netmask_filter) &&
2812 QosPolicy::operator ==(b);
2813 }
2814
2815 inline void clear() override
2816 {
2817 TransportConfigQos reset = TransportConfigQos();
2818 std::swap(*this, reset);
2819 }
2820
2822 std::vector<std::shared_ptr<fastdds::rtps::TransportDescriptorInterface>> user_transports;
2823
2825 bool use_builtin_transports;
2826
2830
2831 uint32_t send_socket_buffer_size;
2832
2833 /*! Listen socket buffer for all listen resources. Zero value indicates to use default system buffer size. <br>
2834 * By default, 0.
2835 */
2836 uint32_t listen_socket_buffer_size;
2837
2839 rtps::ThreadSettings builtin_transports_reception_threads_;
2840
2841 /*!
2842 * @brief Maximum message size used to avoid fragmentation, set ONLY in LARGE_DATA.
2843 *
2844 * If this value is not zero, the network factory will allow the initialization of UDP transports with maxMessageSize
2845 * higher than 65500K.
2846 */
2847 uint32_t max_msg_size_no_frag;
2848
2850 fastdds::rtps::NetmaskFilterKind netmask_filter;
2851};
2852
2854 FASTDDS_TODO_BEFORE(4, 0, "Make all eProsima extended QoS inherit from Parameter_t and QosPolicy if possible.");
2855 class RTPSEndpointQos
2856{
2857 public:
2858
2859 FASTDDS_EXPORTED_API RTPSEndpointQos() = default;
2860
2861 virtual FASTDDS_EXPORTED_API ~RTPSEndpointQos() = default;
2862
2863 inline void clear()
2864 {
2865 RTPSEndpointQos reset = RTPSEndpointQos();
2866 std::swap(*this, reset);
2867 }
2868
2869 bool operator ==(
2870 const RTPSEndpointQos& b) const
2871 {
2872 return (this->unicast_locator_list == b.unicast_locator_list) &&
2873 (this->multicast_locator_list == b.multicast_locator_list) &&
2874 (this->remote_locator_list == b.remote_locator_list) &&
2875 (this->external_unicast_locators == b.external_unicast_locators) &&
2876 (this->ignore_non_matching_locators == b.ignore_non_matching_locators) &&
2877 (this->user_defined_id == b.user_defined_id) &&
2878 (this->entity_id == b.entity_id) &&
2879 (this->history_memory_policy == b.history_memory_policy);
2880 }
2881
2883 rtps::LocatorList unicast_locator_list;
2884
2885
2886 rtps::LocatorList multicast_locator_list;
2887
2889 rtps::LocatorList remote_locator_list;
2890
2892 fastdds::rtps::ExternalLocators external_unicast_locators;
2893
2894 //! Whether locators that don't match with the announced locators should be kept.
2895 bool ignore_non_matching_locators = false;
2896
2898 int16_t user_defined_id = -1;
2899
2901 int16_t entity_id = -1;
2902
2904 fastdds::rtps::MemoryManagementPolicy_t history_memory_policy =
2905 fastdds::rtps::PREALLOCATED_WITH_REALLOC_MEMORY_MODE;
2906};
2907
2909 class WriterResourceLimitsQos
2910{
2911 public:
2912
2916 FASTDDS_EXPORTED_API WriterResourceLimitsQos()
2917 : matched_subscriber_allocation()
2918 , reader_filters_allocation(0, 32u, 1u)
2919 {
2920 }
2921
2923
2925 virtual FASTDDS_EXPORTED_API ~WriterResourceLimitsQos() = default;
2926
2927 inline void clear()
2928 {
2929 WriterResourceLimitsQos reset = WriterResourceLimitsQos();
2930 std::swap(*this, reset);
2931 }
2932
2933 bool operator ==(
2934 const WriterResourceLimitsQos& b) const
2935 {
2936 return (matched_subscriber_allocation == b.matched_subscriber_allocation) &&
2937 (reader_filters_allocation == b.reader_filters_allocation);
2938 }
2939
2941 fastdds::ResourceLimitedContainerConfig matched_subscriber_allocation;
2943 fastdds::ResourceLimitedContainerConfig reader_filters_allocation;
2944};
2945
2949 enum DataSharingKind : fastdds::rtps::octet
2950{
2951 /**
2952 * Automatic configuration.
2953 * DataSharing will be used if requirements are met.
2954 */
2955 AUTO = 0x01,
2958 * Entity creation will fail if requirements for DataSharing are not met
2959 */
2960 ON = 0x02,
2964 OFF = 0x03
2965};
2966
2967
2973 class DataSharingQosPolicy : public Parameter_t, public QosPolicy
2974{
2975 public:
2976
2980 FASTDDS_EXPORTED_API DataSharingQosPolicy()
2981 : Parameter_t(PID_DATASHARING, 0)
2982 , QosPolicy(true)
2983 {
2984 //Needed to generate the automatic domain ID
2985 automatic();
2986 }
2987
2989
2990 */
2991 virtual FASTDDS_EXPORTED_API ~DataSharingQosPolicy() = default;
2992
2998 FASTDDS_EXPORTED_API DataSharingQosPolicy(
2999 const DataSharingQosPolicy& b)
3000 : Parameter_t(b)
3001 , QosPolicy(b)
3002 , kind_(b.kind())
3003 , shm_directory_ (b.shm_directory())
3004 , max_domains_ (b.max_domains())
3005 , domain_ids_(b.max_domains() != 0 ?
3006 b.max_domains() :
3007 b.domain_ids().size())
3008 {
3009 domain_ids_ = b.domain_ids();
3010 }
3011
3012 FASTDDS_EXPORTED_API DataSharingQosPolicy& operator =(
3013 const DataSharingQosPolicy& b)
3014 {
3015 QosPolicy::operator =(b);
3016 Parameter_t::operator =(b);
3017 kind_ = b.kind();
3018 shm_directory_ = b.shm_directory();
3019 max_domains_ = b.max_domains();
3020 domain_ids_.reserve(max_domains_ != 0 ?
3021 max_domains_ :
3022 b.domain_ids().size());
3023 domain_ids_ = b.domain_ids();
3024 data_sharing_listener_thread_ = b.data_sharing_listener_thread();
3025
3026 return *this;
3027 }
3028
3029 bool operator ==(
3030 const DataSharingQosPolicy& b) const
3031 {
3032 return kind_ == b.kind_ &&
3033 shm_directory_ == b.shm_directory_ &&
3034 domain_ids_ == b.domain_ids_ &&
3035 data_sharing_listener_thread_ == b.data_sharing_listener_thread_ &&
3036 Parameter_t::operator ==(b) &&
3037 QosPolicy::operator ==(b);
3038 }
3039
3040 inline void clear() override
3041 {
3042 DataSharingQosPolicy reset = DataSharingQosPolicy();
3043 std::swap(*this, reset);
3044 }
3045
3049 FASTDDS_EXPORTED_API const DataSharingKind& kind() const
3050 {
3051 return kind_;
3052 }
3053
3057 FASTDDS_EXPORTED_API const std::string& shm_directory() const
3058 {
3059 return shm_directory_;
3060 }
3061
3067
3071 * - User defined domain IDs use the 16 LSB and leave the 48 MSB as zero.
3072 *
3073 * @return the current DataSharing domain IDs
3074 */
3075 FASTDDS_EXPORTED_API const std::vector<uint64_t>& domain_ids() const
3076 {
3077 return domain_ids_;
3078 }
3079
3082 */
3083 FASTDDS_EXPORTED_API void set_max_domains(
3084 uint32_t size)
3085 {
3086 domain_ids_.reserve(size);
3087 max_domains_ = size;
3088 }
3089
3093 FASTDDS_EXPORTED_API const uint32_t& max_domains() const
3094 {
3095 return max_domains_;
3096 }
3097
3099
3104 FASTDDS_EXPORTED_API void automatic()
3105 {
3106 setup (AUTO, "", std::vector<uint16_t>());
3107 }
3108
3112
3116 FASTDDS_EXPORTED_API void automatic(
3117 const std::vector<uint16_t>& domain_ids)
3118 {
3119 setup (AUTO, "", domain_ids);
3120 }
3121
3125
3129 FASTDDS_EXPORTED_API void automatic(
3130 const std::string& directory)
3131 {
3132 setup (AUTO, directory, std::vector<uint16_t>());
3133 }
3134
3141 FASTDDS_EXPORTED_API void automatic(
3142 const std::string& directory,
3143 const std::vector<uint16_t>& domain_ids)
3144 {
3145 setup (AUTO, directory, domain_ids);
3146 }
3147
3149 * @brief Configures the DataSharing in active mode
3150 *
3151 * A default domain ID is automatically computed.
3152 *
3153 * @param directory The shared memory directory to use.
3154 * It is mandatory to provide a non-empty name or the creation of endpoints will fail.
3155 */
3156 FASTDDS_EXPORTED_API void on(
3157 const std::string& directory)
3158 {
3159 // TODO [ILG]: This parameter is unused right now. Activate the assert once it is used
3160 //assert(!directory.empty());
3161 setup (ON, directory, std::vector<uint16_t>());
3162 }
3163
3165
3171 FASTDDS_EXPORTED_API void on(
3172 const std::string& directory,
3173 const std::vector<uint16_t>& domain_ids)
3174 {
3175 // TODO [ILG]: This parameter is unused right now. Activate the assert once it is used
3176 //assert(!directory.empty());
3177 setup (ON, directory, domain_ids);
3178 }
3179
3181 * @brief Configures the DataSharing in disabled mode
3182 */
3183 FASTDDS_EXPORTED_API void off()
3184 {
3185 setup (OFF, "", std::vector<uint16_t>());
3186 }
3187
3189
3193 FASTDDS_EXPORTED_API void add_domain_id(
3194 uint16_t id)
3195 {
3196 if (max_domains_ == 0 || domain_ids_.size() < max_domains_)
3197 {
3198 domain_ids_.push_back(id);
3199 }
3200 }
3201
3202 // Not on the exported API, but must be public for other internal classes
3203 void add_domain_id(
3204 uint64_t id)
3205 {
3206 if (max_domains_ == 0 || domain_ids_.size() < max_domains_)
3207 {
3208 domain_ids_.push_back(id);
3209 }
3210 }
3211
3215 * @return rtps::ThreadSettings reference
3216 */
3217 rtps::ThreadSettings& data_sharing_listener_thread()
3218 {
3219 return data_sharing_listener_thread_;
3220 }
3221
3227 const rtps::ThreadSettings& data_sharing_listener_thread() const
3228 {
3229 return data_sharing_listener_thread_;
3230 }
3231
3237 void data_sharing_listener_thread(
3238 const rtps::ThreadSettings& value)
3239 {
3240 data_sharing_listener_thread_ = value;
3241 }
3242
3243 private:
3244
3245 void setup(
3246 const DataSharingKind& kind,
3247 const std::string& directory,
3248 const std::vector<uint16_t>& domain_ids)
3249 {
3250 kind_ = kind;
3251 shm_directory_ = directory;
3252 domain_ids_.clear();
3253
3254 for (uint16_t id : domain_ids)
3255 {
3256 add_domain_id(id);
3257 }
3258 }
3259
3261 DataSharingKind kind_ = AUTO;
3262
3264 std::string shm_directory_;
3265
3267 uint32_t max_domains_ = 0;
3268
3270 std::vector<uint64_t> domain_ids_;
3271
3273 rtps::ThreadSettings data_sharing_listener_thread_;
3274};
3275
3276
3277} // namespace dds
3278} // namespace fastdds
3279} // namespace eprosima
3280
3281#endif // FASTDDS_DDS_CORE_POLICY__QOSPOLICIES_HPP
eprosima::fastdds::ResourceLimitedVector
Resource limited wrapper of std::vector.
Definition ResourceLimitedVector.hpp:59
eprosima::fastdds::ResourceLimitedVector< fastdds::rtps::octet >::size
size_type size() const noexcept
Definition ResourceLimitedVector.hpp:479
eprosima::fastdds::ResourceLimitedVector< fastdds::rtps::octet >::configuration_
configuration_type configuration_
Definition ResourceLimitedVector.hpp:543
eprosima::fastdds::ResourceLimitedVector< fastdds::rtps::octet >::collection_type
std::vector< fastdds::rtps::octet, std::allocator< fastdds::rtps::octet > > collection_type
Definition ResourceLimitedVector.hpp:63
eprosima::fastdds::ResourceLimitedVector< fastdds::rtps::octet >::clear
void clear()
Definition ResourceLimitedVector.hpp:494
eprosima::fastdds::ResourceLimitedVector< fastdds::rtps::octet >::assign
void assign(InputIterator first, InputIterator last)
Definition ResourceLimitedVector.hpp:318
eprosima::fastdds::ResourceLimitedVector< fastdds::rtps::octet >::collection_
collection_type collection_
Definition ResourceLimitedVector.hpp:544
eprosima::fastdds::ResourceLimitedVector< fastdds::rtps::octet >::data
value_type * data()
Definition ResourceLimitedVector.hpp:517
eprosima::fastdds::dds::DataRepresentationQosPolicy
With multiple standard data Representations available, and vendor-specific extensions possible,...
Definition QosPolicies.hpp:2072
eprosima::fastdds::dds::DataRepresentationQosPolicy::operator==
bool operator==(const DataRepresentationQosPolicy &b) const
Compares the given policy to check if it's equal.
Definition QosPolicies.hpp:2098
eprosima::fastdds::dds::DataRepresentationQosPolicy::~DataRepresentationQosPolicy
virtual FASTDDS_EXPORTED_API ~DataRepresentationQosPolicy() override=default
Destructor.
eprosima::fastdds::dds::DataRepresentationQosPolicy::DataRepresentationQosPolicy
FASTDDS_EXPORTED_API DataRepresentationQosPolicy()
Constructor.
Definition QosPolicies.hpp:2081
eprosima::fastdds::dds::DataRepresentationQosPolicy::m_value
std::vector< DataRepresentationId_t > m_value
List of DataRepresentationId. By default, empty list.
Definition QosPolicies.hpp:2076
eprosima::fastdds::dds::DataRepresentationQosPolicy::clear
void clear() override
Clears the QosPolicy object.
Definition QosPolicies.hpp:2106
eprosima::fastdds::dds::DataSharingQosPolicy
Qos Policy to configure the data sharing.
Definition QosPolicies.hpp:2952
eprosima::fastdds::dds::DataSharingQosPolicy::domain_ids
FASTDDS_EXPORTED_API const std::vector< uint64_t > & domain_ids() const
Gets the set of DataSharing domain IDs.
Definition QosPolicies.hpp:3053
eprosima::fastdds::dds::DataSharingQosPolicy::max_domains
FASTDDS_EXPORTED_API const uint32_t & max_domains() const
Definition QosPolicies.hpp:3071
eprosima::fastdds::dds::DataSharingQosPolicy::operator==
bool operator==(const DataSharingQosPolicy &b) const
Definition QosPolicies.hpp:3007
eprosima::fastdds::dds::DataSharingQosPolicy::kind
FASTDDS_EXPORTED_API const DataSharingKind & kind() const
Definition QosPolicies.hpp:3027
eprosima::fastdds::dds::DataSharingQosPolicy::DataSharingQosPolicy
FASTDDS_EXPORTED_API DataSharingQosPolicy()
Constructor.
Definition QosPolicies.hpp:2958
eprosima::fastdds::dds::DataSharingQosPolicy::shm_directory
FASTDDS_EXPORTED_API const std::string & shm_directory() const
Definition QosPolicies.hpp:3035
eprosima::fastdds::dds::DataSharingQosPolicy::data_sharing_listener_thread
rtps::ThreadSettings & data_sharing_listener_thread()
Getter for DataSharing listener thread ThreadSettings.
Definition QosPolicies.hpp:3195
eprosima::fastdds::dds::DataSharingQosPolicy::operator=
FASTDDS_EXPORTED_API DataSharingQosPolicy & operator=(const DataSharingQosPolicy &b)
Definition QosPolicies.hpp:2990
eprosima::fastdds::dds::DataSharingQosPolicy::~DataSharingQosPolicy
virtual FASTDDS_EXPORTED_API ~DataSharingQosPolicy()=default
Destructor.
eprosima::fastdds::dds::DataSharingQosPolicy::add_domain_id
FASTDDS_EXPORTED_API void add_domain_id(uint16_t id)
Adds a user-specific DataSharing domain ID.
Definition QosPolicies.hpp:3171
eprosima::fastdds::dds::DataSharingQosPolicy::off
FASTDDS_EXPORTED_API void off()
Configures the DataSharing in disabled mode.
Definition QosPolicies.hpp:3161
eprosima::fastdds::dds::DataSharingQosPolicy::set_max_domains
FASTDDS_EXPORTED_API void set_max_domains(uint32_t size)
Definition QosPolicies.hpp:3061
eprosima::fastdds::dds::DataSharingQosPolicy::on
FASTDDS_EXPORTED_API void on(const std::string &directory)
Configures the DataSharing in active mode.
Definition QosPolicies.hpp:3134
eprosima::fastdds::dds::DataSharingQosPolicy::clear
void clear() override
Clears the QosPolicy object.
Definition QosPolicies.hpp:3018
eprosima::fastdds::dds::DataSharingQosPolicy::automatic
FASTDDS_EXPORTED_API void automatic()
Configures the DataSharing in automatic mode.
Definition QosPolicies.hpp:3082
eprosima::fastdds::dds::DeadlineQosPolicy::operator==
bool operator==(const DeadlineQosPolicy &b) const
Definition QosPolicies.hpp:381
eprosima::fastdds::dds::DeadlineQosPolicy::period
fastdds::dds::Duration_t period
Maximum time expected between samples.
Definition QosPolicies.hpp:403
eprosima::fastdds::dds::DeadlineQosPolicy::DeadlineQosPolicy
FASTDDS_EXPORTED_API DeadlineQosPolicy()
Constructor.
Definition QosPolicies.hpp:369
eprosima::fastdds::dds::DeadlineQosPolicy::~DeadlineQosPolicy
virtual FASTDDS_EXPORTED_API ~DeadlineQosPolicy()=default
Destructor.
eprosima::fastdds::dds::DeadlineQosPolicy::clear
void clear() override
Clears the QosPolicy object.
Definition QosPolicies.hpp:389
eprosima::fastdds::dds::DestinationOrderQosPolicy::operator==
bool operator==(const DestinationOrderQosPolicy &b) const
Definition QosPolicies.hpp:737
eprosima::fastdds::dds::DestinationOrderQosPolicy::kind
DestinationOrderQosPolicyKind kind
DestinationOrderQosPolicyKind. By default, BY_RECEPTION_TIMESTAMP_DESTINATIONORDER_QOS.
Definition QosPolicies.hpp:754
eprosima::fastdds::dds::DestinationOrderQosPolicy::~DestinationOrderQosPolicy
virtual FASTDDS_EXPORTED_API ~DestinationOrderQosPolicy()=default
Destructor.
eprosima::fastdds::dds::DestinationOrderQosPolicy::DestinationOrderQosPolicy
FASTDDS_EXPORTED_API DestinationOrderQosPolicy()
Constructor.
Definition QosPolicies.hpp:725
eprosima::fastdds::dds::DestinationOrderQosPolicy::clear
void clear() override
Clears the QosPolicy object.
Definition QosPolicies.hpp:745
eprosima::fastdds::dds::DisablePositiveACKsQosPolicy
Class DisablePositiveACKsQosPolicy to disable sending of positive ACKs.
Definition QosPolicies.hpp:2224
eprosima::fastdds::dds::DisablePositiveACKsQosPolicy::operator==
bool operator==(const DisablePositiveACKsQosPolicy &b) const
Definition QosPolicies.hpp:2243
eprosima::fastdds::dds::DisablePositiveACKsQosPolicy::enabled
bool enabled
True if this QoS is enabled. By default, false.
Definition QosPolicies.hpp:2261
eprosima::fastdds::dds::DisablePositiveACKsQosPolicy::duration
fastdds::dds::Duration_t duration
The duration to keep samples for (not serialized as not needed by reader). By default,...
Definition QosPolicies.hpp:2263
eprosima::fastdds::dds::DisablePositiveACKsQosPolicy::DisablePositiveACKsQosPolicy
FASTDDS_EXPORTED_API DisablePositiveACKsQosPolicy()
Constructor.
Definition QosPolicies.hpp:2230
eprosima::fastdds::dds::DisablePositiveACKsQosPolicy::clear
void clear() override
Clears the QosPolicy object.
Definition QosPolicies.hpp:2252
eprosima::fastdds::dds::DisablePositiveACKsQosPolicy::~DisablePositiveACKsQosPolicy
virtual FASTDDS_EXPORTED_API ~DisablePositiveACKsQosPolicy()=default
Destructor.
eprosima::fastdds::dds::DurabilityQosPolicy::~DurabilityQosPolicy
virtual FASTDDS_EXPORTED_API ~DurabilityQosPolicy()=default
Destructor.
eprosima::fastdds::dds::DurabilityQosPolicy::durabilityKind
fastdds::rtps::DurabilityKind_t durabilityKind() const
Translates kind to rtps layer equivalent.
Definition QosPolicies.hpp:301
eprosima::fastdds::dds::DurabilityQosPolicy::kind
DurabilityQosPolicyKind_t kind
DurabilityQosPolicyKind.
Definition QosPolicies.hpp:352
eprosima::fastdds::dds::DurabilityQosPolicy::DurabilityQosPolicy
FASTDDS_EXPORTED_API DurabilityQosPolicy()
Constructor.
Definition QosPolicies.hpp:284
eprosima::fastdds::dds::DurabilityQosPolicy::operator==
bool operator==(const DurabilityQosPolicy &b) const
Definition QosPolicies.hpp:313
eprosima::fastdds::dds::DurabilityQosPolicy::durabilityKind
void durabilityKind(const fastdds::rtps::DurabilityKind_t new_kind)
Set kind passing the rtps layer equivalent kind.
Definition QosPolicies.hpp:326
eprosima::fastdds::dds::DurabilityQosPolicy::clear
void clear() override
Clears the QosPolicy object.
Definition QosPolicies.hpp:340
eprosima::fastdds::dds::DurabilityServiceQosPolicy
Specifies the configuration of the durability service.
Definition QosPolicies.hpp:1789
eprosima::fastdds::dds::DurabilityServiceQosPolicy::~DurabilityServiceQosPolicy
virtual FASTDDS_EXPORTED_API ~DurabilityServiceQosPolicy()=default
Destructor.
eprosima::fastdds::dds::DurabilityServiceQosPolicy::max_samples_per_instance
int32_t max_samples_per_instance
Control the ResourceLimitsQos of the implied DataReader that stores the data within the durability se...
Definition QosPolicies.hpp:1868
eprosima::fastdds::dds::DurabilityServiceQosPolicy::DurabilityServiceQosPolicy
FASTDDS_EXPORTED_API DurabilityServiceQosPolicy()
Constructor.
Definition QosPolicies.hpp:1795
eprosima::fastdds::dds::DurabilityServiceQosPolicy::max_samples
int32_t max_samples
Control the ResourceLimitsQos of the implied DataReader that stores the data within the durability se...
Definition QosPolicies.hpp:1855
eprosima::fastdds::dds::DurabilityServiceQosPolicy::max_instances
int32_t max_instances
Control the ResourceLimitsQos of the implied DataReader that stores the data within the durability se...
Definition QosPolicies.hpp:1861
eprosima::fastdds::dds::DurabilityServiceQosPolicy::service_cleanup_delay
fastdds::dds::Duration_t service_cleanup_delay
Control when the service is able to remove all information regarding a data-instance.
Definition QosPolicies.hpp:1835
eprosima::fastdds::dds::DurabilityServiceQosPolicy::history_kind
HistoryQosPolicyKind history_kind
Controls the HistoryQosPolicy of the fictitious DataReader that stores the data within the durability...
Definition QosPolicies.hpp:1841
eprosima::fastdds::dds::DurabilityServiceQosPolicy::history_depth
int32_t history_depth
Number of most recent values that should be maintained on the History.
Definition QosPolicies.hpp:1847
eprosima::fastdds::dds::DurabilityServiceQosPolicy::operator==
bool operator==(const DurabilityServiceQosPolicy &b) const
Definition QosPolicies.hpp:1811
eprosima::fastdds::dds::DurabilityServiceQosPolicy::clear
void clear() override
Clears the QosPolicy object.
Definition QosPolicies.hpp:1823
eprosima::fastdds::dds::EntityFactoryQosPolicy::operator==
bool operator==(const EntityFactoryQosPolicy &b) const
Definition QosPolicies.hpp:225
eprosima::fastdds::dds::EntityFactoryQosPolicy::EntityFactoryQosPolicy
FASTDDS_EXPORTED_API EntityFactoryQosPolicy(bool autoenable)
Constructor.
Definition QosPolicies.hpp:212
eprosima::fastdds::dds::EntityFactoryQosPolicy::EntityFactoryQosPolicy
FASTDDS_EXPORTED_API EntityFactoryQosPolicy()
Constructor without parameters.
Definition QosPolicies.hpp:202
eprosima::fastdds::dds::EntityFactoryQosPolicy::autoenable_created_entities
bool autoenable_created_entities
Specifies whether the entity acting as a factory automatically enables the instances it creates.
Definition QosPolicies.hpp:197
eprosima::fastdds::dds::EntityFactoryQosPolicy::~EntityFactoryQosPolicy
virtual FASTDDS_EXPORTED_API ~EntityFactoryQosPolicy()
Destructor.
Definition QosPolicies.hpp:221
eprosima::fastdds::dds::EntityFactoryQosPolicy::clear
void clear()
Definition QosPolicies.hpp:232
eprosima::fastdds::dds::GenericDataQosPolicy
Class GenericDataQosPolicy, base class to transmit user data during the discovery phase.
Definition QosPolicies.hpp:763
eprosima::fastdds::dds::GenericDataQosPolicy::~GenericDataQosPolicy
virtual FASTDDS_EXPORTED_API ~GenericDataQosPolicy()=default
eprosima::fastdds::dds::GenericDataQosPolicy::getValue
FASTDDS_EXPORTED_API const collection_type & getValue() const
Returns raw data vector.
Definition QosPolicies.hpp:962
eprosima::fastdds::dds::GenericDataQosPolicy::GenericDataQosPolicy
FASTDDS_EXPORTED_API GenericDataQosPolicy(const GenericDataQosPolicy &data)
Construct from another GenericDataQosPolicy.
Definition QosPolicies.hpp:793
eprosima::fastdds::dds::GenericDataQosPolicy::GenericDataQosPolicy
FASTDDS_EXPORTED_API GenericDataQosPolicy(ParameterId_t pid, uint16_t in_length)
Definition QosPolicies.hpp:776
eprosima::fastdds::dds::GenericDataQosPolicy::data_vec
FASTDDS_EXPORTED_API collection_type & data_vec()
Returns raw data vector.
Definition QosPolicies.hpp:936
eprosima::fastdds::dds::GenericDataQosPolicy::GenericDataQosPolicy
FASTDDS_EXPORTED_API GenericDataQosPolicy(ParameterId_t pid)
Definition QosPolicies.hpp:768
eprosima::fastdds::dds::GenericDataQosPolicy::resize
void resize(size_t new_size)
Definition QosPolicies.hpp:901
eprosima::fastdds::dds::GenericDataQosPolicy::dataVec
const collection_type & dataVec() const
Definition QosPolicies.hpp:910
eprosima::fastdds::dds::GenericDataQosPolicy::data_vec
FASTDDS_EXPORTED_API const collection_type & data_vec() const
Returns raw data vector.
Definition QosPolicies.hpp:926
eprosima::fastdds::dds::GenericDataQosPolicy::data_vec
FASTDDS_EXPORTED_API void data_vec(const collection_type &vec)
Sets raw data vector.
Definition QosPolicies.hpp:946
eprosima::fastdds::dds::GenericDataQosPolicy::GenericDataQosPolicy
FASTDDS_EXPORTED_API GenericDataQosPolicy(ParameterId_t pid, const collection_type &data)
Construct from underlying collection type.
Definition QosPolicies.hpp:810
eprosima::fastdds::dds::GenericDataQosPolicy::set_max_size
void set_max_size(size_t size)
Set the maximum size of the user data and reserves memory for that much.
Definition QosPolicies.hpp:887
eprosima::fastdds::dds::GenericDataQosPolicy::operator==
bool operator==(const GenericDataQosPolicy &b) const
Definition QosPolicies.hpp:868
eprosima::fastdds::dds::GenericDataQosPolicy::setValue
FASTDDS_EXPORTED_API void setValue(const collection_type &vec)
Sets raw data vector.
Definition QosPolicies.hpp:972
eprosima::fastdds::dds::GenericDataQosPolicy::clear
void clear() override
Clears the QosPolicy object.
Definition QosPolicies.hpp:915
eprosima::fastdds::dds::GenericDataQosPolicy::operator=
GenericDataQosPolicy & operator=(const collection_type &b)
Copies data from underlying collection type.
Definition QosPolicies.hpp:834
eprosima::fastdds::dds::HistoryQosPolicy
Specifies the behavior of the Service in the case where the value of a sample changes (one or more ti...
Definition QosPolicies.hpp:1651
eprosima::fastdds::dds::HistoryQosPolicy::operator==
bool operator==(const HistoryQosPolicy &b) const
Definition QosPolicies.hpp:1670
eprosima::fastdds::dds::HistoryQosPolicy::kind
HistoryQosPolicyKind kind
HistoryQosPolicyKind. By default, KEEP_LAST_HISTORY_QOS.
Definition QosPolicies.hpp:1688
eprosima::fastdds::dds::HistoryQosPolicy::depth
int32_t depth
History depth.
Definition QosPolicies.hpp:1694
eprosima::fastdds::dds::HistoryQosPolicy::HistoryQosPolicy
FASTDDS_EXPORTED_API HistoryQosPolicy()
Constructor.
Definition QosPolicies.hpp:1657
eprosima::fastdds::dds::HistoryQosPolicy::~HistoryQosPolicy
virtual FASTDDS_EXPORTED_API ~HistoryQosPolicy()=default
Destructor.
eprosima::fastdds::dds::HistoryQosPolicy::clear
void clear() override
Clears the QosPolicy object.
Definition QosPolicies.hpp:1679
eprosima::fastdds::dds::LatencyBudgetQosPolicy::LatencyBudgetQosPolicy
FASTDDS_EXPORTED_API LatencyBudgetQosPolicy()
Constructor.
Definition QosPolicies.hpp:422
eprosima::fastdds::dds::LatencyBudgetQosPolicy::operator==
bool operator==(const LatencyBudgetQosPolicy &b) const
Definition QosPolicies.hpp:434
eprosima::fastdds::dds::LatencyBudgetQosPolicy::duration
fastdds::dds::Duration_t duration
Maximum acceptable delay from the time data is written until it is received. By default,...
Definition QosPolicies.hpp:451
eprosima::fastdds::dds::LatencyBudgetQosPolicy::~LatencyBudgetQosPolicy
virtual FASTDDS_EXPORTED_API ~LatencyBudgetQosPolicy()=default
Destructor.
eprosima::fastdds::dds::LatencyBudgetQosPolicy::clear
void clear() override
Clears the QosPolicy object.
Definition QosPolicies.hpp:442
eprosima::fastdds::dds::LifespanQosPolicy
Specifies the maximum duration of validity of the data written by the DataWriter.
Definition QosPolicies.hpp:1877
eprosima::fastdds::dds::LifespanQosPolicy::LifespanQosPolicy
FASTDDS_EXPORTED_API LifespanQosPolicy()
Constructor.
Definition QosPolicies.hpp:1883
eprosima::fastdds::dds::LifespanQosPolicy::~LifespanQosPolicy
virtual FASTDDS_EXPORTED_API ~LifespanQosPolicy()=default
Destructor.
eprosima::fastdds::dds::LifespanQosPolicy::duration
fastdds::dds::Duration_t duration
Period of validity. By default, dds::c_TimeInfinite.
Definition QosPolicies.hpp:1912
eprosima::fastdds::dds::LifespanQosPolicy::operator==
bool operator==(const LifespanQosPolicy &b) const
Definition QosPolicies.hpp:1895
eprosima::fastdds::dds::LifespanQosPolicy::clear
void clear() override
Clears the QosPolicy object.
Definition QosPolicies.hpp:1903
eprosima::fastdds::dds::LivelinessQosPolicy::~LivelinessQosPolicy
virtual FASTDDS_EXPORTED_API ~LivelinessQosPolicy()=default
Destructor.
eprosima::fastdds::dds::LivelinessQosPolicy::kind
LivelinessQosPolicyKind kind
Liveliness kind By default, AUTOMATIC_LIVELINESS.
Definition QosPolicies.hpp:527
eprosima::fastdds::dds::LivelinessQosPolicy::LivelinessQosPolicy
FASTDDS_EXPORTED_API LivelinessQosPolicy()
Constructor.
Definition QosPolicies.hpp:494
eprosima::fastdds::dds::LivelinessQosPolicy::lease_duration
fastdds::dds::Duration_t lease_duration
Period within which liveliness should be asserted.
Definition QosPolicies.hpp:534
eprosima::fastdds::dds::LivelinessQosPolicy::operator==
bool operator==(const LivelinessQosPolicy &b) const
Definition QosPolicies.hpp:508
eprosima::fastdds::dds::LivelinessQosPolicy::announcement_period
fastdds::dds::Duration_t announcement_period
The period for automatic assertion of liveliness.
Definition QosPolicies.hpp:541
eprosima::fastdds::dds::LivelinessQosPolicy::clear
void clear() override
Clears the QosPolicy object.
Definition QosPolicies.hpp:518
eprosima::fastdds::dds::OwnershipQosPolicy::OwnershipQosPolicy
FASTDDS_EXPORTED_API OwnershipQosPolicy()
Constructor.
Definition QosPolicies.hpp:658
eprosima::fastdds::dds::OwnershipQosPolicy::operator==
bool operator==(const OwnershipQosPolicy &b) const
Definition QosPolicies.hpp:670
eprosima::fastdds::dds::OwnershipQosPolicy::kind
OwnershipQosPolicyKind kind
OwnershipQosPolicyKind.
Definition QosPolicies.hpp:687
eprosima::fastdds::dds::OwnershipQosPolicy::clear
void clear() override
Clears the QosPolicy object.
Definition QosPolicies.hpp:678
eprosima::fastdds::dds::OwnershipQosPolicy::~OwnershipQosPolicy
virtual FASTDDS_EXPORTED_API ~OwnershipQosPolicy()=default
Destructor.
eprosima::fastdds::dds::OwnershipStrengthQosPolicy
Specifies the value of the “strength” used to arbitrate among multiple DataWriter objects that attemp...
Definition QosPolicies.hpp:1923
eprosima::fastdds::dds::OwnershipStrengthQosPolicy::OwnershipStrengthQosPolicy
FASTDDS_EXPORTED_API OwnershipStrengthQosPolicy()
Constructor.
Definition QosPolicies.hpp:1929
eprosima::fastdds::dds::OwnershipStrengthQosPolicy::~OwnershipStrengthQosPolicy
virtual FASTDDS_EXPORTED_API ~OwnershipStrengthQosPolicy()=default
Destructor.
eprosima::fastdds::dds::OwnershipStrengthQosPolicy::value
uint32_t value
Strength By default, 0.
Definition QosPolicies.hpp:1958
eprosima::fastdds::dds::OwnershipStrengthQosPolicy::clear
void clear() override
Clears the QosPolicy object.
Definition QosPolicies.hpp:1949
eprosima::fastdds::dds::OwnershipStrengthQosPolicy::operator==
bool operator==(const OwnershipStrengthQosPolicy &b) const
Definition QosPolicies.hpp:1941
eprosima::fastdds::dds::Parameter_t
Base Parameter class with parameter PID and parameter length in bytes.
Definition ParameterTypes.hpp:198
eprosima::fastdds::dds::Parameter_t::Pid
ParameterId_t Pid
Parameter ID. By default, PID_PAD.
Definition ParameterTypes.hpp:241
eprosima::fastdds::dds::Parameter_t::Parameter_t
FASTDDS_EXPORTED_API Parameter_t()
Constructor without parameters.
Definition ParameterTypes.hpp:204
eprosima::fastdds::dds::Parameter_t::length
uint16_t length
Parameter length. By default, 0.
Definition ParameterTypes.hpp:243
eprosima::fastdds::dds::Parameter_t::operator==
bool operator==(const Parameter_t &b) const
Definition ParameterTypes.hpp:231
eprosima::fastdds::dds::Partition_t
Definition QosPolicies.hpp:1212
eprosima::fastdds::dds::Partition_t::PartitionQosPolicy
friend class PartitionQosPolicy
Definition QosPolicies.hpp:1214
eprosima::fastdds::dds::Partition_t::operator==
bool operator==(const Partition_t &rhs) const
Definition QosPolicies.hpp:1240
eprosima::fastdds::dds::Partition_t::operator!=
bool operator!=(const Partition_t &rhs) const
Definition QosPolicies.hpp:1247
eprosima::fastdds::dds::Partition_t::size
uint32_t size() const
Getter for the size.
Definition QosPolicies.hpp:1258
eprosima::fastdds::dds::Partition_t::name
const char * name() const
Getter for the partition name.
Definition QosPolicies.hpp:1268
eprosima::fastdds::dds::PartitionQosPolicy::const_iterator
Definition QosPolicies.hpp:1290
eprosima::fastdds::dds::PartitionQosPolicy::const_iterator::operator->
pointer operator->()
Definition QosPolicies.hpp:1331
eprosima::fastdds::dds::PartitionQosPolicy::const_iterator::difference_type
size_t difference_type
Definition QosPolicies.hpp:1297
eprosima::fastdds::dds::PartitionQosPolicy::const_iterator::operator++
self_type operator++()
Definition QosPolicies.hpp:1312
eprosima::fastdds::dds::PartitionQosPolicy::const_iterator::operator==
bool operator==(const self_type &rhs) const
Definition QosPolicies.hpp:1336
eprosima::fastdds::dds::PartitionQosPolicy::const_iterator::iterator_category
std::forward_iterator_tag iterator_category
Definition QosPolicies.hpp:1298
eprosima::fastdds::dds::PartitionQosPolicy::const_iterator::value_type
const Partition_t value_type
Definition QosPolicies.hpp:1294
eprosima::fastdds::dds::PartitionQosPolicy::const_iterator::operator!=
bool operator!=(const self_type &rhs) const
Definition QosPolicies.hpp:1342
eprosima::fastdds::dds::PartitionQosPolicy::const_iterator::operator*
reference operator*()
Definition QosPolicies.hpp:1326
eprosima::fastdds::dds::PartitionQosPolicy::const_iterator::reference
const Partition_t reference
Definition QosPolicies.hpp:1295
eprosima::fastdds::dds::PartitionQosPolicy::const_iterator::self_type
const_iterator self_type
Definition QosPolicies.hpp:1293
eprosima::fastdds::dds::PartitionQosPolicy::const_iterator::const_iterator
const_iterator(const fastdds::rtps::octet *ptr)
Constructor using a pointer.
Definition QosPolicies.hpp:1305
eprosima::fastdds::dds::PartitionQosPolicy::const_iterator::advance
void advance()
Shift the pointer to the next element.
Definition QosPolicies.hpp:1353
eprosima::fastdds::dds::PartitionQosPolicy::const_iterator::pointer
const Partition_t * pointer
Definition QosPolicies.hpp:1296
eprosima::fastdds::dds::PartitionQosPolicy
Set of strings that introduces a logical partition among the topics visible by the Publisher and Subs...
Definition QosPolicies.hpp:1286
eprosima::fastdds::dds::PartitionQosPolicy::operator==
bool operator==(const PartitionQosPolicy &b) const
Definition QosPolicies.hpp:1421
eprosima::fastdds::dds::PartitionQosPolicy::names
FASTDDS_EXPORTED_API const std::vector< std::string > names() const
Returns partition names.
Definition QosPolicies.hpp:1578
eprosima::fastdds::dds::PartitionQosPolicy::begin
const_iterator begin() const
Getter for the first position of the partition list.
Definition QosPolicies.hpp:1451
eprosima::fastdds::dds::PartitionQosPolicy::push_back
FASTDDS_EXPORTED_API void push_back(const char *name)
Appends a name to the list of partition names.
Definition QosPolicies.hpp:1513
eprosima::fastdds::dds::PartitionQosPolicy::size
uint32_t size() const
Getter for the number of partitions.
Definition QosPolicies.hpp:1471
eprosima::fastdds::dds::PartitionQosPolicy::getNames
FASTDDS_EXPORTED_API const std::vector< std::string > getNames() const
Returns partition names.
Definition QosPolicies.hpp:1557
eprosima::fastdds::dds::PartitionQosPolicy::max_size
uint32_t max_size() const
Getter for the maximum size (in bytes).
Definition QosPolicies.hpp:1503
eprosima::fastdds::dds::PartitionQosPolicy::~PartitionQosPolicy
virtual FASTDDS_EXPORTED_API ~PartitionQosPolicy()=default
Destructor.
eprosima::fastdds::dds::PartitionQosPolicy::setNames
FASTDDS_EXPORTED_API void setNames(std::vector< std::string > &nam)
Overrides partition names.
Definition QosPolicies.hpp:1567
eprosima::fastdds::dds::PartitionQosPolicy::set_max_size
void set_max_size(uint32_t size)
Setter for the maximum size reserved for partitions (in bytes).
Definition QosPolicies.hpp:1491
eprosima::fastdds::dds::PartitionQosPolicy::operator=
PartitionQosPolicy & operator=(const PartitionQosPolicy &b)
Definition QosPolicies.hpp:1431
eprosima::fastdds::dds::PartitionQosPolicy::end
const_iterator end() const
Getter for the end of the partition list.
Definition QosPolicies.hpp:1461
eprosima::fastdds::dds::PartitionQosPolicy::empty
uint32_t empty() const
Check if the set is empty.
Definition QosPolicies.hpp:1481
eprosima::fastdds::dds::PartitionQosPolicy::clear
FASTDDS_EXPORTED_API void clear() override
Clears list of partition names.
Definition QosPolicies.hpp:1545
eprosima::fastdds::dds::PartitionQosPolicy::PartitionQosPolicy
FASTDDS_EXPORTED_API PartitionQosPolicy()
Constructor without parameters.
Definition QosPolicies.hpp:1375
eprosima::fastdds::dds::PresentationQosPolicy::coherent_access
bool coherent_access
Specifies support coherent access.
Definition QosPolicies.hpp:1201
eprosima::fastdds::dds::PresentationQosPolicy::~PresentationQosPolicy
virtual FASTDDS_EXPORTED_API ~PresentationQosPolicy()=default
Destructor.
eprosima::fastdds::dds::PresentationQosPolicy::operator==
bool operator==(const PresentationQosPolicy &b) const
Definition QosPolicies.hpp:1176
eprosima::fastdds::dds::PresentationQosPolicy::PresentationQosPolicy
FASTDDS_EXPORTED_API PresentationQosPolicy()
Constructor without parameters.
Definition QosPolicies.hpp:1162
eprosima::fastdds::dds::PresentationQosPolicy::ordered_access
bool ordered_access
Specifies support for ordered access to the samples received at the subscription end.
Definition QosPolicies.hpp:1207
eprosima::fastdds::dds::PresentationQosPolicy::access_scope
PresentationQosPolicyAccessScopeKind access_scope
Access Scope Kind By default, INSTANCE_PRESENTATION_QOS.
Definition QosPolicies.hpp:1195
eprosima::fastdds::dds::PresentationQosPolicy::clear
void clear() override
Clears the QosPolicy object.
Definition QosPolicies.hpp:1186
eprosima::fastdds::dds::PublishModeQosPolicy
Class PublishModeQosPolicy, defines the publication mode for a specific writer.
Definition QosPolicies.hpp:2020
eprosima::fastdds::dds::PublishModeQosPolicy::flow_controller_name
std::string flow_controller_name
Name of the flow controller used when publish mode kind is ASYNCHRONOUS_PUBLISH_MODE.
Definition QosPolicies.hpp:2030
eprosima::fastdds::dds::PublishModeQosPolicy::kind
PublishModeQosPolicyKind kind
PublishModeQosPolicyKind By default, SYNCHRONOUS_PUBLISH_MODE.
Definition QosPolicies.hpp:2024
eprosima::fastdds::dds::PublishModeQosPolicy::operator==
bool operator==(const PublishModeQosPolicy &b) const
Definition QosPolicies.hpp:2038
eprosima::fastdds::dds::PublishModeQosPolicy::clear
void clear() override
Clears the QosPolicy object.
Definition QosPolicies.hpp:2032
eprosima::fastdds::dds::QosPolicy
Definition QosPolicies.hpp:111
eprosima::fastdds::dds::QosPolicy::hasChanged
bool hasChanged
Boolean that indicates if the Qos has been changed with respect to the default Qos.
Definition QosPolicies.hpp:115
eprosima::fastdds::dds::QosPolicy::QosPolicy
QosPolicy(bool send_always)
Constructor.
Definition QosPolicies.hpp:131
eprosima::fastdds::dds::QosPolicy::send_always_
bool send_always_
Boolean that indicates if the Qos has to be sent even if it is not changed.
Definition QosPolicies.hpp:179
eprosima::fastdds::dds::QosPolicy::clear
virtual void clear()=0
Clears the QosPolicy object.
eprosima::fastdds::dds::QosPolicy::QosPolicy
QosPolicy(const QosPolicy &b)=default
Copy Constructor.
eprosima::fastdds::dds::QosPolicy::operator=
QosPolicy & operator=(const QosPolicy &b)=default
eprosima::fastdds::dds::QosPolicy::send_always
virtual bool send_always() const
Whether it should always be sent.
Definition QosPolicies.hpp:166
eprosima::fastdds::dds::QosPolicy::QosPolicy
QosPolicy()
Constructor without parameters.
Definition QosPolicies.hpp:120
eprosima::fastdds::dds::QosPolicy::~QosPolicy
virtual ~QosPolicy()=default
Destructor.
eprosima::fastdds::dds::QosPolicy::operator==
bool operator==(const QosPolicy &b) const
Definition QosPolicies.hpp:151
eprosima::fastdds::dds::RTPSEndpointQos
Definition QosPolicies.hpp:2834
eprosima::fastdds::dds::RTPSEndpointQos::external_unicast_locators
fastdds::rtps::ExternalLocators external_unicast_locators
The collection of external locators to use for communication.
Definition QosPolicies.hpp:2870
eprosima::fastdds::dds::RTPSEndpointQos::entity_id
int16_t entity_id
Entity ID, if the user wants to specify the EntityID of the endpoint. By default,...
Definition QosPolicies.hpp:2879
eprosima::fastdds::dds::RTPSEndpointQos::history_memory_policy
fastdds::rtps::MemoryManagementPolicy_t history_memory_policy
Underlying History memory policy. By default, PREALLOCATED_WITH_REALLOC_MEMORY_MODE.
Definition QosPolicies.hpp:2882
eprosima::fastdds::dds::RTPSEndpointQos::user_defined_id
int16_t user_defined_id
User Defined ID, used for StaticEndpointDiscovery. By default, -1.
Definition QosPolicies.hpp:2876
eprosima::fastdds::dds::RTPSEndpointQos::multicast_locator_list
rtps::LocatorList multicast_locator_list
Multicast locator list.
Definition QosPolicies.hpp:2864
eprosima::fastdds::dds::RTPSEndpointQos::RTPSEndpointQos
FASTDDS_EXPORTED_API RTPSEndpointQos()=default
eprosima::fastdds::dds::RTPSEndpointQos::~RTPSEndpointQos
virtual FASTDDS_EXPORTED_API ~RTPSEndpointQos()=default
eprosima::fastdds::dds::RTPSEndpointQos::remote_locator_list
rtps::LocatorList remote_locator_list
Remote locator list.
Definition QosPolicies.hpp:2867
eprosima::fastdds::dds::RTPSEndpointQos::ignore_non_matching_locators
bool ignore_non_matching_locators
Whether locators that don't match with the announced locators should be kept.
Definition QosPolicies.hpp:2873
eprosima::fastdds::dds::RTPSEndpointQos::clear
void clear()
Definition QosPolicies.hpp:2841
eprosima::fastdds::dds::RTPSEndpointQos::operator==
bool operator==(const RTPSEndpointQos &b) const
Definition QosPolicies.hpp:2847
eprosima::fastdds::dds::RTPSEndpointQos::unicast_locator_list
rtps::LocatorList unicast_locator_list
Unicast locator list.
Definition QosPolicies.hpp:2861
eprosima::fastdds::dds::ReliabilityQosPolicy::ReliabilityQosPolicy
FASTDDS_EXPORTED_API ReliabilityQosPolicy()
Constructor.
Definition QosPolicies.hpp:576
eprosima::fastdds::dds::ReliabilityQosPolicy::~ReliabilityQosPolicy
virtual FASTDDS_EXPORTED_API ~ReliabilityQosPolicy()=default
Destructor.
eprosima::fastdds::dds::ReliabilityQosPolicy::max_blocking_time
fastdds::dds::Duration_t max_blocking_time
Defines the maximum period of time certain methods will be blocked.
Definition QosPolicies.hpp:622
eprosima::fastdds::dds::ReliabilityQosPolicy::operator==
bool operator==(const ReliabilityQosPolicy &b) const
Definition QosPolicies.hpp:589
eprosima::fastdds::dds::ReliabilityQosPolicy::kind
ReliabilityQosPolicyKind kind
Defines the reliability kind of the endpoint.
Definition QosPolicies.hpp:610
eprosima::fastdds::dds::ReliabilityQosPolicy::clear
void clear() override
Clears the QosPolicy object.
Definition QosPolicies.hpp:598
eprosima::fastdds::dds::ResourceLimitsQosPolicy
Specifies the resources that the Service can consume in order to meet the requested QoS.
Definition QosPolicies.hpp:1703
eprosima::fastdds::dds::ResourceLimitsQosPolicy::operator==
bool operator==(const ResourceLimitsQosPolicy &b) const
Definition QosPolicies.hpp:1759
eprosima::fastdds::dds::ResourceLimitsQosPolicy::ResourceLimitsQosPolicy
FASTDDS_EXPORTED_API ResourceLimitsQosPolicy()
Constructor.
Definition QosPolicies.hpp:1743
eprosima::fastdds::dds::ResourceLimitsQosPolicy::max_samples_per_instance
int32_t max_samples_per_instance
Represents the maximum number of samples of any one instance a DataWriter(or DataReader) can manage.
Definition QosPolicies.hpp:1728
eprosima::fastdds::dds::ResourceLimitsQosPolicy::allocated_samples
int32_t allocated_samples
Number of samples currently allocated.
Definition QosPolicies.hpp:1733
eprosima::fastdds::dds::ResourceLimitsQosPolicy::extra_samples
int32_t extra_samples
Represents the extra number of samples available once the max_samples have been reached in the histor...
Definition QosPolicies.hpp:1738
eprosima::fastdds::dds::ResourceLimitsQosPolicy::max_samples
int32_t max_samples
Specifies the maximum number of data-samples the DataWriter (or DataReader) can manage across all the...
Definition QosPolicies.hpp:1714
eprosima::fastdds::dds::ResourceLimitsQosPolicy::~ResourceLimitsQosPolicy
virtual FASTDDS_EXPORTED_API ~ResourceLimitsQosPolicy()=default
Destructor.
eprosima::fastdds::dds::ResourceLimitsQosPolicy::max_instances
int32_t max_instances
Represents the maximum number of instances DataWriter (or DataReader) can manage.
Definition QosPolicies.hpp:1721
eprosima::fastdds::dds::ResourceLimitsQosPolicy::clear
void clear() override
Clears the QosPolicy object.
Definition QosPolicies.hpp:1770
eprosima::fastdds::dds::TimeBasedFilterQosPolicy
Filter that allows a DataReader to specify that it is interested only in (potentially) a subset of th...
Definition QosPolicies.hpp:1082
eprosima::fastdds::dds::TimeBasedFilterQosPolicy::minimum_separation
fastdds::dds::Duration_t minimum_separation
Minimum interval between samples. By default, dds::c_TimeZero (the DataReader is interested in all va...
Definition QosPolicies.hpp:1117
eprosima::fastdds::dds::TimeBasedFilterQosPolicy::TimeBasedFilterQosPolicy
FASTDDS_EXPORTED_API TimeBasedFilterQosPolicy()
Constructor.
Definition QosPolicies.hpp:1088
eprosima::fastdds::dds::TransportConfigQos::user_transports
std::vector< std::shared_ptr< fastdds::rtps::TransportDescriptorInterface > > user_transports
User defined transports to use alongside or in place of builtins.
Definition QosPolicies.hpp:2800
eprosima::fastdds::dds::TransportConfigQos::operator==
bool operator==(const TransportConfigQos &b) const
Definition QosPolicies.hpp:2780
eprosima::fastdds::dds::TransportConfigQos::netmask_filter
fastdds::rtps::NetmaskFilterKind netmask_filter
Netmask filter configuration.
Definition QosPolicies.hpp:2828
eprosima::fastdds::dds::TransportConfigQos::listen_socket_buffer_size
uint32_t listen_socket_buffer_size
Listen socket buffer for all listen resources.
Definition QosPolicies.hpp:2814
eprosima::fastdds::dds::TransportConfigQos::use_builtin_transports
bool use_builtin_transports
Set as false to disable the default UDPv4 implementation. By default, true.
Definition QosPolicies.hpp:2803
eprosima::fastdds::dds::TransportConfigQos::max_msg_size_no_frag
uint32_t max_msg_size_no_frag
Maximum message size used to avoid fragmentation, set ONLY in LARGE_DATA.
Definition QosPolicies.hpp:2825
eprosima::fastdds::dds::TransportConfigQos::builtin_transports_reception_threads_
rtps::ThreadSettings builtin_transports_reception_threads_
Thread settings for the builtin transports reception threads.
Definition QosPolicies.hpp:2817
eprosima::fastdds::dds::TransportConfigQos::TransportConfigQos
FASTDDS_EXPORTED_API TransportConfigQos()
Constructor.
Definition QosPolicies.hpp:2765
eprosima::fastdds::dds::TransportConfigQos::send_socket_buffer_size
uint32_t send_socket_buffer_size
Send socket buffer size for the send resource.
Definition QosPolicies.hpp:2809
eprosima::fastdds::dds::TransportConfigQos::~TransportConfigQos
virtual FASTDDS_EXPORTED_API ~TransportConfigQos()=default
Destructor.
eprosima::fastdds::dds::TransportConfigQos::clear
void clear() override
Clears the QosPolicy object.
Definition QosPolicies.hpp:2793
eprosima::fastdds::dds::TransportPriorityQosPolicy
This policy is a hint to the infrastructure as to how to set the priority of the underlying transport...
Definition QosPolicies.hpp:1970
eprosima::fastdds::dds::TransportPriorityQosPolicy::operator==
bool operator==(const TransportPriorityQosPolicy &b) const
Definition QosPolicies.hpp:1991
eprosima::fastdds::dds::TransportPriorityQosPolicy::TransportPriorityQosPolicy
FASTDDS_EXPORTED_API TransportPriorityQosPolicy()
Constructor.
Definition QosPolicies.hpp:1979
eprosima::fastdds::dds::TransportPriorityQosPolicy::value
uint32_t value
Priority By default, 0.
Definition QosPolicies.hpp:1974
eprosima::fastdds::dds::TransportPriorityQosPolicy::clear
void clear() override
Clears the QosPolicy object.
Definition QosPolicies.hpp:1999
eprosima::fastdds::dds::TransportPriorityQosPolicy::~TransportPriorityQosPolicy
virtual FASTDDS_EXPORTED_API ~TransportPriorityQosPolicy()=default
Destructor.
eprosima::fastdds::dds::TypeConsistencyEnforcementQosPolicy
The TypeConsistencyEnforcementQosPolicy defines the rules for determining whether the type used to pu...
Definition QosPolicies.hpp:2134
eprosima::fastdds::dds::TypeConsistencyEnforcementQosPolicy::m_ignore_member_names
bool m_ignore_member_names
This option controls whether member names are taken into consideration for type assignability.
Definition QosPolicies.hpp:2163
eprosima::fastdds::dds::TypeConsistencyEnforcementQosPolicy::TypeConsistencyEnforcementQosPolicy
FASTDDS_EXPORTED_API TypeConsistencyEnforcementQosPolicy()
Constructor.
Definition QosPolicies.hpp:2180
eprosima::fastdds::dds::TypeConsistencyEnforcementQosPolicy::m_ignore_string_bounds
bool m_ignore_string_bounds
This option controls whether string bounds are taken into consideration for type assignability.
Definition QosPolicies.hpp:2156
eprosima::fastdds::dds::TypeConsistencyEnforcementQosPolicy::m_ignore_sequence_bounds
bool m_ignore_sequence_bounds
This option controls whether sequence bounds are taken into consideration for type assignability.
Definition QosPolicies.hpp:2147
eprosima::fastdds::dds::TypeConsistencyEnforcementQosPolicy::m_prevent_type_widening
bool m_prevent_type_widening
This option controls whether type widening is allowed.
Definition QosPolicies.hpp:2169
eprosima::fastdds::dds::TypeConsistencyEnforcementQosPolicy::operator==
bool operator==(const TypeConsistencyEnforcementQosPolicy &b) const
Definition QosPolicies.hpp:2197
eprosima::fastdds::dds::TypeConsistencyEnforcementQosPolicy::m_force_type_validation
bool m_force_type_validation
This option requires type information to be available in order to complete matching between a DataWri...
Definition QosPolicies.hpp:2175
eprosima::fastdds::dds::TypeConsistencyEnforcementQosPolicy::~TypeConsistencyEnforcementQosPolicy
virtual FASTDDS_EXPORTED_API ~TypeConsistencyEnforcementQosPolicy() override=default
Destructor.
eprosima::fastdds::dds::TypeConsistencyEnforcementQosPolicy::m_kind
TypeConsistencyKind m_kind
TypeConsistencyKind. By default, ALLOW_TYPE_COERCION.
Definition QosPolicies.hpp:2138
eprosima::fastdds::dds::TypeConsistencyEnforcementQosPolicy::clear
void clear() override
Clears the QosPolicy object.
Definition QosPolicies.hpp:2210
eprosima::fastdds::dds::TypeIdV1
Class TypeIdV1.
Definition QosPolicies.hpp:2270
eprosima::fastdds::dds::TypeIdV1::~TypeIdV1
virtual FASTDDS_EXPORTED_API ~TypeIdV1() override=default
Destructor.
eprosima::fastdds::dds::TypeIdV1::m_type_identifier
xtypes::TypeIdentifier m_type_identifier
Type Identifier.
Definition QosPolicies.hpp:2274
eprosima::fastdds::dds::TypeIdV1::TypeIdV1
FASTDDS_EXPORTED_API TypeIdV1()
Constructor without parameters.
Definition QosPolicies.hpp:2280
eprosima::fastdds::dds::TypeIdV1::operator=
FASTDDS_EXPORTED_API TypeIdV1 & operator=(const TypeIdV1 &type)
Definition QosPolicies.hpp:2326
eprosima::fastdds::dds::TypeIdV1::get
FASTDDS_EXPORTED_API const xtypes::TypeIdentifier & get() const
Getter for the TypeIndentifier.
Definition QosPolicies.hpp:2372
eprosima::fastdds::dds::TypeIdV1::clear
void clear() override
Clears the QosPolicy object.
Definition QosPolicies.hpp:2355
eprosima::fastdds::dds::TypeObjectV1
Class TypeObjectV1.
Definition QosPolicies.hpp:2383
eprosima::fastdds::dds::TypeObjectV1::~TypeObjectV1
virtual FASTDDS_EXPORTED_API ~TypeObjectV1() override=default
Destructor.
eprosima::fastdds::dds::TypeObjectV1::operator=
FASTDDS_EXPORTED_API TypeObjectV1 & operator=(const TypeObjectV1 &type)
Definition QosPolicies.hpp:2438
eprosima::fastdds::dds::TypeObjectV1::m_type_object
xtypes::TypeObject m_type_object
Type Object.
Definition QosPolicies.hpp:2387
eprosima::fastdds::dds::TypeObjectV1::TypeObjectV1
FASTDDS_EXPORTED_API TypeObjectV1()
Constructor.
Definition QosPolicies.hpp:2392
eprosima::fastdds::dds::TypeObjectV1::get
FASTDDS_EXPORTED_API const xtypes::TypeObject & get() const
Getter for the TypeObject.
Definition QosPolicies.hpp:2484
eprosima::fastdds::dds::TypeObjectV1::clear
void clear() override
Clears the QosPolicy object.
Definition QosPolicies.hpp:2467
eprosima::fastdds::dds::WireProtocolConfigQos::prefix
fastdds::rtps::GuidPrefix_t prefix
Optionally allows user to define the GuidPrefix_t.
Definition QosPolicies.hpp:2678
eprosima::fastdds::dds::WireProtocolConfigQos::WireProtocolConfigQos
FASTDDS_EXPORTED_API WireProtocolConfigQos()
Constructor.
Definition QosPolicies.hpp:2644
eprosima::fastdds::dds::WireProtocolConfigQos::default_multicast_locator_list
rtps::LocatorList default_multicast_locator_list
Default list of Multicast Locators to be used for any Endpoint defined inside this RTPSParticipant in...
Definition QosPolicies.hpp:2699
eprosima::fastdds::dds::WireProtocolConfigQos::builtin
fastdds::rtps::BuiltinAttributes builtin
Builtin parameters.
Definition QosPolicies.hpp:2684
eprosima::fastdds::dds::WireProtocolConfigQos::default_external_unicast_locators
rtps::ExternalLocators default_external_unicast_locators
The collection of external locators to use for communication on user created topics.
Definition QosPolicies.hpp:2704
eprosima::fastdds::dds::WireProtocolConfigQos::easy_mode
const std::string & easy_mode() const
Getter for ROS 2 Easy Mode IP.
Definition QosPolicies.hpp:2746
eprosima::fastdds::dds::WireProtocolConfigQos::ignore_non_matching_locators
bool ignore_non_matching_locators
Whether locators that don't match with the announced locators should be kept.
Definition QosPolicies.hpp:2709
eprosima::fastdds::dds::WireProtocolConfigQos::~WireProtocolConfigQos
virtual FASTDDS_EXPORTED_API ~WireProtocolConfigQos()=default
Destructor.
eprosima::fastdds::dds::WireProtocolConfigQos::easy_mode
ReturnCode_t easy_mode(const std::string &ip)
Setter for ROS 2 Easy Mode IP.
Definition QosPolicies.hpp:2720
eprosima::fastdds::dds::WireProtocolConfigQos::default_unicast_locator_list
rtps::LocatorList default_unicast_locator_list
Default list of Unicast Locators to be used for any Endpoint defined inside this RTPSParticipant in t...
Definition QosPolicies.hpp:2693
eprosima::fastdds::dds::WireProtocolConfigQos::port
fastdds::rtps::PortParameters port
Port Parameters.
Definition QosPolicies.hpp:2687
eprosima::fastdds::dds::WireProtocolConfigQos::clear
void clear() override
Clears the QosPolicy object.
Definition QosPolicies.hpp:2671
eprosima::fastdds::dds::WireProtocolConfigQos::operator==
bool operator==(const WireProtocolConfigQos &b) const
Definition QosPolicies.hpp:2656
eprosima::fastdds::dds::WireProtocolConfigQos::participant_id
int32_t participant_id
Participant ID By default, -1.
Definition QosPolicies.hpp:2681
eprosima::fastdds::dds::WriterResourceLimitsQos
Qos Policy to configure the limit of the writer resources.
Definition QosPolicies.hpp:2888
eprosima::fastdds::dds::WriterResourceLimitsQos::~WriterResourceLimitsQos
virtual FASTDDS_EXPORTED_API ~WriterResourceLimitsQos()=default
Destructor.
eprosima::fastdds::dds::WriterResourceLimitsQos::operator==
bool operator==(const WriterResourceLimitsQos &b) const
Definition QosPolicies.hpp:2911
eprosima::fastdds::dds::WriterResourceLimitsQos::reader_filters_allocation
fastdds::ResourceLimitedContainerConfig reader_filters_allocation
Reader filters allocation limits.
Definition QosPolicies.hpp:2921
eprosima::fastdds::dds::WriterResourceLimitsQos::WriterResourceLimitsQos
FASTDDS_EXPORTED_API WriterResourceLimitsQos()
Constructor.
Definition QosPolicies.hpp:2894
eprosima::fastdds::dds::WriterResourceLimitsQos::clear
void clear()
Definition QosPolicies.hpp:2905
eprosima::fastdds::dds::WriterResourceLimitsQos::matched_subscriber_allocation
fastdds::ResourceLimitedContainerConfig matched_subscriber_allocation
Matched subscribers allocation limits.
Definition QosPolicies.hpp:2919
eprosima::fastdds::dds::xtypes::TypeIdentifier
This class represents the union TypeIdentifier defined by the user in the IDL file.
Definition dds_xtypes_typeobject.hpp:2820
eprosima::fastdds::dds::xtypes::TypeInformation
This class represents the structure TypeInformation defined by the user in the IDL file.
Definition dds_xtypes_typeobject.hpp:24606
eprosima::fastdds::dds::xtypes::TypeInformationParameter
Class xtypes::TypeInformationParameter.
Definition QosPolicies.hpp:2497
eprosima::fastdds::dds::xtypes::TypeInformationParameter::TypeInformationParameter
FASTDDS_EXPORTED_API TypeInformationParameter()
Constructor.
Definition QosPolicies.hpp:2506
eprosima::fastdds::dds::xtypes::TypeInformationParameter::~TypeInformationParameter
virtual FASTDDS_EXPORTED_API ~TypeInformationParameter() override=default
Destructor.
eprosima::fastdds::dds::xtypes::TypeInformationParameter::type_information
eprosima::fastdds::dds::xtypes::TypeInformation type_information
Type Information.
Definition QosPolicies.hpp:2501
eprosima::fastdds::dds::xtypes::TypeInformationParameter::assigned
FASTDDS_EXPORTED_API bool assigned() const
Check if it is assigned.
Definition QosPolicies.hpp:2597
eprosima::fastdds::dds::xtypes::TypeInformationParameter::operator=
FASTDDS_EXPORTED_API TypeInformationParameter & operator=(const TypeInformationParameter &type)
Definition QosPolicies.hpp:2556
eprosima::fastdds::dds::xtypes::TypeInformationParameter::clear
void clear() override
Clears the QosPolicy object.
Definition QosPolicies.hpp:2587
eprosima::fastdds::dds::xtypes::TypeObject
This class represents the union TypeObject defined by the user in the IDL file.
Definition dds_xtypes_typeobject.hpp:23463
eprosima::fastdds::rtps::BuiltinAttributes
Class BuiltinAttributes, to define the behavior of the RTPSParticipant builtin protocols.
Definition RTPSParticipantAttributes.hpp:351
eprosima::fastdds::rtps::IPLocator::isIPv4
static FASTDDS_EXPORTED_API bool isIPv4(const std::string &address)
Check whether a string contains an IPv4 format.
eprosima::fastdds::rtps::LocatorList
Class LocatorList, a Locator vector that doesn't allow duplicates.
Definition LocatorList.hpp:97
eprosima::fastdds::rtps::PortParameters
Class PortParameters, to define the port parameters and gains related with the RTPS protocol.
Definition PortParameters.hpp:35
eprosima::fastdds::rtps::PropertyPolicy
Definition PropertyPolicy.hpp:30
eprosima::fastdds::dds::ParameterId_t
ParameterId_t
Enum for the unique parameter identifier.
Definition ParameterTypes.hpp:69
PARAMETER_TIME_LENGTH
#define PARAMETER_TIME_LENGTH
Definition ParameterTypes.hpp:949
PARAMETER_BOOL_LENGTH
#define PARAMETER_BOOL_LENGTH
Definition ParameterTypes.hpp:791
eprosima::fastdds::dds::PID_TOPIC_DATA
@ PID_TOPIC_DATA
Definition ParameterTypes.hpp:77
eprosima::fastdds::dds::PID_DURABILITY_SERVICE
@ PID_DURABILITY_SERVICE
Definition ParameterTypes.hpp:79
eprosima::fastdds::dds::PID_LIVELINESS
@ PID_LIVELINESS
Definition ParameterTypes.hpp:82
eprosima::fastdds::dds::PID_OWNERSHIP
@ PID_OWNERSHIP
Definition ParameterTypes.hpp:88
eprosima::fastdds::dds::PID_LATENCY_BUDGET
@ PID_LATENCY_BUDGET
Definition ParameterTypes.hpp:81
eprosima::fastdds::dds::PID_RESOURCE_LIMITS
@ PID_RESOURCE_LIMITS
Definition ParameterTypes.hpp:87
eprosima::fastdds::dds::PID_DATASHARING
@ PID_DATASHARING
Definition ParameterTypes.hpp:173
eprosima::fastdds::dds::PID_RELIABILITY
@ PID_RELIABILITY
Definition ParameterTypes.hpp:83
eprosima::fastdds::dds::PID_DURABILITY
@ PID_DURABILITY
Definition ParameterTypes.hpp:78
eprosima::fastdds::dds::PID_USER_DATA
@ PID_USER_DATA
Definition ParameterTypes.hpp:73
eprosima::fastdds::dds::PID_DEADLINE
@ PID_DEADLINE
Definition ParameterTypes.hpp:80
eprosima::fastdds::dds::PID_TYPE_IDV1
@ PID_TYPE_IDV1
Definition ParameterTypes.hpp:142
eprosima::fastdds::dds::PID_TYPE_INFORMATION
@ PID_TYPE_INFORMATION
Definition ParameterTypes.hpp:146
eprosima::fastdds::dds::PID_DESTINATION_ORDER
@ PID_DESTINATION_ORDER
Definition ParameterTypes.hpp:85
eprosima::fastdds::dds::PID_PRESENTATION
@ PID_PRESENTATION
Definition ParameterTypes.hpp:90
eprosima::fastdds::dds::PID_LIFESPAN
@ PID_LIFESPAN
Definition ParameterTypes.hpp:84
eprosima::fastdds::dds::PID_DISABLE_POSITIVE_ACKS
@ PID_DISABLE_POSITIVE_ACKS
Definition ParameterTypes.hpp:172
eprosima::fastdds::dds::PID_TYPE_CONSISTENCY_ENFORCEMENT
@ PID_TYPE_CONSISTENCY_ENFORCEMENT
Definition ParameterTypes.hpp:145
eprosima::fastdds::dds::PID_OWNERSHIP_STRENGTH
@ PID_OWNERSHIP_STRENGTH
Definition ParameterTypes.hpp:89
eprosima::fastdds::dds::PID_PARTITION
@ PID_PARTITION
Definition ParameterTypes.hpp:91
eprosima::fastdds::dds::PID_TRANSPORT_PRIORITY
@ PID_TRANSPORT_PRIORITY
Definition ParameterTypes.hpp:93
eprosima::fastdds::dds::PID_TIME_BASED_FILTER
@ PID_TIME_BASED_FILTER
Definition ParameterTypes.hpp:92
eprosima::fastdds::dds::PID_GROUP_DATA
@ PID_GROUP_DATA
Definition ParameterTypes.hpp:76
eprosima::fastdds::dds::PID_HISTORY
@ PID_HISTORY
Definition ParameterTypes.hpp:86
eprosima::fastdds::dds::PID_TYPE_OBJECTV1
@ PID_TYPE_OBJECTV1
Definition ParameterTypes.hpp:143
eprosima::fastdds::dds::PID_DATA_REPRESENTATION
@ PID_DATA_REPRESENTATION
Definition ParameterTypes.hpp:144
eprosima::fastdds::dds::xtypes
Definition QosPolicies.hpp:2491
eprosima::fastdds::dds
Definition BuiltinTopicKey.hpp:26
eprosima::fastdds::dds::QosPolicyId_t
QosPolicyId_t
The identifier for each QosPolicy.
Definition QosPolicies.hpp:56
eprosima::fastdds::dds::HISTORY_QOS_POLICY_ID
@ HISTORY_QOS_POLICY_ID
Definition QosPolicies.hpp:72
eprosima::fastdds::dds::TIMEBASEDFILTER_QOS_POLICY_ID
@ TIMEBASEDFILTER_QOS_POLICY_ID
Definition QosPolicies.hpp:68
eprosima::fastdds::dds::TRANSPORTPRIORITY_QOS_POLICY_ID
@ TRANSPORTPRIORITY_QOS_POLICY_ID
Definition QosPolicies.hpp:79
eprosima::fastdds::dds::RESOURCELIMITS_QOS_POLICY_ID
@ RESOURCELIMITS_QOS_POLICY_ID
Definition QosPolicies.hpp:73
eprosima::fastdds::dds::DATAREPRESENTATION_QOS_POLICY_ID
@ DATAREPRESENTATION_QOS_POLICY_ID
Definition QosPolicies.hpp:84
eprosima::fastdds::dds::RELIABILITY_QOS_POLICY_ID
@ RELIABILITY_QOS_POLICY_ID
Definition QosPolicies.hpp:70
eprosima::fastdds::dds::PUBLISHMODE_QOS_POLICY_ID
@ PUBLISHMODE_QOS_POLICY_ID
Definition QosPolicies.hpp:91
eprosima::fastdds::dds::RTPSRELIABLEREADER_QOS_POLICY_ID
@ RTPSRELIABLEREADER_QOS_POLICY_ID
Definition QosPolicies.hpp:94
eprosima::fastdds::dds::LATENCYBUDGET_QOS_POLICY_ID
@ LATENCYBUDGET_QOS_POLICY_ID
Definition QosPolicies.hpp:64
eprosima::fastdds::dds::NEXT_QOS_POLICY_ID
@ NEXT_QOS_POLICY_ID
Definition QosPolicies.hpp:101
eprosima::fastdds::dds::PRESENTATION_QOS_POLICY_ID
@ PRESENTATION_QOS_POLICY_ID
Definition QosPolicies.hpp:62
eprosima::fastdds::dds::TYPECONSISTENCYENFORCEMENT_QOS_POLICY_ID
@ TYPECONSISTENCYENFORCEMENT_QOS_POLICY_ID
Definition QosPolicies.hpp:85
eprosima::fastdds::dds::ENTITYFACTORY_QOS_POLICY_ID
@ ENTITYFACTORY_QOS_POLICY_ID
Definition QosPolicies.hpp:74
eprosima::fastdds::dds::TRANSPORTCONFIG_QOS_POLICY_ID
@ TRANSPORTCONFIG_QOS_POLICY_ID
Definition QosPolicies.hpp:96
eprosima::fastdds::dds::USERDATA_QOS_POLICY_ID
@ USERDATA_QOS_POLICY_ID
Definition QosPolicies.hpp:60
eprosima::fastdds::dds::WRITERRESOURCELIMITS_QOS_POLICY_ID
@ WRITERRESOURCELIMITS_QOS_POLICY_ID
Definition QosPolicies.hpp:99
eprosima::fastdds::dds::WRITERDATALIFECYCLE_QOS_POLICY_ID
@ WRITERDATALIFECYCLE_QOS_POLICY_ID
Definition QosPolicies.hpp:75
eprosima::fastdds::dds::PARTITION_QOS_POLICY_ID
@ PARTITION_QOS_POLICY_ID
Definition QosPolicies.hpp:69
eprosima::fastdds::dds::READERDATALIFECYCLE_QOS_POLICY_ID
@ READERDATALIFECYCLE_QOS_POLICY_ID
Definition QosPolicies.hpp:76
eprosima::fastdds::dds::RTPSENDPOINT_QOS_POLICY_ID
@ RTPSENDPOINT_QOS_POLICY_ID
Definition QosPolicies.hpp:93
eprosima::fastdds::dds::RTPSRELIABLEWRITER_QOS_POLICY_ID
@ RTPSRELIABLEWRITER_QOS_POLICY_ID
Definition QosPolicies.hpp:95
eprosima::fastdds::dds::DISABLEPOSITIVEACKS_QOS_POLICY_ID
@ DISABLEPOSITIVEACKS_QOS_POLICY_ID
Definition QosPolicies.hpp:88
eprosima::fastdds::dds::PARTICIPANTRESOURCELIMITS_QOS_POLICY_ID
@ PARTICIPANTRESOURCELIMITS_QOS_POLICY_ID
Definition QosPolicies.hpp:89
eprosima::fastdds::dds::GROUPDATA_QOS_POLICY_ID
@ GROUPDATA_QOS_POLICY_ID
Definition QosPolicies.hpp:78
eprosima::fastdds::dds::TYPECONSISTENCY_QOS_POLICY_ID
@ TYPECONSISTENCY_QOS_POLICY_ID
Definition QosPolicies.hpp:97
eprosima::fastdds::dds::LIVELINESS_QOS_POLICY_ID
@ LIVELINESS_QOS_POLICY_ID
Definition QosPolicies.hpp:67
eprosima::fastdds::dds::OWNERSHIP_QOS_POLICY_ID
@ OWNERSHIP_QOS_POLICY_ID
Definition QosPolicies.hpp:65
eprosima::fastdds::dds::OWNERSHIPSTRENGTH_QOS_POLICY_ID
@ OWNERSHIPSTRENGTH_QOS_POLICY_ID
Definition QosPolicies.hpp:66
eprosima::fastdds::dds::LIFESPAN_QOS_POLICY_ID
@ LIFESPAN_QOS_POLICY_ID
Definition QosPolicies.hpp:80
eprosima::fastdds::dds::READERRESOURCELIMITS_QOS_POLICY_ID
@ READERRESOURCELIMITS_QOS_POLICY_ID
Definition QosPolicies.hpp:92
eprosima::fastdds::dds::WIREPROTOCOLCONFIG_QOS_POLICY_ID
@ WIREPROTOCOLCONFIG_QOS_POLICY_ID
Definition QosPolicies.hpp:98
eprosima::fastdds::dds::DEADLINE_QOS_POLICY_ID
@ DEADLINE_QOS_POLICY_ID
Definition QosPolicies.hpp:63
eprosima::fastdds::dds::TOPICDATA_QOS_POLICY_ID
@ TOPICDATA_QOS_POLICY_ID
Definition QosPolicies.hpp:77
eprosima::fastdds::dds::DESTINATIONORDER_QOS_POLICY_ID
@ DESTINATIONORDER_QOS_POLICY_ID
Definition QosPolicies.hpp:71
eprosima::fastdds::dds::DURABILITYSERVICE_QOS_POLICY_ID
@ DURABILITYSERVICE_QOS_POLICY_ID
Definition QosPolicies.hpp:81
eprosima::fastdds::dds::DURABILITY_QOS_POLICY_ID
@ DURABILITY_QOS_POLICY_ID
Definition QosPolicies.hpp:61
eprosima::fastdds::dds::INVALID_QOS_POLICY_ID
@ INVALID_QOS_POLICY_ID
Definition QosPolicies.hpp:57
eprosima::fastdds::dds::PROPERTYPOLICY_QOS_POLICY_ID
@ PROPERTYPOLICY_QOS_POLICY_ID
Definition QosPolicies.hpp:90
eprosima::fastdds::dds::DataSharingKind
DataSharingKind
Data sharing configuration kinds.
Definition QosPolicies.hpp:2928
eprosima::fastdds::dds::ON
@ ON
Activate the use of DataSharing.
Definition QosPolicies.hpp:2938
eprosima::fastdds::dds::OFF
@ OFF
Disable the use of DataSharing.
Definition QosPolicies.hpp:2942
eprosima::fastdds::dds::AUTO
@ AUTO
Automatic configuration.
Definition QosPolicies.hpp:2933
eprosima::fastdds::dds::RETCODE_BAD_PARAMETER
const ReturnCode_t RETCODE_BAD_PARAMETER
Definition DDSReturnCode.hpp:64
eprosima::fastdds::dds::operator==
static bool operator==(const Time_t &t1, const Time_t &t2)
Comparison assignment.
Definition Time_t.hpp:101
eprosima::fastdds::dds::PolicyMask
std::bitset< NEXT_QOS_POLICY_ID > PolicyMask
Definition QosPolicies.hpp:104
eprosima::fastdds::dds::LivelinessQosPolicyKind
LivelinessQosPolicyKind
Enum LivelinessQosPolicyKind, different kinds of liveliness for LivelinessQosPolicy.
Definition QosPolicies.hpp:458
eprosima::fastdds::dds::AUTOMATIC_LIVELINESS_QOS
@ AUTOMATIC_LIVELINESS_QOS
The infrastructure will automatically signal liveliness for the DataWriters at least as often as requ...
Definition QosPolicies.hpp:462
eprosima::fastdds::dds::MANUAL_BY_PARTICIPANT_LIVELINESS_QOS
@ MANUAL_BY_PARTICIPANT_LIVELINESS_QOS
The Service will assume that as long as at least one Entity within the DomainParticipant has asserted...
Definition QosPolicies.hpp:467
eprosima::fastdds::dds::MANUAL_BY_TOPIC_LIVELINESS_QOS
@ MANUAL_BY_TOPIC_LIVELINESS_QOS
The Service will only assume liveliness of the DataWriter if the application has asserted liveliness ...
Definition QosPolicies.hpp:471
eprosima::fastdds::dds::LENGTH_UNLIMITED
const int32_t LENGTH_UNLIMITED
Definition Types.hpp:28
eprosima::fastdds::dds::TypeConsistencyKind
TypeConsistencyKind
Definition QosPolicies.hpp:2115
eprosima::fastdds::dds::ALLOW_TYPE_COERCION
@ ALLOW_TYPE_COERCION
The DataWriter and the DataReader need not support the same data type in order for them to communicat...
Definition QosPolicies.hpp:2124
eprosima::fastdds::dds::DISALLOW_TYPE_COERCION
@ DISALLOW_TYPE_COERCION
The DataWriter and the DataReader must support the same data type in order for them to communicate.
Definition QosPolicies.hpp:2119
eprosima::fastdds::dds::ReliabilityQosPolicyKind
ReliabilityQosPolicyKind
Enum ReliabilityQosPolicyKind, different kinds of reliability for ReliabilityQosPolicy.
Definition QosPolicies.hpp:548
eprosima::fastdds::dds::RELIABLE_RELIABILITY_QOS
@ RELIABLE_RELIABILITY_QOS
Specifies the Service will attempt to deliver all samples in its history.
Definition QosPolicies.hpp:561
eprosima::fastdds::dds::BEST_EFFORT_RELIABILITY_QOS
@ BEST_EFFORT_RELIABILITY_QOS
Indicates that it is acceptable to not retry propagation of any samples.
Definition QosPolicies.hpp:553
eprosima::fastdds::dds::DataRepresentationId_t
enum eprosima::fastdds::dds::DataRepresentationId DataRepresentationId_t
Enum DataRepresentationId, different kinds of topic data representation.
eprosima::fastdds::dds::DurabilityQosPolicyKind_t
enum eprosima::fastdds::dds::DurabilityQosPolicyKind DurabilityQosPolicyKind_t
Enum DurabilityQosPolicyKind_t, different kinds of durability for DurabilityQosPolicy.
eprosima::fastdds::dds::OwnershipQosPolicyKind
OwnershipQosPolicyKind
Enum OwnershipQosPolicyKind, different kinds of ownership for OwnershipQosPolicy.
Definition QosPolicies.hpp:631
eprosima::fastdds::dds::SHARED_OWNERSHIP_QOS
@ SHARED_OWNERSHIP_QOS
Indicates shared ownership for each instance.
Definition QosPolicies.hpp:636
eprosima::fastdds::dds::EXCLUSIVE_OWNERSHIP_QOS
@ EXCLUSIVE_OWNERSHIP_QOS
Indicates each instance can only be owned by one DataWriter, but the owner of an instance can change ...
Definition QosPolicies.hpp:642
eprosima::fastdds::dds::Duration_t
Time_t Duration_t
Definition Time_t.hpp:91
eprosima::fastdds::dds::PropertyPolicyQos
fastdds::rtps::PropertyPolicy PropertyPolicyQos
Property policies.
Definition QosPolicies.hpp:2633
eprosima::fastdds::dds::PublishModeQosPolicyKind
PublishModeQosPolicyKind
Enum PublishModeQosPolicyKind, different kinds of publication synchronism.
Definition QosPolicies.hpp:2011
eprosima::fastdds::dds::ASYNCHRONOUS_PUBLISH_MODE
@ ASYNCHRONOUS_PUBLISH_MODE
Asynchronous publication mode.
Definition QosPolicies.hpp:2013
eprosima::fastdds::dds::SYNCHRONOUS_PUBLISH_MODE
@ SYNCHRONOUS_PUBLISH_MODE
Synchronous publication mode (default for writers).
Definition QosPolicies.hpp:2012
eprosima::fastdds::dds::RETCODE_OK
const ReturnCode_t RETCODE_OK
Definition DDSReturnCode.hpp:61
eprosima::fastdds::dds::ParticipantResourceLimitsQos
fastdds::rtps::RTPSParticipantAllocationAttributes ParticipantResourceLimitsQos
Holds allocation limits affecting collections managed by a participant.
Definition QosPolicies.hpp:2630
eprosima::fastdds::dds::ReturnCode_t
int32_t ReturnCode_t
Definition DDSReturnCode.hpp:59
eprosima::fastdds::dds::PresentationQosPolicyAccessScopeKind
PresentationQosPolicyAccessScopeKind
Enum PresentationQosPolicyAccessScopeKind, different kinds of Presentation Policy order for Presentat...
Definition QosPolicies.hpp:1124
eprosima::fastdds::dds::INSTANCE_PRESENTATION_QOS
@ INSTANCE_PRESENTATION_QOS
Scope spans only a single instance.
Definition QosPolicies.hpp:1130
eprosima::fastdds::dds::TOPIC_PRESENTATION_QOS
@ TOPIC_PRESENTATION_QOS
Scope spans to all instances within the same DataWriter (or DataReader), but not across instances in ...
Definition QosPolicies.hpp:1135
eprosima::fastdds::dds::GROUP_PRESENTATION_QOS
@ GROUP_PRESENTATION_QOS
Scope spans to all instances belonging to DataWriter (or DataReader) entities within the same Publish...
Definition QosPolicies.hpp:1139
eprosima::fastdds::dds::FASTDDS_TODO_BEFORE
FASTDDS_TODO_BEFORE(4, 0, "Remove 'hasChanged' and 'send_always_' as they were replaced by 'should_be_sent'.")
Class QosPolicy, base for all QoS policies defined for Writers and Readers.
eprosima::fastdds::dds::DEFAULT_DATA_REPRESENTATION
constexpr DataRepresentationId_t DEFAULT_DATA_REPRESENTATION
Default DataRepresentationId used in Fast DDS.
Definition QosPolicies.hpp:2059
eprosima::fastdds::dds::DurabilityQosPolicyKind
DurabilityQosPolicyKind
Enum DurabilityQosPolicyKind_t, different kinds of durability for DurabilityQosPolicy.
Definition QosPolicies.hpp:244
eprosima::fastdds::dds::TRANSIENT_LOCAL_DURABILITY_QOS
@ TRANSIENT_LOCAL_DURABILITY_QOS
For TRANSIENT_LOCAL, the service is only required to keep the data in the memory of the DataWriter th...
Definition QosPolicies.hpp:255
eprosima::fastdds::dds::TRANSIENT_DURABILITY_QOS
@ TRANSIENT_DURABILITY_QOS
For TRANSIENT, the service is only required to keep the data in memory and not in permanent storage; ...
Definition QosPolicies.hpp:260
eprosima::fastdds::dds::PERSISTENT_DURABILITY_QOS
@ PERSISTENT_DURABILITY_QOS
Data is kept on permanent storage, so that they can outlive a system session.
Definition QosPolicies.hpp:266
eprosima::fastdds::dds::VOLATILE_DURABILITY_QOS
@ VOLATILE_DURABILITY_QOS
The Service does not need to keep any samples of data-instances on behalf of any DataReader that is n...
Definition QosPolicies.hpp:250
eprosima::fastdds::dds::HistoryQosPolicyKind
HistoryQosPolicyKind
Enum HistoryQosPolicyKind, different kinds of History Qos for HistoryQosPolicy.
Definition QosPolicies.hpp:1621
eprosima::fastdds::dds::KEEP_LAST_HISTORY_QOS
@ KEEP_LAST_HISTORY_QOS
On the publishing side, the Service will only attempt to keep the most recent “depth” samples of each...
Definition QosPolicies.hpp:1628
eprosima::fastdds::dds::KEEP_ALL_HISTORY_QOS
@ KEEP_ALL_HISTORY_QOS
On the publishing side, the Service will attempt to keep all samples (representing each value written...
Definition QosPolicies.hpp:1636
eprosima::fastdds::dds::DestinationOrderQosPolicyKind
DestinationOrderQosPolicyKind
Enum DestinationOrderQosPolicyKind, different kinds of destination order for DestinationOrderQosPolic...
Definition QosPolicies.hpp:694
eprosima::fastdds::dds::BY_SOURCE_TIMESTAMP_DESTINATIONORDER_QOS
@ BY_SOURCE_TIMESTAMP_DESTINATIONORDER_QOS
Indicates that data is ordered based on a timestamp placed at the source (by the Service or by the ap...
Definition QosPolicies.hpp:705
eprosima::fastdds::dds::BY_RECEPTION_TIMESTAMP_DESTINATIONORDER_QOS
@ BY_RECEPTION_TIMESTAMP_DESTINATIONORDER_QOS
Indicates that data is ordered based on the reception time at each Subscriber.
Definition QosPolicies.hpp:700
eprosima::fastdds::dds::PublishModeQosPolicyKind_t
enum eprosima::fastdds::dds::PublishModeQosPolicyKind PublishModeQosPolicyKind_t
Enum PublishModeQosPolicyKind, different kinds of publication synchronism.
eprosima::fastdds::dds::DataRepresentationId
DataRepresentationId
Enum DataRepresentationId, different kinds of topic data representation.
Definition QosPolicies.hpp:2052
eprosima::fastdds::dds::XCDR2_DATA_REPRESENTATION
@ XCDR2_DATA_REPRESENTATION
Extended CDR Encoding version 2.
Definition QosPolicies.hpp:2055
eprosima::fastdds::dds::XML_DATA_REPRESENTATION
@ XML_DATA_REPRESENTATION
XML Data Representation (Unsupported).
Definition QosPolicies.hpp:2054
eprosima::fastdds::dds::XCDR_DATA_REPRESENTATION
@ XCDR_DATA_REPRESENTATION
Extended CDR Encoding version 1.
Definition QosPolicies.hpp:2053
eprosima::fastdds::rtps::octet
unsigned char octet
Definition Types.hpp:83
eprosima::fastdds::rtps::FASTDDS_FLOW_CONTROLLER_DEFAULT
FASTDDS_EXPORTED_API const char *const FASTDDS_FLOW_CONTROLLER_DEFAULT
Name of the default flow controller.
eprosima::fastdds::rtps::NetmaskFilterKind
NetmaskFilterKind
Definition NetmaskFilterKind.hpp:31
eprosima::fastdds::rtps::NetmaskFilterKind::AUTO
@ AUTO
Definition NetmaskFilterKind.hpp:33
eprosima::fastdds::rtps::ExternalLocators
std::map< uint8_t, std::map< uint8_t, std::vector< LocatorWithMask > >, std::greater< uint8_t > > ExternalLocators
A collection of LocatorWithMask grouped by externality and cost.
Definition ExternalLocators.hpp:34
eprosima::fastdds::rtps::MemoryManagementPolicy_t
enum eprosima::fastdds::rtps::MemoryManagementPolicy MemoryManagementPolicy_t
Enum MemoryuManagementPolicy_t, indicated the way memory is managed in terms of dealing with CacheCha...
eprosima::fastdds::rtps::PREALLOCATED_WITH_REALLOC_MEMORY_MODE
@ PREALLOCATED_WITH_REALLOC_MEMORY_MODE
Default size preallocated, requires reallocation when a bigger message arrives.
Definition ResourceManagement.hpp:35
eprosima::fastdds::rtps::DurabilityKind_t
DurabilityKind_t
Durability kind.
Definition Types.hpp:56
eprosima::fastdds::rtps::TRANSIENT
@ TRANSIENT
Transient Durability.
Definition Types.hpp:59
eprosima::fastdds::rtps::TRANSIENT_LOCAL
@ TRANSIENT_LOCAL
Transient Local Durability.
Definition Types.hpp:58
eprosima::fastdds::rtps::PERSISTENT
@ PERSISTENT
NOT IMPLEMENTED.
Definition Types.hpp:60
eprosima::fastdds::rtps::VOLATILE
@ VOLATILE
Volatile Durability.
Definition Types.hpp:57
eprosima::fastdds
eprosima
eProsima namespace.
std
Definition EntityId_t.hpp:388
eprosima::fastdds::ResourceLimitedContainerConfig
Specifies the configuration of a resource limited collection.
Definition ResourceLimitedContainerConfig.hpp:36
eprosima::fastdds::ResourceLimitedContainerConfig::dynamic_allocation_configuration
static ResourceLimitedContainerConfig dynamic_allocation_configuration(size_t increment=1u)
Return a resource limits configuration for a linearly growing, dynamically allocated collection.
Definition ResourceLimitedContainerConfig.hpp:71
eprosima::fastdds::ResourceLimitedContainerConfig::fixed_size_configuration
static ResourceLimitedContainerConfig fixed_size_configuration(size_t size)
Return a resource limits configuration for a fixed size collection.
Definition ResourceLimitedContainerConfig.hpp:60
eprosima::fastdds::rtps::GuidPrefix_t
Structure GuidPrefix_t, Guid Prefix of GUID_t.
Definition GuidPrefix_t.hpp:37
eprosima::fastdds::rtps::RTPSParticipantAllocationAttributes
Holds allocation limits affecting collections managed by a participant.
Definition RTPSParticipantAllocationAttributes.hpp:129
eprosima::fastdds::rtps::SerializedPayload_t
Structure SerializedPayload_t.
Definition SerializedPayload.hpp:59
eprosima::fastdds::rtps::SerializedPayload_t::data
octet * data
Pointer to the data.
Definition SerializedPayload.hpp:68
eprosima::fastdds::rtps::SerializedPayload_t::max_size
uint32_t max_size
Maximum size of the payload.
Definition SerializedPayload.hpp:70
eprosima::fastdds::rtps::SerializedPayload_t::reserve
void reserve(uint32_t new_size)
eprosima::fastdds::rtps::SerializedPayload_t::length
uint32_t length
Actual length of the data.
Definition SerializedPayload.hpp:66
eprosima::fastdds::rtps::ThreadSettings
Struct ThreadSettings to specify various thread settings.
Definition ThreadSettings.hpp:37