.. _program_listing_file__tmp_ws_src_fastrtps_include_dds_core_policy_CorePolicy.hpp:

Program Listing for File CorePolicy.hpp
=======================================

|exhale_lsh| :ref:`Return to documentation for file <file__tmp_ws_src_fastrtps_include_dds_core_policy_CorePolicy.hpp>` (``/tmp/ws/src/fastrtps/include/dds/core/policy/CorePolicy.hpp``)

.. |exhale_lsh| unicode:: U+021B0 .. UPWARDS ARROW WITH TIP LEFTWARDS

.. code-block:: cpp

   /*
    * Copyright 2010, Object Management Group, Inc.
    * Copyright 2010, PrismTech, Corp.
    * Copyright 2010, Real-Time Innovations, Inc.
    * Copyright 2019, Proyectos y Sistemas de Mantenimiento SL (eProsima).
    * All rights reserved.
    *
    * Licensed under the Apache License, Version 2.0 (the "License");
    * you may not use this file except in compliance with the License.
    * You may obtain a copy of the License at
    *
    *     http://www.apache.org/licenses/LICENSE-2.0
    *
    * Unless required by applicable law or agreed to in writing, software
    * distributed under the License is distributed on an "AS IS" BASIS,
    * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
    * See the License for the specific language governing permissions and
    * limitations under the License.
    */
   
   #ifndef OMG_DDS_CORE_POLICY_CORE_POLICY_HPP_
   #define OMG_DDS_CORE_POLICY_CORE_POLICY_HPP_
   
   #include <dds/core/policy/PolicyKind.hpp>
   #include <dds/core/policy/detail/CorePolicy.hpp>
   #include <dds/core/policy/QosPolicyCount.hpp>
   
   #include <dds/core/detail/inttypes.hpp>
   #include <dds/core/types.hpp>
   #include <dds/core/LengthUnlimited.hpp>
   #include <dds/core/detail/Value.hpp>
   #include <dds/core/Duration.hpp>
   
   //==============================================================================
   // MACROS
   // *INDENT-OFF*
   #define OMG_DDS_POLICY_TRAITS(POLICY, ID) \
       template<> \
       class policy_id<POLICY> { \
       public: \
           static const dds::core::policy::QosPolicyId value = ID; \
       }; \
       template<> \
       class policy_name<POLICY> { \
       public: \
           static const std::string& name(); \
       };
   
   #define OMG_DDS_DEFINE_POLICY_TRAITS(POLICY, NAME) \
       const std::string& dds::core::policy::policy_name<POLICY>::name() { \
           static std::string name = #NAME; \
           return name; \
       }
   // *INDENT-OFF*
   
   
   namespace dds {
   namespace core {
   namespace policy {
   
   //==============================================================================
   class UserData : public dds::core::Value<detail::UserData>
   {
   public:
   
       UserData();
   
       explicit UserData(
               const dds::core::ByteSeq& sequence);
   
       UserData(
               const uint8_t* value_begin,
               const uint8_t* value_end);
   
       UserData(
               const UserData& other);
   
       UserData& value(
               const dds::core::ByteSeq& sequence);
   
       template<typename OCTET_ITER>
       UserData& value(
               OCTET_ITER begin,
               OCTET_ITER end);
   
       const dds::core::ByteSeq value() const;
   
       const uint8_t* begin() const;
   
       const uint8_t* end() const;
   };
   
   //==============================================================================
   
   class GroupData : public dds::core::Value<detail::GroupData>
   {
   public:
   
       GroupData();
   
       explicit GroupData(
               const dds::core::ByteSeq& sequence);
   
       GroupData(
               const GroupData& other);
   
       GroupData(
               const uint8_t* value_begin,
               const uint8_t* value_end);
   
       GroupData& value(
               const dds::core::ByteSeq& sequence);
   
       template<typename OCTET_ITER>
       GroupData& value(
               OCTET_ITER begin,
               OCTET_ITER end);
   
       const dds::core::ByteSeq value() const;
   
       const uint8_t* begin() const;
   
       const uint8_t* end() const;
   };
   
   //==============================================================================
   
   class TopicData : public dds::core::Value<detail::TopicData>
   {
   public:
   
       TopicData();
   
       explicit TopicData(
               const dds::core::ByteSeq& sequence);
   
       TopicData(
               const TopicData& other);
   
       TopicData(
               const uint8_t* value_begin,
               const uint8_t* value_end);
   
       TopicData& value(
               const dds::core::ByteSeq& sequence);
   
       template<typename OCTET_ITER>
       TopicData& value(
               OCTET_ITER begin,
               OCTET_ITER end);
   
       const dds::core::ByteSeq value() const;
   
       const uint8_t* begin() const;
   
       const uint8_t* end() const;
   };
   
   
   //==============================================================================
   
   class EntityFactory : public dds::core::Value<detail::EntityFactory>
   {
   public:
   
       explicit EntityFactory(
               bool autoenable_created_entities = true);
   
       EntityFactory(
               const EntityFactory& other);
   
       EntityFactory& autoenable_created_entities(
               bool autoenable_created_entities);
   
       bool autoenable_created_entities() const;
   
       static EntityFactory AutoEnable();
   
       static EntityFactory ManuallyEnable();
   };
   
   //==============================================================================
   
   class TransportPriority : public dds::core::Value<detail::TransportPriority>
   {
   public:
   
       explicit TransportPriority(
               int32_t priority = 0);
   
       TransportPriority(
               const TransportPriority& other);
   
       TransportPriority& value(
               int32_t priority);
   
       int32_t value() const;
   };
   
   //==============================================================================
   
   class Lifespan : public dds::core::Value<detail::Lifespan>
   {
   public:
   
       explicit Lifespan(
               const dds::core::Duration& duration = dds::core::Duration::infinite());
   
       Lifespan(
               const Lifespan& other);
   
       Lifespan& duration(
               const dds::core::Duration& duration);
   
       const dds::core::Duration duration() const;
   };
   
   //==============================================================================
   
   class Deadline : public dds::core::Value<detail::Deadline>
   {
   public:
   
       explicit Deadline(
               const dds::core::Duration& period = dds::core::Duration::infinite());
   
       Deadline(
               const Deadline& other);
   
       Deadline& period(
               const dds::core::Duration& period);
   
       const dds::core::Duration period() const;
   };
   
   //==============================================================================
   
   class LatencyBudget : public dds::core::Value<detail::LatencyBudget>
   {
   public:
   
       explicit LatencyBudget(
               const dds::core::Duration& duration = dds::core::Duration::zero());
   
       LatencyBudget(
               const LatencyBudget& other);
   
       LatencyBudget& duration(
               const dds::core::Duration& duration);
   
       const dds::core::Duration duration() const;
   };
   
   //==============================================================================
   
   class TimeBasedFilter : public dds::core::Value<detail::TimeBasedFilter>
   {
   public:
   
       explicit TimeBasedFilter(
               const dds::core::Duration& period = dds::core::Duration::zero());
   
       TimeBasedFilter(
               const TimeBasedFilter& other);
   
       TimeBasedFilter& minimum_separation(
               const dds::core::Duration& period);
   
       const dds::core::Duration minimum_separation() const;
   };
   
   
   //==============================================================================
   
   class Partition : public dds::core::Value<detail::Partition>
   {
   public:
   
       Partition();
   
       explicit Partition(
               uint16_t in_length);
   
       Partition(
               const Partition& other);
   
       Partition& name(
               const std::string& name);
   
       Partition& names(
               dds::core::StringSeq& names);
   
       const dds::core::StringSeq names() const;
   
       void push_back(
               const char* name);
   
       void clear();
   };
   
   //==============================================================================
   //#ifdef OMG_DDS_OWNERSHIP_SUPPORT
   
   class Ownership : public dds::core::Value<detail::Ownership>
   {
   public:
   
       #   if defined (__SUNPRO_CC) && defined(SHARED)
       #   undef SHARED
       #   endif // if defined (__SUNPRO_CC) && defined(SHARED)
       explicit Ownership(
               dds::core::policy::OwnershipKind::Type kind = dds::core::policy::OwnershipKind::SHARED);
   
       Ownership(
               const Ownership& other);
   
       Ownership& kind(
               dds::core::policy::OwnershipKind::Type kind);
   
       dds::core::policy::OwnershipKind::Type kind() const;
   
       static Ownership Exclusive();
   
       static Ownership Shared();
   
   private:
   
       static eprosima::fastdds::dds::OwnershipQosPolicyKind to_native(
               OwnershipKind::Type kind);
   
       static OwnershipKind::Type from_native(
               eprosima::fastdds::dds::OwnershipQosPolicyKind kind);
   };
   
   
   //==============================================================================
   
   class OwnershipStrength : public dds::core::Value<detail::OwnershipStrength>
   {
   public:
   
       explicit OwnershipStrength(
               int32_t strength = 0);
   
       OwnershipStrength(
               const OwnershipStrength& other);
   
       int32_t value() const;
   
       OwnershipStrength& value(
               int32_t strength);
   };
   
   //#endif  // OMG_DDS_OWNERSHIP_SUPPORT
   //==============================================================================
   
   class WriterDataLifecycle : public dds::core::Value<detail::WriterDataLifecycle>
   {
   public:
   
       explicit WriterDataLifecycle(
               bool autodispose_unregistered_instances = true);
   
       WriterDataLifecycle(
               const WriterDataLifecycle& other);
   
       bool autodispose_unregistered_instances() const;
   
       WriterDataLifecycle& autodispose_unregistered_instances(
               bool autodispose_unregistered_instances);
   
       static WriterDataLifecycle AutoDisposeUnregisteredInstances();
   
       static WriterDataLifecycle ManuallyDisposeUnregisteredInstances();
   
   };
   
   //==============================================================================
   
   class ReaderDataLifecycle : public dds::core::Value<detail::ReaderDataLifecycle>
   {
   public:
   
       ReaderDataLifecycle(
               const dds::core::Duration& autopurge_nowriter_samples_delay = dds::core::Duration::infinite(),
               const dds::core::Duration& autopurge_disposed_samples_delay = dds::core::Duration::infinite());
   
       ReaderDataLifecycle(
               const ReaderDataLifecycle& other);
       const dds::core::Duration autopurge_nowriter_samples_delay() const;
   
       ReaderDataLifecycle& autopurge_nowriter_samples_delay(
               const dds::core::Duration& autopurge_nowriter_samples_delay);
   
       const dds::core::Duration autopurge_disposed_samples_delay() const;
   
       ReaderDataLifecycle& autopurge_disposed_samples_delay(
               const dds::core::Duration& autopurge_disposed_samples_delay);
   
       static ReaderDataLifecycle NoAutoPurgeDisposedSamples();
   
       static ReaderDataLifecycle AutoPurgeDisposedSamples(
               const dds::core::Duration& autopurge_disposed_samples_delay);
   
   };
   
   //==============================================================================
   
   class Durability : public dds::core::Value<detail::Durability>
   {
   public:
   
       explicit Durability(
               dds::core::policy::DurabilityKind::Type kind = dds::core::policy::DurabilityKind::VOLATILE);
   
       Durability(
               const Durability& other);
   
       Durability& kind(
               dds::core::policy::DurabilityKind::Type kind);
   
       dds::core::policy::DurabilityKind::Type  kind() const;
   
       static Durability Volatile();
   
       static Durability TransientLocal();
   
       static Durability Transient();
   
       static Durability Persistent();
   
   private:
   
       static eprosima::fastdds::dds::DurabilityQosPolicyKind to_native(
               DurabilityKind::Type kind);
   
       static DurabilityKind::Type from_native(
               eprosima::fastdds::dds::DurabilityQosPolicyKind kind);
   
   };
   
   //==============================================================================
   
   class Presentation : public dds::core::Value<detail::Presentation>
   {
   public:
   
       Presentation(
               dds::core::policy::PresentationAccessScopeKind::Type access_scope =
                   dds::core::policy::PresentationAccessScopeKind::INSTANCE,
               bool coherent_access = false,
               bool ordered_access = false);
   
       Presentation(
               const Presentation& other);
   
       Presentation& access_scope(
               dds::core::policy::PresentationAccessScopeKind::Type access_scope);
   
       dds::core::policy::PresentationAccessScopeKind::Type access_scope() const;
   
       Presentation& coherent_access(
               bool coherent_access);
   
       bool coherent_access() const;
   
       Presentation& ordered_access(
               bool ordered_access);
   
       bool ordered_access() const;
   
       static Presentation GroupAccessScope(
               bool coherent_access = false,
               bool ordered_access = false);
   
       static Presentation InstanceAccessScope(
               bool coherent_access = false,
               bool ordered_access = false);
   
       static Presentation TopicAccessScope(
               bool coherent_access = false,
               bool ordered_access = false);
   
   private:
   
       static eprosima::fastdds::dds::PresentationQosPolicyAccessScopeKind to_native(
               PresentationAccessScopeKind::Type kind);
   
       static PresentationAccessScopeKind::Type from_native(
               eprosima::fastdds::dds::PresentationQosPolicyAccessScopeKind kind);
   };
   
   //==============================================================================
   
   class Reliability : public dds::core::Value<detail::Reliability>
   {
   public:
   
       Reliability(
               dds::core::policy::ReliabilityKind::Type kind = dds::core::policy::ReliabilityKind::BEST_EFFORT,
               const dds::core::Duration& max_blocking_time = dds::core::Duration::from_millisecs(100));
   
       Reliability(
               const Reliability& other);
   
       Reliability& kind(
               dds::core::policy::ReliabilityKind::Type kind);
   
       dds::core::policy::ReliabilityKind::Type kind() const;
   
       Reliability& max_blocking_time(
               const dds::core::Duration& max_blocking_time);
   
       const dds::core::Duration max_blocking_time() const;
   
       static OMG_DDS_API Reliability Reliable(
               const dds::core::Duration& max_blocking_time = dds::core::Duration::from_millisecs(100));
   
       static Reliability BestEffort(
               const dds::core::Duration& max_blocking_time = dds::core::Duration::from_millisecs(100));
   
   private:
   
       static ReliabilityKind::Type from_native(
               eprosima::fastdds::dds::ReliabilityQosPolicyKind kind);
   
       static eprosima::fastdds::dds::ReliabilityQosPolicyKind to_native(
               ReliabilityKind::Type kind);
   
   };
   
   //==============================================================================
   
   class DestinationOrder : public dds::core::Value<detail::DestinationOrder>
   {
   public:
   
       explicit DestinationOrder(
               dds::core::policy::DestinationOrderKind::Type kind =
                   dds::core::policy::DestinationOrderKind::BY_RECEPTION_TIMESTAMP);
   
       DestinationOrder(
               const DestinationOrder& other);
   
       DestinationOrder& kind(
               dds::core::policy::DestinationOrderKind::Type kind);
   
       dds::core::policy::DestinationOrderKind::Type kind() const;
   
       static DestinationOrder SourceTimestamp();
   
       static DestinationOrder ReceptionTimestamp();
   
   private:
   
       static eprosima::fastdds::dds::DestinationOrderQosPolicyKind to_native(
               DestinationOrderKind::Type kind);
   
       static DestinationOrderKind::Type from_native(
               eprosima::fastdds::dds::DestinationOrderQosPolicyKind kind);
   
   };
   
   //==============================================================================
   
   class History : public dds::core::Value<detail::History>
   {
   public:
   
       History(
               dds::core::policy::HistoryKind::Type kind = dds::core::policy::HistoryKind::KEEP_LAST,
               int32_t depth = 1);
   
       History(
               const History& other);
   
       dds::core::policy::HistoryKind::Type kind() const;
   
       History& kind(
               dds::core::policy::HistoryKind::Type kind);
   
       int32_t depth() const;
   
       History& depth(
               int32_t depth);
   
       static History KeepAll();
   
       static History KeepLast(
               uint32_t depth);
   
   private:
   
       friend class DurabilityService;
   
       static eprosima::fastdds::dds::HistoryQosPolicyKind to_native(
               HistoryKind::Type kind);
   
       static HistoryKind::Type from_native(
               eprosima::fastdds::dds::HistoryQosPolicyKind kind);
   
   };
   
   //==============================================================================
   
   class ResourceLimits : public dds::core::Value<detail::ResourceLimits>
   {
   public:
   
       ResourceLimits(
               uint32_t max_samples = dds::core::LENGTH_UNLIMITED,
               uint32_t max_instances = dds::core::LENGTH_UNLIMITED,
               uint32_t max_samples_per_instance = dds::core::LENGTH_UNLIMITED);
   
       ResourceLimits(
               const ResourceLimits& other);
   
   public:
   
       ResourceLimits& max_samples(
               int32_t max_samples);
   
       int32_t max_samples() const;
   
       ResourceLimits& max_instances(
               int32_t max_instances);
   
       int32_t max_instances() const;
   
       ResourceLimits& max_samples_per_instance(
               int32_t max_samples_per_instance);
   
       int32_t max_samples_per_instance() const;
   };
   
   //==============================================================================
   
   class Liveliness : public dds::core::Value<detail::Liveliness>
   {
   public:
   
       Liveliness(
               dds::core::policy::LivelinessKind::Type kind = dds::core::policy::LivelinessKind::AUTOMATIC,
               const dds::core::Duration& lease_duration = dds::core::Duration::infinite());
   
       Liveliness(
               const Liveliness& other);
   
       Liveliness& kind(
               dds::core::policy::LivelinessKind::Type kind);
   
       dds::core::policy::LivelinessKind::Type kind() const;
   
       Liveliness& lease_duration(
               const dds::core::Duration& lease_duration);
   
       const dds::core::Duration lease_duration() const;
   
       static Liveliness Automatic();
   
       static Liveliness ManualByParticipant(
               const dds::core::Duration& lease_duration = dds::core::Duration::infinite());
   
       static Liveliness ManualByTopic(
               const dds::core::Duration& lease_duration = dds::core::Duration::infinite());
   
   private:
   
       static eprosima::fastdds::dds::LivelinessQosPolicyKind to_native(
               LivelinessKind::Type kind);
   
       static LivelinessKind::Type from_native(
               eprosima::fastdds::dds::LivelinessQosPolicyKind kind);
   
   };
   
   
   //==============================================================================
   //#ifdef OMG_DDS_PERSISTENCE_SUPPORT
   
   class DurabilityService : public dds::core::Value<detail::DurabilityService>
   {
   public:
   
       DurabilityService(
               const dds::core::Duration& service_cleanup_delay = dds::core::Duration::zero(),
               dds::core::policy::HistoryKind::Type history_kind = dds::core::policy::HistoryKind::KEEP_LAST,
               int32_t history_depth = 1,
               int32_t max_samples = dds::core::LENGTH_UNLIMITED,
               int32_t max_instances = dds::core::LENGTH_UNLIMITED,
               int32_t max_samples_per_instance = dds::core::LENGTH_UNLIMITED);
   
       DurabilityService(
               const DurabilityService& other);
   
       DurabilityService& service_cleanup_delay(
               const dds::core::Duration& service_cleanup_delay);
   
       const dds::core::Duration service_cleanup_delay() const;
   
       DurabilityService& history_kind(
               dds::core::policy::HistoryKind::Type history_kind);
   
       dds::core::policy::HistoryKind::Type history_kind() const;
   
       DurabilityService& history_depth(
               int32_t history_depth);
   
       int32_t history_depth() const;
   
       DurabilityService& max_samples(
               int32_t max_samples);
   
       int32_t max_samples() const;
   
       DurabilityService& max_instances(
               int32_t max_instances);
   
       int32_t max_instances() const;
   
       DurabilityService& max_samples_per_instance(
               int32_t max_samples_per_instance);
   
       int32_t max_samples_per_instance() const;
   };
   
   //#endif  //OMG_DDS_PERSISTENCE_SUPPORT
   
   //==============================================================================
   
   //#ifdef OMG_DDS_EXTENSIBLE_AND_DYNAMIC_TOPIC_TYPE_SUPPORT
   
   typedef uint16_t DataRepresentationId;
   
   typedef std::vector<DataRepresentationId> DataRepresentationIdSeq;
   
   class DataRepresentation : public dds::core::Value<detail::DataRepresentation>
   {
   
   public:
   
       explicit DataRepresentation(
               const dds::core::policy::DataRepresentationIdSeq& value);
   
       DataRepresentation(
               const DataRepresentation& other)
           : dds::core::Value<detail::DataRepresentation>(other)
       {
       }
   
       DataRepresentation& value(
               const dds::core::policy::DataRepresentationIdSeq& value);
   
       const dds::core::policy::DataRepresentationIdSeq value() const;
   
       dds::core::policy::DataRepresentationIdSeq& value();
   
   private:
   
       static std::vector<eprosima::fastdds::dds::DataRepresentationId> to_native(
               const DataRepresentationIdSeq& seq);
   
   };
   
   //#endif  //OMG_DDS_EXTENSIBLE_AND_DYNAMIC_TOPIC_TYPE_SUPPORT
   
   
   //============================================================================
   
   //#ifdef OMG_DDS_EXTENSIBLE_AND_DYNAMIC_TOPIC_TYPE_SUPPORT
   
   class TypeConsistencyEnforcement : public dds::core::Value<detail::TypeConsistencyEnforcement>
   {
   public:
   
       explicit TypeConsistencyEnforcement(
               dds::core::policy::TypeConsistencyEnforcementKind::Type kind);
   
       TypeConsistencyEnforcement& kind(
               dds::core::policy::TypeConsistencyEnforcementKind::Type kind);
   
       dds::core::policy::TypeConsistencyEnforcementKind::Type  kind() const;
   
       TypeConsistencyEnforcement& ignore_sequence_bounds(
               bool ignore_sequence_bounds);
   
       TypeConsistencyEnforcement& ignore_string_bounds(
               bool ignore_string_bounds);
   
       TypeConsistencyEnforcement& ignore_member_names(
               bool ignore_member_names);
   
       TypeConsistencyEnforcement& prevent_type_widening(
               bool prevent_type_widening);
   
       TypeConsistencyEnforcement& force_type_validation(
               bool force_type_validation);
   
       bool ignore_sequence_bounds();
   
       bool ignore_string_bounds();
   
       bool ignore_member_names();
   
       bool prevent_type_widening();
   
       bool force_type_validation();
   
   };
   
   //#endif  //OMG_DDS_EXTENSIBLE_AND_DYNAMIC_TOPIC_TYPE_SUPPORT
   
   //==============================================================================
   // Policy Trait Classes
   
   template<typename Policy>
   class policy_id;
   
   template<typename Policy>
   class policy_name;
   
   #ifdef OMG_DDS_EXTENSIBLE_AND_DYNAMIC_TOPIC_TYPE_SUPPORT
   #endif // ifdef OMG_DDS_EXTENSIBLE_AND_DYNAMIC_TOPIC_TYPE_SUPPORT
   
   OMG_DDS_POLICY_TRAITS(UserData,             eprosima::fastdds::dds::USERDATA_QOS_POLICY_ID)
   OMG_DDS_POLICY_TRAITS(Durability,           eprosima::fastdds::dds::DURABILITY_QOS_POLICY_ID)
   OMG_DDS_POLICY_TRAITS(Presentation,         eprosima::fastdds::dds::PRESENTATION_QOS_POLICY_ID)
   OMG_DDS_POLICY_TRAITS(Deadline,             eprosima::fastdds::dds::DEADLINE_QOS_POLICY_ID)
   OMG_DDS_POLICY_TRAITS(LatencyBudget,        eprosima::fastdds::dds::LATENCYBUDGET_QOS_POLICY_ID)
   OMG_DDS_POLICY_TRAITS(Ownership,            eprosima::fastdds::dds::OWNERSHIP_QOS_POLICY_ID)
   
   //#ifdef OMG_DDS_OWNERSHIP_SUPPORT
   OMG_DDS_POLICY_TRAITS(OwnershipStrength,    eprosima::fastdds::dds::OWNERSHIPSTRENGTH_QOS_POLICY_ID)
   //#endif  //OMG_DDS_OWNERSHIP_SUPPORT
   
   OMG_DDS_POLICY_TRAITS(Liveliness,           eprosima::fastdds::dds::LIVELINESS_QOS_POLICY_ID)
   OMG_DDS_POLICY_TRAITS(TimeBasedFilter,      eprosima::fastdds::dds::TIMEBASEDFILTER_QOS_POLICY_ID)
   OMG_DDS_POLICY_TRAITS(Partition,            eprosima::fastdds::dds::PARTITION_QOS_POLICY_ID)
   OMG_DDS_POLICY_TRAITS(Reliability,          eprosima::fastdds::dds::RELIABILITY_QOS_POLICY_ID)
   OMG_DDS_POLICY_TRAITS(DestinationOrder,     eprosima::fastdds::dds::DESTINATIONORDER_QOS_POLICY_ID)
   OMG_DDS_POLICY_TRAITS(History,              eprosima::fastdds::dds::HISTORY_QOS_POLICY_ID)
   OMG_DDS_POLICY_TRAITS(ResourceLimits,       eprosima::fastdds::dds::RESOURCELIMITS_QOS_POLICY_ID)
   OMG_DDS_POLICY_TRAITS(EntityFactory,        eprosima::fastdds::dds::ENTITYFACTORY_QOS_POLICY_ID)
   OMG_DDS_POLICY_TRAITS(WriterDataLifecycle,  eprosima::fastdds::dds::WRITERDATALIFECYCLE_QOS_POLICY_ID)
   OMG_DDS_POLICY_TRAITS(ReaderDataLifecycle,  eprosima::fastdds::dds::READERDATALIFECYCLE_QOS_POLICY_ID)
   OMG_DDS_POLICY_TRAITS(TopicData,            eprosima::fastdds::dds::TOPICDATA_QOS_POLICY_ID)
   OMG_DDS_POLICY_TRAITS(GroupData,            eprosima::fastdds::dds::GROUPDATA_QOS_POLICY_ID)
   OMG_DDS_POLICY_TRAITS(TransportPriority,    eprosima::fastdds::dds::TRANSPORTPRIORITY_QOS_POLICY_ID)
   OMG_DDS_POLICY_TRAITS(Lifespan,             eprosima::fastdds::dds::LIFESPAN_QOS_POLICY_ID)
   
   //#ifdef  OMG_DDS_PERSISTENCE_SUPPORT
   OMG_DDS_POLICY_TRAITS(DurabilityService,    eprosima::fastdds::dds::DURABILITYSERVICE_QOS_POLICY_ID)
   //#endif  //OMG_DDS_PERSISTENCE_SUPPORT
   
   } //namespace policy
   } //namespace core
   } //namespace dds
   
   
   #endif //OMG_DDS_CORE_POLICY_CORE_POLICY_HPP_