.. _program_listing_file__tmp_ws_src_fastrtps_include_fastdds_dds_core_policy_ParameterTypes.hpp:

Program Listing for File ParameterTypes.hpp
===========================================

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

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

.. code-block:: cpp

   // Copyright 2016 Proyectos y Sistemas de Mantenimiento SL (eProsima).
   //
   // Licensed under the Apache License, Version 2.0 (the "License");
   // you may not use this file except in compliance with the License.
   // You may obtain a copy of the License at
   //
   //     http://www.apache.org/licenses/LICENSE-2.0
   //
   // Unless required by applicable law or agreed to in writing, software
   // distributed under the License is distributed on an "AS IS" BASIS,
   // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   // See the License for the specific language governing permissions and
   // limitations under the License.
   
   #ifndef _FASTDDS_DDS_QOS_PARAMETERTYPES_HPP_
   #define _FASTDDS_DDS_QOS_PARAMETERTYPES_HPP_
   
   #ifndef DOXYGEN_SHOULD_SKIP_THIS_PUBLIC
   
   #include <fastdds/rtps/common/all_common.h>
   #include <fastdds/rtps/common/Token.h>
   #include <fastdds/rtps/messages/CDRMessage.h>
   
   #include <fastrtps/utils/fixed_size_string.hpp>
   
   #if HAVE_SECURITY
   #include <fastdds/rtps/security/accesscontrol/ParticipantSecurityAttributes.h>
   #include <fastdds/rtps/security/accesscontrol/EndpointSecurityAttributes.h>
   #endif // if HAVE_SECURITY
   
   #include <string>
   #include <vector>
   
   namespace eprosima {
   
   namespace fastrtps {
   namespace rtps {
   struct CDRMessage_t;
   } // namespace rtps
   } // namespace fastrtps
   
   namespace fastdds {
   namespace dds {
   
   enum ParameterId_t : uint16_t
   {
       /* From Table 9.18 of DDS-RTPS 2.5 */
       PID_PAD                                 = 0x0000,
       PID_SENTINEL                            = 0x0001,
       PID_USER_DATA                           = 0x002c,
       PID_TOPIC_NAME                          = 0x0005,
       PID_TYPE_NAME                           = 0x0007,
       PID_GROUP_DATA                          = 0x002d,
       PID_TOPIC_DATA                          = 0x002e,
       PID_DURABILITY                          = 0x001d,
       PID_DURABILITY_SERVICE                  = 0x001e,
       PID_DEADLINE                            = 0x0023,
       PID_LATENCY_BUDGET                      = 0x0027,
       PID_LIVELINESS                          = 0x001b,
       PID_RELIABILITY                         = 0x001a,
       PID_LIFESPAN                            = 0x002b,
       PID_DESTINATION_ORDER                   = 0x0025,
       PID_HISTORY                             = 0x0040,
       PID_RESOURCE_LIMITS                     = 0x0041,
       PID_OWNERSHIP                           = 0x001f,
       PID_OWNERSHIP_STRENGTH                  = 0x0006,
       PID_PRESENTATION                        = 0x0021,
       PID_PARTITION                           = 0x0029,
       PID_TIME_BASED_FILTER                   = 0x0004,
       PID_TRANSPORT_PRIORITY                  = 0x0049,
       PID_DOMAIN_ID                           = 0x000f,
       PID_DOMAIN_TAG                          = 0x4014,
       PID_PROTOCOL_VERSION                    = 0x0015,
       PID_VENDORID                            = 0x0016,
       PID_UNICAST_LOCATOR                     = 0x002f,
       PID_MULTICAST_LOCATOR                   = 0x0030,
       PID_DEFAULT_UNICAST_LOCATOR             = 0x0031,
       PID_DEFAULT_MULTICAST_LOCATOR           = 0x0048,
       PID_METATRAFFIC_UNICAST_LOCATOR         = 0x0032,
       PID_METATRAFFIC_MULTICAST_LOCATOR       = 0x0033,
       PID_EXPECTS_INLINE_QOS                  = 0x0043,
       PID_PARTICIPANT_MANUAL_LIVELINESS_COUNT = 0x0034,
       PID_PARTICIPANT_LEASE_DURATION          = 0x0002,
       PID_CONTENT_FILTER_PROPERTY             = 0x0035,
       PID_PARTICIPANT_GUID                    = 0x0050,
       PID_GROUP_GUID                          = 0x0052,
       PID_GROUP_ENTITYID                      = 0x0053,
       PID_BUILTIN_ENDPOINT_SET                = 0x0058,
       PID_BUILTIN_ENDPOINT_QOS                = 0x0077,
       PID_PROPERTY_LIST                       = 0x0059,
       PID_TYPE_MAX_SIZE_SERIALIZED            = 0x0060,
       PID_ENTITY_NAME                         = 0x0062,
       PID_ENDPOINT_GUID                       = 0x005a,
   
       /* From table 9.20 of DDS-RTPS 2.5 - inline QoS only */
       PID_CONTENT_FILTER_INFO                 = 0x0055,
       PID_COHERENT_SET                        = 0x0056,
       PID_DIRECTED_WRITE                      = 0x0057,
       PID_ORIGINAL_WRITER_INFO                = 0x0061,
       PID_GROUP_COHERENT_SET                  = 0x0063,
       PID_GROUP_SEQ_NUM                       = 0x0064,
       PID_WRITER_GROUP_INFO                   = 0x0065,
       PID_SECURE_WRITER_GROUP_INFO            = 0x0066,
       PID_KEY_HASH                            = 0x0070,
       PID_STATUS_INFO                         = 0x0071,
   
       /* Deprecated */
       // PID_MULTICAST_IPADDRESS             = 0x0011,
       // PID_DEFAULT_UNICAST_IPADDRESS       = 0x000c,
       // PID_DEFAULT_UNICAST_PORT            = 0x000e,
       // PID_METATRAFFIC_UNICAST_IPADDRESS   = 0x0045,
       // PID_METATRAFFIC_UNICAST_PORT        = 0x000d,
       // PID_METATRAFFIC_MULTICAST_IPADDRESS = 0x000b,
       // PID_METATRAFFIC_MULTICAST_PORT      = 0x0046,
       // PID_PARTICIPANT_BUILTIN_ENDPOINTS   = 0x0044,
       // PID_PARTICIPANT_ENTITYID            = 0x0051,
   
       /* From DDS-XTYPES 1.3 */
       PID_TYPE_IDV1                           = 0x0069,
       PID_TYPE_OBJECTV1                       = 0x0072,
       PID_DATA_REPRESENTATION                 = 0x0073,
       PID_TYPE_CONSISTENCY_ENFORCEMENT        = 0x0074,
       PID_TYPE_INFORMATION                    = 0x0075,
   
       /* From table 10 of DDS-SEC 1.1 */
       PID_IDENTITY_TOKEN                      = 0x1001,
       PID_PERMISSIONS_TOKEN                   = 0x1002,
       PID_PARTICIPANT_SECURITY_INFO           = 0x1005,
   
       /* From table 12 of DDS-SEC 1.1 */
       PID_ENDPOINT_SECURITY_INFO              = 0x1004,
   
       /* From table 13 of DDS-SEC 1.1 */
       PID_IDENTITY_STATUS_TOKEN               = 0x1006,
   
       /* From table 14 of DDS-SEC 1.1 */
       PID_DATA_TAGS                           = 0x1003,
   
       /* eProsima Fast DDS extensions */
       PID_PERSISTENCE_GUID                    = 0x8002,
       PID_RELATED_SAMPLE_IDENTITY             = 0x800f,
       PID_DISABLE_POSITIVE_ACKS               = 0x8005,
       PID_DATASHARING                         = 0x8006,
   };
   
   class Parameter_t
   {
   public:
   
       RTPS_DllAPI Parameter_t()
           : Pid(PID_PAD)
           , length(0)
       {
       }
   
       RTPS_DllAPI Parameter_t(
               ParameterId_t pid,
               uint16_t length)
           : Pid(pid)
           , length(length)
       {
       }
   
       virtual RTPS_DllAPI ~Parameter_t()
       {
       }
   
       bool operator ==(
               const Parameter_t& b) const
       {
           return (this->Pid == b.Pid) &&
                  (this->length == b.length);
       }
   
   public:
   
       ParameterId_t Pid;
       uint16_t length;
   };
   
   class ParameterKey_t : public Parameter_t
   {
   public:
   
       fastrtps::rtps::InstanceHandle_t key;
       ParameterKey_t()
       {
       }
   
       ParameterKey_t(
               ParameterId_t pid,
               uint16_t in_length)
           : Parameter_t(pid, in_length)
       {
       }
   
       ParameterKey_t(
               ParameterId_t pid,
               uint16_t in_length,
               const fastrtps::rtps::InstanceHandle_t& ke)
           : Parameter_t(pid, in_length)
           , key(ke)
       {
       }
   
   };
   
   #define PARAMETER_KEY_HASH_LENGTH 16
   
   class ParameterLocator_t : public Parameter_t
   {
   public:
   
       rtps::Locator locator;
   
       ParameterLocator_t()
       {
       }
   
       ParameterLocator_t(
               ParameterId_t pid,
               uint16_t in_length)
           : Parameter_t(pid, in_length)
       {
       }
   
       ParameterLocator_t(
               ParameterId_t pid,
               uint16_t in_length,
               const rtps::Locator& loc)
           : Parameter_t(pid, in_length)
           , locator(loc)
       {
       }
   
   };
   #define PARAMETER_LOCATOR_LENGTH 24
   
   
   class ParameterString_t : public Parameter_t
   {
   public:
   
       ParameterString_t()
       {
       }
   
       ParameterString_t(
               ParameterId_t pid,
               uint16_t in_length)
           : Parameter_t(pid, in_length)
       {
       }
   
       ParameterString_t(
               ParameterId_t pid,
               uint16_t in_length,
               const fastrtps::string_255& strin)
           : Parameter_t(pid, in_length)
           , string_(strin)
       {
       }
   
       inline const char* getName() const
       {
           return string_.c_str();
       }
   
       inline void setName(
               const char* name)
       {
           string_ = name;
       }
   
       inline size_t size() const
       {
           return string_.size();
       }
   
   private:
   
       fastrtps::string_255 string_;
   };
   
   class ParameterPort_t : public Parameter_t
   {
   public:
   
       uint32_t port;
   
       ParameterPort_t()
           : port(0)
       {
       }
   
       ParameterPort_t(
               ParameterId_t pid,
               uint16_t in_length)
           : Parameter_t(pid, in_length)
           , port(0)
       {
       }
   
       ParameterPort_t(
               ParameterId_t pid,
               uint16_t in_length,
               uint32_t po)
           : Parameter_t(pid, in_length)
           , port(po)
       {
       }
   
   };
   
   #define PARAMETER_PORT_LENGTH 4
   
   class ParameterGuid_t : public Parameter_t
   {
   public:
   
       fastrtps::rtps::GUID_t guid;
   
       ParameterGuid_t()
       {
       }
   
       ParameterGuid_t(
               ParameterId_t pid,
               uint16_t in_length)
           : Parameter_t(pid, in_length)
       {
       }
   
       ParameterGuid_t(
               ParameterId_t pid,
               uint16_t in_length,
               const fastrtps::rtps::GUID_t& guidin)
           : Parameter_t(pid, in_length)
           , guid(guidin)
       {
       }
   
       ParameterGuid_t(
               ParameterId_t pid,
               uint16_t in_length,
               const fastrtps::rtps::InstanceHandle_t& iH)
           : Parameter_t(pid, in_length)
       {
           fastrtps::rtps::iHandle2GUID(guid, iH);
       }
   
   };
   
   #define PARAMETER_GUID_LENGTH 16
   
   class ParameterProtocolVersion_t : public Parameter_t
   {
   public:
   
       fastrtps::rtps::ProtocolVersion_t protocolVersion;
   
       ParameterProtocolVersion_t()
       {
           protocolVersion = fastrtps::rtps::c_ProtocolVersion;
       }
   
       ParameterProtocolVersion_t(
               ParameterId_t pid,
               uint16_t in_length)
           : Parameter_t(pid, in_length)
       {
           protocolVersion = fastrtps::rtps::c_ProtocolVersion;
       }
   
   };
   
   #define PARAMETER_PROTOCOL_LENGTH 4
   
   class ParameterVendorId_t : public Parameter_t
   {
   public:
   
       fastrtps::rtps::VendorId_t vendorId;
   
       ParameterVendorId_t()
           : vendorId(fastrtps::rtps::c_VendorId_eProsima)
       {
       }
   
       ParameterVendorId_t(
               ParameterId_t pid,
               uint16_t in_length)
           : Parameter_t(pid, in_length)
           , vendorId(fastrtps::rtps::c_VendorId_eProsima)
       {
       }
   
   };
   
   #define PARAMETER_VENDOR_LENGTH 4
   
   class ParameterIP4Address_t : public Parameter_t
   {
   public:
   
       fastrtps::rtps::octet address[4];
   
       ParameterIP4Address_t()
       {
           this->setIP4Address(0, 0, 0, 0);
       }
   
       ParameterIP4Address_t(
               ParameterId_t pid,
               uint16_t in_length)
           : Parameter_t(pid, in_length)
       {
           this->setIP4Address(0, 0, 0, 0);
       }
   
       void setIP4Address(
               fastrtps::rtps::octet o1,
               fastrtps::rtps::octet o2,
               fastrtps::rtps::octet o3,
               fastrtps::rtps::octet o4)
       {
           address[0] = o1;
           address[1] = o2;
           address[2] = o3;
           address[3] = o4;
       }
   
   };
   
   #define PARAMETER_IP4_LENGTH 4
   
   class ParameterBool_t : public Parameter_t
   {
   public:
   
       bool value;
   
       ParameterBool_t()
           : value(false)
       {
       }
   
       ParameterBool_t(
               ParameterId_t pid,
               uint16_t in_length)
           : Parameter_t(pid, in_length)
           , value(false)
       {
       }
   
       ParameterBool_t(
               ParameterId_t pid,
               uint16_t in_length,
               bool inbool)
           : Parameter_t(pid, in_length)
           , value(inbool)
       {
       }
   
   };
   
   #define PARAMETER_BOOL_LENGTH 4
   
   class ParameterStatusInfo_t : public Parameter_t
   {
   public:
   
       uint8_t status;
   
       ParameterStatusInfo_t()
           : status(0)
       {
       }
   
       ParameterStatusInfo_t(
               ParameterId_t pid,
               uint16_t in_length)
           : Parameter_t(pid, in_length)
           , status(0)
       {
       }
   
       ParameterStatusInfo_t(
               ParameterId_t pid,
               uint16_t in_length,
               uint8_t instatus)
           : Parameter_t(pid, in_length)
           , status(instatus)
       {
       }
   
   };
   
   #define PARAMETER_STATUS_INFO_LENGTH 4
   
   class ParameterCount_t : public Parameter_t
   {
   public:
   
       fastrtps::rtps::Count_t count;
   
       ParameterCount_t()
           : count(0)
       {
       }
   
       ParameterCount_t(
               ParameterId_t pid,
               uint16_t in_length)
           : Parameter_t(pid, in_length)
           , count(0)
       {
       }
   
   };
   
   #define PARAMETER_COUNT_LENGTH 4
   
   class ParameterEntityId_t : public Parameter_t
   {
   public:
   
       fastrtps::rtps::EntityId_t entityId;
   
       ParameterEntityId_t()
           : entityId(ENTITYID_UNKNOWN)
       {
       }
   
       ParameterEntityId_t(
               ParameterId_t pid,
               uint16_t in_length)
           : Parameter_t(pid, in_length)
           , entityId(ENTITYID_UNKNOWN)
       {
       }
   
   };
   
   #define PARAMETER_ENTITYID_LENGTH 4
   
   class ParameterTime_t : public Parameter_t
   {
   public:
   
       fastrtps::rtps::Time_t time;
   
       ParameterTime_t()
       {
       }
   
       ParameterTime_t(
               ParameterId_t pid,
               uint16_t in_length)
           : Parameter_t(pid, in_length)
       {
       }
   
   };
   
   #define PARAMETER_TIME_LENGTH 8
   
   class ParameterBuiltinEndpointSet_t : public Parameter_t
   {
   public:
   
       fastrtps::rtps::BuiltinEndpointSet_t endpointSet;
   
       ParameterBuiltinEndpointSet_t()
           : endpointSet(0)
       {
       }
   
       ParameterBuiltinEndpointSet_t(
               ParameterId_t pid,
               uint16_t in_length)
           : Parameter_t(pid, in_length)
           , endpointSet(0)
       {
       }
   
   };
   
   #define PARAMETER_BUILTINENDPOINTSET_LENGTH 4
   
   
   class ParameterProperty_t
   {
   
       friend class ParameterPropertyList_t;
   
   private:
   
       fastrtps::rtps::octet* data;
   
   public:
   
       ParameterProperty_t()
       {
           data = nullptr;
       }
   
       explicit ParameterProperty_t(
               void* ptr)
       {
           data = (fastrtps::rtps::octet*)ptr;
       }
   
       std::string first() const
       {
           //Skip the size and return the string
           return std::string((char*)data + 4);
       }
   
       std::string second() const
       {
           //Skip the first element
           uint32_t size1 = ParameterProperty_t::element_size(data);
   
           //Skip the size of the second element and return the string
           return std::string((char*)data + size1 + 4);
       }
   
       bool modify(
               const std::pair<std::string, std::string>& new_value)
       {
           uint32_t old_size = size();
   
           uint32_t first_size = (uint32_t)new_value.first.size() + 1;
           uint32_t first_alignment = ((first_size + 3u) & ~3u) - first_size;
           uint32_t second_size = (uint32_t)new_value.second.size() + 1;
           uint32_t second_alignment = ((second_size + 3u) & ~3u) - second_size;
           uint32_t new_size = first_size + first_alignment + second_size + second_alignment + 8;
   
           if (old_size != new_size)
           {
               return false;
           }
   
           fastrtps::rtps::octet* current = data;
           memcpy(current, &first_size, 4);
           memcpy(current + 4, new_value.first.c_str(), first_size);
           memset(current + 4 + first_size, 0, first_alignment);
   
           current = data + 4 + first_size + first_alignment;
           memcpy(current, &second_size, 4);
           memcpy(current + 4, new_value.second.c_str(), second_size);
           memset(current + 4 + second_size, 0, second_alignment);
   
           return true;
       }
   
       std::pair<const std::string, const std::string> pair() const
       {
           return std::make_pair(std::string(first()), std::string(second()));
       }
   
       uint32_t size() const
       {
           //Size of the first element (with alignment)
           uint32_t size1 = ParameterProperty_t::element_size(data);
   
           //Size of the second element (with alignment)
           uint32_t size2 = ParameterProperty_t::element_size(data + size1);
           return size1 + size2;
       }
   
       bool operator ==(
               const ParameterProperty_t& b) const
       {
           return (first() == b.first()) &&
                  (second() == b.second());
       }
   
       bool operator !=(
               const ParameterProperty_t& b) const
       {
           return !(*this == b);
       }
   
   private:
   
       static uint32_t element_size(
               const fastrtps::rtps::octet* ptr)
       {
           //Size of the element (with alignment)
           uint32_t size = *(uint32_t*)ptr;
           return (4u + ((size + 3u) & ~3u));
       }
   
   };
   
   const std::string parameter_property_persistence_guid = "PID_PERSISTENCE_GUID";
   
   const std::string parameter_property_participant_type = "PARTICIPANT_TYPE";
   
   const std::string parameter_property_ds_version = "DS_VERSION";
   
   const std::string parameter_property_current_ds_version = "2.0";
   
   const char* const parameter_policy_physical_data_host = "fastdds.physical_data.host";
   
   const char* const parameter_policy_physical_data_user = "fastdds.physical_data.user";
   
   const char* const parameter_policy_physical_data_process = "fastdds.physical_data.process";
   
   class ParameterPropertyList_t : public Parameter_t
   {
   private:
   
       fastrtps::rtps::SerializedPayload_t properties_;
       uint32_t Nproperties_ = 0;
       bool limit_size_ = false;
   
   public:
   
       class iterator
       {
       public:
   
           typedef iterator self_type;
           typedef ParameterProperty_t value_type;
           typedef ParameterProperty_t& reference;
           typedef ParameterProperty_t* pointer;
           typedef size_t difference_type;
           typedef std::forward_iterator_tag iterator_category;
   
           iterator(
                   fastrtps::rtps::octet* ptr)
               : ptr_(ptr)
               , value_(ptr)
           {
           }
   
           self_type operator ++()
           {
               self_type i = *this;
               advance();
               return i;
           }
   
           self_type operator ++(
                   int)
           {
               advance();
               return *this;
           }
   
           reference operator *()
           {
               return value_;
           }
   
           pointer operator ->()
           {
               return &value_;
           }
   
           bool operator ==(
                   const self_type& rhs) const
           {
               return ptr_ == rhs.ptr_;
           }
   
           bool operator !=(
                   const self_type& rhs) const
           {
               return ptr_ != rhs.ptr_;
           }
   
       protected:
   
           void advance()
           {
               ptr_ += value_.size();
               value_ = ParameterProperty_t(ptr_);
           }
   
           fastrtps::rtps::octet* address() const
           {
               return ptr_;
           }
   
       private:
   
           fastrtps::rtps::octet* ptr_;
           ParameterProperty_t value_;
       };
   
       class const_iterator
       {
       public:
   
           typedef const_iterator self_type;
           typedef const ParameterProperty_t value_type;
           typedef const ParameterProperty_t& reference;
           typedef const ParameterProperty_t* pointer;
           typedef size_t difference_type;
           typedef std::forward_iterator_tag iterator_category;
   
           const_iterator(
                   const fastrtps::rtps::octet* ptr)
               : ptr_(ptr)
               , value_(const_cast<fastrtps::rtps::octet*>(ptr))
           {
           }
   
           self_type operator ++()
           {
               self_type i = *this;
               advance();
               return i;
           }
   
           self_type operator ++(
                   int)
           {
               advance();
               return *this;
           }
   
           reference operator *()
           {
               return value_;
           }
   
           pointer operator ->()
           {
               return &value_;
           }
   
           bool operator ==(
                   const self_type& rhs) const
           {
               return ptr_ == rhs.ptr_;
           }
   
           bool operator !=(
                   const self_type& rhs) const
           {
               return ptr_ != rhs.ptr_;
           }
   
       protected:
   
           void advance()
           {
               ptr_ += value_.size();
               value_ = ParameterProperty_t(const_cast<fastrtps::rtps::octet*>(ptr_));
           }
   
           const fastrtps::rtps::octet* address() const
           {
               return ptr_;
           }
   
       private:
   
           const fastrtps::rtps::octet* ptr_;
           ParameterProperty_t value_;
       };
   
   public:
   
       ParameterPropertyList_t()
           : Parameter_t(PID_PROPERTY_LIST, 0)
           , Nproperties_ (0)
           , limit_size_ (false)
       {
       }
   
       ParameterPropertyList_t(
               uint32_t size)
           : Parameter_t(PID_PROPERTY_LIST, 0)
           , properties_(size)
           , Nproperties_ (0)
           , limit_size_ (size == 0 ? false : true)
       {
       }
   
       ParameterPropertyList_t(
               ParameterId_t pid,
               uint16_t in_length)
           : Parameter_t(PID_PROPERTY_LIST, in_length)
           , Nproperties_ (0)
           , limit_size_ (false)
       {
           static_cast<void>(pid);
       }
   
       ParameterPropertyList_t(
               const ParameterPropertyList_t& parameter_properties)
           : Parameter_t(PID_PROPERTY_LIST, parameter_properties.length)
           , properties_(parameter_properties.limit_size_ ?
                   parameter_properties.properties_.max_size :
                   parameter_properties.properties_.length)
           , Nproperties_ (parameter_properties.Nproperties_)
           , limit_size_ (parameter_properties.limit_size_)
       {
           properties_.copy(&parameter_properties.properties_, parameter_properties.limit_size_);
       }
   
       ParameterPropertyList_t& operator = (
               const ParameterPropertyList_t& parameter_properties)
       {
           length = parameter_properties.length;
           limit_size_ = parameter_properties.limit_size_;
           properties_.reserve(limit_size_ ?
                   parameter_properties.properties_.max_size :
                   parameter_properties.properties_.length);
           properties_.copy(&parameter_properties.properties_, parameter_properties.limit_size_);
           Nproperties_ = parameter_properties.Nproperties_;
           return *this;
       }
   
       iterator begin()
       {
           return iterator(properties_.data);
       }
   
       iterator end()
       {
           return iterator(properties_.data + properties_.length);
       }
   
       const_iterator begin() const
       {
           return const_iterator(properties_.data);
       }
   
       const_iterator end() const
       {
           return const_iterator(properties_.data + properties_.length);
       }
   
       bool push_back(
               std::pair<std::string, std::string> p)
       {
           return push_back(p.first, p.second);
       }
   
       bool push_back(
               const std::string& key,
               const std::string& value)
       {
           auto str1 = reinterpret_cast<const unsigned char*>(key.c_str());
           uint32_t size1 = (uint32_t) key.length() + 1;
           auto str2 = reinterpret_cast<const unsigned char*>(value.c_str());
           uint32_t size2 = (uint32_t) value.length() + 1;
   
           return push_back(str1, size1, str2, size2);
       }
   
       bool push_back(
               const unsigned char* str1,
               uint32_t str1_size,
               const unsigned char* str2,
               uint32_t str2_size)
       {
           //Realloc if needed;
           uint32_t alignment1 = ((str1_size + 3u) & ~3u) - str1_size;
           uint32_t alignment2 = ((str2_size + 3u) & ~3u) - str2_size;
   
           if (limit_size_ && (properties_.max_size < properties_.length +
                   str1_size + alignment1 + 4 +
                   str2_size + alignment2 + 4))
           {
               return false;
           }
           properties_.reserve(properties_.length +
                   str1_size + alignment1 + 4 +
                   str2_size + alignment2 + 4);
   
           push_back_helper((fastrtps::rtps::octet*)str1, str1_size, alignment1);
           push_back_helper((fastrtps::rtps::octet*)str2, str2_size, alignment2);
           ++Nproperties_;
           return true;
       }
   
       bool set_property (
               iterator pos,
               const std::pair<std::string, std::string>& new_value)
       {
           return pos->modify(new_value);
       }
   
       void clear()
       {
           properties_.length = 0;
           Nproperties_ = 0;
       }
   
       uint32_t size() const
       {
           return Nproperties_;
       }
   
       void set_max_size (
               uint32_t size)
       {
           properties_.reserve(size);
           limit_size_ = true;
       }
   
       uint32_t max_size ()
       {
           return (limit_size_ ? properties_.max_size : 0);
       }
   
   protected:
   
       void push_back_helper (
               const fastrtps::rtps::octet* data,
               uint32_t size,
               uint32_t alignment)
       {
           fastrtps::rtps::octet* o = (fastrtps::rtps::octet*)&size;
           memcpy(properties_.data + properties_.length, o, 4);
           properties_.length += 4;
   
           memcpy(properties_.data + properties_.length, data, size);
           properties_.length += size;
   
           for (uint32_t i = 0; i < alignment; ++i)
           {
               properties_.data[properties_.length + i] = '\0';
           }
           properties_.length += alignment;
       }
   
   };
   
   
   class ParameterSampleIdentity_t : public Parameter_t
   {
   public:
   
       fastrtps::rtps::SampleIdentity sample_id;
   
       ParameterSampleIdentity_t()
           : sample_id(fastrtps::rtps::SampleIdentity::unknown())
       {
       }
   
       ParameterSampleIdentity_t(
               ParameterId_t pid,
               uint16_t in_length)
           : Parameter_t(pid, in_length)
           , sample_id(fastrtps::rtps::SampleIdentity::unknown())
       {
       }
   
       bool addToCDRMessage(
               fastrtps::rtps::CDRMessage_t* msg) const;
   
       bool readFromCDRMessage(
               fastrtps::rtps::CDRMessage_t* msg,
               uint16_t size);
   
   };
   
   #define PARAMETER_SAMPLEIDENTITY_LENGTH 24
   
   
   #if HAVE_SECURITY
   
   class ParameterToken_t : public Parameter_t
   {
   public:
   
       fastrtps::rtps::Token token;
   
       ParameterToken_t()
       {
       }
   
       ParameterToken_t(
               ParameterId_t pid,
               uint16_t in_length)
           : Parameter_t(pid, in_length)
       {
       }
   
   };
   
   #define PARAMETER_PARTICIPANT_SECURITY_INFO_LENGTH 8
   
   class ParameterParticipantSecurityInfo_t : public Parameter_t
   {
   public:
   
       fastrtps::rtps::security::ParticipantSecurityAttributesMask security_attributes = 0;
       fastrtps::rtps::security::PluginParticipantSecurityAttributesMask plugin_security_attributes = 0;
   
       ParameterParticipantSecurityInfo_t()
           : Parameter_t(PID_PARTICIPANT_SECURITY_INFO, PARAMETER_PARTICIPANT_SECURITY_INFO_LENGTH)
       {
       }
   
       ParameterParticipantSecurityInfo_t(
               ParameterId_t pid,
               uint16_t in_length)
           : Parameter_t(pid, in_length)
       {
       }
   
   };
   
   #define PARAMETER_ENDPOINT_SECURITY_INFO_LENGTH 8
   
   class ParameterEndpointSecurityInfo_t : public Parameter_t
   {
   public:
   
       fastrtps::rtps::security::EndpointSecurityAttributesMask security_attributes = 0;
       fastrtps::rtps::security::PluginEndpointSecurityAttributesMask plugin_security_attributes = 0;
   
       ParameterEndpointSecurityInfo_t()
           : Parameter_t(PID_ENDPOINT_SECURITY_INFO, PARAMETER_ENDPOINT_SECURITY_INFO_LENGTH)
       {
       }
   
       ParameterEndpointSecurityInfo_t(
               ParameterId_t pid,
               uint16_t in_length)
           : Parameter_t(pid, in_length)
       {
       }
   
   };
   
   #endif // if HAVE_SECURITY
   
   
   template<class T, class PL>
   void set_proxy_property(
           const T& p,
           const char* PID,
           PL& properties)
   {
       // only valid values
       if (p == T::unknown())
       {
           return;
       }
   
       // generate pair
       std::pair<std::string, std::string> pair;
       pair.first = PID;
   
       std::ostringstream data;
       data << p;
       pair.second = data.str();
   
       // if exists replace
       auto it = std::find_if(
           properties.begin(),
           properties.end(),
           [&pair](const typename PL::const_iterator::reference p)
           {
               return pair.first == p.first();
           });
   
       if (it != properties.end())
       {
           // it->modify(pair);
           properties.set_property(it, pair);
       }
       else
       {
           // if not exists add
           properties.push_back(pair.first, pair.second);
       }
   }
   
   template<class T, class PL>
   T get_proxy_property(
           const char* const PID,
           PL& properties)
   {
       T property;
   
       auto it = std::find_if(
           properties.begin(),
           properties.end(),
           [PID](const typename PL::const_iterator::reference p)
           {
               return PID == p.first();
           });
   
       if (it != properties.end())
       {
           std::istringstream in(it->second());
           in >> property;
       }
   
       return property;
   }
   
   } //namespace dds
   } //namespace fastdds
   } //namespace eprosima
   
   #endif // ifndef DOXYGEN_SHOULD_SKIP_THIS_PUBLIC
   #endif // _FASTDDS_DDS_QOS_PARAMETERTYPES_HPP_