LLVMFuzzerTestOneInput:
   27|  20.0k|{
   28|  20.0k|    if (!initialized)
  ------------------
  |  Branch (28:9): [True: 1, False: 20.0k]
  ------------------
   29|      1|    {
   30|      1|        ignore_stdout();
   31|      1|        initialized = true;
   32|      1|    }
   33|       |
   34|  20.0k|    if (!size)
  ------------------
  |  Branch (34:9): [True: 0, False: 20.0k]
  ------------------
   35|      0|    {
   36|      0|        return EXIT_FAILURE;
   37|      0|    }
   38|       |
   39|  20.0k|    fastdds::dds::DomainParticipantFactory::get_instance()->load_XML_profiles_string(reinterpret_cast<const char*>(data), size);
   40|       |
   41|  20.0k|    return 0;
   42|  20.0k|}

ignore_stdout:
   26|      1|{
   27|      1|    int fd = open("/dev/null", O_WRONLY);
   28|      1|    if (fd == -1)
  ------------------
  |  Branch (28:9): [True: 0, False: 1]
  ------------------
   29|      0|    {
   30|      0|        warn("open(\"/dev/null\") failed");
   31|      0|        return -1;
   32|      0|    }
   33|       |
   34|      1|    int ret = 0;
   35|      1|    if (dup2(fd, STDOUT_FILENO) == -1)
  ------------------
  |  Branch (35:9): [True: 0, False: 1]
  ------------------
   36|      0|    {
   37|      0|        warn("failed to redirect stdout to /dev/null\n");
   38|      0|        ret = -1;
   39|      0|    }
   40|       |
   41|      1|    if (close(fd) == -1)
  ------------------
  |  Branch (41:9): [True: 0, False: 1]
  ------------------
   42|      0|    {
   43|      0|        warn("close");
   44|      0|        ret = -1;
   45|      0|    }
   46|       |
   47|      1|    return ret;
   48|      1|}

_ZN8eprosima7fastdds15LibrarySettingsC2Ev:
   42|      2|    {
   43|      2|    }

_ZN8eprosima7fastdds3dds11Parameter_tC2ENS1_13ParameterId_tEt:
  217|  4.28M|        : Pid(pid)
  218|  4.28M|        , length(length)
  219|  4.28M|    {
  220|  4.28M|    }
_ZN8eprosima7fastdds3dds11Parameter_tD2Ev:
  226|  4.18M|    {
  227|  4.18M|    }

_ZN8eprosima7fastdds3dds9QosPolicyC2Ev:
  121|  63.7k|        : hasChanged(false)
  122|  63.7k|        , send_always_(false)
  123|  63.7k|    {
  124|  63.7k|    }
_ZN8eprosima7fastdds3dds9QosPolicyC2Eb:
  133|  4.28M|        : hasChanged(false)
  134|  4.28M|        , send_always_(send_always)
  135|  4.28M|    {
  136|  4.28M|    }
_ZN8eprosima7fastdds3dds22EntityFactoryQosPolicyC2Ev:
  203|  12.8k|        : autoenable_created_entities(true)
  204|  12.8k|    {
  205|  12.8k|    }
_ZN8eprosima7fastdds3dds22EntityFactoryQosPolicyD2Ev:
  222|  11.9k|    {
  223|  11.9k|    }
_ZN8eprosima7fastdds3dds19DurabilityQosPolicyC2Ev:
  285|   173k|        : Parameter_t(PID_DURABILITY, PARAMETER_KIND_LENGTH)
  ------------------
  |  |  269|   173k|#define PARAMETER_KIND_LENGTH 4
  ------------------
  286|   173k|        , QosPolicy(true)
  287|   173k|        , kind(VOLATILE_DURABILITY_QOS)
  288|   173k|    {
  289|   173k|    }
_ZN8eprosima7fastdds3dds17DeadlineQosPolicyC2Ev:
  370|   173k|        : Parameter_t(PID_DEADLINE, PARAMETER_TIME_LENGTH)
  ------------------
  |  |  947|   173k|#define PARAMETER_TIME_LENGTH 8
  ------------------
  371|   173k|        , QosPolicy(true)
  372|   173k|        , period(TIME_T_INFINITE_SECONDS, TIME_T_INFINITE_NANOSECONDS)
  ------------------
  |  |  410|   173k|#define TIME_T_INFINITE_SECONDS (eprosima::fastdds::dds::Time_t::INFINITE_SECONDS)
  ------------------
                      , period(TIME_T_INFINITE_SECONDS, TIME_T_INFINITE_NANOSECONDS)
  ------------------
  |  |  411|   173k|#define TIME_T_INFINITE_NANOSECONDS (eprosima::fastdds::dds::Time_t::INFINITE_NANOSECONDS)
  ------------------
  373|   173k|    {
  374|   173k|    }
_ZN8eprosima7fastdds3dds22LatencyBudgetQosPolicyC2Ev:
  423|   173k|        : Parameter_t(PID_LATENCY_BUDGET, PARAMETER_TIME_LENGTH)
  ------------------
  |  |  947|   173k|#define PARAMETER_TIME_LENGTH 8
  ------------------
  424|   173k|        , QosPolicy(true)
  425|   173k|        , duration(0, 0)
  426|   173k|    {
  427|   173k|    }
_ZN8eprosima7fastdds3dds19LivelinessQosPolicyC2Ev:
  495|   173k|        : Parameter_t(PID_LIVELINESS, PARAMETER_KIND_LENGTH + PARAMETER_TIME_LENGTH)
  ------------------
  |  |  269|   173k|#define PARAMETER_KIND_LENGTH 4
  ------------------
                      : Parameter_t(PID_LIVELINESS, PARAMETER_KIND_LENGTH + PARAMETER_TIME_LENGTH)
  ------------------
  |  |  947|   173k|#define PARAMETER_TIME_LENGTH 8
  ------------------
  496|   173k|        , QosPolicy(true)
  497|   173k|        , kind(AUTOMATIC_LIVELINESS_QOS)
  498|   173k|        , lease_duration(TIME_T_INFINITE_SECONDS, TIME_T_INFINITE_NANOSECONDS)
  ------------------
  |  |  410|   173k|#define TIME_T_INFINITE_SECONDS (eprosima::fastdds::dds::Time_t::INFINITE_SECONDS)
  ------------------
                      , lease_duration(TIME_T_INFINITE_SECONDS, TIME_T_INFINITE_NANOSECONDS)
  ------------------
  |  |  411|   173k|#define TIME_T_INFINITE_NANOSECONDS (eprosima::fastdds::dds::Time_t::INFINITE_NANOSECONDS)
  ------------------
  499|   173k|        , announcement_period(TIME_T_INFINITE_SECONDS, TIME_T_INFINITE_NANOSECONDS)
  ------------------
  |  |  410|   173k|#define TIME_T_INFINITE_SECONDS (eprosima::fastdds::dds::Time_t::INFINITE_SECONDS)
  ------------------
                      , announcement_period(TIME_T_INFINITE_SECONDS, TIME_T_INFINITE_NANOSECONDS)
  ------------------
  |  |  411|   173k|#define TIME_T_INFINITE_NANOSECONDS (eprosima::fastdds::dds::Time_t::INFINITE_NANOSECONDS)
  ------------------
  500|   173k|    {
  501|   173k|    }
_ZN8eprosima7fastdds3dds20ReliabilityQosPolicyC2Ev:
  577|   173k|        : Parameter_t(PID_RELIABILITY, PARAMETER_KIND_LENGTH + PARAMETER_TIME_LENGTH)
  ------------------
  |  |  269|   173k|#define PARAMETER_KIND_LENGTH 4
  ------------------
                      : Parameter_t(PID_RELIABILITY, PARAMETER_KIND_LENGTH + PARAMETER_TIME_LENGTH)
  ------------------
  |  |  947|   173k|#define PARAMETER_TIME_LENGTH 8
  ------------------
  578|   173k|        , QosPolicy(true) //indicate send always
  579|   173k|        , kind(BEST_EFFORT_RELIABILITY_QOS)
  580|   173k|        , max_blocking_time{0, 100000000} // max_blocking_time = 100ms
  581|   173k|    {
  582|   173k|    }
_ZN8eprosima7fastdds3dds18OwnershipQosPolicyC2Ev:
  659|   173k|        : Parameter_t(PID_OWNERSHIP, PARAMETER_KIND_LENGTH)
  ------------------
  |  |  269|   173k|#define PARAMETER_KIND_LENGTH 4
  ------------------
  660|   173k|        , QosPolicy(true)
  661|   173k|        , kind(SHARED_OWNERSHIP_QOS)
  662|   173k|    {
  663|   173k|    }
_ZN8eprosima7fastdds3dds25DestinationOrderQosPolicyC2Ev:
  726|   173k|        : Parameter_t(PID_DESTINATION_ORDER, PARAMETER_KIND_LENGTH)
  ------------------
  |  |  269|   173k|#define PARAMETER_KIND_LENGTH 4
  ------------------
  727|   173k|        , QosPolicy(true)
  728|   173k|        , kind(BY_RECEPTION_TIMESTAMP_DESTINATIONORDER_QOS)
  729|   173k|    {
  730|   173k|    }
_ZN8eprosima7fastdds3dds20GenericDataQosPolicyC2ENS1_13ParameterId_tE:
  770|   521k|        : Parameter_t(pid, 0)
  771|   521k|        , QosPolicy(false)
  772|   521k|        , ResourceLimitedOctetVector()
  773|   521k|    {
  774|   521k|    }
_ZN8eprosima7fastdds3dds20GenericDataQosPolicyC2ERKS2_:
  795|      1|        : Parameter_t(data.Pid, data.length)
  796|      1|        , QosPolicy(false)
  797|      1|        , ResourceLimitedOctetVector(data)
  798|      1|    {
  799|      1|    }
_ZN8eprosima7fastdds3dds20GenericDataQosPolicyaSERKS2_:
  859|  1.41k|    {
  860|  1.41k|        QosPolicy::operator =(b);
  861|  1.41k|        Parameter_t::operator =(b);
  862|  1.41k|        configuration_ = b.configuration_;
  863|  1.41k|        collection_.reserve(b.collection_.capacity());
  864|  1.41k|        collection_.assign(b.collection_.begin(), b.collection_.end());
  865|  1.41k|        return *this;
  866|  1.41k|    }
_ZN8eprosima7fastdds3dds20GenericDataQosPolicy8data_vecEv:
  937|  2.95k|    {
  938|  2.95k|        return collection_;
  939|  2.95k|    }
_ZN8eprosima7fastdds3dds17UserDataQosPolicyC2Ev:
  994|   173k|            : GenericDataQosPolicy(TPid)                                                   \
  995|   173k|        {                                                                                  \
  996|   173k|        }                                                                                  \
_ZN8eprosima7fastdds3dds18TopicDataQosPolicyC2Ev:
  994|   173k|            : GenericDataQosPolicy(TPid)                                                   \
  995|   173k|        {                                                                                  \
  996|   173k|        }                                                                                  \
_ZN8eprosima7fastdds3dds18GroupDataQosPolicyC2Ev:
  994|   173k|            : GenericDataQosPolicy(TPid)                                                   \
  995|   173k|        {                                                                                  \
  996|   173k|        }                                                                                  \
_ZN8eprosima7fastdds3dds24TimeBasedFilterQosPolicyC2Ev:
 1111|   173k|        : Parameter_t(PID_TIME_BASED_FILTER, PARAMETER_TIME_LENGTH)
  ------------------
  |  |  947|   173k|#define PARAMETER_TIME_LENGTH 8
  ------------------
 1112|   173k|        , QosPolicy(false)
 1113|   173k|        , minimum_separation(0, 0)
 1114|   173k|    {
 1115|   173k|    }
_ZN8eprosima7fastdds3dds21PresentationQosPolicyC2Ev:
 1185|   173k|        : Parameter_t(PID_PRESENTATION, PARAMETER_PRESENTATION_LENGTH)
  ------------------
  |  | 1164|   173k|#define PARAMETER_PRESENTATION_LENGTH 8
  ------------------
 1186|   173k|        , QosPolicy(false)
 1187|   173k|        , access_scope(INSTANCE_PRESENTATION_QOS)
 1188|   173k|        , coherent_access(false)
 1189|   173k|        , ordered_access(false)
 1190|   173k|    {
 1191|   173k|    }
_ZN8eprosima7fastdds3dds18PartitionQosPolicyC2Ev:
 1398|   173k|        : Parameter_t(PID_PARTITION, 0)
 1399|   173k|        , QosPolicy(false)
 1400|   173k|        , max_size_ (0)
 1401|   173k|        , Npartitions_ (0)
 1402|   173k|    {
 1403|   173k|    }
_ZN8eprosima7fastdds3dds18PartitionQosPolicyaSERKS2_:
 1455|    472|    {
 1456|    472|        QosPolicy::operator =(b);
 1457|    472|        Parameter_t::operator =(b);
 1458|    472|        max_size_ = b.max_size_;
 1459|    472|        partitions_.reserve(max_size_ != 0 ?
  ------------------
  |  Branch (1459:29): [True: 0, False: 472]
  ------------------
 1460|      0|                b.partitions_.max_size :
 1461|    472|                b.partitions_.length);
 1462|    472|        partitions_.copy(&b.partitions_, b.max_size_ != 0);
 1463|    472|        Npartitions_ = b.Npartitions_;
 1464|       |
 1465|    472|        return *this;
 1466|    472|    }
_ZN8eprosima7fastdds3dds16HistoryQosPolicyC2Ev:
 1680|   197k|        : Parameter_t(PID_HISTORY, PARAMETER_KIND_LENGTH + 4)
  ------------------
  |  |  269|   197k|#define PARAMETER_KIND_LENGTH 4
  ------------------
 1681|   197k|        , QosPolicy(true)
 1682|   197k|        , kind(KEEP_LAST_HISTORY_QOS)
 1683|   197k|        , depth(1)
 1684|   197k|    {
 1685|   197k|    }
_ZN8eprosima7fastdds3dds23ResourceLimitsQosPolicyC2Ev:
 1766|   197k|        : Parameter_t(PID_RESOURCE_LIMITS, 4 * 5)
 1767|   197k|        , QosPolicy(false)
 1768|   197k|        , max_samples(5000)
 1769|   197k|        , max_instances(10)
 1770|   197k|        , max_samples_per_instance(400)
 1771|   197k|        , allocated_samples(100)
 1772|   197k|        , extra_samples(1)
 1773|   197k|    {
 1774|   197k|    }
_ZN8eprosima7fastdds3dds26DurabilityServiceQosPolicyC2Ev:
 1818|   173k|        : Parameter_t(PID_DURABILITY_SERVICE, PARAMETER_TIME_LENGTH + PARAMETER_KIND_LENGTH + 4 + 4 + 4 + 4)
  ------------------
  |  |  947|   173k|#define PARAMETER_TIME_LENGTH 8
  ------------------
                      : Parameter_t(PID_DURABILITY_SERVICE, PARAMETER_TIME_LENGTH + PARAMETER_KIND_LENGTH + 4 + 4 + 4 + 4)
  ------------------
  |  |  269|   173k|#define PARAMETER_KIND_LENGTH 4
  ------------------
 1819|   173k|        , QosPolicy(false)
 1820|   173k|        , history_kind(KEEP_LAST_HISTORY_QOS)
 1821|   173k|        , history_depth(1)
 1822|   173k|        , max_samples(LENGTH_UNLIMITED)
 1823|   173k|        , max_instances(LENGTH_UNLIMITED)
 1824|   173k|        , max_samples_per_instance(LENGTH_UNLIMITED)
 1825|   173k|    {
 1826|   173k|    }
_ZN8eprosima7fastdds3dds17LifespanQosPolicyC2Ev:
 1906|   173k|        : Parameter_t(PID_LIFESPAN, PARAMETER_TIME_LENGTH)
  ------------------
  |  |  947|   173k|#define PARAMETER_TIME_LENGTH 8
  ------------------
 1907|   173k|        , QosPolicy(true)
 1908|   173k|        , duration(TIME_T_INFINITE_SECONDS, TIME_T_INFINITE_NANOSECONDS)
  ------------------
  |  |  410|   173k|#define TIME_T_INFINITE_SECONDS (eprosima::fastdds::dds::Time_t::INFINITE_SECONDS)
  ------------------
                      , duration(TIME_T_INFINITE_SECONDS, TIME_T_INFINITE_NANOSECONDS)
  ------------------
  |  |  411|   173k|#define TIME_T_INFINITE_NANOSECONDS (eprosima::fastdds::dds::Time_t::INFINITE_NANOSECONDS)
  ------------------
 1909|   173k|    {
 1910|   173k|    }
_ZN8eprosima7fastdds3dds26OwnershipStrengthQosPolicyC2Ev:
 1952|  63.7k|        : Parameter_t(PID_OWNERSHIP_STRENGTH, 4)
 1953|  63.7k|        , QosPolicy(false)
 1954|  63.7k|        , value(0)
 1955|  63.7k|    {
 1956|  63.7k|    }
_ZN8eprosima7fastdds3dds26TransportPriorityQosPolicyC2Ev:
 2002|     10|        : Parameter_t(PID_TRANSPORT_PRIORITY, 4)
 2003|     10|        , QosPolicy(false)
 2004|     10|        , value(0)
 2005|     10|    {
 2006|     10|    }
_ZN8eprosima7fastdds3dds27DataRepresentationQosPolicyC2Ev:
 2104|   173k|        : Parameter_t(PID_DATA_REPRESENTATION, 0)
 2105|   173k|        , QosPolicy(false)
 2106|   173k|    {
 2107|   173k|    }
_ZN8eprosima7fastdds3dds35TypeConsistencyEnforcementQosPolicyC2Ev:
 2203|   109k|        : Parameter_t(PID_TYPE_CONSISTENCY_ENFORCEMENT, 8) // 2 + 5 + 1 alignment byte
 2204|   109k|        , QosPolicy(true)
 2205|   109k|    {
 2206|   109k|        m_kind = ALLOW_TYPE_COERCION;
 2207|   109k|        m_ignore_sequence_bounds = true;
 2208|   109k|        m_ignore_string_bounds = true;
 2209|   109k|        m_ignore_member_names = false;
 2210|   109k|        m_prevent_type_widening = false;
 2211|   109k|        m_force_type_validation = false;
 2212|   109k|    }
_ZN8eprosima7fastdds3dds28DisablePositiveACKsQosPolicyC2Ev:
 2253|   173k|        : Parameter_t(PID_DISABLE_POSITIVE_ACKS, PARAMETER_BOOL_LENGTH)
  ------------------
  |  |  270|   173k|#define PARAMETER_BOOL_LENGTH 4
  ------------------
 2254|   173k|        , QosPolicy(true)
 2255|   173k|        , enabled(false)
 2256|   173k|        , duration(TIME_T_INFINITE_SECONDS, TIME_T_INFINITE_NANOSECONDS)
  ------------------
  |  |  410|   173k|#define TIME_T_INFINITE_SECONDS (eprosima::fastdds::dds::Time_t::INFINITE_SECONDS)
  ------------------
                      , duration(TIME_T_INFINITE_SECONDS, TIME_T_INFINITE_NANOSECONDS)
  ------------------
  |  |  411|   173k|#define TIME_T_INFINITE_NANOSECONDS (eprosima::fastdds::dds::Time_t::INFINITE_NANOSECONDS)
  ------------------
 2257|   173k|    {
 2258|   173k|    }
_ZN8eprosima7fastdds3dds8TypeIdV1C2Ev:
 2303|   197k|        : Parameter_t(PID_TYPE_IDV1, 0)
 2304|   197k|        , QosPolicy(false)
 2305|   197k|        , m_type_identifier()
 2306|   197k|    {
 2307|   197k|    }
_ZN8eprosima7fastdds3dds8TypeIdV1aSERKS2_:
 2350|    560|    {
 2351|    560|        Pid = type.Pid;
 2352|    560|        length = type.length;
 2353|    560|        send_always_ = type.send_always_;
 2354|       |
 2355|    560|        m_type_identifier = type.m_type_identifier;
 2356|       |
 2357|    560|        return *this;
 2358|    560|    }
_ZN8eprosima7fastdds3dds12TypeObjectV1C2Ev:
 2415|   197k|        : Parameter_t(PID_TYPE_OBJECTV1, 0)
 2416|   197k|        , QosPolicy(false)
 2417|   197k|        , m_type_object()
 2418|   197k|    {
 2419|   197k|    }
_ZN8eprosima7fastdds3dds12TypeObjectV1aSERKS2_:
 2462|    560|    {
 2463|    560|        Pid = type.Pid;
 2464|    560|        length = type.length;
 2465|    560|        send_always_ = type.send_always_;
 2466|       |
 2467|    560|        m_type_object = type.m_type_object;
 2468|       |
 2469|    560|        return *this;
 2470|    560|    }
_ZN8eprosima7fastdds3dds6xtypes24TypeInformationParameterC2Ev:
 2529|   197k|        : Parameter_t(PID_TYPE_INFORMATION, 0)
 2530|   197k|        , QosPolicy(false)
 2531|   197k|        , type_information()
 2532|   197k|        , assigned_(false)
 2533|   197k|    {
 2534|   197k|    }
_ZN8eprosima7fastdds3dds6xtypes24TypeInformationParameteraSERKS3_:
 2580|    560|    {
 2581|    560|        Pid = type.Pid;
 2582|    560|        length = type.length;
 2583|    560|        send_always_ = type.send_always_;
 2584|       |
 2585|    560|        type_information = type.type_information;
 2586|    560|        assigned_ = type.assigned_;
 2587|       |
 2588|    560|        return *this;
 2589|    560|    }
_ZN8eprosima7fastdds3dds21WireProtocolConfigQosC2Ev:
 2667|      2|        : QosPolicy(false)
 2668|      2|        , participant_id(-1)
 2669|      2|        , easy_mode_("")
 2670|      2|    {
 2671|      2|    }
_ZN8eprosima7fastdds3dds18TransportConfigQosC2Ev:
 2788|      2|        : QosPolicy(false)
 2789|      2|        , use_builtin_transports(true)
 2790|      2|        , send_socket_buffer_size(0)
 2791|      2|        , listen_socket_buffer_size(0)
 2792|      2|        , max_msg_size_no_frag(0)
 2793|      2|        , netmask_filter(fastdds::rtps::NetmaskFilterKind::AUTO)
 2794|      2|    {
 2795|      2|    }
_ZN8eprosima7fastdds3dds23WriterResourceLimitsQosC2Ev:
 2917|      8|        : matched_subscriber_allocation()
 2918|      8|        , reader_filters_allocation(0, 32u, 1u)
 2919|      8|    {
 2920|      8|    }
_ZN8eprosima7fastdds3dds20DataSharingQosPolicyC2Ev:
 2981|   173k|        : Parameter_t(PID_DATASHARING, 0)
 2982|   173k|        , QosPolicy(true)
 2983|   173k|    {
 2984|       |        //Needed to generate the automatic domain ID
 2985|   173k|        automatic();
 2986|   173k|    }
_ZN8eprosima7fastdds3dds20DataSharingQosPolicyaSERKS2_:
 3014|    472|    {
 3015|    472|        QosPolicy::operator =(b);
 3016|    472|        Parameter_t::operator =(b);
 3017|    472|        kind_ = b.kind();
 3018|    472|        shm_directory_ = b.shm_directory();
 3019|    472|        max_domains_ = b.max_domains();
 3020|    472|        domain_ids_.reserve(max_domains_ != 0 ?
  ------------------
  |  Branch (3020:29): [True: 0, False: 472]
  ------------------
 3021|      0|                max_domains_ :
 3022|    472|                b.domain_ids().size());
 3023|    472|        domain_ids_ = b.domain_ids();
 3024|    472|        data_sharing_listener_thread_ = b.data_sharing_listener_thread();
 3025|       |
 3026|    472|        return *this;
 3027|    472|    }
_ZNK8eprosima7fastdds3dds20DataSharingQosPolicy4kindEv:
 3050|    472|    {
 3051|    472|        return kind_;
 3052|    472|    }
_ZNK8eprosima7fastdds3dds20DataSharingQosPolicy13shm_directoryEv:
 3058|    472|    {
 3059|    472|        return shm_directory_;
 3060|    472|    }
_ZNK8eprosima7fastdds3dds20DataSharingQosPolicy10domain_idsEv:
 3076|    944|    {
 3077|    944|        return domain_ids_;
 3078|    944|    }
_ZNK8eprosima7fastdds3dds20DataSharingQosPolicy11max_domainsEv:
 3094|    472|    {
 3095|    472|        return max_domains_;
 3096|    472|    }
_ZN8eprosima7fastdds3dds20DataSharingQosPolicy9automaticEv:
 3105|   173k|    {
 3106|   173k|        setup (AUTO, "", std::vector<uint16_t>());
 3107|   173k|    }
_ZNK8eprosima7fastdds3dds20DataSharingQosPolicy28data_sharing_listener_threadEv:
 3228|    472|    {
 3229|    472|        return data_sharing_listener_thread_;
 3230|    472|    }
_ZN8eprosima7fastdds3dds20DataSharingQosPolicy5setupERKNS1_15DataSharingKindERKNSt3__112basic_stringIcNS6_11char_traitsIcEENS6_9allocatorIcEEEERKNS6_6vectorItNSA_ItEEEE:
 3249|   173k|    {
 3250|   173k|        kind_ = kind;
 3251|   173k|        shm_directory_ = directory;
 3252|   173k|        domain_ids_.clear();
 3253|       |
 3254|   173k|        for (uint16_t id : domain_ids)
  ------------------
  |  Branch (3254:26): [True: 0, False: 173k]
  ------------------
 3255|      0|        {
 3256|      0|            add_domain_id(id);
 3257|      0|        }
 3258|   173k|    }
_ZN8eprosima7fastdds3dds17UserDataQosPolicyC2ERKS2_:
 1013|      1|                const TClassName &data) = default;                                         \
_ZN8eprosima7fastdds3dds9QosPolicyD2Ev:
  149|  4.24M|    virtual ~QosPolicy() = default;
_ZN8eprosima7fastdds3dds20GenericDataQosPolicyD2Ev:
  821|   509k|    virtual FASTDDS_EXPORTED_API ~GenericDataQosPolicy() = default;
_ZN8eprosima7fastdds3dds9QosPolicyC2ERKS2_:
  144|      2|            const QosPolicy& b) = default;
_ZN8eprosima7fastdds3dds9QosPolicyaSERKS2_:
  159|  10.3k|            const QosPolicy& b) = default;
_ZN8eprosima7fastdds3dds18TransportConfigQosD2Ev:
 2800|      1|    virtual FASTDDS_EXPORTED_API ~TransportConfigQos() = default;
_ZN8eprosima7fastdds3dds21WireProtocolConfigQosD2Ev:
 2676|      1|    virtual FASTDDS_EXPORTED_API ~WireProtocolConfigQos() = default;
_ZN8eprosima7fastdds3dds17UserDataQosPolicyaSERKS2_:
 1041|    472|                const TClassName& b) = default;                                            \
_ZN8eprosima7fastdds3dds18PartitionQosPolicyD2Ev:
 1441|   169k|    virtual FASTDDS_EXPORTED_API ~PartitionQosPolicy() = default;
_ZN8eprosima7fastdds3dds21PresentationQosPolicyD2Ev:
 1196|   169k|    virtual FASTDDS_EXPORTED_API ~PresentationQosPolicy() = default;
_ZN8eprosima7fastdds3dds27DataRepresentationQosPolicyD2Ev:
 2112|   169k|    virtual FASTDDS_EXPORTED_API ~DataRepresentationQosPolicy() override = default;
_ZN8eprosima7fastdds3dds18OwnershipQosPolicyD2Ev:
  668|   169k|    virtual FASTDDS_EXPORTED_API ~OwnershipQosPolicy() = default;
_ZN8eprosima7fastdds3dds17LifespanQosPolicyD2Ev:
 1915|   169k|    virtual FASTDDS_EXPORTED_API ~LifespanQosPolicy() = default;
_ZN8eprosima7fastdds3dds23ResourceLimitsQosPolicyD2Ev:
 1779|   192k|    virtual FASTDDS_EXPORTED_API ~ResourceLimitsQosPolicy() = default;
_ZN8eprosima7fastdds3dds16HistoryQosPolicyD2Ev:
 1690|   192k|    virtual FASTDDS_EXPORTED_API ~HistoryQosPolicy() = default;
_ZN8eprosima7fastdds3dds25DestinationOrderQosPolicyD2Ev:
  735|   169k|    virtual FASTDDS_EXPORTED_API ~DestinationOrderQosPolicy() = default;
_ZN8eprosima7fastdds3dds20ReliabilityQosPolicyD2Ev:
  587|   169k|    virtual FASTDDS_EXPORTED_API ~ReliabilityQosPolicy() = default;
_ZN8eprosima7fastdds3dds19LivelinessQosPolicyD2Ev:
  506|   169k|    virtual FASTDDS_EXPORTED_API ~LivelinessQosPolicy() = default;
_ZN8eprosima7fastdds3dds22LatencyBudgetQosPolicyD2Ev:
  432|   169k|    virtual FASTDDS_EXPORTED_API ~LatencyBudgetQosPolicy() = default;
_ZN8eprosima7fastdds3dds17DeadlineQosPolicyD2Ev:
  379|   169k|    virtual FASTDDS_EXPORTED_API ~DeadlineQosPolicy() = default;
_ZN8eprosima7fastdds3dds26DurabilityServiceQosPolicyD2Ev:
 1831|   169k|    virtual FASTDDS_EXPORTED_API ~DurabilityServiceQosPolicy() = default;
_ZN8eprosima7fastdds3dds19DurabilityQosPolicyD2Ev:
  294|   169k|    virtual FASTDDS_EXPORTED_API ~DurabilityQosPolicy() = default;
_ZN8eprosima7fastdds3dds20DataSharingQosPolicyD2Ev:
 2991|   169k|    virtual FASTDDS_EXPORTED_API ~DataSharingQosPolicy() = default;
_ZN8eprosima7fastdds3dds28DisablePositiveACKsQosPolicyD2Ev:
 2263|   169k|    virtual FASTDDS_EXPORTED_API ~DisablePositiveACKsQosPolicy() = default;
_ZN8eprosima7fastdds3dds35TypeConsistencyEnforcementQosPolicyD2Ev:
 2217|   107k|    virtual FASTDDS_EXPORTED_API ~TypeConsistencyEnforcementQosPolicy() override = default;
_ZN8eprosima7fastdds3dds24TimeBasedFilterQosPolicyD2Ev:
 1120|   169k|    virtual FASTDDS_EXPORTED_API ~TimeBasedFilterQosPolicy() = default;
_ZN8eprosima7fastdds3dds6xtypes24TypeInformationParameterD2Ev:
 2607|   192k|    virtual FASTDDS_EXPORTED_API ~TypeInformationParameter() override = default;
_ZN8eprosima7fastdds3dds12TypeObjectV1D2Ev:
 2487|   192k|    virtual FASTDDS_EXPORTED_API ~TypeObjectV1() override = default;
_ZN8eprosima7fastdds3dds8TypeIdV1D2Ev:
 2375|   192k|    virtual FASTDDS_EXPORTED_API ~TypeIdV1() override = default;
_ZN8eprosima7fastdds3dds18GroupDataQosPolicyaSERKS2_:
 1041|    472|                const TClassName& b) = default;                                            \
_ZN8eprosima7fastdds3dds18TopicDataQosPolicyaSERKS2_:
 1041|    472|                const TClassName& b) = default;                                            \
_ZN8eprosima7fastdds3dds26OwnershipStrengthQosPolicyD2Ev:
 1961|  61.7k|    virtual FASTDDS_EXPORTED_API ~OwnershipStrengthQosPolicy() = default;
_ZN8eprosima7fastdds3dds15RTPSEndpointQosC2Ev:
 2859|     12|    FASTDDS_EXPORTED_API RTPSEndpointQos() = default;

_ZN8eprosima7fastdds3dds21RTPSReliableReaderQosC2Ev:
   38|      4|    {
   39|      4|    }

_ZN8eprosima7fastdds3dds21RTPSReliableWriterQosC2Ev:
   37|      8|    {
   38|      8|    }

_ZN8eprosima7fastdds3dds28ReaderDataLifecycleQosPolicyC2Ev:
   43|      4|        : autopurge_no_writer_samples_delay(TIME_T_INFINITE_SECONDS, TIME_T_INFINITE_NANOSECONDS)
  ------------------
  |  |  410|      4|#define TIME_T_INFINITE_SECONDS (eprosima::fastdds::dds::Time_t::INFINITE_SECONDS)
  ------------------
                      : autopurge_no_writer_samples_delay(TIME_T_INFINITE_SECONDS, TIME_T_INFINITE_NANOSECONDS)
  ------------------
  |  |  411|      4|#define TIME_T_INFINITE_NANOSECONDS (eprosima::fastdds::dds::Time_t::INFINITE_NANOSECONDS)
  ------------------
   44|      4|        , autopurge_disposed_samples_delay(TIME_T_INFINITE_SECONDS, TIME_T_INFINITE_NANOSECONDS)
  ------------------
  |  |  410|      4|#define TIME_T_INFINITE_SECONDS (eprosima::fastdds::dds::Time_t::INFINITE_SECONDS)
  ------------------
                      , autopurge_disposed_samples_delay(TIME_T_INFINITE_SECONDS, TIME_T_INFINITE_NANOSECONDS)
  ------------------
  |  |  411|      4|#define TIME_T_INFINITE_NANOSECONDS (eprosima::fastdds::dds::Time_t::INFINITE_NANOSECONDS)
  ------------------
   45|      4|    {
   46|      4|    }

_ZN8eprosima7fastdds3dds23ReaderResourceLimitsQosC2Ev:
   37|      4|    FASTDDS_EXPORTED_API ReaderResourceLimitsQos() = default;

_ZN8eprosima7fastdds3dds28WriterDataLifecycleQosPolicyC2Ev:
   39|      8|        : autodispose_unregistered_instances(true)
   40|      8|    {
   41|      8|    }

_ZN8eprosima7fastdds3dds27DomainParticipantFactoryQosC2Ev:
   44|  12.8k|    {
   45|  12.8k|    }
_ZN8eprosima7fastdds3dds27DomainParticipantFactoryQosD2Ev:
   51|  11.9k|    {
   52|  11.9k|    }
_ZN8eprosima7fastdds3dds27DomainParticipantFactoryQos14entity_factoryEv:
   76|     87|    {
   77|     87|        return entity_factory_;
   78|     87|    }
_ZN8eprosima7fastdds3dds27DomainParticipantFactoryQos19shm_watchdog_threadEv:
   96|  1.18k|    {
   97|  1.18k|        return shm_watchdog_thread_;
   98|  1.18k|    }
_ZN8eprosima7fastdds3dds27DomainParticipantFactoryQos18file_watch_threadsEv:
  127|  1.78k|    {
  128|  1.78k|        return file_watch_threads_;
  129|  1.78k|    }

_ZN8eprosima7fastdds3dds20DomainParticipantQosC2Ev:
   58|      2|    {
   59|      2|#ifdef FASTDDS_STATISTICS
   60|       |        /*
   61|       |         * In the case of Statistics, the following properties are set with an empty value. This is because if these
   62|       |         * properties are set and empty during the enabling of the DomainParticipant, they are fill with the default
   63|       |         * mechanism
   64|       |         */
   65|      2|        properties_.properties().emplace_back(parameter_policy_physical_data_host, "");
   66|      2|        properties_.properties().emplace_back(parameter_policy_physical_data_user, "");
   67|      2|        properties_.properties().emplace_back(parameter_policy_physical_data_process, "");
   68|      2|#endif // ifdef FASTDDS_STATISTICS
   69|      2|    }
_ZN8eprosima7fastdds3dds20DomainParticipantQosD2Ev:
   75|      1|    {
   76|      1|    }

_ZN8eprosima7fastdds3ddslsERNSt3__113basic_ostreamIcNS2_11char_traitsIcEEEERKNS1_3Log4KindE:
  199|  1.32M|{
  200|  1.32M|    switch (kind){
  201|      0|        case Log::Kind::Info:
  ------------------
  |  Branch (201:9): [True: 0, False: 1.32M]
  ------------------
  202|      0|            output << "Info";
  203|      0|            break;
  204|       |
  205|      0|        case Log::Kind::Warning:
  ------------------
  |  Branch (205:9): [True: 0, False: 1.32M]
  ------------------
  206|      0|            output << "Warning";
  207|      0|            break;
  208|       |
  209|  1.32M|        case Log::Kind::Error:
  ------------------
  |  Branch (209:9): [True: 1.32M, False: 0]
  ------------------
  210|  1.32M|            output << "Error";
  211|  1.32M|            break;
  212|       |
  213|      0|        default:
  ------------------
  |  Branch (213:9): [True: 0, False: 1.32M]
  ------------------
  214|      0|            output << "Invalid Verbosity Kind.";
  215|      0|            break;
  216|  1.32M|    }
  217|       |
  218|  1.32M|    return output;
  219|  1.32M|}
_ZN8eprosima7fastdds3dds11LogConsumerD2Ev:
  228|      1|    virtual ~LogConsumer() = default;

_ZN8eprosima7fastdds3dds13DataWriterQos10durabilityEv:
   94|      4|    {
   95|      4|        return durability_;
   96|      4|    }
_ZN8eprosima7fastdds3dds13DataWriterQos11reliabilityEv:
  249|      4|    {
  250|      4|        return reliability_;
  251|      4|    }
_ZN8eprosima7fastdds3dds13DataWriterQos7historyEv:
  311|      8|    {
  312|      8|        return history_;
  313|      8|    }
_ZN8eprosima7fastdds3dds13DataWriterQos12publish_modeEv:
  559|      8|    {
  560|      8|        return publish_mode_;
  561|      8|    }
_ZN8eprosima7fastdds3dds13DataWriterQos10propertiesEv:
  621|      4|    {
  622|      4|        return properties_;
  623|      4|    }

_ZN8eprosima7fastdds3dds12PublisherQosC2Ev:
   46|      2|    {
   47|      2|    }

_ZN8eprosima7fastdds3dds13DataReaderQosC2Ev:
   51|      4|        : expects_inline_qos_(false)
   52|      4|    {
   53|      4|    }

_ZN8eprosima7fastdds3dds9ReaderQosC2Ev:
   42|   109k|    {
   43|   109k|    }
_ZN8eprosima7fastdds3dds9ReaderQosD2Ev:
   46|   107k|    {
   47|   107k|    }

_ZN8eprosima7fastdds3dds13SubscriberQosC2Ev:
   45|      2|    {
   46|      2|    }

_ZN8eprosima7fastdds3dds11DynamicTypeC2Ev:
  166|  56.3k|    DynamicType() = default;
_ZN8eprosima7fastdds3dds11DynamicTypeD2Ev:
  168|  56.2k|    virtual ~DynamicType() = default;

_ZN8eprosima7fastdds3dds18DynamicTypeBuilderC2Ev:
  186|  73.2k|    DynamicTypeBuilder() = default;
_ZN8eprosima7fastdds3dds18DynamicTypeBuilderD2Ev:
  188|  71.9k|    virtual ~DynamicTypeBuilder() = default;

_ZN8eprosima7fastdds3dds25DynamicTypeBuilderFactoryD2Ev:
  195|      1|    virtual ~DynamicTypeBuilderFactory() = default;
_ZN8eprosima7fastdds3dds25DynamicTypeBuilderFactoryC2Ev:
  193|      1|    DynamicTypeBuilderFactory() = default;

_ZN8eprosima7fastdds3dds17DynamicTypeMemberC2Ev:
  110|  24.3k|    DynamicTypeMember() = default;
_ZN8eprosima7fastdds3dds17DynamicTypeMemberD2Ev:
  112|  24.1k|    virtual ~DynamicTypeMember() = default;

_ZN8eprosima7fastdds3dds16MemberDescriptorC2Ev:
  307|  58.2k|    MemberDescriptor() = default;
_ZN8eprosima7fastdds3dds16MemberDescriptorD2Ev:
  315|  58.0k|    virtual ~MemberDescriptor() = default;

_ZN8eprosima7fastdds3dds14TypeDescriptorC2Ev:
  250|   249k|    TypeDescriptor() = default;
_ZN8eprosima7fastdds3dds14TypeDescriptorD2Ev:
  258|   248k|    virtual ~TypeDescriptor() = default;

_ZN8eprosima7fastdds3dds13object_traitsINS1_11DynamicTypeEE6narrowINS1_15DynamicTypeImplEvEENSt3__110shared_ptrIT_EENS8_IS3_EE:
   54|   254k|    {
   55|   254k|        return std::dynamic_pointer_cast<_Tp>(obj);
   56|   254k|    }
_ZN8eprosima7fastdds3dds6traitsINS1_14TypeDescriptorEE6narrowINS1_18TypeDescriptorImplEvEENSt3__110shared_ptrIT_EENS8_IS3_EE:
   36|  44.4k|    {
   37|  44.4k|        return std::dynamic_pointer_cast<_Tp>(obj);
   38|  44.4k|    }
_ZN8eprosima7fastdds3dds6traitsINS1_16MemberDescriptorEE6narrowINS1_20MemberDescriptorImplEvEENSt3__110shared_ptrIT_EENS8_IS3_EE:
   36|  33.9k|    {
   37|  33.9k|        return std::dynamic_pointer_cast<_Tp>(obj);
   38|  33.9k|    }

_ZN8eprosima7fastdds3dds6xtypes5DummyC2Ev:
 2732|   593k|    {
 2733|   593k|    }
_ZN8eprosima7fastdds3dds6xtypes5DummyD2Ev:
 2739|   577k|    {
 2740|   577k|    }
_ZN8eprosima7fastdds3dds6xtypes5DummyaSERKS3_:
 2768|  1.71k|    {
 2769|       |
 2770|  1.71k|        static_cast<void>(x);
 2771|       |
 2772|  1.71k|        return *this;
 2773|  1.71k|    }
_ZN8eprosima7fastdds3dds6xtypes5DummyaSEOS3_:
 2781|     30|    {
 2782|       |
 2783|     30|        static_cast<void>(x);
 2784|       |
 2785|     30|        return *this;
 2786|     30|    }
_ZN8eprosima7fastdds3dds6xtypes14TypeIdentifierC2Ev:
 2827|   593k|    {
 2828|   593k|        selected_member_ = 0x00000001;
 2829|   593k|        member_destructor_ = [&]()
 2830|   593k|        {
 2831|   593k|            m_no_value.~Dummy();
 2832|   593k|        };
 2833|   593k|        new(&m_no_value) Dummy();
 2834|       |
 2835|   593k|    }
_ZN8eprosima7fastdds3dds6xtypes14TypeIdentifierD2Ev:
 2841|   577k|    {
 2842|   577k|        if (member_destructor_)
  ------------------
  |  Branch (2842:13): [True: 577k, False: 0]
  ------------------
 2843|   577k|        {
 2844|   577k|            member_destructor_();
 2845|   577k|        }
 2846|   577k|    }
_ZN8eprosima7fastdds3dds6xtypes14TypeIdentifieraSERKS3_:
 2978|  1.71k|    {
 2979|  1.71k|        m__d = x.m__d;
 2980|       |
 2981|  1.71k|        switch (x.selected_member_)
  ------------------
  |  Branch (2981:17): [True: 0, False: 1.71k]
  ------------------
 2982|  1.71k|        {
 2983|  1.71k|                        case 0x00000001:
  ------------------
  |  Branch (2983:25): [True: 1.71k, False: 0]
  ------------------
 2984|  1.71k|                            no_value_() = x.m_no_value;
 2985|  1.71k|                            break;
 2986|       |
 2987|      0|                        case 0x00000002:
  ------------------
  |  Branch (2987:25): [True: 0, False: 1.71k]
  ------------------
 2988|      0|                            string_sdefn_() = x.m_string_sdefn;
 2989|      0|                            break;
 2990|       |
 2991|      0|                        case 0x00000003:
  ------------------
  |  Branch (2991:25): [True: 0, False: 1.71k]
  ------------------
 2992|      0|                            string_ldefn_() = x.m_string_ldefn;
 2993|      0|                            break;
 2994|       |
 2995|      0|                        case 0x00000004:
  ------------------
  |  Branch (2995:25): [True: 0, False: 1.71k]
  ------------------
 2996|      0|                            seq_sdefn_() = x.m_seq_sdefn;
 2997|      0|                            break;
 2998|       |
 2999|      0|                        case 0x00000005:
  ------------------
  |  Branch (2999:25): [True: 0, False: 1.71k]
  ------------------
 3000|      0|                            seq_ldefn_() = x.m_seq_ldefn;
 3001|      0|                            break;
 3002|       |
 3003|      0|                        case 0x00000006:
  ------------------
  |  Branch (3003:25): [True: 0, False: 1.71k]
  ------------------
 3004|      0|                            array_sdefn_() = x.m_array_sdefn;
 3005|      0|                            break;
 3006|       |
 3007|      0|                        case 0x00000007:
  ------------------
  |  Branch (3007:25): [True: 0, False: 1.71k]
  ------------------
 3008|      0|                            array_ldefn_() = x.m_array_ldefn;
 3009|      0|                            break;
 3010|       |
 3011|      0|                        case 0x00000008:
  ------------------
  |  Branch (3011:25): [True: 0, False: 1.71k]
  ------------------
 3012|      0|                            map_sdefn_() = x.m_map_sdefn;
 3013|      0|                            break;
 3014|       |
 3015|      0|                        case 0x00000009:
  ------------------
  |  Branch (3015:25): [True: 0, False: 1.71k]
  ------------------
 3016|      0|                            map_ldefn_() = x.m_map_ldefn;
 3017|      0|                            break;
 3018|       |
 3019|      0|                        case 0x0000000a:
  ------------------
  |  Branch (3019:25): [True: 0, False: 1.71k]
  ------------------
 3020|      0|                            sc_component_id_() = x.m_sc_component_id;
 3021|      0|                            break;
 3022|       |
 3023|      0|                        case 0x0000000b:
  ------------------
  |  Branch (3023:25): [True: 0, False: 1.71k]
  ------------------
 3024|      0|                            equivalence_hash_() = x.m_equivalence_hash;
 3025|      0|                            break;
 3026|       |
 3027|      0|                        case 0x0000000c:
  ------------------
  |  Branch (3027:25): [True: 0, False: 1.71k]
  ------------------
 3028|      0|                            extended_defn_() = x.m_extended_defn;
 3029|      0|                            break;
 3030|       |
 3031|  1.71k|        }
 3032|       |
 3033|  1.71k|        return *this;
 3034|  1.71k|    }
_ZN8eprosima7fastdds3dds6xtypes14TypeIdentifieraSEOS3_:
 3042|     30|    {
 3043|     30|        m__d = x.m__d;
 3044|       |
 3045|     30|        switch (x.selected_member_)
  ------------------
  |  Branch (3045:17): [True: 0, False: 30]
  ------------------
 3046|     30|        {
 3047|     30|                        case 0x00000001:
  ------------------
  |  Branch (3047:25): [True: 30, False: 0]
  ------------------
 3048|     30|                            no_value_() = std::move(x.m_no_value);
 3049|     30|                            break;
 3050|       |
 3051|      0|                        case 0x00000002:
  ------------------
  |  Branch (3051:25): [True: 0, False: 30]
  ------------------
 3052|      0|                            string_sdefn_() = std::move(x.m_string_sdefn);
 3053|      0|                            break;
 3054|       |
 3055|      0|                        case 0x00000003:
  ------------------
  |  Branch (3055:25): [True: 0, False: 30]
  ------------------
 3056|      0|                            string_ldefn_() = std::move(x.m_string_ldefn);
 3057|      0|                            break;
 3058|       |
 3059|      0|                        case 0x00000004:
  ------------------
  |  Branch (3059:25): [True: 0, False: 30]
  ------------------
 3060|      0|                            seq_sdefn_() = std::move(x.m_seq_sdefn);
 3061|      0|                            break;
 3062|       |
 3063|      0|                        case 0x00000005:
  ------------------
  |  Branch (3063:25): [True: 0, False: 30]
  ------------------
 3064|      0|                            seq_ldefn_() = std::move(x.m_seq_ldefn);
 3065|      0|                            break;
 3066|       |
 3067|      0|                        case 0x00000006:
  ------------------
  |  Branch (3067:25): [True: 0, False: 30]
  ------------------
 3068|      0|                            array_sdefn_() = std::move(x.m_array_sdefn);
 3069|      0|                            break;
 3070|       |
 3071|      0|                        case 0x00000007:
  ------------------
  |  Branch (3071:25): [True: 0, False: 30]
  ------------------
 3072|      0|                            array_ldefn_() = std::move(x.m_array_ldefn);
 3073|      0|                            break;
 3074|       |
 3075|      0|                        case 0x00000008:
  ------------------
  |  Branch (3075:25): [True: 0, False: 30]
  ------------------
 3076|      0|                            map_sdefn_() = std::move(x.m_map_sdefn);
 3077|      0|                            break;
 3078|       |
 3079|      0|                        case 0x00000009:
  ------------------
  |  Branch (3079:25): [True: 0, False: 30]
  ------------------
 3080|      0|                            map_ldefn_() = std::move(x.m_map_ldefn);
 3081|      0|                            break;
 3082|       |
 3083|      0|                        case 0x0000000a:
  ------------------
  |  Branch (3083:25): [True: 0, False: 30]
  ------------------
 3084|      0|                            sc_component_id_() = std::move(x.m_sc_component_id);
 3085|      0|                            break;
 3086|       |
 3087|      0|                        case 0x0000000b:
  ------------------
  |  Branch (3087:25): [True: 0, False: 30]
  ------------------
 3088|      0|                            equivalence_hash_() = std::move(x.m_equivalence_hash);
 3089|      0|                            break;
 3090|       |
 3091|      0|                        case 0x0000000c:
  ------------------
  |  Branch (3091:25): [True: 0, False: 30]
  ------------------
 3092|      0|                            extended_defn_() = std::move(x.m_extended_defn);
 3093|      0|                            break;
 3094|       |
 3095|     30|        }
 3096|       |
 3097|     30|        return *this;
 3098|     30|    }
_ZN8eprosima7fastdds3dds6xtypes14TypeIdentifier2_dEh:
 3194|     15|    {
 3195|     15|        bool valid_discriminator = false;
 3196|       |
 3197|     15|        switch (__d)
 3198|     15|        {
 3199|      0|                        case TK_NONE:
  ------------------
  |  Branch (3199:25): [True: 0, False: 15]
  ------------------
 3200|      1|                        case TK_BOOLEAN:
  ------------------
  |  Branch (3200:25): [True: 1, False: 14]
  ------------------
 3201|      2|                        case TK_BYTE:
  ------------------
  |  Branch (3201:25): [True: 1, False: 14]
  ------------------
 3202|      3|                        case TK_INT8:
  ------------------
  |  Branch (3202:25): [True: 1, False: 14]
  ------------------
 3203|      4|                        case TK_INT16:
  ------------------
  |  Branch (3203:25): [True: 1, False: 14]
  ------------------
 3204|      5|                        case TK_INT32:
  ------------------
  |  Branch (3204:25): [True: 1, False: 14]
  ------------------
 3205|      6|                        case TK_INT64:
  ------------------
  |  Branch (3205:25): [True: 1, False: 14]
  ------------------
 3206|      7|                        case TK_UINT8:
  ------------------
  |  Branch (3206:25): [True: 1, False: 14]
  ------------------
 3207|      8|                        case TK_UINT16:
  ------------------
  |  Branch (3207:25): [True: 1, False: 14]
  ------------------
 3208|      9|                        case TK_UINT32:
  ------------------
  |  Branch (3208:25): [True: 1, False: 14]
  ------------------
 3209|     10|                        case TK_UINT64:
  ------------------
  |  Branch (3209:25): [True: 1, False: 14]
  ------------------
 3210|     11|                        case TK_FLOAT32:
  ------------------
  |  Branch (3210:25): [True: 1, False: 14]
  ------------------
 3211|     12|                        case TK_FLOAT64:
  ------------------
  |  Branch (3211:25): [True: 1, False: 14]
  ------------------
 3212|     13|                        case TK_FLOAT128:
  ------------------
  |  Branch (3212:25): [True: 1, False: 14]
  ------------------
 3213|     14|                        case TK_CHAR8:
  ------------------
  |  Branch (3213:25): [True: 1, False: 14]
  ------------------
 3214|     15|                        case TK_CHAR16:
  ------------------
  |  Branch (3214:25): [True: 1, False: 14]
  ------------------
 3215|     15|                            if (0x00000001 == selected_member_)
  ------------------
  |  Branch (3215:33): [True: 15, False: 0]
  ------------------
 3216|     15|                            {
 3217|     15|                                valid_discriminator = true;
 3218|     15|                            }
 3219|     15|                            break;
 3220|       |
 3221|      0|                        case TI_STRING8_SMALL:
  ------------------
  |  Branch (3221:25): [True: 0, False: 15]
  ------------------
 3222|      0|                        case TI_STRING16_SMALL:
  ------------------
  |  Branch (3222:25): [True: 0, False: 15]
  ------------------
 3223|      0|                            if (0x00000002 == selected_member_)
  ------------------
  |  Branch (3223:33): [True: 0, False: 0]
  ------------------
 3224|      0|                            {
 3225|      0|                                valid_discriminator = true;
 3226|      0|                            }
 3227|      0|                            break;
 3228|       |
 3229|      0|                        case TI_STRING8_LARGE:
  ------------------
  |  Branch (3229:25): [True: 0, False: 15]
  ------------------
 3230|      0|                        case TI_STRING16_LARGE:
  ------------------
  |  Branch (3230:25): [True: 0, False: 15]
  ------------------
 3231|      0|                            if (0x00000003 == selected_member_)
  ------------------
  |  Branch (3231:33): [True: 0, False: 0]
  ------------------
 3232|      0|                            {
 3233|      0|                                valid_discriminator = true;
 3234|      0|                            }
 3235|      0|                            break;
 3236|       |
 3237|      0|                        case TI_PLAIN_SEQUENCE_SMALL:
  ------------------
  |  Branch (3237:25): [True: 0, False: 15]
  ------------------
 3238|      0|                            if (0x00000004 == selected_member_)
  ------------------
  |  Branch (3238:33): [True: 0, False: 0]
  ------------------
 3239|      0|                            {
 3240|      0|                                valid_discriminator = true;
 3241|      0|                            }
 3242|      0|                            break;
 3243|       |
 3244|      0|                        case TI_PLAIN_SEQUENCE_LARGE:
  ------------------
  |  Branch (3244:25): [True: 0, False: 15]
  ------------------
 3245|      0|                            if (0x00000005 == selected_member_)
  ------------------
  |  Branch (3245:33): [True: 0, False: 0]
  ------------------
 3246|      0|                            {
 3247|      0|                                valid_discriminator = true;
 3248|      0|                            }
 3249|      0|                            break;
 3250|       |
 3251|      0|                        case TI_PLAIN_ARRAY_SMALL:
  ------------------
  |  Branch (3251:25): [True: 0, False: 15]
  ------------------
 3252|      0|                            if (0x00000006 == selected_member_)
  ------------------
  |  Branch (3252:33): [True: 0, False: 0]
  ------------------
 3253|      0|                            {
 3254|      0|                                valid_discriminator = true;
 3255|      0|                            }
 3256|      0|                            break;
 3257|       |
 3258|      0|                        case TI_PLAIN_ARRAY_LARGE:
  ------------------
  |  Branch (3258:25): [True: 0, False: 15]
  ------------------
 3259|      0|                            if (0x00000007 == selected_member_)
  ------------------
  |  Branch (3259:33): [True: 0, False: 0]
  ------------------
 3260|      0|                            {
 3261|      0|                                valid_discriminator = true;
 3262|      0|                            }
 3263|      0|                            break;
 3264|       |
 3265|      0|                        case TI_PLAIN_MAP_SMALL:
  ------------------
  |  Branch (3265:25): [True: 0, False: 15]
  ------------------
 3266|      0|                            if (0x00000008 == selected_member_)
  ------------------
  |  Branch (3266:33): [True: 0, False: 0]
  ------------------
 3267|      0|                            {
 3268|      0|                                valid_discriminator = true;
 3269|      0|                            }
 3270|      0|                            break;
 3271|       |
 3272|      0|                        case TI_PLAIN_MAP_LARGE:
  ------------------
  |  Branch (3272:25): [True: 0, False: 15]
  ------------------
 3273|      0|                            if (0x00000009 == selected_member_)
  ------------------
  |  Branch (3273:33): [True: 0, False: 0]
  ------------------
 3274|      0|                            {
 3275|      0|                                valid_discriminator = true;
 3276|      0|                            }
 3277|      0|                            break;
 3278|       |
 3279|      0|                        case TI_STRONGLY_CONNECTED_COMPONENT:
  ------------------
  |  Branch (3279:25): [True: 0, False: 15]
  ------------------
 3280|      0|                            if (0x0000000a == selected_member_)
  ------------------
  |  Branch (3280:33): [True: 0, False: 0]
  ------------------
 3281|      0|                            {
 3282|      0|                                valid_discriminator = true;
 3283|      0|                            }
 3284|      0|                            break;
 3285|       |
 3286|      0|                        case EK_COMPLETE:
  ------------------
  |  Branch (3286:25): [True: 0, False: 15]
  ------------------
 3287|      0|                        case EK_MINIMAL:
  ------------------
  |  Branch (3287:25): [True: 0, False: 15]
  ------------------
 3288|      0|                            if (0x0000000b == selected_member_)
  ------------------
  |  Branch (3288:33): [True: 0, False: 0]
  ------------------
 3289|      0|                            {
 3290|      0|                                valid_discriminator = true;
 3291|      0|                            }
 3292|      0|                            break;
 3293|       |
 3294|      0|                        default:
  ------------------
  |  Branch (3294:25): [True: 0, False: 15]
  ------------------
 3295|      0|                            if (0x0000000c == selected_member_)
  ------------------
  |  Branch (3295:33): [True: 0, False: 0]
  ------------------
 3296|      0|                            {
 3297|      0|                                valid_discriminator = true;
 3298|      0|                            }
 3299|      0|                            break;
 3300|       |
 3301|     15|        }
 3302|       |
 3303|     15|        if (!valid_discriminator)
  ------------------
  |  Branch (3303:13): [True: 0, False: 15]
  ------------------
 3304|      0|        {
 3305|      0|            throw eprosima::fastcdr::exception::BadParamException("Discriminator doesn't correspond with the selected union member");
 3306|      0|        }
 3307|       |
 3308|     15|        m__d = __d;
 3309|     15|    }
_ZN8eprosima7fastdds3dds6xtypes14TypeIdentifier9no_value_Ev:
 3960|  1.74k|            {
 3961|  1.74k|                if (0x00000001 != selected_member_)
  ------------------
  |  Branch (3961:21): [True: 0, False: 1.74k]
  ------------------
 3962|      0|                {
 3963|      0|                    if (member_destructor_)
  ------------------
  |  Branch (3963:25): [True: 0, False: 0]
  ------------------
 3964|      0|                    {
 3965|      0|                        member_destructor_();
 3966|      0|                    }
 3967|       |
 3968|      0|                    selected_member_ = 0x00000001;
 3969|      0|                    member_destructor_ = [&]()
 3970|      0|                    {
 3971|      0|                        m_no_value.~Dummy();
 3972|      0|                    };
 3973|      0|                    new(&m_no_value) Dummy();
 3974|       |
 3975|      0|                }
 3976|       |
 3977|  1.74k|                return m_no_value;
 3978|  1.74k|            }
_ZN8eprosima7fastdds3dds6xtypes10TypeObjectC2Ev:
23470|   197k|    {
23471|   197k|    }
_ZN8eprosima7fastdds3dds6xtypes10TypeObjectD2Ev:
23477|   192k|    {
23478|   192k|        if (member_destructor_)
  ------------------
  |  Branch (23478:13): [True: 0, False: 192k]
  ------------------
23479|      0|        {
23480|      0|            member_destructor_();
23481|      0|        }
23482|   192k|    }
_ZN8eprosima7fastdds3dds6xtypes10TypeObjectaSERKS3_:
23534|    560|    {
23535|    560|        m__d = x.m__d;
23536|       |
23537|    560|        switch (x.selected_member_)
  ------------------
  |  Branch (23537:17): [True: 560, False: 0]
  ------------------
23538|    560|        {
23539|      0|                        case 0x00000001:
  ------------------
  |  Branch (23539:25): [True: 0, False: 560]
  ------------------
23540|      0|                            complete_() = x.m_complete;
23541|      0|                            break;
23542|       |
23543|      0|                        case 0x00000002:
  ------------------
  |  Branch (23543:25): [True: 0, False: 560]
  ------------------
23544|      0|                            minimal_() = x.m_minimal;
23545|      0|                            break;
23546|       |
23547|    560|        }
23548|       |
23549|    560|        return *this;
23550|    560|    }
_ZN8eprosima7fastdds3dds6xtypes18TypeIdentifierPairC2Ev:
24040|      1|    {
24041|      1|    }
_ZN8eprosima7fastdds3dds6xtypes18TypeIdentifierPairD2Ev:
24047|     31|    {
24048|     31|    }
_ZN8eprosima7fastdds3dds6xtypes18TypeIdentifierPairC2ERKS3_:
24056|     15|    {
24057|     15|                    m_type_identifier1 = x.m_type_identifier1;
24058|       |
24059|     15|                    m_type_identifier2 = x.m_type_identifier2;
24060|       |
24061|     15|    }
_ZN8eprosima7fastdds3dds6xtypes18TypeIdentifierPairC2EOS3_:
24069|     15|    {
24070|     15|        m_type_identifier1 = std::move(x.m_type_identifier1);
24071|     15|        m_type_identifier2 = std::move(x.m_type_identifier2);
24072|     15|    }
_ZN8eprosima7fastdds3dds6xtypes18TypeIdentifierPair16type_identifier1Ev:
24157|     15|    {
24158|     15|        return m_type_identifier1;
24159|     15|    }
_ZN8eprosima7fastdds3dds6xtypes21TypeIdentfierWithSizeC2Ev:
24222|   395k|    {
24223|   395k|    }
_ZN8eprosima7fastdds3dds6xtypes21TypeIdentfierWithSizeD2Ev:
24229|   385k|    {
24230|   385k|    }
_ZN8eprosima7fastdds3dds6xtypes21TypeIdentfierWithSizeaSERKS3_:
24262|  1.12k|    {
24263|       |
24264|  1.12k|                    m_type_id = x.m_type_id;
24265|       |
24266|  1.12k|                    m_typeobject_serialized_size = x.m_typeobject_serialized_size;
24267|       |
24268|  1.12k|        return *this;
24269|  1.12k|    }
_ZN8eprosima7fastdds3dds6xtypes30TypeIdentifierWithDependenciesC2Ev:
24394|   395k|    {
24395|   395k|    }
_ZN8eprosima7fastdds3dds6xtypes30TypeIdentifierWithDependenciesD2Ev:
24401|   385k|    {
24402|   385k|    }
_ZN8eprosima7fastdds3dds6xtypes30TypeIdentifierWithDependenciesaSERKS3_:
24437|  1.12k|    {
24438|       |
24439|  1.12k|                    m_typeid_with_size = x.m_typeid_with_size;
24440|       |
24441|  1.12k|                    m_dependent_typeid_count = x.m_dependent_typeid_count;
24442|       |
24443|  1.12k|                    m_dependent_typeids = x.m_dependent_typeids;
24444|       |
24445|  1.12k|        return *this;
24446|  1.12k|    }
_ZN8eprosima7fastdds3dds6xtypes15TypeInformationC2Ev:
24613|   197k|    {
24614|   197k|    }
_ZN8eprosima7fastdds3dds6xtypes15TypeInformationD2Ev:
24620|   192k|    {
24621|   192k|    }
_ZN8eprosima7fastdds3dds6xtypes15TypeInformationaSERKS3_:
24653|    560|    {
24654|       |
24655|    560|                    m_minimal = x.m_minimal;
24656|       |
24657|    560|                    m_complete = x.m_complete;
24658|       |
24659|    560|        return *this;
24660|    560|    }
_ZZN8eprosima7fastdds3dds6xtypes14TypeIdentifierC1EvENKUlvE_clEv:
 2830|   577k|        {
 2831|   577k|            m_no_value.~Dummy();
 2832|   577k|        };

_ZN8eprosima7fastdds4rtps14PropertyPolicyC2Ev:
   34|   278k|    {
   35|   278k|    }
_ZN8eprosima7fastdds4rtps14PropertyPolicyC2ERKS2_:
   39|      1|        : properties_(property_policy.properties_)
   40|      1|        , binary_properties_(property_policy.binary_properties_)
   41|      1|    {
   42|      1|    }
_ZN8eprosima7fastdds4rtps14PropertyPolicyaSERKS2_:
   53|    709|    {
   54|    709|        properties_ = property_policy.properties_;
   55|    709|        binary_properties_ = property_policy.binary_properties_;
   56|    709|        return *this;
   57|    709|    }
_ZN8eprosima7fastdds4rtps14PropertyPolicy10propertiesEv:
   88|     10|    {
   89|     10|        return properties_;
   90|     10|    }

_ZN8eprosima7fastdds4rtps19SimpleEDPAttributesC2Ev:
  199|   105k|        : use_PublicationWriterANDSubscriptionReader(true)
  200|   105k|        , use_PublicationReaderANDSubscriptionWriter(true)
  201|       |#if HAVE_SECURITY
  202|       |        , enable_builtin_secure_publications_writer_and_subscriptions_reader(true)
  203|       |        , enable_builtin_secure_subscriptions_writer_and_publications_reader(true)
  204|       |#endif // if HAVE_SECURITY
  205|   105k|    {
  206|   105k|    }
_ZN8eprosima7fastdds4rtps25RTPSParticipantAttributes7setNameEPKc:
  554|  1.90k|    {
  555|  1.90k|        name = nam;
  556|  1.90k|    }
_ZN8eprosima7fastdds4rtps17BuiltinAttributesD2Ev:
  400|   104k|    virtual ~BuiltinAttributes() = default;
_ZN8eprosima7fastdds4rtps17BuiltinAttributesC2Ev:
  398|   105k|    BuiltinAttributes() = default;
_ZN8eprosima7fastdds4rtps17DiscoverySettingsC2Ev:
  299|   105k|    DiscoverySettings() = default;
_ZN8eprosima7fastdds4rtps25RTPSParticipantAttributesC2Ev:
  433|   105k|    RTPSParticipantAttributes() = default;
_ZN8eprosima7fastdds4rtps25RTPSParticipantAttributesD2Ev:
  435|   104k|    virtual ~RTPSParticipantAttributes() = default;

_ZN8eprosima7fastdds4rtps10EntityId_tC2Ej:
   92|  6.15k|    {
   93|  6.15k|        memcpy(value, &id, size);
   94|  6.15k|#if !FASTDDS_IS_BIG_ENDIAN_TARGET
   95|  6.15k|        reverse();
   96|  6.15k|#endif // if !FASTDDS_IS_BIG_ENDIAN_TARGET
   97|  6.15k|    }
_ZN8eprosima7fastdds4rtps10EntityId_t7reverseEv:
  149|  6.48k|    {
  150|  6.48k|        octet oaux;
  151|  6.48k|        oaux = value[3];
  152|  6.48k|        value[3] = value[0];
  153|  6.48k|        value[0] = oaux;
  154|  6.48k|        oaux = value[2];
  155|  6.48k|        value[2] = value[1];
  156|  6.48k|        value[1] = oaux;
  157|  6.48k|    }
_ZN8eprosima7fastdds4rtps10EntityId_tC2Ev:
   82|    328|    {
   83|    328|        *this = ENTITYID_UNKNOWN;
  ------------------
  |  |   34|    328|#define ENTITYID_UNKNOWN 0x00000000
  ------------------
   84|    328|    }
_ZN8eprosima7fastdds4rtps10EntityId_taSEj:
  137|    328|    {
  138|    328|        memcpy(value, &id, size);
  139|    328|#if !FASTDDS_IS_BIG_ENDIAN_TARGET
  140|    328|        reverse();
  141|    328|#endif // if !FASTDDS_IS_BIG_ENDIAN_TARGET
  142|    328|        return *this;
  143|       |        //return id;
  144|    328|    }

_ZN8eprosima7fastdds4rtps6GUID_tC2Ev:
   50|    328|    {
   51|    328|    }
_ZN8eprosima7fastdds4rtps6GUID_t7unknownEv:
  139|      4|    {
  140|      4|        return GUID_t();
  141|      4|    }

_ZN8eprosima7fastdds4rtps12GuidPrefix_tC2Ev:
   43|   105k|    {
   44|   105k|        memset(value, 0, size);
   45|   105k|    }

_ZN8eprosima7fastdds4rtps11LocatorListC2Ev:
  104|  1.15M|    {
  105|  1.15M|    }
_ZN8eprosima7fastdds4rtps11LocatorListD2Ev:
  109|  1.13M|    {
  110|  1.13M|    }
_ZN8eprosima7fastdds4rtps11LocatorListC2ERKS2_:
  115|      6|        : m_locators(list.m_locators)
  116|      6|    {
  117|      6|    }
_ZN8eprosima7fastdds4rtps11LocatorListaSERKS2_:
  129|  2.83k|    {
  130|  2.83k|        m_locators = list.m_locators;
  131|  2.83k|        return *this;
  132|  2.83k|    }

_ZN8eprosima7fastdds4rtps14PortParametersC2Ev:
   38|   105k|        : portBase(7400)
   39|   105k|        , domainIDGain(250)
   40|   105k|        , participantIDGain(2)
   41|   105k|        , offsetd0(0)
   42|   105k|        , offsetd1(10)
   43|   105k|        , offsetd2(1)
   44|   105k|        , offsetd3(11)
   45|   105k|        , offsetd4(2)
   46|   105k|    {
   47|   105k|    }
_ZN8eprosima7fastdds4rtps14PortParametersD2Ev:
   50|   104k|    {
   51|   104k|    }

_ZN8eprosima7fastdds4rtps8PropertyC2ERKS2_:
   40|      9|        : name_(property.name_)
   41|      9|        , value_(property.value_)
   42|      9|        , propagate_(property.propagate_)
   43|      9|    {
   44|      9|    }
_ZN8eprosima7fastdds4rtps8PropertyC2EONSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEESA_b:
   68|     10|        : name_(std::move(name))
   69|     10|        , value_(std::move(value))
   70|     10|        , propagate_(propagate)
   71|     10|    {
   72|     10|    }

_ZN8eprosima7fastdds4rtps14SampleIdentityC2Ev:
   41|      4|        : writer_guid_(GUID_t::unknown())
   42|      4|        , sequence_number_(SequenceNumber_t::unknown())
   43|      4|    {
   44|      4|    }

_ZN8eprosima7fastdds4rtps16SequenceNumber_tC2Eij:
   58|    320|        : high(hi)
   59|    320|        , low(lo)
   60|    320|    {
   61|    320|    }
_ZN8eprosima7fastdds4rtps16SequenceNumber_t7unknownEv:
  124|      4|    {
  125|      4|        return {-1, 0};
  126|      4|    }

_ZN8eprosima7fastdds4rtps19SerializedPayload_tC2Ev:
   78|   173k|        : encapsulation(CDR_BE)
  ------------------
  |  |   43|   173k|#define CDR_BE 0x0000
  ------------------
   79|   173k|        , length(0)
   80|   173k|        , data(nullptr)
   81|   173k|        , max_size(0)
   82|   173k|        , pos(0)
   83|   173k|    {
   84|   173k|    }

_ZN8eprosima7fastdds4rtps17ProtocolVersion_tC2Ehh:
  122|  1.86k|        : m_major(maj)
  123|  1.86k|        , m_minor(min)
  124|  1.86k|    {
  125|  1.86k|    }
_ZN8eprosima7fastdds4rtps17ProtocolVersion_tC2Ev:
  114|    368|        ProtocolVersion_t(2, 2)
  115|       |#endif // if HAVE_SECURITY
  116|    368|    {
  117|    368|    }

_ZN8eprosima7fastdds4rtps11WriteParams16UserWriteDataPtrC2ENSt3__110shared_ptrINS2_13UserWriteDataEEE:
  248|      2|            : std::shared_ptr<UserWriteData>(ptr)
  249|      2|        {
  250|      2|        }

_ZN8eprosima7fastdds30ResourceLimitedContainerConfigC2Emmm:
   42|  1.22M|        : initial(ini)
   43|  1.22M|        , maximum(max)
   44|  1.22M|        , increment(inc)
   45|  1.22M|    {
   46|  1.22M|    }

_ZN8eprosima7fastdds21ResourceLimitedVectorIhNSt3__117integral_constantIbLb0EEENS0_30ResourceLimitedContainerConfigENS2_9allocatorIhEENS2_6vectorIhS7_EEEC2ERKSA_:
  100|      1|        : configuration_(other.configuration_)
  101|      1|        , collection_(other.collection_.get_allocator())
  102|      1|    {
  103|      1|        collection_.reserve(other.collection_.capacity());
  104|      1|        collection_.assign(other.collection_.begin(), other.collection_.end());
  105|      1|    }
_ZN8eprosima7fastdds21ResourceLimitedVectorIhNSt3__117integral_constantIbLb0EEENS0_30ResourceLimitedContainerConfigENS2_9allocatorIhEENS2_6vectorIhS7_EEED2Ev:
  107|   509k|    virtual ~ResourceLimitedVector () = default;
_ZN8eprosima7fastdds21ResourceLimitedVectorIhNSt3__117integral_constantIbLb0EEENS0_30ResourceLimitedContainerConfigENS2_9allocatorIhEENS2_6vectorIhS7_EEEC2ES5_RKS7_:
   92|   521k|        : configuration_(cfg)
   93|   521k|        , collection_(alloc)
   94|   521k|    {
   95|   521k|        collection_.reserve(cfg.initial);
   96|   521k|    }

_ZN8eprosima7fastdds3dds14SampleIdentityC2Ev:
  586|     20|    {
  587|     20|    }
_ZN8eprosima7fastdds3dds6GUID_tC2Ev:
  246|     20|    {
  247|     20|    }
_ZN8eprosima7fastdds3dds10EntityId_tC2Ev:
   76|     20|    {
   77|     20|    }
_ZN8eprosima7fastdds3dds16SequenceNumber_tC2Ev:
  426|     20|    {
  427|     20|    }

_ZN8eprosima7fastdds3dds6Time_tC2Ev:
   30|   173k|{
   31|   173k|    seconds = 0;
   32|   173k|    nanosec = 0;
   33|   173k|}
_ZN8eprosima7fastdds3dds6Time_tC2Eij:
   38|  2.28M|{
   39|  2.28M|    seconds = sec;
   40|  2.28M|    nanosec = nsec;
   41|  2.28M|}

_ZN8eprosima7fastdds3dds24DomainParticipantFactoryC2Ev:
   53|      1|    : default_xml_profiles_loaded(false)
   54|      1|    , default_domain_id_(0)
   55|      1|    , default_participant_qos_(PARTICIPANT_QOS_DEFAULT)
   56|      1|    , topic_pool_(rtps::TopicPayloadPoolRegistry::instance())
   57|      1|    , rtps_domain_(rtps::RTPSDomainImpl::get_instance())
   58|      1|    , log_resources_(detail::get_log_resources())
   59|      1|{
   60|      1|}
_ZN8eprosima7fastdds3dds24DomainParticipantFactoryD2Ev:
   63|      1|{
   64|      1|    {
   65|      1|        std::lock_guard<std::mutex> guard(mtx_participants_);
   66|      1|        for (auto it : participants_)
  ------------------
  |  Branch (66:22): [True: 0, False: 1]
  ------------------
   67|      0|        {
   68|      0|            for (auto pit : it.second)
  ------------------
  |  Branch (68:27): [True: 0, False: 0]
  ------------------
   69|      0|            {
   70|      0|                pit->disable();
   71|      0|                delete pit;
   72|      0|            }
   73|      0|        }
   74|      1|        participants_.clear();
   75|      1|    }
   76|       |
   77|       |    // Deletes DynamicTypes and TypeObject factories
   78|      1|    dds::DynamicDataFactory::delete_instance();
   79|      1|    dds::DynamicTypeBuilderFactory::delete_instance();
   80|       |
   81|      1|    std::this_thread::sleep_for(std::chrono::milliseconds(100));
   82|      1|    Log::KillThread();
   83|      1|}
_ZN8eprosima7fastdds3dds24DomainParticipantFactory12get_instanceEv:
   86|  20.0k|{
   87|  20.0k|    return get_shared_instance().get();
   88|  20.0k|}
_ZN8eprosima7fastdds3dds24DomainParticipantFactory19get_shared_instanceEv:
   91|  20.0k|{
   92|       |    // Note we need a custom deleter, since the destructor is protected.
   93|  20.0k|    static std::shared_ptr<DomainParticipantFactory> instance(
   94|  20.0k|        new DomainParticipantFactory(),
   95|  20.0k|        [](DomainParticipantFactory* p)
   96|  20.0k|        {
   97|  20.0k|            delete p;
   98|  20.0k|        });
   99|  20.0k|    return instance;
  100|  20.0k|}
_ZN8eprosima7fastdds3dds24DomainParticipantFactory24load_XML_profiles_stringEPKcm:
  523|  20.0k|{
  524|  20.0k|    if (XMLP_ret::XML_ERROR == XMLProfileManager::loadXMLString(data, length))
  ------------------
  |  Branch (524:9): [True: 17.7k, False: 2.25k]
  ------------------
  525|  17.7k|    {
  526|  17.7k|        EPROSIMA_LOG_ERROR(DDS_DOMAIN, "Problem loading XML string");
  ------------------
  |  |   45|  17.7k|#define EPROSIMA_LOG_ERROR(cat, msg) EPROSIMA_LOG_ERROR_IMPL_(cat, msg)
  |  |  ------------------
  |  |  |  |  291|  17.7k|    do {                                                                                                               \
  |  |  |  |  292|  17.7k|        std::stringstream fastdds_log_ss_tmp__;                                                                        \
  |  |  |  |  293|  17.7k|        fastdds_log_ss_tmp__ << msg;                                                                                   \
  |  |  |  |  294|  17.7k|        eprosima::fastdds::dds::Log::QueueLog(                                                                         \
  |  |  |  |  295|  17.7k|            fastdds_log_ss_tmp__.str(), eprosima::fastdds::dds::Log::Context{__FILE__, __LINE__, __func__, #cat},      \
  |  |  |  |  296|  17.7k|            eprosima::fastdds::dds::Log::Kind::Error);                                                                 \
  |  |  |  |  297|  17.7k|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (297:14): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  527|  17.7k|        return RETCODE_ERROR;
  528|  17.7k|    }
  529|  2.25k|    return RETCODE_OK;
  530|  20.0k|}
DomainParticipantFactory.cpp:_ZZN8eprosima7fastdds3dds24DomainParticipantFactory19get_shared_instanceEvENK3$_0clEPS2_:
   96|      1|        {
   97|      1|            delete p;
   98|      1|        });

_ZN8eprosima7fastdds3dds6detail17get_log_resourcesEv:
  403|  1.32M|{
  404|  1.32M|    static std::shared_ptr<LogResources> instance = std::make_shared<LogResources>();
  405|  1.32M|    return instance;
  406|  1.32M|}
_ZN8eprosima7fastdds3dds3Log10KillThreadEv:
  444|      1|{
  445|      1|    detail::get_log_resources()->KillThread();
  446|      1|}
_ZN8eprosima7fastdds3dds3Log8QueueLogERKNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEERKNS2_7ContextENS2_4KindE:
  452|  1.32M|{
  453|  1.32M|    detail::get_log_resources()->QueueLog(message, context, kind);
  454|  1.32M|}
_ZN8eprosima7fastdds3dds3Log12GetVerbosityEv:
  457|  2.45k|{
  458|  2.45k|    return detail::get_log_resources()->GetVerbosity();
  459|  2.45k|}
_ZN8eprosima7fastdds3dds3Log15SetThreadConfigERKNS0_4rtps14ThreadSettingsE:
  487|    644|{
  488|    644|    detail::get_log_resources()->SetThreadConfig(config);
  489|    644|}
_ZNK8eprosima7fastdds3dds11LogConsumer15print_timestampERNSt3__113basic_ostreamIcNS3_11char_traitsIcEEEERKNS1_3Log5EntryEb:
  520|  1.32M|{
  521|  1.32M|    std::string white = (color) ? C_B_WHITE : "";
  ------------------
  |  |   55|  1.32M|    #define C_B_WHITE "\033[37;1m"
  ------------------
  |  Branch (521:25): [True: 1.32M, False: 0]
  ------------------
  522|  1.32M|    stream << white << entry.timestamp << " ";
  523|  1.32M|}
_ZNK8eprosima7fastdds3dds11LogConsumer12print_headerERNSt3__113basic_ostreamIcNS3_11char_traitsIcEEEERKNS1_3Log5EntryEb:
  529|  1.32M|{
  530|  1.32M|    std::string c_b_color = (!color) ? "" :
  ------------------
  |  Branch (530:29): [True: 0, False: 1.32M]
  ------------------
  531|  1.32M|            (entry.kind == Log::Kind::Error) ? C_B_RED :
  ------------------
  |  |   43|  1.32M|    #define C_B_RED "\033[31;1m"
  ------------------
  |  Branch (531:13): [True: 1.32M, False: 0]
  ------------------
  532|  1.32M|            (entry.kind == Log::Kind::Warning) ? C_B_YELLOW :
  ------------------
  |  |   47|      0|    #define C_B_YELLOW "\033[33;1m"
  ------------------
  |  Branch (532:13): [True: 0, False: 0]
  ------------------
  533|      0|            (entry.kind == Log::Kind::Info) ? C_B_GREEN : "";
  ------------------
  |  |   45|      0|    #define C_B_GREEN "\033[32;1m"
  ------------------
  |  Branch (533:13): [True: 0, False: 0]
  ------------------
  534|       |
  535|  1.32M|    std::string white = (color) ? C_B_WHITE : "";
  ------------------
  |  |   55|  1.32M|    #define C_B_WHITE "\033[37;1m"
  ------------------
  |  Branch (535:25): [True: 1.32M, False: 0]
  ------------------
  536|       |
  537|  1.32M|    stream << c_b_color << "[" << white << entry.context.category << c_b_color << " " << entry.kind << "] ";
  538|  1.32M|}
_ZNK8eprosima7fastdds3dds11LogConsumer13print_contextERNSt3__113basic_ostreamIcNS3_11char_traitsIcEEEERKNS1_3Log5EntryEb:
  544|  1.32M|{
  545|  1.32M|    if (color)
  ------------------
  |  Branch (545:9): [True: 1.32M, False: 0]
  ------------------
  546|  1.32M|    {
  547|  1.32M|        stream << C_B_BLUE;
  ------------------
  |  |   49|  1.32M|    #define C_B_BLUE "\033[34;1m"
  ------------------
  548|  1.32M|    }
  549|  1.32M|    if (entry.context.filename)
  ------------------
  |  Branch (549:9): [True: 0, False: 1.32M]
  ------------------
  550|      0|    {
  551|      0|        stream << " (" << entry.context.filename;
  552|      0|        stream << ":" << entry.context.line << ")";
  553|      0|    }
  554|  1.32M|    if (entry.context.function)
  ------------------
  |  Branch (554:9): [True: 1.32M, False: 0]
  ------------------
  555|  1.32M|    {
  556|  1.32M|        stream << " -> Function ";
  557|  1.32M|        if (color)
  ------------------
  |  Branch (557:13): [True: 1.32M, False: 0]
  ------------------
  558|  1.32M|        {
  559|  1.32M|            stream << C_CYAN;
  ------------------
  |  |   52|  1.32M|    #define C_CYAN "\033[36m"
  ------------------
  560|  1.32M|        }
  561|  1.32M|        stream << entry.context.function;
  562|  1.32M|    }
  563|  1.32M|}
_ZNK8eprosima7fastdds3dds11LogConsumer13print_messageERNSt3__113basic_ostreamIcNS3_11char_traitsIcEEEERKNS1_3Log5EntryEb:
  569|  1.32M|{
  570|  1.32M|    std::string white = (color) ? C_WHITE : "";
  ------------------
  |  |   54|  1.32M|    #define C_WHITE "\033[37m"
  ------------------
  |  Branch (570:25): [True: 1.32M, False: 0]
  ------------------
  571|  1.32M|    stream << white << entry.message;
  572|  1.32M|}
_ZNK8eprosima7fastdds3dds11LogConsumer14print_new_lineERNSt3__113basic_ostreamIcNS3_11char_traitsIcEEEEb:
  577|  1.32M|{
  578|  1.32M|    std::string def = (color) ? C_DEF : "";
  ------------------
  |  |   41|  1.32M|    #define C_DEF "\033[m"
  ------------------
  |  Branch (578:23): [True: 1.32M, False: 0]
  ------------------
  579|  1.32M|    stream << def << std::endl;
  580|  1.32M|}
_ZN8eprosima7fastdds3dds6detail12LogResources5FlushEv:
  199|      1|    {
  200|      1|        std::unique_lock<std::mutex> guard(cv_mutex_);
  201|       |
  202|      1|        if (!logging_ && !logging_thread_.joinable())
  ------------------
  |  Branch (202:13): [True: 1, False: 0]
  |  Branch (202:26): [True: 1, False: 0]
  ------------------
  203|      1|        {
  204|       |            // already killed
  205|      1|            return;
  206|      1|        }
  207|       |
  208|       |        /*   Flush() two steps strategy:
  209|       |
  210|       |             We must assure Log::Run swaps the queues twice
  211|       |             because its the only way the content in the background queue
  212|       |             will be consumed (first Run() loop).
  213|       |
  214|       |             Then, we must assure the new front queue content is consumed (second Run() loop).
  215|       |         */
  216|       |
  217|      0|        int last_loop = current_loop_;
  218|       |
  219|      0|        for (int i = 0; i < 2; ++i)
  ------------------
  |  Branch (219:25): [True: 0, False: 0]
  ------------------
  220|      0|        {
  221|      0|            cv_.wait(guard,
  222|      0|                    [&]()
  223|      0|                    {
  224|       |                        /* We must avoid:
  225|       |                         + the two calls be processed without an intermediate Run() loop
  226|       |                           (by using last_loop sequence number and checking if the foreground queue is empty)
  227|       |                         + deadlock by absence of Run() loop activity (by using BothEmpty() call)
  228|       |                         */
  229|      0|                        return !logging_ ||
  230|      0|                        logs_.BothEmpty() ||
  231|      0|                        (last_loop != current_loop_ && logs_.Empty());
  232|      0|                    });
  233|       |
  234|      0|            last_loop = current_loop_;
  235|       |
  236|      0|        }
  237|      0|    }
_ZN8eprosima7fastdds3dds6detail12LogResources10KillThreadEv:
  272|      2|    {
  273|      2|        {
  274|      2|            std::unique_lock<std::mutex> guard(cv_mutex_);
  275|      2|            logging_ = false;
  276|      2|            work_ = false;
  277|      2|        }
  278|       |
  279|      2|        if (logging_thread_.joinable())
  ------------------
  |  Branch (279:13): [True: 1, False: 1]
  ------------------
  280|      1|        {
  281|      1|            cv_.notify_all();
  282|      1|            if (!logging_thread_.is_calling_thread())
  ------------------
  |  Branch (282:17): [True: 1, False: 0]
  ------------------
  283|      1|            {
  284|      1|                logging_thread_.join();
  285|      1|            }
  286|      1|        }
  287|      2|    }
_ZN8eprosima7fastdds3dds6detail12LogResources8QueueLogERKNSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEERKNS1_3Log7ContextENSD_4KindE:
  252|  1.32M|    {
  253|  1.32M|        StartThread();
  254|       |
  255|  1.32M|        std::string timestamp = SystemInfo::get_timestamp();
  256|  1.32M|        logs_.Push(Log::Entry{ message, context, kind, timestamp });
  257|  1.32M|        {
  258|  1.32M|            std::unique_lock<std::mutex> guard(cv_mutex_);
  259|  1.32M|            work_ = true;
  260|       |            // pessimization
  261|  1.32M|            cv_.notify_all();
  262|       |            // wait till the thread is initialized
  263|  1.32M|            cv_.wait(guard, [&]
  264|  1.32M|                    {
  265|  1.32M|                        return current_loop_;
  266|  1.32M|                    });
  267|  1.32M|        }
  268|  1.32M|    }
_ZN8eprosima7fastdds3dds6detail12LogResources11StartThreadEv:
  292|  1.32M|    {
  293|  1.32M|        std::unique_lock<std::mutex> guard(cv_mutex_);
  294|  1.32M|        if (!logging_ && !logging_thread_.joinable())
  ------------------
  |  Branch (294:13): [True: 1, False: 1.32M]
  |  Branch (294:26): [True: 1, False: 0]
  ------------------
  295|      1|        {
  296|      1|            logging_ = true;
  297|      1|            auto thread_fn = [this]()
  298|      1|                    {
  299|      1|                        run();
  300|      1|                    };
  301|      1|            logging_thread_ = eprosima::create_thread(thread_fn, thread_settings_, "dds.log");
  302|      1|        }
  303|  1.32M|    }
_ZZN8eprosima7fastdds3dds6detail12LogResources11StartThreadEvENKUlvE_clEv:
  298|      1|                    {
  299|      1|                        run();
  300|      1|                    };
_ZN8eprosima7fastdds3dds6detail12LogResources3runEv:
  306|      1|    {
  307|      1|        std::unique_lock<std::mutex> guard(cv_mutex_);
  308|       |
  309|     13|        while (logging_)
  ------------------
  |  Branch (309:16): [True: 12, False: 1]
  ------------------
  310|     12|        {
  311|     12|            cv_.wait(guard,
  312|     12|                    [&]()
  313|     12|                    {
  314|     12|                        return !logging_ || work_;
  315|     12|                    });
  316|       |
  317|     12|            work_ = false;
  318|       |
  319|     12|            guard.unlock();
  320|     12|            {
  321|     12|                logs_.Swap();
  322|  1.32M|                while (!logs_.Empty())
  ------------------
  |  Branch (322:24): [True: 1.32M, False: 12]
  ------------------
  323|  1.32M|                {
  324|  1.32M|                    Log::Entry& entry = logs_.Front();
  325|  1.32M|                    {
  326|  1.32M|                        std::unique_lock<std::mutex> configGuard(config_mutex_);
  327|       |
  328|  1.32M|                        if (preprocess(entry))
  ------------------
  |  Branch (328:29): [True: 1.32M, False: 0]
  ------------------
  329|  1.32M|                        {
  330|  1.32M|                            for (auto& consumer : consumers_)
  ------------------
  |  Branch (330:49): [True: 1.32M, False: 1.32M]
  ------------------
  331|  1.32M|                            {
  332|  1.32M|                                consumer->Consume(entry);
  333|  1.32M|                            }
  334|  1.32M|                        }
  335|  1.32M|                    }
  336|       |                    // This Pop() is also a barrier for Log::Flush wait condition
  337|  1.32M|                    logs_.Pop();
  338|  1.32M|                }
  339|     12|            }
  340|     12|            guard.lock();
  341|       |
  342|       |            // avoid overflow
  343|     12|            if (++current_loop_ > 10000)
  ------------------
  |  Branch (343:17): [True: 0, False: 12]
  ------------------
  344|      0|            {
  345|      0|                current_loop_ = 0;
  346|      0|            }
  347|       |
  348|     12|            cv_.notify_all();
  349|     12|        }
  350|      1|    }
_ZZN8eprosima7fastdds3dds6detail12LogResources3runEvENKUlvE_clEv:
  313|     13|                    {
  314|     13|                        return !logging_ || work_;
  ------------------
  |  Branch (314:32): [True: 0, False: 13]
  |  Branch (314:45): [True: 12, False: 1]
  ------------------
  315|     13|                    });
_ZN8eprosima7fastdds3dds6detail12LogResources10preprocessERNS1_3Log5EntryE:
  354|  1.32M|    {
  355|  1.32M|        if (category_filter_ && !regex_search(entry.context.category, *category_filter_))
  ------------------
  |  Branch (355:13): [True: 0, False: 1.32M]
  |  Branch (355:33): [True: 0, False: 0]
  ------------------
  356|      0|        {
  357|      0|            return false;
  358|      0|        }
  359|  1.32M|        if (filename_filter_ && !regex_search(entry.context.filename, *filename_filter_))
  ------------------
  |  Branch (359:13): [True: 0, False: 1.32M]
  |  Branch (359:33): [True: 0, False: 0]
  ------------------
  360|      0|        {
  361|      0|            return false;
  362|      0|        }
  363|  1.32M|        if (error_string_filter_ && !regex_search(entry.message, *error_string_filter_))
  ------------------
  |  Branch (363:13): [True: 0, False: 1.32M]
  |  Branch (363:37): [True: 0, False: 0]
  ------------------
  364|      0|        {
  365|      0|            return false;
  366|      0|        }
  367|  1.32M|        if (!filenames_)
  ------------------
  |  Branch (367:13): [True: 1.32M, False: 0]
  ------------------
  368|  1.32M|        {
  369|  1.32M|            entry.context.filename = nullptr;
  370|  1.32M|        }
  371|  1.32M|        if (!functions_)
  ------------------
  |  Branch (371:13): [True: 0, False: 1.32M]
  ------------------
  372|      0|        {
  373|      0|            entry.context.function = nullptr;
  374|      0|        }
  375|       |
  376|  1.32M|        return true;
  377|  1.32M|    }
_ZZN8eprosima7fastdds3dds6detail12LogResources8QueueLogERKNSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEERKNS1_3Log7ContextENSD_4KindEENKUlvE_clEv:
  264|  1.32M|                    {
  265|  1.32M|                        return current_loop_;
  266|  1.32M|                    });
_ZN8eprosima7fastdds3dds6detail12LogResources12GetVerbosityEv:
  106|  2.45k|    {
  107|  2.45k|        return verbosity_;
  108|  2.45k|    }
_ZN8eprosima7fastdds3dds6detail12LogResources15SetThreadConfigERKNS0_4rtps14ThreadSettingsE:
  163|    644|    {
  164|    644|        std::lock_guard<std::mutex> guard(cv_mutex_);
  165|    644|        thread_settings_ = config;
  166|    644|    }
_ZN8eprosima7fastdds3dds6detail12LogResourcesC2Ev:
   40|      1|        : logging_(false)
   41|      1|        , work_(false)
   42|      1|        , current_loop_(0)
   43|      1|        , filenames_(false)
   44|      1|        , functions_(true)
   45|      1|        , verbosity_(Log::Error)
   46|      1|    {
   47|      1|#if STDOUTERR_LOG_CONSUMER
   48|      1|        consumers_.emplace_back(new StdoutErrConsumer);
   49|       |#else
   50|       |        consumers_.emplace_back(new StdoutConsumer);
   51|       |#endif // STDOUTERR_LOG_CONSUMER
   52|      1|    }
_ZN8eprosima7fastdds3dds6detail12LogResourcesD2Ev:
   55|      1|    {
   56|      1|        Flush();
   57|      1|        KillThread();
   58|      1|    }

_ZN8eprosima7fastdds3dds15OStreamConsumer7ConsumeERKNS1_3Log5EntryE:
   23|  1.32M|{
   24|  1.32M|    std::ostream& stream = get_stream(entry);
   25|  1.32M|    print_timestamp(stream, entry, true);
   26|  1.32M|    print_header(stream, entry, true);
   27|  1.32M|    print_message(stream, entry, true);
   28|  1.32M|    print_context(stream, entry, true);
   29|  1.32M|    print_new_line(stream, true);
   30|  1.32M|    stream.flush();
   31|  1.32M|}

_ZN8eprosima7fastdds3dds17StdoutErrConsumer10get_streamERKNS1_3Log5EntryE:
   35|  1.32M|{
   36|       |    // If Log::Kind is stderr_threshold_ or more severe, then use STDERR, else use STDOUT
   37|  1.32M|    if (entry.kind <= stderr_threshold_)
  ------------------
  |  Branch (37:9): [True: 1.32M, False: 0]
  ------------------
   38|  1.32M|    {
   39|  1.32M|        return std::cerr;
   40|  1.32M|    }
   41|      0|    return std::cout;
   42|  1.32M|}

_ZN8eprosima7fastdds3dds13DataWriterQosC2Ev:
   30|      8|{
   31|      8|    reliability_.kind = RELIABLE_RELIABILITY_QOS;
   32|      8|    durability_.kind = TRANSIENT_LOCAL_DURABILITY_QOS;
   33|      8|}

_ZN8eprosima7fastdds3dds9WriterQosC2Ev:
   32|  63.7k|{
   33|  63.7k|    m_reliability.kind = RELIABLE_RELIABILITY_QOS;
   34|  63.7k|    m_durability.kind = TRANSIENT_LOCAL_DURABILITY_QOS;
   35|  63.7k|}
_ZN8eprosima7fastdds3dds9WriterQosD2Ev:
   38|  61.7k|{
   39|  61.7k|}

_ZN8eprosima7fastdds3dds8TopicQosC2Ev:
   29|      2|{
   30|      2|    reliability_.kind = RELIABLE_RELIABILITY_QOS;
   31|      2|    durability_.kind = TRANSIENT_LOCAL_DURABILITY_QOS;
   32|      2|}

_ZN8eprosima7fastdds3dds18DynamicDataFactory15delete_instanceEv:
   29|      1|{
   30|       |    // Delegate into the implementation class
   31|      1|    return DynamicDataFactoryImpl::delete_instance();
   32|      1|}

_ZN8eprosima7fastdds3dds22DynamicDataFactoryImpl15delete_instanceEv:
   36|      1|{
   37|      1|    if (!instance_)
  ------------------
  |  Branch (37:9): [True: 1, False: 0]
  ------------------
   38|      1|    {
   39|      1|        return RETCODE_BAD_PARAMETER;
   40|      1|    }
   41|      0|    instance_.reset();
   42|      0|    return RETCODE_OK;
   43|      1|}

_ZN8eprosima7fastdds3dds25DynamicTypeBuilderFactory12get_instanceEv:
   24|   190k|{
   25|   190k|    return DynamicTypeBuilderFactoryImpl::get_instance();
   26|   190k|}
_ZN8eprosima7fastdds3dds25DynamicTypeBuilderFactory15delete_instanceEv:
   29|      1|{
   30|       |    // Delegate into the implementation class
   31|      1|    return DynamicTypeBuilderFactoryImpl::delete_instance();
   32|      1|}

_ZN8eprosima7fastdds3dds29DynamicTypeBuilderFactoryImpl11create_typeENSt3__110shared_ptrINS1_14TypeDescriptorEEE:
   56|  44.4k|{
   57|  44.4k|    auto descriptor_impl = traits<TypeDescriptor>::narrow<TypeDescriptorImpl>(descriptor);
   58|       |
   59|  44.4k|    if (descriptor_impl->is_consistent())
  ------------------
  |  Branch (59:9): [True: 4.59k, False: 39.8k]
  ------------------
   60|  4.59k|    {
   61|  4.59k|        return std::make_shared<DynamicTypeBuilderImpl>(*descriptor_impl);
   62|  4.59k|    }
   63|       |
   64|  39.8k|    return {};
   65|  44.4k|}
_ZN8eprosima7fastdds3dds29DynamicTypeBuilderFactoryImpl17create_array_typeENSt3__110shared_ptrINS1_11DynamicTypeEEERKNS3_6vectorIjNS3_9allocatorIjEEEE:
  213|  36.4k|{
  214|  36.4k|    traits<DynamicTypeBuilderImpl>::ref_type ret_val {std::make_shared<DynamicTypeBuilderImpl>(
  215|  36.4k|                                                          TypeDescriptorImpl{TK_ARRAY, ""})};
  216|  36.4k|    ret_val->get_descriptor().element_type(element_type);
  217|  36.4k|    ret_val->get_descriptor().bound() = bound;
  218|       |
  219|  36.4k|    if (ret_val->get_descriptor().is_consistent())
  ------------------
  |  Branch (219:9): [True: 24.6k, False: 11.8k]
  ------------------
  220|  24.6k|    {
  221|  24.6k|        return ret_val;
  222|  24.6k|    }
  223|  11.8k|    return {};
  224|  36.4k|}
_ZN8eprosima7fastdds3dds29DynamicTypeBuilderFactoryImpl15create_map_typeENSt3__110shared_ptrINS1_11DynamicTypeEEES6_j:
  246|  8.50k|{
  247|  8.50k|    traits<DynamicTypeBuilderImpl>::ref_type ret_val {std::make_shared<DynamicTypeBuilderImpl>(
  248|  8.50k|                                                          TypeDescriptorImpl{TK_MAP, ""})};
  249|  8.50k|    ret_val->get_descriptor().key_element_type(key_element_type);
  250|  8.50k|    ret_val->get_descriptor().element_type(element_type);
  251|  8.50k|    ret_val->get_descriptor().bound().push_back(bound);
  252|       |
  253|  8.50k|    if (ret_val->get_descriptor().is_consistent())
  ------------------
  |  Branch (253:9): [True: 6.92k, False: 1.57k]
  ------------------
  254|  6.92k|    {
  255|  6.92k|        return ret_val;
  256|  6.92k|    }
  257|       |
  258|  1.57k|    return {};
  259|  8.50k|}
_ZN8eprosima7fastdds3dds29DynamicTypeBuilderFactoryImpl20create_sequence_typeENSt3__110shared_ptrINS1_11DynamicTypeEEEj:
  264|  6.78k|{
  265|  6.78k|    traits<DynamicTypeBuilderImpl>::ref_type ret_val {std::make_shared<DynamicTypeBuilderImpl>(
  266|  6.78k|                                                          TypeDescriptorImpl{TK_SEQUENCE, ""})};
  267|  6.78k|    ret_val->get_descriptor().element_type(element_type);
  268|  6.78k|    ret_val->get_descriptor().bound().push_back(bound);
  269|       |
  270|  6.78k|    if (ret_val->get_descriptor().is_consistent())
  ------------------
  |  Branch (270:9): [True: 5.32k, False: 1.46k]
  ------------------
  271|  5.32k|    {
  272|  5.32k|        return ret_val;
  273|  5.32k|    }
  274|  1.46k|    return {};
  275|  6.78k|}
_ZN8eprosima7fastdds3dds29DynamicTypeBuilderFactoryImpl18create_string_typeEj:
  279|  11.5k|{
  280|  11.5k|    traits<DynamicTypeBuilderImpl>::ref_type ret_val {std::make_shared<DynamicTypeBuilderImpl>(
  281|  11.5k|                                                          TypeDescriptorImpl{TK_STRING8, ""})};
  282|  11.5k|    ret_val->get_descriptor().element_type(char8_type_);
  283|  11.5k|    ret_val->get_descriptor().bound().push_back(bound);
  284|       |
  285|  11.5k|    if (ret_val->get_descriptor().is_consistent())
  ------------------
  |  Branch (285:9): [True: 11.5k, False: 29]
  ------------------
  286|  11.5k|    {
  287|  11.5k|        return ret_val;
  288|  11.5k|    }
  289|     29|    return {};
  290|  11.5k|}
_ZN8eprosima7fastdds3dds29DynamicTypeBuilderFactoryImpl19create_wstring_typeEj:
  294|  5.36k|{
  295|  5.36k|    traits<DynamicTypeBuilderImpl>::ref_type ret_val {std::make_shared<DynamicTypeBuilderImpl>(
  296|  5.36k|                                                          TypeDescriptorImpl{TK_STRING16, ""})};
  297|  5.36k|    ret_val->get_descriptor().element_type(char16_type_);
  298|  5.36k|    ret_val->get_descriptor().bound().push_back(bound);
  299|       |
  300|  5.36k|    if (ret_val->get_descriptor().is_consistent())
  ------------------
  |  Branch (300:9): [True: 4.84k, False: 517]
  ------------------
  301|  4.84k|    {
  302|  4.84k|        return ret_val;
  303|  4.84k|    }
  304|    517|    return {};
  305|  5.36k|}
_ZN8eprosima7fastdds3dds29DynamicTypeBuilderFactoryImpl15delete_instanceEv:
  310|      1|{
  311|      1|    if (!instance_)
  ------------------
  |  Branch (311:9): [True: 0, False: 1]
  ------------------
  312|      0|    {
  313|      0|        return RETCODE_BAD_PARAMETER;
  314|      0|    }
  315|      1|    instance_.reset();
  316|      1|    return RETCODE_OK;
  317|      1|}
_ZN8eprosima7fastdds3dds29DynamicTypeBuilderFactoryImpl12get_instanceEv:
  327|   190k|{
  328|   190k|    if (!instance_)
  ------------------
  |  Branch (328:9): [True: 1, False: 190k]
  ------------------
  329|      1|    {
  330|      1|        instance_ = std::make_shared<DynamicTypeBuilderFactoryImpl>();
  331|      1|    }
  332|       |
  333|   190k|    return instance_;
  334|   190k|}
_ZN8eprosima7fastdds3dds29DynamicTypeBuilderFactoryImpl18get_primitive_typeEh:
  338|  92.5k|{
  339|  92.5k|    traits<DynamicTypeImpl>::ref_type ret_val;
  340|       |
  341|  92.5k|    switch (kind)
  342|  92.5k|    {
  343|  40.9k|        case TK_BOOLEAN:
  ------------------
  |  Branch (343:9): [True: 40.9k, False: 51.6k]
  ------------------
  344|  40.9k|            ret_val = bool_type_;
  345|  40.9k|            break;
  346|  16.6k|        case TK_BYTE:
  ------------------
  |  Branch (346:9): [True: 16.6k, False: 75.9k]
  ------------------
  347|  16.6k|            ret_val = byte_type_;
  348|  16.6k|            break;
  349|  1.61k|        case TK_INT16:
  ------------------
  |  Branch (349:9): [True: 1.61k, False: 90.9k]
  ------------------
  350|  1.61k|            ret_val = int16_type_;
  351|  1.61k|            break;
  352|  2.80k|        case TK_INT32:
  ------------------
  |  Branch (352:9): [True: 2.80k, False: 89.7k]
  ------------------
  353|  2.80k|            ret_val = int32_type_;
  354|  2.80k|            break;
  355|  1.31k|        case TK_INT64:
  ------------------
  |  Branch (355:9): [True: 1.31k, False: 91.2k]
  ------------------
  356|  1.31k|            ret_val = int64_type_;
  357|  1.31k|            break;
  358|  4.58k|        case TK_UINT16:
  ------------------
  |  Branch (358:9): [True: 4.58k, False: 87.9k]
  ------------------
  359|  4.58k|            ret_val = uint16_type_;
  360|  4.58k|            break;
  361|  7.56k|        case TK_UINT32:
  ------------------
  |  Branch (361:9): [True: 7.56k, False: 85.0k]
  ------------------
  362|  7.56k|            ret_val = uint32_type_;
  363|  7.56k|            break;
  364|  2.47k|        case TK_UINT64:
  ------------------
  |  Branch (364:9): [True: 2.47k, False: 90.1k]
  ------------------
  365|  2.47k|            ret_val = uint64_type_;
  366|  2.47k|            break;
  367|  1.74k|        case TK_FLOAT32:
  ------------------
  |  Branch (367:9): [True: 1.74k, False: 90.8k]
  ------------------
  368|  1.74k|            ret_val = float32_type_;
  369|  1.74k|            break;
  370|  3.89k|        case TK_FLOAT64:
  ------------------
  |  Branch (370:9): [True: 3.89k, False: 88.6k]
  ------------------
  371|  3.89k|            ret_val = float64_type_;
  372|  3.89k|            break;
  373|  2.01k|        case TK_FLOAT128:
  ------------------
  |  Branch (373:9): [True: 2.01k, False: 90.5k]
  ------------------
  374|  2.01k|            ret_val = float128_type_;
  375|  2.01k|            break;
  376|  1.43k|        case TK_INT8:
  ------------------
  |  Branch (376:9): [True: 1.43k, False: 91.1k]
  ------------------
  377|  1.43k|            ret_val = int8_type_;
  378|  1.43k|            break;
  379|  1.73k|        case TK_UINT8:
  ------------------
  |  Branch (379:9): [True: 1.73k, False: 90.8k]
  ------------------
  380|  1.73k|            ret_val = uint8_type_;
  381|  1.73k|            break;
  382|  1.80k|        case TK_CHAR8:
  ------------------
  |  Branch (382:9): [True: 1.80k, False: 90.7k]
  ------------------
  383|  1.80k|            ret_val = char8_type_;
  384|  1.80k|            break;
  385|  1.99k|        case TK_CHAR16:
  ------------------
  |  Branch (385:9): [True: 1.99k, False: 90.5k]
  ------------------
  386|  1.99k|            ret_val = char16_type_;
  387|  1.99k|            break;
  388|      0|        default:
  ------------------
  |  Branch (388:9): [True: 0, False: 92.5k]
  ------------------
  389|      0|            break;
  390|  92.5k|    }
  391|       |
  392|  92.5k|    return ret_val;
  393|  92.5k|}

_ZN8eprosima7fastdds3dds22DynamicTypeBuilderImplC2ERKNS1_18TypeDescriptorImplE:
   38|  73.2k|{
   39|  73.2k|    type_descriptor_.copy_from(type_descriptor);
   40|       |
   41|  73.2k|    if ((TK_STRUCTURE == type_descriptor_.kind() ||
  ------------------
  |  Branch (41:10): [True: 287, False: 73.0k]
  ------------------
   42|  73.2k|            TK_BITSET == type_descriptor_.kind()) &&
  ------------------
  |  Branch (42:13): [True: 159, False: 72.8k]
  ------------------
   43|  73.2k|            type_descriptor_.base_type())
  ------------------
  |  Branch (43:13): [True: 0, False: 446]
  ------------------
   44|      0|    {
   45|       |        // Get the members of the base type.
   46|      0|        auto base_type =
   47|      0|                traits<DynamicType>::narrow<DynamicTypeImpl>(type_descriptor_.base_type())->resolve_alias_enclosed_type();
   48|      0|        member_ = base_type->member_;
   49|      0|        member_by_name_ = base_type->member_by_name_;
   50|      0|        members_ = base_type->members_;
   51|       |
   52|       |        // In case TK_BITSET, get the base type bounds.
   53|      0|        type_descriptor_.bound().insert(type_descriptor_.bound().begin(),
   54|      0|                base_type->get_descriptor().bound().begin(),
   55|      0|                base_type->get_descriptor().bound().end());
   56|       |
   57|       |        // Get last member_id from the base type.
   58|      0|        if (0 < members_.size())
  ------------------
  |  Branch (58:13): [True: 0, False: 0]
  ------------------
   59|      0|        {
   60|      0|            traits<DynamicTypeMemberImpl>::ref_type member_impl {traits<DynamicTypeMember>::narrow<DynamicTypeMemberImpl>(
   61|      0|                                                                     members_.back())};
   62|      0|            assert(MEMBER_ID_INVALID != member_impl->get_descriptor().id());
   63|      0|            next_id_ = member_impl->get_descriptor().id() + 1;
   64|      0|        }
   65|       |
   66|      0|        next_index_ = static_cast<uint32_t>(members_.size());
   67|      0|        index_own_members_ = static_cast<uint32_t>(members_.size());
   68|      0|    }
   69|  73.2k|    else if (TK_UNION == type_descriptor_.kind())
  ------------------
  |  Branch (69:14): [True: 0, False: 73.2k]
  ------------------
   70|      0|    {
   71|      0|        MemberDescriptorImpl discriminator_descriptor;
   72|      0|        discriminator_descriptor.id(0);
   73|      0|        discriminator_descriptor.index(0);
   74|      0|        discriminator_descriptor.name("discriminator");
   75|      0|        discriminator_descriptor.type(type_descriptor.discriminator_type());
   76|       |
   77|      0|        traits<DynamicTypeMemberImpl>::ref_type dyn_member = std::make_shared<DynamicTypeMemberImpl>(
   78|      0|            discriminator_descriptor);
   79|      0|        members_.push_back(dyn_member);
   80|      0|        member_by_name_.emplace(std::make_pair(discriminator_descriptor.name(), dyn_member));
   81|      0|        member_.emplace(std::make_pair(discriminator_descriptor.id(), dyn_member));
   82|      0|        next_index_ = 1;
   83|      0|        next_id_ = 1;
   84|      0|    }
   85|  73.2k|}
_ZN8eprosima7fastdds3dds22DynamicTypeBuilderImpl10add_memberENSt3__110shared_ptrINS1_16MemberDescriptorEEE:
  277|  33.9k|{
  278|  33.9k|    auto type_descriptor_kind = type_descriptor_.kind();
  279|       |
  280|  33.9k|    RollbackSetting<uint32_t> id_reverter{next_id_}, index_reverter{next_index_};
  281|  33.9k|    RollbackSetting<int32_t> default_value_reverter{default_value_};
  282|       |
  283|  33.9k|    if (TK_ANNOTATION != type_descriptor_kind &&
  ------------------
  |  Branch (283:9): [True: 33.9k, False: 0]
  ------------------
  284|  33.9k|            TK_BITMASK != type_descriptor_kind &&
  ------------------
  |  Branch (284:13): [True: 0, False: 33.9k]
  ------------------
  285|  33.9k|            TK_BITSET != type_descriptor_kind &&
  ------------------
  |  Branch (285:13): [True: 0, False: 0]
  ------------------
  286|  33.9k|            TK_ENUM != type_descriptor_kind &&
  ------------------
  |  Branch (286:13): [True: 0, False: 0]
  ------------------
  287|  33.9k|            TK_STRUCTURE != type_descriptor_kind &&
  ------------------
  |  Branch (287:13): [True: 0, False: 0]
  ------------------
  288|  33.9k|            TK_UNION != type_descriptor_kind)
  ------------------
  |  Branch (288:13): [True: 0, False: 0]
  ------------------
  289|      0|    {
  290|      0|        EPROSIMA_LOG_ERROR(DYN_TYPES, "Type of kind " << type_descriptor_kind << " does not support adding members");
  ------------------
  |  |   45|      0|#define EPROSIMA_LOG_ERROR(cat, msg) EPROSIMA_LOG_ERROR_IMPL_(cat, msg)
  |  |  ------------------
  |  |  |  |  291|      0|    do {                                                                                                               \
  |  |  |  |  292|      0|        std::stringstream fastdds_log_ss_tmp__;                                                                        \
  |  |  |  |  293|      0|        fastdds_log_ss_tmp__ << msg;                                                                                   \
  |  |  |  |  294|      0|        eprosima::fastdds::dds::Log::QueueLog(                                                                         \
  |  |  |  |  295|      0|            fastdds_log_ss_tmp__.str(), eprosima::fastdds::dds::Log::Context{__FILE__, __LINE__, __func__, #cat},      \
  |  |  |  |  296|      0|            eprosima::fastdds::dds::Log::Kind::Error);                                                                 \
  |  |  |  |  297|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (297:14): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  291|      0|        return RETCODE_PRECONDITION_NOT_MET;
  292|      0|    }
  293|       |
  294|  33.9k|    if (!descriptor)
  ------------------
  |  Branch (294:9): [True: 0, False: 33.9k]
  ------------------
  295|      0|    {
  296|      0|        EPROSIMA_LOG_ERROR(DYN_TYPES, "Descriptor reference is nil");
  ------------------
  |  |   45|      0|#define EPROSIMA_LOG_ERROR(cat, msg) EPROSIMA_LOG_ERROR_IMPL_(cat, msg)
  |  |  ------------------
  |  |  |  |  291|      0|    do {                                                                                                               \
  |  |  |  |  292|      0|        std::stringstream fastdds_log_ss_tmp__;                                                                        \
  |  |  |  |  293|      0|        fastdds_log_ss_tmp__ << msg;                                                                                   \
  |  |  |  |  294|      0|        eprosima::fastdds::dds::Log::QueueLog(                                                                         \
  |  |  |  |  295|      0|            fastdds_log_ss_tmp__.str(), eprosima::fastdds::dds::Log::Context{__FILE__, __LINE__, __func__, #cat},      \
  |  |  |  |  296|      0|            eprosima::fastdds::dds::Log::Kind::Error);                                                                 \
  |  |  |  |  297|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (297:14): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  297|      0|        return RETCODE_BAD_PARAMETER;
  298|      0|    }
  299|       |
  300|  33.9k|    auto descriptor_impl = traits<MemberDescriptor>::narrow<MemberDescriptorImpl>(descriptor);
  301|       |
  302|       |
  303|       |    //{{{ Check on BITMASK doesn't exceed bound.
  304|  33.9k|    assert(TK_BITMASK != type_descriptor_kind || 1 == type_descriptor_.bound().size());
  305|  33.9k|    if (TK_BITMASK == type_descriptor_kind && members_.size() >= type_descriptor_.bound().at(0))
  ------------------
  |  Branch (305:9): [True: 33.9k, False: 0]
  |  Branch (305:47): [True: 202, False: 33.7k]
  ------------------
  306|    202|    {
  307|    202|        EPROSIMA_LOG_ERROR(DYN_TYPES, "Adding new member in this BITMASK exceeds the bound.");
  ------------------
  |  |   45|    202|#define EPROSIMA_LOG_ERROR(cat, msg) EPROSIMA_LOG_ERROR_IMPL_(cat, msg)
  |  |  ------------------
  |  |  |  |  291|    202|    do {                                                                                                               \
  |  |  |  |  292|    202|        std::stringstream fastdds_log_ss_tmp__;                                                                        \
  |  |  |  |  293|    202|        fastdds_log_ss_tmp__ << msg;                                                                                   \
  |  |  |  |  294|    202|        eprosima::fastdds::dds::Log::QueueLog(                                                                         \
  |  |  |  |  295|    202|            fastdds_log_ss_tmp__.str(), eprosima::fastdds::dds::Log::Context{__FILE__, __LINE__, __func__, #cat},      \
  |  |  |  |  296|    202|            eprosima::fastdds::dds::Log::Kind::Error);                                                                 \
  |  |  |  |  297|    202|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (297:14): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  308|    202|        return RETCODE_BAD_PARAMETER;
  309|    202|    }
  310|       |    //}}}
  311|       |
  312|       |    //{{{ Check on BITSET new member doesn't exceed the bound vector's size.
  313|  33.7k|    if (TK_BITSET == type_descriptor_kind && members_.size() == type_descriptor_.bound().size())
  ------------------
  |  Branch (313:9): [True: 0, False: 33.7k]
  |  Branch (313:46): [True: 0, False: 0]
  ------------------
  314|      0|    {
  315|      0|        EPROSIMA_LOG_ERROR(DYN_TYPES, "Adding new member in this BITSET exceeds the size of bounds.");
  ------------------
  |  |   45|      0|#define EPROSIMA_LOG_ERROR(cat, msg) EPROSIMA_LOG_ERROR_IMPL_(cat, msg)
  |  |  ------------------
  |  |  |  |  291|      0|    do {                                                                                                               \
  |  |  |  |  292|      0|        std::stringstream fastdds_log_ss_tmp__;                                                                        \
  |  |  |  |  293|      0|        fastdds_log_ss_tmp__ << msg;                                                                                   \
  |  |  |  |  294|      0|        eprosima::fastdds::dds::Log::QueueLog(                                                                         \
  |  |  |  |  295|      0|            fastdds_log_ss_tmp__.str(), eprosima::fastdds::dds::Log::Context{__FILE__, __LINE__, __func__, #cat},      \
  |  |  |  |  296|      0|            eprosima::fastdds::dds::Log::Kind::Error);                                                                 \
  |  |  |  |  297|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (297:14): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  316|      0|        return RETCODE_BAD_PARAMETER;
  317|      0|    }
  318|       |    //}}}
  319|       |
  320|  33.7k|    const auto& member_name = descriptor_impl->name();
  321|       |
  322|       |    //{{{ Check there is already a member with same name.
  323|  33.7k|    auto it_by_name = member_by_name_.find(member_name);
  324|  33.7k|    if (member_by_name_.end() != it_by_name)
  ------------------
  |  Branch (324:9): [True: 6.18k, False: 27.5k]
  ------------------
  325|  6.18k|    {
  326|  6.18k|        EPROSIMA_LOG_ERROR(DYN_TYPES, "There is already a member with name " << member_name);
  ------------------
  |  |   45|  6.18k|#define EPROSIMA_LOG_ERROR(cat, msg) EPROSIMA_LOG_ERROR_IMPL_(cat, msg)
  |  |  ------------------
  |  |  |  |  291|  6.18k|    do {                                                                                                               \
  |  |  |  |  292|  6.18k|        std::stringstream fastdds_log_ss_tmp__;                                                                        \
  |  |  |  |  293|  6.18k|        fastdds_log_ss_tmp__ << msg;                                                                                   \
  |  |  |  |  294|  6.18k|        eprosima::fastdds::dds::Log::QueueLog(                                                                         \
  |  |  |  |  295|  6.18k|            fastdds_log_ss_tmp__.str(), eprosima::fastdds::dds::Log::Context{__FILE__, __LINE__, __func__, #cat},      \
  |  |  |  |  296|  6.18k|            eprosima::fastdds::dds::Log::Kind::Error);                                                                 \
  |  |  |  |  297|  6.18k|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (297:14): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  327|  6.18k|        return RETCODE_BAD_PARAMETER;
  328|  6.18k|    }
  329|       |    //}}}
  330|       |
  331|  27.5k|    auto member_id = descriptor_impl->id();
  332|       |
  333|       |    //{{{ If member_id is MEMBER_ID_INVALID and type is aggregated, find a new one.
  334|  27.5k|    if (TK_ANNOTATION == type_descriptor_kind ||
  ------------------
  |  Branch (334:9): [True: 0, False: 27.5k]
  ------------------
  335|  27.5k|            TK_BITMASK == type_descriptor_kind ||
  ------------------
  |  Branch (335:13): [True: 27.5k, False: 0]
  ------------------
  336|  27.5k|            TK_STRUCTURE == type_descriptor_kind ||
  ------------------
  |  Branch (336:13): [True: 0, False: 0]
  ------------------
  337|  27.5k|            TK_UNION == type_descriptor_kind)
  ------------------
  |  Branch (337:13): [True: 0, False: 0]
  ------------------
  338|  27.5k|    {
  339|  27.5k|        if (MEMBER_ID_INVALID == member_id)
  ------------------
  |  Branch (339:13): [True: 0, False: 27.5k]
  ------------------
  340|      0|        {
  341|      0|            member_id = next_id_++;
  342|      0|            id_reverter.activate = true;
  343|       |
  344|      0|        }
  345|  27.5k|        else if (member_id >= next_id_)
  ------------------
  |  Branch (345:18): [True: 20.0k, False: 7.44k]
  ------------------
  346|  20.0k|        {
  347|  20.0k|            next_id_ = member_id + 1;
  348|  20.0k|            id_reverter.activate = true;
  349|  20.0k|        }
  350|       |
  351|       |        // Check there is already a member with same id.
  352|  27.5k|        auto it_by_id = member_.find(member_id);
  353|  27.5k|        if (member_.end() != it_by_id)
  ------------------
  |  Branch (353:13): [True: 3.20k, False: 24.3k]
  ------------------
  354|  3.20k|        {
  355|  3.20k|            EPROSIMA_LOG_ERROR(DYN_TYPES, "There is already a member with MemberId " << member_id);
  ------------------
  |  |   45|  3.20k|#define EPROSIMA_LOG_ERROR(cat, msg) EPROSIMA_LOG_ERROR_IMPL_(cat, msg)
  |  |  ------------------
  |  |  |  |  291|  3.20k|    do {                                                                                                               \
  |  |  |  |  292|  3.20k|        std::stringstream fastdds_log_ss_tmp__;                                                                        \
  |  |  |  |  293|  3.20k|        fastdds_log_ss_tmp__ << msg;                                                                                   \
  |  |  |  |  294|  3.20k|        eprosima::fastdds::dds::Log::QueueLog(                                                                         \
  |  |  |  |  295|  3.20k|            fastdds_log_ss_tmp__.str(), eprosima::fastdds::dds::Log::Context{__FILE__, __LINE__, __func__, #cat},      \
  |  |  |  |  296|  3.20k|            eprosima::fastdds::dds::Log::Kind::Error);                                                                 \
  |  |  |  |  297|  3.20k|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (297:14): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  356|  3.20k|            return RETCODE_BAD_PARAMETER;
  357|  3.20k|        }
  358|  27.5k|    }
  359|       |    //}}}
  360|       |    //{{{ Else if it is mandatory to a BITSET's member to have MemberId.
  361|      0|    else if (TK_BITSET == type_descriptor_kind)
  ------------------
  |  Branch (361:14): [True: 0, False: 0]
  ------------------
  362|      0|    {
  363|      0|        if (MEMBER_ID_INVALID == member_id)
  ------------------
  |  Branch (363:13): [True: 0, False: 0]
  ------------------
  364|      0|        {
  365|      0|            EPROSIMA_LOG_ERROR(DYN_TYPES, "MemberId for BITSET must be different than MEMBER_ID_INVALID");
  ------------------
  |  |   45|      0|#define EPROSIMA_LOG_ERROR(cat, msg) EPROSIMA_LOG_ERROR_IMPL_(cat, msg)
  |  |  ------------------
  |  |  |  |  291|      0|    do {                                                                                                               \
  |  |  |  |  292|      0|        std::stringstream fastdds_log_ss_tmp__;                                                                        \
  |  |  |  |  293|      0|        fastdds_log_ss_tmp__ << msg;                                                                                   \
  |  |  |  |  294|      0|        eprosima::fastdds::dds::Log::QueueLog(                                                                         \
  |  |  |  |  295|      0|            fastdds_log_ss_tmp__.str(), eprosima::fastdds::dds::Log::Context{__FILE__, __LINE__, __func__, #cat},      \
  |  |  |  |  296|      0|            eprosima::fastdds::dds::Log::Kind::Error);                                                                 \
  |  |  |  |  297|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (297:14): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  366|      0|            return RETCODE_BAD_PARAMETER;
  367|      0|        }
  368|      0|    }
  369|       |    //}}}
  370|       |    //{{{ Else, TK_ENUM has to come with MEMBER_ID_INVALID.
  371|      0|    else if (MEMBER_ID_INVALID != member_id)
  ------------------
  |  Branch (371:14): [True: 0, False: 0]
  ------------------
  372|      0|    {
  373|      0|        EPROSIMA_LOG_ERROR(DYN_TYPES, "MemberId must be MEMBER_ID_INVALID");
  ------------------
  |  |   45|      0|#define EPROSIMA_LOG_ERROR(cat, msg) EPROSIMA_LOG_ERROR_IMPL_(cat, msg)
  |  |  ------------------
  |  |  |  |  291|      0|    do {                                                                                                               \
  |  |  |  |  292|      0|        std::stringstream fastdds_log_ss_tmp__;                                                                        \
  |  |  |  |  293|      0|        fastdds_log_ss_tmp__ << msg;                                                                                   \
  |  |  |  |  294|      0|        eprosima::fastdds::dds::Log::QueueLog(                                                                         \
  |  |  |  |  295|      0|            fastdds_log_ss_tmp__.str(), eprosima::fastdds::dds::Log::Context{__FILE__, __LINE__, __func__, #cat},      \
  |  |  |  |  296|      0|            eprosima::fastdds::dds::Log::Kind::Error);                                                                 \
  |  |  |  |  297|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (297:14): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  374|      0|        return RETCODE_BAD_PARAMETER;
  375|      0|    }
  376|       |    //}}}
  377|       |
  378|  24.3k|    traits<DynamicTypeMemberImpl>::ref_type dyn_member = std::make_shared<DynamicTypeMemberImpl>(*descriptor_impl);
  379|  24.3k|    dyn_member->get_descriptor().id(member_id);
  380|       |    //{{{ Set index
  381|  24.3k|    dyn_member->get_descriptor().index(next_index_++);
  382|  24.3k|    index_reverter.activate = true;
  383|       |    //}}}
  384|       |
  385|       |    //{{{ Check bound in case of BITMASK
  386|  24.3k|    if (TK_BITMASK == type_descriptor_kind && member_id >= type_descriptor_.bound().at(0))
  ------------------
  |  Branch (386:9): [True: 24.3k, False: 0]
  |  Branch (386:47): [True: 916, False: 23.4k]
  ------------------
  387|    916|    {
  388|    916|        EPROSIMA_LOG_ERROR(DYN_TYPES, "The BITMASK member id exceeds the bound.");
  ------------------
  |  |   45|    916|#define EPROSIMA_LOG_ERROR(cat, msg) EPROSIMA_LOG_ERROR_IMPL_(cat, msg)
  |  |  ------------------
  |  |  |  |  291|    916|    do {                                                                                                               \
  |  |  |  |  292|    916|        std::stringstream fastdds_log_ss_tmp__;                                                                        \
  |  |  |  |  293|    916|        fastdds_log_ss_tmp__ << msg;                                                                                   \
  |  |  |  |  294|    916|        eprosima::fastdds::dds::Log::QueueLog(                                                                         \
  |  |  |  |  295|    916|            fastdds_log_ss_tmp__.str(), eprosima::fastdds::dds::Log::Context{__FILE__, __LINE__, __func__, #cat},      \
  |  |  |  |  296|    916|            eprosima::fastdds::dds::Log::Kind::Error);                                                                 \
  |  |  |  |  297|    916|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (297:14): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  389|    916|        return RETCODE_BAD_PARAMETER;
  390|    916|    }
  391|       |    //}}}
  392|       |
  393|       |    //{{{ Specific checks for STRUCTURE
  394|  23.4k|    if (TK_STRUCTURE == type_descriptor_kind)
  ------------------
  |  Branch (394:9): [True: 0, False: 23.4k]
  ------------------
  395|      0|    {
  396|      0|        if (descriptor_impl->is_key() && type_descriptor_.base_type())
  ------------------
  |  Branch (396:13): [True: 0, False: 0]
  |  Branch (396:42): [True: 0, False: 0]
  ------------------
  397|      0|        {
  398|      0|            EPROSIMA_LOG_ERROR(DYN_TYPES, "A derived structure cannot contains keyed members");
  ------------------
  |  |   45|      0|#define EPROSIMA_LOG_ERROR(cat, msg) EPROSIMA_LOG_ERROR_IMPL_(cat, msg)
  |  |  ------------------
  |  |  |  |  291|      0|    do {                                                                                                               \
  |  |  |  |  292|      0|        std::stringstream fastdds_log_ss_tmp__;                                                                        \
  |  |  |  |  293|      0|        fastdds_log_ss_tmp__ << msg;                                                                                   \
  |  |  |  |  294|      0|        eprosima::fastdds::dds::Log::QueueLog(                                                                         \
  |  |  |  |  295|      0|            fastdds_log_ss_tmp__.str(), eprosima::fastdds::dds::Log::Context{__FILE__, __LINE__, __func__, #cat},      \
  |  |  |  |  296|      0|            eprosima::fastdds::dds::Log::Kind::Error);                                                                 \
  |  |  |  |  297|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (297:14): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  399|      0|            return RETCODE_BAD_PARAMETER;
  400|      0|        }
  401|      0|    }
  402|       |    //}}}
  403|       |    //{{{ Specific checks for UNION
  404|  23.4k|    else if (TK_UNION == type_descriptor_kind)
  ------------------
  |  Branch (404:14): [True: 0, False: 23.4k]
  ------------------
  405|      0|    {
  406|      0|        for (auto member : members_)
  ------------------
  |  Branch (406:26): [True: 0, False: 0]
  ------------------
  407|      0|        {
  408|      0|            const auto member_impl {traits<DynamicTypeMember>::narrow<DynamicTypeMemberImpl>(member)};
  409|       |
  410|       |            // Check default label and label cases uniqueness.
  411|      0|            if (descriptor_impl->is_default_label() && member_impl->member_descriptor_.is_default_label())
  ------------------
  |  Branch (411:17): [True: 0, False: 0]
  |  Branch (411:56): [True: 0, False: 0]
  ------------------
  412|      0|            {
  413|      0|                EPROSIMA_LOG_ERROR(DYN_TYPES,
  ------------------
  |  |   45|      0|#define EPROSIMA_LOG_ERROR(cat, msg) EPROSIMA_LOG_ERROR_IMPL_(cat, msg)
  |  |  ------------------
  |  |  |  |  291|      0|    do {                                                                                                               \
  |  |  |  |  292|      0|        std::stringstream fastdds_log_ss_tmp__;                                                                        \
  |  |  |  |  293|      0|        fastdds_log_ss_tmp__ << msg;                                                                                   \
  |  |  |  |  294|      0|        eprosima::fastdds::dds::Log::QueueLog(                                                                         \
  |  |  |  |  295|      0|            fastdds_log_ss_tmp__.str(), eprosima::fastdds::dds::Log::Context{__FILE__, __LINE__, __func__, #cat},      \
  |  |  |  |  296|      0|            eprosima::fastdds::dds::Log::Kind::Error);                                                                 \
  |  |  |  |  297|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (297:14): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  414|      0|                        "Member " << member_impl->member_descriptor_.name().c_str() <<
  415|      0|                        " already defined as default_label");
  416|      0|                return RETCODE_BAD_PARAMETER;
  417|      0|            }
  418|      0|            for (const int32_t new_label : descriptor_impl->label())
  ------------------
  |  Branch (418:42): [True: 0, False: 0]
  ------------------
  419|      0|            {
  420|      0|                for (const int32_t label : member_impl->member_descriptor_.label())
  ------------------
  |  Branch (420:42): [True: 0, False: 0]
  ------------------
  421|      0|                {
  422|      0|                    if (new_label == label)
  ------------------
  |  Branch (422:25): [True: 0, False: 0]
  ------------------
  423|      0|                    {
  424|      0|                        EPROSIMA_LOG_ERROR(DYN_TYPES,
  ------------------
  |  |   45|      0|#define EPROSIMA_LOG_ERROR(cat, msg) EPROSIMA_LOG_ERROR_IMPL_(cat, msg)
  |  |  ------------------
  |  |  |  |  291|      0|    do {                                                                                                               \
  |  |  |  |  292|      0|        std::stringstream fastdds_log_ss_tmp__;                                                                        \
  |  |  |  |  293|      0|        fastdds_log_ss_tmp__ << msg;                                                                                   \
  |  |  |  |  294|      0|        eprosima::fastdds::dds::Log::QueueLog(                                                                         \
  |  |  |  |  295|      0|            fastdds_log_ss_tmp__.str(), eprosima::fastdds::dds::Log::Context{__FILE__, __LINE__, __func__, #cat},      \
  |  |  |  |  296|      0|            eprosima::fastdds::dds::Log::Kind::Error);                                                                 \
  |  |  |  |  297|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (297:14): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  425|      0|                                "Member " << member_impl->member_descriptor_.name().c_str() << " already contains the label " <<
  426|      0|                                label);
  427|      0|                        return RETCODE_BAD_PARAMETER;
  428|      0|                    }
  429|      0|                }
  430|       |
  431|       |                // Recalculate the default discriminator value (for default case or default implicit member).
  432|      0|                if (new_label >= default_value_)
  ------------------
  |  Branch (432:21): [True: 0, False: 0]
  ------------------
  433|      0|                {
  434|      0|                    default_value_ = new_label + 1;
  435|      0|                }
  436|      0|            }
  437|      0|        }
  438|       |
  439|       |        // In case of default case, store the related MemberId.
  440|      0|        if (descriptor_impl->is_default_label())
  ------------------
  |  Branch (440:13): [True: 0, False: 0]
  ------------------
  441|      0|        {
  442|      0|            default_union_member_ = member_id;
  443|      0|        }
  444|      0|    }
  445|       |    //}}}
  446|       |    //{{{ Specific checks for BITSET
  447|  23.4k|    else if (TK_BITSET == type_descriptor_kind)
  ------------------
  |  Branch (447:14): [True: 0, False: 23.4k]
  ------------------
  448|      0|    {
  449|      0|        const MemberId new_member_id {dyn_member->get_descriptor().id()};
  450|      0|        const auto new_member_bound {type_descriptor_.bound().at(dyn_member->get_descriptor().index())};
  451|       |
  452|      0|        for (auto member : member_)
  ------------------
  |  Branch (452:26): [True: 0, False: 0]
  ------------------
  453|      0|        {
  454|      0|            const MemberId mid {member.first};
  455|      0|            const auto member_impl {traits<DynamicTypeMember>::narrow<DynamicTypeMemberImpl>(member.second)};
  456|      0|            const auto member_index {member_impl->get_descriptor().index()};
  457|       |
  458|      0|            if (mid == new_member_id)
  ------------------
  |  Branch (458:17): [True: 0, False: 0]
  ------------------
  459|      0|            {
  460|      0|                EPROSIMA_LOG_ERROR(DYN_TYPES, "Inconsistency in the new MemberId because it is equal to MemberId(" <<
  ------------------
  |  |   45|      0|#define EPROSIMA_LOG_ERROR(cat, msg) EPROSIMA_LOG_ERROR_IMPL_(cat, msg)
  |  |  ------------------
  |  |  |  |  291|      0|    do {                                                                                                               \
  |  |  |  |  292|      0|        std::stringstream fastdds_log_ss_tmp__;                                                                        \
  |  |  |  |  293|      0|        fastdds_log_ss_tmp__ << msg;                                                                                   \
  |  |  |  |  294|      0|        eprosima::fastdds::dds::Log::QueueLog(                                                                         \
  |  |  |  |  295|      0|            fastdds_log_ss_tmp__.str(), eprosima::fastdds::dds::Log::Context{__FILE__, __LINE__, __func__, #cat},      \
  |  |  |  |  296|      0|            eprosima::fastdds::dds::Log::Kind::Error);                                                                 \
  |  |  |  |  297|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (297:14): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  461|      0|                        mid << ")");
  462|      0|                return RETCODE_BAD_PARAMETER;
  463|      0|            }
  464|      0|            else if (mid < new_member_id)
  ------------------
  |  Branch (464:22): [True: 0, False: 0]
  ------------------
  465|      0|            {
  466|      0|                const auto bound {type_descriptor_.bound().at(member_index)};
  467|       |
  468|      0|                if (new_member_id < mid + bound)
  ------------------
  |  Branch (468:21): [True: 0, False: 0]
  ------------------
  469|      0|                {
  470|      0|                    EPROSIMA_LOG_ERROR(DYN_TYPES, "Inconsistency in the new MemberId because is less than MemberId(" <<
  ------------------
  |  |   45|      0|#define EPROSIMA_LOG_ERROR(cat, msg) EPROSIMA_LOG_ERROR_IMPL_(cat, msg)
  |  |  ------------------
  |  |  |  |  291|      0|    do {                                                                                                               \
  |  |  |  |  292|      0|        std::stringstream fastdds_log_ss_tmp__;                                                                        \
  |  |  |  |  293|      0|        fastdds_log_ss_tmp__ << msg;                                                                                   \
  |  |  |  |  294|      0|        eprosima::fastdds::dds::Log::QueueLog(                                                                         \
  |  |  |  |  295|      0|            fastdds_log_ss_tmp__.str(), eprosima::fastdds::dds::Log::Context{__FILE__, __LINE__, __func__, #cat},      \
  |  |  |  |  296|      0|            eprosima::fastdds::dds::Log::Kind::Error);                                                                 \
  |  |  |  |  297|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (297:14): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  471|      0|                            mid << ") + Bound(" << bound << ")");
  472|      0|                    return RETCODE_BAD_PARAMETER;
  473|      0|                }
  474|      0|            }
  475|      0|            else
  476|      0|            {
  477|      0|                if (mid < new_member_id + new_member_bound)
  ------------------
  |  Branch (477:21): [True: 0, False: 0]
  ------------------
  478|      0|                {
  479|      0|                    EPROSIMA_LOG_ERROR(DYN_TYPES, "Inconsistency in the new MemberId because there is a member with id "
  ------------------
  |  |   45|      0|#define EPROSIMA_LOG_ERROR(cat, msg) EPROSIMA_LOG_ERROR_IMPL_(cat, msg)
  |  |  ------------------
  |  |  |  |  291|      0|    do {                                                                                                               \
  |  |  |  |  292|      0|        std::stringstream fastdds_log_ss_tmp__;                                                                        \
  |  |  |  |  293|      0|        fastdds_log_ss_tmp__ << msg;                                                                                   \
  |  |  |  |  294|      0|        eprosima::fastdds::dds::Log::QueueLog(                                                                         \
  |  |  |  |  295|      0|            fastdds_log_ss_tmp__.str(), eprosima::fastdds::dds::Log::Context{__FILE__, __LINE__, __func__, #cat},      \
  |  |  |  |  296|      0|            eprosima::fastdds::dds::Log::Kind::Error);                                                                 \
  |  |  |  |  297|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (297:14): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  480|      0|                            << "less than MemberId(" << new_member_id << ") + Bound(" << new_member_bound << ")");
  481|      0|                    return RETCODE_BAD_PARAMETER;
  482|      0|                }
  483|      0|            }
  484|      0|        }
  485|       |
  486|       |        //TODO(richiware) Not valid when bitset refactored to support more than 64bits.
  487|      0|        if (64 < new_member_id + new_member_bound)
  ------------------
  |  Branch (487:13): [True: 0, False: 0]
  ------------------
  488|      0|        {
  489|      0|            EPROSIMA_LOG_ERROR(DYN_TYPES, "Inconsistency in the new MemberId because exceeds the maximum "
  ------------------
  |  |   45|      0|#define EPROSIMA_LOG_ERROR(cat, msg) EPROSIMA_LOG_ERROR_IMPL_(cat, msg)
  |  |  ------------------
  |  |  |  |  291|      0|    do {                                                                                                               \
  |  |  |  |  292|      0|        std::stringstream fastdds_log_ss_tmp__;                                                                        \
  |  |  |  |  293|      0|        fastdds_log_ss_tmp__ << msg;                                                                                   \
  |  |  |  |  294|      0|        eprosima::fastdds::dds::Log::QueueLog(                                                                         \
  |  |  |  |  295|      0|            fastdds_log_ss_tmp__.str(), eprosima::fastdds::dds::Log::Context{__FILE__, __LINE__, __func__, #cat},      \
  |  |  |  |  296|      0|            eprosima::fastdds::dds::Log::Kind::Error);                                                                 \
  |  |  |  |  297|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (297:14): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  490|      0|                    << "64 bits length is exceeded");
  491|      0|            return RETCODE_BAD_PARAMETER;
  492|      0|        }
  493|      0|    }
  494|       |    //}}}
  495|       |    //{{{ Specific checks for ENUM
  496|  23.4k|    if (TK_ENUM == type_descriptor_kind)
  ------------------
  |  Branch (496:9): [True: 0, False: 23.4k]
  ------------------
  497|      0|    {
  498|      0|        if (0 < members_.size())
  ------------------
  |  Branch (498:13): [True: 0, False: 0]
  ------------------
  499|      0|        {
  500|      0|            const auto member_impl = traits<DynamicTypeMember>::narrow<DynamicTypeMemberImpl>(members_.at(0));
  501|       |
  502|      0|            if (member_impl->get_descriptor().type()->get_kind() != descriptor->type()->get_kind())
  ------------------
  |  Branch (502:17): [True: 0, False: 0]
  ------------------
  503|      0|            {
  504|      0|                EPROSIMA_LOG_ERROR(DYN_TYPES, "Descriptor type kind differs from the current member types.");
  ------------------
  |  |   45|      0|#define EPROSIMA_LOG_ERROR(cat, msg) EPROSIMA_LOG_ERROR_IMPL_(cat, msg)
  |  |  ------------------
  |  |  |  |  291|      0|    do {                                                                                                               \
  |  |  |  |  292|      0|        std::stringstream fastdds_log_ss_tmp__;                                                                        \
  |  |  |  |  293|      0|        fastdds_log_ss_tmp__ << msg;                                                                                   \
  |  |  |  |  294|      0|        eprosima::fastdds::dds::Log::QueueLog(                                                                         \
  |  |  |  |  295|      0|            fastdds_log_ss_tmp__.str(), eprosima::fastdds::dds::Log::Context{__FILE__, __LINE__, __func__, #cat},      \
  |  |  |  |  296|      0|            eprosima::fastdds::dds::Log::Kind::Error);                                                                 \
  |  |  |  |  297|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (297:14): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  505|      0|                return RETCODE_BAD_PARAMETER;
  506|      0|            }
  507|      0|        }
  508|       |
  509|      0|        if (!descriptor->default_value().empty())
  ------------------
  |  Branch (509:13): [True: 0, False: 0]
  ------------------
  510|      0|        {
  511|      0|            for (auto member : members_)
  ------------------
  |  Branch (511:30): [True: 0, False: 0]
  ------------------
  512|      0|            {
  513|      0|                const auto member_impl {traits<DynamicTypeMember>::narrow<DynamicTypeMemberImpl>(member)};
  514|       |
  515|       |                // Check that there isn't already any member with the same default value.
  516|      0|                if (0 == descriptor->default_value().compare(member_impl->get_descriptor().default_value()))
  ------------------
  |  Branch (516:21): [True: 0, False: 0]
  ------------------
  517|      0|                {
  518|      0|                    EPROSIMA_LOG_ERROR(DYN_TYPES,
  ------------------
  |  |   45|      0|#define EPROSIMA_LOG_ERROR(cat, msg) EPROSIMA_LOG_ERROR_IMPL_(cat, msg)
  |  |  ------------------
  |  |  |  |  291|      0|    do {                                                                                                               \
  |  |  |  |  292|      0|        std::stringstream fastdds_log_ss_tmp__;                                                                        \
  |  |  |  |  293|      0|        fastdds_log_ss_tmp__ << msg;                                                                                   \
  |  |  |  |  294|      0|        eprosima::fastdds::dds::Log::QueueLog(                                                                         \
  |  |  |  |  295|      0|            fastdds_log_ss_tmp__.str(), eprosima::fastdds::dds::Log::Context{__FILE__, __LINE__, __func__, #cat},      \
  |  |  |  |  296|      0|            eprosima::fastdds::dds::Log::Kind::Error);                                                                 \
  |  |  |  |  297|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (297:14): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  519|      0|                            "Member " << member_impl->member_descriptor_.name().c_str() <<
  520|      0|                            " has already the value");
  521|      0|                    return RETCODE_BAD_PARAMETER;
  522|      0|                }
  523|      0|            }
  524|      0|            TypeForKind<TK_INT32> value = TypeValueConverter::sto(descriptor->default_value());
  525|       |
  526|      0|            if (value >= default_value_)
  ------------------
  |  Branch (526:17): [True: 0, False: 0]
  ------------------
  527|      0|            {
  528|      0|                default_value_ = value + 1;
  529|      0|                default_value_reverter.activate = true;
  530|      0|            }
  531|      0|        }
  532|      0|        else
  533|      0|        {
  534|      0|            dyn_member->get_descriptor().default_value(std::to_string(default_value_++));
  535|      0|            default_value_reverter.activate = true;
  536|      0|        }
  537|      0|    }
  538|       |    //}}}
  539|       |
  540|       |    // Set before calling is_consistent().
  541|  23.4k|    dyn_member->get_descriptor().parent_kind(type_descriptor_kind);
  542|       |
  543|  23.4k|    if (!dyn_member->get_descriptor().is_consistent())
  ------------------
  |  Branch (543:9): [True: 7.83k, False: 15.5k]
  ------------------
  544|  7.83k|    {
  545|  7.83k|        EPROSIMA_LOG_ERROR(DYN_TYPES, "Descriptor is not consistent");
  ------------------
  |  |   45|  7.83k|#define EPROSIMA_LOG_ERROR(cat, msg) EPROSIMA_LOG_ERROR_IMPL_(cat, msg)
  |  |  ------------------
  |  |  |  |  291|  7.83k|    do {                                                                                                               \
  |  |  |  |  292|  7.83k|        std::stringstream fastdds_log_ss_tmp__;                                                                        \
  |  |  |  |  293|  7.83k|        fastdds_log_ss_tmp__ << msg;                                                                                   \
  |  |  |  |  294|  7.83k|        eprosima::fastdds::dds::Log::QueueLog(                                                                         \
  |  |  |  |  295|  7.83k|            fastdds_log_ss_tmp__.str(), eprosima::fastdds::dds::Log::Context{__FILE__, __LINE__, __func__, #cat},      \
  |  |  |  |  296|  7.83k|            eprosima::fastdds::dds::Log::Kind::Error);                                                                 \
  |  |  |  |  297|  7.83k|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (297:14): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  546|  7.83k|        return RETCODE_BAD_PARAMETER;
  547|  7.83k|    }
  548|       |
  549|  15.5k|    assert(dyn_member->get_descriptor().index() <= members_.size());
  550|  15.5k|    if (dyn_member->get_descriptor().index() < members_.size())
  ------------------
  |  Branch (550:9): [True: 0, False: 15.5k]
  ------------------
  551|      0|    {
  552|      0|        auto it = members_.begin() + dyn_member->get_descriptor().index();
  553|      0|        it = members_.insert(it, dyn_member);
  554|      0|        for (++it; it != members_.end(); ++it)
  ------------------
  |  Branch (554:20): [True: 0, False: 0]
  ------------------
  555|      0|        {
  556|      0|            auto next_member = traits<DynamicTypeMember>::narrow<DynamicTypeMemberImpl>(*it);
  557|      0|            next_member->get_descriptor().index(next_member->get_descriptor().index() + 1);
  558|      0|        }
  559|      0|        ++next_index_;
  560|      0|    }
  561|  15.5k|    else
  562|  15.5k|    {
  563|  15.5k|        members_.push_back(dyn_member);
  564|  15.5k|    }
  565|  15.5k|    assert(next_index_ == traits<DynamicTypeMember>::narrow<DynamicTypeMemberImpl>(
  566|  15.5k|                *members_.rbegin())->get_descriptor().index() + 1);
  567|       |
  568|  15.5k|    member_by_name_.emplace(std::make_pair(member_name, dyn_member));
  569|  15.5k|    if (TK_ANNOTATION == type_descriptor_kind ||
  ------------------
  |  Branch (569:9): [True: 0, False: 15.5k]
  ------------------
  570|  15.5k|            TK_BITMASK == type_descriptor_kind ||
  ------------------
  |  Branch (570:13): [True: 15.5k, False: 0]
  ------------------
  571|  15.5k|            TK_BITSET == type_descriptor_kind ||
  ------------------
  |  Branch (571:13): [True: 0, False: 0]
  ------------------
  572|  15.5k|            TK_STRUCTURE == type_descriptor_kind ||
  ------------------
  |  Branch (572:13): [True: 0, False: 0]
  ------------------
  573|  15.5k|            TK_UNION == type_descriptor_kind)
  ------------------
  |  Branch (573:13): [True: 0, False: 0]
  ------------------
  574|  15.5k|    {
  575|  15.5k|        member_.emplace(std::make_pair(member_id, dyn_member));
  576|  15.5k|    }
  577|       |
  578|  15.5k|    id_reverter.activate = false;
  579|  15.5k|    index_reverter.activate = false;
  580|  15.5k|    default_value_reverter.activate = false;
  581|  15.5k|    return RETCODE_OK;
  582|  23.4k|}
_ZN8eprosima7fastdds3dds22DynamicTypeBuilderImpl5buildEv:
  647|  58.0k|{
  648|  58.0k|    traits<DynamicTypeImpl>::ref_type ret_val;
  649|       |
  650|  58.0k|    if (type_descriptor_.is_consistent())
  ------------------
  |  Branch (650:9): [True: 58.0k, False: 0]
  ------------------
  651|  58.0k|    {
  652|  58.0k|        bool preconditions {true};
  653|       |
  654|       |        // In case of BITSET, verify the TypeDescriptor's bounds size is same as number of members.
  655|  58.0k|        preconditions &= TK_BITSET != type_descriptor_.kind() || type_descriptor_.bound().size() == members_.size();
  ------------------
  |  Branch (655:26): [True: 56.7k, False: 1.33k]
  |  Branch (655:66): [True: 1.33k, False: 0]
  ------------------
  656|  58.0k|        if (!preconditions)
  ------------------
  |  Branch (656:13): [True: 0, False: 58.0k]
  ------------------
  657|      0|        {
  658|      0|            EPROSIMA_LOG_ERROR(DYN_TYPES, "Expected more members in BITSET according to the size of bounds.");
  ------------------
  |  |   45|      0|#define EPROSIMA_LOG_ERROR(cat, msg) EPROSIMA_LOG_ERROR_IMPL_(cat, msg)
  |  |  ------------------
  |  |  |  |  291|      0|    do {                                                                                                               \
  |  |  |  |  292|      0|        std::stringstream fastdds_log_ss_tmp__;                                                                        \
  |  |  |  |  293|      0|        fastdds_log_ss_tmp__ << msg;                                                                                   \
  |  |  |  |  294|      0|        eprosima::fastdds::dds::Log::QueueLog(                                                                         \
  |  |  |  |  295|      0|            fastdds_log_ss_tmp__.str(), eprosima::fastdds::dds::Log::Context{__FILE__, __LINE__, __func__, #cat},      \
  |  |  |  |  296|      0|            eprosima::fastdds::dds::Log::Kind::Error);                                                                 \
  |  |  |  |  297|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (297:14): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  659|      0|        }
  660|       |
  661|       |        // In case of ENUM and BITSET, it must have at least one member
  662|  58.0k|        preconditions &= (TK_ENUM != type_descriptor_.kind() && TK_BITSET != type_descriptor_.kind())
  ------------------
  |  Branch (662:27): [True: 57.6k, False: 403]
  |  Branch (662:65): [True: 56.3k, False: 1.33k]
  ------------------
  663|  58.0k|                || 0 < members_.size();
  ------------------
  |  Branch (663:20): [True: 0, False: 1.73k]
  ------------------
  664|  58.0k|        if (!preconditions)
  ------------------
  |  Branch (664:13): [True: 1.73k, False: 56.3k]
  ------------------
  665|  1.73k|        {
  666|  1.73k|            EPROSIMA_LOG_ERROR(DYN_TYPES, "Expected at least one member.");
  ------------------
  |  |   45|  1.73k|#define EPROSIMA_LOG_ERROR(cat, msg) EPROSIMA_LOG_ERROR_IMPL_(cat, msg)
  |  |  ------------------
  |  |  |  |  291|  1.73k|    do {                                                                                                               \
  |  |  |  |  292|  1.73k|        std::stringstream fastdds_log_ss_tmp__;                                                                        \
  |  |  |  |  293|  1.73k|        fastdds_log_ss_tmp__ << msg;                                                                                   \
  |  |  |  |  294|  1.73k|        eprosima::fastdds::dds::Log::QueueLog(                                                                         \
  |  |  |  |  295|  1.73k|            fastdds_log_ss_tmp__.str(), eprosima::fastdds::dds::Log::Context{__FILE__, __LINE__, __func__, #cat},      \
  |  |  |  |  296|  1.73k|            eprosima::fastdds::dds::Log::Kind::Error);                                                                 \
  |  |  |  |  297|  1.73k|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (297:14): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  667|  1.73k|        }
  668|       |
  669|  58.0k|        if (preconditions)
  ------------------
  |  Branch (669:13): [True: 56.3k, False: 1.73k]
  ------------------
  670|  56.3k|        {
  671|  56.3k|            ret_val = std::make_shared<DynamicTypeImpl>(type_descriptor_);
  672|  56.3k|            for (auto& annotation : annotation_)
  ------------------
  |  Branch (672:35): [True: 0, False: 56.3k]
  ------------------
  673|      0|            {
  674|      0|                ret_val->annotation_.emplace_back();
  675|      0|                ret_val->annotation_.back().copy_from(annotation);
  676|      0|            }
  677|  56.3k|            ret_val->member_ = member_;
  678|  56.3k|            ret_val->member_by_name_ = member_by_name_;
  679|  56.3k|            ret_val->members_ = members_;
  680|  56.3k|            ret_val->default_value_ = default_value_;
  681|  56.3k|            ret_val->default_union_member_ = default_union_member_;
  682|  56.3k|            ret_val->index_own_members_ = index_own_members_;
  683|  56.3k|        }
  684|  58.0k|    }
  685|       |
  686|  58.0k|    return ret_val;
  687|  58.0k|}
_ZN8eprosima7fastdds3dds15RollbackSettingIjEC2ERj:
  256|  67.8k|        : value_reference_{value_reference}
  257|  67.8k|        , previous_value_{value_reference}
  258|  67.8k|    {
  259|  67.8k|    }
_ZN8eprosima7fastdds3dds15RollbackSettingIjED2Ev:
  262|  67.8k|    {
  263|  67.8k|        if (activate)
  ------------------
  |  Branch (263:13): [True: 14.8k, False: 52.9k]
  ------------------
  264|  14.8k|        {
  265|  14.8k|            value_reference_ = previous_value_;
  266|  14.8k|        }
  267|  67.8k|    }
_ZN8eprosima7fastdds3dds15RollbackSettingIiEC2ERi:
  256|  33.9k|        : value_reference_{value_reference}
  257|  33.9k|        , previous_value_{value_reference}
  258|  33.9k|    {
  259|  33.9k|    }
_ZN8eprosima7fastdds3dds15RollbackSettingIiED2Ev:
  262|  33.9k|    {
  263|  33.9k|        if (activate)
  ------------------
  |  Branch (263:13): [True: 0, False: 33.9k]
  ------------------
  264|      0|        {
  265|      0|            value_reference_ = previous_value_;
  266|      0|        }
  267|  33.9k|    }

_ZN8eprosima7fastdds3dds22DynamicTypeBuilderImpl14get_descriptorEv:
  101|   214k|    {
  102|   214k|        return type_descriptor_;
  103|   214k|    }

_ZN8eprosima7fastdds3dds15DynamicTypeImplC1ERKNS1_18TypeDescriptorImplE:
   27|  56.3k|{
   28|  56.3k|    type_descriptor_.copy_from(descriptor);
   29|  56.3k|}
_ZN8eprosima7fastdds3dds15DynamicTypeImpl8get_kindEv:
   49|   412k|{
   50|   412k|    return type_descriptor_.kind();
   51|   412k|}
_ZN8eprosima7fastdds3dds15DynamicTypeImpl27resolve_alias_enclosed_typeEv:
  220|   114k|{
  221|   114k|    traits<DynamicTypeImpl>::ref_type ret_value = traits<DynamicType>::narrow<DynamicTypeImpl>(_this());
  222|       |
  223|   114k|    if (TK_ALIAS == ret_value->get_kind())
  ------------------
  |  Branch (223:9): [True: 1.41k, False: 113k]
  ------------------
  224|  1.41k|    {
  225|  1.41k|        do {
  226|  1.41k|            ret_value = traits<DynamicType>::narrow<DynamicTypeImpl>(ret_value->get_descriptor().base_type());
  227|  1.41k|        } while (TK_ALIAS == ret_value->get_kind());
  ------------------
  |  Branch (227:18): [True: 0, False: 1.41k]
  ------------------
  228|  1.41k|    }
  229|       |
  230|   114k|    return ret_value;
  231|   114k|}
_ZN8eprosima7fastdds3dds15DynamicTypeImpl5_thisEv:
  234|   114k|{
  235|   114k|    return shared_from_this();
  236|   114k|}

_ZNK8eprosima7fastdds3dds15DynamicTypeImpl14get_descriptorEv:
  100|  1.43k|    {
  101|  1.43k|        return type_descriptor_;
  102|  1.43k|    }

_ZN8eprosima7fastdds3dds21DynamicTypeMemberImplC1ERKNS1_20MemberDescriptorImplE:
   28|  24.3k|{
   29|  24.3k|    member_descriptor_.copy_from(descriptor);
   30|  24.3k|}

_ZN8eprosima7fastdds3dds21DynamicTypeMemberImpl14get_descriptorEv:
   69|   111k|    {
   70|   111k|        return member_descriptor_;
   71|   111k|    }

_ZN8eprosima7fastdds3dds6traitsINS1_16MemberDescriptorEE11make_sharedEv:
   72|  33.9k|{
   73|  33.9k|    return std::make_shared<MemberDescriptorImpl>();
   74|  33.9k|}
_ZN8eprosima7fastdds3dds20MemberDescriptorImpl9copy_fromERKS2_:
   89|  24.3k|{
   90|  24.3k|    name_ = descriptor.name_;
   91|  24.3k|    id_ = descriptor.id_;
   92|  24.3k|    type_ = descriptor.type_;
   93|  24.3k|    default_value_ = descriptor.default_value_;
   94|  24.3k|    index_ = descriptor.index_;
   95|  24.3k|    label_ = descriptor.label_;
   96|  24.3k|    try_construct_kind_ = descriptor.try_construct_kind_;
   97|  24.3k|    is_key_ = descriptor.is_key_;
   98|  24.3k|    is_optional_ = descriptor.is_optional_;
   99|  24.3k|    is_must_understand_ = descriptor.is_must_understand_;
  100|  24.3k|    is_shared_ = descriptor.is_shared_;
  101|  24.3k|    is_default_label_ = descriptor.is_default_label_;
  102|  24.3k|    is_try_construct_kind_set_ = descriptor.is_try_construct_kind_set_;
  103|       |
  104|  24.3k|    return RETCODE_OK;
  105|  24.3k|}
_ZN8eprosima7fastdds3dds20MemberDescriptorImpl13is_consistentEv:
  146|  23.4k|{
  147|  23.4k|    if (TK_NONE == parent_kind_)
  ------------------
  |  Branch (147:9): [True: 0, False: 23.4k]
  ------------------
  148|      0|    {
  149|      0|        EPROSIMA_LOG_ERROR(DYN_TYPES, "To check consistency the descriptor should be added as member");
  ------------------
  |  |   45|      0|#define EPROSIMA_LOG_ERROR(cat, msg) EPROSIMA_LOG_ERROR_IMPL_(cat, msg)
  |  |  ------------------
  |  |  |  |  291|      0|    do {                                                                                                               \
  |  |  |  |  292|      0|        std::stringstream fastdds_log_ss_tmp__;                                                                        \
  |  |  |  |  293|      0|        fastdds_log_ss_tmp__ << msg;                                                                                   \
  |  |  |  |  294|      0|        eprosima::fastdds::dds::Log::QueueLog(                                                                         \
  |  |  |  |  295|      0|            fastdds_log_ss_tmp__.str(), eprosima::fastdds::dds::Log::Context{__FILE__, __LINE__, __func__, #cat},      \
  |  |  |  |  296|      0|            eprosima::fastdds::dds::Log::Kind::Error);                                                                 \
  |  |  |  |  297|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (297:14): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  150|      0|        return false;
  151|      0|    }
  152|       |
  153|       |    // type_ cannot be nil.
  154|  23.4k|    if (!type_)
  ------------------
  |  Branch (154:9): [True: 0, False: 23.4k]
  ------------------
  155|      0|    {
  156|      0|        EPROSIMA_LOG_ERROR(DYN_TYPES, "Descriptor has no type and it is mandatory");
  ------------------
  |  |   45|      0|#define EPROSIMA_LOG_ERROR(cat, msg) EPROSIMA_LOG_ERROR_IMPL_(cat, msg)
  |  |  ------------------
  |  |  |  |  291|      0|    do {                                                                                                               \
  |  |  |  |  292|      0|        std::stringstream fastdds_log_ss_tmp__;                                                                        \
  |  |  |  |  293|      0|        fastdds_log_ss_tmp__ << msg;                                                                                   \
  |  |  |  |  294|      0|        eprosima::fastdds::dds::Log::QueueLog(                                                                         \
  |  |  |  |  295|      0|            fastdds_log_ss_tmp__.str(), eprosima::fastdds::dds::Log::Context{__FILE__, __LINE__, __func__, #cat},      \
  |  |  |  |  296|      0|            eprosima::fastdds::dds::Log::Kind::Error);                                                                 \
  |  |  |  |  297|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (297:14): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  157|      0|        return false;
  158|      0|    }
  159|       |
  160|  23.4k|    auto type = traits<DynamicType>::narrow<DynamicTypeImpl>(type_);
  161|       |
  162|       |    // Only aggregated types must use the ID value.
  163|  23.4k|    if ((MEMBER_ID_INVALID == id_ && (TK_ANNOTATION == parent_kind_ ||
  ------------------
  |  Branch (163:10): [True: 0, False: 23.4k]
  |  Branch (163:39): [True: 0, False: 0]
  ------------------
  164|      0|            TK_BITMASK == parent_kind_ ||
  ------------------
  |  Branch (164:13): [True: 0, False: 0]
  ------------------
  165|      0|            TK_BITSET == parent_kind_ ||
  ------------------
  |  Branch (165:13): [True: 0, False: 0]
  ------------------
  166|      0|            TK_UNION == parent_kind_ ||
  ------------------
  |  Branch (166:13): [True: 0, False: 0]
  ------------------
  167|      0|            TK_STRUCTURE == parent_kind_)) ||
  ------------------
  |  Branch (167:13): [True: 0, False: 0]
  ------------------
  168|  23.4k|            (MEMBER_ID_INVALID != id_ && TK_ANNOTATION != parent_kind_ &&
  ------------------
  |  Branch (168:14): [True: 23.4k, False: 0]
  |  Branch (168:42): [True: 23.4k, False: 0]
  ------------------
  169|  23.4k|            TK_BITMASK != parent_kind_ &&
  ------------------
  |  Branch (169:13): [True: 0, False: 23.4k]
  ------------------
  170|  23.4k|            TK_BITSET != parent_kind_ &&
  ------------------
  |  Branch (170:13): [True: 0, False: 0]
  ------------------
  171|  23.4k|            TK_UNION != parent_kind_ &&
  ------------------
  |  Branch (171:13): [True: 0, False: 0]
  ------------------
  172|  23.4k|            TK_STRUCTURE != parent_kind_))
  ------------------
  |  Branch (172:13): [True: 0, False: 0]
  ------------------
  173|      0|    {
  174|      0|        EPROSIMA_LOG_ERROR(DYN_TYPES, "Descriptor has a wrong MemberId " << id_);
  ------------------
  |  |   45|      0|#define EPROSIMA_LOG_ERROR(cat, msg) EPROSIMA_LOG_ERROR_IMPL_(cat, msg)
  |  |  ------------------
  |  |  |  |  291|      0|    do {                                                                                                               \
  |  |  |  |  292|      0|        std::stringstream fastdds_log_ss_tmp__;                                                                        \
  |  |  |  |  293|      0|        fastdds_log_ss_tmp__ << msg;                                                                                   \
  |  |  |  |  294|      0|        eprosima::fastdds::dds::Log::QueueLog(                                                                         \
  |  |  |  |  295|      0|            fastdds_log_ss_tmp__.str(), eprosima::fastdds::dds::Log::Context{__FILE__, __LINE__, __func__, #cat},      \
  |  |  |  |  296|      0|            eprosima::fastdds::dds::Log::Kind::Error);                                                                 \
  |  |  |  |  297|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (297:14): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  175|      0|        return false;
  176|      0|    }
  177|       |
  178|       |    // A union member cannot have the MemberId 0 because this value is for the discriminator
  179|  23.4k|    if (TK_UNION == parent_kind_ && 0 == id_)
  ------------------
  |  Branch (179:9): [True: 0, False: 23.4k]
  |  Branch (179:37): [True: 0, False: 0]
  ------------------
  180|      0|    {
  181|      0|        EPROSIMA_LOG_ERROR(DYN_TYPES,
  ------------------
  |  |   45|      0|#define EPROSIMA_LOG_ERROR(cat, msg) EPROSIMA_LOG_ERROR_IMPL_(cat, msg)
  |  |  ------------------
  |  |  |  |  291|      0|    do {                                                                                                               \
  |  |  |  |  292|      0|        std::stringstream fastdds_log_ss_tmp__;                                                                        \
  |  |  |  |  293|      0|        fastdds_log_ss_tmp__ << msg;                                                                                   \
  |  |  |  |  294|      0|        eprosima::fastdds::dds::Log::QueueLog(                                                                         \
  |  |  |  |  295|      0|            fastdds_log_ss_tmp__.str(), eprosima::fastdds::dds::Log::Context{__FILE__, __LINE__, __func__, #cat},      \
  |  |  |  |  296|      0|            eprosima::fastdds::dds::Log::Kind::Error);                                                                 \
  |  |  |  |  297|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (297:14): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  182|      0|                "Parent type is an UNION and the MemberId 0 is reserved to the discriminator");
  183|      0|        return false;
  184|      0|    }
  185|       |
  186|       |    // Check default_label.
  187|  23.4k|    if (is_default_label_ && TK_UNION != parent_kind_)
  ------------------
  |  Branch (187:9): [True: 0, False: 23.4k]
  |  Branch (187:30): [True: 0, False: 0]
  ------------------
  188|      0|    {
  189|      0|        EPROSIMA_LOG_ERROR(DYN_TYPES, "Parent type is not a UNION and it has set is_default_label");
  ------------------
  |  |   45|      0|#define EPROSIMA_LOG_ERROR(cat, msg) EPROSIMA_LOG_ERROR_IMPL_(cat, msg)
  |  |  ------------------
  |  |  |  |  291|      0|    do {                                                                                                               \
  |  |  |  |  292|      0|        std::stringstream fastdds_log_ss_tmp__;                                                                        \
  |  |  |  |  293|      0|        fastdds_log_ss_tmp__ << msg;                                                                                   \
  |  |  |  |  294|      0|        eprosima::fastdds::dds::Log::QueueLog(                                                                         \
  |  |  |  |  295|      0|            fastdds_log_ss_tmp__.str(), eprosima::fastdds::dds::Log::Context{__FILE__, __LINE__, __func__, #cat},      \
  |  |  |  |  296|      0|            eprosima::fastdds::dds::Log::Kind::Error);                                                                 \
  |  |  |  |  297|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (297:14): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  190|      0|        return false;
  191|      0|    }
  192|       |
  193|       |    // Check labels
  194|  23.4k|    if ((TK_UNION != parent_kind_ && 0 < label_.size()) ||
  ------------------
  |  Branch (194:10): [True: 23.4k, False: 0]
  |  Branch (194:38): [True: 0, False: 23.4k]
  ------------------
  195|  23.4k|            (TK_UNION == parent_kind_ && !is_default_label_ && 0 == label_.size()))
  ------------------
  |  Branch (195:14): [True: 0, False: 23.4k]
  |  Branch (195:42): [True: 0, False: 0]
  |  Branch (195:64): [True: 0, False: 0]
  ------------------
  196|      0|    {
  197|      0|        EPROSIMA_LOG_ERROR(DYN_TYPES, "Descriptor is not consistent with its labels");
  ------------------
  |  |   45|      0|#define EPROSIMA_LOG_ERROR(cat, msg) EPROSIMA_LOG_ERROR_IMPL_(cat, msg)
  |  |  ------------------
  |  |  |  |  291|      0|    do {                                                                                                               \
  |  |  |  |  292|      0|        std::stringstream fastdds_log_ss_tmp__;                                                                        \
  |  |  |  |  293|      0|        fastdds_log_ss_tmp__ << msg;                                                                                   \
  |  |  |  |  294|      0|        eprosima::fastdds::dds::Log::QueueLog(                                                                         \
  |  |  |  |  295|      0|            fastdds_log_ss_tmp__.str(), eprosima::fastdds::dds::Log::Context{__FILE__, __LINE__, __func__, #cat},      \
  |  |  |  |  296|      0|            eprosima::fastdds::dds::Log::Kind::Error);                                                                 \
  |  |  |  |  297|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (297:14): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  198|      0|        return false;
  199|      0|    }
  200|       |
  201|       |    // Check uniqueness of labels.
  202|  23.4k|    if (TK_UNION == parent_kind_)
  ------------------
  |  Branch (202:9): [True: 0, False: 23.4k]
  ------------------
  203|      0|    {
  204|      0|        UnionCaseLabelSeq label_copy {label_};
  205|      0|        std::sort(label_copy.begin(), label_copy.end());
  206|      0|        auto last = std::unique(label_copy.begin(), label_copy.end());
  207|      0|        if (label_copy.end() != last)
  ------------------
  |  Branch (207:13): [True: 0, False: 0]
  ------------------
  208|      0|        {
  209|      0|            EPROSIMA_LOG_ERROR(DYN_TYPES, "Descriptor contains duplicated labels");
  ------------------
  |  |   45|      0|#define EPROSIMA_LOG_ERROR(cat, msg) EPROSIMA_LOG_ERROR_IMPL_(cat, msg)
  |  |  ------------------
  |  |  |  |  291|      0|    do {                                                                                                               \
  |  |  |  |  292|      0|        std::stringstream fastdds_log_ss_tmp__;                                                                        \
  |  |  |  |  293|      0|        fastdds_log_ss_tmp__ << msg;                                                                                   \
  |  |  |  |  294|      0|        eprosima::fastdds::dds::Log::QueueLog(                                                                         \
  |  |  |  |  295|      0|            fastdds_log_ss_tmp__.str(), eprosima::fastdds::dds::Log::Context{__FILE__, __LINE__, __func__, #cat},      \
  |  |  |  |  296|      0|            eprosima::fastdds::dds::Log::Kind::Error);                                                                 \
  |  |  |  |  297|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (297:14): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  210|      0|            return false;
  211|      0|        }
  212|      0|    }
  213|       |
  214|  23.4k|    if (!default_value_.empty() &&
  ------------------
  |  Branch (214:9): [True: 0, False: 23.4k]
  ------------------
  215|  23.4k|            !TypeValueConverter::is_string_consistent(type->get_kind(), type->get_all_members_by_index(),
  ------------------
  |  Branch (215:13): [True: 0, False: 0]
  ------------------
  216|      0|            default_value_))
  217|      0|    {
  218|      0|        EPROSIMA_LOG_ERROR(DYN_TYPES, "Default value is not consistent");
  ------------------
  |  |   45|      0|#define EPROSIMA_LOG_ERROR(cat, msg) EPROSIMA_LOG_ERROR_IMPL_(cat, msg)
  |  |  ------------------
  |  |  |  |  291|      0|    do {                                                                                                               \
  |  |  |  |  292|      0|        std::stringstream fastdds_log_ss_tmp__;                                                                        \
  |  |  |  |  293|      0|        fastdds_log_ss_tmp__ << msg;                                                                                   \
  |  |  |  |  294|      0|        eprosima::fastdds::dds::Log::QueueLog(                                                                         \
  |  |  |  |  295|      0|            fastdds_log_ss_tmp__.str(), eprosima::fastdds::dds::Log::Context{__FILE__, __LINE__, __func__, #cat},      \
  |  |  |  |  296|      0|            eprosima::fastdds::dds::Log::Kind::Error);                                                                 \
  |  |  |  |  297|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (297:14): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  219|      0|        return false;
  220|      0|    }
  221|       |
  222|       |    // Check bitfield|enum enclosing type.
  223|  23.4k|    if (TK_BITSET == parent_kind_ ||
  ------------------
  |  Branch (223:9): [True: 0, False: 23.4k]
  ------------------
  224|  23.4k|            TK_ENUM == parent_kind_)
  ------------------
  |  Branch (224:13): [True: 0, False: 23.4k]
  ------------------
  225|      0|    {
  226|       |
  227|      0|        TypeKind kind = type->resolve_alias_enclosed_type()->get_kind();
  228|       |
  229|      0|        switch (kind)
  230|      0|        {
  231|      0|            case TK_INT8:
  ------------------
  |  Branch (231:13): [True: 0, False: 0]
  ------------------
  232|      0|            case TK_INT16:
  ------------------
  |  Branch (232:13): [True: 0, False: 0]
  ------------------
  233|      0|            case TK_INT32:
  ------------------
  |  Branch (233:13): [True: 0, False: 0]
  ------------------
  234|      0|                break;
  235|      0|            case TK_UINT8:
  ------------------
  |  Branch (235:13): [True: 0, False: 0]
  ------------------
  236|      0|            case TK_UINT16:
  ------------------
  |  Branch (236:13): [True: 0, False: 0]
  ------------------
  237|      0|            case TK_UINT32:
  ------------------
  |  Branch (237:13): [True: 0, False: 0]
  ------------------
  238|      0|            case TK_INT64:
  ------------------
  |  Branch (238:13): [True: 0, False: 0]
  ------------------
  239|      0|            case TK_UINT64:
  ------------------
  |  Branch (239:13): [True: 0, False: 0]
  ------------------
  240|      0|            case TK_BOOLEAN:
  ------------------
  |  Branch (240:13): [True: 0, False: 0]
  ------------------
  241|      0|            case TK_BYTE:
  ------------------
  |  Branch (241:13): [True: 0, False: 0]
  ------------------
  242|      0|                if (TK_ENUM == parent_kind_)
  ------------------
  |  Branch (242:21): [True: 0, False: 0]
  ------------------
  243|      0|                {
  244|      0|                    EPROSIMA_LOG_ERROR(DYN_TYPES, "Parent type is an ENUM and the enclosing type is not valid");
  ------------------
  |  |   45|      0|#define EPROSIMA_LOG_ERROR(cat, msg) EPROSIMA_LOG_ERROR_IMPL_(cat, msg)
  |  |  ------------------
  |  |  |  |  291|      0|    do {                                                                                                               \
  |  |  |  |  292|      0|        std::stringstream fastdds_log_ss_tmp__;                                                                        \
  |  |  |  |  293|      0|        fastdds_log_ss_tmp__ << msg;                                                                                   \
  |  |  |  |  294|      0|        eprosima::fastdds::dds::Log::QueueLog(                                                                         \
  |  |  |  |  295|      0|            fastdds_log_ss_tmp__.str(), eprosima::fastdds::dds::Log::Context{__FILE__, __LINE__, __func__, #cat},      \
  |  |  |  |  296|      0|            eprosima::fastdds::dds::Log::Kind::Error);                                                                 \
  |  |  |  |  297|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (297:14): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  245|      0|                    return false;
  246|      0|                }
  247|      0|                break;
  248|      0|            default:
  ------------------
  |  Branch (248:13): [True: 0, False: 0]
  ------------------
  249|      0|                EPROSIMA_LOG_ERROR(DYN_TYPES, "Parent type is an BITSET|ENUM and the enclosing type is not valid");
  ------------------
  |  |   45|      0|#define EPROSIMA_LOG_ERROR(cat, msg) EPROSIMA_LOG_ERROR_IMPL_(cat, msg)
  |  |  ------------------
  |  |  |  |  291|      0|    do {                                                                                                               \
  |  |  |  |  292|      0|        std::stringstream fastdds_log_ss_tmp__;                                                                        \
  |  |  |  |  293|      0|        fastdds_log_ss_tmp__ << msg;                                                                                   \
  |  |  |  |  294|      0|        eprosima::fastdds::dds::Log::QueueLog(                                                                         \
  |  |  |  |  295|      0|            fastdds_log_ss_tmp__.str(), eprosima::fastdds::dds::Log::Context{__FILE__, __LINE__, __func__, #cat},      \
  |  |  |  |  296|      0|            eprosima::fastdds::dds::Log::Kind::Error);                                                                 \
  |  |  |  |  297|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (297:14): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  250|      0|                return false;
  251|      0|                break;
  252|      0|        }
  253|      0|    }
  254|       |
  255|       |    // Check bitmask enclosing type.
  256|  23.4k|    if (TK_BITMASK ==  parent_kind_ && TK_BOOLEAN != type->get_kind())
  ------------------
  |  Branch (256:9): [True: 23.4k, False: 0]
  |  Branch (256:40): [True: 0, False: 23.4k]
  ------------------
  257|      0|    {
  258|      0|        EPROSIMA_LOG_ERROR(DYN_TYPES, "Parent type is a BITMASK and the enclosing type is not BOOLEAN");
  ------------------
  |  |   45|      0|#define EPROSIMA_LOG_ERROR(cat, msg) EPROSIMA_LOG_ERROR_IMPL_(cat, msg)
  |  |  ------------------
  |  |  |  |  291|      0|    do {                                                                                                               \
  |  |  |  |  292|      0|        std::stringstream fastdds_log_ss_tmp__;                                                                        \
  |  |  |  |  293|      0|        fastdds_log_ss_tmp__ << msg;                                                                                   \
  |  |  |  |  294|      0|        eprosima::fastdds::dds::Log::QueueLog(                                                                         \
  |  |  |  |  295|      0|            fastdds_log_ss_tmp__.str(), eprosima::fastdds::dds::Log::Context{__FILE__, __LINE__, __func__, #cat},      \
  |  |  |  |  296|      0|            eprosima::fastdds::dds::Log::Kind::Error);                                                                 \
  |  |  |  |  297|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (297:14): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  259|      0|        return false;
  260|      0|    }
  261|       |
  262|       |    // Check is_key built-in annotation.
  263|  23.4k|    if (is_key_ && TK_STRUCTURE != parent_kind_)
  ------------------
  |  Branch (263:9): [True: 0, False: 23.4k]
  |  Branch (263:20): [True: 0, False: 0]
  ------------------
  264|      0|    {
  265|      0|        EPROSIMA_LOG_ERROR(DYN_TYPES, "is_key is set but parent type of member is not TK_STRUCTURE.");
  ------------------
  |  |   45|      0|#define EPROSIMA_LOG_ERROR(cat, msg) EPROSIMA_LOG_ERROR_IMPL_(cat, msg)
  |  |  ------------------
  |  |  |  |  291|      0|    do {                                                                                                               \
  |  |  |  |  292|      0|        std::stringstream fastdds_log_ss_tmp__;                                                                        \
  |  |  |  |  293|      0|        fastdds_log_ss_tmp__ << msg;                                                                                   \
  |  |  |  |  294|      0|        eprosima::fastdds::dds::Log::QueueLog(                                                                         \
  |  |  |  |  295|      0|            fastdds_log_ss_tmp__.str(), eprosima::fastdds::dds::Log::Context{__FILE__, __LINE__, __func__, #cat},      \
  |  |  |  |  296|      0|            eprosima::fastdds::dds::Log::Kind::Error);                                                                 \
  |  |  |  |  297|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (297:14): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  266|      0|        return false;
  267|      0|    }
  268|       |
  269|       |    // Check is_must_understand built-in annotation.
  270|  23.4k|    if (is_must_understand_)
  ------------------
  |  Branch (270:9): [True: 0, False: 23.4k]
  ------------------
  271|      0|    {
  272|      0|        if (TK_STRUCTURE != parent_kind_)
  ------------------
  |  Branch (272:13): [True: 0, False: 0]
  ------------------
  273|      0|        {
  274|      0|            EPROSIMA_LOG_ERROR(DYN_TYPES, "is_must_understand is set but parent type of member is not TK_STRUCTURE.");
  ------------------
  |  |   45|      0|#define EPROSIMA_LOG_ERROR(cat, msg) EPROSIMA_LOG_ERROR_IMPL_(cat, msg)
  |  |  ------------------
  |  |  |  |  291|      0|    do {                                                                                                               \
  |  |  |  |  292|      0|        std::stringstream fastdds_log_ss_tmp__;                                                                        \
  |  |  |  |  293|      0|        fastdds_log_ss_tmp__ << msg;                                                                                   \
  |  |  |  |  294|      0|        eprosima::fastdds::dds::Log::QueueLog(                                                                         \
  |  |  |  |  295|      0|            fastdds_log_ss_tmp__.str(), eprosima::fastdds::dds::Log::Context{__FILE__, __LINE__, __func__, #cat},      \
  |  |  |  |  296|      0|            eprosima::fastdds::dds::Log::Kind::Error);                                                                 \
  |  |  |  |  297|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (297:14): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  275|      0|            return false;
  276|      0|        }
  277|      0|        else
  278|      0|        {
  279|      0|            EPROSIMA_LOG_WARNING(DYN_TYPES, "is_must_understand is not implemented yet.");
  ------------------
  |  |   43|      0|#define EPROSIMA_LOG_WARNING(cat, msg) EPROSIMA_LOG_WARNING_IMPL_(cat, msg)
  |  |  ------------------
  |  |  |  |  322|      0|    do {                                                                                                              \
  |  |  |  |  323|      0|        if (eprosima::fastdds::dds::Log::GetVerbosity() >= eprosima::fastdds::dds::Log::Kind::Warning)                \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (323:13): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  |  |  324|      0|        {                                                                                                             \
  |  |  |  |  325|      0|            std::stringstream fastdds_log_ss_tmp__;                                                                   \
  |  |  |  |  326|      0|            fastdds_log_ss_tmp__ << msg;                                                                              \
  |  |  |  |  327|      0|            eprosima::fastdds::dds::Log::QueueLog(                                                                    \
  |  |  |  |  328|      0|                fastdds_log_ss_tmp__.str(), eprosima::fastdds::dds::Log::Context{__FILE__, __LINE__, __func__, #cat}, \
  |  |  |  |  329|      0|                eprosima::fastdds::dds::Log::Kind::Warning);                                                          \
  |  |  |  |  330|      0|        }                                                                                                             \
  |  |  |  |  331|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (331:14): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  280|      0|        }
  281|      0|    }
  282|       |
  283|       |    // Check is_optional built-in annotation.
  284|  23.4k|    if (is_optional_)
  ------------------
  |  Branch (284:9): [True: 0, False: 23.4k]
  ------------------
  285|      0|    {
  286|      0|        if (TK_STRUCTURE != parent_kind_)
  ------------------
  |  Branch (286:13): [True: 0, False: 0]
  ------------------
  287|      0|        {
  288|      0|            {
  289|      0|                EPROSIMA_LOG_ERROR(DYN_TYPES, "is_optional is set but parent type of member is not TK_STRUCTURE.");
  ------------------
  |  |   45|      0|#define EPROSIMA_LOG_ERROR(cat, msg) EPROSIMA_LOG_ERROR_IMPL_(cat, msg)
  |  |  ------------------
  |  |  |  |  291|      0|    do {                                                                                                               \
  |  |  |  |  292|      0|        std::stringstream fastdds_log_ss_tmp__;                                                                        \
  |  |  |  |  293|      0|        fastdds_log_ss_tmp__ << msg;                                                                                   \
  |  |  |  |  294|      0|        eprosima::fastdds::dds::Log::QueueLog(                                                                         \
  |  |  |  |  295|      0|            fastdds_log_ss_tmp__.str(), eprosima::fastdds::dds::Log::Context{__FILE__, __LINE__, __func__, #cat},      \
  |  |  |  |  296|      0|            eprosima::fastdds::dds::Log::Kind::Error);                                                                 \
  |  |  |  |  297|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (297:14): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  290|      0|                return false;
  291|      0|            }
  292|      0|        }
  293|      0|        else
  294|      0|        {
  295|      0|            EPROSIMA_LOG_WARNING(DYN_TYPES, "is_optional is not implemented yet.");
  ------------------
  |  |   43|      0|#define EPROSIMA_LOG_WARNING(cat, msg) EPROSIMA_LOG_WARNING_IMPL_(cat, msg)
  |  |  ------------------
  |  |  |  |  322|      0|    do {                                                                                                              \
  |  |  |  |  323|      0|        if (eprosima::fastdds::dds::Log::GetVerbosity() >= eprosima::fastdds::dds::Log::Kind::Warning)                \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (323:13): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  |  |  324|      0|        {                                                                                                             \
  |  |  |  |  325|      0|            std::stringstream fastdds_log_ss_tmp__;                                                                   \
  |  |  |  |  326|      0|            fastdds_log_ss_tmp__ << msg;                                                                              \
  |  |  |  |  327|      0|            eprosima::fastdds::dds::Log::QueueLog(                                                                    \
  |  |  |  |  328|      0|                fastdds_log_ss_tmp__.str(), eprosima::fastdds::dds::Log::Context{__FILE__, __LINE__, __func__, #cat}, \
  |  |  |  |  329|      0|                eprosima::fastdds::dds::Log::Kind::Warning);                                                          \
  |  |  |  |  330|      0|        }                                                                                                             \
  |  |  |  |  331|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (331:14): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  296|      0|        }
  297|      0|    }
  298|       |
  299|       |    // Check is_shared built-in annotation.
  300|  23.4k|    if (is_shared_)
  ------------------
  |  Branch (300:9): [True: 0, False: 23.4k]
  ------------------
  301|      0|    {
  302|      0|        if (TK_STRUCTURE != parent_kind_ && TK_UNION != parent_kind_)
  ------------------
  |  Branch (302:13): [True: 0, False: 0]
  |  Branch (302:45): [True: 0, False: 0]
  ------------------
  303|      0|        {
  304|      0|            EPROSIMA_LOG_ERROR(DYN_TYPES,
  ------------------
  |  |   45|      0|#define EPROSIMA_LOG_ERROR(cat, msg) EPROSIMA_LOG_ERROR_IMPL_(cat, msg)
  |  |  ------------------
  |  |  |  |  291|      0|    do {                                                                                                               \
  |  |  |  |  292|      0|        std::stringstream fastdds_log_ss_tmp__;                                                                        \
  |  |  |  |  293|      0|        fastdds_log_ss_tmp__ << msg;                                                                                   \
  |  |  |  |  294|      0|        eprosima::fastdds::dds::Log::QueueLog(                                                                         \
  |  |  |  |  295|      0|            fastdds_log_ss_tmp__.str(), eprosima::fastdds::dds::Log::Context{__FILE__, __LINE__, __func__, #cat},      \
  |  |  |  |  296|      0|            eprosima::fastdds::dds::Log::Kind::Error);                                                                 \
  |  |  |  |  297|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (297:14): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  305|      0|                    "is_shared is set but parent type of member is not TK_STRUCTURE or TK_UNION.");
  306|      0|            return false;
  307|      0|        }
  308|      0|        else
  309|      0|        {
  310|      0|            EPROSIMA_LOG_WARNING(DYN_TYPES, "is_shared is not implemented yet.");
  ------------------
  |  |   43|      0|#define EPROSIMA_LOG_WARNING(cat, msg) EPROSIMA_LOG_WARNING_IMPL_(cat, msg)
  |  |  ------------------
  |  |  |  |  322|      0|    do {                                                                                                              \
  |  |  |  |  323|      0|        if (eprosima::fastdds::dds::Log::GetVerbosity() >= eprosima::fastdds::dds::Log::Kind::Warning)                \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (323:13): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  |  |  324|      0|        {                                                                                                             \
  |  |  |  |  325|      0|            std::stringstream fastdds_log_ss_tmp__;                                                                   \
  |  |  |  |  326|      0|            fastdds_log_ss_tmp__ << msg;                                                                              \
  |  |  |  |  327|      0|            eprosima::fastdds::dds::Log::QueueLog(                                                                    \
  |  |  |  |  328|      0|                fastdds_log_ss_tmp__.str(), eprosima::fastdds::dds::Log::Context{__FILE__, __LINE__, __func__, #cat}, \
  |  |  |  |  329|      0|                eprosima::fastdds::dds::Log::Kind::Warning);                                                          \
  |  |  |  |  330|      0|        }                                                                                                             \
  |  |  |  |  331|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (331:14): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  311|      0|        }
  312|      0|    }
  313|       |
  314|       |    // Check try_construct built-in annotation.
  315|  23.4k|    if (is_try_construct_kind_set_)
  ------------------
  |  Branch (315:9): [True: 0, False: 23.4k]
  ------------------
  316|      0|    {
  317|      0|        if (TK_STRUCTURE != parent_kind_ && TK_UNION != parent_kind_)
  ------------------
  |  Branch (317:13): [True: 0, False: 0]
  |  Branch (317:45): [True: 0, False: 0]
  ------------------
  318|      0|        {
  319|      0|            EPROSIMA_LOG_ERROR(DYN_TYPES,
  ------------------
  |  |   45|      0|#define EPROSIMA_LOG_ERROR(cat, msg) EPROSIMA_LOG_ERROR_IMPL_(cat, msg)
  |  |  ------------------
  |  |  |  |  291|      0|    do {                                                                                                               \
  |  |  |  |  292|      0|        std::stringstream fastdds_log_ss_tmp__;                                                                        \
  |  |  |  |  293|      0|        fastdds_log_ss_tmp__ << msg;                                                                                   \
  |  |  |  |  294|      0|        eprosima::fastdds::dds::Log::QueueLog(                                                                         \
  |  |  |  |  295|      0|            fastdds_log_ss_tmp__.str(), eprosima::fastdds::dds::Log::Context{__FILE__, __LINE__, __func__, #cat},      \
  |  |  |  |  296|      0|            eprosima::fastdds::dds::Log::Kind::Error);                                                                 \
  |  |  |  |  297|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (297:14): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  320|      0|                    "try_construct_kind is set but parent type of member is not TK_STRUCTURE or TK_UNION.");
  321|      0|            return false;
  322|      0|        }
  323|      0|        else if (TryConstructKind::DISCARD != try_construct_kind_)
  ------------------
  |  Branch (323:18): [True: 0, False: 0]
  ------------------
  324|      0|        {
  325|      0|            EPROSIMA_LOG_WARNING(DYN_TYPES, "try_construct_kind is not implemented yet.");
  ------------------
  |  |   43|      0|#define EPROSIMA_LOG_WARNING(cat, msg) EPROSIMA_LOG_WARNING_IMPL_(cat, msg)
  |  |  ------------------
  |  |  |  |  322|      0|    do {                                                                                                              \
  |  |  |  |  323|      0|        if (eprosima::fastdds::dds::Log::GetVerbosity() >= eprosima::fastdds::dds::Log::Kind::Warning)                \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (323:13): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  |  |  324|      0|        {                                                                                                             \
  |  |  |  |  325|      0|            std::stringstream fastdds_log_ss_tmp__;                                                                   \
  |  |  |  |  326|      0|            fastdds_log_ss_tmp__ << msg;                                                                              \
  |  |  |  |  327|      0|            eprosima::fastdds::dds::Log::QueueLog(                                                                    \
  |  |  |  |  328|      0|                fastdds_log_ss_tmp__.str(), eprosima::fastdds::dds::Log::Context{__FILE__, __LINE__, __func__, #cat}, \
  |  |  |  |  329|      0|                eprosima::fastdds::dds::Log::Kind::Warning);                                                          \
  |  |  |  |  330|      0|        }                                                                                                             \
  |  |  |  |  331|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (331:14): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  326|      0|        }
  327|      0|    }
  328|       |
  329|       |    // TK_MAP member cannot be key.
  330|  23.4k|    if (TK_MAP == type->get_kind() && is_key_)
  ------------------
  |  Branch (330:9): [True: 0, False: 23.4k]
  |  Branch (330:39): [True: 0, False: 0]
  ------------------
  331|      0|    {
  332|      0|        EPROSIMA_LOG_ERROR(DYN_TYPES, "TK_MAP member cannot be part of the key.");
  ------------------
  |  |   45|      0|#define EPROSIMA_LOG_ERROR(cat, msg) EPROSIMA_LOG_ERROR_IMPL_(cat, msg)
  |  |  ------------------
  |  |  |  |  291|      0|    do {                                                                                                               \
  |  |  |  |  292|      0|        std::stringstream fastdds_log_ss_tmp__;                                                                        \
  |  |  |  |  293|      0|        fastdds_log_ss_tmp__ << msg;                                                                                   \
  |  |  |  |  294|      0|        eprosima::fastdds::dds::Log::QueueLog(                                                                         \
  |  |  |  |  295|      0|            fastdds_log_ss_tmp__.str(), eprosima::fastdds::dds::Log::Context{__FILE__, __LINE__, __func__, #cat},      \
  |  |  |  |  296|      0|            eprosima::fastdds::dds::Log::Kind::Error);                                                                 \
  |  |  |  |  297|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (297:14): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  333|      0|        return false;
  334|      0|    }
  335|       |
  336|       |    // Check name consistency
  337|  23.4k|    if (0 == name_.size() && (TK_ANNOTATION == parent_kind_ ||
  ------------------
  |  Branch (337:9): [True: 7.83k, False: 15.5k]
  |  Branch (337:31): [True: 0, False: 7.83k]
  ------------------
  338|  7.83k|            TK_BITMASK == parent_kind_ ||
  ------------------
  |  Branch (338:13): [True: 7.83k, False: 0]
  ------------------
  339|  7.83k|            TK_BITSET == parent_kind_ ||
  ------------------
  |  Branch (339:13): [True: 0, False: 0]
  ------------------
  340|  7.83k|            TK_ENUM == parent_kind_ ||
  ------------------
  |  Branch (340:13): [True: 0, False: 0]
  ------------------
  341|  7.83k|            TK_STRUCTURE == parent_kind_ ||
  ------------------
  |  Branch (341:13): [True: 0, False: 0]
  ------------------
  342|  7.83k|            TK_UNION == parent_kind_))
  ------------------
  |  Branch (342:13): [True: 0, False: 0]
  ------------------
  343|  7.83k|    {
  344|  7.83k|        EPROSIMA_LOG_ERROR(DYN_TYPES,
  ------------------
  |  |   45|  7.83k|#define EPROSIMA_LOG_ERROR(cat, msg) EPROSIMA_LOG_ERROR_IMPL_(cat, msg)
  |  |  ------------------
  |  |  |  |  291|  7.83k|    do {                                                                                                               \
  |  |  |  |  292|  7.83k|        std::stringstream fastdds_log_ss_tmp__;                                                                        \
  |  |  |  |  293|  7.83k|        fastdds_log_ss_tmp__ << msg;                                                                                   \
  |  |  |  |  294|  7.83k|        eprosima::fastdds::dds::Log::QueueLog(                                                                         \
  |  |  |  |  295|  7.83k|            fastdds_log_ss_tmp__.str(), eprosima::fastdds::dds::Log::Context{__FILE__, __LINE__, __func__, #cat},      \
  |  |  |  |  296|  7.83k|            eprosima::fastdds::dds::Log::Kind::Error);                                                                 \
  |  |  |  |  297|  7.83k|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (297:14): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  345|  7.83k|                "Parent type is an ANNOTATION|BITMASK|BITSET|ENUM|STRUCTURE|UNION and the member has no name.");
  346|  7.83k|        return false;
  347|  7.83k|    }
  348|       |
  349|  15.5k|    return true;
  350|  23.4k|}

_ZN8eprosima7fastdds3dds20MemberDescriptorImpl4nameEv:
   85|  33.7k|    {
   86|  33.7k|        return name_;
   87|  33.7k|    }
_ZN8eprosima7fastdds3dds20MemberDescriptorImpl4nameEONS_7fastcdr12fixed_stringILm256EEE:
  102|  33.9k|    {
  103|  33.9k|        name_ = std::move(name);
  104|  33.9k|    }
_ZN8eprosima7fastdds3dds20MemberDescriptorImpl2idEv:
  112|  27.5k|    {
  113|  27.5k|        return id_;
  114|  27.5k|    }
_ZN8eprosima7fastdds3dds20MemberDescriptorImpl2idEj:
  118|  58.2k|    {
  119|  58.2k|        id_ = id;
  120|  58.2k|    }
_ZN8eprosima7fastdds3dds20MemberDescriptorImpl4typeENSt3__110shared_ptrINS1_11DynamicTypeEEE:
  134|  33.9k|    {
  135|  33.9k|        type_ = type;
  136|  33.9k|    }
_ZN8eprosima7fastdds3dds20MemberDescriptorImpl5indexEv:
  166|  15.5k|    {
  167|  15.5k|        return index_;
  168|  15.5k|    }
_ZN8eprosima7fastdds3dds20MemberDescriptorImpl5indexEj:
  172|  24.3k|    {
  173|  24.3k|        index_ = index;
  174|  24.3k|    }
_ZN8eprosima7fastdds3dds20MemberDescriptorImpl11parent_kindEh:
  210|  23.4k|    {
  211|  23.4k|        parent_kind_ = parent_kind;
  212|  23.4k|    }
_ZN8eprosima7fastdds3dds20MemberDescriptorImplC1Ev:
   74|  58.2k|    MemberDescriptorImpl() noexcept = default;
_ZN8eprosima7fastdds3dds20MemberDescriptorImplD2Ev:
   82|  58.0k|    virtual ~MemberDescriptorImpl() noexcept = default;

_ZN8eprosima7fastdds3dds6traitsINS1_14TypeDescriptorEE11make_sharedEv:
   32|  51.0k|{
   33|  51.0k|    return std::make_shared<TypeDescriptorImpl>();
   34|  51.0k|}
_ZN8eprosima7fastdds3dds23is_type_name_consistentERKNS_7fastcdr12fixed_stringILm256EEE:
   64|   155k|{
   65|       |    // Implement an FSM string parser to deal with both a plain type name
   66|       |    // and a fully qualified name. According to the DDS xtypes standard,
   67|       |    // type's fully qualified name is a concatenation of module names with
   68|       |    // the name of a type inside of those modules.
   69|   155k|    int currState = INVALID;
   70|   609k|    for (uint32_t i = 0; i < sName.size(); ++i)
  ------------------
  |  Branch (70:26): [True: 493k, False: 115k]
  ------------------
   71|   493k|    {
   72|   493k|        int col = 0;
   73|   493k|        if (std::isalpha(sName[i]))
  ------------------
  |  Branch (73:13): [True: 387k, False: 105k]
  ------------------
   74|   387k|        {
   75|   387k|            col = LETTER;
   76|   387k|        }
   77|   105k|        else if (std::isdigit(sName[i]))
  ------------------
  |  Branch (77:18): [True: 59.5k, False: 46.2k]
  ------------------
   78|  59.5k|        {
   79|  59.5k|            col = NUMBER;
   80|  59.5k|        }
   81|  46.2k|        else if (sName[i] == '_')
  ------------------
  |  Branch (81:18): [True: 5.20k, False: 41.0k]
  ------------------
   82|  5.20k|        {
   83|  5.20k|            col = UNDERSCORE;
   84|  5.20k|        }
   85|  41.0k|        else if (sName[i] == ':')
  ------------------
  |  Branch (85:18): [True: 25.0k, False: 15.9k]
  ------------------
   86|  25.0k|        {
   87|  25.0k|            col = COLON;
   88|  25.0k|        }
   89|  15.9k|        else
   90|  15.9k|        {
   91|  15.9k|            col = OTHER;
   92|  15.9k|        }
   93|   493k|        currState = stateTable[currState][col];
   94|   493k|        if (currState == INVALID)
  ------------------
  |  Branch (94:13): [True: 39.8k, False: 453k]
  ------------------
   95|  39.8k|        {
   96|  39.8k|            return false;
   97|  39.8k|        }
   98|   493k|    }
   99|   115k|    return true;
  100|   155k|}
_ZN8eprosima7fastdds3dds18TypeDescriptorImplC1EhRKNS_7fastcdr12fixed_stringILm256EEE:
  105|  68.7k|    : kind_(kind)
  106|  68.7k|    , name_(name)
  107|  68.7k|{
  108|  68.7k|}
_ZN8eprosima7fastdds3dds18TypeDescriptorImpl9copy_fromERKS2_:
  123|   129k|{
  124|   129k|    kind_ = descriptor.kind_;
  125|   129k|    name_ = descriptor.name_;
  126|   129k|    base_type_ = descriptor.base_type_;
  127|   129k|    discriminator_type_ = descriptor.discriminator_type_;
  128|   129k|    bound_ = descriptor.bound_;
  129|   129k|    element_type_ = descriptor.element_type_;
  130|   129k|    key_element_type_ = descriptor.key_element_type_;
  131|   129k|    extensibility_kind_ = descriptor.extensibility_kind_;
  132|   129k|    is_nested_ = descriptor.is_nested_;
  133|   129k|    is_extensibility_set_ = descriptor.is_extensibility_set_;
  134|       |
  135|   129k|    return RETCODE_OK;
  136|   129k|}
_ZN8eprosima7fastdds3dds18TypeDescriptorImpl13is_consistentEv:
  162|   171k|{
  163|       |    // Alias Types need the base type to indicate what type has been aliased.
  164|   171k|    if (TK_ALIAS == kind_ && !base_type_)
  ------------------
  |  Branch (164:9): [True: 33.3k, False: 137k]
  |  Branch (164:30): [True: 0, False: 33.3k]
  ------------------
  165|      0|    {
  166|      0|        EPROSIMA_LOG_ERROR(DYN_TYPES, "Descriptor describes an ALIAS but the base_type was not set");
  ------------------
  |  |   45|      0|#define EPROSIMA_LOG_ERROR(cat, msg) EPROSIMA_LOG_ERROR_IMPL_(cat, msg)
  |  |  ------------------
  |  |  |  |  291|      0|    do {                                                                                                               \
  |  |  |  |  292|      0|        std::stringstream fastdds_log_ss_tmp__;                                                                        \
  |  |  |  |  293|      0|        fastdds_log_ss_tmp__ << msg;                                                                                   \
  |  |  |  |  294|      0|        eprosima::fastdds::dds::Log::QueueLog(                                                                         \
  |  |  |  |  295|      0|            fastdds_log_ss_tmp__.str(), eprosima::fastdds::dds::Log::Context{__FILE__, __LINE__, __func__, #cat},      \
  |  |  |  |  296|      0|            eprosima::fastdds::dds::Log::Kind::Error);                                                                 \
  |  |  |  |  297|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (297:14): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  167|      0|        return false;
  168|      0|    }
  169|       |
  170|       |    // Alias must have base type, and structures and bitsets optionally can have it.
  171|   171k|    if (base_type_ &&
  ------------------
  |  Branch (171:9): [True: 33.4k, False: 137k]
  ------------------
  172|   171k|            TK_ALIAS != kind_ &&
  ------------------
  |  Branch (172:13): [True: 18, False: 33.3k]
  ------------------
  173|   171k|            TK_BITSET != kind_ &&
  ------------------
  |  Branch (173:13): [True: 18, False: 0]
  ------------------
  174|   171k|            TK_STRUCTURE != kind_)
  ------------------
  |  Branch (174:13): [True: 0, False: 18]
  ------------------
  175|      0|    {
  176|      0|        EPROSIMA_LOG_ERROR(DYN_TYPES,
  ------------------
  |  |   45|      0|#define EPROSIMA_LOG_ERROR(cat, msg) EPROSIMA_LOG_ERROR_IMPL_(cat, msg)
  |  |  ------------------
  |  |  |  |  291|      0|    do {                                                                                                               \
  |  |  |  |  292|      0|        std::stringstream fastdds_log_ss_tmp__;                                                                        \
  |  |  |  |  293|      0|        fastdds_log_ss_tmp__ << msg;                                                                                   \
  |  |  |  |  294|      0|        eprosima::fastdds::dds::Log::QueueLog(                                                                         \
  |  |  |  |  295|      0|            fastdds_log_ss_tmp__.str(), eprosima::fastdds::dds::Log::Context{__FILE__, __LINE__, __func__, #cat},      \
  |  |  |  |  296|      0|            eprosima::fastdds::dds::Log::Kind::Error);                                                                 \
  |  |  |  |  297|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (297:14): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  177|      0|                "Descriptor doesn't describe an ALIAS|BITSET|STRUCTURE but the base_type was set");
  178|      0|        return false;
  179|      0|    }
  180|       |
  181|       |    // Check the parent is of the same kind.
  182|   171k|    if (base_type_ && TK_ALIAS != kind_)
  ------------------
  |  Branch (182:9): [True: 33.4k, False: 137k]
  |  Branch (182:23): [True: 18, False: 33.3k]
  ------------------
  183|     18|    {
  184|     18|        auto base_type =
  185|     18|                traits<DynamicType>::narrow<DynamicTypeImpl>(base_type_)->resolve_alias_enclosed_type();
  186|       |
  187|     18|        if (kind_ != base_type->get_kind())
  ------------------
  |  Branch (187:13): [True: 0, False: 18]
  ------------------
  188|      0|        {
  189|      0|            EPROSIMA_LOG_ERROR(DYN_TYPES, "Descriptor type and the base_type are not of the same kind");
  ------------------
  |  |   45|      0|#define EPROSIMA_LOG_ERROR(cat, msg) EPROSIMA_LOG_ERROR_IMPL_(cat, msg)
  |  |  ------------------
  |  |  |  |  291|      0|    do {                                                                                                               \
  |  |  |  |  292|      0|        std::stringstream fastdds_log_ss_tmp__;                                                                        \
  |  |  |  |  293|      0|        fastdds_log_ss_tmp__ << msg;                                                                                   \
  |  |  |  |  294|      0|        eprosima::fastdds::dds::Log::QueueLog(                                                                         \
  |  |  |  |  295|      0|            fastdds_log_ss_tmp__.str(), eprosima::fastdds::dds::Log::Context{__FILE__, __LINE__, __func__, #cat},      \
  |  |  |  |  296|      0|            eprosima::fastdds::dds::Log::Kind::Error);                                                                 \
  |  |  |  |  297|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (297:14): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  190|      0|            return false;
  191|      0|        }
  192|       |
  193|       |        // Check extensibility on structures.
  194|     18|        if (TK_STRUCTURE == kind_)
  ------------------
  |  Branch (194:13): [True: 18, False: 0]
  ------------------
  195|     18|        {
  196|     18|            if (!is_extensibility_set_)
  ------------------
  |  Branch (196:17): [True: 18, False: 0]
  ------------------
  197|     18|            {
  198|     18|                extensibility_kind_ = base_type->get_descriptor().extensibility_kind();
  199|     18|            }
  200|      0|            else if (extensibility_kind_ != base_type->get_descriptor().extensibility_kind())
  ------------------
  |  Branch (200:22): [True: 0, False: 0]
  ------------------
  201|      0|            {
  202|      0|                EPROSIMA_LOG_ERROR(DYN_TYPES, "ExtensibilityKind is different from that of base type.");
  ------------------
  |  |   45|      0|#define EPROSIMA_LOG_ERROR(cat, msg) EPROSIMA_LOG_ERROR_IMPL_(cat, msg)
  |  |  ------------------
  |  |  |  |  291|      0|    do {                                                                                                               \
  |  |  |  |  292|      0|        std::stringstream fastdds_log_ss_tmp__;                                                                        \
  |  |  |  |  293|      0|        fastdds_log_ss_tmp__ << msg;                                                                                   \
  |  |  |  |  294|      0|        eprosima::fastdds::dds::Log::QueueLog(                                                                         \
  |  |  |  |  295|      0|            fastdds_log_ss_tmp__.str(), eprosima::fastdds::dds::Log::Context{__FILE__, __LINE__, __func__, #cat},      \
  |  |  |  |  296|      0|            eprosima::fastdds::dds::Log::Kind::Error);                                                                 \
  |  |  |  |  297|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (297:14): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  203|      0|                return false;
  204|      0|            }
  205|     18|        }
  206|     18|    }
  207|       |
  208|   171k|    if (0 < bound_.size() && (
  ------------------
  |  Branch (208:9): [True: 127k, False: 43.9k]
  ------------------
  209|   127k|                TK_ARRAY != kind_     &&
  ------------------
  |  Branch (209:17): [True: 67.9k, False: 59.4k]
  ------------------
  210|   127k|                TK_BITMASK != kind_   &&
  ------------------
  |  Branch (210:17): [True: 60.8k, False: 7.02k]
  ------------------
  211|   127k|                TK_BITSET != kind_    &&
  ------------------
  |  Branch (211:17): [True: 60.8k, False: 0]
  ------------------
  212|   127k|                TK_MAP != kind_       &&
  ------------------
  |  Branch (212:17): [True: 45.4k, False: 15.4k]
  ------------------
  213|   127k|                TK_SEQUENCE != kind_  &&
  ------------------
  |  Branch (213:17): [True: 33.3k, False: 12.1k]
  ------------------
  214|   127k|                TK_STRING8 != kind_   &&
  ------------------
  |  Branch (214:17): [True: 10.2k, False: 23.1k]
  ------------------
  215|   127k|                TK_STRING16 != kind_  ))
  ------------------
  |  Branch (215:17): [True: 0, False: 10.2k]
  ------------------
  216|      0|    {
  217|      0|        EPROSIMA_LOG_ERROR(DYN_TYPES, "Descriptor describes a type which not support bound");
  ------------------
  |  |   45|      0|#define EPROSIMA_LOG_ERROR(cat, msg) EPROSIMA_LOG_ERROR_IMPL_(cat, msg)
  |  |  ------------------
  |  |  |  |  291|      0|    do {                                                                                                               \
  |  |  |  |  292|      0|        std::stringstream fastdds_log_ss_tmp__;                                                                        \
  |  |  |  |  293|      0|        fastdds_log_ss_tmp__ << msg;                                                                                   \
  |  |  |  |  294|      0|        eprosima::fastdds::dds::Log::QueueLog(                                                                         \
  |  |  |  |  295|      0|            fastdds_log_ss_tmp__.str(), eprosima::fastdds::dds::Log::Context{__FILE__, __LINE__, __func__, #cat},      \
  |  |  |  |  296|      0|            eprosima::fastdds::dds::Log::Kind::Error);                                                                 \
  |  |  |  |  297|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (297:14): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  218|      0|        return false;
  219|      0|    }
  220|       |
  221|       |    // Arrays need one or more bound fields with the lenghts of each dimension.
  222|   171k|    if (TK_ARRAY == kind_ && 0 == bound_.size())
  ------------------
  |  Branch (222:9): [True: 61.1k, False: 110k]
  |  Branch (222:30): [True: 1.71k, False: 59.4k]
  ------------------
  223|  1.71k|    {
  224|  1.71k|        EPROSIMA_LOG_ERROR(DYN_TYPES, "Descriptor describes an ARRAY but bound is empty");
  ------------------
  |  |   45|  1.71k|#define EPROSIMA_LOG_ERROR(cat, msg) EPROSIMA_LOG_ERROR_IMPL_(cat, msg)
  |  |  ------------------
  |  |  |  |  291|  1.71k|    do {                                                                                                               \
  |  |  |  |  292|  1.71k|        std::stringstream fastdds_log_ss_tmp__;                                                                        \
  |  |  |  |  293|  1.71k|        fastdds_log_ss_tmp__ << msg;                                                                                   \
  |  |  |  |  294|  1.71k|        eprosima::fastdds::dds::Log::QueueLog(                                                                         \
  |  |  |  |  295|  1.71k|            fastdds_log_ss_tmp__.str(), eprosima::fastdds::dds::Log::Context{__FILE__, __LINE__, __func__, #cat},      \
  |  |  |  |  296|  1.71k|            eprosima::fastdds::dds::Log::Kind::Error);                                                                 \
  |  |  |  |  297|  1.71k|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (297:14): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  225|  1.71k|        return false;
  226|  1.71k|    }
  227|       |
  228|       |    // These types need one bound with the length of the field.
  229|   169k|    if (1 != bound_.size() && (
  ------------------
  |  Branch (229:9): [True: 46.8k, False: 122k]
  ------------------
  230|  46.8k|                TK_BITMASK == kind_   ||
  ------------------
  |  Branch (230:17): [True: 0, False: 46.8k]
  ------------------
  231|  46.8k|                TK_MAP == kind_       ||
  ------------------
  |  Branch (231:17): [True: 0, False: 46.8k]
  ------------------
  232|  46.8k|                TK_SEQUENCE == kind_  ||
  ------------------
  |  Branch (232:17): [True: 0, False: 46.8k]
  ------------------
  233|  46.8k|                TK_STRING8 == kind_   ||
  ------------------
  |  Branch (233:17): [True: 0, False: 46.8k]
  ------------------
  234|  46.8k|                TK_STRING16 == kind_  ))
  ------------------
  |  Branch (234:17): [True: 0, False: 46.8k]
  ------------------
  235|      0|    {
  236|      0|        EPROSIMA_LOG_ERROR(DYN_TYPES,
  ------------------
  |  |   45|      0|#define EPROSIMA_LOG_ERROR(cat, msg) EPROSIMA_LOG_ERROR_IMPL_(cat, msg)
  |  |  ------------------
  |  |  |  |  291|      0|    do {                                                                                                               \
  |  |  |  |  292|      0|        std::stringstream fastdds_log_ss_tmp__;                                                                        \
  |  |  |  |  293|      0|        fastdds_log_ss_tmp__ << msg;                                                                                   \
  |  |  |  |  294|      0|        eprosima::fastdds::dds::Log::QueueLog(                                                                         \
  |  |  |  |  295|      0|            fastdds_log_ss_tmp__.str(), eprosima::fastdds::dds::Log::Context{__FILE__, __LINE__, __func__, #cat},      \
  |  |  |  |  296|      0|            eprosima::fastdds::dds::Log::Kind::Error);                                                                 \
  |  |  |  |  297|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (297:14): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  237|      0|                "Descriptor describes an SEQUENCE|MAP|BITMASK|STRING but bound doesn't contain only one element");
  238|      0|        return false;
  239|      0|    }
  240|       |
  241|       |    // Check no bound is zero.
  242|   169k|    if (bound_.end() != std::find_if(bound_.begin(), bound_.end(),
  ------------------
  |  Branch (242:9): [True: 13.2k, False: 156k]
  ------------------
  243|   169k|            [](uint32_t bound)
  244|   169k|            {
  245|   169k|                return 0 == bound;
  246|   169k|            }))
  247|  13.2k|    {
  248|  13.2k|        EPROSIMA_LOG_ERROR(DYN_TYPES, "Bounds contains a zero and it is not a valid value.");
  ------------------
  |  |   45|  13.2k|#define EPROSIMA_LOG_ERROR(cat, msg) EPROSIMA_LOG_ERROR_IMPL_(cat, msg)
  |  |  ------------------
  |  |  |  |  291|  13.2k|    do {                                                                                                               \
  |  |  |  |  292|  13.2k|        std::stringstream fastdds_log_ss_tmp__;                                                                        \
  |  |  |  |  293|  13.2k|        fastdds_log_ss_tmp__ << msg;                                                                                   \
  |  |  |  |  294|  13.2k|        eprosima::fastdds::dds::Log::QueueLog(                                                                         \
  |  |  |  |  295|  13.2k|            fastdds_log_ss_tmp__.str(), eprosima::fastdds::dds::Log::Context{__FILE__, __LINE__, __func__, #cat},      \
  |  |  |  |  296|  13.2k|            eprosima::fastdds::dds::Log::Kind::Error);                                                                 \
  |  |  |  |  297|  13.2k|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (297:14): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  249|  13.2k|        return false;
  250|  13.2k|    }
  251|       |
  252|       |    // Bitmask bound must be greater than zero and no greater than 64.
  253|   156k|    if (TK_BITMASK == kind_ && (0 == bound_.at(0) || 64 < bound_.at(0)))
  ------------------
  |  Branch (253:9): [True: 7.02k, False: 149k]
  |  Branch (253:33): [True: 0, False: 7.02k]
  |  Branch (253:54): [True: 0, False: 7.02k]
  ------------------
  254|      0|    {
  255|      0|        EPROSIMA_LOG_ERROR(DYN_TYPES,
  ------------------
  |  |   45|      0|#define EPROSIMA_LOG_ERROR(cat, msg) EPROSIMA_LOG_ERROR_IMPL_(cat, msg)
  |  |  ------------------
  |  |  |  |  291|      0|    do {                                                                                                               \
  |  |  |  |  292|      0|        std::stringstream fastdds_log_ss_tmp__;                                                                        \
  |  |  |  |  293|      0|        fastdds_log_ss_tmp__ << msg;                                                                                   \
  |  |  |  |  294|      0|        eprosima::fastdds::dds::Log::QueueLog(                                                                         \
  |  |  |  |  295|      0|            fastdds_log_ss_tmp__.str(), eprosima::fastdds::dds::Log::Context{__FILE__, __LINE__, __func__, #cat},      \
  |  |  |  |  296|      0|            eprosima::fastdds::dds::Log::Kind::Error);                                                                 \
  |  |  |  |  297|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (297:14): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  256|      0|                "Descriptor describes an BITMASK but bound is not valid.");
  257|      0|        return false;
  258|      0|    }
  259|       |
  260|       |    // Only union types need the discriminator of the union
  261|   156k|    if (TK_UNION == kind_)
  ------------------
  |  Branch (261:9): [True: 0, False: 156k]
  ------------------
  262|      0|    {
  263|      0|        if (!discriminator_type_)
  ------------------
  |  Branch (263:13): [True: 0, False: 0]
  ------------------
  264|      0|        {
  265|      0|            EPROSIMA_LOG_ERROR(DYN_TYPES, "Descriptor describes an UNION but discriminant_type was not set");
  ------------------
  |  |   45|      0|#define EPROSIMA_LOG_ERROR(cat, msg) EPROSIMA_LOG_ERROR_IMPL_(cat, msg)
  |  |  ------------------
  |  |  |  |  291|      0|    do {                                                                                                               \
  |  |  |  |  292|      0|        std::stringstream fastdds_log_ss_tmp__;                                                                        \
  |  |  |  |  293|      0|        fastdds_log_ss_tmp__ << msg;                                                                                   \
  |  |  |  |  294|      0|        eprosima::fastdds::dds::Log::QueueLog(                                                                         \
  |  |  |  |  295|      0|            fastdds_log_ss_tmp__.str(), eprosima::fastdds::dds::Log::Context{__FILE__, __LINE__, __func__, #cat},      \
  |  |  |  |  296|      0|            eprosima::fastdds::dds::Log::Kind::Error);                                                                 \
  |  |  |  |  297|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (297:14): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  266|      0|            return false;
  267|      0|        }
  268|      0|        else
  269|      0|        {
  270|       |            // Check discriminator kind and the type is a integer (labels are int32_t).
  271|       |            // boolean, byte, char8, char16, int8, uint8, int16, uint16, int32, uint32, enum, alias
  272|      0|            TypeKind discriminator_kind =
  273|      0|                    traits<DynamicType>::narrow<DynamicTypeImpl>(discriminator_type_)->resolve_alias_enclosed_type()
  274|      0|                            ->get_kind();
  275|       |
  276|      0|            switch (discriminator_kind)
  277|      0|            {
  278|      0|                case TK_BOOLEAN:
  ------------------
  |  Branch (278:17): [True: 0, False: 0]
  ------------------
  279|      0|                case TK_BYTE:
  ------------------
  |  Branch (279:17): [True: 0, False: 0]
  ------------------
  280|      0|                case TK_CHAR8:
  ------------------
  |  Branch (280:17): [True: 0, False: 0]
  ------------------
  281|      0|                case TK_CHAR16:
  ------------------
  |  Branch (281:17): [True: 0, False: 0]
  ------------------
  282|      0|                case TK_INT8:
  ------------------
  |  Branch (282:17): [True: 0, False: 0]
  ------------------
  283|      0|                case TK_UINT8:
  ------------------
  |  Branch (283:17): [True: 0, False: 0]
  ------------------
  284|      0|                case TK_INT16:
  ------------------
  |  Branch (284:17): [True: 0, False: 0]
  ------------------
  285|      0|                case TK_UINT16:
  ------------------
  |  Branch (285:17): [True: 0, False: 0]
  ------------------
  286|      0|                case TK_INT32:
  ------------------
  |  Branch (286:17): [True: 0, False: 0]
  ------------------
  287|      0|                case TK_UINT32:
  ------------------
  |  Branch (287:17): [True: 0, False: 0]
  ------------------
  288|      0|                case TK_INT64:
  ------------------
  |  Branch (288:17): [True: 0, False: 0]
  ------------------
  289|      0|                case TK_UINT64:
  ------------------
  |  Branch (289:17): [True: 0, False: 0]
  ------------------
  290|      0|                case TK_ENUM:
  ------------------
  |  Branch (290:17): [True: 0, False: 0]
  ------------------
  291|      0|                    break;
  292|      0|                default:
  ------------------
  |  Branch (292:17): [True: 0, False: 0]
  ------------------
  293|      0|                    EPROSIMA_LOG_ERROR(DYN_TYPES, "Discriminantor kind was not valid");
  ------------------
  |  |   45|      0|#define EPROSIMA_LOG_ERROR(cat, msg) EPROSIMA_LOG_ERROR_IMPL_(cat, msg)
  |  |  ------------------
  |  |  |  |  291|      0|    do {                                                                                                               \
  |  |  |  |  292|      0|        std::stringstream fastdds_log_ss_tmp__;                                                                        \
  |  |  |  |  293|      0|        fastdds_log_ss_tmp__ << msg;                                                                                   \
  |  |  |  |  294|      0|        eprosima::fastdds::dds::Log::QueueLog(                                                                         \
  |  |  |  |  295|      0|            fastdds_log_ss_tmp__.str(), eprosima::fastdds::dds::Log::Context{__FILE__, __LINE__, __func__, #cat},      \
  |  |  |  |  296|      0|            eprosima::fastdds::dds::Log::Kind::Error);                                                                 \
  |  |  |  |  297|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (297:14): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  294|      0|                    return false;
  295|      0|                    break;
  296|      0|            }
  297|      0|        }
  298|      0|    }
  299|   156k|    else
  300|   156k|    {
  301|   156k|        if (discriminator_type_)
  ------------------
  |  Branch (301:13): [True: 0, False: 156k]
  ------------------
  302|      0|        {
  303|      0|            EPROSIMA_LOG_ERROR(DYN_TYPES, "Descriptor doesn't describe an UNION but discriminant_type was set");
  ------------------
  |  |   45|      0|#define EPROSIMA_LOG_ERROR(cat, msg) EPROSIMA_LOG_ERROR_IMPL_(cat, msg)
  |  |  ------------------
  |  |  |  |  291|      0|    do {                                                                                                               \
  |  |  |  |  292|      0|        std::stringstream fastdds_log_ss_tmp__;                                                                        \
  |  |  |  |  293|      0|        fastdds_log_ss_tmp__ << msg;                                                                                   \
  |  |  |  |  294|      0|        eprosima::fastdds::dds::Log::QueueLog(                                                                         \
  |  |  |  |  295|      0|            fastdds_log_ss_tmp__.str(), eprosima::fastdds::dds::Log::Context{__FILE__, __LINE__, __func__, #cat},      \
  |  |  |  |  296|      0|            eprosima::fastdds::dds::Log::Kind::Error);                                                                 \
  |  |  |  |  297|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (297:14): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  304|      0|            return false;
  305|      0|        }
  306|   156k|    }
  307|       |
  308|       |    // ElementType is used by these types to set the "value" type of the element, otherwise it should be null.
  309|   156k|    bool is_kind_with_element_type {
  310|   156k|        TK_ARRAY == kind_    ||
  ------------------
  |  Branch (310:9): [True: 49.3k, False: 106k]
  ------------------
  311|   156k|        TK_BITMASK == kind_  ||
  ------------------
  |  Branch (311:9): [True: 7.02k, False: 99.9k]
  ------------------
  312|   156k|        TK_MAP == kind_      ||
  ------------------
  |  Branch (312:9): [True: 14.3k, False: 85.6k]
  ------------------
  313|   156k|        TK_SEQUENCE == kind_ ||
  ------------------
  |  Branch (313:9): [True: 10.6k, False: 74.9k]
  ------------------
  314|   156k|        TK_STRING8 == kind_  ||
  ------------------
  |  Branch (314:9): [True: 23.1k, False: 51.8k]
  ------------------
  315|   156k|        TK_STRING16 == kind_ };
  ------------------
  |  Branch (315:9): [True: 9.69k, False: 42.1k]
  ------------------
  316|   156k|    if (!element_type_ && is_kind_with_element_type)
  ------------------
  |  Branch (316:9): [True: 42.1k, False: 114k]
  |  Branch (316:27): [True: 0, False: 42.1k]
  ------------------
  317|      0|    {
  318|      0|        EPROSIMA_LOG_ERROR(DYN_TYPES,
  ------------------
  |  |   45|      0|#define EPROSIMA_LOG_ERROR(cat, msg) EPROSIMA_LOG_ERROR_IMPL_(cat, msg)
  |  |  ------------------
  |  |  |  |  291|      0|    do {                                                                                                               \
  |  |  |  |  292|      0|        std::stringstream fastdds_log_ss_tmp__;                                                                        \
  |  |  |  |  293|      0|        fastdds_log_ss_tmp__ << msg;                                                                                   \
  |  |  |  |  294|      0|        eprosima::fastdds::dds::Log::QueueLog(                                                                         \
  |  |  |  |  295|      0|            fastdds_log_ss_tmp__.str(), eprosima::fastdds::dds::Log::Context{__FILE__, __LINE__, __func__, #cat},      \
  |  |  |  |  296|      0|            eprosima::fastdds::dds::Log::Kind::Error);                                                                 \
  |  |  |  |  297|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (297:14): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  319|      0|                "Descriptor describes an ARRAY|SEQUENCE|MAP|BITMASK|STRING but element_type was not set");
  320|      0|        return false;
  321|      0|    }
  322|   156k|    else if (element_type_ && !is_kind_with_element_type)
  ------------------
  |  Branch (322:14): [True: 114k, False: 42.1k]
  |  Branch (322:31): [True: 0, False: 114k]
  ------------------
  323|      0|    {
  324|      0|        EPROSIMA_LOG_ERROR(DYN_TYPES,
  ------------------
  |  |   45|      0|#define EPROSIMA_LOG_ERROR(cat, msg) EPROSIMA_LOG_ERROR_IMPL_(cat, msg)
  |  |  ------------------
  |  |  |  |  291|      0|    do {                                                                                                               \
  |  |  |  |  292|      0|        std::stringstream fastdds_log_ss_tmp__;                                                                        \
  |  |  |  |  293|      0|        fastdds_log_ss_tmp__ << msg;                                                                                   \
  |  |  |  |  294|      0|        eprosima::fastdds::dds::Log::QueueLog(                                                                         \
  |  |  |  |  295|      0|            fastdds_log_ss_tmp__.str(), eprosima::fastdds::dds::Log::Context{__FILE__, __LINE__, __func__, #cat},      \
  |  |  |  |  296|      0|            eprosima::fastdds::dds::Log::Kind::Error);                                                                 \
  |  |  |  |  297|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (297:14): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  325|      0|                "Descriptor not describes an ARRAY|SEQUENCE|MAP|BITMASK|STRING but element_type was set");
  326|      0|        return false;
  327|      0|    }
  328|   156k|    else if (element_type_)
  ------------------
  |  Branch (328:14): [True: 114k, False: 42.1k]
  ------------------
  329|   114k|    {
  330|   114k|        TypeKind element_kind =
  331|   114k|                traits<DynamicType>::narrow<DynamicTypeImpl>(element_type_)->resolve_alias_enclosed_type()
  332|   114k|                        ->get_kind();
  333|       |
  334|   114k|        if (TK_STRING8 == kind_ && TK_CHAR8 != element_kind)
  ------------------
  |  Branch (334:13): [True: 23.1k, False: 90.9k]
  |  Branch (334:36): [True: 0, False: 23.1k]
  ------------------
  335|      0|        {
  336|      0|            EPROSIMA_LOG_ERROR(DYN_TYPES, "Elemend type of a TK_STRING8 must be TK_CHAR8.");
  ------------------
  |  |   45|      0|#define EPROSIMA_LOG_ERROR(cat, msg) EPROSIMA_LOG_ERROR_IMPL_(cat, msg)
  |  |  ------------------
  |  |  |  |  291|      0|    do {                                                                                                               \
  |  |  |  |  292|      0|        std::stringstream fastdds_log_ss_tmp__;                                                                        \
  |  |  |  |  293|      0|        fastdds_log_ss_tmp__ << msg;                                                                                   \
  |  |  |  |  294|      0|        eprosima::fastdds::dds::Log::QueueLog(                                                                         \
  |  |  |  |  295|      0|            fastdds_log_ss_tmp__.str(), eprosima::fastdds::dds::Log::Context{__FILE__, __LINE__, __func__, #cat},      \
  |  |  |  |  296|      0|            eprosima::fastdds::dds::Log::Kind::Error);                                                                 \
  |  |  |  |  297|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (297:14): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  337|      0|            return false;
  338|      0|        }
  339|   114k|        else if (TK_STRING16 == kind_ && TK_CHAR16 != element_kind)
  ------------------
  |  Branch (339:18): [True: 9.69k, False: 104k]
  |  Branch (339:42): [True: 0, False: 9.69k]
  ------------------
  340|      0|        {
  341|      0|            EPROSIMA_LOG_ERROR(DYN_TYPES, "Elemend type of a TK_STRING16 must be TK_CHAR16.");
  ------------------
  |  |   45|      0|#define EPROSIMA_LOG_ERROR(cat, msg) EPROSIMA_LOG_ERROR_IMPL_(cat, msg)
  |  |  ------------------
  |  |  |  |  291|      0|    do {                                                                                                               \
  |  |  |  |  292|      0|        std::stringstream fastdds_log_ss_tmp__;                                                                        \
  |  |  |  |  293|      0|        fastdds_log_ss_tmp__ << msg;                                                                                   \
  |  |  |  |  294|      0|        eprosima::fastdds::dds::Log::QueueLog(                                                                         \
  |  |  |  |  295|      0|            fastdds_log_ss_tmp__.str(), eprosima::fastdds::dds::Log::Context{__FILE__, __LINE__, __func__, #cat},      \
  |  |  |  |  296|      0|            eprosima::fastdds::dds::Log::Kind::Error);                                                                 \
  |  |  |  |  297|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (297:14): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  342|      0|            return false;
  343|      0|        }
  344|   114k|    }
  345|       |
  346|       |    // For Bitmask types is mandatory that this element is boolean.
  347|   156k|    if (TK_BITMASK == kind_ && TK_BOOLEAN != element_type_->get_kind())
  ------------------
  |  Branch (347:9): [True: 7.02k, False: 149k]
  |  Branch (347:32): [True: 0, False: 7.02k]
  ------------------
  348|      0|    {
  349|      0|        EPROSIMA_LOG_ERROR(DYN_TYPES, "Descriptor describes a BITMASK but element_type is not of BOOLEAN type");
  ------------------
  |  |   45|      0|#define EPROSIMA_LOG_ERROR(cat, msg) EPROSIMA_LOG_ERROR_IMPL_(cat, msg)
  |  |  ------------------
  |  |  |  |  291|      0|    do {                                                                                                               \
  |  |  |  |  292|      0|        std::stringstream fastdds_log_ss_tmp__;                                                                        \
  |  |  |  |  293|      0|        fastdds_log_ss_tmp__ << msg;                                                                                   \
  |  |  |  |  294|      0|        eprosima::fastdds::dds::Log::QueueLog(                                                                         \
  |  |  |  |  295|      0|            fastdds_log_ss_tmp__.str(), eprosima::fastdds::dds::Log::Context{__FILE__, __LINE__, __func__, #cat},      \
  |  |  |  |  296|      0|            eprosima::fastdds::dds::Log::Kind::Error);                                                                 \
  |  |  |  |  297|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (297:14): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  350|      0|        return false;
  351|      0|    }
  352|       |
  353|       |    // Only map types need the keyElementType to store the "Key" type of the pair.
  354|   156k|    if (TK_MAP == kind_ && !key_element_type_)
  ------------------
  |  Branch (354:9): [True: 14.3k, False: 141k]
  |  Branch (354:28): [True: 0, False: 14.3k]
  ------------------
  355|      0|    {
  356|      0|        EPROSIMA_LOG_ERROR(DYN_TYPES, "Descriptor describes a MAP but key_element_type was not set");
  ------------------
  |  |   45|      0|#define EPROSIMA_LOG_ERROR(cat, msg) EPROSIMA_LOG_ERROR_IMPL_(cat, msg)
  |  |  ------------------
  |  |  |  |  291|      0|    do {                                                                                                               \
  |  |  |  |  292|      0|        std::stringstream fastdds_log_ss_tmp__;                                                                        \
  |  |  |  |  293|      0|        fastdds_log_ss_tmp__ << msg;                                                                                   \
  |  |  |  |  294|      0|        eprosima::fastdds::dds::Log::QueueLog(                                                                         \
  |  |  |  |  295|      0|            fastdds_log_ss_tmp__.str(), eprosima::fastdds::dds::Log::Context{__FILE__, __LINE__, __func__, #cat},      \
  |  |  |  |  296|      0|            eprosima::fastdds::dds::Log::Kind::Error);                                                                 \
  |  |  |  |  297|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (297:14): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  357|      0|        return false;
  358|      0|    }
  359|   156k|    else if (TK_MAP != kind_ && key_element_type_)
  ------------------
  |  Branch (359:14): [True: 141k, False: 14.3k]
  |  Branch (359:33): [True: 0, False: 141k]
  ------------------
  360|      0|    {
  361|      0|        EPROSIMA_LOG_ERROR(DYN_TYPES, "Descriptor doesn't describe a MAP but key_element_type was set");
  ------------------
  |  |   45|      0|#define EPROSIMA_LOG_ERROR(cat, msg) EPROSIMA_LOG_ERROR_IMPL_(cat, msg)
  |  |  ------------------
  |  |  |  |  291|      0|    do {                                                                                                               \
  |  |  |  |  292|      0|        std::stringstream fastdds_log_ss_tmp__;                                                                        \
  |  |  |  |  293|      0|        fastdds_log_ss_tmp__ << msg;                                                                                   \
  |  |  |  |  294|      0|        eprosima::fastdds::dds::Log::QueueLog(                                                                         \
  |  |  |  |  295|      0|            fastdds_log_ss_tmp__.str(), eprosima::fastdds::dds::Log::Context{__FILE__, __LINE__, __func__, #cat},      \
  |  |  |  |  296|      0|            eprosima::fastdds::dds::Log::Kind::Error);                                                                 \
  |  |  |  |  297|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (297:14): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  362|      0|        return false;
  363|      0|    }
  364|       |
  365|   156k|    if (TK_MAP == kind_ && (TK_ANNOTATION == key_element_type()->get_kind() ||
  ------------------
  |  Branch (365:9): [True: 14.3k, False: 141k]
  |  Branch (365:29): [True: 0, False: 14.3k]
  ------------------
  366|  14.3k|            TK_ARRAY == key_element_type()->get_kind() ||
  ------------------
  |  Branch (366:13): [True: 0, False: 14.3k]
  ------------------
  367|  14.3k|            TK_BITSET == key_element_type()->get_kind() ||
  ------------------
  |  Branch (367:13): [True: 0, False: 14.3k]
  ------------------
  368|  14.3k|            TK_BITMASK == key_element_type()->get_kind() ||
  ------------------
  |  Branch (368:13): [True: 264, False: 14.0k]
  ------------------
  369|  14.3k|            TK_MAP == key_element_type()->get_kind() ||
  ------------------
  |  Branch (369:13): [True: 0, False: 14.0k]
  ------------------
  370|  14.3k|            TK_SEQUENCE == key_element_type()->get_kind() ||
  ------------------
  |  Branch (370:13): [True: 0, False: 14.0k]
  ------------------
  371|  14.3k|            TK_STRING16 == key_element_type()->get_kind() ||
  ------------------
  |  Branch (371:13): [True: 191, False: 13.8k]
  ------------------
  372|  14.3k|            TK_STRUCTURE == key_element_type()->get_kind() ||
  ------------------
  |  Branch (372:13): [True: 1, False: 13.8k]
  ------------------
  373|  14.3k|            TK_UNION == key_element_type()->get_kind()
  ------------------
  |  Branch (373:13): [True: 0, False: 13.8k]
  ------------------
  374|  14.3k|            ))
  375|    456|    {
  376|    456|        EPROSIMA_LOG_ERROR(DYN_TYPES, "Descriptor describes a MAP with an invalid key_element_type");
  ------------------
  |  |   45|    456|#define EPROSIMA_LOG_ERROR(cat, msg) EPROSIMA_LOG_ERROR_IMPL_(cat, msg)
  |  |  ------------------
  |  |  |  |  291|    456|    do {                                                                                                               \
  |  |  |  |  292|    456|        std::stringstream fastdds_log_ss_tmp__;                                                                        \
  |  |  |  |  293|    456|        fastdds_log_ss_tmp__ << msg;                                                                                   \
  |  |  |  |  294|    456|        eprosima::fastdds::dds::Log::QueueLog(                                                                         \
  |  |  |  |  295|    456|            fastdds_log_ss_tmp__.str(), eprosima::fastdds::dds::Log::Context{__FILE__, __LINE__, __func__, #cat},      \
  |  |  |  |  296|    456|            eprosima::fastdds::dds::Log::Kind::Error);                                                                 \
  |  |  |  |  297|    456|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (297:14): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  377|    456|        return false;
  378|    456|    }
  379|       |
  380|   155k|    if (!is_type_name_consistent(name_))
  ------------------
  |  Branch (380:9): [True: 39.8k, False: 115k]
  ------------------
  381|  39.8k|    {
  382|  39.8k|        EPROSIMA_LOG_ERROR(DYN_TYPES, "Descriptor name is not a fully qualified name");
  ------------------
  |  |   45|  39.8k|#define EPROSIMA_LOG_ERROR(cat, msg) EPROSIMA_LOG_ERROR_IMPL_(cat, msg)
  |  |  ------------------
  |  |  |  |  291|  39.8k|    do {                                                                                                               \
  |  |  |  |  292|  39.8k|        std::stringstream fastdds_log_ss_tmp__;                                                                        \
  |  |  |  |  293|  39.8k|        fastdds_log_ss_tmp__ << msg;                                                                                   \
  |  |  |  |  294|  39.8k|        eprosima::fastdds::dds::Log::QueueLog(                                                                         \
  |  |  |  |  295|  39.8k|            fastdds_log_ss_tmp__.str(), eprosima::fastdds::dds::Log::Context{__FILE__, __LINE__, __func__, #cat},      \
  |  |  |  |  296|  39.8k|            eprosima::fastdds::dds::Log::Kind::Error);                                                                 \
  |  |  |  |  297|  39.8k|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (297:14): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  383|  39.8k|        return false;
  384|  39.8k|    }
  385|       |
  386|   115k|    return true;
  387|   155k|}
TypeDescriptorImpl.cpp:_ZZN8eprosima7fastdds3dds18TypeDescriptorImpl13is_consistentEvENK3$_0clEj:
  244|   134k|            {
  245|   134k|                return 0 == bound;
  246|   134k|            }))

_ZN8eprosima7fastdds3dds18TypeDescriptorImpl4kindEv:
   75|   840k|    {
   76|   840k|        return kind_;
   77|   840k|    }
_ZN8eprosima7fastdds3dds18TypeDescriptorImpl4kindEh:
   81|  51.0k|    {
   82|  51.0k|        kind_ = kind;
   83|  51.0k|    }
_ZN8eprosima7fastdds3dds18TypeDescriptorImpl4nameEONS_7fastcdr12fixed_stringILm256EEE:
  103|  51.0k|    {
  104|  51.0k|        name_ = std::move(name);
  105|  51.0k|    }
_ZNK8eprosima7fastdds3dds18TypeDescriptorImpl9base_typeEv:
  108|  1.41k|    {
  109|  1.41k|        return base_type_;
  110|  1.41k|    }
_ZN8eprosima7fastdds3dds18TypeDescriptorImpl9base_typeEv:
  113|    446|    {
  114|    446|        return base_type_;
  115|    446|    }
_ZN8eprosima7fastdds3dds18TypeDescriptorImpl9base_typeENSt3__110shared_ptrINS1_11DynamicTypeEEE:
  119|  32.1k|    {
  120|  32.1k|        base_type_ = type;
  121|  32.1k|    }
_ZN8eprosima7fastdds3dds18TypeDescriptorImpl5boundEv:
  145|   133k|    {
  146|   133k|        return bound_;
  147|   133k|    }
_ZN8eprosima7fastdds3dds18TypeDescriptorImpl12element_typeENSt3__110shared_ptrINS1_11DynamicTypeEEE:
  173|  73.9k|    {
  174|  73.9k|        element_type_ = type;
  175|  73.9k|    }
_ZN8eprosima7fastdds3dds18TypeDescriptorImpl16key_element_typeEv:
  183|   127k|    {
  184|   127k|        return key_element_type_;
  185|   127k|    }
_ZN8eprosima7fastdds3dds18TypeDescriptorImpl16key_element_typeENSt3__110shared_ptrINS1_11DynamicTypeEEE:
  189|  8.50k|    {
  190|  8.50k|        key_element_type_ = type;
  191|  8.50k|    }
_ZNK8eprosima7fastdds3dds18TypeDescriptorImpl18extensibility_kindEv:
  194|     18|    {
  195|     18|        return extensibility_kind_;
  196|     18|    }
_ZN8eprosima7fastdds3dds18TypeDescriptorImplC1Ev:
   55|   180k|    TypeDescriptorImpl() noexcept = default;
_ZN8eprosima7fastdds3dds18TypeDescriptorImplD2Ev:
   67|   248k|    virtual ~TypeDescriptorImpl() noexcept = default;

_ZN8eprosima7fastdds3dds6xtypes18TypeObjectRegistryC2Ev:
  607|      1|{
  608|      1|    register_primitive_type_identifiers();
  609|      1|}
_ZN8eprosima7fastdds3dds6xtypes18TypeObjectRegistry35register_primitive_type_identifiersEv:
 1373|      1|{
 1374|      1|    std::lock_guard<std::mutex> data_guard(type_object_registry_mutex_);
 1375|      1|    TypeIdentifierPair type_ids;
 1376|      1|    type_ids.type_identifier1()._d(TK_BOOLEAN);
 1377|      1|    local_type_identifiers_.insert({boolean_type_name, type_ids});
 1378|      1|    type_ids.type_identifier1()._d(TK_BYTE);
 1379|      1|    local_type_identifiers_.insert({byte_type_name, type_ids});
 1380|      1|    type_ids.type_identifier1()._d(TK_INT16);
 1381|      1|    local_type_identifiers_.insert({int16_type_name, type_ids});
 1382|      1|    type_ids.type_identifier1()._d(TK_INT32);
 1383|      1|    local_type_identifiers_.insert({int32_type_name, type_ids});
 1384|      1|    type_ids.type_identifier1()._d(TK_INT64);
 1385|      1|    local_type_identifiers_.insert({int64_type_name, type_ids});
 1386|      1|    type_ids.type_identifier1()._d(TK_UINT16);
 1387|      1|    local_type_identifiers_.insert({uint16_type_name, type_ids});
 1388|      1|    type_ids.type_identifier1()._d(TK_UINT32);
 1389|      1|    local_type_identifiers_.insert({uint32_type_name, type_ids});
 1390|      1|    type_ids.type_identifier1()._d(TK_UINT64);
 1391|      1|    local_type_identifiers_.insert({uint64_type_name, type_ids});
 1392|      1|    type_ids.type_identifier1()._d(TK_FLOAT32);
 1393|      1|    local_type_identifiers_.insert({float32_type_name, type_ids});
 1394|      1|    type_ids.type_identifier1()._d(TK_FLOAT64);
 1395|      1|    local_type_identifiers_.insert({float64_type_name, type_ids});
 1396|      1|    type_ids.type_identifier1()._d(TK_FLOAT128);
 1397|      1|    local_type_identifiers_.insert({float128_type_name, type_ids});
 1398|      1|    type_ids.type_identifier1()._d(TK_INT8);
 1399|      1|    local_type_identifiers_.insert({int8_type_name, type_ids});
 1400|      1|    type_ids.type_identifier1()._d(TK_UINT8);
 1401|      1|    local_type_identifiers_.insert({uint8_type_name, type_ids});
 1402|      1|    type_ids.type_identifier1()._d(TK_CHAR8);
 1403|      1|    local_type_identifiers_.insert({char8_type_name, type_ids});
 1404|      1|    type_ids.type_identifier1()._d(TK_CHAR16);
 1405|      1|    local_type_identifiers_.insert({char16_type_name, type_ids});
 1406|      1|}

_ZN8eprosima7fastdds4rtps14RTPSDomainImpl12get_instanceEv:
   99|      1|{
  100|      1|    static std::shared_ptr<RTPSDomainImpl> instance = std::make_shared<RTPSDomainImpl>();
  101|      1|    return instance;
  102|      1|}

_ZN8eprosima7fastdds4rtps19SerializedPayload_tD2Ev:
   51|   169k|{
   52|   169k|    if (payload_owner != nullptr)
  ------------------
  |  Branch (52:9): [True: 0, False: 169k]
  ------------------
   53|      0|    {
   54|      0|        payload_owner->release_payload(*this);
   55|      0|    }
   56|   169k|    this->empty();
   57|   169k|}
_ZN8eprosima7fastdds4rtps19SerializedPayload_t4copyEPKS2_b:
   70|    472|{
   71|    472|    length = serData->length;
   72|       |
   73|    472|    if (serData->length > max_size)
  ------------------
  |  Branch (73:9): [True: 0, False: 472]
  ------------------
   74|      0|    {
   75|      0|        if (with_limit)
  ------------------
  |  Branch (75:13): [True: 0, False: 0]
  ------------------
   76|      0|        {
   77|      0|            return false;
   78|      0|        }
   79|      0|        else
   80|      0|        {
   81|      0|            this->reserve(serData->length);
   82|      0|        }
   83|      0|    }
   84|    472|    encapsulation = serData->encapsulation;
   85|    472|    if (length == 0)
  ------------------
  |  Branch (85:9): [True: 472, False: 0]
  ------------------
   86|    472|    {
   87|    472|        return true;
   88|    472|    }
   89|      0|    memcpy(data, serData->data, length);
   90|      0|    return true;
   91|    472|}
_ZN8eprosima7fastdds4rtps19SerializedPayload_t5emptyEv:
  104|   169k|{
  105|   169k|    assert(payload_owner == nullptr);
  106|       |
  107|   169k|    length = 0;
  108|   169k|    encapsulation = CDR_BE;
  ------------------
  |  |   43|   169k|#define CDR_BE 0x0000
  ------------------
  109|   169k|    max_size = 0;
  110|   169k|    if (data != nullptr)
  ------------------
  |  Branch (110:9): [True: 0, False: 169k]
  ------------------
  111|      0|    {
  112|      0|        free(data);
  113|      0|    }
  114|   169k|    data = nullptr;
  115|   169k|}
_ZN8eprosima7fastdds4rtps19SerializedPayload_t7reserveEj:
  119|    472|{
  120|    472|    if (new_size <= this->max_size)
  ------------------
  |  Branch (120:9): [True: 472, False: 0]
  ------------------
  121|    472|    {
  122|    472|        return;
  123|    472|    }
  124|      0|    if (data == nullptr)
  ------------------
  |  Branch (124:9): [True: 0, False: 0]
  ------------------
  125|      0|    {
  126|      0|        data = (octet*)calloc(new_size, sizeof(octet));
  127|      0|        if (!data)
  ------------------
  |  Branch (127:13): [True: 0, False: 0]
  ------------------
  128|      0|        {
  129|      0|            throw std::bad_alloc();
  130|      0|        }
  131|      0|    }
  132|      0|    else
  133|      0|    {
  134|      0|        void* old_data = data;
  135|      0|        data = (octet*)realloc(data, new_size);
  136|      0|        if (!data)
  ------------------
  |  Branch (136:13): [True: 0, False: 0]
  ------------------
  137|      0|        {
  138|      0|            free(old_data);
  139|      0|            throw std::bad_alloc();
  140|      0|        }
  141|      0|        memset(data + max_size, 0, (new_size - max_size) * sizeof(octet));
  142|      0|    }
  143|      0|    max_size = new_size;
  144|      0|}

_ZN8eprosima7fastdds4rtps6Time_tC2Eij:
   32|    998|{
   33|    998|    seconds_ = sec;
   34|    998|    set_fraction(frac);
   35|    998|}
_ZN8eprosima7fastdds4rtps6Time_t12set_fractionEj:
  153|    998|{
  154|    998|    fraction_ = frac;
  155|    998|    nanosec_ = (fraction_ == 0xffffffff)
  ------------------
  |  Branch (155:16): [True: 666, False: 332]
  ------------------
  156|    998|        ? 0xffffffff
  157|    998|        : frac_to_nano(fraction_);
  158|    998|}

_ZN8eprosima7fastdds4rtps24TopicPayloadPoolRegistry8instanceEv:
   32|      1|{
   33|      1|    return detail::TopicPayloadPoolRegistry::instance();
   34|      1|}

_ZN8eprosima7fastdds4rtps6detail24TopicPayloadPoolRegistry8instanceEv:
   42|      1|    {
   43|      1|        static std::shared_ptr<TopicPayloadPoolRegistry> pool_registry_instance(new TopicPayloadPoolRegistry());
   44|      1|        return pool_registry_instance;
   45|      1|    }
_ZN8eprosima7fastdds4rtps6detail24TopicPayloadPoolRegistryC2Ev:
   36|      1|    TopicPayloadPoolRegistry() = default;

_ZN8eprosima7fastdds10statistics3dds13DataWriterQosC2Ev:
   29|      4|{
   30|       |    // Specific implementation for recommended statistics DataWriterQos
   31|      4|    reliability().kind = eprosima::fastdds::dds::RELIABLE_RELIABILITY_QOS;
   32|      4|    durability().kind = eprosima::fastdds::dds::TRANSIENT_LOCAL_DURABILITY_QOS;
   33|      4|    publish_mode().kind = eprosima::fastdds::dds::ASYNCHRONOUS_PUBLISH_MODE;
   34|      4|    publish_mode().flow_controller_name = eprosima::fastdds::rtps::FASTDDS_STATISTICS_FLOW_CONTROLLER_DEFAULT;
   35|      4|    history().kind = eprosima::fastdds::dds::KEEP_LAST_HISTORY_QOS;
   36|      4|    history().depth = 10;
   37|      4|    properties().properties().emplace_back("fastdds.push_mode", "false");
   38|      4|}

_ZNK8eprosima7fastdds7DBQueueINS0_3dds3Log5EntryEE5EmptyEv:
  110|  1.32M|    {
  111|  1.32M|        std::unique_lock<std::mutex> guard(mForegroundMutex);
  112|  1.32M|        return mForegroundQueue->empty();
  113|  1.32M|    }
_ZN8eprosima7fastdds7DBQueueINS0_3dds3Log5EntryEE4SwapEv:
   43|     12|    {
   44|     12|        std::unique_lock<std::mutex> fgGuard(mForegroundMutex);
   45|     12|        std::unique_lock<std::mutex> bgGuard(mBackgroundMutex);
   46|       |
   47|       |        // Clear the foreground queue.
   48|     12|        std::queue<T>().swap(*mForegroundQueue);
   49|       |
   50|     12|        auto* swap       = mBackgroundQueue;
   51|     12|        mBackgroundQueue = mForegroundQueue;
   52|     12|        mForegroundQueue = swap;
   53|     12|    }
_ZN8eprosima7fastdds7DBQueueINS0_3dds3Log5EntryEE5FrontEv:
   74|  1.32M|    {
   75|  1.32M|        std::unique_lock<std::mutex> guard(mForegroundMutex);
   76|  1.32M|        return mForegroundQueue->front();
   77|  1.32M|    }
_ZN8eprosima7fastdds7DBQueueINS0_3dds3Log5EntryEE3PopEv:
   87|  1.32M|    {
   88|  1.32M|        std::unique_lock<std::mutex> guard(mForegroundMutex);
   89|  1.32M|        mForegroundQueue->pop();
   90|  1.32M|    }
_ZN8eprosima7fastdds7DBQueueINS0_3dds3Log5EntryEE4PushEOS4_:
   66|  1.32M|    {
   67|  1.32M|        std::unique_lock<std::mutex> guard(mBackgroundMutex);
   68|  1.32M|        mBackgroundQueue->push(std::move(item));
   69|  1.32M|    }
_ZN8eprosima7fastdds7DBQueueINS0_3dds3Log5EntryEEC2Ev:
   36|      1|        : mForegroundQueue(&mQueueAlpha)
   37|      1|        , mBackgroundQueue(&mQueueBeta)
   38|      1|    {
   39|      1|    }

_ZN8eprosima10SystemInfo7get_envERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEERS7_:
   65|   263k|{
   66|   263k|    if (env_name.empty())
  ------------------
  |  Branch (66:9): [True: 0, False: 263k]
  ------------------
   67|      0|    {
   68|      0|        return fastdds::dds::RETCODE_BAD_PARAMETER;
   69|      0|    }
   70|       |
   71|       |    // Try to read environment variable from file
   72|   263k|    if (!environment_file_.empty() && fastdds::dds::RETCODE_OK == get_env(environment_file_, env_name, env_value))
  ------------------
  |  Branch (72:9): [True: 0, False: 263k]
  |  Branch (72:39): [True: 0, False: 0]
  ------------------
   73|      0|    {
   74|      0|        return fastdds::dds::RETCODE_OK;
   75|      0|    }
   76|       |
   77|   263k|    char* data;
   78|   263k|#pragma warning(suppress:4996)
   79|   263k|    data = getenv(env_name.c_str());
   80|   263k|    if (nullptr != data)
  ------------------
  |  Branch (80:9): [True: 0, False: 263k]
  ------------------
   81|      0|    {
   82|      0|        env_value = data;
   83|      0|    }
   84|   263k|    else
   85|   263k|    {
   86|   263k|        return fastdds::dds::RETCODE_NO_DATA;
   87|   263k|    }
   88|       |
   89|      0|    return fastdds::dds::RETCODE_OK;
   90|   263k|}
_ZN8eprosima10SystemInfo13get_timestampEPKc:
  269|  1.32M|{
  270|  1.32M|    std::stringstream stream;
  271|  1.32M|    auto now = std::chrono::system_clock::now();
  272|  1.32M|    std::time_t now_c = std::chrono::system_clock::to_time_t(now);
  273|  1.32M|    std::chrono::system_clock::duration tp = now.time_since_epoch();
  274|  1.32M|    tp -= std::chrono::duration_cast<std::chrono::seconds>(tp);
  275|  1.32M|    auto ms = static_cast<unsigned>(tp / std::chrono::milliseconds(1));
  276|       |
  277|       |#if defined(_WIN32)
  278|       |    struct tm timeinfo;
  279|       |    localtime_s(&timeinfo, &now_c);
  280|       |    //#elif defined(__clang__) && !defined(std::put_time) // TODO arm64 doesn't seem to support std::put_time
  281|       |    //    (void)now_c;
  282|       |    //    (void)ms;
  283|       |#elif (_POSIX_C_SOURCE >= 1) || defined(_XOPEN_SOURCE) || defined(_BSD_SOURCE) || defined(_SVID_SOURCE) || \
  284|       |    defined(_POSIX_SOURCE) || defined(__unix__)
  285|       |    std::tm timeinfo;
  286|  1.32M|    localtime_r(&now_c, &timeinfo);
  287|       |#else
  288|       |    std::tm timeinfo = *localtime(&now_c);
  289|       |#endif // if defined(_WIN32)
  290|  1.32M|    stream << std::put_time(&timeinfo, format) << "." << std::setw(3) << std::setfill('0') << ms;
  291|  1.32M|    return stream.str();
  292|  1.32M|}

_ZN8eprosima7fastdds3dds5utils12to_uppercaseERNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEE:
   39|  19.2k|{
   40|       |    // These lambda has been taken from the notes in https://en.cppreference.com/w/cpp/string/byte/toupper
   41|       |    // Note how the argument passed is unsigned char to avoid undefined behavior
   42|  19.2k|    auto my_toupper = [](unsigned char c)
   43|  19.2k|            {
   44|  19.2k|                return static_cast<char>(std::toupper(c));
   45|  19.2k|            };
   46|  19.2k|    std::transform(st.begin(), st.end(), st.begin(), my_toupper);
   47|  19.2k|}
_ZN8eprosima7fastdds3dds5utils21parse_value_and_unitsERNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEES9_:
   52|  20.4k|{
   53|  20.4k|    static const std::map<std::string, std::uint32_t> magnitudes = {
   54|  20.4k|        {"", 1},
   55|  20.4k|        {"B", 1},
   56|  20.4k|        {"KB", 1000},
   57|  20.4k|        {"MB", 1000 * 1000},
   58|  20.4k|        {"GB", 1000 * 1000 * 1000},
   59|  20.4k|        {"KIB", 1024},
   60|  20.4k|        {"MIB", 1024 * 1024},
   61|  20.4k|        {"GIB", 1024 * 1024 * 1024},
   62|  20.4k|    };
   63|       |
   64|  20.4k|    uint64_t num = 0;
   65|  20.4k|    try
   66|  20.4k|    {
   67|  20.4k|        num = std::stoull(value);
   68|  20.4k|    }
   69|  20.4k|    catch (std::out_of_range&)
   70|  20.4k|    {
   71|  1.22k|        throw std::invalid_argument("Failed to parse value from string." \
   72|  1.22k|                      " The number is too large to be converted to bytes (Max: (2^32)-1 Bytes).");
   73|  1.22k|    }
   74|       |
   75|  19.2k|    to_uppercase(units);
   76|       |
   77|  19.2k|    uint32_t magnitude = 0;
   78|  19.2k|    try
   79|  19.2k|    {
   80|  19.2k|        magnitude = magnitudes.at(units);
   81|  19.2k|    }
   82|  19.2k|    catch (std::out_of_range&)
   83|  19.2k|    {
   84|  10.0k|        throw std::invalid_argument(
   85|  10.0k|                  "The units are not in the expected format. Use: {B, KB, MG, GB, KIB, MIB, GIB}.");
   86|  10.0k|    }
   87|       |
   88|       |    // Check whether the product of number * magnitude overflows
   89|  9.16k|    if (num > std::numeric_limits<std::uint32_t>::max() / magnitude)
  ------------------
  |  Branch (89:9): [True: 3.40k, False: 5.76k]
  ------------------
   90|  3.40k|    {
   91|  3.40k|        throw std::invalid_argument("The number is too large to be converted to bytes (Max: (2^32)-1 Bytes).");
   92|  3.40k|    }
   93|       |
   94|       |    // The explicit cast to uint32_t is safe since the number has already been checked to fit.
   95|       |    // The product is also safe since the possible overflow has also been checked.
   96|  5.76k|    const std::uint32_t bytes = static_cast<std::uint32_t>(num) * magnitude;
   97|       |
   98|  5.76k|    return bytes;
   99|  9.16k|}
UnitsParser.cpp:_ZZN8eprosima7fastdds3dds5utils12to_uppercaseERNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEENK3$_0clEh:
   43|  7.51M|            {
   44|  7.51M|                return static_cast<char>(std::toupper(c));
   45|  7.51M|            };

_ZN8eprosima6detail19BoostAtExitRegistry12get_instanceEv:
   34|      1|    {
   35|       |        // Note we need a custom deleter, since the destructor is private.
   36|      1|        static std::shared_ptr<BoostAtExitRegistry> instance(
   37|      1|            new BoostAtExitRegistry(),
   38|      1|            [](BoostAtExitRegistry* p)
   39|      1|            {
   40|      1|                delete p;
   41|      1|            });
   42|      1|        return instance;
   43|      1|    }
_ZN8eprosima6detail19BoostAtExitRegistryD2Ev:
   63|      1|    {
   64|       |        // Execute the registered functions in reverse order.
   65|      1|        std::unique_lock<std::mutex> lock(mtx_);
   66|      1|        while (!registered_functions_.empty())
  ------------------
  |  Branch (66:16): [True: 0, False: 1]
  ------------------
   67|      0|        {
   68|       |            // Pop one function
   69|      0|            auto f = registered_functions_.back();
   70|      0|            registered_functions_.pop_back();
   71|       |
   72|       |            // Execute function with the mutex released, to allow registering another function in the mean time.
   73|      0|            lock.unlock();
   74|      0|            f();
   75|      0|            lock.lock();
   76|      0|        }
   77|      1|    }
_ZZN8eprosima6detail19BoostAtExitRegistry12get_instanceEvENKUlPS1_E_clES2_:
   39|      1|            {
   40|      1|                delete p;
   41|      1|            });

XMLElementParser.cpp:_ZL22get_element_enum_valueIN8eprosima7fastdds4rtps11TopicKind_tEJPKcS3_EEbS5_RT_S5_S6_DpT0_:
   41|  1.71k|{
   42|  1.71k|    if (0 == strcmp(input, name))
  ------------------
  |  Branch (42:9): [True: 108, False: 1.60k]
  ------------------
   43|    108|    {
   44|    108|        output = value;
   45|    108|        return true;
   46|    108|    }
   47|       |
   48|  1.60k|    return get_element_enum_value(input, output, args ...);
   49|  1.71k|}
XMLElementParser.cpp:_ZL22get_element_enum_valueIN8eprosima7fastdds4rtps11TopicKind_tEEbPKcRT_S5_S6_:
   24|  1.60k|{
   25|  1.60k|    if (0 == strcmp(input, name))
  ------------------
  |  Branch (25:9): [True: 812, False: 794]
  ------------------
   26|    812|    {
   27|    812|        output = value;
   28|    812|        return true;
   29|    812|    }
   30|       |
   31|    794|    return false;
   32|  1.60k|}
XMLElementParser.cpp:_ZL22get_element_enum_valueIN8eprosima7fastdds3dds20HistoryQosPolicyKindEJPKcS3_EEbS5_RT_S5_S6_DpT0_:
   41|    760|{
   42|    760|    if (0 == strcmp(input, name))
  ------------------
  |  Branch (42:9): [True: 316, False: 444]
  ------------------
   43|    316|    {
   44|    316|        output = value;
   45|    316|        return true;
   46|    316|    }
   47|       |
   48|    444|    return get_element_enum_value(input, output, args ...);
   49|    760|}
XMLElementParser.cpp:_ZL22get_element_enum_valueIN8eprosima7fastdds3dds20HistoryQosPolicyKindEEbPKcRT_S5_S6_:
   24|    444|{
   25|    444|    if (0 == strcmp(input, name))
  ------------------
  |  Branch (25:9): [True: 37, False: 407]
  ------------------
   26|     37|    {
   27|     37|        output = value;
   28|     37|        return true;
   29|     37|    }
   30|       |
   31|    407|    return false;
   32|    444|}
XMLElementParser.cpp:_ZL22get_element_enum_valueIN8eprosima7fastdds3dds24ReliabilityQosPolicyKindEJPKcS3_EEbS5_RT_S5_S6_DpT0_:
   41|  4.22k|{
   42|  4.22k|    if (0 == strcmp(input, name))
  ------------------
  |  Branch (42:9): [True: 951, False: 3.27k]
  ------------------
   43|    951|    {
   44|    951|        output = value;
   45|    951|        return true;
   46|    951|    }
   47|       |
   48|  3.27k|    return get_element_enum_value(input, output, args ...);
   49|  4.22k|}
XMLElementParser.cpp:_ZL22get_element_enum_valueIN8eprosima7fastdds3dds24ReliabilityQosPolicyKindEEbPKcRT_S5_S6_:
   24|  3.27k|{
   25|  3.27k|    if (0 == strcmp(input, name))
  ------------------
  |  Branch (25:9): [True: 192, False: 3.08k]
  ------------------
   26|    192|    {
   27|    192|        output = value;
   28|    192|        return true;
   29|    192|    }
   30|       |
   31|  3.08k|    return false;
   32|  3.27k|}
XMLElementParser.cpp:_ZL22get_element_enum_valueIN8eprosima7fastdds4rtps22MemoryManagementPolicyEJPKcS3_S5_S3_S5_S3_EEbS5_RT_S5_S6_DpT0_:
   41|  2.76k|{
   42|  2.76k|    if (0 == strcmp(input, name))
  ------------------
  |  Branch (42:9): [True: 39, False: 2.72k]
  ------------------
   43|     39|    {
   44|     39|        output = value;
   45|     39|        return true;
   46|     39|    }
   47|       |
   48|  2.72k|    return get_element_enum_value(input, output, args ...);
   49|  2.76k|}
XMLElementParser.cpp:_ZL22get_element_enum_valueIN8eprosima7fastdds4rtps22MemoryManagementPolicyEJPKcS3_S5_S3_EEbS5_RT_S5_S6_DpT0_:
   41|  2.72k|{
   42|  2.72k|    if (0 == strcmp(input, name))
  ------------------
  |  Branch (42:9): [True: 126, False: 2.59k]
  ------------------
   43|    126|    {
   44|    126|        output = value;
   45|    126|        return true;
   46|    126|    }
   47|       |
   48|  2.59k|    return get_element_enum_value(input, output, args ...);
   49|  2.72k|}
XMLElementParser.cpp:_ZL22get_element_enum_valueIN8eprosima7fastdds4rtps22MemoryManagementPolicyEJPKcS3_EEbS5_RT_S5_S6_DpT0_:
   41|  2.59k|{
   42|  2.59k|    if (0 == strcmp(input, name))
  ------------------
  |  Branch (42:9): [True: 1.05k, False: 1.54k]
  ------------------
   43|  1.05k|    {
   44|  1.05k|        output = value;
   45|  1.05k|        return true;
   46|  1.05k|    }
   47|       |
   48|  1.54k|    return get_element_enum_value(input, output, args ...);
   49|  2.59k|}
XMLElementParser.cpp:_ZL22get_element_enum_valueIN8eprosima7fastdds4rtps22MemoryManagementPolicyEEbPKcRT_S5_S6_:
   24|  1.54k|{
   25|  1.54k|    if (0 == strcmp(input, name))
  ------------------
  |  Branch (25:9): [True: 355, False: 1.18k]
  ------------------
   26|    355|    {
   27|    355|        output = value;
   28|    355|        return true;
   29|    355|    }
   30|       |
   31|  1.18k|    return false;
   32|  1.54k|}

_ZN8eprosima6threadC2Ev:
   74|      1|        : thread_hnd_(native_handle_type())
   75|      1|    {
   76|      1|    }
_ZN8eprosima6threadD2Ev:
   98|      2|    {
   99|      2|        if (joinable())
  ------------------
  |  Branch (99:13): [True: 0, False: 2]
  ------------------
  100|      0|        {
  101|      0|            std::terminate();
  102|      0|        }
  103|      2|    }
_ZN8eprosima6threadaSEOS0_:
  119|      1|    {
  120|      1|        if (joinable())
  ------------------
  |  Branch (120:13): [True: 0, False: 1]
  ------------------
  121|      0|        {
  122|      0|            std::terminate();
  123|      0|        }
  124|      1|        thread_hnd_ = native_handle_type();
  125|      1|        swap(other);
  126|      1|        return *this;
  127|      1|    }
_ZN8eprosima6thread4swapERS0_:
  131|      1|    {
  132|      1|        std::swap(thread_hnd_, other.thread_hnd_);
  133|      1|    }
_ZNK8eprosima6thread8joinableEv:
  136|      8|    {
  137|      8|        return thread_hnd_ != native_handle_type();
  138|      8|    }
_ZNK8eprosima6thread6get_idEv:
  141|      2|    {
  142|      2|        return get_thread_id_impl(thread_hnd_);
  143|      2|    }
_ZN8eprosima6thread4joinEv:
  156|      1|    {
  157|      1|        if (!joinable())
  ------------------
  |  Branch (157:13): [True: 0, False: 1]
  ------------------
  158|      0|        {
  159|      0|            throw std::system_error(std::make_error_code(std::errc::invalid_argument));
  160|      0|        }
  161|       |
  162|      1|        if (is_calling_thread())
  ------------------
  |  Branch (162:13): [True: 0, False: 1]
  ------------------
  163|      0|        {
  164|      0|            throw std::system_error(std::make_error_code(std::errc::resource_deadlock_would_occur));
  165|      0|        }
  166|       |
  167|      1|        join_thread_impl(thread_hnd_);
  168|      1|        thread_hnd_ = native_handle_type();
  169|      1|    }
_ZNK8eprosima6thread17is_calling_threadEv:
  178|      2|    {
  179|      2|        return get_id() == get_current_thread_id_impl();
  180|      2|    }
_ZN8eprosima6threadC2IZNS_13create_threadIZNS_7fastdds3dds6detail12LogResources11StartThreadEvEUlvE_JEEES0_T_RKNS3_4rtps14ThreadSettingsEPKcDpT0_EUlvE_EEiOS8_:
   82|      1|    {
   83|       |        // Prepare trampoline to pass to ThreadProxy
   84|      1|        using CalleeType = typename std::decay<_Fn>::type;
   85|      1|        std::unique_ptr<CalleeType> callee(new CalleeType(std::forward<_Fn>(f)));
   86|       |
   87|       |        // Start thread
   88|      1|        thread_hnd_ = start_thread_impl(stack_size, ThreadProxy<CalleeType>, callee.get());
   89|      1|        if (thread_hnd_ != native_handle_type())
  ------------------
  |  Branch (89:13): [True: 1, False: 0]
  ------------------
   90|      1|        {
   91|       |            // Thread has been correctly created. Since the ThreadProxy will
   92|       |            // take ownership of the trampoline, we need to release ownership here
   93|      1|            callee.release();
   94|      1|        }
   95|      1|    }
_ZN8eprosima6thread11ThreadProxyIZNS_13create_threadIZNS_7fastdds3dds6detail12LogResources11StartThreadEvEUlvE_JEEES0_T_RKNS3_4rtps14ThreadSettingsEPKcDpT0_EUlvE_EEPvSI_:
   52|      1|    {
   53|       |        // Take ownership of the trampoline
   54|      1|        std::unique_ptr<CalleeType> Callee(static_cast<CalleeType*>(Ptr));
   55|       |        // Call the trampoline
   56|      1|        (*Callee)();
   57|       |        // Finish thread
   58|      1|        return nullptr;
   59|      1|    }

_ZN8eprosima6thread17start_thread_implEiPFPvS1_ES1_:
   25|      1|{
   26|      1|    int errnum;
   27|       |
   28|       |    // Construct the attributes object.
   29|      1|    pthread_attr_t attr;
   30|      1|    if ((errnum = ::pthread_attr_init(&attr)) != 0)
  ------------------
  |  Branch (30:9): [True: 0, False: 1]
  ------------------
   31|      0|    {
   32|      0|        throw std::system_error(errnum, std::system_category(), "pthread_attr_init failed");
   33|      0|    }
   34|       |
   35|       |    // Ensure the attributes object is destroyed
   36|      1|    auto attr_deleter = [](pthread_attr_t* a)
   37|      1|            {
   38|      1|                int err;
   39|      1|                if ((err = ::pthread_attr_destroy(a)) != 0)
   40|      1|                {
   41|      1|                    throw std::system_error(err, std::system_category(), "pthread_attr_destroy failed");
   42|      1|                }
   43|      1|            };
   44|      1|    std::unique_ptr<pthread_attr_t, decltype(attr_deleter)> attr_scope_destroy(&attr, attr_deleter);
   45|       |
   46|       |    // Set the requested stack size, if given.
   47|      1|    if (stack_size >= 0)
  ------------------
  |  Branch (47:9): [True: 0, False: 1]
  ------------------
   48|      0|    {
   49|      0|        if (sizeof(unsigned) <= sizeof(int32_t) &&
  ------------------
  |  Branch (49:13): [Folded - Ignored]
  ------------------
   50|      0|                stack_size > static_cast<int32_t>(std::numeric_limits<unsigned>::max() / 2))
  ------------------
  |  Branch (50:17): [True: 0, False: 0]
  ------------------
   51|      0|        {
   52|      0|            throw std::invalid_argument("Cannot cast stack_size into unsigned");
   53|      0|        }
   54|       |
   55|      0|        if ((errnum = ::pthread_attr_setstacksize(&attr, stack_size)) != 0)
  ------------------
  |  Branch (55:13): [True: 0, False: 0]
  ------------------
   56|      0|        {
   57|      0|            throw std::system_error(errnum, std::system_category(), "pthread_attr_setstacksize failed");
   58|      0|        }
   59|      0|    }
   60|       |
   61|       |    // Construct and execute the thread.
   62|      1|    pthread_t hnd;
   63|      1|    if ((errnum = ::pthread_create(&hnd, &attr, start, arg)) != 0)
  ------------------
  |  Branch (63:9): [True: 0, False: 1]
  ------------------
   64|      0|    {
   65|      0|        throw std::system_error(errnum, std::system_category(), "pthread_create failed");
   66|      0|    }
   67|       |
   68|      1|    return hnd;
   69|      1|}
_ZN8eprosima6thread18get_thread_id_implEm:
   73|      2|{
   74|      2|    return hnd;
   75|      2|}
_ZN8eprosima6thread16join_thread_implEm:
   79|      1|{
   80|      1|    int errnum;
   81|      1|    if ((errnum = ::pthread_join(hnd, nullptr)) != 0)
  ------------------
  |  Branch (81:9): [True: 0, False: 1]
  ------------------
   82|      0|    {
   83|      0|        throw std::system_error(std::make_error_code(std::errc::no_such_process), "pthread_join failed");
   84|      0|    }
   85|      1|}
_ZN8eprosima6thread26get_current_thread_id_implEv:
   99|      2|{
  100|      2|    return ::pthread_self();
  101|      2|}
SystemInfo.cpp:_ZZN8eprosima6thread17start_thread_implEiPFPvS1_ES1_ENK3$_0clEP14pthread_attr_t:
   37|      1|            {
   38|      1|                int err;
   39|      1|                if ((err = ::pthread_attr_destroy(a)) != 0)
  ------------------
  |  Branch (39:21): [True: 0, False: 1]
  ------------------
   40|      0|                {
   41|      0|                    throw std::system_error(err, std::system_category(), "pthread_attr_destroy failed");
   42|      0|                }
   43|      1|            };

_ZN8eprosima13create_threadIZNS_7fastdds3dds6detail12LogResources11StartThreadEvEUlvE_JEEENS_6threadET_RKNS1_4rtps14ThreadSettingsEPKcDpT0_:
  103|      1|{
  104|      1|    return eprosima::thread(settings.stack_size, [=]()
  105|      1|                   {
  106|      1|                       std::array<char, 16> thread_name_buffer;
  107|      1|                       set_name_to_current_thread(thread_name_buffer, name, args ...);
  108|      1|                       apply_thread_settings_to_current_thread(thread_name_buffer.data(), settings);
  109|      1|                       func();
  110|      1|                   });
  111|      1|}
_ZZN8eprosima13create_threadIZNS_7fastdds3dds6detail12LogResources11StartThreadEvEUlvE_JEEENS_6threadET_RKNS1_4rtps14ThreadSettingsEPKcDpT0_ENKUlvE_clEv:
  105|      1|                   {
  106|      1|                       std::array<char, 16> thread_name_buffer;
  107|      1|                       set_name_to_current_thread(thread_name_buffer, name, args ...);
  108|      1|                       apply_thread_settings_to_current_thread(thread_name_buffer.data(), settings);
  109|      1|                       func();
  110|      1|                   });

_ZN8eprosima26set_name_to_current_threadERNSt3__15arrayIcLm16EEEPKc:
   54|      1|{
   55|      1|    set_name_to_current_thread_impl(thread_name_buffer, "%s", name);
   56|      1|}
_ZN8eprosima39apply_thread_settings_to_current_threadEPKcRKNS_7fastdds4rtps14ThreadSettingsE:
  204|      1|{
  205|      1|    configure_current_thread_scheduler(thread_name, settings.scheduling_policy, settings.priority);
  206|      1|    configure_current_thread_affinity(thread_name, settings.affinity);
  207|      1|}
SystemInfo.cpp:_ZN8eprosimaL34configure_current_thread_schedulerEPKcii:
   79|      1|{
   80|      1|    pthread_t self_tid = pthread_self();
   81|      1|    sched_param param;
   82|      1|    sched_param current_param;
   83|      1|    int current_class;
   84|      1|    int result = 0;
   85|      1|    bool change_priority = (std::numeric_limits<int32_t>::min() != sched_priority);
   86|       |
   87|       |    // Get current scheduling parameters
   88|      1|    memset(&current_param, 0, sizeof(current_param));
   89|      1|    pthread_getschedparam(self_tid, &current_class, &current_param);
   90|       |
   91|      1|    memset(&param, 0, sizeof(param));
   92|      1|    param.sched_priority = 0;
   93|      1|    sched_class = (sched_class == -1) ? current_class : sched_class;
  ------------------
  |  Branch (93:19): [True: 1, False: 0]
  ------------------
   94|       |
   95|       |    //
   96|       |    // Set Scheduler Class and Priority
   97|       |    //
   98|       |
   99|      1|    if ((sched_class == SCHED_OTHER) ||
  ------------------
  |  Branch (99:9): [True: 1, False: 0]
  ------------------
  100|      1|            (sched_class == SCHED_BATCH) ||
  ------------------
  |  Branch (100:13): [True: 0, False: 0]
  ------------------
  101|      1|            (sched_class == SCHED_IDLE))
  ------------------
  |  Branch (101:13): [True: 0, False: 0]
  ------------------
  102|      1|    {
  103|       |        //
  104|       |        // BATCH and IDLE do not have explicit priority values.
  105|       |        // - Requires priorty value to be zero (0).
  106|       |
  107|      1|        result = pthread_setschedparam(self_tid, sched_class, &param);
  108|       |
  109|       |        //
  110|       |        // Sched OTHER has a nice value, that we pull from the priority parameter.
  111|       |        //
  112|       |
  113|      1|        if (0 == result && sched_class == SCHED_OTHER && change_priority)
  ------------------
  |  Branch (113:13): [True: 1, False: 0]
  |  Branch (113:28): [True: 1, False: 0]
  |  Branch (113:58): [True: 0, False: 1]
  ------------------
  114|      0|        {
  115|      0|            result = setpriority(PRIO_PROCESS, gettid(), sched_priority);
  116|      0|            if (0 != result)
  ------------------
  |  Branch (116:17): [True: 0, False: 0]
  ------------------
  117|      0|            {
  118|      0|                THREAD_EPROSIMA_LOG_ERROR(thread_name, "Problem to set priority of thread with id [" << self_tid << "," << thread_name << "] to value " << sched_priority << ". Error '" << strerror(
  ------------------
  |  |   23|      0|    do{                                                                     \
  |  |   24|      0|        if (strcmp(thread_name, "dds.log") == 0)                            \
  |  |  ------------------
  |  |  |  Branch (24:13): [True: 0, False: 0]
  |  |  ------------------
  |  |   25|      0|        {                                                                   \
  |  |   26|      0|            std::cerr << msg << std::endl;                                  \
  |  |   27|      0|        }                                                                   \
  |  |   28|      0|        else                                                                \
  |  |   29|      0|        {                                                                   \
  |  |   30|      0|            EPROSIMA_LOG_ERROR(SYSTEM, msg);                                \
  |  |  ------------------
  |  |  |  |   45|      0|#define EPROSIMA_LOG_ERROR(cat, msg) EPROSIMA_LOG_ERROR_IMPL_(cat, msg)
  |  |  |  |  ------------------
  |  |  |  |  |  |  291|      0|    do {                                                                                                               \
  |  |  |  |  |  |  292|      0|        std::stringstream fastdds_log_ss_tmp__;                                                                        \
  |  |  |  |  |  |  293|      0|        fastdds_log_ss_tmp__ << msg;                                                                                   \
  |  |  |  |  |  |  294|      0|        eprosima::fastdds::dds::Log::QueueLog(                                                                         \
  |  |  |  |  |  |  295|      0|            fastdds_log_ss_tmp__.str(), eprosima::fastdds::dds::Log::Context{__FILE__, __LINE__, __func__, #cat},      \
  |  |  |  |  |  |  296|      0|            eprosima::fastdds::dds::Log::Kind::Error);                                                                 \
  |  |  |  |  |  |  297|      0|    } while (0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (297:14): [Folded - Ignored]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   31|      0|        }                                                                   \
  |  |   32|      0|    } while (0)
  |  |  ------------------
  |  |  |  Branch (32:14): [Folded - Ignored]
  |  |  ------------------
  ------------------
  119|      0|                            result) << "'");
  120|      0|            }
  121|      0|        }
  122|      1|        else if (0 != result)
  ------------------
  |  Branch (122:18): [True: 0, False: 1]
  ------------------
  123|      0|        {
  124|      0|            THREAD_EPROSIMA_LOG_ERROR(thread_name, "Problem to set scheduler of thread with id [" << self_tid << "," << thread_name << "] to value " << sched_class << ". Error '" << strerror(
  ------------------
  |  |   23|      0|    do{                                                                     \
  |  |   24|      0|        if (strcmp(thread_name, "dds.log") == 0)                            \
  |  |  ------------------
  |  |  |  Branch (24:13): [True: 0, False: 0]
  |  |  ------------------
  |  |   25|      0|        {                                                                   \
  |  |   26|      0|            std::cerr << msg << std::endl;                                  \
  |  |   27|      0|        }                                                                   \
  |  |   28|      0|        else                                                                \
  |  |   29|      0|        {                                                                   \
  |  |   30|      0|            EPROSIMA_LOG_ERROR(SYSTEM, msg);                                \
  |  |  ------------------
  |  |  |  |   45|      0|#define EPROSIMA_LOG_ERROR(cat, msg) EPROSIMA_LOG_ERROR_IMPL_(cat, msg)
  |  |  |  |  ------------------
  |  |  |  |  |  |  291|      0|    do {                                                                                                               \
  |  |  |  |  |  |  292|      0|        std::stringstream fastdds_log_ss_tmp__;                                                                        \
  |  |  |  |  |  |  293|      0|        fastdds_log_ss_tmp__ << msg;                                                                                   \
  |  |  |  |  |  |  294|      0|        eprosima::fastdds::dds::Log::QueueLog(                                                                         \
  |  |  |  |  |  |  295|      0|            fastdds_log_ss_tmp__.str(), eprosima::fastdds::dds::Log::Context{__FILE__, __LINE__, __func__, #cat},      \
  |  |  |  |  |  |  296|      0|            eprosima::fastdds::dds::Log::Kind::Error);                                                                 \
  |  |  |  |  |  |  297|      0|    } while (0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (297:14): [Folded - Ignored]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   31|      0|        }                                                                   \
  |  |   32|      0|    } while (0)
  |  |  ------------------
  |  |  |  Branch (32:14): [Folded - Ignored]
  |  |  ------------------
  ------------------
  125|      0|                        result) << "'");
  126|      0|        }
  127|      1|    }
  128|      0|    else if ((sched_class == SCHED_FIFO) ||
  ------------------
  |  Branch (128:14): [True: 0, False: 0]
  ------------------
  129|      0|            (sched_class == SCHED_RR))
  ------------------
  |  Branch (129:13): [True: 0, False: 0]
  ------------------
  130|      0|    {
  131|       |        //
  132|       |        // RT Policies use a different priority numberspace.
  133|       |        //
  134|       |
  135|      0|        param.sched_priority = change_priority ? sched_priority : current_param.sched_priority;
  ------------------
  |  Branch (135:32): [True: 0, False: 0]
  ------------------
  136|      0|        result = pthread_setschedparam(self_tid, sched_class, &param);
  137|      0|        if (0 != result)
  ------------------
  |  Branch (137:13): [True: 0, False: 0]
  ------------------
  138|      0|        {
  139|      0|            THREAD_EPROSIMA_LOG_ERROR(thread_name, "Problem to set scheduler of thread with id [" << self_tid << "," << thread_name << "] to value " << sched_class << " with priority " << param.sched_priority << ". Error '" << strerror(
  ------------------
  |  |   23|      0|    do{                                                                     \
  |  |   24|      0|        if (strcmp(thread_name, "dds.log") == 0)                            \
  |  |  ------------------
  |  |  |  Branch (24:13): [True: 0, False: 0]
  |  |  ------------------
  |  |   25|      0|        {                                                                   \
  |  |   26|      0|            std::cerr << msg << std::endl;                                  \
  |  |   27|      0|        }                                                                   \
  |  |   28|      0|        else                                                                \
  |  |   29|      0|        {                                                                   \
  |  |   30|      0|            EPROSIMA_LOG_ERROR(SYSTEM, msg);                                \
  |  |  ------------------
  |  |  |  |   45|      0|#define EPROSIMA_LOG_ERROR(cat, msg) EPROSIMA_LOG_ERROR_IMPL_(cat, msg)
  |  |  |  |  ------------------
  |  |  |  |  |  |  291|      0|    do {                                                                                                               \
  |  |  |  |  |  |  292|      0|        std::stringstream fastdds_log_ss_tmp__;                                                                        \
  |  |  |  |  |  |  293|      0|        fastdds_log_ss_tmp__ << msg;                                                                                   \
  |  |  |  |  |  |  294|      0|        eprosima::fastdds::dds::Log::QueueLog(                                                                         \
  |  |  |  |  |  |  295|      0|            fastdds_log_ss_tmp__.str(), eprosima::fastdds::dds::Log::Context{__FILE__, __LINE__, __func__, #cat},      \
  |  |  |  |  |  |  296|      0|            eprosima::fastdds::dds::Log::Kind::Error);                                                                 \
  |  |  |  |  |  |  297|      0|    } while (0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (297:14): [Folded - Ignored]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   31|      0|        }                                                                   \
  |  |   32|      0|    } while (0)
  |  |  ------------------
  |  |  |  Branch (32:14): [Folded - Ignored]
  |  |  ------------------
  ------------------
  140|      0|                        result) << "'");
  141|      0|        }
  142|      0|    }
  143|      1|}
SystemInfo.cpp:_ZN8eprosimaL33configure_current_thread_affinityEPKcm:
  148|      1|{
  149|      1|    int a;
  150|      1|    int result;
  151|      1|    int cpu_count;
  152|      1|    cpu_set_t cpu_set;
  153|      1|    pthread_t self_tid = pthread_self();
  154|       |
  155|      1|    result = 0;
  156|       |
  157|       |    //
  158|       |    // Rebuilt the cpu set from scratch...
  159|       |    //
  160|       |
  161|      1|    CPU_ZERO(&cpu_set);
  162|       |
  163|       |    //
  164|       |    // If the bit is set in our mask, set it into the cpu_set
  165|       |    // We only consider up to the total number of CPU's the
  166|       |    // system has.
  167|       |    //
  168|      1|    cpu_count = get_nprocs_conf();
  169|       |
  170|     33|    for (a = 0; a < cpu_count; a++)
  ------------------
  |  Branch (170:17): [True: 32, False: 1]
  ------------------
  171|     32|    {
  172|     32|        if (0 != (affinity_mask & 1))
  ------------------
  |  Branch (172:13): [True: 0, False: 32]
  ------------------
  173|      0|        {
  174|      0|            CPU_SET(a, &cpu_set);
  175|      0|            result++;
  176|      0|        }
  177|     32|        affinity_mask >>= 1;
  178|     32|    }
  179|       |
  180|      1|    if (affinity_mask > 0)
  ------------------
  |  Branch (180:9): [True: 0, False: 1]
  ------------------
  181|      0|    {
  182|      0|        THREAD_EPROSIMA_LOG_ERROR(thread_name, "Affinity mask has more processors than the ones present in the system");
  ------------------
  |  |   23|      0|    do{                                                                     \
  |  |   24|      0|        if (strcmp(thread_name, "dds.log") == 0)                            \
  |  |  ------------------
  |  |  |  Branch (24:13): [True: 0, False: 0]
  |  |  ------------------
  |  |   25|      0|        {                                                                   \
  |  |   26|      0|            std::cerr << msg << std::endl;                                  \
  |  |   27|      0|        }                                                                   \
  |  |   28|      0|        else                                                                \
  |  |   29|      0|        {                                                                   \
  |  |   30|      0|            EPROSIMA_LOG_ERROR(SYSTEM, msg);                                \
  |  |  ------------------
  |  |  |  |   45|      0|#define EPROSIMA_LOG_ERROR(cat, msg) EPROSIMA_LOG_ERROR_IMPL_(cat, msg)
  |  |  |  |  ------------------
  |  |  |  |  |  |  291|      0|    do {                                                                                                               \
  |  |  |  |  |  |  292|      0|        std::stringstream fastdds_log_ss_tmp__;                                                                        \
  |  |  |  |  |  |  293|      0|        fastdds_log_ss_tmp__ << msg;                                                                                   \
  |  |  |  |  |  |  294|      0|        eprosima::fastdds::dds::Log::QueueLog(                                                                         \
  |  |  |  |  |  |  295|      0|            fastdds_log_ss_tmp__.str(), eprosima::fastdds::dds::Log::Context{__FILE__, __LINE__, __func__, #cat},      \
  |  |  |  |  |  |  296|      0|            eprosima::fastdds::dds::Log::Kind::Error);                                                                 \
  |  |  |  |  |  |  297|      0|    } while (0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (297:14): [Folded - Ignored]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   31|      0|        }                                                                   \
  |  |   32|      0|    } while (0)
  |  |  ------------------
  |  |  |  Branch (32:14): [Folded - Ignored]
  |  |  ------------------
  ------------------
  183|      0|    }
  184|       |
  185|      1|    if (result > 0)
  ------------------
  |  Branch (185:9): [True: 0, False: 1]
  ------------------
  186|      0|    {
  187|       |#ifdef ANDROID
  188|       |        result = sched_setaffinity(self_tid, sizeof(cpu_set_t), &cpu_set);
  189|       |#else
  190|      0|        result = pthread_setaffinity_np(self_tid, sizeof(cpu_set_t), &cpu_set);
  191|      0|#endif // ifdef ANDROID
  192|      0|    }
  193|       |
  194|      1|    if (0 != result)
  ------------------
  |  Branch (194:9): [True: 0, False: 1]
  ------------------
  195|      0|    {
  196|      0|        THREAD_EPROSIMA_LOG_ERROR(thread_name, "Problem to set affinity of thread with id [" << self_tid << "," << thread_name << "] to value " << affinity_mask << ". Error '" << strerror(
  ------------------
  |  |   23|      0|    do{                                                                     \
  |  |   24|      0|        if (strcmp(thread_name, "dds.log") == 0)                            \
  |  |  ------------------
  |  |  |  Branch (24:13): [True: 0, False: 0]
  |  |  ------------------
  |  |   25|      0|        {                                                                   \
  |  |   26|      0|            std::cerr << msg << std::endl;                                  \
  |  |   27|      0|        }                                                                   \
  |  |   28|      0|        else                                                                \
  |  |   29|      0|        {                                                                   \
  |  |   30|      0|            EPROSIMA_LOG_ERROR(SYSTEM, msg);                                \
  |  |  ------------------
  |  |  |  |   45|      0|#define EPROSIMA_LOG_ERROR(cat, msg) EPROSIMA_LOG_ERROR_IMPL_(cat, msg)
  |  |  |  |  ------------------
  |  |  |  |  |  |  291|      0|    do {                                                                                                               \
  |  |  |  |  |  |  292|      0|        std::stringstream fastdds_log_ss_tmp__;                                                                        \
  |  |  |  |  |  |  293|      0|        fastdds_log_ss_tmp__ << msg;                                                                                   \
  |  |  |  |  |  |  294|      0|        eprosima::fastdds::dds::Log::QueueLog(                                                                         \
  |  |  |  |  |  |  295|      0|            fastdds_log_ss_tmp__.str(), eprosima::fastdds::dds::Log::Context{__FILE__, __LINE__, __func__, #cat},      \
  |  |  |  |  |  |  296|      0|            eprosima::fastdds::dds::Log::Kind::Error);                                                                 \
  |  |  |  |  |  |  297|      0|    } while (0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (297:14): [Folded - Ignored]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   31|      0|        }                                                                   \
  |  |   32|      0|    } while (0)
  |  |  ------------------
  |  |  |  Branch (32:14): [Folded - Ignored]
  |  |  ------------------
  ------------------
  197|      0|                    result) << "'");
  198|      0|    }
  199|      1|}
SystemInfo.cpp:_ZN8eprosimaL31set_name_to_current_thread_implIJPKcEEEvRNSt3__15arrayIcLm16EEES2_DpT_:
   45|      1|{
   46|      1|    snprintf(thread_name_buffer.data(), 16, fmt, args ...);
   47|      1|    auto id = pthread_self();
   48|      1|    pthread_setname_np(id, thread_name_buffer.data());
   49|      1|}

_Z12frac_to_nanoj:
   27|    332|{
   28|    332|    return static_cast<uint32_t>((fractions * C_NANOSECONDS_PER_SEC) / C_FRACTIONS_PER_SEC);
   29|    332|}

_ZN8eprosima7fastdds9xmlparser9XMLParser19parseXMLDynamicTypeEPN8tinyxml210XMLElementE:
  130|   128k|{
  131|       |    /*
  132|       |        <xs:group name="moduleElems">
  133|       |            <xs:sequence>
  134|       |                <xs:choice maxOccurs="unbounded">
  135|       |                    <xs:element name="struct" type="structDcl" minOccurs="0"/>
  136|       |                    <xs:element name="union" type="unionDcl" minOccurs="0"/>
  137|       |                    <xs:element name="enum" type="enumDcl" minOccurs="0"/>
  138|       |                    <xs:element name="typedef" type="typedefDcl" minOccurs="0"/>
  139|       |                    <xs:element name="bitset" type="bitsetDcl" minOccurs="0"/>
  140|       |                    <xs:element name="bitmask" type="bitmaskDcl" minOccurs="0"/>
  141|       |                </xs:choice>
  142|       |            </xs:sequence>
  143|       |        </xs:group>
  144|       |     */
  145|   128k|    XMLP_ret ret = XMLP_ret::XML_OK;
  146|   128k|    tinyxml2::XMLElement* p_aux0 = nullptr;
  147|   129k|    for (p_aux0 = p_root->FirstChildElement(); p_aux0 != nullptr; p_aux0 = p_aux0->NextSiblingElement())
  ------------------
  |  Branch (147:48): [True: 114k, False: 15.2k]
  ------------------
  148|   114k|    {
  149|   114k|        const std::string type = p_aux0->Value();
  150|   114k|        if (type.compare(STRUCT) == 0)
  ------------------
  |  Branch (150:13): [True: 9.22k, False: 105k]
  ------------------
  151|  9.22k|        {
  152|  9.22k|            ret = parseXMLStructDynamicType(p_aux0);
  153|  9.22k|        }
  154|   105k|        else if (type.compare(UNION) == 0)
  ------------------
  |  Branch (154:18): [True: 1.00k, False: 104k]
  ------------------
  155|  1.00k|        {
  156|  1.00k|            ret = parseXMLUnionDynamicType(p_aux0);
  157|  1.00k|        }
  158|   104k|        else if (type.compare(ENUM) == 0)
  ------------------
  |  Branch (158:18): [True: 4.73k, False: 99.7k]
  ------------------
  159|  4.73k|        {
  160|  4.73k|            ret = parseXMLEnumDynamicType(p_aux0);
  161|  4.73k|        }
  162|  99.7k|        else if (type.compare(TYPEDEF) == 0)
  ------------------
  |  Branch (162:18): [True: 81.2k, False: 18.5k]
  ------------------
  163|  81.2k|        {
  164|  81.2k|            ret = parseXMLAliasDynamicType(p_aux0);
  165|  81.2k|        }
  166|  18.5k|        else if (type.compare(BITSET) == 0)
  ------------------
  |  Branch (166:18): [True: 7.11k, False: 11.4k]
  ------------------
  167|  7.11k|        {
  168|  7.11k|            ret = parseXMLBitsetDynamicType(p_aux0);
  169|  7.11k|        }
  170|  11.4k|        else if (type.compare(BITMASK) == 0)
  ------------------
  |  Branch (170:18): [True: 8.31k, False: 3.13k]
  ------------------
  171|  8.31k|        {
  172|  8.31k|            ret = parseXMLBitmaskDynamicType(p_aux0);
  173|  8.31k|        }
  174|  3.13k|        else
  175|  3.13k|        {
  176|  3.13k|            EPROSIMA_LOG_ERROR(XMLPARSER, "Error parsing type: Type " << type << " not recognized.");
  ------------------
  |  |   45|  3.13k|#define EPROSIMA_LOG_ERROR(cat, msg) EPROSIMA_LOG_ERROR_IMPL_(cat, msg)
  |  |  ------------------
  |  |  |  |  291|  3.13k|    do {                                                                                                               \
  |  |  |  |  292|  3.13k|        std::stringstream fastdds_log_ss_tmp__;                                                                        \
  |  |  |  |  293|  3.13k|        fastdds_log_ss_tmp__ << msg;                                                                                   \
  |  |  |  |  294|  3.13k|        eprosima::fastdds::dds::Log::QueueLog(                                                                         \
  |  |  |  |  295|  3.13k|            fastdds_log_ss_tmp__.str(), eprosima::fastdds::dds::Log::Context{__FILE__, __LINE__, __func__, #cat},      \
  |  |  |  |  296|  3.13k|            eprosima::fastdds::dds::Log::Kind::Error);                                                                 \
  |  |  |  |  297|  3.13k|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (297:14): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  177|  3.13k|            ret = XMLP_ret::XML_ERROR;
  178|  3.13k|        }
  179|       |
  180|   114k|        if (ret != XMLP_ret::XML_OK)
  ------------------
  |  Branch (180:13): [True: 113k, False: 1.30k]
  ------------------
  181|   113k|        {
  182|   113k|            EPROSIMA_LOG_ERROR(XMLPARSER, "Error parsing type " << type << ".");
  ------------------
  |  |   45|   113k|#define EPROSIMA_LOG_ERROR(cat, msg) EPROSIMA_LOG_ERROR_IMPL_(cat, msg)
  |  |  ------------------
  |  |  |  |  291|   113k|    do {                                                                                                               \
  |  |  |  |  292|   113k|        std::stringstream fastdds_log_ss_tmp__;                                                                        \
  |  |  |  |  293|   113k|        fastdds_log_ss_tmp__ << msg;                                                                                   \
  |  |  |  |  294|   113k|        eprosima::fastdds::dds::Log::QueueLog(                                                                         \
  |  |  |  |  295|   113k|            fastdds_log_ss_tmp__.str(), eprosima::fastdds::dds::Log::Context{__FILE__, __LINE__, __func__, #cat},      \
  |  |  |  |  296|   113k|            eprosima::fastdds::dds::Log::Kind::Error);                                                                 \
  |  |  |  |  297|   113k|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (297:14): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  183|   113k|            break;
  184|   113k|        }
  185|   114k|    }
  186|   128k|    return ret;
  187|   128k|}
_ZN8eprosima7fastdds9xmlparser9XMLParser13parseXMLTypesEPN8tinyxml210XMLElementE:
  191|   128k|{
  192|       |    /*
  193|       |        <xs:element name="types">
  194|       |            <xs:complexType>
  195|       |                <xs:group ref="moduleElems"/>
  196|       |            </xs:complexType>
  197|       |        </xs:element>
  198|       |     */
  199|       |
  200|   128k|    XMLP_ret ret = XMLP_ret::XML_OK;
  201|   128k|    tinyxml2::XMLElement* p_aux0 = nullptr, * p_aux1 = nullptr;
  202|   128k|    p_aux0 = p_root->FirstChildElement(TYPES);
  203|   128k|    if (p_aux0 != nullptr)
  ------------------
  |  Branch (203:9): [True: 1.66k, False: 126k]
  ------------------
  204|  1.66k|    {
  205|  1.66k|        const char* name = nullptr;
  206|  3.89k|        for (p_aux1 = p_aux0->FirstChildElement(); p_aux1 != nullptr; p_aux1 = p_aux1->NextSiblingElement())
  ------------------
  |  Branch (206:52): [True: 3.09k, False: 799]
  ------------------
  207|  3.09k|        {
  208|  3.09k|            name = p_aux1->Name();
  209|  3.09k|            if (strcmp(name, TYPE) == 0)
  ------------------
  |  Branch (209:17): [True: 2.80k, False: 295]
  ------------------
  210|  2.80k|            {
  211|  2.80k|                if (XMLP_ret::XML_OK != parseXMLDynamicType(p_aux1))
  ------------------
  |  Branch (211:21): [True: 572, False: 2.22k]
  ------------------
  212|    572|                {
  213|    572|                    return XMLP_ret::XML_ERROR;
  214|    572|                }
  215|  2.80k|            }
  216|    295|            else
  217|    295|            {
  218|    295|                EPROSIMA_LOG_ERROR(XMLPARSER, "Invalid element found into 'types'. Name: " << name);
  ------------------
  |  |   45|    295|#define EPROSIMA_LOG_ERROR(cat, msg) EPROSIMA_LOG_ERROR_IMPL_(cat, msg)
  |  |  ------------------
  |  |  |  |  291|    295|    do {                                                                                                               \
  |  |  |  |  292|    295|        std::stringstream fastdds_log_ss_tmp__;                                                                        \
  |  |  |  |  293|    295|        fastdds_log_ss_tmp__ << msg;                                                                                   \
  |  |  |  |  294|    295|        eprosima::fastdds::dds::Log::QueueLog(                                                                         \
  |  |  |  |  295|    295|            fastdds_log_ss_tmp__.str(), eprosima::fastdds::dds::Log::Context{__FILE__, __LINE__, __func__, #cat},      \
  |  |  |  |  296|    295|            eprosima::fastdds::dds::Log::Kind::Error);                                                                 \
  |  |  |  |  297|    295|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (297:14): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  219|    295|                return XMLP_ret::XML_ERROR;
  220|    295|            }
  221|  3.09k|        }
  222|  1.66k|    }
  223|   126k|    else // Directly root is TYPES?
  224|   126k|    {
  225|   126k|        const char* name = nullptr;
  226|   139k|        for (p_aux0 = p_root->FirstChildElement(); p_aux0 != nullptr; p_aux0 = p_aux0->NextSiblingElement())
  ------------------
  |  Branch (226:52): [True: 126k, False: 12.9k]
  ------------------
  227|   126k|        {
  228|   126k|            name = p_aux0->Name();
  229|   126k|            if (strcmp(name, TYPE) == 0)
  ------------------
  |  Branch (229:17): [True: 125k, False: 951]
  ------------------
  230|   125k|            {
  231|   125k|                if (XMLP_ret::XML_OK != parseXMLDynamicType(p_aux0))
  ------------------
  |  Branch (231:21): [True: 112k, False: 13.0k]
  ------------------
  232|   112k|                {
  233|   112k|                    return XMLP_ret::XML_ERROR;
  234|   112k|                }
  235|   125k|            }
  236|    951|            else
  237|    951|            {
  238|    951|                EPROSIMA_LOG_ERROR(XMLPARSER, "Invalid element found into 'types'. Name: " << name);
  ------------------
  |  |   45|    951|#define EPROSIMA_LOG_ERROR(cat, msg) EPROSIMA_LOG_ERROR_IMPL_(cat, msg)
  |  |  ------------------
  |  |  |  |  291|    951|    do {                                                                                                               \
  |  |  |  |  292|    951|        std::stringstream fastdds_log_ss_tmp__;                                                                        \
  |  |  |  |  293|    951|        fastdds_log_ss_tmp__ << msg;                                                                                   \
  |  |  |  |  294|    951|        eprosima::fastdds::dds::Log::QueueLog(                                                                         \
  |  |  |  |  295|    951|            fastdds_log_ss_tmp__.str(), eprosima::fastdds::dds::Log::Context{__FILE__, __LINE__, __func__, #cat},      \
  |  |  |  |  296|    951|            eprosima::fastdds::dds::Log::Kind::Error);                                                                 \
  |  |  |  |  297|    951|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (297:14): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  239|    951|                return XMLP_ret::XML_ERROR;
  240|    951|            }
  241|   126k|        }
  242|   126k|    }
  243|  13.7k|    return ret;
  244|   128k|}
_ZN8eprosima7fastdds9xmlparser9XMLParser27parseXMLBitvalueDynamicTypeEPN8tinyxml210XMLElementENSt3__110shared_ptrINS0_3dds18DynamicTypeBuilderEEERt:
  250|  34.9k|{
  251|       |    /*
  252|       |        <xs:complexType name="bit_valueType">
  253|       |            <xs:attribute name="name" type="stringType" use="required"/>
  254|       |            <xs:attribute name="position" type="int16Type" use="optional"/>
  255|       |        </xs:complexType>
  256|       |     */
  257|  34.9k|    if (p_root == nullptr)
  ------------------
  |  Branch (257:9): [True: 0, False: 34.9k]
  ------------------
  258|      0|    {
  259|      0|        EPROSIMA_LOG_ERROR(XMLPARSER, "Error parsing bitmask: Node not found.");
  ------------------
  |  |   45|      0|#define EPROSIMA_LOG_ERROR(cat, msg) EPROSIMA_LOG_ERROR_IMPL_(cat, msg)
  |  |  ------------------
  |  |  |  |  291|      0|    do {                                                                                                               \
  |  |  |  |  292|      0|        std::stringstream fastdds_log_ss_tmp__;                                                                        \
  |  |  |  |  293|      0|        fastdds_log_ss_tmp__ << msg;                                                                                   \
  |  |  |  |  294|      0|        eprosima::fastdds::dds::Log::QueueLog(                                                                         \
  |  |  |  |  295|      0|            fastdds_log_ss_tmp__.str(), eprosima::fastdds::dds::Log::Context{__FILE__, __LINE__, __func__, #cat},      \
  |  |  |  |  296|      0|            eprosima::fastdds::dds::Log::Kind::Error);                                                                 \
  |  |  |  |  297|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (297:14): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  260|      0|        return XMLP_ret::XML_ERROR;
  261|      0|    }
  262|       |
  263|  34.9k|    if (!builder)
  ------------------
  |  Branch (263:9): [True: 0, False: 34.9k]
  ------------------
  264|      0|    {
  265|      0|        EPROSIMA_LOG_ERROR(XMLPARSER, "Error parsing bitmask: builder is nil.");
  ------------------
  |  |   45|      0|#define EPROSIMA_LOG_ERROR(cat, msg) EPROSIMA_LOG_ERROR_IMPL_(cat, msg)
  |  |  ------------------
  |  |  |  |  291|      0|    do {                                                                                                               \
  |  |  |  |  292|      0|        std::stringstream fastdds_log_ss_tmp__;                                                                        \
  |  |  |  |  293|      0|        fastdds_log_ss_tmp__ << msg;                                                                                   \
  |  |  |  |  294|      0|        eprosima::fastdds::dds::Log::QueueLog(                                                                         \
  |  |  |  |  295|      0|            fastdds_log_ss_tmp__.str(), eprosima::fastdds::dds::Log::Context{__FILE__, __LINE__, __func__, #cat},      \
  |  |  |  |  296|      0|            eprosima::fastdds::dds::Log::Kind::Error);                                                                 \
  |  |  |  |  297|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (297:14): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  266|      0|        return XMLP_ret::XML_ERROR;
  267|      0|    }
  268|       |
  269|  34.9k|    const char* memberName = p_root->Attribute(NAME);
  270|  34.9k|    const char* position = p_root->Attribute(POSITION);
  271|       |
  272|  34.9k|    if (position != nullptr)
  ------------------
  |  Branch (272:9): [True: 4.75k, False: 30.1k]
  ------------------
  273|  4.75k|    {
  274|  4.75k|        try
  275|  4.75k|        {
  276|  4.75k|            field_position = static_cast<uint16_t>(std::stoul(position));
  277|  4.75k|        }
  278|  4.75k|        catch (const std::exception&)
  279|  4.75k|        {
  280|    592|            EPROSIMA_LOG_ERROR(XMLPARSER, "Error parsing bit_value position: Invalid (must be an unsigned short).");
  ------------------
  |  |   45|    592|#define EPROSIMA_LOG_ERROR(cat, msg) EPROSIMA_LOG_ERROR_IMPL_(cat, msg)
  |  |  ------------------
  |  |  |  |  291|    592|    do {                                                                                                               \
  |  |  |  |  292|    592|        std::stringstream fastdds_log_ss_tmp__;                                                                        \
  |  |  |  |  293|    592|        fastdds_log_ss_tmp__ << msg;                                                                                   \
  |  |  |  |  294|    592|        eprosima::fastdds::dds::Log::QueueLog(                                                                         \
  |  |  |  |  295|    592|            fastdds_log_ss_tmp__.str(), eprosima::fastdds::dds::Log::Context{__FILE__, __LINE__, __func__, #cat},      \
  |  |  |  |  296|    592|            eprosima::fastdds::dds::Log::Kind::Error);                                                                 \
  |  |  |  |  297|    592|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (297:14): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  281|    592|            return XMLP_ret::XML_ERROR;
  282|    592|        }
  283|  4.75k|    }
  284|       |
  285|  34.3k|    if (memberName == nullptr)
  ------------------
  |  Branch (285:9): [True: 428, False: 33.9k]
  ------------------
  286|    428|    {
  287|    428|        EPROSIMA_LOG_ERROR(XMLPARSER, "Error parsing bit_value name: Not found.");
  ------------------
  |  |   45|    428|#define EPROSIMA_LOG_ERROR(cat, msg) EPROSIMA_LOG_ERROR_IMPL_(cat, msg)
  |  |  ------------------
  |  |  |  |  291|    428|    do {                                                                                                               \
  |  |  |  |  292|    428|        std::stringstream fastdds_log_ss_tmp__;                                                                        \
  |  |  |  |  293|    428|        fastdds_log_ss_tmp__ << msg;                                                                                   \
  |  |  |  |  294|    428|        eprosima::fastdds::dds::Log::QueueLog(                                                                         \
  |  |  |  |  295|    428|            fastdds_log_ss_tmp__.str(), eprosima::fastdds::dds::Log::Context{__FILE__, __LINE__, __func__, #cat},      \
  |  |  |  |  296|    428|            eprosima::fastdds::dds::Log::Kind::Error);                                                                 \
  |  |  |  |  297|    428|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (297:14): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  288|    428|        return XMLP_ret::XML_ERROR;
  289|    428|    }
  290|       |
  291|  33.9k|    MemberDescriptor::_ref_type md {traits<MemberDescriptor>::make_shared()};
  292|  33.9k|    md->id(field_position);
  293|  33.9k|    md->name(memberName);
  294|  33.9k|    md->type(DynamicTypeBuilderFactory::get_instance()->get_primitive_type(TK_BOOLEAN));
  295|  33.9k|    builder->add_member(md);
  296|  33.9k|    ++field_position;
  297|       |
  298|  33.9k|    return XMLP_ret::XML_OK;
  299|  34.3k|}
_ZN8eprosima7fastdds9xmlparser9XMLParser24parseXMLAliasDynamicTypeEPN8tinyxml210XMLElementE:
  397|  81.2k|{
  398|       |    /*
  399|       |        <typedef name="MyAliasEnum" type="nonBasic" nonBasicTypeName="MyEnum"/>
  400|       |
  401|       |        <typedef name="MyArray" type="int32" arrayDimensions="2,2"/>
  402|       |
  403|       |        <xs:complexType name="typedefDcl">
  404|       |            <xs:attribute name="name" type="identifierName" use="required"/>
  405|       |            <xs:attribute name="type" type="string" use="required"/>
  406|       |            <xs:attribute name="key_type" type="string" use="optional"/>
  407|       |            <xs:attribute name="arrayDimensions" type="string" use="optional"/>
  408|       |            <xs:attribute name="nonBasicTypeName" type="string" use="optional"/>
  409|       |            <xs:attribute name="sequenceMaxLength" type="string" use="optional"/>
  410|       |            <xs:attribute name="mapMaxLength" type="string" use="optional"/>
  411|       |        </xs:complexType>
  412|       |     */
  413|  81.2k|    XMLP_ret ret = XMLP_ret::XML_OK;
  414|       |
  415|  81.2k|    const char* type = p_root->Attribute(TYPE);
  416|  81.2k|    if (type != nullptr)
  ------------------
  |  Branch (416:9): [True: 78.9k, False: 2.24k]
  ------------------
  417|  78.9k|    {
  418|  78.9k|        if (strcmp(type, NON_BASIC_TYPE) == 0)
  ------------------
  |  Branch (418:13): [True: 743, False: 78.2k]
  ------------------
  419|    743|        {
  420|    743|            const char* typeNonBasicName = p_root->Attribute(NON_BASIC_TYPE_NAME);
  421|    743|            if (typeNonBasicName != nullptr)
  ------------------
  |  Branch (421:17): [True: 334, False: 409]
  ------------------
  422|    334|            {
  423|    334|                type = typeNonBasicName;
  424|    334|            }
  425|    409|            else
  426|    409|            {
  427|    409|                EPROSIMA_LOG_ERROR(XMLPARSER, "Error parsing member type: Not found.");
  ------------------
  |  |   45|    409|#define EPROSIMA_LOG_ERROR(cat, msg) EPROSIMA_LOG_ERROR_IMPL_(cat, msg)
  |  |  ------------------
  |  |  |  |  291|    409|    do {                                                                                                               \
  |  |  |  |  292|    409|        std::stringstream fastdds_log_ss_tmp__;                                                                        \
  |  |  |  |  293|    409|        fastdds_log_ss_tmp__ << msg;                                                                                   \
  |  |  |  |  294|    409|        eprosima::fastdds::dds::Log::QueueLog(                                                                         \
  |  |  |  |  295|    409|            fastdds_log_ss_tmp__.str(), eprosima::fastdds::dds::Log::Context{__FILE__, __LINE__, __func__, #cat},      \
  |  |  |  |  296|    409|            eprosima::fastdds::dds::Log::Kind::Error);                                                                 \
  |  |  |  |  297|    409|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (297:14): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  428|    409|                ret = XMLP_ret::XML_ERROR;
  429|    409|            }
  430|    743|        }
  431|       |
  432|  78.9k|        DynamicType::_ref_type value_type;
  433|  78.9k|        if ((p_root->Attribute(ARRAY_DIMENSIONS) != nullptr) ||
  ------------------
  |  Branch (433:13): [True: 46.7k, False: 32.1k]
  ------------------
  434|  78.9k|                (p_root->Attribute(SEQ_MAXLENGTH) != nullptr) ||
  ------------------
  |  Branch (434:17): [True: 5.53k, False: 26.6k]
  ------------------
  435|  78.9k|                (p_root->Attribute(MAP_MAXLENGTH) != nullptr))
  ------------------
  |  Branch (435:17): [True: 4.18k, False: 22.4k]
  ------------------
  436|  56.5k|        {
  437|  56.5k|            value_type = parseXMLMemberDynamicType(p_root);
  438|  56.5k|        }
  439|  22.4k|        else
  440|  22.4k|        {
  441|  22.4k|            uint32_t bound = 0;
  442|  22.4k|            const char* boundStr = p_root->Attribute(STR_MAXLENGTH);
  443|  22.4k|            if (boundStr != nullptr)
  ------------------
  |  Branch (443:17): [True: 2.73k, False: 19.7k]
  ------------------
  444|  2.73k|            {
  445|  2.73k|                try
  446|  2.73k|                {
  447|  2.73k|                    bound = static_cast<uint32_t>(std::stoul(boundStr));
  448|  2.73k|                }
  449|  2.73k|                catch (const std::exception&)
  450|  2.73k|                {
  451|    784|                    EPROSIMA_LOG_ERROR(XMLPARSER,
  ------------------
  |  |   45|    784|#define EPROSIMA_LOG_ERROR(cat, msg) EPROSIMA_LOG_ERROR_IMPL_(cat, msg)
  |  |  ------------------
  |  |  |  |  291|    784|    do {                                                                                                               \
  |  |  |  |  292|    784|        std::stringstream fastdds_log_ss_tmp__;                                                                        \
  |  |  |  |  293|    784|        fastdds_log_ss_tmp__ << msg;                                                                                   \
  |  |  |  |  294|    784|        eprosima::fastdds::dds::Log::QueueLog(                                                                         \
  |  |  |  |  295|    784|            fastdds_log_ss_tmp__.str(), eprosima::fastdds::dds::Log::Context{__FILE__, __LINE__, __func__, #cat},      \
  |  |  |  |  296|    784|            eprosima::fastdds::dds::Log::Kind::Error);                                                                 \
  |  |  |  |  297|    784|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (297:14): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  452|    784|                            "Error parsing alias type bound: '" << STR_MAXLENGTH << "' out of bounds.");
  453|    784|                    return XMLP_ret::XML_ERROR;
  454|    784|                }
  455|  2.73k|            }
  456|  21.6k|            value_type = getDiscriminatorTypeBuilder(type, bound);
  457|  21.6k|        }
  458|       |
  459|  78.1k|        if (value_type)
  ------------------
  |  Branch (459:13): [True: 45.6k, False: 32.4k]
  ------------------
  460|  45.6k|        {
  461|  45.6k|            const char* name = p_root->Attribute(NAME);
  462|  45.6k|            if (name != nullptr && name[0] != '\0')
  ------------------
  |  Branch (462:17): [True: 43.4k, False: 2.25k]
  |  Branch (462:36): [True: 39.0k, False: 4.42k]
  ------------------
  463|  39.0k|            {
  464|  39.0k|                DynamicTypeBuilder::_ref_type aux_type;
  465|  39.0k|                XMLProfileManager::getDynamicTypeBuilderByName(aux_type, name);
  466|  39.0k|                if (!aux_type)
  ------------------
  |  Branch (466:21): [True: 32.1k, False: 6.86k]
  ------------------
  467|  32.1k|                {
  468|  32.1k|                    TypeDescriptor::_ref_type alias_descriptor {traits<TypeDescriptor>::make_shared()};
  469|  32.1k|                    alias_descriptor->kind(TK_ALIAS);
  470|  32.1k|                    alias_descriptor->name(name);
  471|  32.1k|                    alias_descriptor->base_type(value_type);
  472|  32.1k|                    DynamicTypeBuilder::_ref_type builder {DynamicTypeBuilderFactory::get_instance()->create_type(
  473|  32.1k|                                                               alias_descriptor)};
  474|  32.1k|                    if (nullptr == builder
  ------------------
  |  Branch (474:25): [True: 31.8k, False: 268]
  |  Branch (474:25): [True: 31.8k, False: 268]
  ------------------
  475|  32.1k|                            || false == XMLProfileManager::insertDynamicTypeBuilderByName(name, builder))
  ------------------
  |  Branch (475:32): [True: 0, False: 268]
  ------------------
  476|  31.8k|                    {
  477|  31.8k|                        ret = XMLP_ret::XML_ERROR;
  478|  31.8k|                    }
  479|  32.1k|                }
  480|  6.86k|                else
  481|  6.86k|                {
  482|  6.86k|                    EPROSIMA_LOG_ERROR(XMLPARSER, "Error parsing alias type: Type '" << name << "' already defined.");
  ------------------
  |  |   45|  6.86k|#define EPROSIMA_LOG_ERROR(cat, msg) EPROSIMA_LOG_ERROR_IMPL_(cat, msg)
  |  |  ------------------
  |  |  |  |  291|  6.86k|    do {                                                                                                               \
  |  |  |  |  292|  6.86k|        std::stringstream fastdds_log_ss_tmp__;                                                                        \
  |  |  |  |  293|  6.86k|        fastdds_log_ss_tmp__ << msg;                                                                                   \
  |  |  |  |  294|  6.86k|        eprosima::fastdds::dds::Log::QueueLog(                                                                         \
  |  |  |  |  295|  6.86k|            fastdds_log_ss_tmp__.str(), eprosima::fastdds::dds::Log::Context{__FILE__, __LINE__, __func__, #cat},      \
  |  |  |  |  296|  6.86k|            eprosima::fastdds::dds::Log::Kind::Error);                                                                 \
  |  |  |  |  297|  6.86k|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (297:14): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  483|  6.86k|                    ret = XMLP_ret::XML_ERROR;
  484|  6.86k|                }
  485|  39.0k|            }
  486|  6.68k|            else
  487|  6.68k|            {
  488|  6.68k|                EPROSIMA_LOG_ERROR(XMLPARSER, "Error parsing alias type: No name attribute given.");
  ------------------
  |  |   45|  6.68k|#define EPROSIMA_LOG_ERROR(cat, msg) EPROSIMA_LOG_ERROR_IMPL_(cat, msg)
  |  |  ------------------
  |  |  |  |  291|  6.68k|    do {                                                                                                               \
  |  |  |  |  292|  6.68k|        std::stringstream fastdds_log_ss_tmp__;                                                                        \
  |  |  |  |  293|  6.68k|        fastdds_log_ss_tmp__ << msg;                                                                                   \
  |  |  |  |  294|  6.68k|        eprosima::fastdds::dds::Log::QueueLog(                                                                         \
  |  |  |  |  295|  6.68k|            fastdds_log_ss_tmp__.str(), eprosima::fastdds::dds::Log::Context{__FILE__, __LINE__, __func__, #cat},      \
  |  |  |  |  296|  6.68k|            eprosima::fastdds::dds::Log::Kind::Error);                                                                 \
  |  |  |  |  297|  6.68k|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (297:14): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  489|  6.68k|                ret = XMLP_ret::XML_ERROR;
  490|  6.68k|            }
  491|  45.6k|        }
  492|  32.4k|        else
  493|  32.4k|        {
  494|  32.4k|            EPROSIMA_LOG_ERROR(XMLPARSER, "Error parsing alias type: Value not recognized.");
  ------------------
  |  |   45|  32.4k|#define EPROSIMA_LOG_ERROR(cat, msg) EPROSIMA_LOG_ERROR_IMPL_(cat, msg)
  |  |  ------------------
  |  |  |  |  291|  32.4k|    do {                                                                                                               \
  |  |  |  |  292|  32.4k|        std::stringstream fastdds_log_ss_tmp__;                                                                        \
  |  |  |  |  293|  32.4k|        fastdds_log_ss_tmp__ << msg;                                                                                   \
  |  |  |  |  294|  32.4k|        eprosima::fastdds::dds::Log::QueueLog(                                                                         \
  |  |  |  |  295|  32.4k|            fastdds_log_ss_tmp__.str(), eprosima::fastdds::dds::Log::Context{__FILE__, __LINE__, __func__, #cat},      \
  |  |  |  |  296|  32.4k|            eprosima::fastdds::dds::Log::Kind::Error);                                                                 \
  |  |  |  |  297|  32.4k|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (297:14): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  495|  32.4k|            ret = XMLP_ret::XML_ERROR;
  496|  32.4k|        }
  497|  78.1k|    }
  498|  2.24k|    else
  499|  2.24k|    {
  500|  2.24k|        EPROSIMA_LOG_ERROR(XMLPARSER, "Error parsing alias type: Type not defined.");
  ------------------
  |  |   45|  2.24k|#define EPROSIMA_LOG_ERROR(cat, msg) EPROSIMA_LOG_ERROR_IMPL_(cat, msg)
  |  |  ------------------
  |  |  |  |  291|  2.24k|    do {                                                                                                               \
  |  |  |  |  292|  2.24k|        std::stringstream fastdds_log_ss_tmp__;                                                                        \
  |  |  |  |  293|  2.24k|        fastdds_log_ss_tmp__ << msg;                                                                                   \
  |  |  |  |  294|  2.24k|        eprosima::fastdds::dds::Log::QueueLog(                                                                         \
  |  |  |  |  295|  2.24k|            fastdds_log_ss_tmp__.str(), eprosima::fastdds::dds::Log::Context{__FILE__, __LINE__, __func__, #cat},      \
  |  |  |  |  296|  2.24k|            eprosima::fastdds::dds::Log::Kind::Error);                                                                 \
  |  |  |  |  297|  2.24k|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (297:14): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  501|  2.24k|        ret = XMLP_ret::XML_ERROR;
  502|  2.24k|    }
  503|  80.4k|    return ret;
  504|  81.2k|}
_ZN8eprosima7fastdds9xmlparser9XMLParser25parseXMLBitsetDynamicTypeEPN8tinyxml210XMLElementE:
  508|  7.11k|{
  509|       |    /*
  510|       |        <bitset name="MyBitSet">
  511|       |            <bitfield name="a" bit_bound="3"/>
  512|       |            <bitfield name="b" bit_bound="1"/>
  513|       |            <bitfield bit_bound="4"/>
  514|       |            <bitfield name="c" bit_bound="10"/>
  515|       |            <bitfield name="d" bit_bound="12" type="short"/>
  516|       |        </bitset>
  517|       |
  518|       |        <xs:complexType name="bitsetDcl">
  519|       |            <xs:sequence>
  520|       |                <xs:choice maxOccurs="unbounded">
  521|       |                    <xs:element name="bitfield" type="bitfieldDcl" minOccurs="1"/>
  522|       |                </xs:choice>
  523|       |            </xs:sequence>
  524|       |            <xs:attribute name="name" type="stringType" use="required"/>
  525|       |            <xs:attribute name="baseType" type="stringType" use="optional"/>
  526|       |        </xs:complexType>
  527|       |     */
  528|  7.11k|    XMLP_ret ret = XMLP_ret::XML_OK;
  529|       |
  530|  7.11k|    const char* name = p_root->Attribute(NAME);
  531|  7.11k|    if (nullptr == name || name[0] == '\0')
  ------------------
  |  Branch (531:9): [True: 631, False: 6.48k]
  |  Branch (531:28): [True: 71, False: 6.40k]
  ------------------
  532|    702|    {
  533|    702|        EPROSIMA_LOG_ERROR(XMLPARSER, "Error parsing 'bitsetDcl' type. No name attribute given.");
  ------------------
  |  |   45|    702|#define EPROSIMA_LOG_ERROR(cat, msg) EPROSIMA_LOG_ERROR_IMPL_(cat, msg)
  |  |  ------------------
  |  |  |  |  291|    702|    do {                                                                                                               \
  |  |  |  |  292|    702|        std::stringstream fastdds_log_ss_tmp__;                                                                        \
  |  |  |  |  293|    702|        fastdds_log_ss_tmp__ << msg;                                                                                   \
  |  |  |  |  294|    702|        eprosima::fastdds::dds::Log::QueueLog(                                                                         \
  |  |  |  |  295|    702|            fastdds_log_ss_tmp__.str(), eprosima::fastdds::dds::Log::Context{__FILE__, __LINE__, __func__, #cat},      \
  |  |  |  |  296|    702|            eprosima::fastdds::dds::Log::Kind::Error);                                                                 \
  |  |  |  |  297|    702|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (297:14): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  534|    702|        return XMLP_ret::XML_ERROR;
  535|    702|    }
  536|       |
  537|  6.40k|    DynamicTypeBuilder::_ref_type aux_type;
  538|  6.40k|    XMLProfileManager::getDynamicTypeBuilderByName(aux_type, name);
  539|  6.40k|    if (aux_type)
  ------------------
  |  Branch (539:9): [True: 989, False: 5.42k]
  ------------------
  540|    989|    {
  541|    989|        EPROSIMA_LOG_ERROR(XMLPARSER, "Error parsing 'bitsetDcl' type: Type '" << name << "' already defined.");
  ------------------
  |  |   45|    989|#define EPROSIMA_LOG_ERROR(cat, msg) EPROSIMA_LOG_ERROR_IMPL_(cat, msg)
  |  |  ------------------
  |  |  |  |  291|    989|    do {                                                                                                               \
  |  |  |  |  292|    989|        std::stringstream fastdds_log_ss_tmp__;                                                                        \
  |  |  |  |  293|    989|        fastdds_log_ss_tmp__ << msg;                                                                                   \
  |  |  |  |  294|    989|        eprosima::fastdds::dds::Log::QueueLog(                                                                         \
  |  |  |  |  295|    989|            fastdds_log_ss_tmp__.str(), eprosima::fastdds::dds::Log::Context{__FILE__, __LINE__, __func__, #cat},      \
  |  |  |  |  296|    989|            eprosima::fastdds::dds::Log::Kind::Error);                                                                 \
  |  |  |  |  297|    989|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (297:14): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  542|    989|        return XMLP_ret::XML_ERROR;
  543|    989|    }
  544|       |
  545|  5.42k|    TypeDescriptor::_ref_type bitset_descriptor {traits<TypeDescriptor>::make_shared()};
  546|  5.42k|    bitset_descriptor->kind(TK_BITSET);
  547|  5.42k|    bitset_descriptor->name(name);
  548|       |
  549|       |    //{{{ Retrieve bounds
  550|  5.42k|    for (tinyxml2::XMLElement* p_element = p_root->FirstChildElement();
  551|  5.42k|            p_element != nullptr; p_element = p_element->NextSiblingElement())
  ------------------
  |  Branch (551:13): [True: 329, False: 5.09k]
  ------------------
  552|    329|    {
  553|    329|        const char* member_name = p_element->Attribute(NAME);
  554|    329|        const char* bit_bound = p_element->Attribute(BIT_BOUND);
  555|       |
  556|    329|        if (bit_bound == nullptr)
  ------------------
  |  Branch (556:13): [True: 329, False: 0]
  ------------------
  557|    329|        {
  558|    329|            EPROSIMA_LOG_ERROR(XMLPARSER, "Error parsing bitfield bit_bound: Not found.");
  ------------------
  |  |   45|    329|#define EPROSIMA_LOG_ERROR(cat, msg) EPROSIMA_LOG_ERROR_IMPL_(cat, msg)
  |  |  ------------------
  |  |  |  |  291|    329|    do {                                                                                                               \
  |  |  |  |  292|    329|        std::stringstream fastdds_log_ss_tmp__;                                                                        \
  |  |  |  |  293|    329|        fastdds_log_ss_tmp__ << msg;                                                                                   \
  |  |  |  |  294|    329|        eprosima::fastdds::dds::Log::QueueLog(                                                                         \
  |  |  |  |  295|    329|            fastdds_log_ss_tmp__.str(), eprosima::fastdds::dds::Log::Context{__FILE__, __LINE__, __func__, #cat},      \
  |  |  |  |  296|    329|            eprosima::fastdds::dds::Log::Kind::Error);                                                                 \
  |  |  |  |  297|    329|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (297:14): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  559|    329|            return XMLP_ret::XML_ERROR;
  560|    329|        }
  561|      0|        if (nullptr != member_name)
  ------------------
  |  Branch (561:13): [True: 0, False: 0]
  ------------------
  562|      0|        {
  563|      0|            try
  564|      0|            {
  565|      0|                bitset_descriptor->bound().push_back(static_cast<uint32_t>(std::stoul(bit_bound)));
  566|      0|            }
  567|      0|            catch (const std::exception&)
  568|      0|            {
  569|      0|                EPROSIMA_LOG_ERROR(XMLPARSER,
  ------------------
  |  |   45|      0|#define EPROSIMA_LOG_ERROR(cat, msg) EPROSIMA_LOG_ERROR_IMPL_(cat, msg)
  |  |  ------------------
  |  |  |  |  291|      0|    do {                                                                                                               \
  |  |  |  |  292|      0|        std::stringstream fastdds_log_ss_tmp__;                                                                        \
  |  |  |  |  293|      0|        fastdds_log_ss_tmp__ << msg;                                                                                   \
  |  |  |  |  294|      0|        eprosima::fastdds::dds::Log::QueueLog(                                                                         \
  |  |  |  |  295|      0|            fastdds_log_ss_tmp__.str(), eprosima::fastdds::dds::Log::Context{__FILE__, __LINE__, __func__, #cat},      \
  |  |  |  |  296|      0|            eprosima::fastdds::dds::Log::Kind::Error);                                                                 \
  |  |  |  |  297|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (297:14): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  570|      0|                        "Error parsing bitfield type bound: '" << BIT_BOUND << "' out of bounds.");
  571|      0|                return XMLP_ret::XML_ERROR;
  572|      0|            }
  573|      0|        }
  574|      0|    }
  575|       |    //}}}
  576|       |
  577|  5.09k|    const char* baseType = p_root->Attribute(BASE_TYPE);
  578|  5.09k|    if (baseType != nullptr)
  ------------------
  |  Branch (578:9): [True: 2.87k, False: 2.22k]
  ------------------
  579|  2.87k|    {
  580|  2.87k|        DynamicTypeBuilder::_ref_type parent_type_builder = nullptr;
  581|  2.87k|        XMLProfileManager::getDynamicTypeBuilderByName(parent_type_builder, baseType);
  582|       |
  583|  2.87k|        DynamicType::_ref_type parent_type = nullptr;
  584|       |
  585|  2.87k|        if (nullptr != parent_type_builder)
  ------------------
  |  Branch (585:13): [True: 1.03k, False: 1.83k]
  ------------------
  586|  1.03k|        {
  587|  1.03k|            parent_type = parent_type_builder->build();
  588|  1.03k|        }
  589|       |
  590|  2.87k|        if (parent_type && (TK_BITSET == parent_type->get_kind() ||
  ------------------
  |  Branch (590:13): [True: 216, False: 2.65k]
  |  Branch (590:13): [True: 0, False: 2.87k]
  |  Branch (590:29): [True: 0, False: 216]
  ------------------
  591|    216|                TK_BITSET ==
  ------------------
  |  Branch (591:17): [True: 0, False: 216]
  ------------------
  592|    216|                traits<DynamicType>::narrow<DynamicTypeImpl>(parent_type)->resolve_alias_enclosed_type()->get_kind()))
  593|      0|        {
  594|      0|            bitset_descriptor->base_type(parent_type);
  595|      0|        }
  596|  2.87k|        else
  597|  2.87k|        {
  598|  2.87k|            EPROSIMA_LOG_ERROR(XMLPARSER, "Invalid baseType found into 'bitsetDcl'. Name: " << baseType);
  ------------------
  |  |   45|  2.87k|#define EPROSIMA_LOG_ERROR(cat, msg) EPROSIMA_LOG_ERROR_IMPL_(cat, msg)
  |  |  ------------------
  |  |  |  |  291|  2.87k|    do {                                                                                                               \
  |  |  |  |  292|  2.87k|        std::stringstream fastdds_log_ss_tmp__;                                                                        \
  |  |  |  |  293|  2.87k|        fastdds_log_ss_tmp__ << msg;                                                                                   \
  |  |  |  |  294|  2.87k|        eprosima::fastdds::dds::Log::QueueLog(                                                                         \
  |  |  |  |  295|  2.87k|            fastdds_log_ss_tmp__.str(), eprosima::fastdds::dds::Log::Context{__FILE__, __LINE__, __func__, #cat},      \
  |  |  |  |  296|  2.87k|            eprosima::fastdds::dds::Log::Kind::Error);                                                                 \
  |  |  |  |  297|  2.87k|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (297:14): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  599|  2.87k|            return XMLP_ret::XML_ERROR;
  600|  2.87k|        }
  601|  2.87k|    }
  602|       |
  603|  2.22k|    DynamicTypeBuilder::_ref_type type_builder =
  604|  2.22k|            DynamicTypeBuilderFactory::get_instance()->create_type(bitset_descriptor);
  605|       |
  606|  2.22k|    if (nullptr != type_builder)
  ------------------
  |  Branch (606:9): [True: 159, False: 2.06k]
  ------------------
  607|    159|    {
  608|    159|        const char* element_name {nullptr};
  609|    159|        MemberId position {0};
  610|    159|        for (tinyxml2::XMLElement* p_element = p_root->FirstChildElement();
  611|    159|                p_element != nullptr; p_element = p_element->NextSiblingElement())
  ------------------
  |  Branch (611:17): [True: 0, False: 159]
  ------------------
  612|      0|        {
  613|      0|            element_name = p_element->Name();
  614|      0|            if (strcmp(element_name, BITFIELD) == 0)
  ------------------
  |  Branch (614:17): [True: 0, False: 0]
  ------------------
  615|      0|            {
  616|      0|                ret = parseXMLBitfieldDynamicType(p_element, type_builder, position);
  617|      0|            }
  618|      0|            else
  619|      0|            {
  620|      0|                EPROSIMA_LOG_ERROR(XMLPARSER, "Invalid element found into 'bitsetDcl'. Name: " << element_name);
  ------------------
  |  |   45|      0|#define EPROSIMA_LOG_ERROR(cat, msg) EPROSIMA_LOG_ERROR_IMPL_(cat, msg)
  |  |  ------------------
  |  |  |  |  291|      0|    do {                                                                                                               \
  |  |  |  |  292|      0|        std::stringstream fastdds_log_ss_tmp__;                                                                        \
  |  |  |  |  293|      0|        fastdds_log_ss_tmp__ << msg;                                                                                   \
  |  |  |  |  294|      0|        eprosima::fastdds::dds::Log::QueueLog(                                                                         \
  |  |  |  |  295|      0|            fastdds_log_ss_tmp__.str(), eprosima::fastdds::dds::Log::Context{__FILE__, __LINE__, __func__, #cat},      \
  |  |  |  |  296|      0|            eprosima::fastdds::dds::Log::Kind::Error);                                                                 \
  |  |  |  |  297|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (297:14): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  621|      0|                return XMLP_ret::XML_ERROR;
  622|      0|            }
  623|      0|        }
  624|       |
  625|    159|        if (XMLP_ret::XML_OK == ret)
  ------------------
  |  Branch (625:13): [True: 159, False: 0]
  ------------------
  626|    159|        {
  627|    159|            if (false == XMLProfileManager::insertDynamicTypeBuilderByName(name, type_builder))
  ------------------
  |  Branch (627:17): [True: 0, False: 159]
  ------------------
  628|      0|            {
  629|      0|                ret = XMLP_ret::XML_ERROR;
  630|      0|            }
  631|    159|        }
  632|    159|    }
  633|  2.06k|    else
  634|  2.06k|    {
  635|  2.06k|        EPROSIMA_LOG_ERROR(XMLPARSER, "Error creating bitset type: " << name);
  ------------------
  |  |   45|  2.06k|#define EPROSIMA_LOG_ERROR(cat, msg) EPROSIMA_LOG_ERROR_IMPL_(cat, msg)
  |  |  ------------------
  |  |  |  |  291|  2.06k|    do {                                                                                                               \
  |  |  |  |  292|  2.06k|        std::stringstream fastdds_log_ss_tmp__;                                                                        \
  |  |  |  |  293|  2.06k|        fastdds_log_ss_tmp__ << msg;                                                                                   \
  |  |  |  |  294|  2.06k|        eprosima::fastdds::dds::Log::QueueLog(                                                                         \
  |  |  |  |  295|  2.06k|            fastdds_log_ss_tmp__.str(), eprosima::fastdds::dds::Log::Context{__FILE__, __LINE__, __func__, #cat},      \
  |  |  |  |  296|  2.06k|            eprosima::fastdds::dds::Log::Kind::Error);                                                                 \
  |  |  |  |  297|  2.06k|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (297:14): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  636|  2.06k|        ret = XMLP_ret::XML_ERROR;
  637|  2.06k|    }
  638|       |
  639|  2.22k|    return ret;
  640|  2.22k|}
_ZN8eprosima7fastdds9xmlparser9XMLParser26parseXMLBitmaskDynamicTypeEPN8tinyxml210XMLElementE:
  785|  8.31k|{
  786|       |    /*
  787|       |        <bitmask name="MyBitMask" bit_bound="8">
  788|       |            <bit_value name="flag0" position="0"/>
  789|       |            <bit_value name="flag1"/>
  790|       |            <bit_value name="flag2" position="2"/>
  791|       |            <bit_value name="flag5" position="5"/>
  792|       |        </bitmask>
  793|       |
  794|       |        <xs:complexType name="bitmaskDcl">
  795|       |            <xs:sequence>
  796|       |                <xs:element name="bit_value" type="bit_valueType" minOccurs="0" maxOccurs="unbounded"/>
  797|       |            </xs:sequence>
  798|       |            <xs:attribute name="name" use="required"/>
  799|       |            <xs:attribute name="bit_bound" use="optional"/>
  800|       |        </xs:complexType>
  801|       |     */
  802|  8.31k|    XMLP_ret ret = XMLP_ret::XML_OK;
  803|  8.31k|    uint16_t bit_bound = 32;
  804|  8.31k|    const char* anno_bit_bound = p_root->Attribute(BIT_BOUND);
  805|  8.31k|    if (anno_bit_bound != nullptr)
  ------------------
  |  Branch (805:9): [True: 841, False: 7.47k]
  ------------------
  806|    841|    {
  807|    841|        auto input_bit_bound = std::atoi(anno_bit_bound);
  808|    841|        if (input_bit_bound < 1 || input_bit_bound > 64)
  ------------------
  |  Branch (808:13): [True: 231, False: 610]
  |  Branch (808:36): [True: 43, False: 567]
  ------------------
  809|    274|        {
  810|    274|            return XMLP_ret::XML_ERROR;
  811|    274|        }
  812|    567|        bit_bound = static_cast<uint16_t>(input_bit_bound);
  813|    567|    }
  814|       |
  815|  8.04k|    const char* name = p_root->Attribute(NAME);
  816|  8.04k|    if (nullptr == name || name[0] == '\0')
  ------------------
  |  Branch (816:9): [True: 849, False: 7.19k]
  |  Branch (816:28): [True: 106, False: 7.08k]
  ------------------
  817|    955|    {
  818|    955|        return XMLP_ret::XML_ERROR;
  819|    955|    }
  820|  7.08k|    DynamicTypeBuilder::_ref_type aux_type;
  821|  7.08k|    XMLProfileManager::getDynamicTypeBuilderByName(aux_type, name);
  822|  7.08k|    if (aux_type)
  ------------------
  |  Branch (822:9): [True: 1.80k, False: 5.27k]
  ------------------
  823|  1.80k|    {
  824|  1.80k|        EPROSIMA_LOG_ERROR(XMLPARSER, "Error parsing 'bitmaskDcl' type: Type '" << name << "' already defined.");
  ------------------
  |  |   45|  1.80k|#define EPROSIMA_LOG_ERROR(cat, msg) EPROSIMA_LOG_ERROR_IMPL_(cat, msg)
  |  |  ------------------
  |  |  |  |  291|  1.80k|    do {                                                                                                               \
  |  |  |  |  292|  1.80k|        std::stringstream fastdds_log_ss_tmp__;                                                                        \
  |  |  |  |  293|  1.80k|        fastdds_log_ss_tmp__ << msg;                                                                                   \
  |  |  |  |  294|  1.80k|        eprosima::fastdds::dds::Log::QueueLog(                                                                         \
  |  |  |  |  295|  1.80k|            fastdds_log_ss_tmp__.str(), eprosima::fastdds::dds::Log::Context{__FILE__, __LINE__, __func__, #cat},      \
  |  |  |  |  296|  1.80k|            eprosima::fastdds::dds::Log::Kind::Error);                                                                 \
  |  |  |  |  297|  1.80k|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (297:14): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  825|  1.80k|        return XMLP_ret::XML_ERROR;
  826|  1.80k|    }
  827|       |
  828|  5.27k|    TypeDescriptor::_ref_type bitmask_descriptor {traits<TypeDescriptor>::make_shared()};
  829|  5.27k|    bitmask_descriptor->kind(TK_BITMASK);
  830|  5.27k|    bitmask_descriptor->name(name);
  831|  5.27k|    bitmask_descriptor->element_type(DynamicTypeBuilderFactory::get_instance()->get_primitive_type(TK_BOOLEAN));
  832|  5.27k|    bitmask_descriptor->bound().push_back(bit_bound);
  833|  5.27k|    DynamicTypeBuilder::_ref_type type_builder {
  834|  5.27k|        DynamicTypeBuilderFactory::get_instance()->create_type(bitmask_descriptor)};
  835|  5.27k|    uint16_t position = 0;
  836|       |
  837|  5.27k|    if (nullptr != type_builder)
  ------------------
  |  Branch (837:9): [True: 3.57k, False: 1.70k]
  ------------------
  838|  3.57k|    {
  839|  3.57k|        const char* element_name = nullptr;
  840|  3.57k|        for (tinyxml2::XMLElement* p_element = p_root->FirstChildElement();
  841|  37.4k|                p_element != nullptr; p_element = p_element->NextSiblingElement())
  ------------------
  |  Branch (841:17): [True: 37.2k, False: 282]
  ------------------
  842|  37.2k|        {
  843|  37.2k|            element_name = p_element->Name();
  844|  37.2k|            if (strcmp(element_name, BIT_VALUE) == 0)
  ------------------
  |  Branch (844:17): [True: 34.9k, False: 2.27k]
  ------------------
  845|  34.9k|            {
  846|  34.9k|                if (parseXMLBitvalueDynamicType(p_element, type_builder, position) != XMLP_ret::XML_OK)
  ------------------
  |  Branch (846:21): [True: 1.02k, False: 33.9k]
  ------------------
  847|  1.02k|                {
  848|  1.02k|                    return XMLP_ret::XML_ERROR;
  849|  1.02k|                }
  850|  34.9k|            }
  851|  2.27k|            else
  852|  2.27k|            {
  853|  2.27k|                EPROSIMA_LOG_ERROR(XMLPARSER, "Invalid element found into 'bitmaskDcl'. Name: " << element_name);
  ------------------
  |  |   45|  2.27k|#define EPROSIMA_LOG_ERROR(cat, msg) EPROSIMA_LOG_ERROR_IMPL_(cat, msg)
  |  |  ------------------
  |  |  |  |  291|  2.27k|    do {                                                                                                               \
  |  |  |  |  292|  2.27k|        std::stringstream fastdds_log_ss_tmp__;                                                                        \
  |  |  |  |  293|  2.27k|        fastdds_log_ss_tmp__ << msg;                                                                                   \
  |  |  |  |  294|  2.27k|        eprosima::fastdds::dds::Log::QueueLog(                                                                         \
  |  |  |  |  295|  2.27k|            fastdds_log_ss_tmp__.str(), eprosima::fastdds::dds::Log::Context{__FILE__, __LINE__, __func__, #cat},      \
  |  |  |  |  296|  2.27k|            eprosima::fastdds::dds::Log::Kind::Error);                                                                 \
  |  |  |  |  297|  2.27k|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (297:14): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  854|  2.27k|                return XMLP_ret::XML_ERROR;
  855|  2.27k|            }
  856|  37.2k|        }
  857|       |
  858|    282|        if (false == XMLProfileManager::insertDynamicTypeBuilderByName(name, type_builder))
  ------------------
  |  Branch (858:13): [True: 0, False: 282]
  ------------------
  859|      0|        {
  860|      0|            ret = XMLP_ret::XML_ERROR;
  861|      0|        }
  862|    282|    }
  863|  1.70k|    else
  864|  1.70k|    {
  865|  1.70k|        EPROSIMA_LOG_ERROR(XMLPARSER, "Error creating bitmask type: " << name);
  ------------------
  |  |   45|  1.70k|#define EPROSIMA_LOG_ERROR(cat, msg) EPROSIMA_LOG_ERROR_IMPL_(cat, msg)
  |  |  ------------------
  |  |  |  |  291|  1.70k|    do {                                                                                                               \
  |  |  |  |  292|  1.70k|        std::stringstream fastdds_log_ss_tmp__;                                                                        \
  |  |  |  |  293|  1.70k|        fastdds_log_ss_tmp__ << msg;                                                                                   \
  |  |  |  |  294|  1.70k|        eprosima::fastdds::dds::Log::QueueLog(                                                                         \
  |  |  |  |  295|  1.70k|            fastdds_log_ss_tmp__.str(), eprosima::fastdds::dds::Log::Context{__FILE__, __LINE__, __func__, #cat},      \
  |  |  |  |  296|  1.70k|            eprosima::fastdds::dds::Log::Kind::Error);                                                                 \
  |  |  |  |  297|  1.70k|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (297:14): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  866|  1.70k|        ret = XMLP_ret::XML_ERROR;
  867|  1.70k|    }
  868|       |
  869|  1.98k|    return ret;
  870|  5.27k|}
_ZN8eprosima7fastdds9xmlparser9XMLParser23parseXMLEnumDynamicTypeEPN8tinyxml210XMLElementE:
  874|  4.73k|{
  875|       |    /*
  876|       |        <xs:complexType name="enumeratorType">
  877|       |            <xs:attribute name="name" type="stringType" use="required"/>
  878|       |            <xs:attribute name="value" type="stringType" use="optional"/>
  879|       |        </xs:complexType>
  880|       |
  881|       |        <xs:complexType name="enum">
  882|       |            <xs:attribute name="name" use="required"/>
  883|       |            <xs:sequence>
  884|       |                <xs:element name="enumerator" type="enumeratorType" minOccurs="0" maxOccurs="unbounded"/>
  885|       |            </xs:sequence>
  886|       |        </xs:complexType>
  887|       |
  888|       |        //TODO: Enum bitbound to set the internal field
  889|       |     */
  890|  4.73k|    XMLP_ret ret = XMLP_ret::XML_OK;
  891|  4.73k|    const char* enumName = p_root->Attribute(NAME);
  892|       |
  893|  4.73k|    if (enumName == nullptr || enumName[0] == '\0')
  ------------------
  |  Branch (893:9): [True: 640, False: 4.09k]
  |  Branch (893:32): [True: 366, False: 3.73k]
  ------------------
  894|  1.00k|    {
  895|  1.00k|        EPROSIMA_LOG_ERROR(XMLPARSER, "Error parsing 'enum' type. No name attribute given.");
  ------------------
  |  |   45|  1.00k|#define EPROSIMA_LOG_ERROR(cat, msg) EPROSIMA_LOG_ERROR_IMPL_(cat, msg)
  |  |  ------------------
  |  |  |  |  291|  1.00k|    do {                                                                                                               \
  |  |  |  |  292|  1.00k|        std::stringstream fastdds_log_ss_tmp__;                                                                        \
  |  |  |  |  293|  1.00k|        fastdds_log_ss_tmp__ << msg;                                                                                   \
  |  |  |  |  294|  1.00k|        eprosima::fastdds::dds::Log::QueueLog(                                                                         \
  |  |  |  |  295|  1.00k|            fastdds_log_ss_tmp__.str(), eprosima::fastdds::dds::Log::Context{__FILE__, __LINE__, __func__, #cat},      \
  |  |  |  |  296|  1.00k|            eprosima::fastdds::dds::Log::Kind::Error);                                                                 \
  |  |  |  |  297|  1.00k|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (297:14): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  896|  1.00k|        return XMLP_ret::XML_ERROR;
  897|  1.00k|    }
  898|       |
  899|  3.73k|    DynamicTypeBuilder::_ref_type aux_type;
  900|  3.73k|    XMLProfileManager::getDynamicTypeBuilderByName(aux_type, enumName);
  901|  3.73k|    if (aux_type)
  ------------------
  |  Branch (901:9): [True: 2.16k, False: 1.56k]
  ------------------
  902|  2.16k|    {
  903|  2.16k|        EPROSIMA_LOG_ERROR(XMLPARSER, "Error parsing 'enum' type: Type '" << enumName << "' already defined.");
  ------------------
  |  |   45|  2.16k|#define EPROSIMA_LOG_ERROR(cat, msg) EPROSIMA_LOG_ERROR_IMPL_(cat, msg)
  |  |  ------------------
  |  |  |  |  291|  2.16k|    do {                                                                                                               \
  |  |  |  |  292|  2.16k|        std::stringstream fastdds_log_ss_tmp__;                                                                        \
  |  |  |  |  293|  2.16k|        fastdds_log_ss_tmp__ << msg;                                                                                   \
  |  |  |  |  294|  2.16k|        eprosima::fastdds::dds::Log::QueueLog(                                                                         \
  |  |  |  |  295|  2.16k|            fastdds_log_ss_tmp__.str(), eprosima::fastdds::dds::Log::Context{__FILE__, __LINE__, __func__, #cat},      \
  |  |  |  |  296|  2.16k|            eprosima::fastdds::dds::Log::Kind::Error);                                                                 \
  |  |  |  |  297|  2.16k|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (297:14): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  904|  2.16k|        return XMLP_ret::XML_ERROR;
  905|  2.16k|    }
  906|       |
  907|       |
  908|  1.56k|    TypeDescriptor::_ref_type enum_descriptor {traits<TypeDescriptor>::make_shared()};
  909|  1.56k|    enum_descriptor->kind(TK_ENUM);
  910|  1.56k|    enum_descriptor->name(enumName);
  911|  1.56k|    DynamicTypeBuilder::_ref_type type_builder {DynamicTypeBuilderFactory::get_instance()->create_type(
  912|  1.56k|                                                    enum_descriptor)};
  913|       |
  914|  1.56k|    if (nullptr != type_builder)
  ------------------
  |  Branch (914:9): [True: 304, False: 1.26k]
  ------------------
  915|    304|    {
  916|    304|        for (tinyxml2::XMLElement* literal = p_root->FirstChildElement(ENUMERATOR);
  917|    304|                literal != nullptr; literal = literal->NextSiblingElement(ENUMERATOR))
  ------------------
  |  Branch (917:17): [True: 0, False: 304]
  ------------------
  918|      0|        {
  919|      0|            const char* name = literal->Attribute(NAME);
  920|      0|            if (name == nullptr)
  ------------------
  |  Branch (920:17): [True: 0, False: 0]
  ------------------
  921|      0|            {
  922|      0|                EPROSIMA_LOG_ERROR(XMLPARSER, "Error parsing enum type: Literals must have name.");
  ------------------
  |  |   45|      0|#define EPROSIMA_LOG_ERROR(cat, msg) EPROSIMA_LOG_ERROR_IMPL_(cat, msg)
  |  |  ------------------
  |  |  |  |  291|      0|    do {                                                                                                               \
  |  |  |  |  292|      0|        std::stringstream fastdds_log_ss_tmp__;                                                                        \
  |  |  |  |  293|      0|        fastdds_log_ss_tmp__ << msg;                                                                                   \
  |  |  |  |  294|      0|        eprosima::fastdds::dds::Log::QueueLog(                                                                         \
  |  |  |  |  295|      0|            fastdds_log_ss_tmp__.str(), eprosima::fastdds::dds::Log::Context{__FILE__, __LINE__, __func__, #cat},      \
  |  |  |  |  296|      0|            eprosima::fastdds::dds::Log::Kind::Error);                                                                 \
  |  |  |  |  297|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (297:14): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  923|      0|                return XMLP_ret::XML_ERROR;
  924|      0|            }
  925|       |
  926|      0|            MemberDescriptor::_ref_type md {traits<MemberDescriptor>::make_shared()};
  927|      0|            md->type(DynamicTypeBuilderFactory::get_instance()->get_primitive_type(TK_INT32));
  928|      0|            md->name(name);
  929|       |
  930|      0|            const char* value = literal->Attribute(VALUE);
  931|      0|            if (value != nullptr)
  ------------------
  |  Branch (931:17): [True: 0, False: 0]
  ------------------
  932|      0|            {
  933|      0|                md->default_value(value);
  934|      0|            }
  935|       |
  936|      0|            type_builder->add_member(md);
  937|      0|        }
  938|       |
  939|    304|        if (false == XMLProfileManager::insertDynamicTypeBuilderByName(enumName, type_builder))
  ------------------
  |  Branch (939:13): [True: 0, False: 304]
  ------------------
  940|      0|        {
  941|      0|            ret = XMLP_ret::XML_ERROR;
  942|      0|        }
  943|    304|    }
  944|  1.26k|    else
  945|  1.26k|    {
  946|  1.26k|        EPROSIMA_LOG_ERROR(XMLPARSER, "Error creating enum type: " << enumName);
  ------------------
  |  |   45|  1.26k|#define EPROSIMA_LOG_ERROR(cat, msg) EPROSIMA_LOG_ERROR_IMPL_(cat, msg)
  |  |  ------------------
  |  |  |  |  291|  1.26k|    do {                                                                                                               \
  |  |  |  |  292|  1.26k|        std::stringstream fastdds_log_ss_tmp__;                                                                        \
  |  |  |  |  293|  1.26k|        fastdds_log_ss_tmp__ << msg;                                                                                   \
  |  |  |  |  294|  1.26k|        eprosima::fastdds::dds::Log::QueueLog(                                                                         \
  |  |  |  |  295|  1.26k|            fastdds_log_ss_tmp__.str(), eprosima::fastdds::dds::Log::Context{__FILE__, __LINE__, __func__, #cat},      \
  |  |  |  |  296|  1.26k|            eprosima::fastdds::dds::Log::Kind::Error);                                                                 \
  |  |  |  |  297|  1.26k|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (297:14): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  947|  1.26k|        ret = XMLP_ret::XML_ERROR;
  948|  1.26k|    }
  949|       |
  950|  1.56k|    return ret;
  951|  1.56k|}
_ZN8eprosima7fastdds9xmlparser9XMLParser25parseXMLStructDynamicTypeEPN8tinyxml210XMLElementE:
  955|  9.22k|{
  956|       |    /*
  957|       |        <xs:complexType name="structDcl">
  958|       |            <xs:sequence>
  959|       |                <xs:choice maxOccurs="unbounded">
  960|       |                    <xs:element name="member" type="memberDcl" minOccurs="1"/>
  961|       |                </xs:choice>
  962|       |            </xs:sequence>
  963|       |            <xs:attribute name="name" type="string" use="required"/>
  964|       |            <xs:attribute name="baseType" type="stringType" use="optional"/>
  965|       |        </xs:complexType>
  966|       |     */
  967|  9.22k|    XMLP_ret ret = XMLP_ret::XML_OK;
  968|  9.22k|    MemberId mId{0};
  969|  9.22k|    const char* name = p_root->Attribute(NAME);
  970|       |
  971|  9.22k|    if (nullptr == name || name[0] == '\0')
  ------------------
  |  Branch (971:9): [True: 405, False: 8.82k]
  |  Branch (971:28): [True: 261, False: 8.56k]
  ------------------
  972|    666|    {
  973|    666|        EPROSIMA_LOG_ERROR(XMLPARSER, "Missing required attribute 'name' in 'structDcl'.");
  ------------------
  |  |   45|    666|#define EPROSIMA_LOG_ERROR(cat, msg) EPROSIMA_LOG_ERROR_IMPL_(cat, msg)
  |  |  ------------------
  |  |  |  |  291|    666|    do {                                                                                                               \
  |  |  |  |  292|    666|        std::stringstream fastdds_log_ss_tmp__;                                                                        \
  |  |  |  |  293|    666|        fastdds_log_ss_tmp__ << msg;                                                                                   \
  |  |  |  |  294|    666|        eprosima::fastdds::dds::Log::QueueLog(                                                                         \
  |  |  |  |  295|    666|            fastdds_log_ss_tmp__.str(), eprosima::fastdds::dds::Log::Context{__FILE__, __LINE__, __func__, #cat},      \
  |  |  |  |  296|    666|            eprosima::fastdds::dds::Log::Kind::Error);                                                                 \
  |  |  |  |  297|    666|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (297:14): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  974|    666|        return XMLP_ret::XML_ERROR;
  975|    666|    }
  976|       |
  977|  8.56k|    DynamicTypeBuilder::_ref_type aux_type;
  978|  8.56k|    XMLProfileManager::getDynamicTypeBuilderByName(aux_type, name);
  979|  8.56k|    if (aux_type)
  ------------------
  |  Branch (979:9): [True: 1.93k, False: 6.62k]
  ------------------
  980|  1.93k|    {
  981|  1.93k|        EPROSIMA_LOG_ERROR(XMLPARSER, "Error parsing 'structDcl' type: Type '" << name << "' already defined.");
  ------------------
  |  |   45|  1.93k|#define EPROSIMA_LOG_ERROR(cat, msg) EPROSIMA_LOG_ERROR_IMPL_(cat, msg)
  |  |  ------------------
  |  |  |  |  291|  1.93k|    do {                                                                                                               \
  |  |  |  |  292|  1.93k|        std::stringstream fastdds_log_ss_tmp__;                                                                        \
  |  |  |  |  293|  1.93k|        fastdds_log_ss_tmp__ << msg;                                                                                   \
  |  |  |  |  294|  1.93k|        eprosima::fastdds::dds::Log::QueueLog(                                                                         \
  |  |  |  |  295|  1.93k|            fastdds_log_ss_tmp__.str(), eprosima::fastdds::dds::Log::Context{__FILE__, __LINE__, __func__, #cat},      \
  |  |  |  |  296|  1.93k|            eprosima::fastdds::dds::Log::Kind::Error);                                                                 \
  |  |  |  |  297|  1.93k|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (297:14): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  982|  1.93k|        return XMLP_ret::XML_ERROR;
  983|  1.93k|    }
  984|       |
  985|  6.62k|    TypeDescriptor::_ref_type structure_descriptor {traits<TypeDescriptor>::make_shared()};
  986|  6.62k|    structure_descriptor->kind(TK_STRUCTURE);
  987|  6.62k|    structure_descriptor->name(name);
  988|       |
  989|  6.62k|    const char* baseType = p_root->Attribute(BASE_TYPE);
  990|  6.62k|    if (baseType != nullptr)
  ------------------
  |  Branch (990:9): [True: 3.40k, False: 3.22k]
  ------------------
  991|  3.40k|    {
  992|  3.40k|        DynamicTypeBuilder::_ref_type parent_type_builder = nullptr;
  993|  3.40k|        XMLProfileManager::getDynamicTypeBuilderByName(parent_type_builder, baseType);
  994|       |
  995|  3.40k|        DynamicType::_ref_type parent_type = nullptr;
  996|       |
  997|  3.40k|        if (nullptr != parent_type_builder)
  ------------------
  |  Branch (997:13): [True: 1.51k, False: 1.88k]
  ------------------
  998|  1.51k|        {
  999|  1.51k|            parent_type = parent_type_builder->build();
 1000|  1.51k|        }
 1001|       |
 1002|  3.40k|        if (parent_type && (TK_STRUCTURE == parent_type->get_kind() ||
  ------------------
  |  Branch (1002:13): [True: 595, False: 2.80k]
  |  Branch (1002:13): [True: 18, False: 3.38k]
  |  Branch (1002:29): [True: 18, False: 577]
  ------------------
 1003|    595|                TK_STRUCTURE ==
  ------------------
  |  Branch (1003:17): [True: 0, False: 577]
  ------------------
 1004|    577|                traits<DynamicType>::narrow<DynamicTypeImpl>(parent_type)->resolve_alias_enclosed_type()->get_kind()))
 1005|     18|        {
 1006|     18|            structure_descriptor->base_type(parent_type);
 1007|     18|        }
 1008|  3.38k|        else
 1009|  3.38k|        {
 1010|  3.38k|            EPROSIMA_LOG_ERROR(XMLPARSER, "Invalid baseType found into 'structDcl'. Name: " << baseType);
  ------------------
  |  |   45|  3.38k|#define EPROSIMA_LOG_ERROR(cat, msg) EPROSIMA_LOG_ERROR_IMPL_(cat, msg)
  |  |  ------------------
  |  |  |  |  291|  3.38k|    do {                                                                                                               \
  |  |  |  |  292|  3.38k|        std::stringstream fastdds_log_ss_tmp__;                                                                        \
  |  |  |  |  293|  3.38k|        fastdds_log_ss_tmp__ << msg;                                                                                   \
  |  |  |  |  294|  3.38k|        eprosima::fastdds::dds::Log::QueueLog(                                                                         \
  |  |  |  |  295|  3.38k|            fastdds_log_ss_tmp__.str(), eprosima::fastdds::dds::Log::Context{__FILE__, __LINE__, __func__, #cat},      \
  |  |  |  |  296|  3.38k|            eprosima::fastdds::dds::Log::Kind::Error);                                                                 \
  |  |  |  |  297|  3.38k|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (297:14): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1011|  3.38k|            return XMLP_ret::XML_ERROR;
 1012|  3.38k|        }
 1013|  3.40k|    }
 1014|       |
 1015|  3.24k|    DynamicTypeBuilder::_ref_type type_builder = DynamicTypeBuilderFactory::get_instance()->create_type(
 1016|  3.24k|        structure_descriptor);
 1017|       |
 1018|  3.24k|    if (nullptr != type_builder)
  ------------------
  |  Branch (1018:9): [True: 287, False: 2.95k]
  ------------------
 1019|    287|    {
 1020|    287|        const char* element_name = nullptr;
 1021|    287|        for (tinyxml2::XMLElement* p_element = p_root->FirstChildElement();
 1022|    287|                p_element != nullptr; p_element = p_element->NextSiblingElement())
  ------------------
  |  Branch (1022:17): [True: 0, False: 287]
  ------------------
 1023|      0|        {
 1024|      0|            element_name = p_element->Name();
 1025|      0|            if (strcmp(element_name, MEMBER) == 0)
  ------------------
  |  Branch (1025:17): [True: 0, False: 0]
  ------------------
 1026|      0|            {
 1027|      0|                if (!parseXMLMemberDynamicType(p_element, type_builder, mId++))
  ------------------
  |  Branch (1027:21): [True: 0, False: 0]
  ------------------
 1028|      0|                {
 1029|      0|                    return XMLP_ret::XML_ERROR;
 1030|      0|                }
 1031|      0|            }
 1032|      0|            else
 1033|      0|            {
 1034|      0|                EPROSIMA_LOG_ERROR(XMLPARSER, "Invalid element found into 'structDcl'. Name: " << element_name);
  ------------------
  |  |   45|      0|#define EPROSIMA_LOG_ERROR(cat, msg) EPROSIMA_LOG_ERROR_IMPL_(cat, msg)
  |  |  ------------------
  |  |  |  |  291|      0|    do {                                                                                                               \
  |  |  |  |  292|      0|        std::stringstream fastdds_log_ss_tmp__;                                                                        \
  |  |  |  |  293|      0|        fastdds_log_ss_tmp__ << msg;                                                                                   \
  |  |  |  |  294|      0|        eprosima::fastdds::dds::Log::QueueLog(                                                                         \
  |  |  |  |  295|      0|            fastdds_log_ss_tmp__.str(), eprosima::fastdds::dds::Log::Context{__FILE__, __LINE__, __func__, #cat},      \
  |  |  |  |  296|      0|            eprosima::fastdds::dds::Log::Kind::Error);                                                                 \
  |  |  |  |  297|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (297:14): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1035|      0|                return XMLP_ret::XML_ERROR;
 1036|      0|            }
 1037|      0|        }
 1038|       |
 1039|    287|        if (false == XMLProfileManager::insertDynamicTypeBuilderByName(name, type_builder))
  ------------------
  |  Branch (1039:13): [True: 0, False: 287]
  ------------------
 1040|      0|        {
 1041|      0|            ret = XMLP_ret::XML_ERROR;
 1042|      0|        }
 1043|    287|    }
 1044|  2.95k|    else
 1045|  2.95k|    {
 1046|  2.95k|        EPROSIMA_LOG_ERROR(XMLPARSER, "Error creating struct type: " << name);
  ------------------
  |  |   45|  2.95k|#define EPROSIMA_LOG_ERROR(cat, msg) EPROSIMA_LOG_ERROR_IMPL_(cat, msg)
  |  |  ------------------
  |  |  |  |  291|  2.95k|    do {                                                                                                               \
  |  |  |  |  292|  2.95k|        std::stringstream fastdds_log_ss_tmp__;                                                                        \
  |  |  |  |  293|  2.95k|        fastdds_log_ss_tmp__ << msg;                                                                                   \
  |  |  |  |  294|  2.95k|        eprosima::fastdds::dds::Log::QueueLog(                                                                         \
  |  |  |  |  295|  2.95k|            fastdds_log_ss_tmp__.str(), eprosima::fastdds::dds::Log::Context{__FILE__, __LINE__, __func__, #cat},      \
  |  |  |  |  296|  2.95k|            eprosima::fastdds::dds::Log::Kind::Error);                                                                 \
  |  |  |  |  297|  2.95k|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (297:14): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1047|  2.95k|        ret = XMLP_ret::XML_ERROR;
 1048|  2.95k|    }
 1049|       |
 1050|  3.24k|    return ret;
 1051|  3.24k|}
_ZN8eprosima7fastdds9xmlparser9XMLParser24parseXMLUnionDynamicTypeEPN8tinyxml210XMLElementE:
 1055|  1.00k|{
 1056|       |    /*
 1057|       |        <xs:complexType name="caseDcl">
 1058|       |            <xs:sequence>
 1059|       |                <xs:choice minOccurs="1" maxOccurs="unbounded">
 1060|       |                    <xs:element name="caseValue" type="string" minOccurs="1" maxOccurs="unbounded"/>
 1061|       |                </xs:choice>
 1062|       |                <xs:element name="member" type="memberDcl" minOccurs="1" maxOccurs="1"/>
 1063|       |            </xs:sequence>
 1064|       |        </xs:complexType>
 1065|       |
 1066|       |        <xs:complexType name="unionDcl">
 1067|       |            <xs:sequence>
 1068|       |                <xs:element name="discriminator" type="string" minOccurs="1"/>
 1069|       |                <xs:sequence maxOccurs="unbounded">
 1070|       |                    <xs:element name="case" type="caseDcl" minOccurs="1"/>
 1071|       |                </xs:sequence>
 1072|       |            </xs:sequence>
 1073|       |            <xs:attribute name="name" type="identifierName" use="required"/>
 1074|       |        </xs:complexType>
 1075|       |     */
 1076|       |
 1077|  1.00k|    XMLP_ret ret = XMLP_ret::XML_OK;
 1078|  1.00k|    const char* name = p_root->Attribute(NAME);
 1079|  1.00k|    if (nullptr == name || name[0] == '\0')
  ------------------
  |  Branch (1079:9): [True: 294, False: 715]
  |  Branch (1079:28): [True: 32, False: 683]
  ------------------
 1080|    326|    {
 1081|    326|        EPROSIMA_LOG_ERROR(XMLPARSER, "Missing required attribute 'name' in 'unionDcl'.");
  ------------------
  |  |   45|    326|#define EPROSIMA_LOG_ERROR(cat, msg) EPROSIMA_LOG_ERROR_IMPL_(cat, msg)
  |  |  ------------------
  |  |  |  |  291|    326|    do {                                                                                                               \
  |  |  |  |  292|    326|        std::stringstream fastdds_log_ss_tmp__;                                                                        \
  |  |  |  |  293|    326|        fastdds_log_ss_tmp__ << msg;                                                                                   \
  |  |  |  |  294|    326|        eprosima::fastdds::dds::Log::QueueLog(                                                                         \
  |  |  |  |  295|    326|            fastdds_log_ss_tmp__.str(), eprosima::fastdds::dds::Log::Context{__FILE__, __LINE__, __func__, #cat},      \
  |  |  |  |  296|    326|            eprosima::fastdds::dds::Log::Kind::Error);                                                                 \
  |  |  |  |  297|    326|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (297:14): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1082|    326|        return XMLP_ret::XML_ERROR;
 1083|    326|    }
 1084|       |
 1085|    683|    DynamicTypeBuilder::_ref_type aux_type;
 1086|    683|    XMLProfileManager::getDynamicTypeBuilderByName(aux_type, name);
 1087|    683|    if (aux_type)
  ------------------
  |  Branch (1087:9): [True: 175, False: 508]
  ------------------
 1088|    175|    {
 1089|    175|        EPROSIMA_LOG_ERROR(XMLPARSER, "Error parsing 'unionDcl' type: Type '" << name << "' already defined.");
  ------------------
  |  |   45|    175|#define EPROSIMA_LOG_ERROR(cat, msg) EPROSIMA_LOG_ERROR_IMPL_(cat, msg)
  |  |  ------------------
  |  |  |  |  291|    175|    do {                                                                                                               \
  |  |  |  |  292|    175|        std::stringstream fastdds_log_ss_tmp__;                                                                        \
  |  |  |  |  293|    175|        fastdds_log_ss_tmp__ << msg;                                                                                   \
  |  |  |  |  294|    175|        eprosima::fastdds::dds::Log::QueueLog(                                                                         \
  |  |  |  |  295|    175|            fastdds_log_ss_tmp__.str(), eprosima::fastdds::dds::Log::Context{__FILE__, __LINE__, __func__, #cat},      \
  |  |  |  |  296|    175|            eprosima::fastdds::dds::Log::Kind::Error);                                                                 \
  |  |  |  |  297|    175|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (297:14): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1090|    175|        return XMLP_ret::XML_ERROR;
 1091|    175|    }
 1092|       |
 1093|    508|    tinyxml2::XMLElement* p_element = p_root->FirstChildElement(DISCRIMINATOR);
 1094|    508|    if (p_element != nullptr)
  ------------------
  |  Branch (1094:9): [True: 0, False: 508]
  ------------------
 1095|      0|    {
 1096|      0|        const char* disc = p_element->Attribute(TYPE);
 1097|      0|        DynamicType::_ref_type disc_type = getDiscriminatorTypeBuilder(disc);
 1098|      0|        if (!disc_type)
  ------------------
  |  Branch (1098:13): [True: 0, False: 0]
  ------------------
 1099|      0|        {
 1100|      0|            EPROSIMA_LOG_ERROR(XMLPARSER,
  ------------------
  |  |   45|      0|#define EPROSIMA_LOG_ERROR(cat, msg) EPROSIMA_LOG_ERROR_IMPL_(cat, msg)
  |  |  ------------------
  |  |  |  |  291|      0|    do {                                                                                                               \
  |  |  |  |  292|      0|        std::stringstream fastdds_log_ss_tmp__;                                                                        \
  |  |  |  |  293|      0|        fastdds_log_ss_tmp__ << msg;                                                                                   \
  |  |  |  |  294|      0|        eprosima::fastdds::dds::Log::QueueLog(                                                                         \
  |  |  |  |  295|      0|            fastdds_log_ss_tmp__.str(), eprosima::fastdds::dds::Log::Context{__FILE__, __LINE__, __func__, #cat},      \
  |  |  |  |  296|      0|            eprosima::fastdds::dds::Log::Kind::Error);                                                                 \
  |  |  |  |  297|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (297:14): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1101|      0|                    "Error parsing union discriminator: Only primitive types allowed (found type " << disc << ").");
 1102|      0|            ret = XMLP_ret::XML_ERROR;
 1103|      0|        }
 1104|      0|        else
 1105|      0|        {
 1106|      0|            TypeDescriptor::_ref_type union_descriptor {traits<TypeDescriptor>::make_shared()};
 1107|      0|            union_descriptor->kind(TK_UNION);
 1108|      0|            union_descriptor->name(name);
 1109|      0|            union_descriptor->discriminator_type(disc_type);
 1110|      0|            DynamicTypeBuilder::_ref_type type_builder {DynamicTypeBuilderFactory::get_instance()->
 1111|      0|                                                                create_type(union_descriptor)};
 1112|       |
 1113|      0|            if (nullptr != type_builder)
  ------------------
  |  Branch (1113:17): [True: 0, False: 0]
  ------------------
 1114|      0|            {
 1115|      0|                MemberId mId{1};
 1116|      0|                for (p_element = p_root->FirstChildElement(CASE);
 1117|      0|                        p_element != nullptr; p_element = p_element->NextSiblingElement(CASE))
  ------------------
  |  Branch (1117:25): [True: 0, False: 0]
  ------------------
 1118|      0|                {
 1119|      0|                    std::string valuesStr = "";
 1120|      0|                    for (tinyxml2::XMLElement* caseValue = p_element->FirstChildElement(CASE_DISCRIMINATOR);
 1121|      0|                            caseValue != nullptr; caseValue = caseValue->NextSiblingElement(CASE_DISCRIMINATOR))
  ------------------
  |  Branch (1121:29): [True: 0, False: 0]
  ------------------
 1122|      0|                    {
 1123|      0|                        const char* values = caseValue->Attribute(VALUE);
 1124|      0|                        if (values == nullptr)
  ------------------
  |  Branch (1124:29): [True: 0, False: 0]
  ------------------
 1125|      0|                        {
 1126|      0|                            EPROSIMA_LOG_ERROR(XMLPARSER, "Error parsing union case value: Not found.");
  ------------------
  |  |   45|      0|#define EPROSIMA_LOG_ERROR(cat, msg) EPROSIMA_LOG_ERROR_IMPL_(cat, msg)
  |  |  ------------------
  |  |  |  |  291|      0|    do {                                                                                                               \
  |  |  |  |  292|      0|        std::stringstream fastdds_log_ss_tmp__;                                                                        \
  |  |  |  |  293|      0|        fastdds_log_ss_tmp__ << msg;                                                                                   \
  |  |  |  |  294|      0|        eprosima::fastdds::dds::Log::QueueLog(                                                                         \
  |  |  |  |  295|      0|            fastdds_log_ss_tmp__.str(), eprosima::fastdds::dds::Log::Context{__FILE__, __LINE__, __func__, #cat},      \
  |  |  |  |  296|      0|            eprosima::fastdds::dds::Log::Kind::Error);                                                                 \
  |  |  |  |  297|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (297:14): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1127|      0|                            return XMLP_ret::XML_ERROR;
 1128|      0|                        }
 1129|       |
 1130|      0|                        if (valuesStr.empty())
  ------------------
  |  Branch (1130:29): [True: 0, False: 0]
  ------------------
 1131|      0|                        {
 1132|      0|                            valuesStr = values;
 1133|      0|                        }
 1134|      0|                        else
 1135|      0|                        {
 1136|      0|                            valuesStr += std::string(",") + values;
 1137|      0|                        }
 1138|      0|                    }
 1139|       |
 1140|      0|                    tinyxml2::XMLElement* caseElement = p_element->FirstChildElement();
 1141|      0|                    while (caseElement != nullptr &&
  ------------------
  |  Branch (1141:28): [True: 0, False: 0]
  ------------------
 1142|      0|                            strncmp(caseElement->Value(), CASE_DISCRIMINATOR, CASE_DISCRIMINATOR_len) == 0)
  ------------------
  |  Branch (1142:29): [True: 0, False: 0]
  ------------------
 1143|      0|                    {
 1144|      0|                        caseElement = caseElement->NextSiblingElement();
 1145|      0|                    }
 1146|      0|                    if (caseElement != nullptr)
  ------------------
  |  Branch (1146:25): [True: 0, False: 0]
  ------------------
 1147|      0|                    {
 1148|      0|                        if (!parseXMLMemberDynamicType(caseElement, type_builder, mId++, valuesStr))
  ------------------
  |  Branch (1148:29): [True: 0, False: 0]
  ------------------
 1149|      0|                        {
 1150|      0|                            return XMLP_ret::XML_ERROR;
 1151|      0|                        }
 1152|      0|                    }
 1153|      0|                    else
 1154|      0|                    {
 1155|      0|                        EPROSIMA_LOG_ERROR(XMLPARSER, "Error parsing union case member: Not found.");
  ------------------
  |  |   45|      0|#define EPROSIMA_LOG_ERROR(cat, msg) EPROSIMA_LOG_ERROR_IMPL_(cat, msg)
  |  |  ------------------
  |  |  |  |  291|      0|    do {                                                                                                               \
  |  |  |  |  292|      0|        std::stringstream fastdds_log_ss_tmp__;                                                                        \
  |  |  |  |  293|      0|        fastdds_log_ss_tmp__ << msg;                                                                                   \
  |  |  |  |  294|      0|        eprosima::fastdds::dds::Log::QueueLog(                                                                         \
  |  |  |  |  295|      0|            fastdds_log_ss_tmp__.str(), eprosima::fastdds::dds::Log::Context{__FILE__, __LINE__, __func__, #cat},      \
  |  |  |  |  296|      0|            eprosima::fastdds::dds::Log::Kind::Error);                                                                 \
  |  |  |  |  297|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (297:14): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1156|      0|                        return XMLP_ret::XML_ERROR;
 1157|      0|                    }
 1158|      0|                }
 1159|       |
 1160|      0|                if (false == XMLProfileManager::insertDynamicTypeBuilderByName(name, type_builder))
  ------------------
  |  Branch (1160:21): [True: 0, False: 0]
  ------------------
 1161|      0|                {
 1162|      0|                    ret = XMLP_ret::XML_ERROR;
 1163|      0|                }
 1164|      0|            }
 1165|      0|            else
 1166|      0|            {
 1167|      0|                EPROSIMA_LOG_ERROR(XMLPARSER, "Error creating union type: " << name);
  ------------------
  |  |   45|      0|#define EPROSIMA_LOG_ERROR(cat, msg) EPROSIMA_LOG_ERROR_IMPL_(cat, msg)
  |  |  ------------------
  |  |  |  |  291|      0|    do {                                                                                                               \
  |  |  |  |  292|      0|        std::stringstream fastdds_log_ss_tmp__;                                                                        \
  |  |  |  |  293|      0|        fastdds_log_ss_tmp__ << msg;                                                                                   \
  |  |  |  |  294|      0|        eprosima::fastdds::dds::Log::QueueLog(                                                                         \
  |  |  |  |  295|      0|            fastdds_log_ss_tmp__.str(), eprosima::fastdds::dds::Log::Context{__FILE__, __LINE__, __func__, #cat},      \
  |  |  |  |  296|      0|            eprosima::fastdds::dds::Log::Kind::Error);                                                                 \
  |  |  |  |  297|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (297:14): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1168|      0|                ret = XMLP_ret::XML_ERROR;
 1169|      0|            }
 1170|      0|        }
 1171|      0|    }
 1172|    508|    else
 1173|    508|    {
 1174|    508|        EPROSIMA_LOG_ERROR(XMLPARSER, "Error parsing union discriminator: Not found.");
  ------------------
  |  |   45|    508|#define EPROSIMA_LOG_ERROR(cat, msg) EPROSIMA_LOG_ERROR_IMPL_(cat, msg)
  |  |  ------------------
  |  |  |  |  291|    508|    do {                                                                                                               \
  |  |  |  |  292|    508|        std::stringstream fastdds_log_ss_tmp__;                                                                        \
  |  |  |  |  293|    508|        fastdds_log_ss_tmp__ << msg;                                                                                   \
  |  |  |  |  294|    508|        eprosima::fastdds::dds::Log::QueueLog(                                                                         \
  |  |  |  |  295|    508|            fastdds_log_ss_tmp__.str(), eprosima::fastdds::dds::Log::Context{__FILE__, __LINE__, __func__, #cat},      \
  |  |  |  |  296|    508|            eprosima::fastdds::dds::Log::Kind::Error);                                                                 \
  |  |  |  |  297|    508|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (297:14): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1175|    508|        ret = XMLP_ret::XML_ERROR;
 1176|    508|    }
 1177|       |
 1178|    508|    return ret;
 1179|    508|}
_ZN8eprosima7fastdds9xmlparser9XMLParser25parseXMLMemberDynamicTypeEPN8tinyxml210XMLElementE:
 1222|  56.5k|{
 1223|       |    /*
 1224|       |        <xs:complexType name="memberDcl">
 1225|       |            <xs:attribute name="name" type="string" use="required"/>
 1226|       |            <xs:attribute name="type" type="string" use="required"/>
 1227|       |            <xs:attribute name="arrayDimensions" type="string" use="optional"/>
 1228|       |            <xs:attribute name="nonBasic" type="string" use="optional"/>
 1229|       |            <xs:attribute name="sequenceMaxLength" type="string" use="optional"/>
 1230|       |            <xs:attribute name="mapMaxLength" type="string" use="optional"/>
 1231|       |            <xs:sequence>
 1232|       |                <xs:element name="member" type="memberDcl" minOccurs="0"/>
 1233|       |            </xs:sequence>
 1234|       |        </xs:complexType>
 1235|       |     */
 1236|  56.5k|    if (p_root == nullptr)
  ------------------
  |  Branch (1236:9): [True: 0, False: 56.5k]
  ------------------
 1237|      0|    {
 1238|      0|        EPROSIMA_LOG_ERROR(XMLPARSER, "Error parsing member: Node not found.");
  ------------------
  |  |   45|      0|#define EPROSIMA_LOG_ERROR(cat, msg) EPROSIMA_LOG_ERROR_IMPL_(cat, msg)
  |  |  ------------------
  |  |  |  |  291|      0|    do {                                                                                                               \
  |  |  |  |  292|      0|        std::stringstream fastdds_log_ss_tmp__;                                                                        \
  |  |  |  |  293|      0|        fastdds_log_ss_tmp__ << msg;                                                                                   \
  |  |  |  |  294|      0|        eprosima::fastdds::dds::Log::QueueLog(                                                                         \
  |  |  |  |  295|      0|            fastdds_log_ss_tmp__.str(), eprosima::fastdds::dds::Log::Context{__FILE__, __LINE__, __func__, #cat},      \
  |  |  |  |  296|      0|            eprosima::fastdds::dds::Log::Kind::Error);                                                                 \
  |  |  |  |  297|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (297:14): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1239|      0|        return {};
 1240|      0|    }
 1241|       |
 1242|  56.5k|    const char* memberType = p_root->Attribute(TYPE);
 1243|  56.5k|    const char* memberName = p_root->Attribute(NAME);
 1244|  56.5k|    bool isArray = false;
 1245|       |
 1246|  56.5k|    if (memberName == nullptr)
  ------------------
  |  Branch (1246:9): [True: 1.56k, False: 54.9k]
  ------------------
 1247|  1.56k|    {
 1248|  1.56k|        EPROSIMA_LOG_ERROR(XMLPARSER, "Error parsing member name: Not found.");
  ------------------
  |  |   45|  1.56k|#define EPROSIMA_LOG_ERROR(cat, msg) EPROSIMA_LOG_ERROR_IMPL_(cat, msg)
  |  |  ------------------
  |  |  |  |  291|  1.56k|    do {                                                                                                               \
  |  |  |  |  292|  1.56k|        std::stringstream fastdds_log_ss_tmp__;                                                                        \
  |  |  |  |  293|  1.56k|        fastdds_log_ss_tmp__ << msg;                                                                                   \
  |  |  |  |  294|  1.56k|        eprosima::fastdds::dds::Log::QueueLog(                                                                         \
  |  |  |  |  295|  1.56k|            fastdds_log_ss_tmp__.str(), eprosima::fastdds::dds::Log::Context{__FILE__, __LINE__, __func__, #cat},      \
  |  |  |  |  296|  1.56k|            eprosima::fastdds::dds::Log::Kind::Error);                                                                 \
  |  |  |  |  297|  1.56k|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (297:14): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1249|  1.56k|        return {};
 1250|  1.56k|    }
 1251|       |
 1252|  54.9k|    if (memberType == nullptr)
  ------------------
  |  Branch (1252:9): [True: 0, False: 54.9k]
  ------------------
 1253|      0|    {
 1254|      0|        EPROSIMA_LOG_ERROR(XMLPARSER, "Error parsing member type: Not found.");
  ------------------
  |  |   45|      0|#define EPROSIMA_LOG_ERROR(cat, msg) EPROSIMA_LOG_ERROR_IMPL_(cat, msg)
  |  |  ------------------
  |  |  |  |  291|      0|    do {                                                                                                               \
  |  |  |  |  292|      0|        std::stringstream fastdds_log_ss_tmp__;                                                                        \
  |  |  |  |  293|      0|        fastdds_log_ss_tmp__ << msg;                                                                                   \
  |  |  |  |  294|      0|        eprosima::fastdds::dds::Log::QueueLog(                                                                         \
  |  |  |  |  295|      0|            fastdds_log_ss_tmp__.str(), eprosima::fastdds::dds::Log::Context{__FILE__, __LINE__, __func__, #cat},      \
  |  |  |  |  296|      0|            eprosima::fastdds::dds::Log::Kind::Error);                                                                 \
  |  |  |  |  297|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (297:14): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1255|      0|        return {};
 1256|      0|    }
 1257|       |
 1258|  54.9k|    const char* memberArray = p_root->Attribute(ARRAY_DIMENSIONS);
 1259|  54.9k|    if (memberArray != nullptr)
  ------------------
  |  Branch (1259:9): [True: 45.6k, False: 9.25k]
  ------------------
 1260|  45.6k|    {
 1261|  45.6k|        isArray = true;
 1262|  45.6k|    }
 1263|       |
 1264|  54.9k|    if (strcmp(memberType, NON_BASIC_TYPE) == 0)
  ------------------
  |  Branch (1264:9): [True: 648, False: 54.2k]
  ------------------
 1265|    648|    {
 1266|    648|        const char* memberNonBasicTypeName = p_root->Attribute(NON_BASIC_TYPE_NAME);
 1267|    648|        if (memberNonBasicTypeName != nullptr)
  ------------------
  |  Branch (1267:13): [True: 297, False: 351]
  ------------------
 1268|    297|        {
 1269|    297|            memberType = memberNonBasicTypeName;
 1270|    297|        }
 1271|    351|        else
 1272|    351|        {
 1273|    351|            EPROSIMA_LOG_ERROR(XMLPARSER, "Error parsing member type: Not found.");
  ------------------
  |  |   45|    351|#define EPROSIMA_LOG_ERROR(cat, msg) EPROSIMA_LOG_ERROR_IMPL_(cat, msg)
  |  |  ------------------
  |  |  |  |  291|    351|    do {                                                                                                               \
  |  |  |  |  292|    351|        std::stringstream fastdds_log_ss_tmp__;                                                                        \
  |  |  |  |  293|    351|        fastdds_log_ss_tmp__ << msg;                                                                                   \
  |  |  |  |  294|    351|        eprosima::fastdds::dds::Log::QueueLog(                                                                         \
  |  |  |  |  295|    351|            fastdds_log_ss_tmp__.str(), eprosima::fastdds::dds::Log::Context{__FILE__, __LINE__, __func__, #cat},      \
  |  |  |  |  296|    351|            eprosima::fastdds::dds::Log::Kind::Error);                                                                 \
  |  |  |  |  297|    351|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (297:14): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1274|    351|            return {};
 1275|    351|        }
 1276|    648|    }
 1277|       |
 1278|  54.5k|    DynamicType::_ref_type member;
 1279|  54.5k|    DynamicTypeBuilderFactory::_ref_type factory {DynamicTypeBuilderFactory::get_instance()};
 1280|       |
 1281|  54.5k|    const char* memberSequence = p_root->Attribute(SEQ_MAXLENGTH);
 1282|  54.5k|    if (memberSequence != nullptr)
  ------------------
  |  Branch (1282:9): [True: 9.87k, False: 44.7k]
  ------------------
 1283|  9.87k|    {
 1284|       |        /*
 1285|       |            In sequences allowed formats are (complex format includes the basic):
 1286|       |            sequence<sequence<long,2>,2>
 1287|       |            <sequence name="my_sequence" length="2">
 1288|       |                <sequence name="inner_sequence" type="long" length="2"/>
 1289|       |            </sequence>
 1290|       |            In this example, inner sequence's name is ignored and can be omited.
 1291|       |         */
 1292|  9.87k|        DynamicType::_ref_type content_type {getDiscriminatorTypeBuilder(memberType)};
 1293|  9.87k|        if (!content_type)
  ------------------
  |  Branch (1293:13): [True: 2.04k, False: 7.83k]
  ------------------
 1294|  2.04k|        {
 1295|  2.04k|            EPROSIMA_LOG_ERROR(XMLPARSER, "Error parsing sequence element type: Cannot be recognized: " << memberType);
  ------------------
  |  |   45|  2.04k|#define EPROSIMA_LOG_ERROR(cat, msg) EPROSIMA_LOG_ERROR_IMPL_(cat, msg)
  |  |  ------------------
  |  |  |  |  291|  2.04k|    do {                                                                                                               \
  |  |  |  |  292|  2.04k|        std::stringstream fastdds_log_ss_tmp__;                                                                        \
  |  |  |  |  293|  2.04k|        fastdds_log_ss_tmp__ << msg;                                                                                   \
  |  |  |  |  294|  2.04k|        eprosima::fastdds::dds::Log::QueueLog(                                                                         \
  |  |  |  |  295|  2.04k|            fastdds_log_ss_tmp__.str(), eprosima::fastdds::dds::Log::Context{__FILE__, __LINE__, __func__, #cat},      \
  |  |  |  |  296|  2.04k|            eprosima::fastdds::dds::Log::Kind::Error);                                                                 \
  |  |  |  |  297|  2.04k|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (297:14): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1296|  2.04k|            return {};
 1297|  2.04k|        }
 1298|       |
 1299|  7.83k|        uint32_t length {0};
 1300|  7.83k|        try
 1301|  7.83k|        {
 1302|  7.83k|            length = static_cast<uint32_t>(std::stoul(memberSequence));
 1303|  7.83k|        }
 1304|  7.83k|        catch (const std::exception&)
 1305|  7.83k|        {
 1306|  1.04k|            EPROSIMA_LOG_ERROR(XMLPARSER, "Error parsing member sequence length in line " << p_root->GetLineNum());
  ------------------
  |  |   45|  1.04k|#define EPROSIMA_LOG_ERROR(cat, msg) EPROSIMA_LOG_ERROR_IMPL_(cat, msg)
  |  |  ------------------
  |  |  |  |  291|  1.04k|    do {                                                                                                               \
  |  |  |  |  292|  1.04k|        std::stringstream fastdds_log_ss_tmp__;                                                                        \
  |  |  |  |  293|  1.04k|        fastdds_log_ss_tmp__ << msg;                                                                                   \
  |  |  |  |  294|  1.04k|        eprosima::fastdds::dds::Log::QueueLog(                                                                         \
  |  |  |  |  295|  1.04k|            fastdds_log_ss_tmp__.str(), eprosima::fastdds::dds::Log::Context{__FILE__, __LINE__, __func__, #cat},      \
  |  |  |  |  296|  1.04k|            eprosima::fastdds::dds::Log::Kind::Error);                                                                 \
  |  |  |  |  297|  1.04k|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (297:14): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1307|  1.04k|            return {};
 1308|  1.04k|        }
 1309|       |
 1310|  6.78k|        if (!isArray)
  ------------------
  |  Branch (1310:13): [True: 3.93k, False: 2.84k]
  ------------------
 1311|  3.93k|        {
 1312|  3.93k|            DynamicTypeBuilder::_ref_type inner_builder{factory->create_sequence_type(content_type, length)};
 1313|  3.93k|            if (nullptr != inner_builder)
  ------------------
  |  Branch (1313:17): [True: 3.44k, False: 496]
  ------------------
 1314|  3.44k|            {
 1315|  3.44k|                member = inner_builder->build();
 1316|  3.44k|            }
 1317|    496|            else
 1318|    496|            {
 1319|    496|                EPROSIMA_LOG_ERROR(XMLPARSER,
  ------------------
  |  |   45|    496|#define EPROSIMA_LOG_ERROR(cat, msg) EPROSIMA_LOG_ERROR_IMPL_(cat, msg)
  |  |  ------------------
  |  |  |  |  291|    496|    do {                                                                                                               \
  |  |  |  |  292|    496|        std::stringstream fastdds_log_ss_tmp__;                                                                        \
  |  |  |  |  293|    496|        fastdds_log_ss_tmp__ << msg;                                                                                   \
  |  |  |  |  294|    496|        eprosima::fastdds::dds::Log::QueueLog(                                                                         \
  |  |  |  |  295|    496|            fastdds_log_ss_tmp__.str(), eprosima::fastdds::dds::Log::Context{__FILE__, __LINE__, __func__, #cat},      \
  |  |  |  |  296|    496|            eprosima::fastdds::dds::Log::Kind::Error);                                                                 \
  |  |  |  |  297|    496|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (297:14): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1320|    496|                        "Error parsing sequence element type: Cannot recognize inner content of member: " <<
 1321|    496|                        memberType);
 1322|    496|                return {};
 1323|    496|            }
 1324|  3.93k|        }
 1325|  2.84k|        else
 1326|  2.84k|        {
 1327|  2.84k|            DynamicTypeBuilder::_ref_type inner_builder{factory->create_sequence_type(content_type, length)};
 1328|  2.84k|            if (nullptr != inner_builder)
  ------------------
  |  Branch (1328:17): [True: 1.88k, False: 964]
  ------------------
 1329|  1.88k|            {
 1330|  1.88k|                std::vector<uint32_t> bounds;
 1331|  1.88k|                dimensionsToArrayBounds(memberArray, bounds);
 1332|  1.88k|                DynamicTypeBuilder::_ref_type sub_builder{factory->create_array_type(inner_builder->build(), bounds)};
 1333|  1.88k|                if (nullptr != sub_builder)
  ------------------
  |  Branch (1333:21): [True: 478, False: 1.40k]
  ------------------
 1334|    478|                {
 1335|    478|                    member = sub_builder->build();
 1336|    478|                }
 1337|  1.40k|                else
 1338|  1.40k|                {
 1339|  1.40k|                    EPROSIMA_LOG_ERROR(XMLPARSER,
  ------------------
  |  |   45|  1.40k|#define EPROSIMA_LOG_ERROR(cat, msg) EPROSIMA_LOG_ERROR_IMPL_(cat, msg)
  |  |  ------------------
  |  |  |  |  291|  1.40k|    do {                                                                                                               \
  |  |  |  |  292|  1.40k|        std::stringstream fastdds_log_ss_tmp__;                                                                        \
  |  |  |  |  293|  1.40k|        fastdds_log_ss_tmp__ << msg;                                                                                   \
  |  |  |  |  294|  1.40k|        eprosima::fastdds::dds::Log::QueueLog(                                                                         \
  |  |  |  |  295|  1.40k|            fastdds_log_ss_tmp__.str(), eprosima::fastdds::dds::Log::Context{__FILE__, __LINE__, __func__, #cat},      \
  |  |  |  |  296|  1.40k|            eprosima::fastdds::dds::Log::Kind::Error);                                                                 \
  |  |  |  |  297|  1.40k|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (297:14): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1340|  1.40k|                            "Error parsing sequence element type: Cannot recognize inner content of member: " <<
 1341|  1.40k|                            memberType);
 1342|  1.40k|                    return {};
 1343|  1.40k|                }
 1344|  1.88k|            }
 1345|    964|            else
 1346|    964|            {
 1347|    964|                EPROSIMA_LOG_ERROR(XMLPARSER,
  ------------------
  |  |   45|    964|#define EPROSIMA_LOG_ERROR(cat, msg) EPROSIMA_LOG_ERROR_IMPL_(cat, msg)
  |  |  ------------------
  |  |  |  |  291|    964|    do {                                                                                                               \
  |  |  |  |  292|    964|        std::stringstream fastdds_log_ss_tmp__;                                                                        \
  |  |  |  |  293|    964|        fastdds_log_ss_tmp__ << msg;                                                                                   \
  |  |  |  |  294|    964|        eprosima::fastdds::dds::Log::QueueLog(                                                                         \
  |  |  |  |  295|    964|            fastdds_log_ss_tmp__.str(), eprosima::fastdds::dds::Log::Context{__FILE__, __LINE__, __func__, #cat},      \
  |  |  |  |  296|    964|            eprosima::fastdds::dds::Log::Kind::Error);                                                                 \
  |  |  |  |  297|    964|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (297:14): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1348|    964|                        "Error parsing sequence element type: Cannot recognize inner content of member: " <<
 1349|    964|                        memberType);
 1350|    964|                return {};
 1351|    964|            }
 1352|  2.84k|        }
 1353|  6.78k|    }
 1354|  44.7k|    else if (p_root->Attribute(MAP_MAXLENGTH) != nullptr)
  ------------------
  |  Branch (1354:14): [True: 11.4k, False: 33.2k]
  ------------------
 1355|  11.4k|    {
 1356|       |        /*
 1357|       |            In maps allowed formats are (complex format includes the basic):
 1358|       |            map<map<long, long, 6>, map<long, map<long, short>,2>
 1359|       |            <map name="my_map" length="2">
 1360|       |                <key_type>
 1361|       |                    <map name="inner_key_map" key_type="long" value_type="long" length="6"/>
 1362|       |                </key_type>
 1363|       |                </value_type>
 1364|       |                    <map name="inner_value_map" key_type="long" length="2">
 1365|       |                        </value_type>
 1366|       |                            <map name="inner_value_value_map" key_type="long" value_type="short"/>
 1367|       |                        </value_type>
 1368|       |                    </map>
 1369|       |                </value_type>
 1370|       |            </map>
 1371|       |            In this example, inner maps names are ignored and can be omited.
 1372|       |         */
 1373|       |        // Parse key
 1374|       |
 1375|       |        //const char* keyType = p_root->Attribute(KEY);
 1376|  11.4k|        DynamicType::_ref_type key_type;
 1377|  11.4k|        const char* memberMapKeyType = p_root->Attribute(MAP_KEY_TYPE);
 1378|  11.4k|        if (memberMapKeyType != nullptr)
  ------------------
  |  Branch (1378:13): [True: 11.0k, False: 481]
  ------------------
 1379|  11.0k|        {
 1380|  11.0k|            key_type = getDiscriminatorTypeBuilder(memberMapKeyType);
 1381|  11.0k|            if (!key_type)
  ------------------
  |  Branch (1381:17): [True: 1.24k, False: 9.76k]
  ------------------
 1382|  1.24k|            {
 1383|  1.24k|                EPROSIMA_LOG_ERROR(XMLPARSER, "Error parsing map's key element type: Cannot be recognized.");
  ------------------
  |  |   45|  1.24k|#define EPROSIMA_LOG_ERROR(cat, msg) EPROSIMA_LOG_ERROR_IMPL_(cat, msg)
  |  |  ------------------
  |  |  |  |  291|  1.24k|    do {                                                                                                               \
  |  |  |  |  292|  1.24k|        std::stringstream fastdds_log_ss_tmp__;                                                                        \
  |  |  |  |  293|  1.24k|        fastdds_log_ss_tmp__ << msg;                                                                                   \
  |  |  |  |  294|  1.24k|        eprosima::fastdds::dds::Log::QueueLog(                                                                         \
  |  |  |  |  295|  1.24k|            fastdds_log_ss_tmp__.str(), eprosima::fastdds::dds::Log::Context{__FILE__, __LINE__, __func__, #cat},      \
  |  |  |  |  296|  1.24k|            eprosima::fastdds::dds::Log::Kind::Error);                                                                 \
  |  |  |  |  297|  1.24k|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (297:14): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1384|  1.24k|                return {};
 1385|  1.24k|            }
 1386|  11.0k|        }
 1387|    481|        else
 1388|    481|        {
 1389|    481|            EPROSIMA_LOG_ERROR(XMLPARSER, "Error parsing key_type element: Not found.");
  ------------------
  |  |   45|    481|#define EPROSIMA_LOG_ERROR(cat, msg) EPROSIMA_LOG_ERROR_IMPL_(cat, msg)
  |  |  ------------------
  |  |  |  |  291|    481|    do {                                                                                                               \
  |  |  |  |  292|    481|        std::stringstream fastdds_log_ss_tmp__;                                                                        \
  |  |  |  |  293|    481|        fastdds_log_ss_tmp__ << msg;                                                                                   \
  |  |  |  |  294|    481|        eprosima::fastdds::dds::Log::QueueLog(                                                                         \
  |  |  |  |  295|    481|            fastdds_log_ss_tmp__.str(), eprosima::fastdds::dds::Log::Context{__FILE__, __LINE__, __func__, #cat},      \
  |  |  |  |  296|    481|            eprosima::fastdds::dds::Log::Kind::Error);                                                                 \
  |  |  |  |  297|    481|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (297:14): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1390|    481|            return {};
 1391|    481|        }
 1392|       |
 1393|       |        // Parse value
 1394|  9.76k|        DynamicType::_ref_type value_type;
 1395|  9.76k|        if (memberType != nullptr)
  ------------------
  |  Branch (1395:13): [True: 9.76k, False: 0]
  ------------------
 1396|  9.76k|        {
 1397|  9.76k|            value_type = getDiscriminatorTypeBuilder(memberType);
 1398|  9.76k|            if (!value_type)
  ------------------
  |  Branch (1398:17): [True: 594, False: 9.16k]
  ------------------
 1399|    594|            {
 1400|    594|                EPROSIMA_LOG_ERROR(XMLPARSER, "Error parsing map's value element type: Cannot be recognized.");
  ------------------
  |  |   45|    594|#define EPROSIMA_LOG_ERROR(cat, msg) EPROSIMA_LOG_ERROR_IMPL_(cat, msg)
  |  |  ------------------
  |  |  |  |  291|    594|    do {                                                                                                               \
  |  |  |  |  292|    594|        std::stringstream fastdds_log_ss_tmp__;                                                                        \
  |  |  |  |  293|    594|        fastdds_log_ss_tmp__ << msg;                                                                                   \
  |  |  |  |  294|    594|        eprosima::fastdds::dds::Log::QueueLog(                                                                         \
  |  |  |  |  295|    594|            fastdds_log_ss_tmp__.str(), eprosima::fastdds::dds::Log::Context{__FILE__, __LINE__, __func__, #cat},      \
  |  |  |  |  296|    594|            eprosima::fastdds::dds::Log::Kind::Error);                                                                 \
  |  |  |  |  297|    594|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (297:14): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1401|    594|                return {};
 1402|    594|            }
 1403|  9.76k|        }
 1404|      0|        else
 1405|      0|        {
 1406|      0|            EPROSIMA_LOG_ERROR(XMLPARSER, "Error parsing value_value element: Not found.");
  ------------------
  |  |   45|      0|#define EPROSIMA_LOG_ERROR(cat, msg) EPROSIMA_LOG_ERROR_IMPL_(cat, msg)
  |  |  ------------------
  |  |  |  |  291|      0|    do {                                                                                                               \
  |  |  |  |  292|      0|        std::stringstream fastdds_log_ss_tmp__;                                                                        \
  |  |  |  |  293|      0|        fastdds_log_ss_tmp__ << msg;                                                                                   \
  |  |  |  |  294|      0|        eprosima::fastdds::dds::Log::QueueLog(                                                                         \
  |  |  |  |  295|      0|            fastdds_log_ss_tmp__.str(), eprosima::fastdds::dds::Log::Context{__FILE__, __LINE__, __func__, #cat},      \
  |  |  |  |  296|      0|            eprosima::fastdds::dds::Log::Kind::Error);                                                                 \
  |  |  |  |  297|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (297:14): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1407|      0|            return {};
 1408|      0|        }
 1409|       |
 1410|  9.16k|        const char* lengthStr = p_root->Attribute(MAP_MAXLENGTH);
 1411|  9.16k|        uint32_t length {0};
 1412|  9.16k|        try
 1413|  9.16k|        {
 1414|  9.16k|            length = static_cast<uint32_t>(std::stoul(lengthStr));
 1415|  9.16k|        }
 1416|  9.16k|        catch (const std::exception&)
 1417|  9.16k|        {
 1418|    663|            EPROSIMA_LOG_ERROR(XMLPARSER,
  ------------------
  |  |   45|    663|#define EPROSIMA_LOG_ERROR(cat, msg) EPROSIMA_LOG_ERROR_IMPL_(cat, msg)
  |  |  ------------------
  |  |  |  |  291|    663|    do {                                                                                                               \
  |  |  |  |  292|    663|        std::stringstream fastdds_log_ss_tmp__;                                                                        \
  |  |  |  |  293|    663|        fastdds_log_ss_tmp__ << msg;                                                                                   \
  |  |  |  |  294|    663|        eprosima::fastdds::dds::Log::QueueLog(                                                                         \
  |  |  |  |  295|    663|            fastdds_log_ss_tmp__.str(), eprosima::fastdds::dds::Log::Context{__FILE__, __LINE__, __func__, #cat},      \
  |  |  |  |  296|    663|            eprosima::fastdds::dds::Log::Kind::Error);                                                                 \
  |  |  |  |  297|    663|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (297:14): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1419|    663|                    "Error parsing map member sequence length in line " << p_root->GetLineNum());
 1420|    663|            return {};
 1421|    663|        }
 1422|       |
 1423|  8.50k|        if (!isArray)
  ------------------
  |  Branch (1423:13): [True: 1.93k, False: 6.57k]
  ------------------
 1424|  1.93k|        {
 1425|  1.93k|            auto temp_map = factory->create_map_type(key_type, value_type, length);
 1426|  1.93k|            if (temp_map)
  ------------------
  |  Branch (1426:17): [True: 784, False: 1.14k]
  ------------------
 1427|    784|            {
 1428|    784|                member = temp_map->build();
 1429|    784|            }
 1430|  1.14k|            else
 1431|  1.14k|            {
 1432|  1.14k|                EPROSIMA_LOG_ERROR(XMLPARSER,
  ------------------
  |  |   45|  1.14k|#define EPROSIMA_LOG_ERROR(cat, msg) EPROSIMA_LOG_ERROR_IMPL_(cat, msg)
  |  |  ------------------
  |  |  |  |  291|  1.14k|    do {                                                                                                               \
  |  |  |  |  292|  1.14k|        std::stringstream fastdds_log_ss_tmp__;                                                                        \
  |  |  |  |  293|  1.14k|        fastdds_log_ss_tmp__ << msg;                                                                                   \
  |  |  |  |  294|  1.14k|        eprosima::fastdds::dds::Log::QueueLog(                                                                         \
  |  |  |  |  295|  1.14k|            fastdds_log_ss_tmp__.str(), eprosima::fastdds::dds::Log::Context{__FILE__, __LINE__, __func__, #cat},      \
  |  |  |  |  296|  1.14k|            eprosima::fastdds::dds::Log::Kind::Error);                                                                 \
  |  |  |  |  297|  1.14k|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (297:14): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1433|  1.14k|                        "Error parsing map member with name = " << memberName);
 1434|  1.14k|                return {};
 1435|  1.14k|            }
 1436|  1.93k|        }
 1437|  6.57k|        else
 1438|  6.57k|        {
 1439|  6.57k|            DynamicTypeBuilder::_ref_type inner_builder {factory->create_map_type(key_type, value_type,
 1440|  6.57k|                                                                 length)};
 1441|  6.57k|            if (!inner_builder)
  ------------------
  |  Branch (1441:17): [True: 429, False: 6.14k]
  ------------------
 1442|    429|            {
 1443|    429|                EPROSIMA_LOG_ERROR(XMLPARSER,
  ------------------
  |  |   45|    429|#define EPROSIMA_LOG_ERROR(cat, msg) EPROSIMA_LOG_ERROR_IMPL_(cat, msg)
  |  |  ------------------
  |  |  |  |  291|    429|    do {                                                                                                               \
  |  |  |  |  292|    429|        std::stringstream fastdds_log_ss_tmp__;                                                                        \
  |  |  |  |  293|    429|        fastdds_log_ss_tmp__ << msg;                                                                                   \
  |  |  |  |  294|    429|        eprosima::fastdds::dds::Log::QueueLog(                                                                         \
  |  |  |  |  295|    429|            fastdds_log_ss_tmp__.str(), eprosima::fastdds::dds::Log::Context{__FILE__, __LINE__, __func__, #cat},      \
  |  |  |  |  296|    429|            eprosima::fastdds::dds::Log::Kind::Error);                                                                 \
  |  |  |  |  297|    429|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (297:14): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1444|    429|                        "Error parsing map member type: `create_map_type` failed for key=`" << key_type <<
 1445|    429|                        "`, value=`" << value_type << "`, length=`" << length << "`.");
 1446|    429|                return {};
 1447|    429|            }
 1448|  6.14k|            std::vector<uint32_t> bounds;
 1449|  6.14k|            dimensionsToArrayBounds(memberArray, bounds);
 1450|  6.14k|            DynamicTypeBuilder::_ref_type builder = factory->create_array_type(
 1451|  6.14k|                inner_builder->build(),
 1452|  6.14k|                bounds);
 1453|  6.14k|            member = nullptr;
 1454|  6.14k|            if (nullptr != builder)
  ------------------
  |  Branch (1454:17): [True: 5.38k, False: 756]
  ------------------
 1455|  5.38k|            {
 1456|  5.38k|                member = builder->build();
 1457|  5.38k|            }
 1458|  6.14k|        }
 1459|  8.50k|    }
 1460|  33.2k|    else if (strncmp(memberType, BOOLEAN, BOOLEAN_len) == 0)
  ------------------
  |  Branch (1460:14): [True: 873, False: 32.3k]
  ------------------
 1461|    873|    {
 1462|    873|        if (!isArray)
  ------------------
  |  Branch (1462:13): [True: 0, False: 873]
  ------------------
 1463|      0|        {
 1464|      0|            member = factory->get_primitive_type(TK_BOOLEAN);
 1465|      0|        }
 1466|    873|        else
 1467|    873|        {
 1468|    873|            std::vector<uint32_t> bounds;
 1469|    873|            dimensionsToArrayBounds(memberArray, bounds);
 1470|    873|            DynamicTypeBuilder::_ref_type builder = factory->create_array_type(
 1471|    873|                factory->get_primitive_type(TK_BOOLEAN),
 1472|    873|                bounds);
 1473|    873|            member = nullptr;
 1474|    873|            if (nullptr != builder)
  ------------------
  |  Branch (1474:17): [True: 549, False: 324]
  ------------------
 1475|    549|            {
 1476|    549|                member = builder->build();
 1477|    549|            }
 1478|    873|        }
 1479|    873|    }
 1480|  32.3k|    else if (strncmp(memberType, CHAR, CHAR_len) == 0)
  ------------------
  |  Branch (1480:14): [True: 1.18k, False: 31.1k]
  ------------------
 1481|  1.18k|    {
 1482|  1.18k|        if (!isArray)
  ------------------
  |  Branch (1482:13): [True: 0, False: 1.18k]
  ------------------
 1483|      0|        {
 1484|      0|            member = factory->get_primitive_type(TK_CHAR8);
 1485|      0|        }
 1486|  1.18k|        else
 1487|  1.18k|        {
 1488|  1.18k|            std::vector<uint32_t> bounds;
 1489|  1.18k|            dimensionsToArrayBounds(memberArray, bounds);
 1490|  1.18k|            DynamicTypeBuilder::_ref_type builder = factory->create_array_type(
 1491|  1.18k|                factory->get_primitive_type(TK_CHAR8),
 1492|  1.18k|                bounds);
 1493|  1.18k|            member = nullptr;
 1494|  1.18k|            if (nullptr != builder)
  ------------------
  |  Branch (1494:17): [True: 651, False: 529]
  ------------------
 1495|    651|            {
 1496|    651|                member = builder->build();
 1497|    651|            }
 1498|  1.18k|        }
 1499|  1.18k|    }
 1500|  31.1k|    else if (strncmp(memberType, WCHAR, WCHAR_len) == 0)
  ------------------
  |  Branch (1500:14): [True: 1.05k, False: 30.1k]
  ------------------
 1501|  1.05k|    {
 1502|  1.05k|        if (!isArray)
  ------------------
  |  Branch (1502:13): [True: 0, False: 1.05k]
  ------------------
 1503|      0|        {
 1504|      0|            member = factory->get_primitive_type(TK_CHAR16);
 1505|      0|        }
 1506|  1.05k|        else
 1507|  1.05k|        {
 1508|  1.05k|            std::vector<uint32_t> bounds;
 1509|  1.05k|            dimensionsToArrayBounds(memberArray, bounds);
 1510|  1.05k|            DynamicTypeBuilder::_ref_type builder = factory->create_array_type(
 1511|  1.05k|                factory->get_primitive_type(TK_CHAR16),
 1512|  1.05k|                bounds);
 1513|  1.05k|            member = nullptr;
 1514|  1.05k|            if (nullptr != builder)
  ------------------
  |  Branch (1514:17): [True: 505, False: 546]
  ------------------
 1515|    505|            {
 1516|    505|                member = builder->build();
 1517|    505|            }
 1518|  1.05k|        }
 1519|  1.05k|    }
 1520|  30.1k|    else if (strncmp(memberType, TBYTE, TBYTE_len) == 0
  ------------------
  |  Branch (1520:14): [True: 6.16k, False: 23.9k]
  ------------------
 1521|  30.1k|            || strncmp(memberType, OCTET, OCTET_len) == 0)
  ------------------
  |  Branch (1521:16): [True: 321, False: 23.6k]
  ------------------
 1522|  6.48k|    {
 1523|  6.48k|        if (!isArray)
  ------------------
  |  Branch (1523:13): [True: 0, False: 6.48k]
  ------------------
 1524|      0|        {
 1525|      0|            member = factory->get_primitive_type(TK_BYTE);
 1526|      0|        }
 1527|  6.48k|        else
 1528|  6.48k|        {
 1529|  6.48k|            std::vector<uint32_t> bounds;
 1530|  6.48k|            dimensionsToArrayBounds(memberArray, bounds);
 1531|  6.48k|            DynamicTypeBuilder::_ref_type builder = factory->create_array_type(
 1532|  6.48k|                factory->get_primitive_type(TK_BYTE),
 1533|  6.48k|                bounds);
 1534|  6.48k|            member = nullptr;
 1535|  6.48k|            if (nullptr != builder)
  ------------------
  |  Branch (1535:17): [True: 4.76k, False: 1.72k]
  ------------------
 1536|  4.76k|            {
 1537|  4.76k|                member = builder->build();
 1538|  4.76k|            }
 1539|  6.48k|        }
 1540|  6.48k|    }
 1541|  23.6k|    else if (strncmp(memberType, UINT8, UINT8_len) == 0)
  ------------------
  |  Branch (1541:14): [True: 1.13k, False: 22.5k]
  ------------------
 1542|  1.13k|    {
 1543|  1.13k|        if (!isArray)
  ------------------
  |  Branch (1543:13): [True: 0, False: 1.13k]
  ------------------
 1544|      0|        {
 1545|      0|            member = factory->get_primitive_type(TK_UINT8);
 1546|      0|        }
 1547|  1.13k|        else
 1548|  1.13k|        {
 1549|  1.13k|            std::vector<uint32_t> bounds;
 1550|  1.13k|            dimensionsToArrayBounds(memberArray, bounds);
 1551|  1.13k|            DynamicTypeBuilder::_ref_type builder = factory->create_array_type(
 1552|  1.13k|                factory->get_primitive_type(TK_UINT8),
 1553|  1.13k|                bounds);
 1554|       |
 1555|  1.13k|            member = nullptr;
 1556|  1.13k|            if (nullptr != builder)
  ------------------
  |  Branch (1556:17): [True: 643, False: 487]
  ------------------
 1557|    643|            {
 1558|    643|                member = builder->build();
 1559|    643|            }
 1560|  1.13k|        }
 1561|  1.13k|    }
 1562|  22.5k|    else if (strncmp(memberType, INT8, INT8_len) == 0)
  ------------------
  |  Branch (1562:14): [True: 879, False: 21.6k]
  ------------------
 1563|    879|    {
 1564|    879|        if (!isArray)
  ------------------
  |  Branch (1564:13): [True: 0, False: 879]
  ------------------
 1565|      0|        {
 1566|      0|            member = factory->get_primitive_type(TK_INT8);
 1567|      0|        }
 1568|    879|        else
 1569|    879|        {
 1570|    879|            std::vector<uint32_t> bounds;
 1571|    879|            dimensionsToArrayBounds(memberArray, bounds);
 1572|    879|            DynamicTypeBuilder::_ref_type builder = factory->create_array_type(
 1573|    879|                factory->get_primitive_type(TK_INT8),
 1574|    879|                bounds);
 1575|       |
 1576|    879|            member = nullptr;
 1577|    879|            if (nullptr != builder)
  ------------------
  |  Branch (1577:17): [True: 657, False: 222]
  ------------------
 1578|    657|            {
 1579|    657|                member = builder->build();
 1580|    657|            }
 1581|    879|        }
 1582|    879|    }
 1583|  21.6k|    else if (strncmp(memberType, SHORT, SHORT_len) == 0)
  ------------------
  |  Branch (1583:14): [True: 954, False: 20.6k]
  ------------------
 1584|    954|    {
 1585|    954|        if (!isArray)
  ------------------
  |  Branch (1585:13): [True: 0, False: 954]
  ------------------
 1586|      0|        {
 1587|      0|            member = factory->get_primitive_type(TK_INT16);
 1588|      0|        }
 1589|    954|        else
 1590|    954|        {
 1591|    954|            std::vector<uint32_t> bounds;
 1592|    954|            dimensionsToArrayBounds(memberArray, bounds);
 1593|    954|            DynamicTypeBuilder::_ref_type builder = factory->create_array_type(
 1594|    954|                factory->get_primitive_type(TK_INT16),
 1595|    954|                bounds);
 1596|       |
 1597|    954|            member = nullptr;
 1598|    954|            if (nullptr != builder)
  ------------------
  |  Branch (1598:17): [True: 553, False: 401]
  ------------------
 1599|    553|            {
 1600|    553|                member = builder->build();
 1601|    553|            }
 1602|    954|        }
 1603|    954|    }
 1604|  20.6k|    else if (strncmp(memberType, LONG, LONG_len) == 0)
  ------------------
  |  Branch (1604:14): [True: 1.21k, False: 19.4k]
  ------------------
 1605|  1.21k|    {
 1606|  1.21k|        if (!isArray)
  ------------------
  |  Branch (1606:13): [True: 0, False: 1.21k]
  ------------------
 1607|      0|        {
 1608|      0|            member = factory->get_primitive_type(TK_INT32);
 1609|      0|        }
 1610|  1.21k|        else
 1611|  1.21k|        {
 1612|  1.21k|            std::vector<uint32_t> bounds;
 1613|  1.21k|            dimensionsToArrayBounds(memberArray, bounds);
 1614|  1.21k|            DynamicTypeBuilder::_ref_type builder = factory->create_array_type(
 1615|  1.21k|                factory->get_primitive_type(TK_INT32),
 1616|  1.21k|                bounds);
 1617|       |
 1618|  1.21k|            member = nullptr;
 1619|  1.21k|            if (nullptr != builder)
  ------------------
  |  Branch (1619:17): [True: 906, False: 307]
  ------------------
 1620|    906|            {
 1621|    906|                member = builder->build();
 1622|    906|            }
 1623|  1.21k|        }
 1624|  1.21k|    }
 1625|  19.4k|    else if (strncmp(memberType, ULONG, ULONG_len) == 0)
  ------------------
  |  Branch (1625:14): [True: 1.87k, False: 17.5k]
  ------------------
 1626|  1.87k|    {
 1627|  1.87k|        if (!isArray)
  ------------------
  |  Branch (1627:13): [True: 0, False: 1.87k]
  ------------------
 1628|      0|        {
 1629|      0|            member = factory->get_primitive_type(TK_UINT32);
 1630|      0|        }
 1631|  1.87k|        else
 1632|  1.87k|        {
 1633|  1.87k|            std::vector<uint32_t> bounds;
 1634|  1.87k|            dimensionsToArrayBounds(memberArray, bounds);
 1635|  1.87k|            DynamicTypeBuilder::_ref_type builder = factory->create_array_type(
 1636|  1.87k|                factory->get_primitive_type(TK_UINT32),
 1637|  1.87k|                bounds);
 1638|       |
 1639|  1.87k|            member = nullptr;
 1640|  1.87k|            if (nullptr != builder)
  ------------------
  |  Branch (1640:17): [True: 1.23k, False: 638]
  ------------------
 1641|  1.23k|            {
 1642|  1.23k|                member = builder->build();
 1643|  1.23k|            }
 1644|  1.87k|        }
 1645|  1.87k|    }
 1646|  17.5k|    else if (strncmp(memberType, USHORT, USHORT_len) == 0)
  ------------------
  |  Branch (1646:14): [True: 1.92k, False: 15.6k]
  ------------------
 1647|  1.92k|    {
 1648|  1.92k|        if (!isArray)
  ------------------
  |  Branch (1648:13): [True: 0, False: 1.92k]
  ------------------
 1649|      0|        {
 1650|      0|            member = factory->get_primitive_type(TK_UINT16);
 1651|      0|        }
 1652|  1.92k|        else
 1653|  1.92k|        {
 1654|  1.92k|            std::vector<uint32_t> bounds;
 1655|  1.92k|            dimensionsToArrayBounds(memberArray, bounds);
 1656|  1.92k|            DynamicTypeBuilder::_ref_type builder = factory->create_array_type(
 1657|  1.92k|                factory->get_primitive_type(TK_UINT16),
 1658|  1.92k|                bounds);
 1659|       |
 1660|  1.92k|            member = nullptr;
 1661|  1.92k|            if (nullptr != builder)
  ------------------
  |  Branch (1661:17): [True: 1.34k, False: 588]
  ------------------
 1662|  1.34k|            {
 1663|  1.34k|                member = builder->build();
 1664|  1.34k|            }
 1665|  1.92k|        }
 1666|  1.92k|    }
 1667|  15.6k|    else if (strncmp(memberType, LONGLONG, LONGLONG_len) == 0)
  ------------------
  |  Branch (1667:14): [True: 742, False: 14.9k]
  ------------------
 1668|    742|    {
 1669|    742|        if (!isArray)
  ------------------
  |  Branch (1669:13): [True: 0, False: 742]
  ------------------
 1670|      0|        {
 1671|      0|            member = factory->get_primitive_type(TK_INT64);
 1672|      0|        }
 1673|    742|        else
 1674|    742|        {
 1675|    742|            std::vector<uint32_t> bounds;
 1676|    742|            dimensionsToArrayBounds(memberArray, bounds);
 1677|    742|            DynamicTypeBuilder::_ref_type builder = factory->create_array_type(
 1678|    742|                factory->get_primitive_type(TK_INT64),
 1679|    742|                bounds);
 1680|       |
 1681|    742|            member = nullptr;
 1682|    742|            if (nullptr != builder)
  ------------------
  |  Branch (1682:17): [True: 507, False: 235]
  ------------------
 1683|    507|            {
 1684|    507|                member = builder->build();
 1685|    507|            }
 1686|    742|        }
 1687|    742|    }
 1688|  14.9k|    else if (strncmp(memberType, ULONGLONG, ULONGLONG_len) == 0)
  ------------------
  |  Branch (1688:14): [True: 1.28k, False: 13.6k]
  ------------------
 1689|  1.28k|    {
 1690|  1.28k|        if (!isArray)
  ------------------
  |  Branch (1690:13): [True: 0, False: 1.28k]
  ------------------
 1691|      0|        {
 1692|      0|            member = factory->get_primitive_type(TK_UINT64);
 1693|      0|        }
 1694|  1.28k|        else
 1695|  1.28k|        {
 1696|  1.28k|            std::vector<uint32_t> bounds;
 1697|  1.28k|            dimensionsToArrayBounds(memberArray, bounds);
 1698|  1.28k|            DynamicTypeBuilder::_ref_type builder = factory->create_array_type(
 1699|  1.28k|                factory->get_primitive_type(TK_UINT64),
 1700|  1.28k|                bounds);
 1701|       |
 1702|  1.28k|            if (nullptr != builder)
  ------------------
  |  Branch (1702:17): [True: 842, False: 439]
  ------------------
 1703|    842|            {
 1704|    842|                member = builder->build();
 1705|    842|            }
 1706|    439|            else
 1707|    439|            {
 1708|    439|                member = nullptr;
 1709|    439|            }
 1710|  1.28k|        }
 1711|  1.28k|    }
 1712|  13.6k|    else if (strncmp(memberType, FLOAT, FLOAT_len) == 0)
  ------------------
  |  Branch (1712:14): [True: 1.33k, False: 12.2k]
  ------------------
 1713|  1.33k|    {
 1714|  1.33k|        if (!isArray)
  ------------------
  |  Branch (1714:13): [True: 0, False: 1.33k]
  ------------------
 1715|      0|        {
 1716|      0|            member = factory->get_primitive_type(TK_FLOAT32);
 1717|      0|        }
 1718|  1.33k|        else
 1719|  1.33k|        {
 1720|  1.33k|            std::vector<uint32_t> bounds;
 1721|  1.33k|            dimensionsToArrayBounds(memberArray, bounds);
 1722|  1.33k|            DynamicTypeBuilder::_ref_type builder = factory->create_array_type(
 1723|  1.33k|                factory->get_primitive_type(TK_FLOAT32),
 1724|  1.33k|                bounds);
 1725|       |
 1726|  1.33k|            member = nullptr;
 1727|  1.33k|            if (nullptr != builder)
  ------------------
  |  Branch (1727:17): [True: 348, False: 984]
  ------------------
 1728|    348|            {
 1729|    348|                member = builder->build();
 1730|    348|            }
 1731|  1.33k|        }
 1732|  1.33k|    }
 1733|  12.2k|    else if (strncmp(memberType, DOUBLE, DOUBLE_len) == 0)
  ------------------
  |  Branch (1733:14): [True: 1.66k, False: 10.6k]
  ------------------
 1734|  1.66k|    {
 1735|  1.66k|        if (!isArray)
  ------------------
  |  Branch (1735:13): [True: 0, False: 1.66k]
  ------------------
 1736|      0|        {
 1737|      0|            member = factory->get_primitive_type(TK_FLOAT64);
 1738|      0|        }
 1739|  1.66k|        else
 1740|  1.66k|        {
 1741|  1.66k|            std::vector<uint32_t> bounds;
 1742|  1.66k|            dimensionsToArrayBounds(memberArray, bounds);
 1743|  1.66k|            DynamicTypeBuilder::_ref_type builder = factory->create_array_type(
 1744|  1.66k|                factory->get_primitive_type(TK_FLOAT64),
 1745|  1.66k|                bounds);
 1746|       |
 1747|  1.66k|            member = nullptr;
 1748|  1.66k|            if (nullptr != builder)
  ------------------
  |  Branch (1748:17): [True: 1.26k, False: 403]
  ------------------
 1749|  1.26k|            {
 1750|  1.26k|                member = builder->build();
 1751|  1.26k|            }
 1752|  1.66k|        }
 1753|  1.66k|    }
 1754|  10.6k|    else if (strncmp(memberType, LONGDOUBLE, LONGDOUBLE_len) == 0)
  ------------------
  |  Branch (1754:14): [True: 1.38k, False: 9.23k]
  ------------------
 1755|  1.38k|    {
 1756|  1.38k|        if (!isArray)
  ------------------
  |  Branch (1756:13): [True: 0, False: 1.38k]
  ------------------
 1757|      0|        {
 1758|      0|            member = factory->get_primitive_type(TK_FLOAT128);
 1759|      0|        }
 1760|  1.38k|        else
 1761|  1.38k|        {
 1762|  1.38k|            std::vector<uint32_t> bounds;
 1763|  1.38k|            dimensionsToArrayBounds(memberArray, bounds);
 1764|  1.38k|            DynamicTypeBuilder::_ref_type builder = factory->create_array_type(
 1765|  1.38k|                factory->get_primitive_type(TK_FLOAT128),
 1766|  1.38k|                bounds);
 1767|       |
 1768|  1.38k|            member = nullptr;
 1769|  1.38k|            if (nullptr != builder)
  ------------------
  |  Branch (1769:17): [True: 822, False: 567]
  ------------------
 1770|    822|            {
 1771|    822|                member = builder->build();
 1772|    822|            }
 1773|  1.38k|        }
 1774|  1.38k|    }
 1775|  9.23k|    else if (strncmp(memberType, STRING, STRING_len) == 0)
  ------------------
  |  Branch (1775:14): [True: 2.25k, False: 6.98k]
  ------------------
 1776|  2.25k|    {
 1777|  2.25k|        const char* boundStr = p_root->Attribute(STR_MAXLENGTH);
 1778|  2.25k|        uint32_t bound = static_cast<uint32_t>(LENGTH_UNLIMITED);
 1779|       |
 1780|  2.25k|        if (nullptr != boundStr)
  ------------------
  |  Branch (1780:13): [True: 623, False: 1.63k]
  ------------------
 1781|    623|        {
 1782|    623|            try
 1783|    623|            {
 1784|    623|                bound = static_cast<uint32_t>(std::stoul(boundStr));
 1785|    623|            }
 1786|    623|            catch (const std::exception&)
 1787|    623|            {
 1788|    450|                EPROSIMA_LOG_ERROR(XMLPARSER,
  ------------------
  |  |   45|    450|#define EPROSIMA_LOG_ERROR(cat, msg) EPROSIMA_LOG_ERROR_IMPL_(cat, msg)
  |  |  ------------------
  |  |  |  |  291|    450|    do {                                                                                                               \
  |  |  |  |  292|    450|        std::stringstream fastdds_log_ss_tmp__;                                                                        \
  |  |  |  |  293|    450|        fastdds_log_ss_tmp__ << msg;                                                                                   \
  |  |  |  |  294|    450|        eprosima::fastdds::dds::Log::QueueLog(                                                                         \
  |  |  |  |  295|    450|            fastdds_log_ss_tmp__.str(), eprosima::fastdds::dds::Log::Context{__FILE__, __LINE__, __func__, #cat},      \
  |  |  |  |  296|    450|            eprosima::fastdds::dds::Log::Kind::Error);                                                                 \
  |  |  |  |  297|    450|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (297:14): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1789|    450|                        "Error parsing alias type bound: '" << STR_MAXLENGTH << "' out of bounds.");
 1790|    450|                return {};
 1791|    450|            }
 1792|    623|        }
 1793|       |
 1794|  1.80k|        DynamicTypeBuilder::_ref_type string_builder = factory->create_string_type(bound);
 1795|       |
 1796|  1.80k|        if (nullptr == string_builder)
  ------------------
  |  Branch (1796:13): [True: 29, False: 1.77k]
  ------------------
 1797|     29|        {
 1798|     29|            EPROSIMA_LOG_ERROR(XMLPARSER,
  ------------------
  |  |   45|     29|#define EPROSIMA_LOG_ERROR(cat, msg) EPROSIMA_LOG_ERROR_IMPL_(cat, msg)
  |  |  ------------------
  |  |  |  |  291|     29|    do {                                                                                                               \
  |  |  |  |  292|     29|        std::stringstream fastdds_log_ss_tmp__;                                                                        \
  |  |  |  |  293|     29|        fastdds_log_ss_tmp__ << msg;                                                                                   \
  |  |  |  |  294|     29|        eprosima::fastdds::dds::Log::QueueLog(                                                                         \
  |  |  |  |  295|     29|            fastdds_log_ss_tmp__.str(), eprosima::fastdds::dds::Log::Context{__FILE__, __LINE__, __func__, #cat},      \
  |  |  |  |  296|     29|            eprosima::fastdds::dds::Log::Kind::Error);                                                                 \
  |  |  |  |  297|     29|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (297:14): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1799|     29|                    "Error creating string type: " << memberType);
 1800|     29|            return {};
 1801|     29|        }
 1802|       |
 1803|  1.77k|        if (!isArray)
  ------------------
  |  Branch (1803:13): [True: 0, False: 1.77k]
  ------------------
 1804|      0|        {
 1805|      0|            member = string_builder->build();
 1806|      0|        }
 1807|  1.77k|        else
 1808|  1.77k|        {
 1809|  1.77k|            std::vector<uint32_t> boundsArray;
 1810|  1.77k|            dimensionsToArrayBounds(memberArray, boundsArray);
 1811|  1.77k|            DynamicTypeBuilder::_ref_type builder_ = factory->create_array_type(string_builder->build(), boundsArray);
 1812|  1.77k|            if (nullptr != builder_)
  ------------------
  |  Branch (1812:17): [True: 1.43k, False: 343]
  ------------------
 1813|  1.43k|            {
 1814|  1.43k|                member = builder_->build();
 1815|  1.43k|            }
 1816|    343|            else
 1817|    343|            {
 1818|    343|                member = nullptr;
 1819|    343|            }
 1820|  1.77k|        }
 1821|  1.77k|    }
 1822|  6.98k|    else if (strncmp(memberType, WSTRING, WSTRING_len) == 0)
  ------------------
  |  Branch (1822:14): [True: 3.14k, False: 3.83k]
  ------------------
 1823|  3.14k|    {
 1824|  3.14k|        const char* boundStr = p_root->Attribute(STR_MAXLENGTH);
 1825|  3.14k|        uint32_t bound = static_cast<uint32_t>(LENGTH_UNLIMITED);
 1826|       |
 1827|  3.14k|        if (nullptr != boundStr)
  ------------------
  |  Branch (1827:13): [True: 2.17k, False: 975]
  ------------------
 1828|  2.17k|        {
 1829|  2.17k|            try
 1830|  2.17k|            {
 1831|  2.17k|                bound = static_cast<uint32_t>(std::stoul(boundStr));
 1832|  2.17k|            }
 1833|  2.17k|            catch (const std::exception&)
 1834|  2.17k|            {
 1835|    764|                EPROSIMA_LOG_ERROR(XMLPARSER,
  ------------------
  |  |   45|    764|#define EPROSIMA_LOG_ERROR(cat, msg) EPROSIMA_LOG_ERROR_IMPL_(cat, msg)
  |  |  ------------------
  |  |  |  |  291|    764|    do {                                                                                                               \
  |  |  |  |  292|    764|        std::stringstream fastdds_log_ss_tmp__;                                                                        \
  |  |  |  |  293|    764|        fastdds_log_ss_tmp__ << msg;                                                                                   \
  |  |  |  |  294|    764|        eprosima::fastdds::dds::Log::QueueLog(                                                                         \
  |  |  |  |  295|    764|            fastdds_log_ss_tmp__.str(), eprosima::fastdds::dds::Log::Context{__FILE__, __LINE__, __func__, #cat},      \
  |  |  |  |  296|    764|            eprosima::fastdds::dds::Log::Kind::Error);                                                                 \
  |  |  |  |  297|    764|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (297:14): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1836|    764|                        "Error parsing alias type bound: '" << STR_MAXLENGTH << "' out of bounds.");
 1837|    764|                return {};
 1838|    764|            }
 1839|  2.17k|        }
 1840|       |
 1841|  2.38k|        DynamicTypeBuilder::_ref_type wstring_builder = factory->create_wstring_type(bound);
 1842|       |
 1843|  2.38k|        if (nullptr == wstring_builder)
  ------------------
  |  Branch (1843:13): [True: 517, False: 1.86k]
  ------------------
 1844|    517|        {
 1845|    517|            EPROSIMA_LOG_ERROR(XMLPARSER,
  ------------------
  |  |   45|    517|#define EPROSIMA_LOG_ERROR(cat, msg) EPROSIMA_LOG_ERROR_IMPL_(cat, msg)
  |  |  ------------------
  |  |  |  |  291|    517|    do {                                                                                                               \
  |  |  |  |  292|    517|        std::stringstream fastdds_log_ss_tmp__;                                                                        \
  |  |  |  |  293|    517|        fastdds_log_ss_tmp__ << msg;                                                                                   \
  |  |  |  |  294|    517|        eprosima::fastdds::dds::Log::QueueLog(                                                                         \
  |  |  |  |  295|    517|            fastdds_log_ss_tmp__.str(), eprosima::fastdds::dds::Log::Context{__FILE__, __LINE__, __func__, #cat},      \
  |  |  |  |  296|    517|            eprosima::fastdds::dds::Log::Kind::Error);                                                                 \
  |  |  |  |  297|    517|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (297:14): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1846|    517|                    "Error creating wstring type: " << memberType);
 1847|    517|            return {};
 1848|    517|        }
 1849|       |
 1850|  1.86k|        if (!isArray)
  ------------------
  |  Branch (1850:13): [True: 0, False: 1.86k]
  ------------------
 1851|      0|        {
 1852|      0|            member = wstring_builder->build();
 1853|      0|        }
 1854|  1.86k|        else
 1855|  1.86k|        {
 1856|  1.86k|            std::vector<uint32_t> boundsArray;
 1857|  1.86k|            dimensionsToArrayBounds(memberArray, boundsArray);
 1858|  1.86k|            DynamicTypeBuilder::_ref_type builder = factory->create_array_type(
 1859|  1.86k|                wstring_builder->build(),
 1860|  1.86k|                boundsArray);
 1861|  1.86k|            member = nullptr;
 1862|  1.86k|            if (nullptr != builder)
  ------------------
  |  Branch (1862:17): [True: 1.09k, False: 774]
  ------------------
 1863|  1.09k|            {
 1864|  1.09k|                member = builder->build();
 1865|  1.09k|            }
 1866|  1.86k|        }
 1867|  1.86k|    }
 1868|  3.83k|    else // Complex type?
 1869|  3.83k|    {
 1870|  3.83k|        DynamicTypeBuilder::_ref_type type_builder;
 1871|  3.83k|        XMLProfileManager::getDynamicTypeBuilderByName(type_builder, memberType);
 1872|  3.83k|        DynamicType::_ref_type type;
 1873|  3.83k|        if (nullptr != type_builder)
  ------------------
  |  Branch (1873:13): [True: 815, False: 3.02k]
  ------------------
 1874|    815|        {
 1875|    815|            type = type_builder->build();
 1876|    815|        }
 1877|  3.02k|        else
 1878|  3.02k|        {
 1879|  3.02k|            type = nullptr;
 1880|  3.02k|        }
 1881|       |
 1882|  3.83k|        if (!isArray)
  ------------------
  |  Branch (1882:13): [True: 0, False: 3.83k]
  ------------------
 1883|      0|        {
 1884|      0|            member = type;
 1885|      0|        }
 1886|  3.83k|        else if (type)
  ------------------
  |  Branch (1886:18): [True: 815, False: 3.02k]
  ------------------
 1887|    815|        {
 1888|    815|            std::vector<uint32_t> bounds;
 1889|    815|            dimensionsToArrayBounds(memberArray, bounds);
 1890|    815|            DynamicTypeBuilder::_ref_type builder = factory->create_array_type(
 1891|    815|                type,
 1892|    815|                bounds);
 1893|    815|            member = nullptr;
 1894|    815|            if (nullptr != builder)
  ------------------
  |  Branch (1894:17): [True: 673, False: 142]
  ------------------
 1895|    673|            {
 1896|    673|                member = builder->build();
 1897|    673|            }
 1898|    815|        }
 1899|  3.83k|    }
 1900|       |
 1901|  42.3k|    if (!member)
  ------------------
  |  Branch (1901:9): [True: 13.4k, False: 28.8k]
  ------------------
 1902|  13.4k|    {
 1903|  13.4k|        if (!isArray)
  ------------------
  |  Branch (1903:13): [True: 0, False: 13.4k]
  ------------------
 1904|      0|        {
 1905|      0|            EPROSIMA_LOG_ERROR(XMLPARSER, "Failed creating " << memberType << ": " << (memberName ? memberName : ""));
  ------------------
  |  |   45|      0|#define EPROSIMA_LOG_ERROR(cat, msg) EPROSIMA_LOG_ERROR_IMPL_(cat, msg)
  |  |  ------------------
  |  |  |  |  291|      0|    do {                                                                                                               \
  |  |  |  |  292|      0|        std::stringstream fastdds_log_ss_tmp__;                                                                        \
  |  |  |  |  293|      0|        fastdds_log_ss_tmp__ << msg;                                                                                   \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (293:33): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  |  |  294|      0|        eprosima::fastdds::dds::Log::QueueLog(                                                                         \
  |  |  |  |  295|      0|            fastdds_log_ss_tmp__.str(), eprosima::fastdds::dds::Log::Context{__FILE__, __LINE__, __func__, #cat},      \
  |  |  |  |  296|      0|            eprosima::fastdds::dds::Log::Kind::Error);                                                                 \
  |  |  |  |  297|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (297:14): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1906|      0|        }
 1907|  13.4k|        else
 1908|  13.4k|        {
 1909|  13.4k|            EPROSIMA_LOG_ERROR(XMLPARSER,
  ------------------
  |  |   45|  13.4k|#define EPROSIMA_LOG_ERROR(cat, msg) EPROSIMA_LOG_ERROR_IMPL_(cat, msg)
  |  |  ------------------
  |  |  |  |  291|  13.4k|    do {                                                                                                               \
  |  |  |  |  292|  13.4k|        std::stringstream fastdds_log_ss_tmp__;                                                                        \
  |  |  |  |  293|  26.8k|        fastdds_log_ss_tmp__ << msg;                                                                                   \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (293:33): [True: 13.4k, False: 0]
  |  |  |  |  ------------------
  |  |  |  |  294|  13.4k|        eprosima::fastdds::dds::Log::QueueLog(                                                                         \
  |  |  |  |  295|  13.4k|            fastdds_log_ss_tmp__.str(), eprosima::fastdds::dds::Log::Context{__FILE__, __LINE__, __func__, #cat},      \
  |  |  |  |  296|  13.4k|            eprosima::fastdds::dds::Log::Kind::Error);                                                                 \
  |  |  |  |  297|  13.4k|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (297:14): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1910|  13.4k|                    "Failed creating " << memberType << " array: " << (memberName ? memberName : ""));
 1911|  13.4k|        }
 1912|  13.4k|        return {};
 1913|  13.4k|    }
 1914|       |
 1915|  28.8k|    return member;
 1916|  42.3k|}
_ZN8eprosima7fastdds9xmlparser9XMLParser17parseDynamicTypesEPN8tinyxml210XMLElementE:
 1980|  1.33k|{
 1981|  1.33k|    return parseXMLTypes(p_root);
 1982|  1.33k|}
XMLDynamicParser.cpp:_ZL27getDiscriminatorTypeBuilderRKNSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEEj:
  304|  52.3k|{
  305|       |    /*
  306|       |       mKind == TK_BOOLEAN || mKind == TK_BYTE || mKind == TK_INT16 || mKind == TK_INT32 ||
  307|       |        mKind == TK_INT64 || mKind == TK_UINT16 || mKind == TK_UINT32 || mKind == TK_UINT64 ||
  308|       |        mKind == TK_FLOAT32 || mKind == TK_FLOAT64 || mKind == TK_FLOAT128 || mKind == TK_CHAR8 ||
  309|       |        mKind == TK_CHAR16 || mKind == TK_STRING8 || mKind == TK_STRING16 || mKind == TK_ENUM || mKind == TK_BITMASK
  310|       |     */
  311|  52.3k|    auto factory = DynamicTypeBuilderFactory::get_instance();
  312|  52.3k|    if (0 == disc.compare(BOOLEAN))
  ------------------
  |  Branch (312:9): [True: 874, False: 51.4k]
  ------------------
  313|    874|    {
  314|    874|        return factory->get_primitive_type(TK_BOOLEAN);
  315|    874|    }
  316|  51.4k|    else if (0 == disc.compare(TBYTE) ||
  ------------------
  |  Branch (316:14): [True: 4.36k, False: 47.0k]
  ------------------
  317|  51.4k|            0 == disc.compare(OCTET))
  ------------------
  |  Branch (317:13): [True: 5.80k, False: 41.2k]
  ------------------
  318|  10.1k|    {
  319|  10.1k|        return factory->get_primitive_type(TK_BYTE);
  320|  10.1k|    }
  321|  41.2k|    else if (0 == disc.compare(INT8))
  ------------------
  |  Branch (321:14): [True: 559, False: 40.7k]
  ------------------
  322|    559|    {
  323|    559|        return factory->get_primitive_type(TK_INT8);
  324|    559|    }
  325|  40.7k|    else if (0 == disc.compare(UINT8))
  ------------------
  |  Branch (325:14): [True: 608, False: 40.1k]
  ------------------
  326|    608|    {
  327|    608|        return factory->get_primitive_type(TK_UINT8);
  328|    608|    }
  329|  40.1k|    else if (0 == disc.compare(SHORT))
  ------------------
  |  Branch (329:14): [True: 658, False: 39.4k]
  ------------------
  330|    658|    {
  331|    658|        return factory->get_primitive_type(TK_INT16);
  332|    658|    }
  333|  39.4k|    else if (0 == disc.compare(LONG))
  ------------------
  |  Branch (333:14): [True: 1.59k, False: 37.8k]
  ------------------
  334|  1.59k|    {
  335|  1.59k|        return factory->get_primitive_type(TK_INT32);
  336|  1.59k|    }
  337|  37.8k|    else if (0 == disc.compare(LONGLONG))
  ------------------
  |  Branch (337:14): [True: 569, False: 37.2k]
  ------------------
  338|    569|    {
  339|    569|        return factory->get_primitive_type(TK_INT64);
  340|    569|    }
  341|  37.2k|    else if (0 == disc.compare(USHORT))
  ------------------
  |  Branch (341:14): [True: 2.65k, False: 34.6k]
  ------------------
  342|  2.65k|    {
  343|  2.65k|        return factory->get_primitive_type(TK_UINT16);
  344|  2.65k|    }
  345|  34.6k|    else if (0 == disc.compare(ULONG))
  ------------------
  |  Branch (345:14): [True: 5.69k, False: 28.9k]
  ------------------
  346|  5.69k|    {
  347|  5.69k|        return factory->get_primitive_type(TK_UINT32);
  348|  5.69k|    }
  349|  28.9k|    else if (0 == disc.compare(ULONGLONG))
  ------------------
  |  Branch (349:14): [True: 1.19k, False: 27.7k]
  ------------------
  350|  1.19k|    {
  351|  1.19k|        return factory->get_primitive_type(TK_UINT64);
  352|  1.19k|    }
  353|  27.7k|    else if (0 == disc.compare(FLOAT))
  ------------------
  |  Branch (353:14): [True: 414, False: 27.3k]
  ------------------
  354|    414|    {
  355|    414|        return factory->get_primitive_type(TK_FLOAT32);
  356|    414|    }
  357|  27.3k|    else if (0 == disc.compare(DOUBLE))
  ------------------
  |  Branch (357:14): [True: 2.22k, False: 25.1k]
  ------------------
  358|  2.22k|    {
  359|  2.22k|        return factory->get_primitive_type(TK_FLOAT64);
  360|  2.22k|    }
  361|  25.1k|    else if (0 == disc.compare(LONGDOUBLE))
  ------------------
  |  Branch (361:14): [True: 621, False: 24.4k]
  ------------------
  362|    621|    {
  363|    621|        return factory->get_primitive_type(TK_FLOAT128);
  364|    621|    }
  365|  24.4k|    else if (0 == disc.compare(CHAR))
  ------------------
  |  Branch (365:14): [True: 628, False: 23.8k]
  ------------------
  366|    628|    {
  367|    628|        return factory->get_primitive_type(TK_CHAR8);
  368|    628|    }
  369|  23.8k|    else if (0 == disc.compare(WCHAR))
  ------------------
  |  Branch (369:14): [True: 948, False: 22.9k]
  ------------------
  370|    948|    {
  371|    948|        return factory->get_primitive_type(TK_CHAR16);
  372|    948|    }
  373|  22.9k|    else if (0 == disc.compare(STRING))
  ------------------
  |  Branch (373:14): [True: 9.77k, False: 13.1k]
  ------------------
  374|  9.77k|    {
  375|  9.77k|        return factory->create_string_type(0 == bound ? static_cast<uint32_t>(LENGTH_UNLIMITED) : bound)->build();
  ------------------
  |  Branch (375:44): [True: 9.36k, False: 415]
  ------------------
  376|  9.77k|    }
  377|  13.1k|    else if (0 == disc.compare(WSTRING))
  ------------------
  |  Branch (377:14): [True: 2.98k, False: 10.1k]
  ------------------
  378|  2.98k|    {
  379|  2.98k|        return factory->create_wstring_type(0 == bound ? static_cast<uint32_t>(LENGTH_UNLIMITED) : bound)->build();
  ------------------
  |  Branch (379:45): [True: 2.10k, False: 881]
  ------------------
  380|  2.98k|    }
  381|       |
  382|  10.1k|    DynamicTypeBuilder::_ref_type ret;
  383|  10.1k|    XMLProfileManager::getDynamicTypeBuilderByName(ret, disc);
  384|  10.1k|    if (nullptr != ret)
  ------------------
  |  Branch (384:9): [True: 1.40k, False: 8.75k]
  ------------------
  385|  1.40k|    {
  386|  1.40k|        return ret->build();
  387|  1.40k|    }
  388|  8.75k|    else
  389|  8.75k|    {
  390|  8.75k|        return nullptr;
  391|  8.75k|    }
  392|       |
  393|  10.1k|}
XMLDynamicParser.cpp:_ZL23dimensionsToArrayBoundsRKNSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEERNS_6vectorIjNS3_IjEEEE:
 1184|  36.4k|{
 1185|  36.4k|    std::stringstream ss(dimensions);
 1186|  36.4k|    std::string item;
 1187|       |
 1188|  36.4k|    bounds.clear();
 1189|       |
 1190|  3.54M|    while (std::getline(ss, item, ','))
  ------------------
  |  Branch (1190:12): [True: 3.51M, False: 36.4k]
  ------------------
 1191|  3.51M|    {
 1192|  3.51M|        bounds.push_back(static_cast<uint32_t>(std::atoi(item.c_str())));
 1193|  3.51M|    }
 1194|  36.4k|}

_ZN8eprosima7fastdds3xml6detail16get_element_textEPN8tinyxml210XMLElementE:
  116|  86.3k|{
  117|  86.3k|    std::string ret_val{};
  118|       |
  119|  86.3k|    assert(nullptr != element);
  120|  86.3k|    const char* text = element->GetText();
  121|  86.3k|    if (nullptr != text)
  ------------------
  |  Branch (121:9): [True: 40.5k, False: 45.7k]
  ------------------
  122|  40.5k|    {
  123|  40.5k|        ret_val = process_environment(text);
  124|  40.5k|    }
  125|       |
  126|  86.3k|    return ret_val;
  127|  86.3k|}
_ZN8eprosima7fastdds9xmlparser9XMLParser37getXMLParticipantAllocationAttributesEPN8tinyxml210XMLElementERNS0_4rtps35RTPSParticipantAllocationAttributesEh:
  190|     71|{
  191|       |    /*
  192|       |        <xs:complexType name="rtpsParticipantAllocationAttributesType">
  193|       |            <xs:all minOccurs="0">
  194|       |                <xs:element name="remote_locators" type="remoteLocatorsAllocationConfigType" minOccurs="0"/>
  195|       |                <xs:element name="total_participants" type="containerAllocationConfigType" minOccurs="0"/>
  196|       |                <xs:element name="total_readers" type="containerAllocationConfigType" minOccurs="0"/>
  197|       |                <xs:element name="total_writers" type="containerAllocationConfigType" minOccurs="0"/>
  198|       |                <xs:element name="send_buffers" type="sendBuffersAllocationConfigType" minOccurs="0"/>
  199|       |                <xs:element name="max_properties" type="uint32Type" minOccurs="0"/>
  200|       |                <xs:element name="max_user_data" type="uint32Type" minOccurs="0"/>
  201|       |                <xs:element name="max_partitions" type="uint32Type" minOccurs="0"/>
  202|       |            </xs:all>
  203|       |        </xs:complexType>
  204|       |     */
  205|       |
  206|     71|    tinyxml2::XMLElement* p_aux0 = nullptr;
  207|     71|    const char* name = nullptr;
  208|     71|    uint32_t tmp;
  209|     71|    for (p_aux0 = elem->FirstChildElement(); p_aux0 != NULL; p_aux0 = p_aux0->NextSiblingElement())
  ------------------
  |  Branch (209:46): [True: 0, False: 71]
  ------------------
  210|      0|    {
  211|      0|        name = p_aux0->Name();
  212|      0|        if (strcmp(name, REMOTE_LOCATORS) == 0)
  ------------------
  |  Branch (212:13): [True: 0, False: 0]
  ------------------
  213|      0|        {
  214|       |            // leaseDuration - durationType
  215|      0|            if (XMLP_ret::XML_OK != getXMLRemoteLocatorsAllocationAttributes(p_aux0, allocation.locators, ident))
  ------------------
  |  Branch (215:17): [True: 0, False: 0]
  ------------------
  216|      0|            {
  217|      0|                return XMLP_ret::XML_ERROR;
  218|      0|            }
  219|      0|        }
  220|      0|        else if (strcmp(name, TOTAL_PARTICIPANTS) == 0)
  ------------------
  |  Branch (220:18): [True: 0, False: 0]
  ------------------
  221|      0|        {
  222|       |            // total_participants - containerAllocationConfigType
  223|      0|            if (XMLP_ret::XML_OK != getXMLContainerAllocationConfig(p_aux0, allocation.participants, ident))
  ------------------
  |  Branch (223:17): [True: 0, False: 0]
  ------------------
  224|      0|            {
  225|      0|                return XMLP_ret::XML_ERROR;
  226|      0|            }
  227|      0|        }
  228|      0|        else if (strcmp(name, TOTAL_READERS) == 0)
  ------------------
  |  Branch (228:18): [True: 0, False: 0]
  ------------------
  229|      0|        {
  230|       |            // total_readers - containerAllocationConfigType
  231|      0|            if (XMLP_ret::XML_OK != getXMLContainerAllocationConfig(p_aux0, allocation.readers, ident))
  ------------------
  |  Branch (231:17): [True: 0, False: 0]
  ------------------
  232|      0|            {
  233|      0|                return XMLP_ret::XML_ERROR;
  234|      0|            }
  235|      0|        }
  236|      0|        else if (strcmp(name, TOTAL_WRITERS) == 0)
  ------------------
  |  Branch (236:18): [True: 0, False: 0]
  ------------------
  237|      0|        {
  238|       |            // total_writers - containerAllocationConfigType
  239|      0|            if (XMLP_ret::XML_OK != getXMLContainerAllocationConfig(p_aux0, allocation.writers, ident))
  ------------------
  |  Branch (239:17): [True: 0, False: 0]
  ------------------
  240|      0|            {
  241|      0|                return XMLP_ret::XML_ERROR;
  242|      0|            }
  243|      0|        }
  244|      0|        else if (strcmp(name, SEND_BUFFERS) == 0)
  ------------------
  |  Branch (244:18): [True: 0, False: 0]
  ------------------
  245|      0|        {
  246|       |            // send_buffers - sendBuffersAllocationConfigType
  247|      0|            if (XMLP_ret::XML_OK != getXMLSendBuffersAllocationAttributes(p_aux0, allocation.send_buffers, ident))
  ------------------
  |  Branch (247:17): [True: 0, False: 0]
  ------------------
  248|      0|            {
  249|      0|                return XMLP_ret::XML_ERROR;
  250|      0|            }
  251|      0|        }
  252|      0|        else if (strcmp(name, MAX_PROPERTIES) == 0)
  ------------------
  |  Branch (252:18): [True: 0, False: 0]
  ------------------
  253|      0|        {
  254|       |            // max number of properties in incoming message - uint32Type
  255|      0|            if (XMLP_ret::XML_OK != getXMLUint(p_aux0, &tmp, ident))
  ------------------
  |  Branch (255:17): [True: 0, False: 0]
  ------------------
  256|      0|            {
  257|      0|                return XMLP_ret::XML_ERROR;
  258|      0|            }
  259|      0|            allocation.data_limits.max_properties = tmp;
  260|      0|        }
  261|      0|        else if (strcmp(name, MAX_USER_DATA) == 0)
  ------------------
  |  Branch (261:18): [True: 0, False: 0]
  ------------------
  262|      0|        {
  263|       |            // max number of user data in incoming message - uint32Type
  264|      0|            if (XMLP_ret::XML_OK != getXMLUint(p_aux0, &tmp, ident))
  ------------------
  |  Branch (264:17): [True: 0, False: 0]
  ------------------
  265|      0|            {
  266|      0|                return XMLP_ret::XML_ERROR;
  267|      0|            }
  268|      0|            allocation.data_limits.max_user_data = tmp;
  269|      0|        }
  270|      0|        else if (strcmp(name, MAX_PARTITIONS) == 0)
  ------------------
  |  Branch (270:18): [True: 0, False: 0]
  ------------------
  271|      0|        {
  272|       |            // max number of user data in incoming message - uint32Type
  273|      0|            if (XMLP_ret::XML_OK != getXMLUint(p_aux0, &tmp, ident))
  ------------------
  |  Branch (273:17): [True: 0, False: 0]
  ------------------
  274|      0|            {
  275|      0|                return XMLP_ret::XML_ERROR;
  276|      0|            }
  277|      0|            allocation.data_limits.max_partitions = tmp;
  278|      0|        }
  279|      0|        else
  280|      0|        {
  281|      0|            EPROSIMA_LOG_ERROR(XMLPARSER,
  ------------------
  |  |   45|      0|#define EPROSIMA_LOG_ERROR(cat, msg) EPROSIMA_LOG_ERROR_IMPL_(cat, msg)
  |  |  ------------------
  |  |  |  |  291|      0|    do {                                                                                                               \
  |  |  |  |  292|      0|        std::stringstream fastdds_log_ss_tmp__;                                                                        \
  |  |  |  |  293|      0|        fastdds_log_ss_tmp__ << msg;                                                                                   \
  |  |  |  |  294|      0|        eprosima::fastdds::dds::Log::QueueLog(                                                                         \
  |  |  |  |  295|      0|            fastdds_log_ss_tmp__.str(), eprosima::fastdds::dds::Log::Context{__FILE__, __LINE__, __func__, #cat},      \
  |  |  |  |  296|      0|            eprosima::fastdds::dds::Log::Kind::Error);                                                                 \
  |  |  |  |  297|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (297:14): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  282|      0|                    "Invalid element found into 'rtpsParticipantAllocationAttributesType'. Name: " << name);
  283|      0|            return XMLP_ret::XML_ERROR;
  284|      0|        }
  285|      0|    }
  286|       |
  287|     71|    return XMLP_ret::XML_OK;
  288|     71|}
_ZN8eprosima7fastdds9xmlparser9XMLParser23getXMLDiscoverySettingsEPN8tinyxml210XMLElementERNS0_4rtps17DiscoverySettingsEh:
  402|  5.64k|{
  403|       |    /*
  404|       |       <xs:complexType name="discoverySettingsType">
  405|       |        <xs:all minOccurs="0">
  406|       |            <xs:element name="discoveryProtocol" type="DiscoveryProtocol" minOccurs="0"/>
  407|       |            <xs:element name="ignoreParticipantFlags" type="ParticipantFlags" minOccurs="0"/>
  408|       |            <xs:element name="EDP" type="EDPType" minOccurs="0"/>
  409|       |            <xs:element name="leaseDuration" type="durationType" minOccurs="0"/>
  410|       |            <xs:element name="leaseAnnouncement" type="durationType" minOccurs="0"/>
  411|       |            <xs:element name="simpleEDP" type="simpleEDPType" minOccurs="0"/>
  412|       |            <xs:element name="clientAnnouncementPeriod" type="durationType" minOccurs="0"/>
  413|       |            <xs:element name="discoveryServersList" type="DiscoveryServerList" minOccurs="0"/>
  414|       |            <xs:element name="staticEndpointXMLFilename" type="stringType" minOccurs="0"/>
  415|       |            <xs:element name="static_edp_xml_config" type="stringType" minOccurs="0"/>
  416|       |        </xs:all>
  417|       |       </xs:complexType>
  418|       |     */
  419|       |
  420|  5.64k|    tinyxml2::XMLElement* p_aux0 = nullptr, * p_aux1 = nullptr;
  421|  5.64k|    const char* name = nullptr;
  422|  9.33k|    for (p_aux0 = elem->FirstChildElement(); p_aux0 != NULL; p_aux0 = p_aux0->NextSiblingElement())
  ------------------
  |  Branch (422:46): [True: 8.70k, False: 635]
  ------------------
  423|  8.70k|    {
  424|  8.70k|        name = p_aux0->Name();
  425|  8.70k|        if (strcmp(name, RTPS_PDP_TYPE) == 0)
  ------------------
  |  Branch (425:13): [True: 132, False: 8.56k]
  ------------------
  426|    132|        {
  427|       |            // discoveryProtocol - DiscoveryProtocol
  428|    132|            if (XMLP_ret::XML_OK != getXMLEnum(p_aux0, &settings.discoveryProtocol, ident))
  ------------------
  |  Branch (428:17): [True: 132, False: 0]
  ------------------
  429|    132|            {
  430|    132|                return XMLP_ret::XML_ERROR;
  431|    132|            }
  432|    132|        }
  433|  8.56k|        else if (strcmp(name, IGNORE_PARTICIPANT_FLAGS) == 0)
  ------------------
  |  Branch (433:18): [True: 138, False: 8.43k]
  ------------------
  434|    138|        {
  435|       |            // ignoreParticipantFlags - ParticipantFlags
  436|    138|            if (XMLP_ret::XML_OK != getXMLEnum(p_aux0, &settings.ignoreParticipantFlags, ident))
  ------------------
  |  Branch (436:17): [True: 138, False: 0]
  ------------------
  437|    138|            {
  438|    138|                return XMLP_ret::XML_ERROR;
  439|    138|            }
  440|    138|        }
  441|  8.43k|        else if (strcmp(name, _EDP) == 0)
  ------------------
  |  Branch (441:18): [True: 243, False: 8.18k]
  ------------------
  442|    243|        {
  443|       |            /*
  444|       |                <xs:simpleType name="EDPType">
  445|       |                    <xs:restriction base="xs:string">
  446|       |                        <xs:enumeration value="SIMPLE"/>
  447|       |                        <xs:enumeration value="STATIC"/>
  448|       |                    </xs:restriction>
  449|       |                </xs:simpleType>
  450|       |             */
  451|    243|            std::string text = get_element_text(p_aux0);
  452|    243|            if (text.empty())
  ------------------
  |  Branch (452:17): [True: 243, False: 0]
  ------------------
  453|    243|            {
  454|    243|                EPROSIMA_LOG_ERROR(XMLPARSER, "Node '" << _EDP << "' without content");
  ------------------
  |  |   45|    243|#define EPROSIMA_LOG_ERROR(cat, msg) EPROSIMA_LOG_ERROR_IMPL_(cat, msg)
  |  |  ------------------
  |  |  |  |  291|    243|    do {                                                                                                               \
  |  |  |  |  292|    243|        std::stringstream fastdds_log_ss_tmp__;                                                                        \
  |  |  |  |  293|    243|        fastdds_log_ss_tmp__ << msg;                                                                                   \
  |  |  |  |  294|    243|        eprosima::fastdds::dds::Log::QueueLog(                                                                         \
  |  |  |  |  295|    243|            fastdds_log_ss_tmp__.str(), eprosima::fastdds::dds::Log::Context{__FILE__, __LINE__, __func__, #cat},      \
  |  |  |  |  296|    243|            eprosima::fastdds::dds::Log::Kind::Error);                                                                 \
  |  |  |  |  297|    243|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (297:14): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  455|    243|                return XMLP_ret::XML_ERROR;
  456|    243|            }
  457|      0|            else if (strcmp(text.c_str(), SIMPLE) == 0)
  ------------------
  |  Branch (457:22): [True: 0, False: 0]
  ------------------
  458|      0|            {
  459|      0|                settings.use_SIMPLE_EndpointDiscoveryProtocol = true;
  460|      0|                settings.use_STATIC_EndpointDiscoveryProtocol = false;
  461|      0|            }
  462|      0|            else if (strcmp(text.c_str(), STATIC) == 0)
  ------------------
  |  Branch (462:22): [True: 0, False: 0]
  ------------------
  463|      0|            {
  464|      0|                settings.use_SIMPLE_EndpointDiscoveryProtocol = false;
  465|      0|                settings.use_STATIC_EndpointDiscoveryProtocol = true;
  466|      0|            }
  467|      0|            else
  468|      0|            {
  469|      0|                EPROSIMA_LOG_ERROR(XMLPARSER, "Node '" << _EDP << "' with bad content");
  ------------------
  |  |   45|      0|#define EPROSIMA_LOG_ERROR(cat, msg) EPROSIMA_LOG_ERROR_IMPL_(cat, msg)
  |  |  ------------------
  |  |  |  |  291|      0|    do {                                                                                                               \
  |  |  |  |  292|      0|        std::stringstream fastdds_log_ss_tmp__;                                                                        \
  |  |  |  |  293|      0|        fastdds_log_ss_tmp__ << msg;                                                                                   \
  |  |  |  |  294|      0|        eprosima::fastdds::dds::Log::QueueLog(                                                                         \
  |  |  |  |  295|      0|            fastdds_log_ss_tmp__.str(), eprosima::fastdds::dds::Log::Context{__FILE__, __LINE__, __func__, #cat},      \
  |  |  |  |  296|      0|            eprosima::fastdds::dds::Log::Kind::Error);                                                                 \
  |  |  |  |  297|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (297:14): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  470|      0|                return XMLP_ret::XML_ERROR;
  471|      0|            }
  472|    243|        }
  473|  8.18k|        else if (strcmp(name, LEASEDURATION) == 0)
  ------------------
  |  Branch (473:18): [True: 4.51k, False: 3.67k]
  ------------------
  474|  4.51k|        {
  475|       |            // leaseDuration - durationType
  476|  4.51k|            if (XMLP_ret::XML_OK != getXMLDuration(p_aux0, settings.leaseDuration, ident))
  ------------------
  |  Branch (476:17): [True: 2.74k, False: 1.77k]
  ------------------
  477|  2.74k|            {
  478|  2.74k|                return XMLP_ret::XML_ERROR;
  479|  2.74k|            }
  480|  4.51k|        }
  481|  3.67k|        else if (strcmp(name, LEASE_ANNOUNCE) == 0)
  ------------------
  |  Branch (481:18): [True: 220, False: 3.45k]
  ------------------
  482|    220|        {
  483|       |            // leaseAnnouncement - durationType
  484|    220|            if (XMLP_ret::XML_OK != getXMLDuration(p_aux0, settings.leaseDuration_announcementperiod, ident))
  ------------------
  |  Branch (484:17): [True: 220, False: 0]
  ------------------
  485|    220|            {
  486|    220|                return XMLP_ret::XML_ERROR;
  487|    220|            }
  488|    220|        }
  489|  3.45k|        else if (strcmp(name, INITIAL_ANNOUNCEMENTS) == 0)
  ------------------
  |  Branch (489:18): [True: 188, False: 3.26k]
  ------------------
  490|    188|        {
  491|       |            // initialAnnouncements - initialAnnouncementsType
  492|    188|            if (XMLP_ret::XML_OK !=
  ------------------
  |  Branch (492:17): [True: 0, False: 188]
  ------------------
  493|    188|                    getXMLInitialAnnouncementsConfig(p_aux0, settings.initial_announcements, ident))
  494|      0|            {
  495|      0|                return XMLP_ret::XML_ERROR;
  496|      0|            }
  497|    188|        }
  498|  3.26k|        else if (strcmp(name, SIMPLE_EDP) == 0)
  ------------------
  |  Branch (498:18): [True: 1.73k, False: 1.53k]
  ------------------
  499|  1.73k|        {
  500|       |            // simpleEDP
  501|  1.73k|            for (p_aux1 = p_aux0->FirstChildElement(); p_aux1 != nullptr; p_aux1 = p_aux1->NextSiblingElement())
  ------------------
  |  Branch (501:56): [True: 0, False: 1.73k]
  ------------------
  502|      0|            {
  503|      0|                name = p_aux1->Name();
  504|      0|                if (strcmp(name, PUBWRITER_SUBREADER) == 0)
  ------------------
  |  Branch (504:21): [True: 0, False: 0]
  ------------------
  505|      0|                {
  506|       |                    // PUBWRITER_SUBREADER - boolType
  507|      0|                    if (XMLP_ret::XML_OK !=
  ------------------
  |  Branch (507:25): [True: 0, False: 0]
  ------------------
  508|      0|                            getXMLBool(p_aux1, &settings.m_simpleEDP.use_PublicationWriterANDSubscriptionReader,
  509|      0|                            ident + 1))
  510|      0|                    {
  511|      0|                        return XMLP_ret::XML_ERROR;
  512|      0|                    }
  513|      0|                }
  514|      0|                else if (strcmp(name, PUBREADER_SUBWRITER) == 0)
  ------------------
  |  Branch (514:26): [True: 0, False: 0]
  ------------------
  515|      0|                {
  516|       |                    // PUBREADER_SUBWRITER - boolType
  517|      0|                    if (XMLP_ret::XML_OK !=
  ------------------
  |  Branch (517:25): [True: 0, False: 0]
  ------------------
  518|      0|                            getXMLBool(p_aux1, &settings.m_simpleEDP.use_PublicationReaderANDSubscriptionWriter,
  519|      0|                            ident + 1))
  520|      0|                    {
  521|      0|                        return XMLP_ret::XML_ERROR;
  522|      0|                    }
  523|      0|                }
  524|      0|                else
  525|      0|                {
  526|      0|                    EPROSIMA_LOG_ERROR(XMLPARSER, "Invalid element found into 'simpleEDP'. Name: " << name);
  ------------------
  |  |   45|      0|#define EPROSIMA_LOG_ERROR(cat, msg) EPROSIMA_LOG_ERROR_IMPL_(cat, msg)
  |  |  ------------------
  |  |  |  |  291|      0|    do {                                                                                                               \
  |  |  |  |  292|      0|        std::stringstream fastdds_log_ss_tmp__;                                                                        \
  |  |  |  |  293|      0|        fastdds_log_ss_tmp__ << msg;                                                                                   \
  |  |  |  |  294|      0|        eprosima::fastdds::dds::Log::QueueLog(                                                                         \
  |  |  |  |  295|      0|            fastdds_log_ss_tmp__.str(), eprosima::fastdds::dds::Log::Context{__FILE__, __LINE__, __func__, #cat},      \
  |  |  |  |  296|      0|            eprosima::fastdds::dds::Log::Kind::Error);                                                                 \
  |  |  |  |  297|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (297:14): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  527|      0|                    return XMLP_ret::XML_ERROR;
  528|      0|                }
  529|      0|            }
  530|  1.73k|        }
  531|  1.53k|        else if (strcmp(name, CLIENTANNOUNCEMENTPERIOD) == 0)
  ------------------
  |  Branch (531:18): [True: 71, False: 1.46k]
  ------------------
  532|     71|        {
  533|       |            // clientAnnouncementPeriod - durationType
  534|     71|            if (XMLP_ret::XML_OK != getXMLDuration(p_aux0, settings.discoveryServer_client_syncperiod, ident))
  ------------------
  |  Branch (534:17): [True: 71, False: 0]
  ------------------
  535|     71|            {
  536|     71|                return XMLP_ret::XML_ERROR;
  537|     71|            }
  538|     71|        }
  539|  1.46k|        else if (strcmp(name, SERVER_LIST) == 0)
  ------------------
  |  Branch (539:18): [True: 88, False: 1.37k]
  ------------------
  540|     88|        {
  541|       |            // discoverServersList - locatorListType
  542|     88|            if (XMLP_ret::XML_OK != getXMLLocatorList(p_aux0, settings.m_DiscoveryServers, ident))
  ------------------
  |  Branch (542:17): [True: 88, False: 0]
  ------------------
  543|     88|            {
  544|     88|                return XMLP_ret::XML_ERROR;
  545|     88|            }
  546|     88|        }
  547|  1.37k|        else if (strcmp(name, STATIC_ENDPOINT_XML) == 0)
  ------------------
  |  Branch (547:18): [True: 15, False: 1.36k]
  ------------------
  548|     15|        {
  549|       |            // staticEndpointXMLFilename - stringType
  550|     15|            std::string s = "";
  551|     15|            if (XMLP_ret::XML_OK != getXMLString(p_aux0, &s, ident))
  ------------------
  |  Branch (551:17): [True: 15, False: 0]
  ------------------
  552|     15|            {
  553|     15|                return XMLP_ret::XML_ERROR;
  554|     15|            }
  555|      0|            std::string file_name = "file://" + s;
  556|      0|            settings.static_edp_xml_config(file_name.c_str());
  557|      0|        }
  558|  1.36k|        else if (strcmp(name, STATIC_ENDPOINT_XML_URI) == 0)
  ------------------
  |  Branch (558:18): [True: 62, False: 1.29k]
  ------------------
  559|     62|        {
  560|       |            // staticEndpointXMLFilename - stringType
  561|     62|            std::string s = "";
  562|     62|            if (XMLP_ret::XML_OK != getXMLString(p_aux0, &s, ident))
  ------------------
  |  Branch (562:17): [True: 62, False: 0]
  ------------------
  563|     62|            {
  564|     62|                return XMLP_ret::XML_ERROR;
  565|     62|            }
  566|      0|            settings.static_edp_xml_config(s.c_str());
  567|      0|        }
  568|  1.29k|        else
  569|  1.29k|        {
  570|  1.29k|            EPROSIMA_LOG_ERROR(XMLPARSER, "Invalid element found into 'discoverySettingsType'. Name: " << name);
  ------------------
  |  |   45|  1.29k|#define EPROSIMA_LOG_ERROR(cat, msg) EPROSIMA_LOG_ERROR_IMPL_(cat, msg)
  |  |  ------------------
  |  |  |  |  291|  1.29k|    do {                                                                                                               \
  |  |  |  |  292|  1.29k|        std::stringstream fastdds_log_ss_tmp__;                                                                        \
  |  |  |  |  293|  1.29k|        fastdds_log_ss_tmp__ << msg;                                                                                   \
  |  |  |  |  294|  1.29k|        eprosima::fastdds::dds::Log::QueueLog(                                                                         \
  |  |  |  |  295|  1.29k|            fastdds_log_ss_tmp__.str(), eprosima::fastdds::dds::Log::Context{__FILE__, __LINE__, __func__, #cat},      \
  |  |  |  |  296|  1.29k|            eprosima::fastdds::dds::Log::Kind::Error);                                                                 \
  |  |  |  |  297|  1.29k|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (297:14): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  571|  1.29k|            return XMLP_ret::XML_ERROR;
  572|  1.29k|        }
  573|  8.70k|    }
  574|       |
  575|    635|    return XMLP_ret::XML_OK;
  576|       |
  577|  5.64k|}
_ZN8eprosima7fastdds9xmlparser9XMLParser23getXMLBuiltinAttributesEPN8tinyxml210XMLElementERNS0_4rtps17BuiltinAttributesEh:
  583|  11.9k|{
  584|       |    /*
  585|       |       <xs:complexType name="builtinAttributesType">
  586|       |        <xs:all minOccurs="0">
  587|       |            <xs:element name="discovery_config" type="discoverySettingsType" minOccurs="0"/>
  588|       |            <xs:element name="use_WriterLivelinessProtocol" type="boolType" minOccurs="0"/>
  589|       |            <xs:element name="metatraffic_external_unicast_locators" type="externalLocatorListType" minOccurs="0"/>
  590|       |            <xs:element name="metatrafficUnicastLocatorList" type="locatorListType" minOccurs="0"/>
  591|       |            <xs:element name="metatrafficMulticastLocatorList" type="locatorListType" minOccurs="0"/>
  592|       |            <xs:element name="initialPeersList" type="locatorListType" minOccurs="0"/>
  593|       |            <xs:element name="readerHistoryMemoryPolicy" type="historyMemoryPolicyType" minOccurs="0"/>
  594|       |            <xs:element name="writerHistoryMemoryPolicy" type="historyMemoryPolicyType" minOccurs="0"/>
  595|       |            <xs:element name="mutation_tries" type="uint32Type" minOccurs="0"/>
  596|       |            <xs:element name="flow_controller_name" type="stringType" minOccurs="0"/>
  597|       |        </xs:all>
  598|       |       </xs:complexType>
  599|       |     */
  600|       |
  601|  11.9k|    std::unordered_map<std::string, bool> tags_present;
  602|       |
  603|  11.9k|    tinyxml2::XMLElement* p_aux0 = nullptr;
  604|  11.9k|    const char* name = nullptr;
  605|  13.4k|    for (p_aux0 = elem->FirstChildElement(); p_aux0 != NULL; p_aux0 = p_aux0->NextSiblingElement())
  ------------------
  |  Branch (605:46): [True: 10.7k, False: 2.74k]
  ------------------
  606|  10.7k|    {
  607|  10.7k|        name = p_aux0->Name();
  608|       |
  609|  10.7k|        if (tags_present[name])
  ------------------
  |  Branch (609:13): [True: 430, False: 10.3k]
  ------------------
  610|    430|        {
  611|    430|            EPROSIMA_LOG_ERROR(XMLPARSER, "Duplicated element found in 'builtinAttributesType'. Name: " << name);
  ------------------
  |  |   45|    430|#define EPROSIMA_LOG_ERROR(cat, msg) EPROSIMA_LOG_ERROR_IMPL_(cat, msg)
  |  |  ------------------
  |  |  |  |  291|    430|    do {                                                                                                               \
  |  |  |  |  292|    430|        std::stringstream fastdds_log_ss_tmp__;                                                                        \
  |  |  |  |  293|    430|        fastdds_log_ss_tmp__ << msg;                                                                                   \
  |  |  |  |  294|    430|        eprosima::fastdds::dds::Log::QueueLog(                                                                         \
  |  |  |  |  295|    430|            fastdds_log_ss_tmp__.str(), eprosima::fastdds::dds::Log::Context{__FILE__, __LINE__, __func__, #cat},      \
  |  |  |  |  296|    430|            eprosima::fastdds::dds::Log::Kind::Error);                                                                 \
  |  |  |  |  297|    430|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (297:14): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  612|    430|            return XMLP_ret::XML_ERROR;
  613|    430|        }
  614|  10.3k|        tags_present[name] = true;
  615|       |
  616|  10.3k|        if (strcmp(name, DISCOVERY_SETTINGS) == 0)
  ------------------
  |  Branch (616:13): [True: 5.64k, False: 4.65k]
  ------------------
  617|  5.64k|        {
  618|       |            // discovery_config - DiscoverySettings
  619|  5.64k|            if (XMLP_ret::XML_OK != getXMLDiscoverySettings(p_aux0, builtin.discovery_config, ident))
  ------------------
  |  Branch (619:17): [True: 5.01k, False: 635]
  ------------------
  620|  5.01k|            {
  621|  5.01k|                return XMLP_ret::XML_ERROR;
  622|  5.01k|            }
  623|  5.64k|        }
  624|  4.65k|        else if (strcmp(name, WRITER_LVESS_PROTOCOL) == 0)
  ------------------
  |  Branch (624:18): [True: 99, False: 4.55k]
  ------------------
  625|     99|        {
  626|       |            // use_WriterLivelinessProtocol - boolType
  627|     99|            if (XMLP_ret::XML_OK != getXMLBool(p_aux0, &builtin.use_WriterLivelinessProtocol, ident))
  ------------------
  |  Branch (627:17): [True: 99, False: 0]
  ------------------
  628|     99|            {
  629|     99|                return XMLP_ret::XML_ERROR;
  630|     99|            }
  631|     99|        }
  632|  4.55k|        else if (strcmp(name, META_EXT_UNI_LOC_LIST) == 0)
  ------------------
  |  Branch (632:18): [True: 867, False: 3.69k]
  ------------------
  633|    867|        {
  634|       |            // metatraffic_external_unicast_locators - externalLocatorListType
  635|    867|            if (XMLP_ret::XML_OK !=
  ------------------
  |  Branch (635:17): [True: 0, False: 867]
  ------------------
  636|    867|                    getXMLExternalLocatorList(p_aux0, builtin.metatraffic_external_unicast_locators, ident))
  637|      0|            {
  638|      0|                return XMLP_ret::XML_ERROR;
  639|      0|            }
  640|    867|        }
  641|  3.69k|        else if (strcmp(name, META_UNI_LOC_LIST) == 0)
  ------------------
  |  Branch (641:18): [True: 72, False: 3.62k]
  ------------------
  642|     72|        {
  643|       |            // metatrafficUnicastLocatorList
  644|     72|            if (XMLP_ret::XML_OK != getXMLLocatorList(p_aux0, builtin.metatrafficUnicastLocatorList, ident))
  ------------------
  |  Branch (644:17): [True: 72, False: 0]
  ------------------
  645|     72|            {
  646|     72|                return XMLP_ret::XML_ERROR;
  647|     72|            }
  648|     72|        }
  649|  3.62k|        else if (strcmp(name, META_MULTI_LOC_LIST) == 0)
  ------------------
  |  Branch (649:18): [True: 9, False: 3.61k]
  ------------------
  650|      9|        {
  651|       |            // metatrafficMulticastLocatorList
  652|      9|            if (XMLP_ret::XML_OK != getXMLLocatorList(p_aux0, builtin.metatrafficMulticastLocatorList, ident))
  ------------------
  |  Branch (652:17): [True: 9, False: 0]
  ------------------
  653|      9|            {
  654|      9|                return XMLP_ret::XML_ERROR;
  655|      9|            }
  656|      9|        }
  657|  3.61k|        else if (strcmp(name, INIT_PEERS_LIST) == 0)
  ------------------
  |  Branch (657:18): [True: 283, False: 3.32k]
  ------------------
  658|    283|        {
  659|       |            // initialPeersList
  660|    283|            if (XMLP_ret::XML_OK != getXMLLocatorList(p_aux0, builtin.initialPeersList, ident))
  ------------------
  |  Branch (660:17): [True: 283, False: 0]
  ------------------
  661|    283|            {
  662|    283|                return XMLP_ret::XML_ERROR;
  663|    283|            }
  664|    283|        }
  665|  3.32k|        else if (strcmp(name, READER_HIST_MEM_POLICY) == 0)
  ------------------
  |  Branch (665:18): [True: 68, False: 3.26k]
  ------------------
  666|     68|        {
  667|       |            // readerhistoryMemoryPolicy
  668|     68|            if (XMLP_ret::XML_OK != getXMLHistoryMemoryPolicy(p_aux0, builtin.readerHistoryMemoryPolicy, ident))
  ------------------
  |  Branch (668:17): [True: 68, False: 0]
  ------------------
  669|     68|            {
  670|     68|                return XMLP_ret::XML_ERROR;
  671|     68|            }
  672|     68|        }
  673|  3.26k|        else if (strcmp(name, WRITER_HIST_MEM_POLICY) == 0)
  ------------------
  |  Branch (673:18): [True: 65, False: 3.19k]
  ------------------
  674|     65|        {
  675|       |            // writerhistoryMemoryPolicy
  676|     65|            if (XMLP_ret::XML_OK != getXMLHistoryMemoryPolicy(p_aux0, builtin.writerHistoryMemoryPolicy, ident))
  ------------------
  |  Branch (676:17): [True: 65, False: 0]
  ------------------
  677|     65|            {
  678|     65|                return XMLP_ret::XML_ERROR;
  679|     65|            }
  680|     65|        }
  681|  3.19k|        else if (strcmp(name, READER_PAYLOAD_SIZE) == 0)
  ------------------
  |  Branch (681:18): [True: 22, False: 3.17k]
  ------------------
  682|     22|        {
  683|       |            // readerPayloadSize
  684|     22|            if (XMLP_ret::XML_OK != getXMLUint(p_aux0, &builtin.readerPayloadSize, ident))
  ------------------
  |  Branch (684:17): [True: 22, False: 0]
  ------------------
  685|     22|            {
  686|     22|                return XMLP_ret::XML_ERROR;
  687|     22|            }
  688|     22|        }
  689|  3.17k|        else if (strcmp(name, WRITER_PAYLOAD_SIZE) == 0)
  ------------------
  |  Branch (689:18): [True: 234, False: 2.93k]
  ------------------
  690|    234|        {
  691|       |            // readerPayloadSize
  692|    234|            if (XMLP_ret::XML_OK != getXMLUint(p_aux0, &builtin.writerPayloadSize, ident))
  ------------------
  |  Branch (692:17): [True: 234, False: 0]
  ------------------
  693|    234|            {
  694|    234|                return XMLP_ret::XML_ERROR;
  695|    234|            }
  696|    234|        }
  697|  2.93k|        else if (strcmp(name, MUTATION_TRIES) == 0)
  ------------------
  |  Branch (697:18): [True: 472, False: 2.46k]
  ------------------
  698|    472|        {
  699|       |            // mutation_tries - uint32Type
  700|    472|            if (XMLP_ret::XML_OK != getXMLUint(p_aux0, &builtin.mutation_tries, ident))
  ------------------
  |  Branch (700:17): [True: 472, False: 0]
  ------------------
  701|    472|            {
  702|    472|                return XMLP_ret::XML_ERROR;
  703|    472|            }
  704|    472|        }
  705|  2.46k|        else if (strcmp(name, AVOID_BUILTIN_MULTICAST) == 0)
  ------------------
  |  Branch (705:18): [True: 118, False: 2.34k]
  ------------------
  706|    118|        {
  707|       |            // avoid_builtin_multicast - boolType
  708|    118|            if (XMLP_ret::XML_OK != getXMLBool(p_aux0, &builtin.avoid_builtin_multicast, ident))
  ------------------
  |  Branch (708:17): [True: 118, False: 0]
  ------------------
  709|    118|            {
  710|    118|                return XMLP_ret::XML_ERROR;
  711|    118|            }
  712|    118|        }
  713|  2.34k|        else if (strcmp(name, FLOW_CONTROLLER_NAME) == 0)
  ------------------
  |  Branch (713:18): [True: 68, False: 2.28k]
  ------------------
  714|     68|        {
  715|       |            // flow_controller_name - stringType
  716|     68|            if (XMLP_ret::XML_OK != getXMLString(p_aux0, &builtin.flow_controller_name, ident))
  ------------------
  |  Branch (716:17): [True: 68, False: 0]
  ------------------
  717|     68|            {
  718|     68|                return XMLP_ret::XML_ERROR;
  719|     68|            }
  720|     68|        }
  721|  2.28k|        else
  722|  2.28k|        {
  723|  2.28k|            EPROSIMA_LOG_ERROR(XMLPARSER, "Invalid element found into 'builtinAttributesType'. Name: " << name);
  ------------------
  |  |   45|  2.28k|#define EPROSIMA_LOG_ERROR(cat, msg) EPROSIMA_LOG_ERROR_IMPL_(cat, msg)
  |  |  ------------------
  |  |  |  |  291|  2.28k|    do {                                                                                                               \
  |  |  |  |  292|  2.28k|        std::stringstream fastdds_log_ss_tmp__;                                                                        \
  |  |  |  |  293|  2.28k|        fastdds_log_ss_tmp__ << msg;                                                                                   \
  |  |  |  |  294|  2.28k|        eprosima::fastdds::dds::Log::QueueLog(                                                                         \
  |  |  |  |  295|  2.28k|            fastdds_log_ss_tmp__.str(), eprosima::fastdds::dds::Log::Context{__FILE__, __LINE__, __func__, #cat},      \
  |  |  |  |  296|  2.28k|            eprosima::fastdds::dds::Log::Kind::Error);                                                                 \
  |  |  |  |  297|  2.28k|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (297:14): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  724|  2.28k|            return XMLP_ret::XML_ERROR;
  725|  2.28k|        }
  726|  10.3k|    }
  727|       |
  728|  2.74k|    return XMLP_ret::XML_OK;
  729|  11.9k|}
_ZN8eprosima7fastdds9xmlparser9XMLParser32getXMLInitialAnnouncementsConfigEPN8tinyxml210XMLElementERNS0_4rtps25InitialAnnouncementConfigEh:
  735|    188|{
  736|       |    /*
  737|       |        <xs:complexType name="initialAnnouncementsType">
  738|       |            <xs:all minOccurs="0">
  739|       |                <xs:element name="count" type="uint32Type" minOccurs="0"/>
  740|       |                <xs:element name="period" type="durationType" minOccurs="0"/>
  741|       |            </xs:all>
  742|       |        </xs:complexType>
  743|       |     */
  744|    188|    tinyxml2::XMLElement* p_aux0 = nullptr;
  745|    188|    const char* name = nullptr;
  746|    188|    for (p_aux0 = elem->FirstChildElement(); p_aux0 != NULL; p_aux0 = p_aux0->NextSiblingElement())
  ------------------
  |  Branch (746:46): [True: 0, False: 188]
  ------------------
  747|      0|    {
  748|      0|        name = p_aux0->Name();
  749|      0|        if (strcmp(name, COUNT) == 0)
  ------------------
  |  Branch (749:13): [True: 0, False: 0]
  ------------------
  750|      0|        {
  751|       |            // portBase - uint16Type
  752|      0|            if (XMLP_ret::XML_OK != getXMLUint(p_aux0, &config.count, ident))
  ------------------
  |  Branch (752:17): [True: 0, False: 0]
  ------------------
  753|      0|            {
  754|      0|                return XMLP_ret::XML_ERROR;
  755|      0|            }
  756|      0|        }
  757|      0|        else if (strcmp(name, PERIOD) == 0)
  ------------------
  |  Branch (757:18): [True: 0, False: 0]
  ------------------
  758|      0|        {
  759|       |            // domainIDGain - uint16Type
  760|      0|            if (XMLP_ret::XML_OK != getXMLDuration(p_aux0, config.period, ident))
  ------------------
  |  Branch (760:17): [True: 0, False: 0]
  ------------------
  761|      0|            {
  762|      0|                return XMLP_ret::XML_ERROR;
  763|      0|            }
  764|      0|        }
  765|      0|        else
  766|      0|        {
  767|      0|            EPROSIMA_LOG_ERROR(XMLPARSER, "Invalid element found into 'portType'. Name: " << name);
  ------------------
  |  |   45|      0|#define EPROSIMA_LOG_ERROR(cat, msg) EPROSIMA_LOG_ERROR_IMPL_(cat, msg)
  |  |  ------------------
  |  |  |  |  291|      0|    do {                                                                                                               \
  |  |  |  |  292|      0|        std::stringstream fastdds_log_ss_tmp__;                                                                        \
  |  |  |  |  293|      0|        fastdds_log_ss_tmp__ << msg;                                                                                   \
  |  |  |  |  294|      0|        eprosima::fastdds::dds::Log::QueueLog(                                                                         \
  |  |  |  |  295|      0|            fastdds_log_ss_tmp__.str(), eprosima::fastdds::dds::Log::Context{__FILE__, __LINE__, __func__, #cat},      \
  |  |  |  |  296|      0|            eprosima::fastdds::dds::Log::Kind::Error);                                                                 \
  |  |  |  |  297|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (297:14): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  768|      0|            return XMLP_ret::XML_ERROR;
  769|      0|        }
  770|      0|    }
  771|    188|    return XMLP_ret::XML_OK;
  772|    188|}
_ZN8eprosima7fastdds9xmlparser9XMLParser20getXMLPortParametersEPN8tinyxml210XMLElementERNS0_4rtps14PortParametersEh:
  778|  1.00k|{
  779|       |    /*
  780|       |        <xs:complexType name="portType">
  781|       |            <xs:all minOccurs="0">
  782|       |                <xs:element name="portBase" type="uint16Type" minOccurs="0"/>
  783|       |                <xs:element name="domainIDGain" type="uint16Type" minOccurs="0"/>
  784|       |                <xs:element name="participantIDGain" type="uint16Type" minOccurs="0"/>
  785|       |                <xs:element name="offsetd0" type="uint16Type" minOccurs="0"/>
  786|       |                <xs:element name="offsetd1" type="uint16Type" minOccurs="0"/>
  787|       |                <xs:element name="offsetd2" type="uint16Type" minOccurs="0"/>
  788|       |                <xs:element name="offsetd3" type="uint16Type" minOccurs="0"/>
  789|       |                <xs:element name="offsetd4" type="uint16Type" minOccurs="0"/>
  790|       |            </xs:all>
  791|       |        </xs:complexType>
  792|       |     */
  793|       |
  794|  1.00k|    tinyxml2::XMLElement* p_aux0 = nullptr;
  795|  1.00k|    const char* name = nullptr;
  796|  1.00k|    for (p_aux0 = elem->FirstChildElement(); p_aux0 != NULL; p_aux0 = p_aux0->NextSiblingElement())
  ------------------
  |  Branch (796:46): [True: 0, False: 1.00k]
  ------------------
  797|      0|    {
  798|      0|        name = p_aux0->Name();
  799|      0|        if (strcmp(name, PORT_BASE) == 0)
  ------------------
  |  Branch (799:13): [True: 0, False: 0]
  ------------------
  800|      0|        {
  801|       |            // portBase - uint16Type
  802|      0|            if (XMLP_ret::XML_OK != getXMLUint(p_aux0, &port.portBase, ident))
  ------------------
  |  Branch (802:17): [True: 0, False: 0]
  ------------------
  803|      0|            {
  804|      0|                return XMLP_ret::XML_ERROR;
  805|      0|            }
  806|      0|        }
  807|      0|        else if (strcmp(name, DOMAIN_ID_GAIN) == 0)
  ------------------
  |  Branch (807:18): [True: 0, False: 0]
  ------------------
  808|      0|        {
  809|       |            // domainIDGain - uint16Type
  810|      0|            if (XMLP_ret::XML_OK != getXMLUint(p_aux0, &port.domainIDGain, ident))
  ------------------
  |  Branch (810:17): [True: 0, False: 0]
  ------------------
  811|      0|            {
  812|      0|                return XMLP_ret::XML_ERROR;
  813|      0|            }
  814|      0|        }
  815|      0|        else if (strcmp(name, PARTICIPANT_ID_GAIN) == 0)
  ------------------
  |  Branch (815:18): [True: 0, False: 0]
  ------------------
  816|      0|        {
  817|       |            // participantIDGain - uint16Type
  818|      0|            if (XMLP_ret::XML_OK != getXMLUint(p_aux0, &port.participantIDGain, ident))
  ------------------
  |  Branch (818:17): [True: 0, False: 0]
  ------------------
  819|      0|            {
  820|      0|                return XMLP_ret::XML_ERROR;
  821|      0|            }
  822|      0|        }
  823|      0|        else if (strcmp(name, OFFSETD0) == 0)
  ------------------
  |  Branch (823:18): [True: 0, False: 0]
  ------------------
  824|      0|        {
  825|       |            // offsetd0 - uint16Type
  826|      0|            if (XMLP_ret::XML_OK != getXMLUint(p_aux0, &port.offsetd0, ident))
  ------------------
  |  Branch (826:17): [True: 0, False: 0]
  ------------------
  827|      0|            {
  828|      0|                return XMLP_ret::XML_ERROR;
  829|      0|            }
  830|      0|        }
  831|      0|        else if (strcmp(name, OFFSETD1) == 0)
  ------------------
  |  Branch (831:18): [True: 0, False: 0]
  ------------------
  832|      0|        {
  833|       |            // offsetd1 - uint16Type
  834|      0|            if (XMLP_ret::XML_OK != getXMLUint(p_aux0, &port.offsetd1, ident))
  ------------------
  |  Branch (834:17): [True: 0, False: 0]
  ------------------
  835|      0|            {
  836|      0|                return XMLP_ret::XML_ERROR;
  837|      0|            }
  838|      0|        }
  839|      0|        else if (strcmp(name, OFFSETD2) == 0)
  ------------------
  |  Branch (839:18): [True: 0, False: 0]
  ------------------
  840|      0|        {
  841|       |            // offsetd2 - uint16Type
  842|      0|            if (XMLP_ret::XML_OK != getXMLUint(p_aux0, &port.offsetd2, ident))
  ------------------
  |  Branch (842:17): [True: 0, False: 0]
  ------------------
  843|      0|            {
  844|      0|                return XMLP_ret::XML_ERROR;
  845|      0|            }
  846|      0|        }
  847|      0|        else if (strcmp(name, OFFSETD3) == 0)
  ------------------
  |  Branch (847:18): [True: 0, False: 0]
  ------------------
  848|      0|        {
  849|       |            // offsetd3 - uint16Type
  850|      0|            if (XMLP_ret::XML_OK != getXMLUint(p_aux0, &port.offsetd3, ident))
  ------------------
  |  Branch (850:17): [True: 0, False: 0]
  ------------------
  851|      0|            {
  852|      0|                return XMLP_ret::XML_ERROR;
  853|      0|            }
  854|      0|        }
  855|      0|        else if (strcmp(name, OFFSETD4) == 0)
  ------------------
  |  Branch (855:18): [True: 0, False: 0]
  ------------------
  856|      0|        {
  857|       |            // offsetd4 - uint16Type
  858|      0|            if (XMLP_ret::XML_OK != getXMLUint(p_aux0, &port.offsetd4, ident))
  ------------------
  |  Branch (858:17): [True: 0, False: 0]
  ------------------
  859|      0|            {
  860|      0|                return XMLP_ret::XML_ERROR;
  861|      0|            }
  862|      0|        }
  863|      0|        else
  864|      0|        {
  865|      0|            EPROSIMA_LOG_ERROR(XMLPARSER, "Invalid element found into 'portType'. Name: " << name);
  ------------------
  |  |   45|      0|#define EPROSIMA_LOG_ERROR(cat, msg) EPROSIMA_LOG_ERROR_IMPL_(cat, msg)
  |  |  ------------------
  |  |  |  |  291|      0|    do {                                                                                                               \
  |  |  |  |  292|      0|        std::stringstream fastdds_log_ss_tmp__;                                                                        \
  |  |  |  |  293|      0|        fastdds_log_ss_tmp__ << msg;                                                                                   \
  |  |  |  |  294|      0|        eprosima::fastdds::dds::Log::QueueLog(                                                                         \
  |  |  |  |  295|      0|            fastdds_log_ss_tmp__.str(), eprosima::fastdds::dds::Log::Context{__FILE__, __LINE__, __func__, #cat},      \
  |  |  |  |  296|      0|            eprosima::fastdds::dds::Log::Kind::Error);                                                                 \
  |  |  |  |  297|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (297:14): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  866|      0|            return XMLP_ret::XML_ERROR;
  867|      0|        }
  868|      0|    }
  869|  1.00k|    return XMLP_ret::XML_OK;
  870|  1.00k|}
_ZN8eprosima7fastdds9xmlparser9XMLParser16getXMLTransportsEPN8tinyxml210XMLElementERNSt3__16vectorINS6_10shared_ptrINS0_4rtps28TransportDescriptorInterfaceEEENS6_9allocatorISB_EEEEh:
  876|    377|{
  877|       |    /*
  878|       |        <xs:complexType name="stringListType">
  879|       |            <xs:sequence>
  880|       |                <xs:element name="id" type="stringType" minOccurs="0" maxOccurs="unbounded"/>
  881|       |            </xs:sequence>
  882|       |        </xs:complexType>
  883|       |     */
  884|       |
  885|    377|    tinyxml2::XMLElement* p_aux0 = nullptr;
  886|    377|    p_aux0 = elem->FirstChildElement(TRANSPORT_ID);
  887|    377|    if (nullptr == p_aux0)
  ------------------
  |  Branch (887:9): [True: 377, False: 0]
  ------------------
  888|    377|    {
  889|    377|        EPROSIMA_LOG_ERROR(XMLPARSER, "Node '" << elem->Value() << "' without content");
  ------------------
  |  |   45|    377|#define EPROSIMA_LOG_ERROR(cat, msg) EPROSIMA_LOG_ERROR_IMPL_(cat, msg)
  |  |  ------------------
  |  |  |  |  291|    377|    do {                                                                                                               \
  |  |  |  |  292|    377|        std::stringstream fastdds_log_ss_tmp__;                                                                        \
  |  |  |  |  293|    377|        fastdds_log_ss_tmp__ << msg;                                                                                   \
  |  |  |  |  294|    377|        eprosima::fastdds::dds::Log::QueueLog(                                                                         \
  |  |  |  |  295|    377|            fastdds_log_ss_tmp__.str(), eprosima::fastdds::dds::Log::Context{__FILE__, __LINE__, __func__, #cat},      \
  |  |  |  |  296|    377|            eprosima::fastdds::dds::Log::Kind::Error);                                                                 \
  |  |  |  |  297|    377|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (297:14): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  890|    377|        return XMLP_ret::XML_ERROR;
  891|    377|    }
  892|       |
  893|      0|    while (nullptr != p_aux0)
  ------------------
  |  Branch (893:12): [True: 0, False: 0]
  ------------------
  894|      0|    {
  895|      0|        std::string text = get_element_text(p_aux0);
  896|      0|        if (text.empty())
  ------------------
  |  Branch (896:13): [True: 0, False: 0]
  ------------------
  897|      0|        {
  898|      0|            EPROSIMA_LOG_ERROR(XMLPARSER, "Node '" << TRANSPORT_ID << "' without content");
  ------------------
  |  |   45|      0|#define EPROSIMA_LOG_ERROR(cat, msg) EPROSIMA_LOG_ERROR_IMPL_(cat, msg)
  |  |  ------------------
  |  |  |  |  291|      0|    do {                                                                                                               \
  |  |  |  |  292|      0|        std::stringstream fastdds_log_ss_tmp__;                                                                        \
  |  |  |  |  293|      0|        fastdds_log_ss_tmp__ << msg;                                                                                   \
  |  |  |  |  294|      0|        eprosima::fastdds::dds::Log::QueueLog(                                                                         \
  |  |  |  |  295|      0|            fastdds_log_ss_tmp__.str(), eprosima::fastdds::dds::Log::Context{__FILE__, __LINE__, __func__, #cat},      \
  |  |  |  |  296|      0|            eprosima::fastdds::dds::Log::Kind::Error);                                                                 \
  |  |  |  |  297|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (297:14): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  899|      0|            return XMLP_ret::XML_ERROR;
  900|      0|        }
  901|      0|        else
  902|      0|        {
  903|      0|            std::shared_ptr<fastdds::rtps::TransportDescriptorInterface> pDescriptor =
  904|      0|                    XMLProfileManager::getTransportById(text);
  905|      0|            if (pDescriptor != nullptr)
  ------------------
  |  Branch (905:17): [True: 0, False: 0]
  ------------------
  906|      0|            {
  907|      0|                transports.emplace_back(pDescriptor);
  908|      0|            }
  909|      0|            else
  910|      0|            {
  911|      0|                EPROSIMA_LOG_ERROR(XMLPARSER, "Transport Node not found. Given ID: " << text);
  ------------------
  |  |   45|      0|#define EPROSIMA_LOG_ERROR(cat, msg) EPROSIMA_LOG_ERROR_IMPL_(cat, msg)
  |  |  ------------------
  |  |  |  |  291|      0|    do {                                                                                                               \
  |  |  |  |  292|      0|        std::stringstream fastdds_log_ss_tmp__;                                                                        \
  |  |  |  |  293|      0|        fastdds_log_ss_tmp__ << msg;                                                                                   \
  |  |  |  |  294|      0|        eprosima::fastdds::dds::Log::QueueLog(                                                                         \
  |  |  |  |  295|      0|            fastdds_log_ss_tmp__.str(), eprosima::fastdds::dds::Log::Context{__FILE__, __LINE__, __func__, #cat},      \
  |  |  |  |  296|      0|            eprosima::fastdds::dds::Log::Kind::Error);                                                                 \
  |  |  |  |  297|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (297:14): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  912|      0|                return XMLP_ret::XML_ERROR;
  913|      0|            }
  914|      0|        }
  915|      0|        p_aux0 = p_aux0->NextSiblingElement(TRANSPORT_ID);
  916|      0|    }
  917|       |
  918|      0|    return XMLP_ret::XML_OK;
  919|      0|}
_ZN8eprosima7fastdds9xmlparser9XMLParser34getXMLFlowControllerDescriptorListEPN8tinyxml210XMLElementERNSt3__16vectorINS6_10shared_ptrINS0_4rtps24FlowControllerDescriptorEEENS6_9allocatorISB_EEEEh:
  925|    135|{
  926|       |    /*
  927|       |        <xs:complexType name="flowControllerDescriptorListType">
  928|       |            <xs:sequence>
  929|       |                <xs:element name="flow_controller_descriptor" type="flowControllerDescriptorType" maxOccurs="unbounded"/>
  930|       |            </xs:sequence>
  931|       |        </xs:complexType>
  932|       |     */
  933|       |
  934|    135|    tinyxml2::XMLElement* p_aux0 = nullptr;
  935|    135|    p_aux0 = elem->FirstChildElement(FLOW_CONTROLLER_DESCRIPTOR);
  936|    135|    if (nullptr == p_aux0)
  ------------------
  |  Branch (936:9): [True: 135, False: 0]
  ------------------
  937|    135|    {
  938|    135|        EPROSIMA_LOG_ERROR(XMLPARSER, "Node '" << elem->Value() << "' without content");
  ------------------
  |  |   45|    135|#define EPROSIMA_LOG_ERROR(cat, msg) EPROSIMA_LOG_ERROR_IMPL_(cat, msg)
  |  |  ------------------
  |  |  |  |  291|    135|    do {                                                                                                               \
  |  |  |  |  292|    135|        std::stringstream fastdds_log_ss_tmp__;                                                                        \
  |  |  |  |  293|    135|        fastdds_log_ss_tmp__ << msg;                                                                                   \
  |  |  |  |  294|    135|        eprosima::fastdds::dds::Log::QueueLog(                                                                         \
  |  |  |  |  295|    135|            fastdds_log_ss_tmp__.str(), eprosima::fastdds::dds::Log::Context{__FILE__, __LINE__, __func__, #cat},      \
  |  |  |  |  296|    135|            eprosima::fastdds::dds::Log::Kind::Error);                                                                 \
  |  |  |  |  297|    135|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (297:14): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  939|    135|        return XMLP_ret::XML_ERROR;
  940|    135|    }
  941|       |
  942|      0|    while (nullptr != p_aux0)
  ------------------
  |  Branch (942:12): [True: 0, False: 0]
  ------------------
  943|      0|    {
  944|       |        /*
  945|       |            <xs:complexType name="flowControllerDescriptorType">
  946|       |                <xs:all>
  947|       |                    <xs:element name="name" type="string" minOccurs="1" maxOccurs="1"/>
  948|       |                    <xs:element name="scheduler" type="flowControllerSchedulerPolicy" minOccurs="0" maxOccurs="1"/>
  949|       |                    <xs:element name="max_bytes_per_period" type="int32" minOccurs="0" maxOccurs="1"/>
  950|       |                    <xs:element name="period_ms" type="uint64" minOccurs="0" maxOccurs="1"/>
  951|       |                    <xs:element name="sender_thread" type="threadSettingsType" minOccurs="0" maxOccurs="1"/>
  952|       |                </xs:all>
  953|       |            </xs:complexType>
  954|       |
  955|       |            <xs:simpleType name="flowControllerSchedulerPolicy">
  956|       |                <xs:restriction base="xs:string">
  957|       |                    <xs:enumeration value="FIFO" />
  958|       |                    <xs:enumeration value="ROUND_ROBIN" />
  959|       |                    <xs:enumeration value="HIGH_PRIORITY" />
  960|       |                    <xs:enumeration value="PRIORITY_WITH_RESERVATION" />
  961|       |                </xs:restriction>
  962|       |            </xs:simpleType>
  963|       |         */
  964|       |
  965|      0|        tinyxml2::XMLElement* p_aux1;
  966|      0|        bool name_defined = false;
  967|      0|        std::set<std::string> tags_present;
  968|       |
  969|      0|        auto flow_controller_descriptor = std::make_shared<FlowControllerDescriptor>();
  970|       |
  971|      0|        for (p_aux1 = p_aux0->FirstChildElement(); p_aux1 != NULL; p_aux1 = p_aux1->NextSiblingElement())
  ------------------
  |  Branch (971:52): [True: 0, False: 0]
  ------------------
  972|      0|        {
  973|      0|            const char* name = p_aux1->Name();
  974|       |
  975|      0|            if (tags_present.count(name) != 0)
  ------------------
  |  Branch (975:17): [True: 0, False: 0]
  ------------------
  976|      0|            {
  977|      0|                EPROSIMA_LOG_ERROR(XMLPARSER,
  ------------------
  |  |   45|      0|#define EPROSIMA_LOG_ERROR(cat, msg) EPROSIMA_LOG_ERROR_IMPL_(cat, msg)
  |  |  ------------------
  |  |  |  |  291|      0|    do {                                                                                                               \
  |  |  |  |  292|      0|        std::stringstream fastdds_log_ss_tmp__;                                                                        \
  |  |  |  |  293|      0|        fastdds_log_ss_tmp__ << msg;                                                                                   \
  |  |  |  |  294|      0|        eprosima::fastdds::dds::Log::QueueLog(                                                                         \
  |  |  |  |  295|      0|            fastdds_log_ss_tmp__.str(), eprosima::fastdds::dds::Log::Context{__FILE__, __LINE__, __func__, #cat},      \
  |  |  |  |  296|      0|            eprosima::fastdds::dds::Log::Kind::Error);                                                                 \
  |  |  |  |  297|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (297:14): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  978|      0|                        "Duplicated element found in 'flowControllerDescriptorType'. Name: " << name);
  979|      0|                return XMLP_ret::XML_ERROR;
  980|      0|            }
  981|      0|            else
  982|      0|            {
  983|      0|                tags_present.emplace(name);
  984|      0|            }
  985|       |
  986|      0|            if (strcmp(name, NAME) == 0)
  ------------------
  |  Branch (986:17): [True: 0, False: 0]
  ------------------
  987|      0|            {
  988|       |                // name - stringType
  989|      0|                flow_controller_descriptor->name = get_element_text(p_aux1);
  990|      0|                if (flow_controller_descriptor->name.empty())
  ------------------
  |  Branch (990:21): [True: 0, False: 0]
  ------------------
  991|      0|                {
  992|      0|                    EPROSIMA_LOG_ERROR(XMLPARSER, "<" << p_aux1->Value() << "> getXMLString XML_ERROR!");
  ------------------
  |  |   45|      0|#define EPROSIMA_LOG_ERROR(cat, msg) EPROSIMA_LOG_ERROR_IMPL_(cat, msg)
  |  |  ------------------
  |  |  |  |  291|      0|    do {                                                                                                               \
  |  |  |  |  292|      0|        std::stringstream fastdds_log_ss_tmp__;                                                                        \
  |  |  |  |  293|      0|        fastdds_log_ss_tmp__ << msg;                                                                                   \
  |  |  |  |  294|      0|        eprosima::fastdds::dds::Log::QueueLog(                                                                         \
  |  |  |  |  295|      0|            fastdds_log_ss_tmp__.str(), eprosima::fastdds::dds::Log::Context{__FILE__, __LINE__, __func__, #cat},      \
  |  |  |  |  296|      0|            eprosima::fastdds::dds::Log::Kind::Error);                                                                 \
  |  |  |  |  297|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (297:14): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  993|      0|                    return XMLP_ret::XML_ERROR;
  994|      0|                }
  995|      0|                name_defined = true;
  996|      0|            }
  997|      0|            else if (strcmp(name, SCHEDULER) == 0)
  ------------------
  |  Branch (997:22): [True: 0, False: 0]
  ------------------
  998|      0|            {
  999|      0|                std::string text = get_element_text(p_aux1);
 1000|      0|                if (text.empty())
  ------------------
  |  Branch (1000:21): [True: 0, False: 0]
  ------------------
 1001|      0|                {
 1002|      0|                    EPROSIMA_LOG_ERROR(XMLPARSER, "Node '" << SCHEDULER << "' without content");
  ------------------
  |  |   45|      0|#define EPROSIMA_LOG_ERROR(cat, msg) EPROSIMA_LOG_ERROR_IMPL_(cat, msg)
  |  |  ------------------
  |  |  |  |  291|      0|    do {                                                                                                               \
  |  |  |  |  292|      0|        std::stringstream fastdds_log_ss_tmp__;                                                                        \
  |  |  |  |  293|      0|        fastdds_log_ss_tmp__ << msg;                                                                                   \
  |  |  |  |  294|      0|        eprosima::fastdds::dds::Log::QueueLog(                                                                         \
  |  |  |  |  295|      0|            fastdds_log_ss_tmp__.str(), eprosima::fastdds::dds::Log::Context{__FILE__, __LINE__, __func__, #cat},      \
  |  |  |  |  296|      0|            eprosima::fastdds::dds::Log::Kind::Error);                                                                 \
  |  |  |  |  297|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (297:14): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1003|      0|                    return XMLP_ret::XML_ERROR;
 1004|      0|                }
 1005|       |
 1006|       |                // scheduler - flowControllerSchedulerPolicy
 1007|      0|                if (!get_element_enum_value(text.c_str(), flow_controller_descriptor->scheduler,
  ------------------
  |  Branch (1007:21): [True: 0, False: 0]
  ------------------
 1008|      0|                        FIFO, FlowControllerSchedulerPolicy::FIFO,
 1009|      0|                        HIGH_PRIORITY, FlowControllerSchedulerPolicy::HIGH_PRIORITY,
 1010|      0|                        ROUND_ROBIN, FlowControllerSchedulerPolicy::ROUND_ROBIN,
 1011|      0|                        PRIORITY_WITH_RESERVATION, FlowControllerSchedulerPolicy::PRIORITY_WITH_RESERVATION))
 1012|      0|                {
 1013|      0|                    EPROSIMA_LOG_ERROR(XMLPARSER, "Node '" << SCHEDULER << "' with bad content");
  ------------------
  |  |   45|      0|#define EPROSIMA_LOG_ERROR(cat, msg) EPROSIMA_LOG_ERROR_IMPL_(cat, msg)
  |  |  ------------------
  |  |  |  |  291|      0|    do {                                                                                                               \
  |  |  |  |  292|      0|        std::stringstream fastdds_log_ss_tmp__;                                                                        \
  |  |  |  |  293|      0|        fastdds_log_ss_tmp__ << msg;                                                                                   \
  |  |  |  |  294|      0|        eprosima::fastdds::dds::Log::QueueLog(                                                                         \
  |  |  |  |  295|      0|            fastdds_log_ss_tmp__.str(), eprosima::fastdds::dds::Log::Context{__FILE__, __LINE__, __func__, #cat},      \
  |  |  |  |  296|      0|            eprosima::fastdds::dds::Log::Kind::Error);                                                                 \
  |  |  |  |  297|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (297:14): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1014|      0|                    return XMLP_ret::XML_ERROR;
 1015|      0|                }
 1016|      0|            }
 1017|      0|            else if (strcmp(name, MAX_BYTES_PER_PERIOD) == 0)
  ------------------
  |  Branch (1017:22): [True: 0, False: 0]
  ------------------
 1018|      0|            {
 1019|       |                // max_bytes_per_period - int32Type
 1020|      0|                if (XMLP_ret::XML_OK != getXMLInt(p_aux1, &flow_controller_descriptor->max_bytes_per_period, ident))
  ------------------
  |  Branch (1020:21): [True: 0, False: 0]
  ------------------
 1021|      0|                {
 1022|      0|                    return XMLP_ret::XML_ERROR;
 1023|      0|                }
 1024|      0|            }
 1025|      0|            else if (strcmp(name, PERIOD_MILLISECS) == 0)
  ------------------
  |  Branch (1025:22): [True: 0, False: 0]
  ------------------
 1026|      0|            {
 1027|       |                // period_ms - uint64Type
 1028|      0|                if (XMLP_ret::XML_OK != getXMLUint(p_aux1, &flow_controller_descriptor->period_ms, ident))
  ------------------
  |  Branch (1028:21): [True: 0, False: 0]
  ------------------
 1029|      0|                {
 1030|      0|                    return XMLP_ret::XML_ERROR;
 1031|      0|                }
 1032|      0|            }
 1033|      0|            else if (strcmp(name, SENDER_THREAD) == 0)
  ------------------
  |  Branch (1033:22): [True: 0, False: 0]
  ------------------
 1034|      0|            {
 1035|       |                // sender_thread - threadSettingsType
 1036|      0|                getXMLThreadSettings(*p_aux1, flow_controller_descriptor->sender_thread);
 1037|      0|            }
 1038|      0|            else
 1039|      0|            {
 1040|      0|                EPROSIMA_LOG_ERROR(XMLPARSER,
  ------------------
  |  |   45|      0|#define EPROSIMA_LOG_ERROR(cat, msg) EPROSIMA_LOG_ERROR_IMPL_(cat, msg)
  |  |  ------------------
  |  |  |  |  291|      0|    do {                                                                                                               \
  |  |  |  |  292|      0|        std::stringstream fastdds_log_ss_tmp__;                                                                        \
  |  |  |  |  293|      0|        fastdds_log_ss_tmp__ << msg;                                                                                   \
  |  |  |  |  294|      0|        eprosima::fastdds::dds::Log::QueueLog(                                                                         \
  |  |  |  |  295|      0|            fastdds_log_ss_tmp__.str(), eprosima::fastdds::dds::Log::Context{__FILE__, __LINE__, __func__, #cat},      \
  |  |  |  |  296|      0|            eprosima::fastdds::dds::Log::Kind::Error);                                                                 \
  |  |  |  |  297|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (297:14): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1041|      0|                        "Invalid element found into 'flowControllerDescriptorType'. Name: " << name);
 1042|      0|                return XMLP_ret::XML_ERROR;
 1043|      0|            }
 1044|      0|        }
 1045|       |
 1046|      0|        if (!name_defined)
  ------------------
  |  Branch (1046:13): [True: 0, False: 0]
  ------------------
 1047|      0|        {
 1048|      0|            EPROSIMA_LOG_ERROR(XMLPARSER, "Flow Controller Descriptor requires a 'name'");
  ------------------
  |  |   45|      0|#define EPROSIMA_LOG_ERROR(cat, msg) EPROSIMA_LOG_ERROR_IMPL_(cat, msg)
  |  |  ------------------
  |  |  |  |  291|      0|    do {                                                                                                               \
  |  |  |  |  292|      0|        std::stringstream fastdds_log_ss_tmp__;                                                                        \
  |  |  |  |  293|      0|        fastdds_log_ss_tmp__ << msg;                                                                                   \
  |  |  |  |  294|      0|        eprosima::fastdds::dds::Log::QueueLog(                                                                         \
  |  |  |  |  295|      0|            fastdds_log_ss_tmp__.str(), eprosima::fastdds::dds::Log::Context{__FILE__, __LINE__, __func__, #cat},      \
  |  |  |  |  296|      0|            eprosima::fastdds::dds::Log::Kind::Error);                                                                 \
  |  |  |  |  297|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (297:14): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1049|      0|            return XMLP_ret::XML_ERROR;
 1050|      0|        }
 1051|       |
 1052|      0|        flow_controller_descriptor_list.push_back(flow_controller_descriptor);
 1053|      0|        p_aux0 = p_aux0->NextSiblingElement(FLOW_CONTROLLER_DESCRIPTOR);
 1054|      0|    }
 1055|       |
 1056|      0|    return XMLP_ret::XML_OK;
 1057|      0|}
_ZN8eprosima7fastdds9xmlparser9XMLParser21getXMLTopicAttributesEPN8tinyxml210XMLElementERNS1_15TopicAttributesEh:
 1063|  27.8k|{
 1064|       |    /*
 1065|       |        <xs:complexType name="topicAttributesType">
 1066|       |            <xs:all minOccurs="0">
 1067|       |                <xs:element name="kind" type="topicKindType" minOccurs="0"/>
 1068|       |                <xs:element name="name" type="stringType" minOccurs="0"/>
 1069|       |                <xs:element name="dataType" type="stringType" minOccurs="0"/>
 1070|       |                <xs:element name="historyQos" type="historyQosPolicyType" minOccurs="0"/>
 1071|       |                <xs:element name="resourceLimitsQos" type="resourceLimitsQosPolicyType" minOccurs="0"/>
 1072|       |            </xs:all>
 1073|       |        </xs:complexType>
 1074|       |     */
 1075|  27.8k|    tinyxml2::XMLElement* p_aux0 = nullptr;
 1076|  27.8k|    const char* name = nullptr;
 1077|  32.6k|    for (p_aux0 = elem->FirstChildElement(); p_aux0 != NULL; p_aux0 = p_aux0->NextSiblingElement())
  ------------------
  |  Branch (1077:46): [True: 8.64k, False: 23.9k]
  ------------------
 1078|  8.64k|    {
 1079|  8.64k|        name = p_aux0->Name();
 1080|  8.64k|        if (strcmp(name, KIND) == 0)
  ------------------
  |  Branch (1080:13): [True: 1.80k, False: 6.84k]
  ------------------
 1081|  1.80k|        {
 1082|       |            // kind
 1083|       |            /*
 1084|       |                <xs:simpleType name="topicKindType">
 1085|       |                    <xs:restriction base="xs:string">
 1086|       |                        <xs:enumeration value="NO_KEY"/>
 1087|       |                        <xs:enumeration value="WITH_KEY"/>
 1088|       |                    </xs:restriction>
 1089|       |                </xs:simpleType>
 1090|       |             */
 1091|  1.80k|            std::string text = get_element_text(p_aux0);
 1092|  1.80k|            if (text.empty())
  ------------------
  |  Branch (1092:17): [True: 89, False: 1.71k]
  ------------------
 1093|     89|            {
 1094|     89|                EPROSIMA_LOG_ERROR(XMLPARSER, "Node '" << KIND << "' without content");
  ------------------
  |  |   45|     89|#define EPROSIMA_LOG_ERROR(cat, msg) EPROSIMA_LOG_ERROR_IMPL_(cat, msg)
  |  |  ------------------
  |  |  |  |  291|     89|    do {                                                                                                               \
  |  |  |  |  292|     89|        std::stringstream fastdds_log_ss_tmp__;                                                                        \
  |  |  |  |  293|     89|        fastdds_log_ss_tmp__ << msg;                                                                                   \
  |  |  |  |  294|     89|        eprosima::fastdds::dds::Log::QueueLog(                                                                         \
  |  |  |  |  295|     89|            fastdds_log_ss_tmp__.str(), eprosima::fastdds::dds::Log::Context{__FILE__, __LINE__, __func__, #cat},      \
  |  |  |  |  296|     89|            eprosima::fastdds::dds::Log::Kind::Error);                                                                 \
  |  |  |  |  297|     89|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (297:14): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1095|     89|                return XMLP_ret::XML_ERROR;
 1096|     89|            }
 1097|       |
 1098|  1.71k|            if (!get_element_enum_value(text.c_str(), topic.topicKind,
  ------------------
  |  Branch (1098:17): [True: 794, False: 920]
  ------------------
 1099|  1.71k|                    _NO_KEY, TopicKind_t::NO_KEY,
 1100|  1.71k|                    _WITH_KEY, TopicKind_t::WITH_KEY))
 1101|    794|            {
 1102|    794|                EPROSIMA_LOG_ERROR(XMLPARSER, "Node '" << KIND << "' with bad content");
  ------------------
  |  |   45|    794|#define EPROSIMA_LOG_ERROR(cat, msg) EPROSIMA_LOG_ERROR_IMPL_(cat, msg)
  |  |  ------------------
  |  |  |  |  291|    794|    do {                                                                                                               \
  |  |  |  |  292|    794|        std::stringstream fastdds_log_ss_tmp__;                                                                        \
  |  |  |  |  293|    794|        fastdds_log_ss_tmp__ << msg;                                                                                   \
  |  |  |  |  294|    794|        eprosima::fastdds::dds::Log::QueueLog(                                                                         \
  |  |  |  |  295|    794|            fastdds_log_ss_tmp__.str(), eprosima::fastdds::dds::Log::Context{__FILE__, __LINE__, __func__, #cat},      \
  |  |  |  |  296|    794|            eprosima::fastdds::dds::Log::Kind::Error);                                                                 \
  |  |  |  |  297|    794|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (297:14): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1103|    794|                return XMLP_ret::XML_ERROR;
 1104|    794|            }
 1105|  1.71k|        }
 1106|  6.84k|        else if (strcmp(name, NAME) == 0)
  ------------------
  |  Branch (1106:18): [True: 2.86k, False: 3.97k]
  ------------------
 1107|  2.86k|        {
 1108|       |            // name - stringType
 1109|  2.86k|            std::string text = get_element_text(p_aux0);
 1110|  2.86k|            if (text.empty())
  ------------------
  |  Branch (1110:17): [True: 715, False: 2.14k]
  ------------------
 1111|    715|            {
 1112|    715|                EPROSIMA_LOG_ERROR(XMLPARSER, "<" << p_aux0->Value() << "> getXMLString XML_ERROR!");
  ------------------
  |  |   45|    715|#define EPROSIMA_LOG_ERROR(cat, msg) EPROSIMA_LOG_ERROR_IMPL_(cat, msg)
  |  |  ------------------
  |  |  |  |  291|    715|    do {                                                                                                               \
  |  |  |  |  292|    715|        std::stringstream fastdds_log_ss_tmp__;                                                                        \
  |  |  |  |  293|    715|        fastdds_log_ss_tmp__ << msg;                                                                                   \
  |  |  |  |  294|    715|        eprosima::fastdds::dds::Log::QueueLog(                                                                         \
  |  |  |  |  295|    715|            fastdds_log_ss_tmp__.str(), eprosima::fastdds::dds::Log::Context{__FILE__, __LINE__, __func__, #cat},      \
  |  |  |  |  296|    715|            eprosima::fastdds::dds::Log::Kind::Error);                                                                 \
  |  |  |  |  297|    715|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (297:14): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1113|    715|                return XMLP_ret::XML_ERROR;
 1114|    715|            }
 1115|  2.14k|            topic.topicName = text;
 1116|  2.14k|        }
 1117|  3.97k|        else if (strcmp(name, DATA_TYPE) == 0)
  ------------------
  |  Branch (1117:18): [True: 732, False: 3.24k]
  ------------------
 1118|    732|        {
 1119|       |            // dataType - stringType
 1120|    732|            std::string text = get_element_text(p_aux0);
 1121|    732|            if (text.empty())
  ------------------
  |  Branch (1121:17): [True: 36, False: 696]
  ------------------
 1122|     36|            {
 1123|     36|                EPROSIMA_LOG_ERROR(XMLPARSER, "<" << p_aux0->Value() << "> getXMLString XML_ERROR!");
  ------------------
  |  |   45|     36|#define EPROSIMA_LOG_ERROR(cat, msg) EPROSIMA_LOG_ERROR_IMPL_(cat, msg)
  |  |  ------------------
  |  |  |  |  291|     36|    do {                                                                                                               \
  |  |  |  |  292|     36|        std::stringstream fastdds_log_ss_tmp__;                                                                        \
  |  |  |  |  293|     36|        fastdds_log_ss_tmp__ << msg;                                                                                   \
  |  |  |  |  294|     36|        eprosima::fastdds::dds::Log::QueueLog(                                                                         \
  |  |  |  |  295|     36|            fastdds_log_ss_tmp__.str(), eprosima::fastdds::dds::Log::Context{__FILE__, __LINE__, __func__, #cat},      \
  |  |  |  |  296|     36|            eprosima::fastdds::dds::Log::Kind::Error);                                                                 \
  |  |  |  |  297|     36|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (297:14): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1124|     36|                return XMLP_ret::XML_ERROR;
 1125|     36|            }
 1126|    696|            topic.topicDataType = text;
 1127|    696|        }
 1128|  3.24k|        else if (strcmp(name, HISTORY_QOS) == 0)
  ------------------
  |  Branch (1128:18): [True: 1.60k, False: 1.64k]
  ------------------
 1129|  1.60k|        {
 1130|       |            // historyQos
 1131|  1.60k|            if (XMLP_ret::XML_OK != getXMLHistoryQosPolicy(p_aux0, topic.historyQos, ident))
  ------------------
  |  Branch (1131:17): [True: 1.03k, False: 573]
  ------------------
 1132|  1.03k|            {
 1133|  1.03k|                return XMLP_ret::XML_ERROR;
 1134|  1.03k|            }
 1135|  1.60k|        }
 1136|  1.64k|        else if (strcmp(name, RES_LIMITS_QOS) == 0)
  ------------------
  |  Branch (1136:18): [True: 431, False: 1.21k]
  ------------------
 1137|    431|        {
 1138|       |            // resourceLimitsQos
 1139|    431|            if (XMLP_ret::XML_OK != getXMLResourceLimitsQos(p_aux0, topic.resourceLimitsQos, ident))
  ------------------
  |  Branch (1139:17): [True: 0, False: 431]
  ------------------
 1140|      0|            {
 1141|      0|                return XMLP_ret::XML_ERROR;
 1142|      0|            }
 1143|    431|        }
 1144|  1.21k|        else
 1145|  1.21k|        {
 1146|  1.21k|            EPROSIMA_LOG_ERROR(XMLPARSER, "Invalid element found into 'topicAttributesType'. Name: " << name);
  ------------------
  |  |   45|  1.21k|#define EPROSIMA_LOG_ERROR(cat, msg) EPROSIMA_LOG_ERROR_IMPL_(cat, msg)
  |  |  ------------------
  |  |  |  |  291|  1.21k|    do {                                                                                                               \
  |  |  |  |  292|  1.21k|        std::stringstream fastdds_log_ss_tmp__;                                                                        \
  |  |  |  |  293|  1.21k|        fastdds_log_ss_tmp__ << msg;                                                                                   \
  |  |  |  |  294|  1.21k|        eprosima::fastdds::dds::Log::QueueLog(                                                                         \
  |  |  |  |  295|  1.21k|            fastdds_log_ss_tmp__.str(), eprosima::fastdds::dds::Log::Context{__FILE__, __LINE__, __func__, #cat},      \
  |  |  |  |  296|  1.21k|            eprosima::fastdds::dds::Log::Kind::Error);                                                                 \
  |  |  |  |  297|  1.21k|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (297:14): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1147|  1.21k|            return XMLP_ret::XML_ERROR;
 1148|  1.21k|        }
 1149|  8.64k|    }
 1150|  23.9k|    return XMLP_ret::XML_OK;
 1151|  27.8k|}
_ZN8eprosima7fastdds9xmlparser9XMLParser23getXMLResourceLimitsQosEPN8tinyxml210XMLElementERNS0_3dds23ResourceLimitsQosPolicyEh:
 1157|    431|{
 1158|       |    /*
 1159|       |        <xs:complexType name="resourceLimitsQosPolicyType">
 1160|       |            <xs:all minOccurs="0">
 1161|       |                <xs:element name="max_samples" type="int32Type" minOccurs="0"/>
 1162|       |                <xs:element name="max_instances" type="int32Type" minOccurs="0"/>
 1163|       |                <xs:element name="max_samples_per_instance" type="int32Type" minOccurs="0"/>
 1164|       |                <xs:element name="allocated_samples" type="int32Type" minOccurs="0"/>
 1165|       |                <xs:element name="extra_samples" type="int32Type" minOccurs="0"/>
 1166|       |            </xs:all>
 1167|       |        </xs:complexType>
 1168|       |     */
 1169|       |
 1170|    431|    tinyxml2::XMLElement* p_aux0 = nullptr;
 1171|    431|    const char* name = nullptr;
 1172|    431|    for (p_aux0 = elem->FirstChildElement(); p_aux0 != NULL; p_aux0 = p_aux0->NextSiblingElement())
  ------------------
  |  Branch (1172:46): [True: 0, False: 431]
  ------------------
 1173|      0|    {
 1174|      0|        name = p_aux0->Name();
 1175|      0|        if (strcmp(name, MAX_SAMPLES) == 0)
  ------------------
  |  Branch (1175:13): [True: 0, False: 0]
  ------------------
 1176|      0|        {
 1177|       |            // max_samples - int32Type
 1178|      0|            if (XMLP_ret::XML_OK != getXMLInt(p_aux0, &resourceLimitsQos.max_samples, ident))
  ------------------
  |  Branch (1178:17): [True: 0, False: 0]
  ------------------
 1179|      0|            {
 1180|      0|                return XMLP_ret::XML_ERROR;
 1181|      0|            }
 1182|      0|        }
 1183|      0|        else if (strcmp(name, MAX_INSTANCES) == 0)
  ------------------
  |  Branch (1183:18): [True: 0, False: 0]
  ------------------
 1184|      0|        {
 1185|       |            // max_instances - int32Type
 1186|      0|            if (XMLP_ret::XML_OK != getXMLInt(p_aux0, &resourceLimitsQos.max_instances, ident))
  ------------------
  |  Branch (1186:17): [True: 0, False: 0]
  ------------------
 1187|      0|            {
 1188|      0|                return XMLP_ret::XML_ERROR;
 1189|      0|            }
 1190|      0|        }
 1191|      0|        else if (strcmp(name, MAX_SAMPLES_INSTANCE) == 0)
  ------------------
  |  Branch (1191:18): [True: 0, False: 0]
  ------------------
 1192|      0|        {
 1193|       |            // max_samples_per_instance - int32Type
 1194|      0|            if (XMLP_ret::XML_OK != getXMLInt(p_aux0, &resourceLimitsQos.max_samples_per_instance, ident))
  ------------------
  |  Branch (1194:17): [True: 0, False: 0]
  ------------------
 1195|      0|            {
 1196|      0|                return XMLP_ret::XML_ERROR;
 1197|      0|            }
 1198|      0|        }
 1199|      0|        else if (strcmp(name, ALLOCATED_SAMPLES) == 0)
  ------------------
  |  Branch (1199:18): [True: 0, False: 0]
  ------------------
 1200|      0|        {
 1201|       |            // allocated_samples - int32Type
 1202|      0|            if (XMLP_ret::XML_OK != getXMLInt(p_aux0, &resourceLimitsQos.allocated_samples, ident))
  ------------------
  |  Branch (1202:17): [True: 0, False: 0]
  ------------------
 1203|      0|            {
 1204|      0|                return XMLP_ret::XML_ERROR;
 1205|      0|            }
 1206|      0|        }
 1207|      0|        else if (strcmp(name, EXTRA_SAMPLES) == 0)
  ------------------
  |  Branch (1207:18): [True: 0, False: 0]
  ------------------
 1208|      0|        {
 1209|       |            // extra_samples - int32Type
 1210|      0|            if (XMLP_ret::XML_OK != getXMLInt(p_aux0, &resourceLimitsQos.extra_samples, ident))
  ------------------
  |  Branch (1210:17): [True: 0, False: 0]
  ------------------
 1211|      0|            {
 1212|      0|                return XMLP_ret::XML_ERROR;
 1213|      0|            }
 1214|      0|        }
 1215|      0|        else
 1216|      0|        {
 1217|      0|            EPROSIMA_LOG_ERROR(XMLPARSER, "Invalid element found into 'resourceLimitsQosPolicyType'. Name: " << name);
  ------------------
  |  |   45|      0|#define EPROSIMA_LOG_ERROR(cat, msg) EPROSIMA_LOG_ERROR_IMPL_(cat, msg)
  |  |  ------------------
  |  |  |  |  291|      0|    do {                                                                                                               \
  |  |  |  |  292|      0|        std::stringstream fastdds_log_ss_tmp__;                                                                        \
  |  |  |  |  293|      0|        fastdds_log_ss_tmp__ << msg;                                                                                   \
  |  |  |  |  294|      0|        eprosima::fastdds::dds::Log::QueueLog(                                                                         \
  |  |  |  |  295|      0|            fastdds_log_ss_tmp__.str(), eprosima::fastdds::dds::Log::Context{__FILE__, __LINE__, __func__, #cat},      \
  |  |  |  |  296|      0|            eprosima::fastdds::dds::Log::Kind::Error);                                                                 \
  |  |  |  |  297|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (297:14): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1218|      0|            return XMLP_ret::XML_ERROR;
 1219|      0|        }
 1220|      0|    }
 1221|       |
 1222|    431|    return XMLP_ret::XML_OK;
 1223|    431|}
_ZN8eprosima7fastdds9xmlparser9XMLParser31getXMLContainerAllocationConfigEPN8tinyxml210XMLElementERNS0_30ResourceLimitedContainerConfigEh:
 1229|    691|{
 1230|       |    /*
 1231|       |        <xs:complexType name="containerAllocationConfigType">
 1232|       |            <xs:all minOccurs="0">
 1233|       |                <xs:element name="initial" type="uint32Type" minOccurs="0"/>
 1234|       |                <xs:element name="maximum" type="uint32Type" minOccurs="0"/>
 1235|       |                <xs:element name="increment" type="uint32Type" minOccurs="0"/>
 1236|       |            </xs:all>
 1237|       |        </xs:complexType>
 1238|       |     */
 1239|       |
 1240|       |    // First set default values
 1241|    691|    allocation_config = ResourceLimitedContainerConfig();
 1242|       |
 1243|       |    // Then parse XML
 1244|    691|    uint32_t aux_value;
 1245|    691|    tinyxml2::XMLElement* p_aux0 = nullptr;
 1246|    691|    const char* name = nullptr;
 1247|    691|    for (p_aux0 = elem->FirstChildElement(); p_aux0 != NULL; p_aux0 = p_aux0->NextSiblingElement())
  ------------------
  |  Branch (1247:46): [True: 0, False: 691]
  ------------------
 1248|      0|    {
 1249|      0|        name = p_aux0->Name();
 1250|      0|        if (strcmp(name, INITIAL) == 0)
  ------------------
  |  Branch (1250:13): [True: 0, False: 0]
  ------------------
 1251|      0|        {
 1252|       |            // initial - uint32Type
 1253|      0|            if (XMLP_ret::XML_OK != getXMLUint(p_aux0, &aux_value, ident))
  ------------------
  |  Branch (1253:17): [True: 0, False: 0]
  ------------------
 1254|      0|            {
 1255|      0|                return XMLP_ret::XML_ERROR;
 1256|      0|            }
 1257|      0|            allocation_config.initial = static_cast<size_t>(aux_value);
 1258|      0|        }
 1259|      0|        else if (strcmp(name, MAXIMUM) == 0)
  ------------------
  |  Branch (1259:18): [True: 0, False: 0]
  ------------------
 1260|      0|        {
 1261|       |            // maximum - uint32Type
 1262|      0|            if (XMLP_ret::XML_OK != getXMLUint(p_aux0, &aux_value, ident))
  ------------------
  |  Branch (1262:17): [True: 0, False: 0]
  ------------------
 1263|      0|            {
 1264|      0|                return XMLP_ret::XML_ERROR;
 1265|      0|            }
 1266|      0|            allocation_config.maximum = (aux_value == 0u) ?
  ------------------
  |  Branch (1266:41): [True: 0, False: 0]
  ------------------
 1267|      0|                    std::numeric_limits<size_t>::max() : static_cast<size_t>(aux_value);
 1268|      0|        }
 1269|      0|        else if (strcmp(name, INCREMENT) == 0)
  ------------------
  |  Branch (1269:18): [True: 0, False: 0]
  ------------------
 1270|      0|        {
 1271|       |            // increment - uint32Type
 1272|      0|            if (XMLP_ret::XML_OK != getXMLUint(p_aux0, &aux_value, ident))
  ------------------
  |  Branch (1272:17): [True: 0, False: 0]
  ------------------
 1273|      0|            {
 1274|      0|                return XMLP_ret::XML_ERROR;
 1275|      0|            }
 1276|      0|            allocation_config.increment = static_cast<size_t>(aux_value);
 1277|      0|        }
 1278|      0|        else
 1279|      0|        {
 1280|      0|            EPROSIMA_LOG_ERROR(XMLPARSER, "Invalid element found into 'containerAllocationConfigType'. Name: " << name);
  ------------------
  |  |   45|      0|#define EPROSIMA_LOG_ERROR(cat, msg) EPROSIMA_LOG_ERROR_IMPL_(cat, msg)
  |  |  ------------------
  |  |  |  |  291|      0|    do {                                                                                                               \
  |  |  |  |  292|      0|        std::stringstream fastdds_log_ss_tmp__;                                                                        \
  |  |  |  |  293|      0|        fastdds_log_ss_tmp__ << msg;                                                                                   \
  |  |  |  |  294|      0|        eprosima::fastdds::dds::Log::QueueLog(                                                                         \
  |  |  |  |  295|      0|            fastdds_log_ss_tmp__.str(), eprosima::fastdds::dds::Log::Context{__FILE__, __LINE__, __func__, #cat},      \
  |  |  |  |  296|      0|            eprosima::fastdds::dds::Log::Kind::Error);                                                                 \
  |  |  |  |  297|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (297:14): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1281|      0|            return XMLP_ret::XML_ERROR;
 1282|      0|        }
 1283|      0|    }
 1284|       |
 1285|       |    // Check results
 1286|    691|    if (allocation_config.initial > allocation_config.maximum)
  ------------------
  |  Branch (1286:9): [True: 0, False: 691]
  ------------------
 1287|      0|    {
 1288|      0|        EPROSIMA_LOG_ERROR(XMLPARSER,
  ------------------
  |  |   45|      0|#define EPROSIMA_LOG_ERROR(cat, msg) EPROSIMA_LOG_ERROR_IMPL_(cat, msg)
  |  |  ------------------
  |  |  |  |  291|      0|    do {                                                                                                               \
  |  |  |  |  292|      0|        std::stringstream fastdds_log_ss_tmp__;                                                                        \
  |  |  |  |  293|      0|        fastdds_log_ss_tmp__ << msg;                                                                                   \
  |  |  |  |  294|      0|        eprosima::fastdds::dds::Log::QueueLog(                                                                         \
  |  |  |  |  295|      0|            fastdds_log_ss_tmp__.str(), eprosima::fastdds::dds::Log::Context{__FILE__, __LINE__, __func__, #cat},      \
  |  |  |  |  296|      0|            eprosima::fastdds::dds::Log::Kind::Error);                                                                 \
  |  |  |  |  297|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (297:14): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1289|      0|                "Parsing 'containerAllocationConfigType': Field 'initial' cannot be greater than 'maximum'.");
 1290|      0|        return XMLP_ret::XML_ERROR;
 1291|      0|    }
 1292|    691|    else if ((allocation_config.increment == 0) && (allocation_config.initial != allocation_config.maximum))
  ------------------
  |  Branch (1292:14): [True: 0, False: 691]
  |  Branch (1292:52): [True: 0, False: 0]
  ------------------
 1293|      0|    {
 1294|      0|        EPROSIMA_LOG_ERROR(XMLPARSER, "Parsing 'containerAllocationConfigType': Field 'increment' cannot be zero.");
  ------------------
  |  |   45|      0|#define EPROSIMA_LOG_ERROR(cat, msg) EPROSIMA_LOG_ERROR_IMPL_(cat, msg)
  |  |  ------------------
  |  |  |  |  291|      0|    do {                                                                                                               \
  |  |  |  |  292|      0|        std::stringstream fastdds_log_ss_tmp__;                                                                        \
  |  |  |  |  293|      0|        fastdds_log_ss_tmp__ << msg;                                                                                   \
  |  |  |  |  294|      0|        eprosima::fastdds::dds::Log::QueueLog(                                                                         \
  |  |  |  |  295|      0|            fastdds_log_ss_tmp__.str(), eprosima::fastdds::dds::Log::Context{__FILE__, __LINE__, __func__, #cat},      \
  |  |  |  |  296|      0|            eprosima::fastdds::dds::Log::Kind::Error);                                                                 \
  |  |  |  |  297|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (297:14): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1295|      0|        return XMLP_ret::XML_ERROR;
 1296|      0|    }
 1297|       |
 1298|    691|    return XMLP_ret::XML_OK;
 1299|    691|}
_ZN8eprosima7fastdds9xmlparser9XMLParser22getXMLHistoryQosPolicyEPN8tinyxml210XMLElementERNS0_3dds16HistoryQosPolicyEh:
 1305|  1.60k|{
 1306|       |    /*
 1307|       |        <xs:complexType name="historyQosPolicyType">
 1308|       |            <xs:all minOccurs="0">
 1309|       |                <xs:element name="kind" type="historyQosKindType" minOccurs="0"/>
 1310|       |                <xs:element name="depth" type="int32Type" minOccurs="0"/>
 1311|       |            </xs:all>
 1312|       |        </xs:complexType>
 1313|       |     */
 1314|       |
 1315|  1.60k|    tinyxml2::XMLElement* p_aux0 = nullptr;
 1316|  1.60k|    const char* name = nullptr;
 1317|  2.30k|    for (p_aux0 = elem->FirstChildElement(); p_aux0 != NULL; p_aux0 = p_aux0->NextSiblingElement())
  ------------------
  |  Branch (1317:46): [True: 1.73k, False: 573]
  ------------------
 1318|  1.73k|    {
 1319|  1.73k|        name = p_aux0->Name();
 1320|  1.73k|        if (strcmp(name, KIND) == 0)
  ------------------
  |  Branch (1320:13): [True: 1.09k, False: 644]
  ------------------
 1321|  1.09k|        {
 1322|       |            // kind
 1323|       |            /*
 1324|       |                <xs:simpleType name="historyQosKindType">
 1325|       |                    <xs:restriction base="xs:string">
 1326|       |                        <xs:enumeration value="KEEP_LAST"/>
 1327|       |                        <xs:enumeration value="KEEP_ALL"/>
 1328|       |                    </xs:restriction>
 1329|       |                </xs:simpleType>
 1330|       |             */
 1331|  1.09k|            std::string text = get_element_text(p_aux0);
 1332|  1.09k|            if (text.empty())
  ------------------
  |  Branch (1332:17): [True: 330, False: 760]
  ------------------
 1333|    330|            {
 1334|    330|                EPROSIMA_LOG_ERROR(XMLPARSER, "Node '" << KIND << "' without content");
  ------------------
  |  |   45|    330|#define EPROSIMA_LOG_ERROR(cat, msg) EPROSIMA_LOG_ERROR_IMPL_(cat, msg)
  |  |  ------------------
  |  |  |  |  291|    330|    do {                                                                                                               \
  |  |  |  |  292|    330|        std::stringstream fastdds_log_ss_tmp__;                                                                        \
  |  |  |  |  293|    330|        fastdds_log_ss_tmp__ << msg;                                                                                   \
  |  |  |  |  294|    330|        eprosima::fastdds::dds::Log::QueueLog(                                                                         \
  |  |  |  |  295|    330|            fastdds_log_ss_tmp__.str(), eprosima::fastdds::dds::Log::Context{__FILE__, __LINE__, __func__, #cat},      \
  |  |  |  |  296|    330|            eprosima::fastdds::dds::Log::Kind::Error);                                                                 \
  |  |  |  |  297|    330|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (297:14): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1335|    330|                return XMLP_ret::XML_ERROR;
 1336|    330|            }
 1337|       |
 1338|    760|            if (!get_element_enum_value(text.c_str(), historyQos.kind,
  ------------------
  |  Branch (1338:17): [True: 407, False: 353]
  ------------------
 1339|    760|                    KEEP_LAST, dds::HistoryQosPolicyKind::KEEP_LAST_HISTORY_QOS,
 1340|    760|                    KEEP_ALL, dds::HistoryQosPolicyKind::KEEP_ALL_HISTORY_QOS))
 1341|    407|            {
 1342|    407|                EPROSIMA_LOG_ERROR(XMLPARSER, "Node '" << KIND << "' with bad content");
  ------------------
  |  |   45|    407|#define EPROSIMA_LOG_ERROR(cat, msg) EPROSIMA_LOG_ERROR_IMPL_(cat, msg)
  |  |  ------------------
  |  |  |  |  291|    407|    do {                                                                                                               \
  |  |  |  |  292|    407|        std::stringstream fastdds_log_ss_tmp__;                                                                        \
  |  |  |  |  293|    407|        fastdds_log_ss_tmp__ << msg;                                                                                   \
  |  |  |  |  294|    407|        eprosima::fastdds::dds::Log::QueueLog(                                                                         \
  |  |  |  |  295|    407|            fastdds_log_ss_tmp__.str(), eprosima::fastdds::dds::Log::Context{__FILE__, __LINE__, __func__, #cat},      \
  |  |  |  |  296|    407|            eprosima::fastdds::dds::Log::Kind::Error);                                                                 \
  |  |  |  |  297|    407|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (297:14): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1343|    407|                return XMLP_ret::XML_ERROR;
 1344|    407|            }
 1345|    760|        }
 1346|    644|        else if (strcmp(name, DEPTH) == 0)
  ------------------
  |  Branch (1346:18): [True: 422, False: 222]
  ------------------
 1347|    422|        {
 1348|       |            // depth - uint32Type
 1349|    422|            if (XMLP_ret::XML_OK != getXMLInt(p_aux0, &historyQos.depth, ident))
  ------------------
  |  Branch (1349:17): [True: 71, False: 351]
  ------------------
 1350|     71|            {
 1351|     71|                return XMLP_ret::XML_ERROR;
 1352|     71|            }
 1353|    422|        }
 1354|    222|        else
 1355|    222|        {
 1356|    222|            EPROSIMA_LOG_ERROR(XMLPARSER, "Invalid element found into 'historyQosPolicyType'. Name: " << name);
  ------------------
  |  |   45|    222|#define EPROSIMA_LOG_ERROR(cat, msg) EPROSIMA_LOG_ERROR_IMPL_(cat, msg)
  |  |  ------------------
  |  |  |  |  291|    222|    do {                                                                                                               \
  |  |  |  |  292|    222|        std::stringstream fastdds_log_ss_tmp__;                                                                        \
  |  |  |  |  293|    222|        fastdds_log_ss_tmp__ << msg;                                                                                   \
  |  |  |  |  294|    222|        eprosima::fastdds::dds::Log::QueueLog(                                                                         \
  |  |  |  |  295|    222|            fastdds_log_ss_tmp__.str(), eprosima::fastdds::dds::Log::Context{__FILE__, __LINE__, __func__, #cat},      \
  |  |  |  |  296|    222|            eprosima::fastdds::dds::Log::Kind::Error);                                                                 \
  |  |  |  |  297|    222|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (297:14): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1357|    222|            return XMLP_ret::XML_ERROR;
 1358|    222|        }
 1359|  1.73k|    }
 1360|       |
 1361|    573|    return XMLP_ret::XML_OK;
 1362|  1.60k|}
_ZN8eprosima7fastdds9xmlparser9XMLParser23getXMLWriterQosPoliciesEPN8tinyxml210XMLElementERNS0_3dds9WriterQosEh:
 1368|  6.09k|{
 1369|       |    /*
 1370|       |        <xs:complexType name="writerQosPoliciesType">
 1371|       |            <xs:all minOccurs="0">
 1372|       |                <xs:element name="durability" type="durabilityQosPolicyType" minOccurs="0"/>
 1373|       |                <xs:element name="durabilityService" type="durabilityServiceQosPolicyType" minOccurs="0"/>
 1374|       |                <xs:element name="deadline" type="deadlineQosPolicyType" minOccurs="0"/>
 1375|       |                <xs:element name="latencyBudget" type="latencyBudgetQosPolicyType" minOccurs="0"/>
 1376|       |                <xs:element name="liveliness" type="livelinessQosPolicyType" minOccurs="0"/>
 1377|       |                <xs:element name="reliability" type="reliabilityQosPolicyType" minOccurs="0"/>
 1378|       |                <xs:element name="lifespan" type="lifespanQosPolicyType" minOccurs="0"/>
 1379|       |                <xs:element name="userData" type="userDataQosPolicyType" minOccurs="0"/>
 1380|       |                <xs:element name="timeBasedFilter" type="timeBasedFilterQosPolicyType" minOccurs="0"/>
 1381|       |                <xs:element name="ownership" type="ownershipQosPolicyType" minOccurs="0"/>
 1382|       |                <xs:element name="ownershipStrength" type="ownershipStrengthQosPolicyType" minOccurs="0"/>
 1383|       |                <xs:element name="destinationOrder" type="destinationOrderQosPolicyType" minOccurs="0"/>
 1384|       |                <xs:element name="presentation" type="presentationQosPolicyType" minOccurs="0"/>
 1385|       |                <xs:element name="partition" type="partitionQosPolicyType" minOccurs="0"/>
 1386|       |                <xs:element name="topicData" type="topicDataQosPolicyType" minOccurs="0"/>
 1387|       |                <xs:element name="groupData" type="groupDataQosPolicyType" minOccurs="0"/>
 1388|       |                <xs:element name="publishMode" type="publishModeQosPolicyType" minOccurs="0"/>
 1389|       |                <xs:element name="data_sharing" type="dataSharingQosPolicyType" minOccurs="0"/>
 1390|       |                <xs:element name="disablePositiveAcks" type="disablePositiveAcksQosPolicyType" minOccurs="0"/>
 1391|       |                <xs:element name="disable_heartbeat_piggyback" type="boolType" minOccurs="0"/>
 1392|       |            </xs:all>
 1393|       |        </xs:complexType>
 1394|       |     */
 1395|       |
 1396|  6.09k|    tinyxml2::XMLElement* p_aux0 = nullptr;
 1397|  6.09k|    const char* name = nullptr;
 1398|  9.39k|    for (p_aux0 = elem->FirstChildElement(); p_aux0 != NULL; p_aux0 = p_aux0->NextSiblingElement())
  ------------------
  |  Branch (1398:46): [True: 7.47k, False: 1.91k]
  ------------------
 1399|  7.47k|    {
 1400|  7.47k|        name = p_aux0->Name();
 1401|  7.47k|        if (strcmp(name, DURABILITY) == 0)
  ------------------
  |  Branch (1401:13): [True: 62, False: 7.41k]
  ------------------
 1402|     62|        {
 1403|       |            // durability
 1404|     62|            if (XMLP_ret::XML_OK != getXMLDurabilityQos(p_aux0, qos.m_durability, ident))
  ------------------
  |  Branch (1404:17): [True: 62, False: 0]
  ------------------
 1405|     62|            {
 1406|     62|                return XMLP_ret::XML_ERROR;
 1407|     62|            }
 1408|     62|        }
 1409|  7.41k|        else if (strcmp(name, LIVELINESS) == 0)
  ------------------
  |  Branch (1409:18): [True: 76, False: 7.34k]
  ------------------
 1410|     76|        {
 1411|       |            // liveliness
 1412|     76|            if (XMLP_ret::XML_OK != getXMLLivelinessQos(p_aux0, qos.m_liveliness, ident))
  ------------------
  |  Branch (1412:17): [True: 0, False: 76]
  ------------------
 1413|      0|            {
 1414|      0|                return XMLP_ret::XML_ERROR;
 1415|      0|            }
 1416|     76|        }
 1417|  7.34k|        else if (strcmp(name, RELIABILITY) == 0)
  ------------------
  |  Branch (1417:18): [True: 1.09k, False: 6.24k]
  ------------------
 1418|  1.09k|        {
 1419|       |            // reliability
 1420|  1.09k|            if (XMLP_ret::XML_OK != getXMLReliabilityQos(p_aux0, qos.m_reliability, ident))
  ------------------
  |  Branch (1420:17): [True: 938, False: 158]
  ------------------
 1421|    938|            {
 1422|    938|                return XMLP_ret::XML_ERROR;
 1423|    938|            }
 1424|  1.09k|        }
 1425|  6.24k|        else if (strcmp(name, PARTITION) == 0)
  ------------------
  |  Branch (1425:18): [True: 415, False: 5.82k]
  ------------------
 1426|    415|        {
 1427|       |            // partition
 1428|    415|            if (XMLP_ret::XML_OK != getXMLPartitionQos(p_aux0, qos.m_partition, ident))
  ------------------
  |  Branch (1428:17): [True: 415, False: 0]
  ------------------
 1429|    415|            {
 1430|    415|                return XMLP_ret::XML_ERROR;
 1431|    415|            }
 1432|    415|        }
 1433|  5.82k|        else if (strcmp(name, PUB_MODE) == 0)
  ------------------
  |  Branch (1433:18): [True: 88, False: 5.74k]
  ------------------
 1434|     88|        {
 1435|       |            // publishMode
 1436|     88|            if (XMLP_ret::XML_OK != getXMLPublishModeQos(p_aux0, qos.m_publishMode, ident))
  ------------------
  |  Branch (1436:17): [True: 88, False: 0]
  ------------------
 1437|     88|            {
 1438|     88|                return XMLP_ret::XML_ERROR;
 1439|     88|            }
 1440|     88|        }
 1441|  5.74k|        else if (strcmp(name, DEADLINE) == 0)
  ------------------
  |  Branch (1441:18): [True: 121, False: 5.62k]
  ------------------
 1442|    121|        {
 1443|       |            // deadline
 1444|    121|            if (XMLP_ret::XML_OK != getXMLDeadlineQos(p_aux0, qos.m_deadline, ident))
  ------------------
  |  Branch (1444:17): [True: 121, False: 0]
  ------------------
 1445|    121|            {
 1446|    121|                return XMLP_ret::XML_ERROR;
 1447|    121|            }
 1448|    121|        }
 1449|  5.62k|        else if (strcmp(name, LIFESPAN) == 0)
  ------------------
  |  Branch (1449:18): [True: 171, False: 5.44k]
  ------------------
 1450|    171|        {
 1451|       |            // lifespan
 1452|    171|            if (XMLP_ret::XML_OK != getXMLLifespanQos(p_aux0, qos.m_lifespan, ident))
  ------------------
  |  Branch (1452:17): [True: 171, False: 0]
  ------------------
 1453|    171|            {
 1454|    171|                return XMLP_ret::XML_ERROR;
 1455|    171|            }
 1456|    171|        }
 1457|  5.44k|        else if (strcmp(name, DISABLE_POSITIVE_ACKS) == 0)
  ------------------
  |  Branch (1457:18): [True: 108, False: 5.34k]
  ------------------
 1458|    108|        {
 1459|       |            // Disable positive acks
 1460|    108|            if (XMLP_ret::XML_OK != getXMLDisablePositiveAcksQos(p_aux0, qos.m_disablePositiveACKs, ident))
  ------------------
  |  Branch (1460:17): [True: 0, False: 108]
  ------------------
 1461|      0|            {
 1462|      0|                return XMLP_ret::XML_ERROR;
 1463|      0|            }
 1464|    108|        }
 1465|  5.34k|        else if (strcmp(name, LATENCY_BUDGET) == 0)
  ------------------
  |  Branch (1465:18): [True: 79, False: 5.26k]
  ------------------
 1466|     79|        {
 1467|       |            //Latency Budget
 1468|     79|            if (XMLP_ret::XML_OK != getXMLLatencyBudgetQos(p_aux0, qos.m_latencyBudget, ident))
  ------------------
  |  Branch (1468:17): [True: 79, False: 0]
  ------------------
 1469|     79|            {
 1470|     79|                return XMLP_ret::XML_ERROR;
 1471|     79|            }
 1472|     79|        }
 1473|  5.26k|        else if (strcmp(name, DURABILITY_SRV) == 0 ||
  ------------------
  |  Branch (1473:18): [True: 282, False: 4.98k]
  ------------------
 1474|  5.26k|                strcmp(name, TIME_FILTER) == 0 || strcmp(name, DEST_ORDER) == 0 ||
  ------------------
  |  Branch (1474:17): [True: 113, False: 4.86k]
  |  Branch (1474:51): [True: 240, False: 4.62k]
  ------------------
 1475|  5.26k|                strcmp(name, PRESENTATION) == 0)
  ------------------
  |  Branch (1475:17): [True: 549, False: 4.07k]
  ------------------
 1476|  1.18k|        {
 1477|       |            // TODO: Do not supported for now
 1478|       |            //if (nullptr != (p_aux = elem->FirstChildElement(    DURABILITY_SRV))) getXMLDurabilityServiceQos(p_aux, ident);
 1479|       |            //if (nullptr != (p_aux = elem->FirstChildElement(       TIME_FILTER))) getXMLTimeBasedFilterQos(p_aux, ident);
 1480|       |            //if (nullptr != (p_aux = elem->FirstChildElement(        DEST_ORDER))) getXMLDestinationOrderQos(p_aux, ident);
 1481|       |            //if (nullptr != (p_aux = elem->FirstChildElement(      PRESENTATION))) getXMLPresentationQos(p_aux, ident);
 1482|  1.18k|            EPROSIMA_LOG_ERROR(XMLPARSER, "Quality of Service '" << p_aux0->Value() << "' do not supported for now");
  ------------------
  |  |   45|  1.18k|#define EPROSIMA_LOG_ERROR(cat, msg) EPROSIMA_LOG_ERROR_IMPL_(cat, msg)
  |  |  ------------------
  |  |  |  |  291|  1.18k|    do {                                                                                                               \
  |  |  |  |  292|  1.18k|        std::stringstream fastdds_log_ss_tmp__;                                                                        \
  |  |  |  |  293|  1.18k|        fastdds_log_ss_tmp__ << msg;                                                                                   \
  |  |  |  |  294|  1.18k|        eprosima::fastdds::dds::Log::QueueLog(                                                                         \
  |  |  |  |  295|  1.18k|            fastdds_log_ss_tmp__.str(), eprosima::fastdds::dds::Log::Context{__FILE__, __LINE__, __func__, #cat},      \
  |  |  |  |  296|  1.18k|            eprosima::fastdds::dds::Log::Kind::Error);                                                                 \
  |  |  |  |  297|  1.18k|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (297:14): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1483|  1.18k|        }
 1484|  4.07k|        else if (strcmp(name, DATA_SHARING) == 0)
  ------------------
  |  Branch (1484:18): [True: 52, False: 4.02k]
  ------------------
 1485|     52|        {
 1486|       |            //data sharing
 1487|     52|            if (XMLP_ret::XML_OK != getXMLDataSharingQos(p_aux0, qos.data_sharing, ident))
  ------------------
  |  Branch (1487:17): [True: 52, False: 0]
  ------------------
 1488|     52|            {
 1489|     52|                return XMLP_ret::XML_ERROR;
 1490|     52|            }
 1491|     52|        }
 1492|  4.02k|        else if (strcmp(name, OWNERSHIP) == 0)
  ------------------
  |  Branch (1492:18): [True: 48, False: 3.97k]
  ------------------
 1493|     48|        {
 1494|       |            //ownership
 1495|     48|            if (XMLP_ret::XML_OK != getXMLOwnershipQos(p_aux0, qos.m_ownership, ident))
  ------------------
  |  Branch (1495:17): [True: 48, False: 0]
  ------------------
 1496|     48|            {
 1497|     48|                return XMLP_ret::XML_ERROR;
 1498|     48|            }
 1499|     48|        }
 1500|  3.97k|        else if (strcmp(name, OWNERSHIP_STRENGTH) == 0)
  ------------------
  |  Branch (1500:18): [True: 265, False: 3.71k]
  ------------------
 1501|    265|        {
 1502|       |            //ownership
 1503|    265|            if (XMLP_ret::XML_OK != getXMLOwnershipStrengthQos(p_aux0, qos.m_ownershipStrength, ident))
  ------------------
  |  Branch (1503:17): [True: 265, False: 0]
  ------------------
 1504|    265|            {
 1505|    265|                return XMLP_ret::XML_ERROR;
 1506|    265|            }
 1507|    265|        }
 1508|  3.71k|        else if (strcmp(name, DISABLE_HEARTBEAT_PIGGYBACK) == 0)
  ------------------
  |  Branch (1508:18): [True: 61, False: 3.65k]
  ------------------
 1509|     61|        {
 1510|       |            // Disable heartbeat piggyback
 1511|     61|            if (XMLP_ret::XML_OK != getXMLBool(p_aux0, &qos.disable_heartbeat_piggyback, ident))
  ------------------
  |  Branch (1511:17): [True: 61, False: 0]
  ------------------
 1512|     61|            {
 1513|     61|                return XMLP_ret::XML_ERROR;
 1514|     61|            }
 1515|     61|        }
 1516|  3.65k|        else if (0 == strcmp(name, USER_DATA))
  ------------------
  |  Branch (1516:18): [True: 1.26k, False: 2.38k]
  ------------------
 1517|  1.26k|        {
 1518|       |            // userData
 1519|  1.26k|            if (XMLP_ret::XML_OK != getXMLOctetVector(p_aux0, qos.m_userData.data_vec(), ident))
  ------------------
  |  Branch (1519:17): [True: 0, False: 1.26k]
  ------------------
 1520|      0|            {
 1521|      0|                return XMLP_ret::XML_ERROR;
 1522|      0|            }
 1523|  1.26k|        }
 1524|  2.38k|        else if (0 == strcmp(name, TOPIC_DATA))
  ------------------
  |  Branch (1524:18): [True: 384, False: 2.00k]
  ------------------
 1525|    384|        {
 1526|       |            // userData
 1527|    384|            if (XMLP_ret::XML_OK != getXMLOctetVector(p_aux0, qos.m_topicData.data_vec(), ident))
  ------------------
  |  Branch (1527:17): [True: 0, False: 384]
  ------------------
 1528|      0|            {
 1529|      0|                return XMLP_ret::XML_ERROR;
 1530|      0|            }
 1531|    384|        }
 1532|  2.00k|        else if (0 == strcmp(name, GROUP_DATA))
  ------------------
  |  Branch (1532:18): [True: 119, False: 1.88k]
  ------------------
 1533|    119|        {
 1534|       |            // userData
 1535|    119|            if (XMLP_ret::XML_OK != getXMLOctetVector(p_aux0, qos.m_groupData.data_vec(), ident))
  ------------------
  |  Branch (1535:17): [True: 0, False: 119]
  ------------------
 1536|      0|            {
 1537|      0|                return XMLP_ret::XML_ERROR;
 1538|      0|            }
 1539|    119|        }
 1540|  1.88k|        else
 1541|  1.88k|        {
 1542|  1.88k|            EPROSIMA_LOG_ERROR(XMLPARSER, "Invalid element found into 'writerQosPoliciesType'. Name: " << name);
  ------------------
  |  |   45|  1.88k|#define EPROSIMA_LOG_ERROR(cat, msg) EPROSIMA_LOG_ERROR_IMPL_(cat, msg)
  |  |  ------------------
  |  |  |  |  291|  1.88k|    do {                                                                                                               \
  |  |  |  |  292|  1.88k|        std::stringstream fastdds_log_ss_tmp__;                                                                        \
  |  |  |  |  293|  1.88k|        fastdds_log_ss_tmp__ << msg;                                                                                   \
  |  |  |  |  294|  1.88k|        eprosima::fastdds::dds::Log::QueueLog(                                                                         \
  |  |  |  |  295|  1.88k|            fastdds_log_ss_tmp__.str(), eprosima::fastdds::dds::Log::Context{__FILE__, __LINE__, __func__, #cat},      \
  |  |  |  |  296|  1.88k|            eprosima::fastdds::dds::Log::Kind::Error);                                                                 \
  |  |  |  |  297|  1.88k|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (297:14): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1543|  1.88k|            return XMLP_ret::XML_ERROR;
 1544|  1.88k|        }
 1545|  7.47k|    }
 1546|  1.91k|    return XMLP_ret::XML_OK;
 1547|  6.09k|}
_ZN8eprosima7fastdds9xmlparser9XMLParser23getXMLReaderQosPoliciesEPN8tinyxml210XMLElementERNS0_3dds9ReaderQosEh:
 1553|  8.44k|{
 1554|       |    /*
 1555|       |        <xs:complexType name="readerQosPoliciesType">
 1556|       |            <xs:all minOccurs="0">
 1557|       |                <xs:element name="durability" type="durabilityQosPolicyType" minOccurs="0"/>
 1558|       |                <xs:element name="durabilityService" type="durabilityServiceQosPolicyType" minOccurs="0"/>
 1559|       |                <xs:element name="deadline" type="deadlineQosPolicyType" minOccurs="0"/>
 1560|       |                <xs:element name="latencyBudget" type="latencyBudgetQosPolicyType" minOccurs="0"/>
 1561|       |                <xs:element name="liveliness" type="livelinessQosPolicyType" minOccurs="0"/>
 1562|       |                <xs:element name="reliability" type="reliabilityQosPolicyType" minOccurs="0"/>
 1563|       |                <xs:element name="lifespan" type="lifespanQosPolicyType" minOccurs="0"/>
 1564|       |                <xs:element name="userData" type="userDataQosPolicyType" minOccurs="0"/>
 1565|       |                <xs:element name="timeBasedFilter" type="timeBasedFilterQosPolicyType" minOccurs="0"/>
 1566|       |                <xs:element name="ownership" type="ownershipQosPolicyType" minOccurs="0"/>
 1567|       |                <xs:element name="destinationOrder" type="destinationOrderQosPolicyType" minOccurs="0"/>
 1568|       |                <xs:element name="presentation" type="presentationQosPolicyType" minOccurs="0"/>
 1569|       |                <xs:element name="partition" type="partitionQosPolicyType" minOccurs="0"/>
 1570|       |                <xs:element name="topicData" type="topicDataQosPolicyType" minOccurs="0"/>
 1571|       |                <xs:element name="groupData" type="groupDataQosPolicyType" minOccurs="0"/>
 1572|       |                <xs:element name="data_sharing" type="dataSharingQosPolicyType" minOccurs="0"/>
 1573|       |                <xs:element name="disablePositiveAcks" type="disablePositiveAcksQosPolicyType" minOccurs="0"/>
 1574|       |            </xs:all>
 1575|       |        </xs:complexType>
 1576|       |     */
 1577|       |
 1578|  8.44k|    tinyxml2::XMLElement* p_aux0 = nullptr;
 1579|  8.44k|    const char* name = nullptr;
 1580|  10.6k|    for (p_aux0 = elem->FirstChildElement(); p_aux0 != NULL; p_aux0 = p_aux0->NextSiblingElement())
  ------------------
  |  Branch (1580:46): [True: 7.82k, False: 2.82k]
  ------------------
 1581|  7.82k|    {
 1582|  7.82k|        name = p_aux0->Name();
 1583|  7.82k|        if (strcmp(name, DURABILITY) == 0)
  ------------------
  |  Branch (1583:13): [True: 34, False: 7.79k]
  ------------------
 1584|     34|        {
 1585|       |            // durability
 1586|     34|            if (XMLP_ret::XML_OK != getXMLDurabilityQos(p_aux0, qos.m_durability, ident))
  ------------------
  |  Branch (1586:17): [True: 34, False: 0]
  ------------------
 1587|     34|            {
 1588|     34|                return XMLP_ret::XML_ERROR;
 1589|     34|            }
 1590|     34|        }
 1591|  7.79k|        else if (strcmp(name, LIVELINESS) == 0)
  ------------------
  |  Branch (1591:18): [True: 81, False: 7.71k]
  ------------------
 1592|     81|        {
 1593|       |            // liveliness
 1594|     81|            if (XMLP_ret::XML_OK != getXMLLivelinessQos(p_aux0, qos.m_liveliness, ident))
  ------------------
  |  Branch (1594:17): [True: 0, False: 81]
  ------------------
 1595|      0|            {
 1596|      0|                return XMLP_ret::XML_ERROR;
 1597|      0|            }
 1598|     81|        }
 1599|  7.71k|        else if (strcmp(name, RELIABILITY) == 0)
  ------------------
  |  Branch (1599:18): [True: 3.37k, False: 4.33k]
  ------------------
 1600|  3.37k|        {
 1601|       |            // reliability
 1602|  3.37k|            if (XMLP_ret::XML_OK != getXMLReliabilityQos(p_aux0, qos.m_reliability, ident))
  ------------------
  |  Branch (1602:17): [True: 3.24k, False: 129]
  ------------------
 1603|  3.24k|            {
 1604|  3.24k|                return XMLP_ret::XML_ERROR;
 1605|  3.24k|            }
 1606|  3.37k|        }
 1607|  4.33k|        else if (strcmp(name, PARTITION) == 0)
  ------------------
  |  Branch (1607:18): [True: 86, False: 4.25k]
  ------------------
 1608|     86|        {
 1609|       |            // partition
 1610|     86|            if (XMLP_ret::XML_OK != getXMLPartitionQos(p_aux0, qos.m_partition, ident))
  ------------------
  |  Branch (1610:17): [True: 86, False: 0]
  ------------------
 1611|     86|            {
 1612|     86|                return XMLP_ret::XML_ERROR;
 1613|     86|            }
 1614|     86|        }
 1615|  4.25k|        else if (strcmp(name, DEADLINE) == 0)
  ------------------
  |  Branch (1615:18): [True: 204, False: 4.04k]
  ------------------
 1616|    204|        {
 1617|       |            // deadline
 1618|    204|            if (XMLP_ret::XML_OK != getXMLDeadlineQos(p_aux0, qos.m_deadline, ident))
  ------------------
  |  Branch (1618:17): [True: 204, False: 0]
  ------------------
 1619|    204|            {
 1620|    204|                return XMLP_ret::XML_ERROR;
 1621|    204|            }
 1622|    204|        }
 1623|  4.04k|        else if (strcmp(name, LIFESPAN) == 0)
  ------------------
  |  Branch (1623:18): [True: 27, False: 4.02k]
  ------------------
 1624|     27|        {
 1625|     27|            if (XMLP_ret::XML_OK != getXMLLifespanQos(p_aux0, qos.m_lifespan, ident))
  ------------------
  |  Branch (1625:17): [True: 27, False: 0]
  ------------------
 1626|     27|            {
 1627|     27|                return XMLP_ret::XML_ERROR;
 1628|     27|            }
 1629|     27|        }
 1630|  4.02k|        else if (strcmp(name, DISABLE_POSITIVE_ACKS) == 0)
  ------------------
  |  Branch (1630:18): [True: 306, False: 3.71k]
  ------------------
 1631|    306|        {
 1632|       |            // Disable positive acks
 1633|    306|            if (XMLP_ret::XML_OK != getXMLDisablePositiveAcksQos(p_aux0, qos.m_disablePositiveACKs, ident))
  ------------------
  |  Branch (1633:17): [True: 0, False: 306]
  ------------------
 1634|      0|            {
 1635|      0|                return XMLP_ret::XML_ERROR;
 1636|      0|            }
 1637|    306|        }
 1638|  3.71k|        else if (strcmp(name, LATENCY_BUDGET) == 0)
  ------------------
  |  Branch (1638:18): [True: 352, False: 3.36k]
  ------------------
 1639|    352|        {
 1640|       |            //Latency Budget
 1641|    352|            if (XMLP_ret::XML_OK != getXMLLatencyBudgetQos(p_aux0, qos.m_latencyBudget, ident))
  ------------------
  |  Branch (1641:17): [True: 352, False: 0]
  ------------------
 1642|    352|            {
 1643|    352|                return XMLP_ret::XML_ERROR;
 1644|    352|            }
 1645|    352|        }
 1646|  3.36k|        else if (strcmp(name, DURABILITY_SRV) == 0 ||
  ------------------
  |  Branch (1646:18): [True: 138, False: 3.22k]
  ------------------
 1647|  3.36k|                strcmp(name, TIME_FILTER) == 0 || strcmp(name, DEST_ORDER) == 0 ||
  ------------------
  |  Branch (1647:17): [True: 75, False: 3.15k]
  |  Branch (1647:51): [True: 158, False: 2.99k]
  ------------------
 1648|  3.36k|                strcmp(name, PRESENTATION) == 0)
  ------------------
  |  Branch (1648:17): [True: 133, False: 2.85k]
  ------------------
 1649|    504|        {
 1650|       |            // TODO: Do not supported for now
 1651|       |            //if (nullptr != (p_aux = elem->FirstChildElement(    DURABILITY_SRV))) getXMLDurabilityServiceQos(p_aux, ident);
 1652|       |            //if (nullptr != (p_aux = elem->FirstChildElement(       TIME_FILTER))) getXMLTimeBasedFilterQos(p_aux, ident);
 1653|       |            //if (nullptr != (p_aux = elem->FirstChildElement(        DEST_ORDER))) getXMLDestinationOrderQos(p_aux, ident);
 1654|       |            //if (nullptr != (p_aux = elem->FirstChildElement(      PRESENTATION))) getXMLPresentationQos(p_aux, ident);
 1655|    504|            EPROSIMA_LOG_ERROR(XMLPARSER, "Quality of Service '" << p_aux0->Value() << "' do not supported for now");
  ------------------
  |  |   45|    504|#define EPROSIMA_LOG_ERROR(cat, msg) EPROSIMA_LOG_ERROR_IMPL_(cat, msg)
  |  |  ------------------
  |  |  |  |  291|    504|    do {                                                                                                               \
  |  |  |  |  292|    504|        std::stringstream fastdds_log_ss_tmp__;                                                                        \
  |  |  |  |  293|    504|        fastdds_log_ss_tmp__ << msg;                                                                                   \
  |  |  |  |  294|    504|        eprosima::fastdds::dds::Log::QueueLog(                                                                         \
  |  |  |  |  295|    504|            fastdds_log_ss_tmp__.str(), eprosima::fastdds::dds::Log::Context{__FILE__, __LINE__, __func__, #cat},      \
  |  |  |  |  296|    504|            eprosima::fastdds::dds::Log::Kind::Error);                                                                 \
  |  |  |  |  297|    504|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (297:14): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1656|    504|        }
 1657|  2.85k|        else if (strcmp(name, DATA_SHARING) == 0)
  ------------------
  |  Branch (1657:18): [True: 131, False: 2.72k]
  ------------------
 1658|    131|        {
 1659|       |            //data sharing
 1660|    131|            if (XMLP_ret::XML_OK != getXMLDataSharingQos(p_aux0, qos.data_sharing, ident))
  ------------------
  |  Branch (1660:17): [True: 131, False: 0]
  ------------------
 1661|    131|            {
 1662|    131|                return XMLP_ret::XML_ERROR;
 1663|    131|            }
 1664|    131|        }
 1665|  2.72k|        else if (strcmp(name, OWNERSHIP) == 0)
  ------------------
  |  Branch (1665:18): [True: 96, False: 2.63k]
  ------------------
 1666|     96|        {
 1667|       |            //ownership
 1668|     96|            if (XMLP_ret::XML_OK != getXMLOwnershipQos(p_aux0, qos.m_ownership, ident))
  ------------------
  |  Branch (1668:17): [True: 96, False: 0]
  ------------------
 1669|     96|            {
 1670|     96|                return XMLP_ret::XML_ERROR;
 1671|     96|            }
 1672|     96|        }
 1673|  2.63k|        else if (0 == strcmp(name, USER_DATA))
  ------------------
  |  Branch (1673:18): [True: 29, False: 2.60k]
  ------------------
 1674|     29|        {
 1675|       |            // userData
 1676|     29|            if (XMLP_ret::XML_OK != getXMLOctetVector(p_aux0, qos.m_userData.data_vec(), ident))
  ------------------
  |  Branch (1676:17): [True: 0, False: 29]
  ------------------
 1677|      0|            {
 1678|      0|                return XMLP_ret::XML_ERROR;
 1679|      0|            }
 1680|     29|        }
 1681|  2.60k|        else if (0 == strcmp(name, TOPIC_DATA))
  ------------------
  |  Branch (1681:18): [True: 234, False: 2.36k]
  ------------------
 1682|    234|        {
 1683|       |            // userData
 1684|    234|            if (XMLP_ret::XML_OK != getXMLOctetVector(p_aux0, qos.m_topicData.data_vec(), ident))
  ------------------
  |  Branch (1684:17): [True: 0, False: 234]
  ------------------
 1685|      0|            {
 1686|      0|                return XMLP_ret::XML_ERROR;
 1687|      0|            }
 1688|    234|        }
 1689|  2.36k|        else if (0 == strcmp(name, GROUP_DATA))
  ------------------
  |  Branch (1689:18): [True: 923, False: 1.44k]
  ------------------
 1690|    923|        {
 1691|       |            // userData
 1692|    923|            if (XMLP_ret::XML_OK != getXMLOctetVector(p_aux0, qos.m_groupData.data_vec(), ident))
  ------------------
  |  Branch (1692:17): [True: 0, False: 923]
  ------------------
 1693|      0|            {
 1694|      0|                return XMLP_ret::XML_ERROR;
 1695|      0|            }
 1696|    923|        }
 1697|  1.44k|        else
 1698|  1.44k|        {
 1699|  1.44k|            EPROSIMA_LOG_ERROR(XMLPARSER, "Invalid element found into 'readerQosPoliciesType'. Name: " << name);
  ------------------
  |  |   45|  1.44k|#define EPROSIMA_LOG_ERROR(cat, msg) EPROSIMA_LOG_ERROR_IMPL_(cat, msg)
  |  |  ------------------
  |  |  |  |  291|  1.44k|    do {                                                                                                               \
  |  |  |  |  292|  1.44k|        std::stringstream fastdds_log_ss_tmp__;                                                                        \
  |  |  |  |  293|  1.44k|        fastdds_log_ss_tmp__ << msg;                                                                                   \
  |  |  |  |  294|  1.44k|        eprosima::fastdds::dds::Log::QueueLog(                                                                         \
  |  |  |  |  295|  1.44k|            fastdds_log_ss_tmp__.str(), eprosima::fastdds::dds::Log::Context{__FILE__, __LINE__, __func__, #cat},      \
  |  |  |  |  296|  1.44k|            eprosima::fastdds::dds::Log::Kind::Error);                                                                 \
  |  |  |  |  297|  1.44k|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (297:14): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1700|  1.44k|            return XMLP_ret::XML_ERROR;
 1701|  1.44k|        }
 1702|  7.82k|    }
 1703|  2.82k|    return XMLP_ret::XML_OK;
 1704|  8.44k|}
_ZN8eprosima7fastdds9xmlparser9XMLParser19getXMLDurabilityQosEPN8tinyxml210XMLElementERNS0_3dds19DurabilityQosPolicyEh:
 1710|     96|{
 1711|       |    /*
 1712|       |        <xs:complexType name="durabilityQosPolicyType">
 1713|       |            <xs:all>
 1714|       |                <xs:element name="kind" type="durabilityQosKindType"/>
 1715|       |            </xs:all>
 1716|       |        </xs:complexType>
 1717|       |     */
 1718|       |
 1719|     96|    tinyxml2::XMLElement* p_aux0 = nullptr;
 1720|     96|    const char* name = nullptr;
 1721|     96|    bool bKindDefined = false;
 1722|     96|    for (p_aux0 = elem->FirstChildElement(); p_aux0 != NULL; p_aux0 = p_aux0->NextSiblingElement())
  ------------------
  |  Branch (1722:46): [True: 0, False: 96]
  ------------------
 1723|      0|    {
 1724|      0|        name = p_aux0->Name();
 1725|      0|        if (strcmp(name, KIND) == 0)
  ------------------
  |  Branch (1725:13): [True: 0, False: 0]
  ------------------
 1726|      0|        {
 1727|       |            // kind
 1728|       |            /*
 1729|       |                <xs:simpleType name="durabilityQosKindType">
 1730|       |                    <xs:restriction base="xs:string">
 1731|       |                        <xs:enumeration value="VOLATILE"/>
 1732|       |                        <xs:enumeration value="TRANSIENT_LOCAL"/>
 1733|       |                        <xs:enumeration value="TRANSIENT"/>
 1734|       |                        <xs:enumeration value="PERSISTENT"/>
 1735|       |                    </xs:restriction>
 1736|       |                </xs:simpleType>
 1737|       |             */
 1738|      0|            std::string text = get_element_text(p_aux0);
 1739|      0|            if (text.empty())
  ------------------
  |  Branch (1739:17): [True: 0, False: 0]
  ------------------
 1740|      0|            {
 1741|      0|                EPROSIMA_LOG_ERROR(XMLPARSER, "Node '" << KIND << "' without content");
  ------------------
  |  |   45|      0|#define EPROSIMA_LOG_ERROR(cat, msg) EPROSIMA_LOG_ERROR_IMPL_(cat, msg)
  |  |  ------------------
  |  |  |  |  291|      0|    do {                                                                                                               \
  |  |  |  |  292|      0|        std::stringstream fastdds_log_ss_tmp__;                                                                        \
  |  |  |  |  293|      0|        fastdds_log_ss_tmp__ << msg;                                                                                   \
  |  |  |  |  294|      0|        eprosima::fastdds::dds::Log::QueueLog(                                                                         \
  |  |  |  |  295|      0|            fastdds_log_ss_tmp__.str(), eprosima::fastdds::dds::Log::Context{__FILE__, __LINE__, __func__, #cat},      \
  |  |  |  |  296|      0|            eprosima::fastdds::dds::Log::Kind::Error);                                                                 \
  |  |  |  |  297|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (297:14): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1742|      0|                return XMLP_ret::XML_ERROR;
 1743|      0|            }
 1744|      0|            bKindDefined = true;
 1745|       |
 1746|      0|            if (!get_element_enum_value(text.c_str(), durability.kind,
  ------------------
  |  Branch (1746:17): [True: 0, False: 0]
  ------------------
 1747|      0|                    _VOLATILE, dds::DurabilityQosPolicyKind::VOLATILE_DURABILITY_QOS,
 1748|      0|                    _TRANSIENT_LOCAL, dds::DurabilityQosPolicyKind::TRANSIENT_LOCAL_DURABILITY_QOS,
 1749|      0|                    _TRANSIENT, dds::DurabilityQosPolicyKind::TRANSIENT_DURABILITY_QOS,
 1750|      0|                    _PERSISTENT, dds::DurabilityQosPolicyKind::PERSISTENT_DURABILITY_QOS))
 1751|      0|            {
 1752|      0|                EPROSIMA_LOG_ERROR(XMLPARSER, "Node '" << KIND << "' with bad content");
  ------------------
  |  |   45|      0|#define EPROSIMA_LOG_ERROR(cat, msg) EPROSIMA_LOG_ERROR_IMPL_(cat, msg)
  |  |  ------------------
  |  |  |  |  291|      0|    do {                                                                                                               \
  |  |  |  |  292|      0|        std::stringstream fastdds_log_ss_tmp__;                                                                        \
  |  |  |  |  293|      0|        fastdds_log_ss_tmp__ << msg;                                                                                   \
  |  |  |  |  294|      0|        eprosima::fastdds::dds::Log::QueueLog(                                                                         \
  |  |  |  |  295|      0|            fastdds_log_ss_tmp__.str(), eprosima::fastdds::dds::Log::Context{__FILE__, __LINE__, __func__, #cat},      \
  |  |  |  |  296|      0|            eprosima::fastdds::dds::Log::Kind::Error);                                                                 \
  |  |  |  |  297|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (297:14): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1753|      0|                return XMLP_ret::XML_ERROR;
 1754|      0|            }
 1755|      0|        }
 1756|      0|        else
 1757|      0|        {
 1758|      0|            EPROSIMA_LOG_ERROR(XMLPARSER, "Invalid element found into 'durabilityQosPolicyType'. Name: " << name);
  ------------------
  |  |   45|      0|#define EPROSIMA_LOG_ERROR(cat, msg) EPROSIMA_LOG_ERROR_IMPL_(cat, msg)
  |  |  ------------------
  |  |  |  |  291|      0|    do {                                                                                                               \
  |  |  |  |  292|      0|        std::stringstream fastdds_log_ss_tmp__;                                                                        \
  |  |  |  |  293|      0|        fastdds_log_ss_tmp__ << msg;                                                                                   \
  |  |  |  |  294|      0|        eprosima::fastdds::dds::Log::QueueLog(                                                                         \
  |  |  |  |  295|      0|            fastdds_log_ss_tmp__.str(), eprosima::fastdds::dds::Log::Context{__FILE__, __LINE__, __func__, #cat},      \
  |  |  |  |  296|      0|            eprosima::fastdds::dds::Log::Kind::Error);                                                                 \
  |  |  |  |  297|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (297:14): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1759|      0|            return XMLP_ret::XML_ERROR;
 1760|      0|        }
 1761|      0|    }
 1762|     96|    if (!bKindDefined)
  ------------------
  |  Branch (1762:9): [True: 96, False: 0]
  ------------------
 1763|     96|    {
 1764|     96|        EPROSIMA_LOG_ERROR(XMLPARSER, "Node 'durabilityQosPolicyType' without content");
  ------------------
  |  |   45|     96|#define EPROSIMA_LOG_ERROR(cat, msg) EPROSIMA_LOG_ERROR_IMPL_(cat, msg)
  |  |  ------------------
  |  |  |  |  291|     96|    do {                                                                                                               \
  |  |  |  |  292|     96|        std::stringstream fastdds_log_ss_tmp__;                                                                        \
  |  |  |  |  293|     96|        fastdds_log_ss_tmp__ << msg;                                                                                   \
  |  |  |  |  294|     96|        eprosima::fastdds::dds::Log::QueueLog(                                                                         \
  |  |  |  |  295|     96|            fastdds_log_ss_tmp__.str(), eprosima::fastdds::dds::Log::Context{__FILE__, __LINE__, __func__, #cat},      \
  |  |  |  |  296|     96|            eprosima::fastdds::dds::Log::Kind::Error);                                                                 \
  |  |  |  |  297|     96|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (297:14): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1765|     96|        return XMLP_ret::XML_ERROR;
 1766|     96|    }
 1767|       |
 1768|      0|    return XMLP_ret::XML_OK;
 1769|     96|}
_ZN8eprosima7fastdds9xmlparser9XMLParser17getXMLDeadlineQosEPN8tinyxml210XMLElementERNS0_3dds17DeadlineQosPolicyEh:
 1881|    325|{
 1882|       |    /*
 1883|       |        <xs:complexType name="deadlineQosPolicyType">
 1884|       |            <xs:all>
 1885|       |                <xs:element name="period" type="durationType"/>
 1886|       |            </xs:all>
 1887|       |        </xs:complexType>
 1888|       |     */
 1889|    325|    tinyxml2::XMLElement* p_aux0 = nullptr;
 1890|    325|    const char* name = nullptr;
 1891|    325|    bool bPeriodDefined = false;
 1892|    325|    for (p_aux0 = elem->FirstChildElement(); p_aux0 != NULL; p_aux0 = p_aux0->NextSiblingElement())
  ------------------
  |  Branch (1892:46): [True: 0, False: 325]
  ------------------
 1893|      0|    {
 1894|      0|        name = p_aux0->Name();
 1895|      0|        if (strcmp(name, PERIOD) == 0)
  ------------------
  |  Branch (1895:13): [True: 0, False: 0]
  ------------------
 1896|      0|        {
 1897|      0|            bPeriodDefined = true;
 1898|      0|            if (XMLP_ret::XML_OK != getXMLDuration(p_aux0, deadline.period, ident))
  ------------------
  |  Branch (1898:17): [True: 0, False: 0]
  ------------------
 1899|      0|            {
 1900|      0|                return XMLP_ret::XML_ERROR;
 1901|      0|            }
 1902|      0|        }
 1903|      0|        else
 1904|      0|        {
 1905|      0|            EPROSIMA_LOG_ERROR(XMLPARSER, "Invalid element found into 'deadlineQosPolicyType'. Name: " << name);
  ------------------
  |  |   45|      0|#define EPROSIMA_LOG_ERROR(cat, msg) EPROSIMA_LOG_ERROR_IMPL_(cat, msg)
  |  |  ------------------
  |  |  |  |  291|      0|    do {                                                                                                               \
  |  |  |  |  292|      0|        std::stringstream fastdds_log_ss_tmp__;                                                                        \
  |  |  |  |  293|      0|        fastdds_log_ss_tmp__ << msg;                                                                                   \
  |  |  |  |  294|      0|        eprosima::fastdds::dds::Log::QueueLog(                                                                         \
  |  |  |  |  295|      0|            fastdds_log_ss_tmp__.str(), eprosima::fastdds::dds::Log::Context{__FILE__, __LINE__, __func__, #cat},      \
  |  |  |  |  296|      0|            eprosima::fastdds::dds::Log::Kind::Error);                                                                 \
  |  |  |  |  297|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (297:14): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1906|      0|            return XMLP_ret::XML_ERROR;
 1907|      0|        }
 1908|      0|    }
 1909|       |
 1910|    325|    if (!bPeriodDefined)
  ------------------
  |  Branch (1910:9): [True: 325, False: 0]
  ------------------
 1911|    325|    {
 1912|    325|        EPROSIMA_LOG_ERROR(XMLPARSER, "Node 'deadlineQosPolicyType' without content");
  ------------------
  |  |   45|    325|#define EPROSIMA_LOG_ERROR(cat, msg) EPROSIMA_LOG_ERROR_IMPL_(cat, msg)
  |  |  ------------------
  |  |  |  |  291|    325|    do {                                                                                                               \
  |  |  |  |  292|    325|        std::stringstream fastdds_log_ss_tmp__;                                                                        \
  |  |  |  |  293|    325|        fastdds_log_ss_tmp__ << msg;                                                                                   \
  |  |  |  |  294|    325|        eprosima::fastdds::dds::Log::QueueLog(                                                                         \
  |  |  |  |  295|    325|            fastdds_log_ss_tmp__.str(), eprosima::fastdds::dds::Log::Context{__FILE__, __LINE__, __func__, #cat},      \
  |  |  |  |  296|    325|            eprosima::fastdds::dds::Log::Kind::Error);                                                                 \
  |  |  |  |  297|    325|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (297:14): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1913|    325|        return XMLP_ret::XML_ERROR;
 1914|    325|    }
 1915|       |
 1916|      0|    return XMLP_ret::XML_OK;
 1917|    325|}
_ZN8eprosima7fastdds9xmlparser9XMLParser22getXMLLatencyBudgetQosEPN8tinyxml210XMLElementERNS0_3dds22LatencyBudgetQosPolicyEh:
 1923|    431|{
 1924|       |    /*
 1925|       |        <xs:complexType name="latencyBudgetQosPolicyType">
 1926|       |            <xs:all>
 1927|       |                <xs:element name="duration" type="durationType"/>
 1928|       |            </xs:all>
 1929|       |        </xs:complexType>
 1930|       |     */
 1931|       |
 1932|    431|    tinyxml2::XMLElement* p_aux0 = nullptr;
 1933|    431|    const char* name = nullptr;
 1934|    431|    bool bDurationDefined = false;
 1935|    431|    for (p_aux0 = elem->FirstChildElement(); p_aux0 != NULL; p_aux0 = p_aux0->NextSiblingElement())
  ------------------
  |  Branch (1935:46): [True: 0, False: 431]
  ------------------
 1936|      0|    {
 1937|      0|        name = p_aux0->Name();
 1938|      0|        if (strcmp(name, DURATION) == 0)
  ------------------
  |  Branch (1938:13): [True: 0, False: 0]
  ------------------
 1939|      0|        {
 1940|      0|            bDurationDefined = true;
 1941|      0|            if (XMLP_ret::XML_OK != getXMLDuration(p_aux0, latencyBudget.duration, ident))
  ------------------
  |  Branch (1941:17): [True: 0, False: 0]
  ------------------
 1942|      0|            {
 1943|      0|                return XMLP_ret::XML_ERROR;
 1944|      0|            }
 1945|      0|        }
 1946|      0|        else
 1947|      0|        {
 1948|      0|            EPROSIMA_LOG_ERROR(XMLPARSER, "Invalid element found into 'latencyBudgetQosPolicyType'. Name: " << name);
  ------------------
  |  |   45|      0|#define EPROSIMA_LOG_ERROR(cat, msg) EPROSIMA_LOG_ERROR_IMPL_(cat, msg)
  |  |  ------------------
  |  |  |  |  291|      0|    do {                                                                                                               \
  |  |  |  |  292|      0|        std::stringstream fastdds_log_ss_tmp__;                                                                        \
  |  |  |  |  293|      0|        fastdds_log_ss_tmp__ << msg;                                                                                   \
  |  |  |  |  294|      0|        eprosima::fastdds::dds::Log::QueueLog(                                                                         \
  |  |  |  |  295|      0|            fastdds_log_ss_tmp__.str(), eprosima::fastdds::dds::Log::Context{__FILE__, __LINE__, __func__, #cat},      \
  |  |  |  |  296|      0|            eprosima::fastdds::dds::Log::Kind::Error);                                                                 \
  |  |  |  |  297|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (297:14): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1949|      0|            return XMLP_ret::XML_ERROR;
 1950|      0|        }
 1951|      0|    }
 1952|       |
 1953|    431|    if (!bDurationDefined)
  ------------------
  |  Branch (1953:9): [True: 431, False: 0]
  ------------------
 1954|    431|    {
 1955|    431|        EPROSIMA_LOG_ERROR(XMLPARSER, "Node 'latencyBudgetQosPolicyType' without content");
  ------------------
  |  |   45|    431|#define EPROSIMA_LOG_ERROR(cat, msg) EPROSIMA_LOG_ERROR_IMPL_(cat, msg)
  |  |  ------------------
  |  |  |  |  291|    431|    do {                                                                                                               \
  |  |  |  |  292|    431|        std::stringstream fastdds_log_ss_tmp__;                                                                        \
  |  |  |  |  293|    431|        fastdds_log_ss_tmp__ << msg;                                                                                   \
  |  |  |  |  294|    431|        eprosima::fastdds::dds::Log::QueueLog(                                                                         \
  |  |  |  |  295|    431|            fastdds_log_ss_tmp__.str(), eprosima::fastdds::dds::Log::Context{__FILE__, __LINE__, __func__, #cat},      \
  |  |  |  |  296|    431|            eprosima::fastdds::dds::Log::Kind::Error);                                                                 \
  |  |  |  |  297|    431|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (297:14): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1956|    431|        return XMLP_ret::XML_ERROR;
 1957|    431|    }
 1958|      0|    return XMLP_ret::XML_OK;
 1959|    431|}
_ZN8eprosima7fastdds9xmlparser9XMLParser19getXMLLivelinessQosEPN8tinyxml210XMLElementERNS0_3dds19LivelinessQosPolicyEh:
 1965|    157|{
 1966|       |    /*
 1967|       |        <xs:complexType name="livelinessQosPolicyType">
 1968|       |            <xs:all minOccurs="0">
 1969|       |                <xs:element name="kind" type="livelinessQosKindType" minOccurs="0"/>
 1970|       |                <xs:element name="leaseDuration" type="durationType" minOccurs="0"/>
 1971|       |                <xs:element name="announcement_period" type="durationType" minOccurs="0"/>
 1972|       |            </xs:all>
 1973|       |        </xs:complexType>
 1974|       |     */
 1975|       |
 1976|    157|    tinyxml2::XMLElement* p_aux0 = nullptr;
 1977|    157|    const char* name = nullptr;
 1978|    157|    for (p_aux0 = elem->FirstChildElement(); p_aux0 != NULL; p_aux0 = p_aux0->NextSiblingElement())
  ------------------
  |  Branch (1978:46): [True: 0, False: 157]
  ------------------
 1979|      0|    {
 1980|      0|        name = p_aux0->Name();
 1981|      0|        if (strcmp(name, KIND) == 0)
  ------------------
  |  Branch (1981:13): [True: 0, False: 0]
  ------------------
 1982|      0|        {
 1983|       |            // kind
 1984|       |            /*
 1985|       |                <xs:simpleType name="livelinessQosKindType">
 1986|       |                    <xs:restriction base="xs:string">
 1987|       |                        <xs:enumeration value="AUTOMATIC"/>
 1988|       |                        <xs:enumeration value="MANUAL_BY_PARTICIPANT"/>
 1989|       |                        <xs:enumeration value="MANUAL_BY_TOPIC"/>
 1990|       |                    </xs:restriction>
 1991|       |                </xs:simpleType>
 1992|       |             */
 1993|      0|            std::string text = get_element_text(p_aux0);
 1994|      0|            if (text.empty())
  ------------------
  |  Branch (1994:17): [True: 0, False: 0]
  ------------------
 1995|      0|            {
 1996|      0|                EPROSIMA_LOG_ERROR(XMLPARSER, "Node '" << KIND << "' without content");
  ------------------
  |  |   45|      0|#define EPROSIMA_LOG_ERROR(cat, msg) EPROSIMA_LOG_ERROR_IMPL_(cat, msg)
  |  |  ------------------
  |  |  |  |  291|      0|    do {                                                                                                               \
  |  |  |  |  292|      0|        std::stringstream fastdds_log_ss_tmp__;                                                                        \
  |  |  |  |  293|      0|        fastdds_log_ss_tmp__ << msg;                                                                                   \
  |  |  |  |  294|      0|        eprosima::fastdds::dds::Log::QueueLog(                                                                         \
  |  |  |  |  295|      0|            fastdds_log_ss_tmp__.str(), eprosima::fastdds::dds::Log::Context{__FILE__, __LINE__, __func__, #cat},      \
  |  |  |  |  296|      0|            eprosima::fastdds::dds::Log::Kind::Error);                                                                 \
  |  |  |  |  297|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (297:14): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1997|      0|                return XMLP_ret::XML_ERROR;
 1998|      0|            }
 1999|       |
 2000|      0|            if (!get_element_enum_value(text.c_str(), liveliness.kind,
  ------------------
  |  Branch (2000:17): [True: 0, False: 0]
  ------------------
 2001|      0|                    AUTOMATIC, dds::LivelinessQosPolicyKind::AUTOMATIC_LIVELINESS_QOS,
 2002|      0|                    MANUAL_BY_PARTICIPANT, dds::LivelinessQosPolicyKind::MANUAL_BY_PARTICIPANT_LIVELINESS_QOS,
 2003|      0|                    MANUAL_BY_TOPIC, dds::LivelinessQosPolicyKind::MANUAL_BY_TOPIC_LIVELINESS_QOS))
 2004|      0|            {
 2005|      0|                EPROSIMA_LOG_ERROR(XMLPARSER, "Node '" << KIND << "' with bad content");
  ------------------
  |  |   45|      0|#define EPROSIMA_LOG_ERROR(cat, msg) EPROSIMA_LOG_ERROR_IMPL_(cat, msg)
  |  |  ------------------
  |  |  |  |  291|      0|    do {                                                                                                               \
  |  |  |  |  292|      0|        std::stringstream fastdds_log_ss_tmp__;                                                                        \
  |  |  |  |  293|      0|        fastdds_log_ss_tmp__ << msg;                                                                                   \
  |  |  |  |  294|      0|        eprosima::fastdds::dds::Log::QueueLog(                                                                         \
  |  |  |  |  295|      0|            fastdds_log_ss_tmp__.str(), eprosima::fastdds::dds::Log::Context{__FILE__, __LINE__, __func__, #cat},      \
  |  |  |  |  296|      0|            eprosima::fastdds::dds::Log::Kind::Error);                                                                 \
  |  |  |  |  297|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (297:14): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 2006|      0|                return XMLP_ret::XML_ERROR;
 2007|      0|            }
 2008|      0|        }
 2009|      0|        else if (strcmp(name, LEASE_DURATION) == 0)
  ------------------
  |  Branch (2009:18): [True: 0, False: 0]
  ------------------
 2010|      0|        {
 2011|       |            // lease_duration
 2012|      0|            if (XMLP_ret::XML_OK != getXMLDuration(p_aux0, liveliness.lease_duration, ident))
  ------------------
  |  Branch (2012:17): [True: 0, False: 0]
  ------------------
 2013|      0|            {
 2014|      0|                return XMLP_ret::XML_ERROR;
 2015|      0|            }
 2016|      0|        }
 2017|      0|        else if (strcmp(name, ANNOUNCE_PERIOD) == 0)
  ------------------
  |  Branch (2017:18): [True: 0, False: 0]
  ------------------
 2018|      0|        {
 2019|       |            // announcement_period
 2020|      0|            if (XMLP_ret::XML_OK != getXMLDuration(p_aux0, liveliness.announcement_period, ident))
  ------------------
  |  Branch (2020:17): [True: 0, False: 0]
  ------------------
 2021|      0|            {
 2022|      0|                return XMLP_ret::XML_ERROR;
 2023|      0|            }
 2024|      0|        }
 2025|      0|        else
 2026|      0|        {
 2027|      0|            EPROSIMA_LOG_ERROR(XMLPARSER, "Invalid element found into 'livelinessQosPolicyType'. Name: " << name);
  ------------------
  |  |   45|      0|#define EPROSIMA_LOG_ERROR(cat, msg) EPROSIMA_LOG_ERROR_IMPL_(cat, msg)
  |  |  ------------------
  |  |  |  |  291|      0|    do {                                                                                                               \
  |  |  |  |  292|      0|        std::stringstream fastdds_log_ss_tmp__;                                                                        \
  |  |  |  |  293|      0|        fastdds_log_ss_tmp__ << msg;                                                                                   \
  |  |  |  |  294|      0|        eprosima::fastdds::dds::Log::QueueLog(                                                                         \
  |  |  |  |  295|      0|            fastdds_log_ss_tmp__.str(), eprosima::fastdds::dds::Log::Context{__FILE__, __LINE__, __func__, #cat},      \
  |  |  |  |  296|      0|            eprosima::fastdds::dds::Log::Kind::Error);                                                                 \
  |  |  |  |  297|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (297:14): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 2028|      0|            return XMLP_ret::XML_ERROR;
 2029|      0|        }
 2030|      0|    }
 2031|       |
 2032|    157|    return XMLP_ret::XML_OK;
 2033|    157|}
_ZN8eprosima7fastdds9xmlparser9XMLParser20getXMLReliabilityQosEPN8tinyxml210XMLElementERNS0_3dds20ReliabilityQosPolicyEh:
 2039|  4.46k|{
 2040|       |    /*
 2041|       |        <xs:complexType name="reliabilityQosPolicyType">
 2042|       |            <xs:all>
 2043|       |                <xs:element name="kind" type="reliabilityQosKindType" minOccurs="0"/>
 2044|       |                <xs:element name="max_blocking_time" type="durationType" minOccurs="0"/>
 2045|       |            </xs:all>
 2046|       |        </xs:complexType>
 2047|       |     */
 2048|       |
 2049|  4.46k|    tinyxml2::XMLElement* p_aux0 = nullptr;
 2050|  4.46k|    const char* name = nullptr;
 2051|  5.61k|    for (p_aux0 = elem->FirstChildElement(); p_aux0 != NULL; p_aux0 = p_aux0->NextSiblingElement())
  ------------------
  |  Branch (2051:46): [True: 5.32k, False: 287]
  ------------------
 2052|  5.32k|    {
 2053|  5.32k|        name = p_aux0->Name();
 2054|  5.32k|        if (strcmp(name, KIND) == 0)
  ------------------
  |  Branch (2054:13): [True: 4.37k, False: 954]
  ------------------
 2055|  4.37k|        {
 2056|       |            // kind
 2057|       |            /*
 2058|       |                <xs:simpleType name="reliabilityQosKindType">
 2059|       |                    <xs:restriction base="xs:string">
 2060|       |                        <xs:enumeration value="BEST_EFFORT"/>
 2061|       |                        <xs:enumeration value="RELIABLE"/>
 2062|       |                    </xs:restriction>
 2063|       |                </xs:simpleType>
 2064|       |             */
 2065|  4.37k|            std::string text = get_element_text(p_aux0);
 2066|  4.37k|            if (text.empty())
  ------------------
  |  Branch (2066:17): [True: 144, False: 4.22k]
  ------------------
 2067|    144|            {
 2068|    144|                EPROSIMA_LOG_ERROR(XMLPARSER, "Node '" << KIND << "' without content");
  ------------------
  |  |   45|    144|#define EPROSIMA_LOG_ERROR(cat, msg) EPROSIMA_LOG_ERROR_IMPL_(cat, msg)
  |  |  ------------------
  |  |  |  |  291|    144|    do {                                                                                                               \
  |  |  |  |  292|    144|        std::stringstream fastdds_log_ss_tmp__;                                                                        \
  |  |  |  |  293|    144|        fastdds_log_ss_tmp__ << msg;                                                                                   \
  |  |  |  |  294|    144|        eprosima::fastdds::dds::Log::QueueLog(                                                                         \
  |  |  |  |  295|    144|            fastdds_log_ss_tmp__.str(), eprosima::fastdds::dds::Log::Context{__FILE__, __LINE__, __func__, #cat},      \
  |  |  |  |  296|    144|            eprosima::fastdds::dds::Log::Kind::Error);                                                                 \
  |  |  |  |  297|    144|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (297:14): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 2069|    144|                return XMLP_ret::XML_ERROR;
 2070|    144|            }
 2071|       |
 2072|  4.22k|            if (!get_element_enum_value(text.c_str(), reliability.kind,
  ------------------
  |  Branch (2072:17): [True: 3.08k, False: 1.14k]
  ------------------
 2073|  4.22k|                    _BEST_EFFORT, dds::ReliabilityQosPolicyKind::BEST_EFFORT_RELIABILITY_QOS,
 2074|  4.22k|                    _RELIABLE, dds::ReliabilityQosPolicyKind::RELIABLE_RELIABILITY_QOS))
 2075|  3.08k|            {
 2076|  3.08k|                EPROSIMA_LOG_ERROR(XMLPARSER, "Node '" << KIND << "' with bad content");
  ------------------
  |  |   45|  3.08k|#define EPROSIMA_LOG_ERROR(cat, msg) EPROSIMA_LOG_ERROR_IMPL_(cat, msg)
  |  |  ------------------
  |  |  |  |  291|  3.08k|    do {                                                                                                               \
  |  |  |  |  292|  3.08k|        std::stringstream fastdds_log_ss_tmp__;                                                                        \
  |  |  |  |  293|  3.08k|        fastdds_log_ss_tmp__ << msg;                                                                                   \
  |  |  |  |  294|  3.08k|        eprosima::fastdds::dds::Log::QueueLog(                                                                         \
  |  |  |  |  295|  3.08k|            fastdds_log_ss_tmp__.str(), eprosima::fastdds::dds::Log::Context{__FILE__, __LINE__, __func__, #cat},      \
  |  |  |  |  296|  3.08k|            eprosima::fastdds::dds::Log::Kind::Error);                                                                 \
  |  |  |  |  297|  3.08k|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (297:14): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 2077|  3.08k|                return XMLP_ret::XML_ERROR;
 2078|  3.08k|            }
 2079|  4.22k|        }
 2080|    954|        else if (strcmp(name, MAX_BLOCK_TIME) == 0)
  ------------------
  |  Branch (2080:18): [True: 572, False: 382]
  ------------------
 2081|    572|        {
 2082|       |            // max_blocking_time
 2083|    572|            if (XMLP_ret::XML_OK != getXMLDuration(p_aux0, reliability.max_blocking_time, ident))
  ------------------
  |  Branch (2083:17): [True: 572, False: 0]
  ------------------
 2084|    572|            {
 2085|    572|                return XMLP_ret::XML_ERROR;
 2086|    572|            }
 2087|    572|        }
 2088|    382|        else
 2089|    382|        {
 2090|    382|            EPROSIMA_LOG_ERROR(XMLPARSER, "Invalid element found into 'reliabilityQosPolicyType'. Name: " << name);
  ------------------
  |  |   45|    382|#define EPROSIMA_LOG_ERROR(cat, msg) EPROSIMA_LOG_ERROR_IMPL_(cat, msg)
  |  |  ------------------
  |  |  |  |  291|    382|    do {                                                                                                               \
  |  |  |  |  292|    382|        std::stringstream fastdds_log_ss_tmp__;                                                                        \
  |  |  |  |  293|    382|        fastdds_log_ss_tmp__ << msg;                                                                                   \
  |  |  |  |  294|    382|        eprosima::fastdds::dds::Log::QueueLog(                                                                         \
  |  |  |  |  295|    382|            fastdds_log_ss_tmp__.str(), eprosima::fastdds::dds::Log::Context{__FILE__, __LINE__, __func__, #cat},      \
  |  |  |  |  296|    382|            eprosima::fastdds::dds::Log::Kind::Error);                                                                 \
  |  |  |  |  297|    382|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (297:14): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 2091|    382|            return XMLP_ret::XML_ERROR;
 2092|    382|        }
 2093|  5.32k|    }
 2094|    287|    return XMLP_ret::XML_OK;
 2095|  4.46k|}
_ZN8eprosima7fastdds9xmlparser9XMLParser17getXMLLifespanQosEPN8tinyxml210XMLElementERNS0_3dds17LifespanQosPolicyEh:
 2101|    198|{
 2102|       |    /*
 2103|       |        <xs:complexType name="lifespanQosPolicyType">
 2104|       |            <xs:all>
 2105|       |                <xs:element name="duration" type="durationType"/>
 2106|       |            </xs:all>
 2107|       |        </xs:complexType>
 2108|       |     */
 2109|       |
 2110|    198|    tinyxml2::XMLElement* p_aux0 = nullptr;
 2111|    198|    bool bDurationDefined = false;
 2112|    198|    const char* name = nullptr;
 2113|    198|    for (p_aux0 = elem->FirstChildElement(); p_aux0 != NULL; p_aux0 = p_aux0->NextSiblingElement())
  ------------------
  |  Branch (2113:46): [True: 0, False: 198]
  ------------------
 2114|      0|    {
 2115|      0|        name = p_aux0->Name();
 2116|      0|        if (strcmp(name, DURATION) == 0)
  ------------------
  |  Branch (2116:13): [True: 0, False: 0]
  ------------------
 2117|      0|        {
 2118|      0|            bDurationDefined = true;
 2119|      0|            if (XMLP_ret::XML_OK != getXMLDuration(p_aux0, lifespan.duration, ident))
  ------------------
  |  Branch (2119:17): [True: 0, False: 0]
  ------------------
 2120|      0|            {
 2121|      0|                return XMLP_ret::XML_ERROR;
 2122|      0|            }
 2123|      0|        }
 2124|      0|        else
 2125|      0|        {
 2126|      0|            EPROSIMA_LOG_ERROR(XMLPARSER, "Invalid element found into 'lifespanQosPolicyType'. Name: " << name);
  ------------------
  |  |   45|      0|#define EPROSIMA_LOG_ERROR(cat, msg) EPROSIMA_LOG_ERROR_IMPL_(cat, msg)
  |  |  ------------------
  |  |  |  |  291|      0|    do {                                                                                                               \
  |  |  |  |  292|      0|        std::stringstream fastdds_log_ss_tmp__;                                                                        \
  |  |  |  |  293|      0|        fastdds_log_ss_tmp__ << msg;                                                                                   \
  |  |  |  |  294|      0|        eprosima::fastdds::dds::Log::QueueLog(                                                                         \
  |  |  |  |  295|      0|            fastdds_log_ss_tmp__.str(), eprosima::fastdds::dds::Log::Context{__FILE__, __LINE__, __func__, #cat},      \
  |  |  |  |  296|      0|            eprosima::fastdds::dds::Log::Kind::Error);                                                                 \
  |  |  |  |  297|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (297:14): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 2127|      0|            return XMLP_ret::XML_ERROR;
 2128|      0|        }
 2129|      0|    }
 2130|       |
 2131|    198|    if (!bDurationDefined)
  ------------------
  |  Branch (2131:9): [True: 198, False: 0]
  ------------------
 2132|    198|    {
 2133|    198|        EPROSIMA_LOG_ERROR(XMLPARSER, "Node 'lifespanQosPolicyType' without content");
  ------------------
  |  |   45|    198|#define EPROSIMA_LOG_ERROR(cat, msg) EPROSIMA_LOG_ERROR_IMPL_(cat, msg)
  |  |  ------------------
  |  |  |  |  291|    198|    do {                                                                                                               \
  |  |  |  |  292|    198|        std::stringstream fastdds_log_ss_tmp__;                                                                        \
  |  |  |  |  293|    198|        fastdds_log_ss_tmp__ << msg;                                                                                   \
  |  |  |  |  294|    198|        eprosima::fastdds::dds::Log::QueueLog(                                                                         \
  |  |  |  |  295|    198|            fastdds_log_ss_tmp__.str(), eprosima::fastdds::dds::Log::Context{__FILE__, __LINE__, __func__, #cat},      \
  |  |  |  |  296|    198|            eprosima::fastdds::dds::Log::Kind::Error);                                                                 \
  |  |  |  |  297|    198|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (297:14): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 2134|    198|        return XMLP_ret::XML_ERROR;
 2135|    198|    }
 2136|       |
 2137|      0|    return XMLP_ret::XML_OK;
 2138|    198|}
_ZN8eprosima7fastdds9xmlparser9XMLParser28getXMLDisablePositiveAcksQosEPN8tinyxml210XMLElementERNS0_3dds28DisablePositiveACKsQosPolicyEh:
 2144|    414|{
 2145|       |    /*
 2146|       |        <xs:complexType name="disablePositiveAcksQosPolicyType">
 2147|       |            <xs:all>
 2148|       |                <xs:element name="enabled" type="boolType"/>
 2149|       |                <xs:element name="duration" type="durationType"/>
 2150|       |            </xs:all>
 2151|       |        </xs:complexType>
 2152|       |     */
 2153|       |
 2154|    414|    tinyxml2::XMLElement* p_aux0 = nullptr;
 2155|    414|    const char* name = nullptr;
 2156|    414|    for (p_aux0 = elem->FirstChildElement(); p_aux0 != NULL; p_aux0 = p_aux0->NextSiblingElement())
  ------------------
  |  Branch (2156:46): [True: 0, False: 414]
  ------------------
 2157|      0|    {
 2158|      0|        name = p_aux0->Name();
 2159|      0|        if (strcmp(name, ENABLED) == 0)
  ------------------
  |  Branch (2159:13): [True: 0, False: 0]
  ------------------
 2160|      0|        {
 2161|      0|            if (XMLP_ret::XML_OK != getXMLBool(p_aux0, &disablePositiveAcks.enabled, ident))
  ------------------
  |  Branch (2161:17): [True: 0, False: 0]
  ------------------
 2162|      0|            {
 2163|      0|                return XMLP_ret::XML_ERROR;
 2164|      0|            }
 2165|      0|        }
 2166|      0|        else if (strcmp(name, DURATION) == 0)
  ------------------
  |  Branch (2166:18): [True: 0, False: 0]
  ------------------
 2167|      0|        {
 2168|      0|            if (XMLP_ret::XML_OK != getXMLDuration(p_aux0, disablePositiveAcks.duration, ident))
  ------------------
  |  Branch (2168:17): [True: 0, False: 0]
  ------------------
 2169|      0|            {
 2170|      0|                return XMLP_ret::XML_ERROR;
 2171|      0|            }
 2172|      0|        }
 2173|      0|        else
 2174|      0|        {
 2175|      0|            EPROSIMA_LOG_ERROR(XMLPARSER, "Node 'disablePositiveAcksQosPolicyType' with unknown content");
  ------------------
  |  |   45|      0|#define EPROSIMA_LOG_ERROR(cat, msg) EPROSIMA_LOG_ERROR_IMPL_(cat, msg)
  |  |  ------------------
  |  |  |  |  291|      0|    do {                                                                                                               \
  |  |  |  |  292|      0|        std::stringstream fastdds_log_ss_tmp__;                                                                        \
  |  |  |  |  293|      0|        fastdds_log_ss_tmp__ << msg;                                                                                   \
  |  |  |  |  294|      0|        eprosima::fastdds::dds::Log::QueueLog(                                                                         \
  |  |  |  |  295|      0|            fastdds_log_ss_tmp__.str(), eprosima::fastdds::dds::Log::Context{__FILE__, __LINE__, __func__, #cat},      \
  |  |  |  |  296|      0|            eprosima::fastdds::dds::Log::Kind::Error);                                                                 \
  |  |  |  |  297|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (297:14): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 2176|      0|            return XMLP_ret::XML_ERROR;
 2177|      0|        }
 2178|      0|    }
 2179|       |
 2180|    414|    return XMLP_ret::XML_OK;
 2181|    414|}
_ZN8eprosima7fastdds9xmlparser9XMLParser20getXMLDataSharingQosEPN8tinyxml210XMLElementERNS0_3dds20DataSharingQosPolicyEh:
 2187|    183|{
 2188|       |    /*
 2189|       |        <xs:complexType name="dataSharingQosPolicyType">
 2190|       |            <xs:all>
 2191|       |                <xs:element name="kind" minOccurs="1" maxOccurs="1">
 2192|       |                    <xs:simpleType>
 2193|       |                        <xs:restriction base="xs:string">
 2194|       |                            <xs:enumeration value="AUTOMATIC"/>
 2195|       |                            <xs:enumeration value="ON"/>
 2196|       |                            <xs:enumeration value="OFF"/>
 2197|       |                        </xs:restriction>
 2198|       |                    </xs:simpleType>
 2199|       |                </xs:element>
 2200|       |                <xs:element name="shared_dir" type="string" minOccurs="0" maxOccurs="1"/>
 2201|       |                <xs:element name="domain_ids" minOccurs="0" maxOccurs="1">
 2202|       |                    <xs:complexType>
 2203|       |                        <xs:sequence>
 2204|       |                            <xs:element name="domainId" type="domainIDType" minOccurs="0" maxOccurs="unbounded"/>
 2205|       |                        </xs:sequence>
 2206|       |                    </xs:complexType>
 2207|       |                </xs:element>
 2208|       |                <xs:element name="max_domains" type="uint32" minOccurs="0" maxOccurs="1"/>
 2209|       |                <xs:element name="data_sharing_listener_thread" type="threadSettingsType" minOccurs="0" maxOccurs="1"/>
 2210|       |            </xs:all>
 2211|       |        </xs:complexType>
 2212|       |     */
 2213|    183|    bool kind_found = false;
 2214|    183|    dds::DataSharingKind kind = dds::DataSharingKind::AUTO;
 2215|    183|    std::string shm_directory = "";
 2216|    183|    int32_t max_domains = 0;
 2217|    183|    std::vector<uint16_t> domain_ids;
 2218|       |
 2219|    183|    tinyxml2::XMLElement* p_aux0 = nullptr;
 2220|    183|    const char* name = nullptr;
 2221|    183|    for (p_aux0 = elem->FirstChildElement(); p_aux0 != NULL; p_aux0 = p_aux0->NextSiblingElement())
  ------------------
  |  Branch (2221:46): [True: 0, False: 183]
  ------------------
 2222|      0|    {
 2223|      0|        name = p_aux0->Name();
 2224|      0|        if (strcmp(name, KIND) == 0)
  ------------------
  |  Branch (2224:13): [True: 0, False: 0]
  ------------------
 2225|      0|        {
 2226|       |            /*
 2227|       |                <xs:simpleType name="datasharingQosKindType">
 2228|       |                    <xs:restriction base="xs:string">
 2229|       |                        <xs:enumeration value="ON"/>
 2230|       |                        <xs:enumeration value="OFF"/>
 2231|       |                        <xs:enumeration value="DEFAULT"/>
 2232|       |                    </xs:restriction>
 2233|       |                </xs:simpleType>
 2234|       |             */
 2235|      0|            std::string text = get_element_text(p_aux0);
 2236|      0|            if (text.empty())
  ------------------
  |  Branch (2236:17): [True: 0, False: 0]
  ------------------
 2237|      0|            {
 2238|      0|                EPROSIMA_LOG_ERROR(XMLPARSER, "Node '" << KIND << "' without content");
  ------------------
  |  |   45|      0|#define EPROSIMA_LOG_ERROR(cat, msg) EPROSIMA_LOG_ERROR_IMPL_(cat, msg)
  |  |  ------------------
  |  |  |  |  291|      0|    do {                                                                                                               \
  |  |  |  |  292|      0|        std::stringstream fastdds_log_ss_tmp__;                                                                        \
  |  |  |  |  293|      0|        fastdds_log_ss_tmp__ << msg;                                                                                   \
  |  |  |  |  294|      0|        eprosima::fastdds::dds::Log::QueueLog(                                                                         \
  |  |  |  |  295|      0|            fastdds_log_ss_tmp__.str(), eprosima::fastdds::dds::Log::Context{__FILE__, __LINE__, __func__, #cat},      \
  |  |  |  |  296|      0|            eprosima::fastdds::dds::Log::Kind::Error);                                                                 \
  |  |  |  |  297|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (297:14): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 2239|      0|                return XMLP_ret::XML_ERROR;
 2240|      0|            }
 2241|       |
 2242|      0|            if (!get_element_enum_value(text.c_str(), kind,
  ------------------
  |  Branch (2242:17): [True: 0, False: 0]
  ------------------
 2243|      0|                    ON, dds::DataSharingKind::ON,
 2244|      0|                    OFF, dds::DataSharingKind::OFF,
 2245|      0|                    AUTOMATIC, dds::DataSharingKind::AUTO,
 2246|      0|                    AUTO, dds::DataSharingKind::AUTO))
 2247|      0|            {
 2248|      0|                EPROSIMA_LOG_ERROR(XMLPARSER, "Node '" << KIND << "' with bad content");
  ------------------
  |  |   45|      0|#define EPROSIMA_LOG_ERROR(cat, msg) EPROSIMA_LOG_ERROR_IMPL_(cat, msg)
  |  |  ------------------
  |  |  |  |  291|      0|    do {                                                                                                               \
  |  |  |  |  292|      0|        std::stringstream fastdds_log_ss_tmp__;                                                                        \
  |  |  |  |  293|      0|        fastdds_log_ss_tmp__ << msg;                                                                                   \
  |  |  |  |  294|      0|        eprosima::fastdds::dds::Log::QueueLog(                                                                         \
  |  |  |  |  295|      0|            fastdds_log_ss_tmp__.str(), eprosima::fastdds::dds::Log::Context{__FILE__, __LINE__, __func__, #cat},      \
  |  |  |  |  296|      0|            eprosima::fastdds::dds::Log::Kind::Error);                                                                 \
  |  |  |  |  297|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (297:14): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 2249|      0|                return XMLP_ret::XML_ERROR;
 2250|      0|            }
 2251|      0|            kind_found = true;
 2252|      0|        }
 2253|      0|        else if (strcmp(name, SHARED_DIR) == 0)
  ------------------
  |  Branch (2253:18): [True: 0, False: 0]
  ------------------
 2254|      0|        {
 2255|      0|            if (XMLP_ret::XML_OK != getXMLString(p_aux0, &shm_directory, ident))
  ------------------
  |  Branch (2255:17): [True: 0, False: 0]
  ------------------
 2256|      0|            {
 2257|      0|                return XMLP_ret::XML_ERROR;
 2258|      0|            }
 2259|      0|        }
 2260|      0|        else if (strcmp(name, MAX_DOMAINS) == 0)
  ------------------
  |  Branch (2260:18): [True: 0, False: 0]
  ------------------
 2261|      0|        {
 2262|      0|            if (XMLP_ret::XML_OK != getXMLInt(p_aux0, &max_domains, ident))
  ------------------
  |  Branch (2262:17): [True: 0, False: 0]
  ------------------
 2263|      0|            {
 2264|      0|                return XMLP_ret::XML_ERROR;
 2265|      0|            }
 2266|      0|            if (max_domains < 0)
  ------------------
  |  Branch (2266:17): [True: 0, False: 0]
  ------------------
 2267|      0|            {
 2268|      0|                EPROSIMA_LOG_ERROR(XMLPARSER, "max domains cannot be negative");
  ------------------
  |  |   45|      0|#define EPROSIMA_LOG_ERROR(cat, msg) EPROSIMA_LOG_ERROR_IMPL_(cat, msg)
  |  |  ------------------
  |  |  |  |  291|      0|    do {                                                                                                               \
  |  |  |  |  292|      0|        std::stringstream fastdds_log_ss_tmp__;                                                                        \
  |  |  |  |  293|      0|        fastdds_log_ss_tmp__ << msg;                                                                                   \
  |  |  |  |  294|      0|        eprosima::fastdds::dds::Log::QueueLog(                                                                         \
  |  |  |  |  295|      0|            fastdds_log_ss_tmp__.str(), eprosima::fastdds::dds::Log::Context{__FILE__, __LINE__, __func__, #cat},      \
  |  |  |  |  296|      0|            eprosima::fastdds::dds::Log::Kind::Error);                                                                 \
  |  |  |  |  297|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (297:14): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 2269|      0|                return XMLP_ret::XML_ERROR;
 2270|      0|            }
 2271|       |
 2272|      0|        }
 2273|      0|        else if (strcmp(name, DOMAIN_IDS) == 0)
  ------------------
  |  Branch (2273:18): [True: 0, False: 0]
  ------------------
 2274|      0|        {
 2275|       |            /*
 2276|       |                <xs:complexType name="domainIdVectorType">
 2277|       |                    <xs:sequence>
 2278|       |                        <xs:element name="domainId" type="uint16Type" maxOccurs="unbounded"/>
 2279|       |                    </xs:sequence>
 2280|       |                </xs:complexType>
 2281|       |             */
 2282|       |
 2283|      0|            tinyxml2::XMLElement* p_aux1;
 2284|      0|            const char* name1 = nullptr;
 2285|      0|            bool domain_id_found = false;
 2286|      0|            for (p_aux1 = p_aux0->FirstChildElement(); p_aux1 != NULL; p_aux1 = p_aux1->NextSiblingElement())
  ------------------
  |  Branch (2286:56): [True: 0, False: 0]
  ------------------
 2287|      0|            {
 2288|      0|                name1 = p_aux1->Name();
 2289|      0|                if (strcmp(name1, DOMAIN_ID) == 0)
  ------------------
  |  Branch (2289:21): [True: 0, False: 0]
  ------------------
 2290|      0|                {
 2291|      0|                    uint16_t id;
 2292|      0|                    if (XMLP_ret::XML_OK != getXMLUint(p_aux1, &id, ident))
  ------------------
  |  Branch (2292:25): [True: 0, False: 0]
  ------------------
 2293|      0|                    {
 2294|      0|                        return XMLP_ret::XML_ERROR;
 2295|      0|                    }
 2296|      0|                    domain_ids.push_back(id);
 2297|      0|                    domain_id_found = true;
 2298|      0|                }
 2299|      0|                else
 2300|      0|                {
 2301|      0|                    EPROSIMA_LOG_ERROR(XMLPARSER, "Invalid element found in 'domain_ids'. Name: " << name1);
  ------------------
  |  |   45|      0|#define EPROSIMA_LOG_ERROR(cat, msg) EPROSIMA_LOG_ERROR_IMPL_(cat, msg)
  |  |  ------------------
  |  |  |  |  291|      0|    do {                                                                                                               \
  |  |  |  |  292|      0|        std::stringstream fastdds_log_ss_tmp__;                                                                        \
  |  |  |  |  293|      0|        fastdds_log_ss_tmp__ << msg;                                                                                   \
  |  |  |  |  294|      0|        eprosima::fastdds::dds::Log::QueueLog(                                                                         \
  |  |  |  |  295|      0|            fastdds_log_ss_tmp__.str(), eprosima::fastdds::dds::Log::Context{__FILE__, __LINE__, __func__, #cat},      \
  |  |  |  |  296|      0|            eprosima::fastdds::dds::Log::Kind::Error);                                                                 \
  |  |  |  |  297|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (297:14): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 2302|      0|                    return XMLP_ret::XML_ERROR;
 2303|      0|                }
 2304|      0|            }
 2305|       |
 2306|      0|            if (!domain_id_found)
  ------------------
  |  Branch (2306:17): [True: 0, False: 0]
  ------------------
 2307|      0|            {
 2308|       |                // Not even one
 2309|      0|                EPROSIMA_LOG_ERROR(XMLPARSER, "Node '" << DOMAIN_IDS << "' without content");
  ------------------
  |  |   45|      0|#define EPROSIMA_LOG_ERROR(cat, msg) EPROSIMA_LOG_ERROR_IMPL_(cat, msg)
  |  |  ------------------
  |  |  |  |  291|      0|    do {                                                                                                               \
  |  |  |  |  292|      0|        std::stringstream fastdds_log_ss_tmp__;                                                                        \
  |  |  |  |  293|      0|        fastdds_log_ss_tmp__ << msg;                                                                                   \
  |  |  |  |  294|      0|        eprosima::fastdds::dds::Log::QueueLog(                                                                         \
  |  |  |  |  295|      0|            fastdds_log_ss_tmp__.str(), eprosima::fastdds::dds::Log::Context{__FILE__, __LINE__, __func__, #cat},      \
  |  |  |  |  296|      0|            eprosima::fastdds::dds::Log::Kind::Error);                                                                 \
  |  |  |  |  297|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (297:14): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 2310|      0|                return XMLP_ret::XML_ERROR;
 2311|      0|            }
 2312|      0|        }
 2313|      0|        else if (strcmp(name, DATA_SHARING_LISTENER_THREAD) == 0)
  ------------------
  |  Branch (2313:18): [True: 0, False: 0]
  ------------------
 2314|      0|        {
 2315|       |            // data_sharing_listener_thread
 2316|      0|            if (XMLP_ret::XML_OK != getXMLThreadSettings(*p_aux0, data_sharing.data_sharing_listener_thread()))
  ------------------
  |  Branch (2316:17): [True: 0, False: 0]
  ------------------
 2317|      0|            {
 2318|      0|                return XMLP_ret::XML_ERROR;
 2319|      0|            }
 2320|      0|        }
 2321|      0|        else
 2322|      0|        {
 2323|      0|            EPROSIMA_LOG_ERROR(XMLPARSER, "Invalid element found in 'data_sharing'. Name: " << name);
  ------------------
  |  |   45|      0|#define EPROSIMA_LOG_ERROR(cat, msg) EPROSIMA_LOG_ERROR_IMPL_(cat, msg)
  |  |  ------------------
  |  |  |  |  291|      0|    do {                                                                                                               \
  |  |  |  |  292|      0|        std::stringstream fastdds_log_ss_tmp__;                                                                        \
  |  |  |  |  293|      0|        fastdds_log_ss_tmp__ << msg;                                                                                   \
  |  |  |  |  294|      0|        eprosima::fastdds::dds::Log::QueueLog(                                                                         \
  |  |  |  |  295|      0|            fastdds_log_ss_tmp__.str(), eprosima::fastdds::dds::Log::Context{__FILE__, __LINE__, __func__, #cat},      \
  |  |  |  |  296|      0|            eprosima::fastdds::dds::Log::Kind::Error);                                                                 \
  |  |  |  |  297|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (297:14): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 2324|      0|            return XMLP_ret::XML_ERROR;
 2325|      0|        }
 2326|      0|    }
 2327|       |
 2328|    183|    if (!kind_found)
  ------------------
  |  Branch (2328:9): [True: 183, False: 0]
  ------------------
 2329|    183|    {
 2330|    183|        EPROSIMA_LOG_ERROR(XMLPARSER, "Node 'data_sharing' without kind");
  ------------------
  |  |   45|    183|#define EPROSIMA_LOG_ERROR(cat, msg) EPROSIMA_LOG_ERROR_IMPL_(cat, msg)
  |  |  ------------------
  |  |  |  |  291|    183|    do {                                                                                                               \
  |  |  |  |  292|    183|        std::stringstream fastdds_log_ss_tmp__;                                                                        \
  |  |  |  |  293|    183|        fastdds_log_ss_tmp__ << msg;                                                                                   \
  |  |  |  |  294|    183|        eprosima::fastdds::dds::Log::QueueLog(                                                                         \
  |  |  |  |  295|    183|            fastdds_log_ss_tmp__.str(), eprosima::fastdds::dds::Log::Context{__FILE__, __LINE__, __func__, #cat},      \
  |  |  |  |  296|    183|            eprosima::fastdds::dds::Log::Kind::Error);                                                                 \
  |  |  |  |  297|    183|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (297:14): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 2331|    183|        return XMLP_ret::XML_ERROR;
 2332|    183|    }
 2333|       |
 2334|      0|    if (max_domains != 0 && domain_ids.size() > static_cast<uint32_t>(max_domains))
  ------------------
  |  Branch (2334:9): [True: 0, False: 0]
  |  Branch (2334:29): [True: 0, False: 0]
  ------------------
 2335|      0|    {
 2336|      0|        EPROSIMA_LOG_ERROR(XMLPARSER, "Node 'data_sharing' defines a maximum of " << max_domains
  ------------------
  |  |   45|      0|#define EPROSIMA_LOG_ERROR(cat, msg) EPROSIMA_LOG_ERROR_IMPL_(cat, msg)
  |  |  ------------------
  |  |  |  |  291|      0|    do {                                                                                                               \
  |  |  |  |  292|      0|        std::stringstream fastdds_log_ss_tmp__;                                                                        \
  |  |  |  |  293|      0|        fastdds_log_ss_tmp__ << msg;                                                                                   \
  |  |  |  |  294|      0|        eprosima::fastdds::dds::Log::QueueLog(                                                                         \
  |  |  |  |  295|      0|            fastdds_log_ss_tmp__.str(), eprosima::fastdds::dds::Log::Context{__FILE__, __LINE__, __func__, #cat},      \
  |  |  |  |  296|      0|            eprosima::fastdds::dds::Log::Kind::Error);                                                                 \
  |  |  |  |  297|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (297:14): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 2337|      0|                                                                                  << " domain IDs but also define " << domain_ids.size() <<
 2338|      0|                " domain IDs");
 2339|      0|        return XMLP_ret::XML_ERROR;
 2340|      0|    }
 2341|       |
 2342|      0|    data_sharing.set_max_domains(static_cast<uint32_t>(max_domains));
 2343|       |
 2344|      0|    switch (kind)
 2345|      0|    {
 2346|      0|        case dds::DataSharingKind::ON:
  ------------------
  |  Branch (2346:9): [True: 0, False: 0]
  ------------------
 2347|      0|            data_sharing.on(shm_directory, domain_ids);
 2348|      0|            break;
 2349|       |
 2350|      0|        case dds::DataSharingKind::AUTO:
  ------------------
  |  Branch (2350:9): [True: 0, False: 0]
  ------------------
 2351|      0|            data_sharing.automatic(shm_directory, domain_ids);
 2352|      0|            break;
 2353|       |
 2354|      0|        case dds::DataSharingKind::OFF:
  ------------------
  |  Branch (2354:9): [True: 0, False: 0]
  ------------------
 2355|      0|            data_sharing.off();
 2356|      0|            break;
 2357|       |
 2358|      0|        default:
  ------------------
  |  Branch (2358:9): [True: 0, False: 0]
  ------------------
 2359|      0|            break;
 2360|      0|    }
 2361|       |
 2362|      0|    return XMLP_ret::XML_OK;
 2363|      0|}
_ZN8eprosima7fastdds9xmlparser9XMLParser18getXMLOwnershipQosEPN8tinyxml210XMLElementERNS0_3dds18OwnershipQosPolicyEh:
 2414|    144|{
 2415|    144|    (void)ident;
 2416|       |
 2417|       |    //    <xs:complexType name="ownershipQosPolicyType">
 2418|       |    //        <xs:all>
 2419|       |    //            <xs:element name="kind" type="ownershipQosKindType"/>
 2420|       |    //        </xs:all>
 2421|       |    //    </xs:complexType>
 2422|       |
 2423|    144|    tinyxml2::XMLElement* p_aux0 = nullptr;
 2424|    144|    bool bKindDefined = false;
 2425|    144|    const char* name = nullptr;
 2426|    144|    for (p_aux0 = elem->FirstChildElement(); p_aux0 != NULL; p_aux0 = p_aux0->NextSiblingElement())
  ------------------
  |  Branch (2426:46): [True: 0, False: 144]
  ------------------
 2427|      0|    {
 2428|      0|        name = p_aux0->Name();
 2429|      0|        if (strcmp(name, KIND) == 0)
  ------------------
  |  Branch (2429:13): [True: 0, False: 0]
  ------------------
 2430|      0|        {
 2431|       |
 2432|       |            //    <xs:simpleType name="ownershipQosKindType">
 2433|       |            //        <xs:restriction base="xs:string">
 2434|       |            //            <xs:enumeration value="SHARED"/>
 2435|       |            //            <xs:enumeration value="EXCLUSIVE"/>
 2436|       |            //        </xs:restriction>
 2437|       |            //    </xs:simpleType>
 2438|       |
 2439|      0|            bKindDefined = true;
 2440|      0|            std::string text = get_element_text(p_aux0);
 2441|      0|            if (text.empty())
  ------------------
  |  Branch (2441:17): [True: 0, False: 0]
  ------------------
 2442|      0|            {
 2443|      0|                EPROSIMA_LOG_ERROR(XMLPARSER, "Node '" << KIND << "' without content");
  ------------------
  |  |   45|      0|#define EPROSIMA_LOG_ERROR(cat, msg) EPROSIMA_LOG_ERROR_IMPL_(cat, msg)
  |  |  ------------------
  |  |  |  |  291|      0|    do {                                                                                                               \
  |  |  |  |  292|      0|        std::stringstream fastdds_log_ss_tmp__;                                                                        \
  |  |  |  |  293|      0|        fastdds_log_ss_tmp__ << msg;                                                                                   \
  |  |  |  |  294|      0|        eprosima::fastdds::dds::Log::QueueLog(                                                                         \
  |  |  |  |  295|      0|            fastdds_log_ss_tmp__.str(), eprosima::fastdds::dds::Log::Context{__FILE__, __LINE__, __func__, #cat},      \
  |  |  |  |  296|      0|            eprosima::fastdds::dds::Log::Kind::Error);                                                                 \
  |  |  |  |  297|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (297:14): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 2444|      0|                return XMLP_ret::XML_ERROR;
 2445|      0|            }
 2446|       |
 2447|      0|            if (!get_element_enum_value(text.c_str(), ownership.kind,
  ------------------
  |  Branch (2447:17): [True: 0, False: 0]
  ------------------
 2448|      0|                    SHARED, dds::OwnershipQosPolicyKind::SHARED_OWNERSHIP_QOS,
 2449|      0|                    EXCLUSIVE, dds::OwnershipQosPolicyKind::EXCLUSIVE_OWNERSHIP_QOS))
 2450|      0|            {
 2451|      0|                EPROSIMA_LOG_ERROR(XMLPARSER, "Node '" << KIND << "' with bad content");
  ------------------
  |  |   45|      0|#define EPROSIMA_LOG_ERROR(cat, msg) EPROSIMA_LOG_ERROR_IMPL_(cat, msg)
  |  |  ------------------
  |  |  |  |  291|      0|    do {                                                                                                               \
  |  |  |  |  292|      0|        std::stringstream fastdds_log_ss_tmp__;                                                                        \
  |  |  |  |  293|      0|        fastdds_log_ss_tmp__ << msg;                                                                                   \
  |  |  |  |  294|      0|        eprosima::fastdds::dds::Log::QueueLog(                                                                         \
  |  |  |  |  295|      0|            fastdds_log_ss_tmp__.str(), eprosima::fastdds::dds::Log::Context{__FILE__, __LINE__, __func__, #cat},      \
  |  |  |  |  296|      0|            eprosima::fastdds::dds::Log::Kind::Error);                                                                 \
  |  |  |  |  297|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (297:14): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 2452|      0|                return XMLP_ret::XML_ERROR;
 2453|      0|            }
 2454|      0|        }
 2455|      0|        else
 2456|      0|        {
 2457|      0|            EPROSIMA_LOG_ERROR(XMLPARSER, "Invalid element found into 'ownershipQosPolicyType'. Name: " << name);
  ------------------
  |  |   45|      0|#define EPROSIMA_LOG_ERROR(cat, msg) EPROSIMA_LOG_ERROR_IMPL_(cat, msg)
  |  |  ------------------
  |  |  |  |  291|      0|    do {                                                                                                               \
  |  |  |  |  292|      0|        std::stringstream fastdds_log_ss_tmp__;                                                                        \
  |  |  |  |  293|      0|        fastdds_log_ss_tmp__ << msg;                                                                                   \
  |  |  |  |  294|      0|        eprosima::fastdds::dds::Log::QueueLog(                                                                         \
  |  |  |  |  295|      0|            fastdds_log_ss_tmp__.str(), eprosima::fastdds::dds::Log::Context{__FILE__, __LINE__, __func__, #cat},      \
  |  |  |  |  296|      0|            eprosima::fastdds::dds::Log::Kind::Error);                                                                 \
  |  |  |  |  297|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (297:14): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 2458|      0|            return XMLP_ret::XML_ERROR;
 2459|      0|        }
 2460|      0|    }
 2461|       |
 2462|    144|    if (!bKindDefined)
  ------------------
  |  Branch (2462:9): [True: 144, False: 0]
  ------------------
 2463|    144|    {
 2464|    144|        EPROSIMA_LOG_ERROR(XMLPARSER, "Node 'ownershipQosPolicyType' without content");
  ------------------
  |  |   45|    144|#define EPROSIMA_LOG_ERROR(cat, msg) EPROSIMA_LOG_ERROR_IMPL_(cat, msg)
  |  |  ------------------
  |  |  |  |  291|    144|    do {                                                                                                               \
  |  |  |  |  292|    144|        std::stringstream fastdds_log_ss_tmp__;                                                                        \
  |  |  |  |  293|    144|        fastdds_log_ss_tmp__ << msg;                                                                                   \
  |  |  |  |  294|    144|        eprosima::fastdds::dds::Log::QueueLog(                                                                         \
  |  |  |  |  295|    144|            fastdds_log_ss_tmp__.str(), eprosima::fastdds::dds::Log::Context{__FILE__, __LINE__, __func__, #cat},      \
  |  |  |  |  296|    144|            eprosima::fastdds::dds::Log::Kind::Error);                                                                 \
  |  |  |  |  297|    144|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (297:14): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 2465|    144|        return XMLP_ret::XML_ERROR;
 2466|    144|    }
 2467|       |
 2468|      0|    return XMLP_ret::XML_OK;
 2469|    144|}
_ZN8eprosima7fastdds9xmlparser9XMLParser26getXMLOwnershipStrengthQosEPN8tinyxml210XMLElementERNS0_3dds26OwnershipStrengthQosPolicyEh:
 2475|    265|{
 2476|       |
 2477|       |    //    <xs:complexType name="ownershipStrengthQosPolicyType">
 2478|       |    //        <xs:all>
 2479|       |    //            <xs:element name="value" type="uint32Type"/>
 2480|       |    //        </xs:all>
 2481|       |    //    </xs:complexType>
 2482|       |
 2483|    265|    tinyxml2::XMLElement* p_aux0 = nullptr;
 2484|    265|    bool bValueDefined = false;
 2485|    265|    const char* name = nullptr;
 2486|    265|    for (p_aux0 = elem->FirstChildElement(); p_aux0 != NULL; p_aux0 = p_aux0->NextSiblingElement())
  ------------------
  |  Branch (2486:46): [True: 0, False: 265]
  ------------------
 2487|      0|    {
 2488|      0|        name = p_aux0->Name();
 2489|      0|        if (strcmp(name, VALUE) == 0)
  ------------------
  |  Branch (2489:13): [True: 0, False: 0]
  ------------------
 2490|      0|        {
 2491|      0|            bValueDefined = true;
 2492|      0|            if (XMLP_ret::XML_OK != getXMLUint(p_aux0, &ownershipStrength.value, ident))
  ------------------
  |  Branch (2492:17): [True: 0, False: 0]
  ------------------
 2493|      0|            {
 2494|      0|                return XMLP_ret::XML_ERROR;
 2495|      0|            }
 2496|      0|        }
 2497|      0|        else
 2498|      0|        {
 2499|      0|            EPROSIMA_LOG_ERROR(XMLPARSER,
  ------------------
  |  |   45|      0|#define EPROSIMA_LOG_ERROR(cat, msg) EPROSIMA_LOG_ERROR_IMPL_(cat, msg)
  |  |  ------------------
  |  |  |  |  291|      0|    do {                                                                                                               \
  |  |  |  |  292|      0|        std::stringstream fastdds_log_ss_tmp__;                                                                        \
  |  |  |  |  293|      0|        fastdds_log_ss_tmp__ << msg;                                                                                   \
  |  |  |  |  294|      0|        eprosima::fastdds::dds::Log::QueueLog(                                                                         \
  |  |  |  |  295|      0|            fastdds_log_ss_tmp__.str(), eprosima::fastdds::dds::Log::Context{__FILE__, __LINE__, __func__, #cat},      \
  |  |  |  |  296|      0|            eprosima::fastdds::dds::Log::Kind::Error);                                                                 \
  |  |  |  |  297|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (297:14): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 2500|      0|                    "Invalid element found into 'ownershipStrengthQosPolicyType'. Name: " << name);
 2501|      0|            return XMLP_ret::XML_ERROR;
 2502|      0|        }
 2503|      0|    }
 2504|       |
 2505|    265|    if (!bValueDefined)
  ------------------
  |  Branch (2505:9): [True: 265, False: 0]
  ------------------
 2506|    265|    {
 2507|    265|        EPROSIMA_LOG_ERROR(XMLPARSER, "Node 'ownershipStrengthQosPolicyType' without content");
  ------------------
  |  |   45|    265|#define EPROSIMA_LOG_ERROR(cat, msg) EPROSIMA_LOG_ERROR_IMPL_(cat, msg)
  |  |  ------------------
  |  |  |  |  291|    265|    do {                                                                                                               \
  |  |  |  |  292|    265|        std::stringstream fastdds_log_ss_tmp__;                                                                        \
  |  |  |  |  293|    265|        fastdds_log_ss_tmp__ << msg;                                                                                   \
  |  |  |  |  294|    265|        eprosima::fastdds::dds::Log::QueueLog(                                                                         \
  |  |  |  |  295|    265|            fastdds_log_ss_tmp__.str(), eprosima::fastdds::dds::Log::Context{__FILE__, __LINE__, __func__, #cat},      \
  |  |  |  |  296|    265|            eprosima::fastdds::dds::Log::Kind::Error);                                                                 \
  |  |  |  |  297|    265|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (297:14): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 2508|    265|        return XMLP_ret::XML_ERROR;
 2509|    265|    }
 2510|       |
 2511|      0|    return XMLP_ret::XML_OK;
 2512|    265|}
_ZN8eprosima7fastdds9xmlparser9XMLParser18getXMLPartitionQosEPN8tinyxml210XMLElementERNS0_3dds18PartitionQosPolicyEh:
 2671|    501|{
 2672|       |    /*
 2673|       |        <xs:complexType name="partitionQosPolicyType">
 2674|       |            <xs:all>
 2675|       |                <xs:element name="names" type="nameVectorType"/>
 2676|       |            </xs:all>
 2677|       |        </xs:complexType>
 2678|       |     */
 2679|       |
 2680|    501|    tinyxml2::XMLElement* p_aux0 = nullptr, * p_aux1 = nullptr;
 2681|    501|    bool bNamesDefined = false;
 2682|    501|    const char* name = nullptr;
 2683|    501|    for (p_aux0 = elem->FirstChildElement(); p_aux0 != NULL; p_aux0 = p_aux0->NextSiblingElement())
  ------------------
  |  Branch (2683:46): [True: 0, False: 501]
  ------------------
 2684|      0|    {
 2685|      0|        name = p_aux0->Name();
 2686|      0|        if (strcmp(name, NAMES) == 0)
  ------------------
  |  Branch (2686:13): [True: 0, False: 0]
  ------------------
 2687|      0|        {
 2688|      0|            bNamesDefined = true;
 2689|      0|            p_aux1 = p_aux0->FirstChildElement(NAME);
 2690|      0|            if (nullptr == p_aux1)
  ------------------
  |  Branch (2690:17): [True: 0, False: 0]
  ------------------
 2691|      0|            {
 2692|       |                // Not even one
 2693|      0|                EPROSIMA_LOG_ERROR(XMLPARSER, "Node '" << NAMES << "' without content");
  ------------------
  |  |   45|      0|#define EPROSIMA_LOG_ERROR(cat, msg) EPROSIMA_LOG_ERROR_IMPL_(cat, msg)
  |  |  ------------------
  |  |  |  |  291|      0|    do {                                                                                                               \
  |  |  |  |  292|      0|        std::stringstream fastdds_log_ss_tmp__;                                                                        \
  |  |  |  |  293|      0|        fastdds_log_ss_tmp__ << msg;                                                                                   \
  |  |  |  |  294|      0|        eprosima::fastdds::dds::Log::QueueLog(                                                                         \
  |  |  |  |  295|      0|            fastdds_log_ss_tmp__.str(), eprosima::fastdds::dds::Log::Context{__FILE__, __LINE__, __func__, #cat},      \
  |  |  |  |  296|      0|            eprosima::fastdds::dds::Log::Kind::Error);                                                                 \
  |  |  |  |  297|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (297:14): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 2694|      0|                return XMLP_ret::XML_ERROR;
 2695|      0|            }
 2696|       |
 2697|      0|            std::vector<std::string> names;
 2698|      0|            while (nullptr != p_aux1)
  ------------------
  |  Branch (2698:20): [True: 0, False: 0]
  ------------------
 2699|      0|            {
 2700|      0|                std::string sName = "";
 2701|      0|                if (XMLP_ret::XML_OK != getXMLString(p_aux1, &sName, ident))
  ------------------
  |  Branch (2701:21): [True: 0, False: 0]
  ------------------
 2702|      0|                {
 2703|      0|                    return XMLP_ret::XML_ERROR;
 2704|      0|                }
 2705|      0|                names.push_back(sName);
 2706|      0|                p_aux1 = p_aux1->NextSiblingElement(NAME);
 2707|      0|            }
 2708|      0|            partition.names(names);
 2709|      0|        }
 2710|      0|        else
 2711|      0|        {
 2712|      0|            EPROSIMA_LOG_ERROR(XMLPARSER, "Invalid element found into 'partitionQosPolicyType'. Name: " << name);
  ------------------
  |  |   45|      0|#define EPROSIMA_LOG_ERROR(cat, msg) EPROSIMA_LOG_ERROR_IMPL_(cat, msg)
  |  |  ------------------
  |  |  |  |  291|      0|    do {                                                                                                               \
  |  |  |  |  292|      0|        std::stringstream fastdds_log_ss_tmp__;                                                                        \
  |  |  |  |  293|      0|        fastdds_log_ss_tmp__ << msg;                                                                                   \
  |  |  |  |  294|      0|        eprosima::fastdds::dds::Log::QueueLog(                                                                         \
  |  |  |  |  295|      0|            fastdds_log_ss_tmp__.str(), eprosima::fastdds::dds::Log::Context{__FILE__, __LINE__, __func__, #cat},      \
  |  |  |  |  296|      0|            eprosima::fastdds::dds::Log::Kind::Error);                                                                 \
  |  |  |  |  297|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (297:14): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 2713|      0|            return XMLP_ret::XML_ERROR;
 2714|      0|        }
 2715|      0|    }
 2716|       |
 2717|    501|    if (!bNamesDefined)
  ------------------
  |  Branch (2717:9): [True: 501, False: 0]
  ------------------
 2718|    501|    {
 2719|    501|        EPROSIMA_LOG_ERROR(XMLPARSER, "Node 'partitionQosPolicyType' without content");
  ------------------
  |  |   45|    501|#define EPROSIMA_LOG_ERROR(cat, msg) EPROSIMA_LOG_ERROR_IMPL_(cat, msg)
  |  |  ------------------
  |  |  |  |  291|    501|    do {                                                                                                               \
  |  |  |  |  292|    501|        std::stringstream fastdds_log_ss_tmp__;                                                                        \
  |  |  |  |  293|    501|        fastdds_log_ss_tmp__ << msg;                                                                                   \
  |  |  |  |  294|    501|        eprosima::fastdds::dds::Log::QueueLog(                                                                         \
  |  |  |  |  295|    501|            fastdds_log_ss_tmp__.str(), eprosima::fastdds::dds::Log::Context{__FILE__, __LINE__, __func__, #cat},      \
  |  |  |  |  296|    501|            eprosima::fastdds::dds::Log::Kind::Error);                                                                 \
  |  |  |  |  297|    501|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (297:14): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 2720|    501|        return XMLP_ret::XML_ERROR;
 2721|    501|    }
 2722|       |
 2723|      0|    return XMLP_ret::XML_OK;
 2724|    501|}
_ZN8eprosima7fastdds9xmlparser9XMLParser20getXMLPublishModeQosEPN8tinyxml210XMLElementERNS0_3dds20PublishModeQosPolicyEh:
 2730|     88|{
 2731|       |    /*
 2732|       |        <xs:complexType name="publishModeQosPolicyType">
 2733|       |            <xs:all>
 2734|       |                <xs:element name="kind" type="publishModeQosKindType"/>
 2735|       |            </xs:all>
 2736|       |        </xs:complexType>
 2737|       |     */
 2738|     88|    tinyxml2::XMLElement* p_aux0 = nullptr;
 2739|     88|    bool bKindDefined = false;
 2740|     88|    const char* name = nullptr;
 2741|     88|    for (p_aux0 = elem->FirstChildElement(); p_aux0 != NULL; p_aux0 = p_aux0->NextSiblingElement())
  ------------------
  |  Branch (2741:46): [True: 0, False: 88]
  ------------------
 2742|      0|    {
 2743|      0|        name = p_aux0->Name();
 2744|      0|        if (strcmp(name, KIND) == 0)
  ------------------
  |  Branch (2744:13): [True: 0, False: 0]
  ------------------
 2745|      0|        {
 2746|       |            /*
 2747|       |                <xs:simpleType name="publishModeQosKindType">
 2748|       |                    <xs:restriction base="xs:string">
 2749|       |                        <xs:enumeration value="SYNCHRONOUS"/>
 2750|       |                        <xs:enumeration value="ASYNCHRONOUS"/>
 2751|       |                    </xs:restriction>
 2752|       |                </xs:simpleType>
 2753|       |             */
 2754|      0|            bKindDefined = true;
 2755|      0|            std::string text = get_element_text(p_aux0);
 2756|      0|            if (text.empty())
  ------------------
  |  Branch (2756:17): [True: 0, False: 0]
  ------------------
 2757|      0|            {
 2758|      0|                EPROSIMA_LOG_ERROR(XMLPARSER, "Node '" << KIND << "' without content");
  ------------------
  |  |   45|      0|#define EPROSIMA_LOG_ERROR(cat, msg) EPROSIMA_LOG_ERROR_IMPL_(cat, msg)
  |  |  ------------------
  |  |  |  |  291|      0|    do {                                                                                                               \
  |  |  |  |  292|      0|        std::stringstream fastdds_log_ss_tmp__;                                                                        \
  |  |  |  |  293|      0|        fastdds_log_ss_tmp__ << msg;                                                                                   \
  |  |  |  |  294|      0|        eprosima::fastdds::dds::Log::QueueLog(                                                                         \
  |  |  |  |  295|      0|            fastdds_log_ss_tmp__.str(), eprosima::fastdds::dds::Log::Context{__FILE__, __LINE__, __func__, #cat},      \
  |  |  |  |  296|      0|            eprosima::fastdds::dds::Log::Kind::Error);                                                                 \
  |  |  |  |  297|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (297:14): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 2759|      0|                return XMLP_ret::XML_ERROR;
 2760|      0|            }
 2761|       |
 2762|      0|            if (!get_element_enum_value(text.c_str(), publishMode.kind,
  ------------------
  |  Branch (2762:17): [True: 0, False: 0]
  ------------------
 2763|      0|                    SYNCHRONOUS, dds::PublishModeQosPolicyKind::SYNCHRONOUS_PUBLISH_MODE,
 2764|      0|                    ASYNCHRONOUS, dds::PublishModeQosPolicyKind::ASYNCHRONOUS_PUBLISH_MODE))
 2765|      0|            {
 2766|      0|                EPROSIMA_LOG_ERROR(XMLPARSER, "Node '" << KIND << "' bad content");
  ------------------
  |  |   45|      0|#define EPROSIMA_LOG_ERROR(cat, msg) EPROSIMA_LOG_ERROR_IMPL_(cat, msg)
  |  |  ------------------
  |  |  |  |  291|      0|    do {                                                                                                               \
  |  |  |  |  292|      0|        std::stringstream fastdds_log_ss_tmp__;                                                                        \
  |  |  |  |  293|      0|        fastdds_log_ss_tmp__ << msg;                                                                                   \
  |  |  |  |  294|      0|        eprosima::fastdds::dds::Log::QueueLog(                                                                         \
  |  |  |  |  295|      0|            fastdds_log_ss_tmp__.str(), eprosima::fastdds::dds::Log::Context{__FILE__, __LINE__, __func__, #cat},      \
  |  |  |  |  296|      0|            eprosima::fastdds::dds::Log::Kind::Error);                                                                 \
  |  |  |  |  297|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (297:14): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 2767|      0|                return XMLP_ret::XML_ERROR;
 2768|      0|            }
 2769|      0|        }
 2770|      0|        else if (strcmp(name, FLOW_CONTROLLER_NAME) == 0)
  ------------------
  |  Branch (2770:18): [True: 0, False: 0]
  ------------------
 2771|      0|        {
 2772|       |
 2773|      0|            publishMode.flow_controller_name = get_element_text(p_aux0);
 2774|      0|            if (publishMode.flow_controller_name.empty())
  ------------------
  |  Branch (2774:17): [True: 0, False: 0]
  ------------------
 2775|      0|            {
 2776|      0|                EPROSIMA_LOG_ERROR(XMLPARSER, "Node '" << FLOW_CONTROLLER_NAME << "' without content");
  ------------------
  |  |   45|      0|#define EPROSIMA_LOG_ERROR(cat, msg) EPROSIMA_LOG_ERROR_IMPL_(cat, msg)
  |  |  ------------------
  |  |  |  |  291|      0|    do {                                                                                                               \
  |  |  |  |  292|      0|        std::stringstream fastdds_log_ss_tmp__;                                                                        \
  |  |  |  |  293|      0|        fastdds_log_ss_tmp__ << msg;                                                                                   \
  |  |  |  |  294|      0|        eprosima::fastdds::dds::Log::QueueLog(                                                                         \
  |  |  |  |  295|      0|            fastdds_log_ss_tmp__.str(), eprosima::fastdds::dds::Log::Context{__FILE__, __LINE__, __func__, #cat},      \
  |  |  |  |  296|      0|            eprosima::fastdds::dds::Log::Kind::Error);                                                                 \
  |  |  |  |  297|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (297:14): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 2777|      0|                return XMLP_ret::XML_ERROR;
 2778|      0|            }
 2779|      0|        }
 2780|      0|        else
 2781|      0|        {
 2782|      0|            EPROSIMA_LOG_ERROR(XMLPARSER, "Invalid element found into 'publishModeQosPolicyType'. Name: " << name);
  ------------------
  |  |   45|      0|#define EPROSIMA_LOG_ERROR(cat, msg) EPROSIMA_LOG_ERROR_IMPL_(cat, msg)
  |  |  ------------------
  |  |  |  |  291|      0|    do {                                                                                                               \
  |  |  |  |  292|      0|        std::stringstream fastdds_log_ss_tmp__;                                                                        \
  |  |  |  |  293|      0|        fastdds_log_ss_tmp__ << msg;                                                                                   \
  |  |  |  |  294|      0|        eprosima::fastdds::dds::Log::QueueLog(                                                                         \
  |  |  |  |  295|      0|            fastdds_log_ss_tmp__.str(), eprosima::fastdds::dds::Log::Context{__FILE__, __LINE__, __func__, #cat},      \
  |  |  |  |  296|      0|            eprosima::fastdds::dds::Log::Kind::Error);                                                                 \
  |  |  |  |  297|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (297:14): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 2783|      0|            return XMLP_ret::XML_ERROR;
 2784|      0|        }
 2785|      0|    }
 2786|       |
 2787|     88|    if (!bKindDefined)
  ------------------
  |  Branch (2787:9): [True: 88, False: 0]
  ------------------
 2788|     88|    {
 2789|     88|        EPROSIMA_LOG_ERROR(XMLPARSER, "Node 'publishModeQosPolicyType' without content");
  ------------------
  |  |   45|     88|#define EPROSIMA_LOG_ERROR(cat, msg) EPROSIMA_LOG_ERROR_IMPL_(cat, msg)
  |  |  ------------------
  |  |  |  |  291|     88|    do {                                                                                                               \
  |  |  |  |  292|     88|        std::stringstream fastdds_log_ss_tmp__;                                                                        \
  |  |  |  |  293|     88|        fastdds_log_ss_tmp__ << msg;                                                                                   \
  |  |  |  |  294|     88|        eprosima::fastdds::dds::Log::QueueLog(                                                                         \
  |  |  |  |  295|     88|            fastdds_log_ss_tmp__.str(), eprosima::fastdds::dds::Log::Context{__FILE__, __LINE__, __func__, #cat},      \
  |  |  |  |  296|     88|            eprosima::fastdds::dds::Log::Kind::Error);                                                                 \
  |  |  |  |  297|     88|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (297:14): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 2790|     88|        return XMLP_ret::XML_ERROR;
 2791|     88|    }
 2792|       |
 2793|      0|    return XMLP_ret::XML_OK;
 2794|     88|}
_ZN8eprosima7fastdds9xmlparser9XMLParser14getXMLDurationEPN8tinyxml210XMLElementERNS0_3dds6Time_tEh:
 2800|  7.36k|{
 2801|       |    /*
 2802|       |       <xs:complexType name="durationType" mixed="true">
 2803|       |       <xs:sequence>
 2804|       |        <xs:choice minOccurs="0">
 2805|       |         <xs:sequence>
 2806|       |          <xs:element name="sec" type="nonNegativeInteger_Duration_SEC" default="0" minOccurs="1" maxOccurs="1"/>
 2807|       |          <xs:element name="nanosec" type="nonNegativeInteger_Duration_NSEC" default="0" minOccurs="0" maxOccurs="1"/>
 2808|       |         </xs:sequence>
 2809|       |         <xs:sequence>
 2810|       |          <xs:element name="nanosec" type="nonNegativeInteger_Duration_NSEC" default="0" minOccurs="1" maxOccurs="1"/>
 2811|       |          <xs:element name="sec" type="nonNegativeInteger_Duration_SEC" default="0" minOccurs="0" maxOccurs="1"/>
 2812|       |        </xs:sequence>
 2813|       |       </xs:choice>
 2814|       |       </xs:sequence>
 2815|       |       </xs:complexType>
 2816|       |     */
 2817|       |
 2818|       |    // set default values
 2819|  7.36k|    duration.seconds = 0;
 2820|  7.36k|    duration.nanosec = 0;
 2821|       |
 2822|       |    // it's mandatory to provide a sec or nanocsec child item
 2823|  7.36k|    bool empty = true;
 2824|       |
 2825|       |    // First we check if it matches the schema pattern
 2826|  7.36k|    std::regex infinite(DURATION_INFINITY);
 2827|  7.36k|    std::regex infinite_sec(DURATION_INFINITE_SEC);
 2828|  7.36k|    std::regex infinite_nsec(DURATION_INFINITE_NSEC);
 2829|  7.36k|    std::string text = get_element_text(elem);
 2830|       |
 2831|  7.36k|    if (!text.empty() && std::regex_match(text, infinite))
  ------------------
  |  Branch (2831:9): [True: 3.22k, False: 4.14k]
  |  Branch (2831:26): [True: 191, False: 3.03k]
  ------------------
 2832|    191|    {
 2833|    191|        empty = false;
 2834|    191|        duration = dds::c_TimeInfinite;
 2835|       |
 2836|    191|        if (elem->FirstChildElement() != nullptr)
  ------------------
  |  Branch (2836:13): [True: 19, False: 172]
  ------------------
 2837|     19|        {
 2838|     19|            EPROSIMA_LOG_ERROR(XMLPARSER, "If a dds::Duration_t type element is defined as DURATION_INFINITY it cannot have <sec> or"
  ------------------
  |  |   45|     19|#define EPROSIMA_LOG_ERROR(cat, msg) EPROSIMA_LOG_ERROR_IMPL_(cat, msg)
  |  |  ------------------
  |  |  |  |  291|     19|    do {                                                                                                               \
  |  |  |  |  292|     19|        std::stringstream fastdds_log_ss_tmp__;                                                                        \
  |  |  |  |  293|     19|        fastdds_log_ss_tmp__ << msg;                                                                                   \
  |  |  |  |  294|     19|        eprosima::fastdds::dds::Log::QueueLog(                                                                         \
  |  |  |  |  295|     19|            fastdds_log_ss_tmp__.str(), eprosima::fastdds::dds::Log::Context{__FILE__, __LINE__, __func__, #cat},      \
  |  |  |  |  296|     19|            eprosima::fastdds::dds::Log::Kind::Error);                                                                 \
  |  |  |  |  297|     19|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (297:14): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 2839|     19|                    " <nanosec> subelements.");
 2840|     19|            return XMLP_ret::XML_ERROR;
 2841|     19|        }
 2842|    191|    }
 2843|       |
 2844|  7.34k|    tinyxml2::XMLElement* p_aux0 = nullptr;
 2845|  7.34k|    const char* name = nullptr;
 2846|  17.2k|    for (p_aux0 = elem->FirstChildElement(); p_aux0 != NULL; p_aux0 = p_aux0->NextSiblingElement())
  ------------------
  |  Branch (2846:46): [True: 12.5k, False: 4.68k]
  ------------------
 2847|  12.5k|    {
 2848|       |        // there is at least a child element
 2849|  12.5k|        empty = false;
 2850|       |
 2851|  12.5k|        name = p_aux0->Name();
 2852|  12.5k|        if (strcmp(name, SECONDS) == 0)
  ------------------
  |  Branch (2852:13): [True: 10.2k, False: 2.28k]
  ------------------
 2853|  10.2k|        {
 2854|       |            /*
 2855|       |               <xs:simpleType name="nonNegativeInteger_Duration_SEC">
 2856|       |                    <xs:union>
 2857|       |                        <xs:simpleType>
 2858|       |                            <xs:restriction base="xs:string">
 2859|       |                                <xs:pattern value="\s*(DURATION_INFINITY|DURATION_INFINITE_SEC)\s*"/>
 2860|       |                            </xs:restriction>
 2861|       |                        </xs:simpleType>
 2862|       |                        <xs:simpleType>
 2863|       |                            <xs:restriction base="xs:unsignedInt"/>
 2864|       |                        </xs:simpleType>
 2865|       |                    </xs:union>
 2866|       |                </xs:simpleType>
 2867|       |             */
 2868|  10.2k|            text = get_element_text(p_aux0);
 2869|  10.2k|            if (text.empty())
  ------------------
  |  Branch (2869:17): [True: 211, False: 10.0k]
  ------------------
 2870|    211|            {
 2871|    211|                EPROSIMA_LOG_ERROR(XMLPARSER, "Node 'SECONDS' without content");
  ------------------
  |  |   45|    211|#define EPROSIMA_LOG_ERROR(cat, msg) EPROSIMA_LOG_ERROR_IMPL_(cat, msg)
  |  |  ------------------
  |  |  |  |  291|    211|    do {                                                                                                               \
  |  |  |  |  292|    211|        std::stringstream fastdds_log_ss_tmp__;                                                                        \
  |  |  |  |  293|    211|        fastdds_log_ss_tmp__ << msg;                                                                                   \
  |  |  |  |  294|    211|        eprosima::fastdds::dds::Log::QueueLog(                                                                         \
  |  |  |  |  295|    211|            fastdds_log_ss_tmp__.str(), eprosima::fastdds::dds::Log::Context{__FILE__, __LINE__, __func__, #cat},      \
  |  |  |  |  296|    211|            eprosima::fastdds::dds::Log::Kind::Error);                                                                 \
  |  |  |  |  297|    211|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (297:14): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 2872|    211|                return XMLP_ret::XML_ERROR;
 2873|    211|            }
 2874|  10.0k|            else if (std::regex_match(text, infinite_sec))
  ------------------
  |  Branch (2874:22): [True: 30, False: 10.0k]
  ------------------
 2875|     30|            {
 2876|       |                // if either SECONDS or NANOSECONDS is set to infinity then all of it is
 2877|     30|                duration = dds::c_TimeInfinite;
 2878|     30|                return XMLP_ret::XML_OK;
 2879|     30|            }
 2880|  10.0k|            else if (XMLP_ret::XML_OK != getXMLInt(p_aux0, &duration.seconds, ident))
  ------------------
  |  Branch (2880:22): [True: 131, False: 9.88k]
  ------------------
 2881|    131|            {
 2882|    131|                EPROSIMA_LOG_ERROR(XMLPARSER, "<" << elem->Value() << "> getXMLInt XML_ERROR!");
  ------------------
  |  |   45|    131|#define EPROSIMA_LOG_ERROR(cat, msg) EPROSIMA_LOG_ERROR_IMPL_(cat, msg)
  |  |  ------------------
  |  |  |  |  291|    131|    do {                                                                                                               \
  |  |  |  |  292|    131|        std::stringstream fastdds_log_ss_tmp__;                                                                        \
  |  |  |  |  293|    131|        fastdds_log_ss_tmp__ << msg;                                                                                   \
  |  |  |  |  294|    131|        eprosima::fastdds::dds::Log::QueueLog(                                                                         \
  |  |  |  |  295|    131|            fastdds_log_ss_tmp__.str(), eprosima::fastdds::dds::Log::Context{__FILE__, __LINE__, __func__, #cat},      \
  |  |  |  |  296|    131|            eprosima::fastdds::dds::Log::Kind::Error);                                                                 \
  |  |  |  |  297|    131|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (297:14): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 2883|    131|                return XMLP_ret::XML_ERROR;
 2884|    131|            }
 2885|  10.2k|        }
 2886|  2.28k|        else if (strcmp(name, NANOSECONDS) == 0)
  ------------------
  |  Branch (2886:18): [True: 1.89k, False: 388]
  ------------------
 2887|  1.89k|        {
 2888|       |            /*
 2889|       |                <xs:simpleType name="nonNegativeInteger_Duration_NSEC">
 2890|       |                    <xs:union>
 2891|       |                        <xs:simpleType>
 2892|       |                            <xs:restriction base="xs:string">
 2893|       |                                <xs:pattern value="\s*(DURATION_INFINITY|DURATION_INFINITE_NSEC)\s*"/>
 2894|       |                            </xs:restriction>
 2895|       |                        </xs:simpleType>
 2896|       |                        <xs:simpleType>
 2897|       |                            <xs:restriction base="xs:unsignedInt"/>
 2898|       |                        </xs:simpleType>
 2899|       |                    </xs:union>
 2900|       |                </xs:simpleType>
 2901|       |             */
 2902|  1.89k|            text = get_element_text(p_aux0);
 2903|  1.89k|            if (text.empty())
  ------------------
  |  Branch (2903:17): [True: 1.89k, False: 0]
  ------------------
 2904|  1.89k|            {
 2905|  1.89k|                EPROSIMA_LOG_ERROR(XMLPARSER, "Node 'NANOSECONDS' without content");
  ------------------
  |  |   45|  1.89k|#define EPROSIMA_LOG_ERROR(cat, msg) EPROSIMA_LOG_ERROR_IMPL_(cat, msg)
  |  |  ------------------
  |  |  |  |  291|  1.89k|    do {                                                                                                               \
  |  |  |  |  292|  1.89k|        std::stringstream fastdds_log_ss_tmp__;                                                                        \
  |  |  |  |  293|  1.89k|        fastdds_log_ss_tmp__ << msg;                                                                                   \
  |  |  |  |  294|  1.89k|        eprosima::fastdds::dds::Log::QueueLog(                                                                         \
  |  |  |  |  295|  1.89k|            fastdds_log_ss_tmp__.str(), eprosima::fastdds::dds::Log::Context{__FILE__, __LINE__, __func__, #cat},      \
  |  |  |  |  296|  1.89k|            eprosima::fastdds::dds::Log::Kind::Error);                                                                 \
  |  |  |  |  297|  1.89k|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (297:14): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 2906|  1.89k|                return XMLP_ret::XML_ERROR;
 2907|  1.89k|            }
 2908|      0|            else if (std::regex_match(text, infinite_nsec))
  ------------------
  |  Branch (2908:22): [True: 0, False: 0]
  ------------------
 2909|      0|            {
 2910|       |                // if either SECONDS or NANOSECONDS is set to infinity then all of it is
 2911|      0|                duration = dds::c_TimeInfinite;
 2912|      0|                return XMLP_ret::XML_OK;
 2913|      0|            }
 2914|      0|            else if (XMLP_ret::XML_OK != getXMLUint(p_aux0, &duration.nanosec, ident))
  ------------------
  |  Branch (2914:22): [True: 0, False: 0]
  ------------------
 2915|      0|            {
 2916|      0|                EPROSIMA_LOG_ERROR(XMLPARSER, "<" << elem->Value() << "> getXMLInt XML_ERROR!");
  ------------------
  |  |   45|      0|#define EPROSIMA_LOG_ERROR(cat, msg) EPROSIMA_LOG_ERROR_IMPL_(cat, msg)
  |  |  ------------------
  |  |  |  |  291|      0|    do {                                                                                                               \
  |  |  |  |  292|      0|        std::stringstream fastdds_log_ss_tmp__;                                                                        \
  |  |  |  |  293|      0|        fastdds_log_ss_tmp__ << msg;                                                                                   \
  |  |  |  |  294|      0|        eprosima::fastdds::dds::Log::QueueLog(                                                                         \
  |  |  |  |  295|      0|            fastdds_log_ss_tmp__.str(), eprosima::fastdds::dds::Log::Context{__FILE__, __LINE__, __func__, #cat},      \
  |  |  |  |  296|      0|            eprosima::fastdds::dds::Log::Kind::Error);                                                                 \
  |  |  |  |  297|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (297:14): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 2917|      0|                return XMLP_ret::XML_ERROR;
 2918|      0|            }
 2919|  1.89k|        }
 2920|    388|        else
 2921|    388|        {
 2922|    388|            EPROSIMA_LOG_ERROR(XMLPARSER, "Invalid element found into 'durationType'. Name: " << name);
  ------------------
  |  |   45|    388|#define EPROSIMA_LOG_ERROR(cat, msg) EPROSIMA_LOG_ERROR_IMPL_(cat, msg)
  |  |  ------------------
  |  |  |  |  291|    388|    do {                                                                                                               \
  |  |  |  |  292|    388|        std::stringstream fastdds_log_ss_tmp__;                                                                        \
  |  |  |  |  293|    388|        fastdds_log_ss_tmp__ << msg;                                                                                   \
  |  |  |  |  294|    388|        eprosima::fastdds::dds::Log::QueueLog(                                                                         \
  |  |  |  |  295|    388|            fastdds_log_ss_tmp__.str(), eprosima::fastdds::dds::Log::Context{__FILE__, __LINE__, __func__, #cat},      \
  |  |  |  |  296|    388|            eprosima::fastdds::dds::Log::Kind::Error);                                                                 \
  |  |  |  |  297|    388|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (297:14): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 2923|    388|            return XMLP_ret::XML_ERROR;
 2924|    388|        }
 2925|  12.5k|    }
 2926|       |
 2927|       |    // An empty dds::Duration_t xml is forbidden
 2928|  4.68k|    if (empty)
  ------------------
  |  Branch (2928:9): [True: 2.94k, False: 1.74k]
  ------------------
 2929|  2.94k|    {
 2930|  2.94k|        EPROSIMA_LOG_ERROR(XMLPARSER, "'durationType' elements cannot be empty."
  ------------------
  |  |   45|  2.94k|#define EPROSIMA_LOG_ERROR(cat, msg) EPROSIMA_LOG_ERROR_IMPL_(cat, msg)
  |  |  ------------------
  |  |  |  |  291|  2.94k|    do {                                                                                                               \
  |  |  |  |  292|  2.94k|        std::stringstream fastdds_log_ss_tmp__;                                                                        \
  |  |  |  |  293|  2.94k|        fastdds_log_ss_tmp__ << msg;                                                                                   \
  |  |  |  |  294|  2.94k|        eprosima::fastdds::dds::Log::QueueLog(                                                                         \
  |  |  |  |  295|  2.94k|            fastdds_log_ss_tmp__.str(), eprosima::fastdds::dds::Log::Context{__FILE__, __LINE__, __func__, #cat},      \
  |  |  |  |  296|  2.94k|            eprosima::fastdds::dds::Log::Kind::Error);                                                                 \
  |  |  |  |  297|  2.94k|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (297:14): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 2931|  2.94k|                "At least second or nanoseconds should be provided");
 2932|  2.94k|        return XMLP_ret::XML_ERROR;
 2933|  2.94k|    }
 2934|       |
 2935|  1.74k|    return XMLP_ret::XML_OK;
 2936|  4.68k|}
_ZN8eprosima7fastdds9xmlparser9XMLParser17getXMLWriterTimesEPN8tinyxml210XMLElementERNS0_4rtps11WriterTimesEh:
 2942|  5.49k|{
 2943|       |    /*
 2944|       |        <xs:complexType name="writerTimesType">
 2945|       |            <xs:all minOccurs="0">
 2946|       |                <xs:element name="initial_heartbeat_delay" type="durationType" minOccurs="0"/>
 2947|       |                <xs:element name="heartbeat_period" type="durationType" minOccurs="0"/>
 2948|       |                <xs:element name="nack_response_delay" type="durationType" minOccurs="0"/>
 2949|       |                <xs:element name="nack_supression_duration" type="durationType" minOccurs="0"/>
 2950|       |            </xs:all>
 2951|       |        </xs:complexType>
 2952|       |     */
 2953|  5.49k|    tinyxml2::XMLElement* p_aux0 = nullptr;
 2954|  5.49k|    const char* name = nullptr;
 2955|  5.49k|    for (p_aux0 = elem->FirstChildElement(); p_aux0 != NULL; p_aux0 = p_aux0->NextSiblingElement())
  ------------------
  |  Branch (2955:46): [True: 3.62k, False: 1.87k]
  ------------------
 2956|  3.62k|    {
 2957|  3.62k|        name = p_aux0->Name();
 2958|  3.62k|        if (strcmp(name, INIT_HEARTB_DELAY) == 0)
  ------------------
  |  Branch (2958:13): [True: 91, False: 3.53k]
  ------------------
 2959|     91|        {
 2960|       |            // initial_heartbeat_delay
 2961|     91|            if (XMLP_ret::XML_OK != getXMLDuration(p_aux0, times.initial_heartbeat_delay, ident))
  ------------------
  |  Branch (2961:17): [True: 91, False: 0]
  ------------------
 2962|     91|            {
 2963|     91|                return XMLP_ret::XML_ERROR;
 2964|     91|            }
 2965|     91|        }
 2966|  3.53k|        else if (strcmp(name, HEARTB_PERIOD) == 0)
  ------------------
  |  Branch (2966:18): [True: 486, False: 3.05k]
  ------------------
 2967|    486|        {
 2968|       |            // heartbeat_period
 2969|    486|            if (XMLP_ret::XML_OK != getXMLDuration(p_aux0, times.heartbeat_period, ident))
  ------------------
  |  Branch (2969:17): [True: 486, False: 0]
  ------------------
 2970|    486|            {
 2971|    486|                return XMLP_ret::XML_ERROR;
 2972|    486|            }
 2973|    486|        }
 2974|  3.05k|        else if (strcmp(name, NACK_RESP_DELAY) == 0)
  ------------------
  |  Branch (2974:18): [True: 791, False: 2.26k]
  ------------------
 2975|    791|        {
 2976|       |            // nack_response_delay
 2977|    791|            if (XMLP_ret::XML_OK != getXMLDuration(p_aux0, times.nack_response_delay, ident))
  ------------------
  |  Branch (2977:17): [True: 791, False: 0]
  ------------------
 2978|    791|            {
 2979|    791|                return XMLP_ret::XML_ERROR;
 2980|    791|            }
 2981|    791|        }
 2982|  2.26k|        else if (strcmp(name, NACK_SUPRESSION) == 0)
  ------------------
  |  Branch (2982:18): [True: 270, False: 1.99k]
  ------------------
 2983|    270|        {
 2984|       |            // nack_supression_duration
 2985|    270|            if (XMLP_ret::XML_OK != getXMLDuration(p_aux0, times.nack_supression_duration, ident))
  ------------------
  |  Branch (2985:17): [True: 270, False: 0]
  ------------------
 2986|    270|            {
 2987|    270|                return XMLP_ret::XML_ERROR;
 2988|    270|            }
 2989|    270|        }
 2990|  1.99k|        else
 2991|  1.99k|        {
 2992|  1.99k|            EPROSIMA_LOG_ERROR(XMLPARSER, "Invalid element found into 'writerTimesType'. Name: " << name);
  ------------------
  |  |   45|  1.99k|#define EPROSIMA_LOG_ERROR(cat, msg) EPROSIMA_LOG_ERROR_IMPL_(cat, msg)
  |  |  ------------------
  |  |  |  |  291|  1.99k|    do {                                                                                                               \
  |  |  |  |  292|  1.99k|        std::stringstream fastdds_log_ss_tmp__;                                                                        \
  |  |  |  |  293|  1.99k|        fastdds_log_ss_tmp__ << msg;                                                                                   \
  |  |  |  |  294|  1.99k|        eprosima::fastdds::dds::Log::QueueLog(                                                                         \
  |  |  |  |  295|  1.99k|            fastdds_log_ss_tmp__.str(), eprosima::fastdds::dds::Log::Context{__FILE__, __LINE__, __func__, #cat},      \
  |  |  |  |  296|  1.99k|            eprosima::fastdds::dds::Log::Kind::Error);                                                                 \
  |  |  |  |  297|  1.99k|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (297:14): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 2993|  1.99k|            return XMLP_ret::XML_ERROR;
 2994|  1.99k|        }
 2995|  3.62k|    }
 2996|       |
 2997|  1.87k|    return XMLP_ret::XML_OK;
 2998|  5.49k|}
_ZN8eprosima7fastdds9xmlparser9XMLParser17getXMLReaderTimesEPN8tinyxml210XMLElementERNS0_4rtps11ReaderTimesEh:
 3004|  2.86k|{
 3005|       |    /*
 3006|       |        <xs:complexType name="readerTimesType">
 3007|       |            <xs:all minOccurs="0">
 3008|       |                <xs:element name="initial_acknack_delay" type="durationType" minOccurs="0"/>
 3009|       |                <xs:element name="heartbeat_response_delay" type="durationType" minOccurs="0"/>
 3010|       |            </xs:all>
 3011|       |        </xs:complexType>
 3012|       |     */
 3013|       |
 3014|  2.86k|    tinyxml2::XMLElement* p_aux0 = nullptr;
 3015|  2.86k|    const char* name = nullptr;
 3016|  2.86k|    for (p_aux0 = elem->FirstChildElement(); p_aux0 != NULL; p_aux0 = p_aux0->NextSiblingElement())
  ------------------
  |  Branch (3016:46): [True: 986, False: 1.88k]
  ------------------
 3017|    986|    {
 3018|    986|        name = p_aux0->Name();
 3019|    986|        if (strcmp(name, INIT_ACKNACK_DELAY) == 0)
  ------------------
  |  Branch (3019:13): [True: 248, False: 738]
  ------------------
 3020|    248|        {
 3021|       |            // initial_acknack_delay
 3022|    248|            if (XMLP_ret::XML_OK != getXMLDuration(p_aux0, times.initial_acknack_delay, ident))
  ------------------
  |  Branch (3022:17): [True: 248, False: 0]
  ------------------
 3023|    248|            {
 3024|    248|                return XMLP_ret::XML_ERROR;
 3025|    248|            }
 3026|    248|        }
 3027|    738|        else if (strcmp(name, HEARTB_RESP_DELAY) == 0)
  ------------------
  |  Branch (3027:18): [True: 100, False: 638]
  ------------------
 3028|    100|        {
 3029|       |            // heartbeat_response_delay
 3030|    100|            if (XMLP_ret::XML_OK != getXMLDuration(p_aux0, times.heartbeat_response_delay, ident))
  ------------------
  |  Branch (3030:17): [True: 100, False: 0]
  ------------------
 3031|    100|            {
 3032|    100|                return XMLP_ret::XML_ERROR;
 3033|    100|            }
 3034|    100|        }
 3035|    638|        else
 3036|    638|        {
 3037|    638|            EPROSIMA_LOG_ERROR(XMLPARSER, "Invalid element found into 'readerTimesType'. Name: " << name);
  ------------------
  |  |   45|    638|#define EPROSIMA_LOG_ERROR(cat, msg) EPROSIMA_LOG_ERROR_IMPL_(cat, msg)
  |  |  ------------------
  |  |  |  |  291|    638|    do {                                                                                                               \
  |  |  |  |  292|    638|        std::stringstream fastdds_log_ss_tmp__;                                                                        \
  |  |  |  |  293|    638|        fastdds_log_ss_tmp__ << msg;                                                                                   \
  |  |  |  |  294|    638|        eprosima::fastdds::dds::Log::QueueLog(                                                                         \
  |  |  |  |  295|    638|            fastdds_log_ss_tmp__.str(), eprosima::fastdds::dds::Log::Context{__FILE__, __LINE__, __func__, #cat},      \
  |  |  |  |  296|    638|            eprosima::fastdds::dds::Log::Kind::Error);                                                                 \
  |  |  |  |  297|    638|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (297:14): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 3038|    638|            return XMLP_ret::XML_ERROR;
 3039|    638|        }
 3040|    986|    }
 3041|       |
 3042|  1.88k|    return XMLP_ret::XML_OK;
 3043|  2.86k|}
_ZN8eprosima7fastdds9xmlparser9XMLParser25getXMLExternalLocatorListEPN8tinyxml210XMLElementERNSt3__13mapIhNS7_IhNS6_6vectorINS0_4rtps15LocatorWithMaskENS6_9allocatorISA_EEEENS6_4lessIhEENSB_INS6_4pairIKhSD_EEEEEENS6_7greaterIhEENSB_INSG_ISH_SK_EEEEEEh:
 3398|  2.53k|{
 3399|       |    /*
 3400|       |        <xs:complexType name="externalLocatorListType">
 3401|       |            <xs:sequence>
 3402|       |              <xs:choice>
 3403|       |                <xs:element name="udpv4" type="udpExternalLocatorType"/>
 3404|       |                <xs:element name="udpv6" type="udpExternalLocatorType"/>
 3405|       |              </xs:choice>
 3406|       |            </xs:sequence>
 3407|       |        </xs:complexType>
 3408|       |     */
 3409|       |
 3410|  2.53k|    external_locators.clear();
 3411|       |
 3412|  2.53k|    tinyxml2::XMLElement* child = nullptr;
 3413|  2.53k|    for (child = elem->FirstChildElement(); nullptr != child; child = child->NextSiblingElement())
  ------------------
  |  Branch (3413:45): [True: 0, False: 2.53k]
  ------------------
 3414|      0|    {
 3415|      0|        fastdds::rtps::LocatorWithMask locator;
 3416|      0|        const char* name = child->Name();
 3417|      0|        if (strcmp(name, UDPv4_LOCATOR) == 0)
  ------------------
  |  Branch (3417:13): [True: 0, False: 0]
  ------------------
 3418|      0|        {
 3419|      0|            if (XMLP_ret::XML_OK != getXMLLocatorUDPv4(child, locator, ident + 1))
  ------------------
  |  Branch (3419:17): [True: 0, False: 0]
  ------------------
 3420|      0|            {
 3421|      0|                external_locators.clear();
 3422|      0|                return XMLP_ret::XML_ERROR;
 3423|      0|            }
 3424|      0|        }
 3425|      0|        else if (strcmp(name, UDPv6_LOCATOR) == 0)
  ------------------
  |  Branch (3425:18): [True: 0, False: 0]
  ------------------
 3426|      0|        {
 3427|      0|            if (XMLP_ret::XML_OK != getXMLLocatorUDPv6(child, locator, ident + 1))
  ------------------
  |  Branch (3427:17): [True: 0, False: 0]
  ------------------
 3428|      0|            {
 3429|      0|                external_locators.clear();
 3430|      0|                return XMLP_ret::XML_ERROR;
 3431|      0|            }
 3432|      0|        }
 3433|      0|        else
 3434|      0|        {
 3435|      0|            EPROSIMA_LOG_ERROR(XMLPARSER, "Invalid element found inside 'externalLocatorListType'. Name: " << name);
  ------------------
  |  |   45|      0|#define EPROSIMA_LOG_ERROR(cat, msg) EPROSIMA_LOG_ERROR_IMPL_(cat, msg)
  |  |  ------------------
  |  |  |  |  291|      0|    do {                                                                                                               \
  |  |  |  |  292|      0|        std::stringstream fastdds_log_ss_tmp__;                                                                        \
  |  |  |  |  293|      0|        fastdds_log_ss_tmp__ << msg;                                                                                   \
  |  |  |  |  294|      0|        eprosima::fastdds::dds::Log::QueueLog(                                                                         \
  |  |  |  |  295|      0|            fastdds_log_ss_tmp__.str(), eprosima::fastdds::dds::Log::Context{__FILE__, __LINE__, __func__, #cat},      \
  |  |  |  |  296|      0|            eprosima::fastdds::dds::Log::Kind::Error);                                                                 \
  |  |  |  |  297|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (297:14): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 3436|      0|            external_locators.clear();
 3437|      0|            return XMLP_ret::XML_ERROR;
 3438|      0|        }
 3439|       |
 3440|      0|        if (IPLocator::isAny(locator) || 0 == locator.port)
  ------------------
  |  Branch (3440:13): [True: 0, False: 0]
  |  Branch (3440:42): [True: 0, False: 0]
  ------------------
 3441|      0|        {
 3442|      0|            EPROSIMA_LOG_ERROR(XMLPARSER, "Address and port are mandatory for 'udpExternalLocatorType'.");
  ------------------
  |  |   45|      0|#define EPROSIMA_LOG_ERROR(cat, msg) EPROSIMA_LOG_ERROR_IMPL_(cat, msg)
  |  |  ------------------
  |  |  |  |  291|      0|    do {                                                                                                               \
  |  |  |  |  292|      0|        std::stringstream fastdds_log_ss_tmp__;                                                                        \
  |  |  |  |  293|      0|        fastdds_log_ss_tmp__ << msg;                                                                                   \
  |  |  |  |  294|      0|        eprosima::fastdds::dds::Log::QueueLog(                                                                         \
  |  |  |  |  295|      0|            fastdds_log_ss_tmp__.str(), eprosima::fastdds::dds::Log::Context{__FILE__, __LINE__, __func__, #cat},      \
  |  |  |  |  296|      0|            eprosima::fastdds::dds::Log::Kind::Error);                                                                 \
  |  |  |  |  297|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (297:14): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 3443|      0|            external_locators.clear();
 3444|      0|            return XMLP_ret::XML_ERROR;
 3445|      0|        }
 3446|       |
 3447|      0|        if (IPLocator::isMulticast(locator))
  ------------------
  |  Branch (3447:13): [True: 0, False: 0]
  ------------------
 3448|      0|        {
 3449|      0|            EPROSIMA_LOG_ERROR(XMLPARSER, "Address should be unicast for 'udpExternalLocatorType'.");
  ------------------
  |  |   45|      0|#define EPROSIMA_LOG_ERROR(cat, msg) EPROSIMA_LOG_ERROR_IMPL_(cat, msg)
  |  |  ------------------
  |  |  |  |  291|      0|    do {                                                                                                               \
  |  |  |  |  292|      0|        std::stringstream fastdds_log_ss_tmp__;                                                                        \
  |  |  |  |  293|      0|        fastdds_log_ss_tmp__ << msg;                                                                                   \
  |  |  |  |  294|      0|        eprosima::fastdds::dds::Log::QueueLog(                                                                         \
  |  |  |  |  295|      0|            fastdds_log_ss_tmp__.str(), eprosima::fastdds::dds::Log::Context{__FILE__, __LINE__, __func__, #cat},      \
  |  |  |  |  296|      0|            eprosima::fastdds::dds::Log::Kind::Error);                                                                 \
  |  |  |  |  297|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (297:14): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 3450|      0|            external_locators.clear();
 3451|      0|            return XMLP_ret::XML_ERROR;
 3452|      0|        }
 3453|       |
 3454|      0|        if (XMLP_ret::XML_OK != process_external_locator_attributes(child, locator, external_locators))
  ------------------
  |  Branch (3454:13): [True: 0, False: 0]
  ------------------
 3455|      0|        {
 3456|      0|            external_locators.clear();
 3457|      0|            return XMLP_ret::XML_ERROR;
 3458|      0|        }
 3459|      0|    }
 3460|       |
 3461|  2.53k|    return XMLP_ret::XML_OK;
 3462|  2.53k|}
_ZN8eprosima7fastdds9xmlparser9XMLParser17getXMLLocatorListEPN8tinyxml210XMLElementERNS0_4rtps11LocatorListEh:
 3468|  2.03k|{
 3469|       |    /*
 3470|       |        <xs:complexType name="locatorListType">
 3471|       |            <xs:sequence>
 3472|       |                <xs:element name="locator" type="locatorType" minOccurs="0" maxOccurs="unbounded"/>
 3473|       |            </xs:sequence>
 3474|       |        </xs:complexType>
 3475|       |     */
 3476|  2.03k|    tinyxml2::XMLElement* p_aux0 = nullptr, * p_aux1 = nullptr;
 3477|  2.03k|    p_aux0 = elem->FirstChildElement(LOCATOR);
 3478|  2.03k|    if (nullptr == p_aux0)
  ------------------
  |  Branch (3478:9): [True: 2.03k, False: 0]
  ------------------
 3479|  2.03k|    {
 3480|  2.03k|        EPROSIMA_LOG_ERROR(XMLPARSER, "Node '" << elem->Value() << "' without content");
  ------------------
  |  |   45|  2.03k|#define EPROSIMA_LOG_ERROR(cat, msg) EPROSIMA_LOG_ERROR_IMPL_(cat, msg)
  |  |  ------------------
  |  |  |  |  291|  2.03k|    do {                                                                                                               \
  |  |  |  |  292|  2.03k|        std::stringstream fastdds_log_ss_tmp__;                                                                        \
  |  |  |  |  293|  2.03k|        fastdds_log_ss_tmp__ << msg;                                                                                   \
  |  |  |  |  294|  2.03k|        eprosima::fastdds::dds::Log::QueueLog(                                                                         \
  |  |  |  |  295|  2.03k|            fastdds_log_ss_tmp__.str(), eprosima::fastdds::dds::Log::Context{__FILE__, __LINE__, __func__, #cat},      \
  |  |  |  |  296|  2.03k|            eprosima::fastdds::dds::Log::Kind::Error);                                                                 \
  |  |  |  |  297|  2.03k|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (297:14): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 3481|  2.03k|        return XMLP_ret::XML_ERROR;
 3482|  2.03k|    }
 3483|       |
 3484|      0|    while (nullptr != p_aux0)
  ------------------
  |  Branch (3484:12): [True: 0, False: 0]
  ------------------
 3485|      0|    {
 3486|       |        /*
 3487|       |            <xs:complexType name="locatorType">
 3488|       |                <xs:choice>
 3489|       |                    <xs:element name="udpv4" type="udpv4LocatorType"/>
 3490|       |                    <xs:element name="udpv6" type="udpv6LocatorType"/>
 3491|       |                    <xs:element name="tcpv4" type="tcpv4LocatorType"/>
 3492|       |                    <xs:element name="tcpv6" type="tcpv6LocatorType"/>
 3493|       |                </xs:choice>
 3494|       |            </xs:complexType>
 3495|       |         */
 3496|      0|        Locator_t loc;
 3497|      0|        if (nullptr != (p_aux1 = p_aux0->FirstChildElement(UDPv4_LOCATOR)))
  ------------------
  |  Branch (3497:13): [True: 0, False: 0]
  ------------------
 3498|      0|        {
 3499|      0|            if (XMLP_ret::XML_OK != getXMLLocatorUDPv4(p_aux1, loc, ident + 1))
  ------------------
  |  Branch (3499:17): [True: 0, False: 0]
  ------------------
 3500|      0|            {
 3501|      0|                return XMLP_ret::XML_ERROR;
 3502|      0|            }
 3503|      0|        }
 3504|      0|        else if (nullptr != (p_aux1 = p_aux0->FirstChildElement(UDPv6_LOCATOR)))
  ------------------
  |  Branch (3504:18): [True: 0, False: 0]
  ------------------
 3505|      0|        {
 3506|      0|            if (XMLP_ret::XML_OK != getXMLLocatorUDPv6(p_aux1, loc, ident + 1))
  ------------------
  |  Branch (3506:17): [True: 0, False: 0]
  ------------------
 3507|      0|            {
 3508|      0|                return XMLP_ret::XML_ERROR;
 3509|      0|            }
 3510|      0|        }
 3511|      0|        else if (nullptr != (p_aux1 = p_aux0->FirstChildElement(TCPv4_LOCATOR)))
  ------------------
  |  Branch (3511:18): [True: 0, False: 0]
  ------------------
 3512|      0|        {
 3513|      0|            if (XMLP_ret::XML_OK != getXMLLocatorTCPv4(p_aux1, loc, ident + 1))
  ------------------
  |  Branch (3513:17): [True: 0, False: 0]
  ------------------
 3514|      0|            {
 3515|      0|                return XMLP_ret::XML_ERROR;
 3516|      0|            }
 3517|      0|        }
 3518|      0|        else if (nullptr != (p_aux1 = p_aux0->FirstChildElement(TCPv6_LOCATOR)))
  ------------------
  |  Branch (3518:18): [True: 0, False: 0]
  ------------------
 3519|      0|        {
 3520|      0|            if (XMLP_ret::XML_OK != getXMLLocatorTCPv6(p_aux1, loc, ident + 1))
  ------------------
  |  Branch (3520:17): [True: 0, False: 0]
  ------------------
 3521|      0|            {
 3522|      0|                return XMLP_ret::XML_ERROR;
 3523|      0|            }
 3524|      0|        }
 3525|      0|        else if (nullptr != (p_aux1 = p_aux0->FirstChildElement()))
  ------------------
  |  Branch (3525:18): [True: 0, False: 0]
  ------------------
 3526|      0|        {
 3527|      0|            EPROSIMA_LOG_ERROR(XMLPARSER, "Invalid element found into 'locatorType'. Name: " << p_aux1->Name());
  ------------------
  |  |   45|      0|#define EPROSIMA_LOG_ERROR(cat, msg) EPROSIMA_LOG_ERROR_IMPL_(cat, msg)
  |  |  ------------------
  |  |  |  |  291|      0|    do {                                                                                                               \
  |  |  |  |  292|      0|        std::stringstream fastdds_log_ss_tmp__;                                                                        \
  |  |  |  |  293|      0|        fastdds_log_ss_tmp__ << msg;                                                                                   \
  |  |  |  |  294|      0|        eprosima::fastdds::dds::Log::QueueLog(                                                                         \
  |  |  |  |  295|      0|            fastdds_log_ss_tmp__.str(), eprosima::fastdds::dds::Log::Context{__FILE__, __LINE__, __func__, #cat},      \
  |  |  |  |  296|      0|            eprosima::fastdds::dds::Log::Kind::Error);                                                                 \
  |  |  |  |  297|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (297:14): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 3528|      0|            return XMLP_ret::XML_ERROR;
 3529|      0|        }
 3530|       |
 3531|      0|        locatorList.push_back(loc);
 3532|      0|        p_aux0 = p_aux0->NextSiblingElement(LOCATOR);
 3533|      0|    }
 3534|       |
 3535|      0|    return XMLP_ret::XML_OK;
 3536|      0|}
_ZN8eprosima7fastdds9xmlparser9XMLParser25getXMLHistoryMemoryPolicyEPN8tinyxml210XMLElementERNS0_4rtps22MemoryManagementPolicyEh:
 3542|  3.05k|{
 3543|       |    /*
 3544|       |        <xs:simpleType name="historyMemoryPolicyType">
 3545|       |            <xs:restriction base="xs:string">
 3546|       |                <xs:enumeration value="PREALLOCATED"/>
 3547|       |                <xs:enumeration value="PREALLOCATED_WITH_REALLOC"/>
 3548|       |                <xs:enumeration value="DYNAMIC"/>
 3549|       |                <xs:enumeration value="DYNAMIC_REUSABLE"/>
 3550|       |            </xs:restriction>
 3551|       |        </xs:simpleType>
 3552|       |     */
 3553|  3.05k|    std::string text = get_element_text(elem);
 3554|  3.05k|    if (text.empty())
  ------------------
  |  Branch (3554:9): [True: 290, False: 2.76k]
  ------------------
 3555|    290|    {
 3556|    290|        EPROSIMA_LOG_ERROR(XMLPARSER, "Node '" << KIND << "' without content");
  ------------------
  |  |   45|    290|#define EPROSIMA_LOG_ERROR(cat, msg) EPROSIMA_LOG_ERROR_IMPL_(cat, msg)
  |  |  ------------------
  |  |  |  |  291|    290|    do {                                                                                                               \
  |  |  |  |  292|    290|        std::stringstream fastdds_log_ss_tmp__;                                                                        \
  |  |  |  |  293|    290|        fastdds_log_ss_tmp__ << msg;                                                                                   \
  |  |  |  |  294|    290|        eprosima::fastdds::dds::Log::QueueLog(                                                                         \
  |  |  |  |  295|    290|            fastdds_log_ss_tmp__.str(), eprosima::fastdds::dds::Log::Context{__FILE__, __LINE__, __func__, #cat},      \
  |  |  |  |  296|    290|            eprosima::fastdds::dds::Log::Kind::Error);                                                                 \
  |  |  |  |  297|    290|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (297:14): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 3557|    290|        return XMLP_ret::XML_ERROR;
 3558|    290|    }
 3559|       |
 3560|  2.76k|    if (!get_element_enum_value(text.c_str(), historyMemoryPolicy,
  ------------------
  |  Branch (3560:9): [True: 1.18k, False: 1.57k]
  ------------------
 3561|  2.76k|            PREALLOCATED, MemoryManagementPolicy::PREALLOCATED_MEMORY_MODE,
 3562|  2.76k|            PREALLOCATED_WITH_REALLOC, MemoryManagementPolicy::PREALLOCATED_WITH_REALLOC_MEMORY_MODE,
 3563|  2.76k|            DYNAMIC, MemoryManagementPolicy::DYNAMIC_RESERVE_MEMORY_MODE,
 3564|  2.76k|            DYNAMIC_REUSABLE, MemoryManagementPolicy::DYNAMIC_REUSABLE_MEMORY_MODE))
 3565|  1.18k|    {
 3566|  1.18k|        EPROSIMA_LOG_ERROR(XMLPARSER, "Node '" << KIND << "' bad content");
  ------------------
  |  |   45|  1.18k|#define EPROSIMA_LOG_ERROR(cat, msg) EPROSIMA_LOG_ERROR_IMPL_(cat, msg)
  |  |  ------------------
  |  |  |  |  291|  1.18k|    do {                                                                                                               \
  |  |  |  |  292|  1.18k|        std::stringstream fastdds_log_ss_tmp__;                                                                        \
  |  |  |  |  293|  1.18k|        fastdds_log_ss_tmp__ << msg;                                                                                   \
  |  |  |  |  294|  1.18k|        eprosima::fastdds::dds::Log::QueueLog(                                                                         \
  |  |  |  |  295|  1.18k|            fastdds_log_ss_tmp__.str(), eprosima::fastdds::dds::Log::Context{__FILE__, __LINE__, __func__, #cat},      \
  |  |  |  |  296|  1.18k|            eprosima::fastdds::dds::Log::Kind::Error);                                                                 \
  |  |  |  |  297|  1.18k|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (297:14): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 3567|  1.18k|        return XMLP_ret::XML_ERROR;
 3568|  1.18k|    }
 3569|       |
 3570|  1.57k|    return XMLP_ret::XML_OK;
 3571|  2.76k|}
_ZN8eprosima7fastdds9xmlparser9XMLParser22getXMLPropertiesPolicyEPN8tinyxml210XMLElementERNS0_4rtps14PropertyPolicyEh:
 3577|  2.45k|{
 3578|       |    /*
 3579|       |        <xs:complexType name="propertyPolicyType">
 3580|       |            <xs:all minOccurs="0">
 3581|       |                <xs:element name="properties" type="propertyVectorType" minOccurs="0"/>
 3582|       |                <xs:element name="binary_properties" type="binaryPropertyVectorType" minOccurs="0"/>
 3583|       |            </xs:all>
 3584|       |        </xs:complexType>
 3585|       |     */
 3586|       |
 3587|  2.45k|    tinyxml2::XMLElement* p_aux0 = nullptr, * p_aux1 = nullptr, * p_aux2 = nullptr;
 3588|  2.45k|    const char* name = nullptr;
 3589|  2.45k|    for (p_aux0 = elem->FirstChildElement(); p_aux0 != nullptr; p_aux0 = p_aux0->NextSiblingElement())
  ------------------
  |  Branch (3589:46): [True: 0, False: 2.45k]
  ------------------
 3590|      0|    {
 3591|      0|        name = p_aux0->Name();
 3592|      0|        if (strcmp(name, PROPERTIES) == 0)
  ------------------
  |  Branch (3592:13): [True: 0, False: 0]
  ------------------
 3593|      0|        {
 3594|      0|            p_aux1 = p_aux0->FirstChildElement(PROPERTY);
 3595|      0|            if (nullptr == p_aux1)
  ------------------
  |  Branch (3595:17): [True: 0, False: 0]
  ------------------
 3596|      0|            {
 3597|      0|                EPROSIMA_LOG_ERROR(XMLPARSER, "Node '" << PROPERTIES << "' without content");
  ------------------
  |  |   45|      0|#define EPROSIMA_LOG_ERROR(cat, msg) EPROSIMA_LOG_ERROR_IMPL_(cat, msg)
  |  |  ------------------
  |  |  |  |  291|      0|    do {                                                                                                               \
  |  |  |  |  292|      0|        std::stringstream fastdds_log_ss_tmp__;                                                                        \
  |  |  |  |  293|      0|        fastdds_log_ss_tmp__ << msg;                                                                                   \
  |  |  |  |  294|      0|        eprosima::fastdds::dds::Log::QueueLog(                                                                         \
  |  |  |  |  295|      0|            fastdds_log_ss_tmp__.str(), eprosima::fastdds::dds::Log::Context{__FILE__, __LINE__, __func__, #cat},      \
  |  |  |  |  296|      0|            eprosima::fastdds::dds::Log::Kind::Error);                                                                 \
  |  |  |  |  297|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (297:14): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 3598|      0|                return XMLP_ret::XML_ERROR;
 3599|      0|            }
 3600|       |
 3601|      0|            while (nullptr != p_aux1)
  ------------------
  |  Branch (3601:20): [True: 0, False: 0]
  ------------------
 3602|      0|            {
 3603|       |                /*
 3604|       |                    <xs:complexType name="propertyType">
 3605|       |                        <xs:all>
 3606|       |                            <xs:element name="name" type="stringType"/>
 3607|       |                            <xs:element name="value" type="stringType"/>
 3608|       |                            <xs:element name="propagate" type="boolType"/>
 3609|       |                        </xs:all>
 3610|       |                    </xs:complexType>
 3611|       |                 */
 3612|       |
 3613|      0|                const char* sub_name = nullptr;
 3614|      0|                Property prop;
 3615|      0|                for (p_aux2 = p_aux1->FirstChildElement(); p_aux2 != NULL; p_aux2 = p_aux2->NextSiblingElement())
  ------------------
  |  Branch (3615:60): [True: 0, False: 0]
  ------------------
 3616|      0|                {
 3617|      0|                    sub_name = p_aux2->Name();
 3618|      0|                    if (strcmp(sub_name, NAME) == 0)
  ------------------
  |  Branch (3618:25): [True: 0, False: 0]
  ------------------
 3619|      0|                    {
 3620|       |                        // name - stringType
 3621|      0|                        std::string s = "";
 3622|      0|                        if (XMLP_ret::XML_OK != getXMLString(p_aux2, &s, ident + 2))
  ------------------
  |  Branch (3622:29): [True: 0, False: 0]
  ------------------
 3623|      0|                        {
 3624|      0|                            return XMLP_ret::XML_ERROR;
 3625|      0|                        }
 3626|      0|                        prop.name(s);
 3627|      0|                    }
 3628|      0|                    else if (strcmp(sub_name, VALUE) == 0)
  ------------------
  |  Branch (3628:30): [True: 0, False: 0]
  ------------------
 3629|      0|                    {
 3630|       |                        // value - stringType
 3631|      0|                        std::string s = "";
 3632|      0|                        if (XMLP_ret::XML_OK != getXMLString(p_aux2, &s, ident + 2))
  ------------------
  |  Branch (3632:29): [True: 0, False: 0]
  ------------------
 3633|      0|                        {
 3634|      0|                            return XMLP_ret::XML_ERROR;
 3635|      0|                        }
 3636|      0|                        prop.value(s);
 3637|      0|                    }
 3638|      0|                    else if (strcmp(sub_name, PROPAGATE) == 0)
  ------------------
  |  Branch (3638:30): [True: 0, False: 0]
  ------------------
 3639|      0|                    {
 3640|       |                        // propagate - boolType
 3641|      0|                        bool b = false;
 3642|      0|                        if (XMLP_ret::XML_OK != getXMLBool(p_aux2, &b, ident + 2))
  ------------------
  |  Branch (3642:29): [True: 0, False: 0]
  ------------------
 3643|      0|                        {
 3644|      0|                            return XMLP_ret::XML_ERROR;
 3645|      0|                        }
 3646|      0|                        prop.propagate(b);
 3647|      0|                    }
 3648|      0|                }
 3649|      0|                propertiesPolicy.properties().push_back(prop);
 3650|      0|                p_aux1 = p_aux1->NextSiblingElement(PROPERTY);
 3651|      0|            }
 3652|      0|        }
 3653|      0|        else if (strcmp(name, BIN_PROPERTIES) == 0)
  ------------------
  |  Branch (3653:18): [True: 0, False: 0]
  ------------------
 3654|      0|        {
 3655|       |            // TODO: The value will be std::vector<uint8_t>
 3656|      0|            p_aux1 = p_aux0->FirstChildElement(PROPERTY);
 3657|      0|            if (nullptr == p_aux1)
  ------------------
  |  Branch (3657:17): [True: 0, False: 0]
  ------------------
 3658|      0|            {
 3659|      0|                EPROSIMA_LOG_ERROR(XMLPARSER, "Node '" << BIN_PROPERTIES << "' without content");
  ------------------
  |  |   45|      0|#define EPROSIMA_LOG_ERROR(cat, msg) EPROSIMA_LOG_ERROR_IMPL_(cat, msg)
  |  |  ------------------
  |  |  |  |  291|      0|    do {                                                                                                               \
  |  |  |  |  292|      0|        std::stringstream fastdds_log_ss_tmp__;                                                                        \
  |  |  |  |  293|      0|        fastdds_log_ss_tmp__ << msg;                                                                                   \
  |  |  |  |  294|      0|        eprosima::fastdds::dds::Log::QueueLog(                                                                         \
  |  |  |  |  295|      0|            fastdds_log_ss_tmp__.str(), eprosima::fastdds::dds::Log::Context{__FILE__, __LINE__, __func__, #cat},      \
  |  |  |  |  296|      0|            eprosima::fastdds::dds::Log::Kind::Error);                                                                 \
  |  |  |  |  297|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (297:14): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 3660|      0|                return XMLP_ret::XML_ERROR;
 3661|      0|            }
 3662|       |
 3663|      0|            while (nullptr != p_aux1)
  ------------------
  |  Branch (3663:20): [True: 0, False: 0]
  ------------------
 3664|      0|            {
 3665|       |                /*
 3666|       |                    <xs:complexType name="binaryPropertyType">
 3667|       |                        <xs:all>
 3668|       |                            <xs:element name="name" type="stringType"/>
 3669|       |                            <xs:element name="value" type="stringType"/><!-- std::vector<uint8_t> -->
 3670|       |                            <xs:element name="propagate" type="boolType"/>
 3671|       |                        </xs:all>
 3672|       |                    </xs:complexType>
 3673|       |                 */
 3674|      0|                const char* sub_name = nullptr;
 3675|      0|                BinaryProperty bin_prop;
 3676|      0|                for (p_aux2 = p_aux1->FirstChildElement(); p_aux2 != NULL; p_aux2 = p_aux2->NextSiblingElement())
  ------------------
  |  Branch (3676:60): [True: 0, False: 0]
  ------------------
 3677|      0|                {
 3678|      0|                    sub_name = p_aux2->Name();
 3679|      0|                    if (strcmp(sub_name, NAME) == 0)
  ------------------
  |  Branch (3679:25): [True: 0, False: 0]
  ------------------
 3680|      0|                    {
 3681|       |                        // name - stringType
 3682|      0|                        std::string s = "";
 3683|      0|                        if (XMLP_ret::XML_OK != getXMLString(p_aux2, &s, ident + 2))
  ------------------
  |  Branch (3683:29): [True: 0, False: 0]
  ------------------
 3684|      0|                        {
 3685|      0|                            return XMLP_ret::XML_ERROR;
 3686|      0|                        }
 3687|      0|                        bin_prop.name(s);
 3688|      0|                    }
 3689|      0|                    else if (strcmp(sub_name, VALUE) == 0)
  ------------------
  |  Branch (3689:30): [True: 0, False: 0]
  ------------------
 3690|      0|                    {
 3691|      0|                        if (XMLP_ret::XML_OK != parseXMLOctetVector(p_aux2, bin_prop.value(), true))
  ------------------
  |  Branch (3691:29): [True: 0, False: 0]
  ------------------
 3692|      0|                        {
 3693|      0|                            return XMLP_ret::XML_ERROR;
 3694|      0|                        }
 3695|      0|                    }
 3696|      0|                    else if (strcmp(sub_name, PROPAGATE) == 0)
  ------------------
  |  Branch (3696:30): [True: 0, False: 0]
  ------------------
 3697|      0|                    {
 3698|       |                        // propagate - boolType
 3699|      0|                        bool b = false;
 3700|      0|                        if (XMLP_ret::XML_OK != getXMLBool(p_aux2, &b, ident + 2))
  ------------------
  |  Branch (3700:29): [True: 0, False: 0]
  ------------------
 3701|      0|                        {
 3702|      0|                            return XMLP_ret::XML_ERROR;
 3703|      0|                        }
 3704|      0|                        bin_prop.propagate(b);
 3705|      0|                    }
 3706|      0|                }
 3707|      0|                propertiesPolicy.binary_properties().push_back(bin_prop);
 3708|      0|                p_aux1 = p_aux1->NextSiblingElement(PROPERTY);
 3709|      0|            }
 3710|      0|        }
 3711|      0|        else
 3712|      0|        {
 3713|      0|            EPROSIMA_LOG_ERROR(XMLPARSER, "Invalid element found into 'propertyPolicyType'. Name: " << name);
  ------------------
  |  |   45|      0|#define EPROSIMA_LOG_ERROR(cat, msg) EPROSIMA_LOG_ERROR_IMPL_(cat, msg)
  |  |  ------------------
  |  |  |  |  291|      0|    do {                                                                                                               \
  |  |  |  |  292|      0|        std::stringstream fastdds_log_ss_tmp__;                                                                        \
  |  |  |  |  293|      0|        fastdds_log_ss_tmp__ << msg;                                                                                   \
  |  |  |  |  294|      0|        eprosima::fastdds::dds::Log::QueueLog(                                                                         \
  |  |  |  |  295|      0|            fastdds_log_ss_tmp__.str(), eprosima::fastdds::dds::Log::Context{__FILE__, __LINE__, __func__, #cat},      \
  |  |  |  |  296|      0|            eprosima::fastdds::dds::Log::Kind::Error);                                                                 \
  |  |  |  |  297|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (297:14): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 3714|      0|            return XMLP_ret::XML_ERROR;
 3715|      0|        }
 3716|      0|    }
 3717|  2.45k|    return XMLP_ret::XML_OK;
 3718|  2.45k|}
_ZN8eprosima7fastdds9xmlparser9XMLParser17getXMLOctetVectorEPN8tinyxml210XMLElementERNSt3__16vectorIhNS6_9allocatorIhEEEEh:
 3724|  3.43k|{
 3725|  3.43k|    if (nullptr == elem)
  ------------------
  |  Branch (3725:9): [True: 0, False: 3.43k]
  ------------------
 3726|      0|    {
 3727|      0|        EPROSIMA_LOG_ERROR(XMLPARSER, "preconditions error");
  ------------------
  |  |   45|      0|#define EPROSIMA_LOG_ERROR(cat, msg) EPROSIMA_LOG_ERROR_IMPL_(cat, msg)
  |  |  ------------------
  |  |  |  |  291|      0|    do {                                                                                                               \
  |  |  |  |  292|      0|        std::stringstream fastdds_log_ss_tmp__;                                                                        \
  |  |  |  |  293|      0|        fastdds_log_ss_tmp__ << msg;                                                                                   \
  |  |  |  |  294|      0|        eprosima::fastdds::dds::Log::QueueLog(                                                                         \
  |  |  |  |  295|      0|            fastdds_log_ss_tmp__.str(), eprosima::fastdds::dds::Log::Context{__FILE__, __LINE__, __func__, #cat},      \
  |  |  |  |  296|      0|            eprosima::fastdds::dds::Log::Kind::Error);                                                                 \
  |  |  |  |  297|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (297:14): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 3728|      0|        return XMLP_ret::XML_ERROR;
 3729|      0|    }
 3730|       |
 3731|  3.43k|    tinyxml2::XMLElement* p_aux0 = nullptr;
 3732|  3.43k|    size_t num_elems = 0;
 3733|  3.43k|    XMLP_ret ret_val = XMLP_ret::XML_OK;
 3734|       |
 3735|  3.43k|    for (p_aux0 = elem->FirstChildElement(); nullptr != p_aux0; p_aux0 = p_aux0->NextSiblingElement())
  ------------------
  |  Branch (3735:46): [True: 0, False: 3.43k]
  ------------------
 3736|      0|    {
 3737|      0|        if (1 < ++num_elems)
  ------------------
  |  Branch (3737:13): [True: 0, False: 0]
  ------------------
 3738|      0|        {
 3739|      0|            EPROSIMA_LOG_ERROR(XMLPARSER, "More than one tag on " << p_aux0->GetLineNum());
  ------------------
  |  |   45|      0|#define EPROSIMA_LOG_ERROR(cat, msg) EPROSIMA_LOG_ERROR_IMPL_(cat, msg)
  |  |  ------------------
  |  |  |  |  291|      0|    do {                                                                                                               \
  |  |  |  |  292|      0|        std::stringstream fastdds_log_ss_tmp__;                                                                        \
  |  |  |  |  293|      0|        fastdds_log_ss_tmp__ << msg;                                                                                   \
  |  |  |  |  294|      0|        eprosima::fastdds::dds::Log::QueueLog(                                                                         \
  |  |  |  |  295|      0|            fastdds_log_ss_tmp__.str(), eprosima::fastdds::dds::Log::Context{__FILE__, __LINE__, __func__, #cat},      \
  |  |  |  |  296|      0|            eprosima::fastdds::dds::Log::Kind::Error);                                                                 \
  |  |  |  |  297|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (297:14): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 3740|      0|            return XMLP_ret::XML_ERROR;
 3741|      0|        }
 3742|      0|        if (0 == strcmp(p_aux0->Name(), VALUE))
  ------------------
  |  Branch (3742:13): [True: 0, False: 0]
  ------------------
 3743|      0|        {
 3744|      0|            ret_val = parseXMLOctetVector(p_aux0, octet_vector, false);
 3745|      0|        }
 3746|      0|        else
 3747|      0|        {
 3748|      0|            EPROSIMA_LOG_ERROR(XMLPARSER,
  ------------------
  |  |   45|      0|#define EPROSIMA_LOG_ERROR(cat, msg) EPROSIMA_LOG_ERROR_IMPL_(cat, msg)
  |  |  ------------------
  |  |  |  |  291|      0|    do {                                                                                                               \
  |  |  |  |  292|      0|        std::stringstream fastdds_log_ss_tmp__;                                                                        \
  |  |  |  |  293|      0|        fastdds_log_ss_tmp__ << msg;                                                                                   \
  |  |  |  |  294|      0|        eprosima::fastdds::dds::Log::QueueLog(                                                                         \
  |  |  |  |  295|      0|            fastdds_log_ss_tmp__.str(), eprosima::fastdds::dds::Log::Context{__FILE__, __LINE__, __func__, #cat},      \
  |  |  |  |  296|      0|            eprosima::fastdds::dds::Log::Kind::Error);                                                                 \
  |  |  |  |  297|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (297:14): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 3749|      0|                    "Invalid tag with name of " << p_aux0->Name() << " on line " << p_aux0->GetLineNum());
 3750|      0|            return XMLP_ret::XML_ERROR;
 3751|      0|        }
 3752|      0|    }
 3753|       |
 3754|  3.43k|    return ret_val;
 3755|  3.43k|}
_ZN8eprosima7fastdds9xmlparser9XMLParser9getXMLIntEPN8tinyxml210XMLElementEPih:
 3761|  11.2k|{
 3762|  11.2k|    if (nullptr == elem || nullptr == in)
  ------------------
  |  Branch (3762:9): [True: 0, False: 11.2k]
  |  Branch (3762:28): [True: 0, False: 11.2k]
  ------------------
 3763|      0|    {
 3764|      0|        EPROSIMA_LOG_ERROR(XMLPARSER, "nullptr when getXMLUint XML_ERROR!");
  ------------------
  |  |   45|      0|#define EPROSIMA_LOG_ERROR(cat, msg) EPROSIMA_LOG_ERROR_IMPL_(cat, msg)
  |  |  ------------------
  |  |  |  |  291|      0|    do {                                                                                                               \
  |  |  |  |  292|      0|        std::stringstream fastdds_log_ss_tmp__;                                                                        \
  |  |  |  |  293|      0|        fastdds_log_ss_tmp__ << msg;                                                                                   \
  |  |  |  |  294|      0|        eprosima::fastdds::dds::Log::QueueLog(                                                                         \
  |  |  |  |  295|      0|            fastdds_log_ss_tmp__.str(), eprosima::fastdds::dds::Log::Context{__FILE__, __LINE__, __func__, #cat},      \
  |  |  |  |  296|      0|            eprosima::fastdds::dds::Log::Kind::Error);                                                                 \
  |  |  |  |  297|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (297:14): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 3765|      0|        return XMLP_ret::XML_ERROR;
 3766|      0|    }
 3767|       |
 3768|  11.2k|    std::string text = get_element_text(elem);
 3769|  11.2k|    if (text.empty() || !tinyxml2::XMLUtil::ToInt(text.c_str(), in))
  ------------------
  |  Branch (3769:9): [True: 768, False: 10.4k]
  |  Branch (3769:25): [True: 202, False: 10.2k]
  ------------------
 3770|    970|    {
 3771|    970|        EPROSIMA_LOG_ERROR(XMLPARSER, "<" << elem->Value() << "> getXMLInt XML_ERROR!");
  ------------------
  |  |   45|    970|#define EPROSIMA_LOG_ERROR(cat, msg) EPROSIMA_LOG_ERROR_IMPL_(cat, msg)
  |  |  ------------------
  |  |  |  |  291|    970|    do {                                                                                                               \
  |  |  |  |  292|    970|        std::stringstream fastdds_log_ss_tmp__;                                                                        \
  |  |  |  |  293|    970|        fastdds_log_ss_tmp__ << msg;                                                                                   \
  |  |  |  |  294|    970|        eprosima::fastdds::dds::Log::QueueLog(                                                                         \
  |  |  |  |  295|    970|            fastdds_log_ss_tmp__.str(), eprosima::fastdds::dds::Log::Context{__FILE__, __LINE__, __func__, #cat},      \
  |  |  |  |  296|    970|            eprosima::fastdds::dds::Log::Kind::Error);                                                                 \
  |  |  |  |  297|    970|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (297:14): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 3772|    970|        return XMLP_ret::XML_ERROR;
 3773|    970|    }
 3774|  10.2k|    return XMLP_ret::XML_OK;
 3775|  11.2k|}
_ZN8eprosima7fastdds9xmlparser9XMLParser10getXMLUintEPN8tinyxml210XMLElementEPjh:
 3781|  2.04k|{
 3782|  2.04k|    if (nullptr == elem || nullptr == ui)
  ------------------
  |  Branch (3782:9): [True: 0, False: 2.04k]
  |  Branch (3782:28): [True: 0, False: 2.04k]
  ------------------
 3783|      0|    {
 3784|      0|        EPROSIMA_LOG_ERROR(XMLPARSER, "nullptr when getXMLUint XML_ERROR!");
  ------------------
  |  |   45|      0|#define EPROSIMA_LOG_ERROR(cat, msg) EPROSIMA_LOG_ERROR_IMPL_(cat, msg)
  |  |  ------------------
  |  |  |  |  291|      0|    do {                                                                                                               \
  |  |  |  |  292|      0|        std::stringstream fastdds_log_ss_tmp__;                                                                        \
  |  |  |  |  293|      0|        fastdds_log_ss_tmp__ << msg;                                                                                   \
  |  |  |  |  294|      0|        eprosima::fastdds::dds::Log::QueueLog(                                                                         \
  |  |  |  |  295|      0|            fastdds_log_ss_tmp__.str(), eprosima::fastdds::dds::Log::Context{__FILE__, __LINE__, __func__, #cat},      \
  |  |  |  |  296|      0|            eprosima::fastdds::dds::Log::Kind::Error);                                                                 \
  |  |  |  |  297|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (297:14): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 3785|      0|        return XMLP_ret::XML_ERROR;
 3786|      0|    }
 3787|       |
 3788|  2.04k|    std::string text = get_element_text(elem);
 3789|  2.04k|    if (text.empty() || !tinyxml2::XMLUtil::ToUnsigned(text.c_str(), ui))
  ------------------
  |  Branch (3789:9): [True: 958, False: 1.09k]
  |  Branch (3789:25): [True: 216, False: 874]
  ------------------
 3790|  1.17k|    {
 3791|  1.17k|        EPROSIMA_LOG_ERROR(XMLPARSER, "<" << elem->Value() << "> getXMLUint XML_ERROR!");
  ------------------
  |  |   45|  1.17k|#define EPROSIMA_LOG_ERROR(cat, msg) EPROSIMA_LOG_ERROR_IMPL_(cat, msg)
  |  |  ------------------
  |  |  |  |  291|  1.17k|    do {                                                                                                               \
  |  |  |  |  292|  1.17k|        std::stringstream fastdds_log_ss_tmp__;                                                                        \
  |  |  |  |  293|  1.17k|        fastdds_log_ss_tmp__ << msg;                                                                                   \
  |  |  |  |  294|  1.17k|        eprosima::fastdds::dds::Log::QueueLog(                                                                         \
  |  |  |  |  295|  1.17k|            fastdds_log_ss_tmp__.str(), eprosima::fastdds::dds::Log::Context{__FILE__, __LINE__, __func__, #cat},      \
  |  |  |  |  296|  1.17k|            eprosima::fastdds::dds::Log::Kind::Error);                                                                 \
  |  |  |  |  297|  1.17k|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (297:14): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 3792|  1.17k|        return XMLP_ret::XML_ERROR;
 3793|  1.17k|    }
 3794|    874|    return XMLP_ret::XML_OK;
 3795|  2.04k|}
_ZN8eprosima7fastdds9xmlparser9XMLParser10getXMLBoolEPN8tinyxml210XMLElementEPbh:
 3873|  1.87k|{
 3874|  1.87k|    if (nullptr == elem || nullptr == b)
  ------------------
  |  Branch (3874:9): [True: 0, False: 1.87k]
  |  Branch (3874:28): [True: 0, False: 1.87k]
  ------------------
 3875|      0|    {
 3876|      0|        EPROSIMA_LOG_ERROR(XMLPARSER, "nullptr when getXMLUint XML_ERROR!");
  ------------------
  |  |   45|      0|#define EPROSIMA_LOG_ERROR(cat, msg) EPROSIMA_LOG_ERROR_IMPL_(cat, msg)
  |  |  ------------------
  |  |  |  |  291|      0|    do {                                                                                                               \
  |  |  |  |  292|      0|        std::stringstream fastdds_log_ss_tmp__;                                                                        \
  |  |  |  |  293|      0|        fastdds_log_ss_tmp__ << msg;                                                                                   \
  |  |  |  |  294|      0|        eprosima::fastdds::dds::Log::QueueLog(                                                                         \
  |  |  |  |  295|      0|            fastdds_log_ss_tmp__.str(), eprosima::fastdds::dds::Log::Context{__FILE__, __LINE__, __func__, #cat},      \
  |  |  |  |  296|      0|            eprosima::fastdds::dds::Log::Kind::Error);                                                                 \
  |  |  |  |  297|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (297:14): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 3877|      0|        return XMLP_ret::XML_ERROR;
 3878|      0|    }
 3879|       |
 3880|  1.87k|    std::string text = get_element_text(elem);
 3881|  1.87k|    if (text.empty() || !tinyxml2::XMLUtil::ToBool(text.c_str(), b))
  ------------------
  |  Branch (3881:9): [True: 1.87k, False: 0]
  |  Branch (3881:25): [True: 0, False: 0]
  ------------------
 3882|  1.87k|    {
 3883|  1.87k|        EPROSIMA_LOG_ERROR(XMLPARSER, "<" << elem->Value() << "> getXMLBool XML_ERROR!");
  ------------------
  |  |   45|  1.87k|#define EPROSIMA_LOG_ERROR(cat, msg) EPROSIMA_LOG_ERROR_IMPL_(cat, msg)
  |  |  ------------------
  |  |  |  |  291|  1.87k|    do {                                                                                                               \
  |  |  |  |  292|  1.87k|        std::stringstream fastdds_log_ss_tmp__;                                                                        \
  |  |  |  |  293|  1.87k|        fastdds_log_ss_tmp__ << msg;                                                                                   \
  |  |  |  |  294|  1.87k|        eprosima::fastdds::dds::Log::QueueLog(                                                                         \
  |  |  |  |  295|  1.87k|            fastdds_log_ss_tmp__.str(), eprosima::fastdds::dds::Log::Context{__FILE__, __LINE__, __func__, #cat},      \
  |  |  |  |  296|  1.87k|            eprosima::fastdds::dds::Log::Kind::Error);                                                                 \
  |  |  |  |  297|  1.87k|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (297:14): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 3884|  1.87k|        return XMLP_ret::XML_ERROR;
 3885|  1.87k|    }
 3886|      0|    return XMLP_ret::XML_OK;
 3887|  1.87k|}
_ZN8eprosima7fastdds9xmlparser9XMLParser10getXMLEnumEPN8tinyxml210XMLElementEPNS0_4rtps17DiscoveryProtocolEh:
 3931|    132|{
 3932|       |    /*
 3933|       |        <xs:simpleType name="DiscoveryProtocol">
 3934|       |            <xs:restriction base="xs:string">
 3935|       |                <xs:enumeration value="NONE"/>
 3936|       |                <xs:enumeration value="SIMPLE"/>
 3937|       |                <xs:enumeration value="CLIENT"/>
 3938|       |                <xs:enumeration value="SERVER"/>
 3939|       |                <xs:enumeration value="BACKUP"/>
 3940|       |                <xs:enumeration value="SUPER_CLIENT"/>
 3941|       |            </xs:restriction>
 3942|       |        </xs:simpleType>
 3943|       |     */
 3944|       |
 3945|       |
 3946|    132|    if (nullptr == elem || nullptr == e)
  ------------------
  |  Branch (3946:9): [True: 0, False: 132]
  |  Branch (3946:28): [True: 0, False: 132]
  ------------------
 3947|      0|    {
 3948|      0|        EPROSIMA_LOG_ERROR(XMLPARSER, "nullptr when getXMLEnum XML_ERROR!");
  ------------------
  |  |   45|      0|#define EPROSIMA_LOG_ERROR(cat, msg) EPROSIMA_LOG_ERROR_IMPL_(cat, msg)
  |  |  ------------------
  |  |  |  |  291|      0|    do {                                                                                                               \
  |  |  |  |  292|      0|        std::stringstream fastdds_log_ss_tmp__;                                                                        \
  |  |  |  |  293|      0|        fastdds_log_ss_tmp__ << msg;                                                                                   \
  |  |  |  |  294|      0|        eprosima::fastdds::dds::Log::QueueLog(                                                                         \
  |  |  |  |  295|      0|            fastdds_log_ss_tmp__.str(), eprosima::fastdds::dds::Log::Context{__FILE__, __LINE__, __func__, #cat},      \
  |  |  |  |  296|      0|            eprosima::fastdds::dds::Log::Kind::Error);                                                                 \
  |  |  |  |  297|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (297:14): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 3949|      0|        return XMLP_ret::XML_ERROR;
 3950|      0|    }
 3951|       |
 3952|    132|    std::string text = get_element_text(elem);
 3953|    132|    if (text.empty())
  ------------------
  |  Branch (3953:9): [True: 132, False: 0]
  ------------------
 3954|    132|    {
 3955|    132|        EPROSIMA_LOG_ERROR(XMLPARSER, "<" << elem->Value() << "> getXMLEnum XML_ERROR!");
  ------------------
  |  |   45|    132|#define EPROSIMA_LOG_ERROR(cat, msg) EPROSIMA_LOG_ERROR_IMPL_(cat, msg)
  |  |  ------------------
  |  |  |  |  291|    132|    do {                                                                                                               \
  |  |  |  |  292|    132|        std::stringstream fastdds_log_ss_tmp__;                                                                        \
  |  |  |  |  293|    132|        fastdds_log_ss_tmp__ << msg;                                                                                   \
  |  |  |  |  294|    132|        eprosima::fastdds::dds::Log::QueueLog(                                                                         \
  |  |  |  |  295|    132|            fastdds_log_ss_tmp__.str(), eprosima::fastdds::dds::Log::Context{__FILE__, __LINE__, __func__, #cat},      \
  |  |  |  |  296|    132|            eprosima::fastdds::dds::Log::Kind::Error);                                                                 \
  |  |  |  |  297|    132|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (297:14): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 3956|    132|        return XMLP_ret::XML_ERROR;
 3957|    132|    }
 3958|       |
 3959|      0|    if (!get_element_enum_value(text.c_str(), *e,
  ------------------
  |  Branch (3959:9): [True: 0, False: 0]
  ------------------
 3960|      0|            NONE, DiscoveryProtocol::NONE,
 3961|      0|            SIMPLE, DiscoveryProtocol::SIMPLE,
 3962|      0|            CLIENT, DiscoveryProtocol::CLIENT,
 3963|      0|            SERVER, DiscoveryProtocol::SERVER,
 3964|      0|            BACKUP, DiscoveryProtocol::BACKUP,
 3965|      0|            SUPER_CLIENT, DiscoveryProtocol::SUPER_CLIENT))
 3966|      0|    {
 3967|      0|        EPROSIMA_LOG_ERROR(XMLPARSER, "Node '" << RTPS_PDP_TYPE << "' with bad content");
  ------------------
  |  |   45|      0|#define EPROSIMA_LOG_ERROR(cat, msg) EPROSIMA_LOG_ERROR_IMPL_(cat, msg)
  |  |  ------------------
  |  |  |  |  291|      0|    do {                                                                                                               \
  |  |  |  |  292|      0|        std::stringstream fastdds_log_ss_tmp__;                                                                        \
  |  |  |  |  293|      0|        fastdds_log_ss_tmp__ << msg;                                                                                   \
  |  |  |  |  294|      0|        eprosima::fastdds::dds::Log::QueueLog(                                                                         \
  |  |  |  |  295|      0|            fastdds_log_ss_tmp__.str(), eprosima::fastdds::dds::Log::Context{__FILE__, __LINE__, __func__, #cat},      \
  |  |  |  |  296|      0|            eprosima::fastdds::dds::Log::Kind::Error);                                                                 \
  |  |  |  |  297|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (297:14): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 3968|      0|        return XMLP_ret::XML_ERROR;
 3969|      0|    }
 3970|       |
 3971|      0|    return XMLP_ret::XML_OK;
 3972|      0|}
_ZN8eprosima7fastdds9xmlparser9XMLParser10getXMLEnumEPN8tinyxml210XMLElementEPNS0_4rtps25ParticipantFilteringFlagsEh:
 3978|    138|{
 3979|       |    /*
 3980|       |        <xs:simpleType name="ParticipantFlags">
 3981|       |            <xs:restriction base="xs:string">
 3982|       |                <xs:pattern value="((FILTER_DIFFERENT_HOST|FILTER_DIFFERENT_PROCESS|FILTER_SAME_PROCESS)(\||\s)*)*" />
 3983|       |            </xs:restriction>
 3984|       |        </xs:simpleType>
 3985|       |     */
 3986|       |
 3987|    138|    if (nullptr == elem || nullptr == e)
  ------------------
  |  Branch (3987:9): [True: 0, False: 138]
  |  Branch (3987:28): [True: 0, False: 138]
  ------------------
 3988|      0|    {
 3989|      0|        EPROSIMA_LOG_ERROR(XMLPARSER, "nullptr when getXMLEnum XML_ERROR!");
  ------------------
  |  |   45|      0|#define EPROSIMA_LOG_ERROR(cat, msg) EPROSIMA_LOG_ERROR_IMPL_(cat, msg)
  |  |  ------------------
  |  |  |  |  291|      0|    do {                                                                                                               \
  |  |  |  |  292|      0|        std::stringstream fastdds_log_ss_tmp__;                                                                        \
  |  |  |  |  293|      0|        fastdds_log_ss_tmp__ << msg;                                                                                   \
  |  |  |  |  294|      0|        eprosima::fastdds::dds::Log::QueueLog(                                                                         \
  |  |  |  |  295|      0|            fastdds_log_ss_tmp__.str(), eprosima::fastdds::dds::Log::Context{__FILE__, __LINE__, __func__, #cat},      \
  |  |  |  |  296|      0|            eprosima::fastdds::dds::Log::Kind::Error);                                                                 \
  |  |  |  |  297|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (297:14): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 3990|      0|        return XMLP_ret::XML_ERROR;
 3991|      0|    }
 3992|       |
 3993|    138|    std::string text = get_element_text(elem);
 3994|    138|    if (text.empty())
  ------------------
  |  Branch (3994:9): [True: 138, False: 0]
  ------------------
 3995|    138|    {
 3996|    138|        EPROSIMA_LOG_ERROR(XMLPARSER, "<" << elem->Value() << "> getXMLEnum XML_ERROR!");
  ------------------
  |  |   45|    138|#define EPROSIMA_LOG_ERROR(cat, msg) EPROSIMA_LOG_ERROR_IMPL_(cat, msg)
  |  |  ------------------
  |  |  |  |  291|    138|    do {                                                                                                               \
  |  |  |  |  292|    138|        std::stringstream fastdds_log_ss_tmp__;                                                                        \
  |  |  |  |  293|    138|        fastdds_log_ss_tmp__ << msg;                                                                                   \
  |  |  |  |  294|    138|        eprosima::fastdds::dds::Log::QueueLog(                                                                         \
  |  |  |  |  295|    138|            fastdds_log_ss_tmp__.str(), eprosima::fastdds::dds::Log::Context{__FILE__, __LINE__, __func__, #cat},      \
  |  |  |  |  296|    138|            eprosima::fastdds::dds::Log::Kind::Error);                                                                 \
  |  |  |  |  297|    138|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (297:14): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 3997|    138|        return XMLP_ret::XML_ERROR;
 3998|    138|    }
 3999|       |
 4000|       |    // First we check if it matches the schema pattern
 4001|      0|    std::regex schema("((FILTER_DIFFERENT_HOST|FILTER_DIFFERENT_PROCESS|FILTER_SAME_PROCESS|NO_FILTER)*(\\||\\s)*)*");
 4002|       |
 4003|      0|    if (!std::regex_match(text, schema))
  ------------------
  |  Branch (4003:9): [True: 0, False: 0]
  ------------------
 4004|      0|    {
 4005|      0|        EPROSIMA_LOG_ERROR(XMLPARSER, "provided flags doesn't match expected ParticipantFilteringFlags!");
  ------------------
  |  |   45|      0|#define EPROSIMA_LOG_ERROR(cat, msg) EPROSIMA_LOG_ERROR_IMPL_(cat, msg)
  |  |  ------------------
  |  |  |  |  291|      0|    do {                                                                                                               \
  |  |  |  |  292|      0|        std::stringstream fastdds_log_ss_tmp__;                                                                        \
  |  |  |  |  293|      0|        fastdds_log_ss_tmp__ << msg;                                                                                   \
  |  |  |  |  294|      0|        eprosima::fastdds::dds::Log::QueueLog(                                                                         \
  |  |  |  |  295|      0|            fastdds_log_ss_tmp__.str(), eprosima::fastdds::dds::Log::Context{__FILE__, __LINE__, __func__, #cat},      \
  |  |  |  |  296|      0|            eprosima::fastdds::dds::Log::Kind::Error);                                                                 \
  |  |  |  |  297|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (297:14): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 4006|      0|        return XMLP_ret::XML_ERROR;
 4007|      0|    }
 4008|       |
 4009|       |    // Lets parse the flags, we assume the flags argument has been already flushed
 4010|      0|    std::regex flags("FILTER_DIFFERENT_HOST|FILTER_DIFFERENT_PROCESS|FILTER_SAME_PROCESS");
 4011|      0|    std::cregex_iterator it(text.c_str(), text.c_str() + strlen(text.c_str()), flags);
 4012|      0|    uint32_t newflags = *e;
 4013|       |
 4014|      0|    while (it != std::cregex_iterator())
  ------------------
  |  Branch (4014:12): [True: 0, False: 0]
  ------------------
 4015|      0|    {
 4016|      0|        std::string flag(it++->str());
 4017|       |
 4018|      0|        if (flag == FILTER_DIFFERENT_HOST )
  ------------------
  |  Branch (4018:13): [True: 0, False: 0]
  ------------------
 4019|      0|        {
 4020|      0|            newflags |= ParticipantFilteringFlags::FILTER_DIFFERENT_HOST;
 4021|      0|        }
 4022|      0|        else if (flag == FILTER_DIFFERENT_PROCESS )
  ------------------
  |  Branch (4022:18): [True: 0, False: 0]
  ------------------
 4023|      0|        {
 4024|      0|            newflags |= ParticipantFilteringFlags::FILTER_DIFFERENT_PROCESS;
 4025|      0|        }
 4026|      0|        else if (flag == FILTER_SAME_PROCESS )
  ------------------
  |  Branch (4026:18): [True: 0, False: 0]
  ------------------
 4027|      0|        {
 4028|      0|            newflags |= ParticipantFilteringFlags::FILTER_SAME_PROCESS;
 4029|      0|        }
 4030|      0|    }
 4031|       |
 4032|      0|    *e = static_cast<ParticipantFilteringFlags>(newflags);
 4033|       |
 4034|      0|    return XMLP_ret::XML_OK;
 4035|      0|}
_ZN8eprosima7fastdds9xmlparser9XMLParser12getXMLStringEPN8tinyxml210XMLElementEPNSt3__112basic_stringIcNS6_11char_traitsIcEENS6_9allocatorIcEEEEh:
 4041|  4.49k|{
 4042|  4.49k|    if (nullptr == elem || nullptr == s)
  ------------------
  |  Branch (4042:9): [True: 0, False: 4.49k]
  |  Branch (4042:28): [True: 0, False: 4.49k]
  ------------------
 4043|      0|    {
 4044|      0|        EPROSIMA_LOG_ERROR(XMLPARSER, "nullptr when getXMLUint XML_ERROR!");
  ------------------
  |  |   45|      0|#define EPROSIMA_LOG_ERROR(cat, msg) EPROSIMA_LOG_ERROR_IMPL_(cat, msg)
  |  |  ------------------
  |  |  |  |  291|      0|    do {                                                                                                               \
  |  |  |  |  292|      0|        std::stringstream fastdds_log_ss_tmp__;                                                                        \
  |  |  |  |  293|      0|        fastdds_log_ss_tmp__ << msg;                                                                                   \
  |  |  |  |  294|      0|        eprosima::fastdds::dds::Log::QueueLog(                                                                         \
  |  |  |  |  295|      0|            fastdds_log_ss_tmp__.str(), eprosima::fastdds::dds::Log::Context{__FILE__, __LINE__, __func__, #cat},      \
  |  |  |  |  296|      0|            eprosima::fastdds::dds::Log::Kind::Error);                                                                 \
  |  |  |  |  297|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (297:14): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 4045|      0|        return XMLP_ret::XML_ERROR;
 4046|      0|    }
 4047|       |
 4048|  4.49k|    std::string text = get_element_text(elem);
 4049|  4.49k|    if (text.empty())
  ------------------
  |  Branch (4049:9): [True: 2.58k, False: 1.90k]
  ------------------
 4050|  2.58k|    {
 4051|  2.58k|        EPROSIMA_LOG_ERROR(XMLPARSER, "<" << elem->Value() << "> getXMLString XML_ERROR!");
  ------------------
  |  |   45|  2.58k|#define EPROSIMA_LOG_ERROR(cat, msg) EPROSIMA_LOG_ERROR_IMPL_(cat, msg)
  |  |  ------------------
  |  |  |  |  291|  2.58k|    do {                                                                                                               \
  |  |  |  |  292|  2.58k|        std::stringstream fastdds_log_ss_tmp__;                                                                        \
  |  |  |  |  293|  2.58k|        fastdds_log_ss_tmp__ << msg;                                                                                   \
  |  |  |  |  294|  2.58k|        eprosima::fastdds::dds::Log::QueueLog(                                                                         \
  |  |  |  |  295|  2.58k|            fastdds_log_ss_tmp__.str(), eprosima::fastdds::dds::Log::Context{__FILE__, __LINE__, __func__, #cat},      \
  |  |  |  |  296|  2.58k|            eprosima::fastdds::dds::Log::Kind::Error);                                                                 \
  |  |  |  |  297|  2.58k|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (297:14): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 4052|  2.58k|        return XMLP_ret::XML_ERROR;
 4053|  2.58k|    }
 4054|  1.90k|    *s = text;
 4055|  1.90k|    return XMLP_ret::XML_OK;
 4056|  4.49k|}
_ZN8eprosima7fastdds9xmlparser9XMLParser16getXMLguidPrefixEPN8tinyxml210XMLElementERNS0_4rtps12GuidPrefix_tEh:
 4062|    146|{
 4063|    146|    if (nullptr == elem )
  ------------------
  |  Branch (4063:9): [True: 0, False: 146]
  ------------------
 4064|      0|    {
 4065|      0|        EPROSIMA_LOG_ERROR(XMLPARSER, "nullptr when getXMLguidPrefix XML_ERROR!");
  ------------------
  |  |   45|      0|#define EPROSIMA_LOG_ERROR(cat, msg) EPROSIMA_LOG_ERROR_IMPL_(cat, msg)
  |  |  ------------------
  |  |  |  |  291|      0|    do {                                                                                                               \
  |  |  |  |  292|      0|        std::stringstream fastdds_log_ss_tmp__;                                                                        \
  |  |  |  |  293|      0|        fastdds_log_ss_tmp__ << msg;                                                                                   \
  |  |  |  |  294|      0|        eprosima::fastdds::dds::Log::QueueLog(                                                                         \
  |  |  |  |  295|      0|            fastdds_log_ss_tmp__.str(), eprosima::fastdds::dds::Log::Context{__FILE__, __LINE__, __func__, #cat},      \
  |  |  |  |  296|      0|            eprosima::fastdds::dds::Log::Kind::Error);                                                                 \
  |  |  |  |  297|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (297:14): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 4066|      0|        return XMLP_ret::XML_ERROR;
 4067|      0|    }
 4068|       |
 4069|    146|    std::string text = get_element_text(elem);
 4070|    146|    if (text.empty())
  ------------------
  |  Branch (4070:9): [True: 146, False: 0]
  ------------------
 4071|    146|    {
 4072|    146|        EPROSIMA_LOG_ERROR(XMLPARSER, "<" << elem->Value() << "> getXMLguidPrefix XML_ERROR!");
  ------------------
  |  |   45|    146|#define EPROSIMA_LOG_ERROR(cat, msg) EPROSIMA_LOG_ERROR_IMPL_(cat, msg)
  |  |  ------------------
  |  |  |  |  291|    146|    do {                                                                                                               \
  |  |  |  |  292|    146|        std::stringstream fastdds_log_ss_tmp__;                                                                        \
  |  |  |  |  293|    146|        fastdds_log_ss_tmp__ << msg;                                                                                   \
  |  |  |  |  294|    146|        eprosima::fastdds::dds::Log::QueueLog(                                                                         \
  |  |  |  |  295|    146|            fastdds_log_ss_tmp__.str(), eprosima::fastdds::dds::Log::Context{__FILE__, __LINE__, __func__, #cat},      \
  |  |  |  |  296|    146|            eprosima::fastdds::dds::Log::Kind::Error);                                                                 \
  |  |  |  |  297|    146|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (297:14): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 4073|    146|        return XMLP_ret::XML_ERROR;
 4074|    146|    }
 4075|       |
 4076|      0|    std::istringstream is(text);
 4077|      0|    return (is >> prefix ? XMLP_ret::XML_OK : XMLP_ret::XML_ERROR);
  ------------------
  |  Branch (4077:13): [True: 0, False: 0]
  ------------------
 4078|       |
 4079|    146|}
_ZN8eprosima7fastdds9xmlparser9XMLParser33getXMLDomainParticipantFactoryQosERN8tinyxml210XMLElementERNS0_3dds27DomainParticipantFactoryQosE:
 4084|  2.81k|{
 4085|       |    /*
 4086|       |        <xs:complexType name="domainParticipantFactoryQosPoliciesType">
 4087|       |            <xs:all>
 4088|       |                <xs:element name="entity_factory" type="entityFactoryQosPolicyType" minOccurs="0" maxOccurs="1"/>
 4089|       |                <xs:element name="shm_watchdog_thread" type="threadSettingsType" minOccurs="0" maxOccurs="1"/>
 4090|       |                <xs:element name="file_watch_threads" type="threadSettingsType" minOccurs="0" maxOccurs="1"/>
 4091|       |            </xs:all>
 4092|       |        </xs:complexType>
 4093|       |     */
 4094|       |
 4095|  2.81k|    std::set<std::string> tags_present;
 4096|       |
 4097|  5.79k|    for (tinyxml2::XMLElement* element = elem.FirstChildElement(); element != nullptr;
  ------------------
  |  Branch (4097:68): [True: 5.21k, False: 585]
  ------------------
 4098|  2.97k|            element = element->NextSiblingElement())
 4099|  5.21k|    {
 4100|  5.21k|        const char* name = element->Name();
 4101|  5.21k|        if (tags_present.count(name) != 0)
  ------------------
  |  Branch (4101:13): [True: 516, False: 4.69k]
  ------------------
 4102|    516|        {
 4103|    516|            EPROSIMA_LOG_ERROR(XMLPARSER,
  ------------------
  |  |   45|    516|#define EPROSIMA_LOG_ERROR(cat, msg) EPROSIMA_LOG_ERROR_IMPL_(cat, msg)
  |  |  ------------------
  |  |  |  |  291|    516|    do {                                                                                                               \
  |  |  |  |  292|    516|        std::stringstream fastdds_log_ss_tmp__;                                                                        \
  |  |  |  |  293|    516|        fastdds_log_ss_tmp__ << msg;                                                                                   \
  |  |  |  |  294|    516|        eprosima::fastdds::dds::Log::QueueLog(                                                                         \
  |  |  |  |  295|    516|            fastdds_log_ss_tmp__.str(), eprosima::fastdds::dds::Log::Context{__FILE__, __LINE__, __func__, #cat},      \
  |  |  |  |  296|    516|            eprosima::fastdds::dds::Log::Kind::Error);                                                                 \
  |  |  |  |  297|    516|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (297:14): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 4104|    516|                    "Duplicated element found in 'domainParticipantFactoryQosPoliciesType'. Name: " << name);
 4105|    516|            return XMLP_ret::XML_ERROR;
 4106|    516|        }
 4107|  4.69k|        tags_present.emplace(name);
 4108|       |
 4109|  4.69k|        if (strcmp(name, ENTITY_FACTORY) == 0)
  ------------------
  |  Branch (4109:13): [True: 87, False: 4.60k]
  ------------------
 4110|     87|        {
 4111|     87|            if (XMLP_ret::XML_OK != getXMLEntityFactoryQos(*element, qos.entity_factory()))
  ------------------
  |  Branch (4111:17): [True: 0, False: 87]
  ------------------
 4112|      0|            {
 4113|      0|                return XMLP_ret::XML_ERROR;
 4114|      0|            }
 4115|     87|        }
 4116|  4.60k|        else if (strcmp(name, SHM_WATCHDOG_THREAD) == 0)
  ------------------
  |  Branch (4116:18): [True: 1.18k, False: 3.42k]
  ------------------
 4117|  1.18k|        {
 4118|  1.18k|            if (XMLP_ret::XML_OK != getXMLThreadSettings(*element, qos.shm_watchdog_thread()))
  ------------------
  |  Branch (4118:17): [True: 34, False: 1.15k]
  ------------------
 4119|     34|            {
 4120|     34|                return XMLP_ret::XML_ERROR;
 4121|     34|            }
 4122|  1.18k|        }
 4123|  3.42k|        else if (strcmp(name, FILE_WATCH_THREADS) == 0)
  ------------------
  |  Branch (4123:18): [True: 1.78k, False: 1.64k]
  ------------------
 4124|  1.78k|        {
 4125|  1.78k|            if (XMLP_ret::XML_OK != getXMLThreadSettings(*element, qos.file_watch_threads()))
  ------------------
  |  Branch (4125:17): [True: 40, False: 1.74k]
  ------------------
 4126|     40|            {
 4127|     40|                return XMLP_ret::XML_ERROR;
 4128|     40|            }
 4129|  1.78k|        }
 4130|  1.64k|        else
 4131|  1.64k|        {
 4132|  1.64k|            EPROSIMA_LOG_ERROR(XMLPARSER,
  ------------------
  |  |   45|  1.64k|#define EPROSIMA_LOG_ERROR(cat, msg) EPROSIMA_LOG_ERROR_IMPL_(cat, msg)
  |  |  ------------------
  |  |  |  |  291|  1.64k|    do {                                                                                                               \
  |  |  |  |  292|  1.64k|        std::stringstream fastdds_log_ss_tmp__;                                                                        \
  |  |  |  |  293|  1.64k|        fastdds_log_ss_tmp__ << msg;                                                                                   \
  |  |  |  |  294|  1.64k|        eprosima::fastdds::dds::Log::QueueLog(                                                                         \
  |  |  |  |  295|  1.64k|            fastdds_log_ss_tmp__.str(), eprosima::fastdds::dds::Log::Context{__FILE__, __LINE__, __func__, #cat},      \
  |  |  |  |  296|  1.64k|            eprosima::fastdds::dds::Log::Kind::Error);                                                                 \
  |  |  |  |  297|  1.64k|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (297:14): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 4133|  1.64k|                    "Invalid element found into 'domainParticipantFactoryQosPoliciesType'. Name: " << name);
 4134|  1.64k|            return XMLP_ret::XML_ERROR;
 4135|  1.64k|        }
 4136|  4.69k|    }
 4137|    585|    return XMLP_ret::XML_OK;
 4138|  2.81k|}
_ZN8eprosima7fastdds9xmlparser9XMLParser25getXMLPublisherAttributesEPN8tinyxml210XMLElementERNS1_19PublisherAttributesEh:
 4144|  36.5k|{
 4145|       |    /*
 4146|       |        <xs:complexType name="publisherProfileType">
 4147|       |            <xs:all minOccurs="0">
 4148|       |                <xs:element name="topic" type="topicAttributesType" minOccurs="0"/>
 4149|       |                <xs:element name="qos" type="writerQosPoliciesType" minOccurs="0"/>
 4150|       |                <xs:element name="times" type="writerTimesType" minOccurs="0"/>
 4151|       |                <xs:element name="external_unicast_locators" type="externalLocatorListType" minOccurs="0"/>
 4152|       |                <xs:element name="ignore_non_matching_locators" type="boolType" minOccurs="0"/>
 4153|       |                <xs:element name="unicastLocatorList" type="locatorListType" minOccurs="0"/>
 4154|       |                <xs:element name="multicastLocatorList" type="locatorListType" minOccurs="0"/>
 4155|       |                <xs:element name="historyMemoryPolicy" type="historyMemoryPolicyType" minOccurs="0"/>
 4156|       |                <xs:element name="propertiesPolicy" type="propertyPolicyType" minOccurs="0"/>
 4157|       |                <xs:element name="userDefinedID" type="int16Type" minOccurs="0"/>
 4158|       |                <xs:element name="entityID" type="int16Type" minOccurs="0"/>
 4159|       |                <xs:element name="matchedSubscribersAllocation" type="containerAllocationConfigType" minOccurs="0"/>
 4160|       |            </xs:all>
 4161|       |            <xs:attribute name="profile_name" type="stringType" use="required"/>
 4162|       |        </xs:complexType>
 4163|       |     */
 4164|       |
 4165|  36.5k|    std::unordered_map<std::string, bool> tags_present;
 4166|       |
 4167|  36.5k|    tinyxml2::XMLElement* p_aux0 = nullptr;
 4168|  36.5k|    const char* name = nullptr;
 4169|  43.5k|    for (p_aux0 = elem->FirstChildElement(); p_aux0 != nullptr; p_aux0 = p_aux0->NextSiblingElement())
  ------------------
  |  Branch (4169:46): [True: 21.7k, False: 21.8k]
  ------------------
 4170|  21.7k|    {
 4171|  21.7k|        name = p_aux0->Name();
 4172|  21.7k|        if (tags_present[name])
  ------------------
  |  Branch (4172:13): [True: 585, False: 21.1k]
  ------------------
 4173|    585|        {
 4174|    585|            EPROSIMA_LOG_ERROR(XMLPARSER, "Duplicated element found in 'publisherProfileType'. Name: " << name);
  ------------------
  |  |   45|    585|#define EPROSIMA_LOG_ERROR(cat, msg) EPROSIMA_LOG_ERROR_IMPL_(cat, msg)
  |  |  ------------------
  |  |  |  |  291|    585|    do {                                                                                                               \
  |  |  |  |  292|    585|        std::stringstream fastdds_log_ss_tmp__;                                                                        \
  |  |  |  |  293|    585|        fastdds_log_ss_tmp__ << msg;                                                                                   \
  |  |  |  |  294|    585|        eprosima::fastdds::dds::Log::QueueLog(                                                                         \
  |  |  |  |  295|    585|            fastdds_log_ss_tmp__.str(), eprosima::fastdds::dds::Log::Context{__FILE__, __LINE__, __func__, #cat},      \
  |  |  |  |  296|    585|            eprosima::fastdds::dds::Log::Kind::Error);                                                                 \
  |  |  |  |  297|    585|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (297:14): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 4175|    585|            return XMLP_ret::XML_ERROR;
 4176|    585|        }
 4177|  21.1k|        tags_present[name] = true;
 4178|       |
 4179|  21.1k|        if (strcmp(name, TOPIC) == 0)
  ------------------
  |  Branch (4179:13): [True: 1.49k, False: 19.6k]
  ------------------
 4180|  1.49k|        {
 4181|       |            // topic
 4182|  1.49k|            if (XMLP_ret::XML_OK != getXMLTopicAttributes(p_aux0, publisher.topic, ident))
  ------------------
  |  Branch (4182:17): [True: 34, False: 1.46k]
  ------------------
 4183|     34|            {
 4184|     34|                return XMLP_ret::XML_ERROR;
 4185|     34|            }
 4186|  1.49k|        }
 4187|  19.6k|        else if (strcmp(name, QOS) == 0)
  ------------------
  |  Branch (4187:18): [True: 6.09k, False: 13.5k]
  ------------------
 4188|  6.09k|        {
 4189|       |            // qos
 4190|  6.09k|            if (XMLP_ret::XML_OK != getXMLWriterQosPolicies(p_aux0, publisher.qos, ident))
  ------------------
  |  Branch (4190:17): [True: 4.18k, False: 1.91k]
  ------------------
 4191|  4.18k|            {
 4192|  4.18k|                return XMLP_ret::XML_ERROR;
 4193|  4.18k|            }
 4194|  6.09k|        }
 4195|  13.5k|        else if (strcmp(name, TIMES) == 0)
  ------------------
  |  Branch (4195:18): [True: 5.49k, False: 8.03k]
  ------------------
 4196|  5.49k|        {
 4197|       |            // times
 4198|  5.49k|            if (XMLP_ret::XML_OK != getXMLWriterTimes(p_aux0, publisher.times, ident))
  ------------------
  |  Branch (4198:17): [True: 3.62k, False: 1.87k]
  ------------------
 4199|  3.62k|            {
 4200|  3.62k|                return XMLP_ret::XML_ERROR;
 4201|  3.62k|            }
 4202|  5.49k|        }
 4203|  8.03k|        else if (strcmp(name, IGN_NON_MATCHING_LOCS) == 0)
  ------------------
  |  Branch (4203:18): [True: 317, False: 7.71k]
  ------------------
 4204|    317|        {
 4205|       |            // ignore_non_matching_locators - boolType
 4206|    317|            if (XMLP_ret::XML_OK != getXMLBool(p_aux0, &publisher.ignore_non_matching_locators, ident))
  ------------------
  |  Branch (4206:17): [True: 317, False: 0]
  ------------------
 4207|    317|            {
 4208|    317|                return XMLP_ret::XML_ERROR;
 4209|    317|            }
 4210|    317|        }
 4211|  7.71k|        else if (strcmp(name, EXT_UNI_LOC_LIST) == 0)
  ------------------
  |  Branch (4211:18): [True: 691, False: 7.02k]
  ------------------
 4212|    691|        {
 4213|       |            // external_unicast_locators - externalLocatorListType
 4214|    691|            if (XMLP_ret::XML_OK != getXMLExternalLocatorList(p_aux0, publisher.external_unicast_locators, ident))
  ------------------
  |  Branch (4214:17): [True: 0, False: 691]
  ------------------
 4215|      0|            {
 4216|      0|                return XMLP_ret::XML_ERROR;
 4217|      0|            }
 4218|    691|        }
 4219|  7.02k|        else if (strcmp(name, UNI_LOC_LIST) == 0)
  ------------------
  |  Branch (4219:18): [True: 357, False: 6.66k]
  ------------------
 4220|    357|        {
 4221|       |            // unicastLocatorList
 4222|    357|            if (XMLP_ret::XML_OK != getXMLLocatorList(p_aux0, publisher.unicastLocatorList, ident))
  ------------------
  |  Branch (4222:17): [True: 357, False: 0]
  ------------------
 4223|    357|            {
 4224|    357|                return XMLP_ret::XML_ERROR;
 4225|    357|            }
 4226|    357|        }
 4227|  6.66k|        else if (strcmp(name, MULTI_LOC_LIST) == 0)
  ------------------
  |  Branch (4227:18): [True: 287, False: 6.38k]
  ------------------
 4228|    287|        {
 4229|       |            // multicastLocatorList
 4230|    287|            if (XMLP_ret::XML_OK != getXMLLocatorList(p_aux0, publisher.multicastLocatorList, ident))
  ------------------
  |  Branch (4230:17): [True: 287, False: 0]
  ------------------
 4231|    287|            {
 4232|    287|                return XMLP_ret::XML_ERROR;
 4233|    287|            }
 4234|    287|        }
 4235|  6.38k|        else if (strcmp(name, REM_LOC_LIST) == 0)
  ------------------
  |  Branch (4235:18): [True: 107, False: 6.27k]
  ------------------
 4236|    107|        {
 4237|       |            // remoteLocatorList
 4238|    107|            if (XMLP_ret::XML_OK != getXMLLocatorList(p_aux0, publisher.remoteLocatorList, ident))
  ------------------
  |  Branch (4238:17): [True: 107, False: 0]
  ------------------
 4239|    107|            {
 4240|    107|                return XMLP_ret::XML_ERROR;
 4241|    107|            }
 4242|    107|        }
 4243|  6.27k|        else if (strcmp(name, HIST_MEM_POLICY) == 0)
  ------------------
  |  Branch (4243:18): [True: 1.70k, False: 4.57k]
  ------------------
 4244|  1.70k|        {
 4245|       |            // historyMemoryPolicy
 4246|  1.70k|            if (XMLP_ret::XML_OK != getXMLHistoryMemoryPolicy(p_aux0, publisher.historyMemoryPolicy, ident))
  ------------------
  |  Branch (4246:17): [True: 1.18k, False: 520]
  ------------------
 4247|  1.18k|            {
 4248|  1.18k|                return XMLP_ret::XML_ERROR;
 4249|  1.18k|            }
 4250|  1.70k|        }
 4251|  4.57k|        else if (strcmp(name, PROPERTIES_POLICY) == 0)
  ------------------
  |  Branch (4251:18): [True: 77, False: 4.49k]
  ------------------
 4252|     77|        {
 4253|       |            // propertiesPolicy
 4254|     77|            if (XMLP_ret::XML_OK != getXMLPropertiesPolicy(p_aux0, publisher.properties, ident))
  ------------------
  |  Branch (4254:17): [True: 0, False: 77]
  ------------------
 4255|      0|            {
 4256|      0|                return XMLP_ret::XML_ERROR;
 4257|      0|            }
 4258|     77|        }
 4259|  4.49k|        else if (strcmp(name, USER_DEF_ID) == 0)
  ------------------
  |  Branch (4259:18): [True: 196, False: 4.29k]
  ------------------
 4260|    196|        {
 4261|       |            // userDefinedID - int16type
 4262|    196|            int i = 0;
 4263|    196|            if (XMLP_ret::XML_OK != getXMLInt(p_aux0, &i, ident) || i > 255)
  ------------------
  |  Branch (4263:17): [True: 196, False: 0]
  |  Branch (4263:69): [True: 0, False: 0]
  ------------------
 4264|    196|            {
 4265|    196|                return XMLP_ret::XML_ERROR;
 4266|    196|            }
 4267|      0|            publisher.setUserDefinedID(static_cast<uint8_t>(i));
 4268|      0|        }
 4269|  4.29k|        else if (strcmp(name, ENTITY_ID) == 0)
  ------------------
  |  Branch (4269:18): [True: 113, False: 4.18k]
  ------------------
 4270|    113|        {
 4271|       |            // entityID - int16Type
 4272|    113|            int i = 0;
 4273|    113|            if (XMLP_ret::XML_OK != getXMLInt(p_aux0, &i, ident) || i > 255)
  ------------------
  |  Branch (4273:17): [True: 113, False: 0]
  |  Branch (4273:69): [True: 0, False: 0]
  ------------------
 4274|    113|            {
 4275|    113|                return XMLP_ret::XML_ERROR;
 4276|    113|            }
 4277|      0|            publisher.setEntityID(static_cast<uint8_t>(i));
 4278|      0|        }
 4279|  4.18k|        else if (strcmp(name, MATCHED_SUBSCRIBERS_ALLOCATION) == 0)
  ------------------
  |  Branch (4279:18): [True: 462, False: 3.72k]
  ------------------
 4280|    462|        {
 4281|       |            // matchedSubscribersAllocation - containerAllocationConfigType
 4282|    462|            if (XMLP_ret::XML_OK !=
  ------------------
  |  Branch (4282:17): [True: 0, False: 462]
  ------------------
 4283|    462|                    getXMLContainerAllocationConfig(p_aux0, publisher.matched_subscriber_allocation, ident))
 4284|      0|            {
 4285|      0|                return XMLP_ret::XML_ERROR;
 4286|      0|            }
 4287|    462|        }
 4288|  3.72k|        else
 4289|  3.72k|        {
 4290|  3.72k|            EPROSIMA_LOG_ERROR(XMLPARSER, "Invalid element found into 'publisherProfileType'. Name: " << name);
  ------------------
  |  |   45|  3.72k|#define EPROSIMA_LOG_ERROR(cat, msg) EPROSIMA_LOG_ERROR_IMPL_(cat, msg)
  |  |  ------------------
  |  |  |  |  291|  3.72k|    do {                                                                                                               \
  |  |  |  |  292|  3.72k|        std::stringstream fastdds_log_ss_tmp__;                                                                        \
  |  |  |  |  293|  3.72k|        fastdds_log_ss_tmp__ << msg;                                                                                   \
  |  |  |  |  294|  3.72k|        eprosima::fastdds::dds::Log::QueueLog(                                                                         \
  |  |  |  |  295|  3.72k|            fastdds_log_ss_tmp__.str(), eprosima::fastdds::dds::Log::Context{__FILE__, __LINE__, __func__, #cat},      \
  |  |  |  |  296|  3.72k|            eprosima::fastdds::dds::Log::Kind::Error);                                                                 \
  |  |  |  |  297|  3.72k|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (297:14): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 4291|  3.72k|            return XMLP_ret::XML_ERROR;
 4292|  3.72k|        }
 4293|  21.1k|    }
 4294|  21.8k|    return XMLP_ret::XML_OK;
 4295|  36.5k|}
_ZN8eprosima7fastdds9xmlparser9XMLParser26getXMLSubscriberAttributesEPN8tinyxml210XMLElementERNS1_20SubscriberAttributesEh:
 4301|  83.3k|{
 4302|       |    /*
 4303|       |        <xs:complexType name="subscriberProfileType">
 4304|       |            <xs:all minOccurs="0">
 4305|       |                <xs:element name="topic" type="topicAttributesType" minOccurs="0"/>
 4306|       |                <xs:element name="qos" type="readerQosPoliciesType" minOccurs="0"/>
 4307|       |                <xs:element name="times" type="readerTimesType" minOccurs="0"/>
 4308|       |                <xs:element name="external_unicast_locators" type="externalLocatorListType" minOccurs="0"/>
 4309|       |                <xs:element name="ignore_non_matching_locators" type="boolType" minOccurs="0"/>
 4310|       |                <xs:element name="unicastLocatorList" type="locatorListType" minOccurs="0"/>
 4311|       |                <xs:element name="multicastLocatorList" type="locatorListType" minOccurs="0"/>
 4312|       |                <xs:element name="expects_inline_qos" type="boolType" minOccurs="0"/>
 4313|       |                <xs:element name="historyMemoryPolicy" type="historyMemoryPolicyType" minOccurs="0"/>
 4314|       |                <xs:element name="propertiesPolicy" type="propertyPolicyType" minOccurs="0"/>
 4315|       |                <xs:element name="userDefinedID" type="int16Type" minOccurs="0"/>
 4316|       |                <xs:element name="entityID" type="int16Type" minOccurs="0"/>
 4317|       |                <xs:element name="matchedPublishersAllocation" type="containerAllocationConfigType" minOccurs="0"/>
 4318|       |            </xs:all>
 4319|       |            <xs:attribute name="profile_name" type="stringType" use="required"/>
 4320|       |        </xs:complexType>
 4321|       |     */
 4322|       |
 4323|  83.3k|    std::unordered_map<std::string, bool> tags_present;
 4324|       |
 4325|  83.3k|    tinyxml2::XMLElement* p_aux0 = nullptr;
 4326|  83.3k|    const char* name = nullptr;
 4327|  94.0k|    for (p_aux0 = elem->FirstChildElement(); p_aux0 != nullptr; p_aux0 = p_aux0->NextSiblingElement())
  ------------------
  |  Branch (4327:46): [True: 24.2k, False: 69.8k]
  ------------------
 4328|  24.2k|    {
 4329|  24.2k|        name = p_aux0->Name();
 4330|  24.2k|        if (tags_present[name])
  ------------------
  |  Branch (4330:13): [True: 627, False: 23.5k]
  ------------------
 4331|    627|        {
 4332|    627|            EPROSIMA_LOG_ERROR(XMLPARSER, "Duplicated element found in 'subscriberProfileType'. Name: " << name);
  ------------------
  |  |   45|    627|#define EPROSIMA_LOG_ERROR(cat, msg) EPROSIMA_LOG_ERROR_IMPL_(cat, msg)
  |  |  ------------------
  |  |  |  |  291|    627|    do {                                                                                                               \
  |  |  |  |  292|    627|        std::stringstream fastdds_log_ss_tmp__;                                                                        \
  |  |  |  |  293|    627|        fastdds_log_ss_tmp__ << msg;                                                                                   \
  |  |  |  |  294|    627|        eprosima::fastdds::dds::Log::QueueLog(                                                                         \
  |  |  |  |  295|    627|            fastdds_log_ss_tmp__.str(), eprosima::fastdds::dds::Log::Context{__FILE__, __LINE__, __func__, #cat},      \
  |  |  |  |  296|    627|            eprosima::fastdds::dds::Log::Kind::Error);                                                                 \
  |  |  |  |  297|    627|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (297:14): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 4333|    627|            return XMLP_ret::XML_ERROR;
 4334|    627|        }
 4335|  23.5k|        tags_present[name] = true;
 4336|       |
 4337|  23.5k|        if (strcmp(name, TOPIC) == 0)
  ------------------
  |  Branch (4337:13): [True: 2.44k, False: 21.1k]
  ------------------
 4338|  2.44k|        {
 4339|       |            // topic
 4340|  2.44k|            if (XMLP_ret::XML_OK != getXMLTopicAttributes(p_aux0, subscriber.topic, ident))
  ------------------
  |  Branch (4340:17): [True: 66, False: 2.37k]
  ------------------
 4341|     66|            {
 4342|     66|                return XMLP_ret::XML_ERROR;
 4343|     66|            }
 4344|  2.44k|        }
 4345|  21.1k|        else if (strcmp(name, QOS) == 0)
  ------------------
  |  Branch (4345:18): [True: 8.44k, False: 12.6k]
  ------------------
 4346|  8.44k|        {
 4347|       |            // qos
 4348|  8.44k|            if (XMLP_ret::XML_OK != getXMLReaderQosPolicies(p_aux0, subscriber.qos, ident))
  ------------------
  |  Branch (4348:17): [True: 5.61k, False: 2.82k]
  ------------------
 4349|  5.61k|            {
 4350|  5.61k|                return XMLP_ret::XML_ERROR;
 4351|  5.61k|            }
 4352|  8.44k|        }
 4353|  12.6k|        else if (strcmp(name, TIMES) == 0)
  ------------------
  |  Branch (4353:18): [True: 2.86k, False: 9.82k]
  ------------------
 4354|  2.86k|        {
 4355|       |            // times
 4356|  2.86k|            if (XMLP_ret::XML_OK != getXMLReaderTimes(p_aux0, subscriber.times, ident))
  ------------------
  |  Branch (4356:17): [True: 986, False: 1.88k]
  ------------------
 4357|    986|            {
 4358|    986|                return XMLP_ret::XML_ERROR;
 4359|    986|            }
 4360|  2.86k|        }
 4361|  9.82k|        else if (strcmp(name, IGN_NON_MATCHING_LOCS) == 0)
  ------------------
  |  Branch (4361:18): [True: 364, False: 9.46k]
  ------------------
 4362|    364|        {
 4363|       |            // ignore_non_matching_locators - boolType
 4364|    364|            if (XMLP_ret::XML_OK != getXMLBool(p_aux0, &subscriber.ignore_non_matching_locators, ident))
  ------------------
  |  Branch (4364:17): [True: 364, False: 0]
  ------------------
 4365|    364|            {
 4366|    364|                return XMLP_ret::XML_ERROR;
 4367|    364|            }
 4368|    364|        }
 4369|  9.46k|        else if (strcmp(name, EXT_UNI_LOC_LIST) == 0)
  ------------------
  |  Branch (4369:18): [True: 524, False: 8.94k]
  ------------------
 4370|    524|        {
 4371|       |            // external_unicast_locators - externalLocatorListType
 4372|    524|            if (XMLP_ret::XML_OK != getXMLExternalLocatorList(p_aux0, subscriber.external_unicast_locators, ident))
  ------------------
  |  Branch (4372:17): [True: 0, False: 524]
  ------------------
 4373|      0|            {
 4374|      0|                return XMLP_ret::XML_ERROR;
 4375|      0|            }
 4376|    524|        }
 4377|  8.94k|        else if (strcmp(name, UNI_LOC_LIST) == 0)
  ------------------
  |  Branch (4377:18): [True: 221, False: 8.71k]
  ------------------
 4378|    221|        {
 4379|       |            // unicastLocatorList
 4380|    221|            if (XMLP_ret::XML_OK != getXMLLocatorList(p_aux0, subscriber.unicastLocatorList, ident))
  ------------------
  |  Branch (4380:17): [True: 221, False: 0]
  ------------------
 4381|    221|            {
 4382|    221|                return XMLP_ret::XML_ERROR;
 4383|    221|            }
 4384|    221|        }
 4385|  8.71k|        else if (strcmp(name, MULTI_LOC_LIST) == 0)
  ------------------
  |  Branch (4385:18): [True: 93, False: 8.62k]
  ------------------
 4386|     93|        {
 4387|       |            // multicastLocatorList
 4388|     93|            if (XMLP_ret::XML_OK != getXMLLocatorList(p_aux0, subscriber.multicastLocatorList, ident))
  ------------------
  |  Branch (4388:17): [True: 93, False: 0]
  ------------------
 4389|     93|            {
 4390|     93|                return XMLP_ret::XML_ERROR;
 4391|     93|            }
 4392|     93|        }
 4393|  8.62k|        else if (strcmp(name, REM_LOC_LIST) == 0)
  ------------------
  |  Branch (4393:18): [True: 94, False: 8.53k]
  ------------------
 4394|     94|        {
 4395|       |            // remote LocatorList
 4396|     94|            if (XMLP_ret::XML_OK != getXMLLocatorList(p_aux0, subscriber.remoteLocatorList, ident))
  ------------------
  |  Branch (4396:17): [True: 94, False: 0]
  ------------------
 4397|     94|            {
 4398|     94|                return XMLP_ret::XML_ERROR;
 4399|     94|            }
 4400|     94|        }
 4401|  8.53k|        else if (strcmp(name, EXP_INLINE_QOS) == 0)
  ------------------
  |  Branch (4401:18): [True: 218, False: 8.31k]
  ------------------
 4402|    218|        {
 4403|       |            // expects_inline_qos - boolType
 4404|    218|            if (XMLP_ret::XML_OK != getXMLBool(p_aux0, &subscriber.expects_inline_qos, ident))
  ------------------
  |  Branch (4404:17): [True: 218, False: 0]
  ------------------
 4405|    218|            {
 4406|    218|                return XMLP_ret::XML_ERROR;
 4407|    218|            }
 4408|    218|        }
 4409|  8.31k|        else if (strcmp(name, HIST_MEM_POLICY) == 0)
  ------------------
  |  Branch (4409:18): [True: 1.21k, False: 7.09k]
  ------------------
 4410|  1.21k|        {
 4411|       |            // historyMemoryPolicy
 4412|  1.21k|            if (XMLP_ret::XML_OK != getXMLHistoryMemoryPolicy(
  ------------------
  |  Branch (4412:17): [True: 159, False: 1.05k]
  ------------------
 4413|  1.21k|                        p_aux0,
 4414|  1.21k|                        subscriber.historyMemoryPolicy,
 4415|  1.21k|                        ident))
 4416|    159|            {
 4417|    159|                return XMLP_ret::XML_ERROR;
 4418|    159|            }
 4419|  1.21k|        }
 4420|  7.09k|        else if (strcmp(name, PROPERTIES_POLICY) == 0)
  ------------------
  |  Branch (4420:18): [True: 1.78k, False: 5.31k]
  ------------------
 4421|  1.78k|        {
 4422|       |            // propertiesPolicy
 4423|  1.78k|            if (XMLP_ret::XML_OK != getXMLPropertiesPolicy(p_aux0, subscriber.properties, ident))
  ------------------
  |  Branch (4423:17): [True: 0, False: 1.78k]
  ------------------
 4424|      0|            {
 4425|      0|                return XMLP_ret::XML_ERROR;
 4426|      0|            }
 4427|  1.78k|        }
 4428|  5.31k|        else if (strcmp(name, USER_DEF_ID) == 0)
  ------------------
  |  Branch (4428:18): [True: 158, False: 5.15k]
  ------------------
 4429|    158|        {
 4430|       |            // userDefinedID - int16Type
 4431|    158|            int i = 0;
 4432|    158|            if (XMLP_ret::XML_OK != getXMLInt(p_aux0, &i, ident) || i > 255)
  ------------------
  |  Branch (4432:17): [True: 158, False: 0]
  |  Branch (4432:69): [True: 0, False: 0]
  ------------------
 4433|    158|            {
 4434|    158|                return XMLP_ret::XML_ERROR;
 4435|    158|            }
 4436|      0|            subscriber.setUserDefinedID(static_cast<uint8_t>(i));
 4437|      0|        }
 4438|  5.15k|        else if (strcmp(name, ENTITY_ID) == 0)
  ------------------
  |  Branch (4438:18): [True: 280, False: 4.87k]
  ------------------
 4439|    280|        {
 4440|       |            // entityID - int16Type
 4441|    280|            int i = 0;
 4442|    280|            if (XMLP_ret::XML_OK != getXMLInt(p_aux0, &i, ident) || i > 255)
  ------------------
  |  Branch (4442:17): [True: 280, False: 0]
  |  Branch (4442:69): [True: 0, False: 0]
  ------------------
 4443|    280|            {
 4444|    280|                return XMLP_ret::XML_ERROR;
 4445|    280|            }
 4446|      0|            subscriber.setEntityID(static_cast<uint8_t>(i));
 4447|      0|        }
 4448|  4.87k|        else if (strcmp(name, MATCHED_PUBLISHERS_ALLOCATION) == 0)
  ------------------
  |  Branch (4448:18): [True: 229, False: 4.64k]
  ------------------
 4449|    229|        {
 4450|       |            // matchedPublishersAllocation - containerAllocationConfigType
 4451|    229|            if (XMLP_ret::XML_OK != getXMLContainerAllocationConfig(
  ------------------
  |  Branch (4451:17): [True: 0, False: 229]
  ------------------
 4452|    229|                        p_aux0,
 4453|    229|                        subscriber.matched_publisher_allocation,
 4454|    229|                        ident))
 4455|      0|            {
 4456|      0|                return XMLP_ret::XML_ERROR;
 4457|      0|            }
 4458|    229|        }
 4459|  4.64k|        else
 4460|  4.64k|        {
 4461|  4.64k|            EPROSIMA_LOG_ERROR(XMLPARSER, "Invalid element found into 'subscriberProfileType'. Name: " << name);
  ------------------
  |  |   45|  4.64k|#define EPROSIMA_LOG_ERROR(cat, msg) EPROSIMA_LOG_ERROR_IMPL_(cat, msg)
  |  |  ------------------
  |  |  |  |  291|  4.64k|    do {                                                                                                               \
  |  |  |  |  292|  4.64k|        std::stringstream fastdds_log_ss_tmp__;                                                                        \
  |  |  |  |  293|  4.64k|        fastdds_log_ss_tmp__ << msg;                                                                                   \
  |  |  |  |  294|  4.64k|        eprosima::fastdds::dds::Log::QueueLog(                                                                         \
  |  |  |  |  295|  4.64k|            fastdds_log_ss_tmp__.str(), eprosima::fastdds::dds::Log::Context{__FILE__, __LINE__, __func__, #cat},      \
  |  |  |  |  296|  4.64k|            eprosima::fastdds::dds::Log::Kind::Error);                                                                 \
  |  |  |  |  297|  4.64k|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (297:14): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 4462|  4.64k|            return XMLP_ret::XML_ERROR;
 4463|  4.64k|        }
 4464|  23.5k|    }
 4465|       |
 4466|  69.8k|    return XMLP_ret::XML_OK;
 4467|  83.3k|}
_ZN8eprosima7fastdds9xmlparser9XMLParser20getXMLThreadSettingsERN8tinyxml210XMLElementERNS0_4rtps14ThreadSettingsE:
 4472|  7.15k|{
 4473|       |    /*
 4474|       |        <xs:complexType name="threadSettingsType">
 4475|       |            <xs:all>
 4476|       |                <xs:element name="scheduling_policy" type="int32" minOccurs="0" maxOccurs="1"/>
 4477|       |                <xs:element name="priority" type="int32" minOccurs="0" maxOccurs="1"/>
 4478|       |                <xs:element name="affinity" type="uint32" minOccurs="0" maxOccurs="1"/>
 4479|       |                <xs:element name="stack_size" type="int32" minOccurs="0" maxOccurs="1"/>
 4480|       |            </xs:all>
 4481|       |        </xs:complexType>
 4482|       |     */
 4483|  7.15k|    uint32_t port = 0;
 4484|  7.15k|    return getXMLThreadSettingsWithPort(elem, thread_setting,
  ------------------
  |  Branch (4484:12): [True: 4.80k, False: 2.34k]
  ------------------
 4485|  7.15k|                   port) != XMLP_ret::XML_ERROR ? XMLP_ret::XML_OK : XMLP_ret::XML_ERROR;
 4486|  7.15k|}
_ZN8eprosima7fastdds9xmlparser9XMLParser28getXMLThreadSettingsWithPortERN8tinyxml210XMLElementERNS0_4rtps14ThreadSettingsERj:
 4492|  7.15k|{
 4493|       |    /*
 4494|       |        <xs:complexType name="threadSettingsWithPortType">
 4495|       |            <xs:complexContent>
 4496|       |                <xs:extension base="threadSettingsType">
 4497|       |                    <xs:attribute name="port" type="uint32" use="optional"/>
 4498|       |                </xs:extension>
 4499|       |            </xs:complexContent>
 4500|       |        </xs:complexType>
 4501|       |     */
 4502|       |
 4503|       |    /*
 4504|       |     * The are 4 allowed elements, all their min occurrences are 0, and their max are 1.
 4505|       |     * In case port is not present, return NOK instead of ERROR
 4506|       |     */
 4507|  7.15k|    XMLP_ret ret = XMLP_ret::XML_OK;
 4508|  7.15k|    bool port_found = false;
 4509|  8.42k|    for (const tinyxml2::XMLAttribute* attrib = elem.FirstAttribute(); attrib != nullptr; attrib = attrib->Next())
  ------------------
  |  Branch (4509:72): [True: 3.61k, False: 4.80k]
  ------------------
 4510|  3.61k|    {
 4511|  3.61k|        if (strcmp(attrib->Name(), PORT) == 0)
  ------------------
  |  Branch (4511:13): [True: 2.54k, False: 1.06k]
  ------------------
 4512|  2.54k|        {
 4513|  2.54k|            try
 4514|  2.54k|            {
 4515|  2.54k|                std::string temp = attrib->Value();
 4516|  2.54k|                temp.erase(std::remove_if(temp.begin(), temp.end(), [](unsigned char c)
 4517|  2.54k|                        {
 4518|  2.54k|                            return std::isspace(c);
 4519|  2.54k|                        }), temp.end());
 4520|  2.54k|                if (attrib->Value()[0] == '-')
  ------------------
  |  Branch (4520:21): [True: 373, False: 2.17k]
  ------------------
 4521|    373|                {
 4522|    373|                    throw std::invalid_argument("Negative value detected");
 4523|    373|                }
 4524|  2.17k|                port = static_cast<uint32_t>(std::stoul(attrib->Value()));
 4525|  2.17k|                port_found = true;
 4526|  2.17k|            }
 4527|  2.54k|            catch (std::invalid_argument& except)
 4528|  2.54k|            {
 4529|    635|                EPROSIMA_LOG_ERROR(XMLPARSER,
  ------------------
  |  |   45|    635|#define EPROSIMA_LOG_ERROR(cat, msg) EPROSIMA_LOG_ERROR_IMPL_(cat, msg)
  |  |  ------------------
  |  |  |  |  291|    635|    do {                                                                                                               \
  |  |  |  |  292|    635|        std::stringstream fastdds_log_ss_tmp__;                                                                        \
  |  |  |  |  293|    635|        fastdds_log_ss_tmp__ << msg;                                                                                   \
  |  |  |  |  294|    635|        eprosima::fastdds::dds::Log::QueueLog(                                                                         \
  |  |  |  |  295|    635|            fastdds_log_ss_tmp__.str(), eprosima::fastdds::dds::Log::Context{__FILE__, __LINE__, __func__, #cat},      \
  |  |  |  |  296|    635|            eprosima::fastdds::dds::Log::Kind::Error);                                                                 \
  |  |  |  |  297|    635|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (297:14): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 4530|    635|                        "Found wrong value " << attrib->Value() << " for port attribute. " <<
 4531|    635|                        except.what());
 4532|    635|                ret = XMLP_ret::XML_ERROR;
 4533|    635|                break;
 4534|    635|            }
 4535|  2.54k|            catch (const std::out_of_range& except)
 4536|  2.54k|            {
 4537|    642|                EPROSIMA_LOG_ERROR(XMLPARSER,
  ------------------
  |  |   45|    642|#define EPROSIMA_LOG_ERROR(cat, msg) EPROSIMA_LOG_ERROR_IMPL_(cat, msg)
  |  |  ------------------
  |  |  |  |  291|    642|    do {                                                                                                               \
  |  |  |  |  292|    642|        std::stringstream fastdds_log_ss_tmp__;                                                                        \
  |  |  |  |  293|    642|        fastdds_log_ss_tmp__ << msg;                                                                                   \
  |  |  |  |  294|    642|        eprosima::fastdds::dds::Log::QueueLog(                                                                         \
  |  |  |  |  295|    642|            fastdds_log_ss_tmp__.str(), eprosima::fastdds::dds::Log::Context{__FILE__, __LINE__, __func__, #cat},      \
  |  |  |  |  296|    642|            eprosima::fastdds::dds::Log::Kind::Error);                                                                 \
  |  |  |  |  297|    642|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (297:14): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 4538|    642|                        "Value of the port attribute " << attrib->Value() << " out of range. " <<
 4539|    642|                        except.what());
 4540|    642|                ret = XMLP_ret::XML_ERROR;
 4541|    642|                break;
 4542|    642|            }
 4543|  2.54k|        }
 4544|  1.06k|        else
 4545|  1.06k|        {
 4546|  1.06k|            EPROSIMA_LOG_ERROR(XMLPARSER, "Found wrong attribute " << attrib->Name() << " in 'thread_settings");
  ------------------
  |  |   45|  1.06k|#define EPROSIMA_LOG_ERROR(cat, msg) EPROSIMA_LOG_ERROR_IMPL_(cat, msg)
  |  |  ------------------
  |  |  |  |  291|  1.06k|    do {                                                                                                               \
  |  |  |  |  292|  1.06k|        std::stringstream fastdds_log_ss_tmp__;                                                                        \
  |  |  |  |  293|  1.06k|        fastdds_log_ss_tmp__ << msg;                                                                                   \
  |  |  |  |  294|  1.06k|        eprosima::fastdds::dds::Log::QueueLog(                                                                         \
  |  |  |  |  295|  1.06k|            fastdds_log_ss_tmp__.str(), eprosima::fastdds::dds::Log::Context{__FILE__, __LINE__, __func__, #cat},      \
  |  |  |  |  296|  1.06k|            eprosima::fastdds::dds::Log::Kind::Error);                                                                 \
  |  |  |  |  297|  1.06k|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (297:14): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 4547|  1.06k|            ret = XMLP_ret::XML_ERROR;
 4548|  1.06k|            break;
 4549|  1.06k|        }
 4550|  3.61k|    }
 4551|       |
 4552|       |    // Set ret to NOK if port attribute was not present
 4553|  7.15k|    if (ret == XMLP_ret::XML_OK && !port_found)
  ------------------
  |  Branch (4553:9): [True: 4.80k, False: 2.34k]
  |  Branch (4553:36): [True: 4.01k, False: 796]
  ------------------
 4554|  4.01k|    {
 4555|  4.01k|        ret = XMLP_ret::XML_NOK;
 4556|  4.01k|    }
 4557|       |
 4558|  7.15k|    const uint8_t ident = 1;
 4559|  7.15k|    std::set<std::string> tags_present;
 4560|       |
 4561|  7.15k|    for (tinyxml2::XMLElement* current_elem = elem.FirstChildElement();
 4562|  7.15k|            current_elem != nullptr && ret != XMLP_ret::XML_ERROR;
  ------------------
  |  Branch (4562:13): [True: 0, False: 7.15k]
  |  Branch (4562:40): [True: 0, False: 0]
  ------------------
 4563|  7.15k|            current_elem = current_elem->NextSiblingElement())
 4564|      0|    {
 4565|      0|        const char* name = current_elem->Name();
 4566|      0|        if (tags_present.count(name) != 0)
  ------------------
  |  Branch (4566:13): [True: 0, False: 0]
  ------------------
 4567|      0|        {
 4568|      0|            EPROSIMA_LOG_ERROR(XMLPARSER, "Duplicated element found in 'thread_settings'. Tag: " << name);
  ------------------
  |  |   45|      0|#define EPROSIMA_LOG_ERROR(cat, msg) EPROSIMA_LOG_ERROR_IMPL_(cat, msg)
  |  |  ------------------
  |  |  |  |  291|      0|    do {                                                                                                               \
  |  |  |  |  292|      0|        std::stringstream fastdds_log_ss_tmp__;                                                                        \
  |  |  |  |  293|      0|        fastdds_log_ss_tmp__ << msg;                                                                                   \
  |  |  |  |  294|      0|        eprosima::fastdds::dds::Log::QueueLog(                                                                         \
  |  |  |  |  295|      0|            fastdds_log_ss_tmp__.str(), eprosima::fastdds::dds::Log::Context{__FILE__, __LINE__, __func__, #cat},      \
  |  |  |  |  296|      0|            eprosima::fastdds::dds::Log::Kind::Error);                                                                 \
  |  |  |  |  297|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (297:14): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 4569|      0|            ret = XMLP_ret::XML_ERROR;
 4570|      0|            break;
 4571|      0|        }
 4572|      0|        tags_present.emplace(name);
 4573|       |
 4574|      0|        if (strcmp(current_elem->Name(), SCHEDULING_POLICY) == 0)
  ------------------
  |  Branch (4574:13): [True: 0, False: 0]
  ------------------
 4575|      0|        {
 4576|       |            // scheduling_policy - int32Type
 4577|      0|            if (XMLP_ret::XML_OK != getXMLInt(current_elem, &thread_setting.scheduling_policy, ident) ||
  ------------------
  |  Branch (4577:17): [True: 0, False: 0]
  ------------------
 4578|      0|                    thread_setting.scheduling_policy < -1)
  ------------------
  |  Branch (4578:21): [True: 0, False: 0]
  ------------------
 4579|      0|            {
 4580|      0|                ret = XMLP_ret::XML_ERROR;
 4581|      0|                break;
 4582|      0|            }
 4583|      0|        }
 4584|      0|        else if (strcmp(current_elem->Name(), PRIORITY) == 0)
  ------------------
  |  Branch (4584:18): [True: 0, False: 0]
  ------------------
 4585|      0|        {
 4586|       |            // priority - int32Type
 4587|      0|            if (XMLP_ret::XML_OK != getXMLInt(current_elem, &thread_setting.priority, ident))
  ------------------
  |  Branch (4587:17): [True: 0, False: 0]
  ------------------
 4588|      0|            {
 4589|      0|                ret = XMLP_ret::XML_ERROR;
 4590|      0|                break;
 4591|      0|            }
 4592|      0|        }
 4593|      0|        else if (strcmp(current_elem->Name(), AFFINITY) == 0)
  ------------------
  |  Branch (4593:18): [True: 0, False: 0]
  ------------------
 4594|      0|        {
 4595|       |            // affinity - uint64Type
 4596|      0|            if (XMLP_ret::XML_OK != getXMLUint(current_elem, &thread_setting.affinity, ident))
  ------------------
  |  Branch (4596:17): [True: 0, False: 0]
  ------------------
 4597|      0|            {
 4598|      0|                ret = XMLP_ret::XML_ERROR;
 4599|      0|                break;
 4600|      0|            }
 4601|      0|        }
 4602|      0|        else if (strcmp(current_elem->Name(), STACK_SIZE) == 0)
  ------------------
  |  Branch (4602:18): [True: 0, False: 0]
  ------------------
 4603|      0|        {
 4604|       |            // stack_size - int32Type
 4605|      0|            if (XMLP_ret::XML_OK != getXMLInt(current_elem, &thread_setting.stack_size, ident) ||
  ------------------
  |  Branch (4605:17): [True: 0, False: 0]
  ------------------
 4606|      0|                    thread_setting.stack_size < -1)
  ------------------
  |  Branch (4606:21): [True: 0, False: 0]
  ------------------
 4607|      0|            {
 4608|      0|                ret = XMLP_ret::XML_ERROR;
 4609|      0|                break;
 4610|      0|            }
 4611|      0|        }
 4612|      0|        else
 4613|      0|        {
 4614|      0|            EPROSIMA_LOG_ERROR(XMLPARSER, "Found incorrect tag '" << current_elem->Name() << "'");
  ------------------
  |  |   45|      0|#define EPROSIMA_LOG_ERROR(cat, msg) EPROSIMA_LOG_ERROR_IMPL_(cat, msg)
  |  |  ------------------
  |  |  |  |  291|      0|    do {                                                                                                               \
  |  |  |  |  292|      0|        std::stringstream fastdds_log_ss_tmp__;                                                                        \
  |  |  |  |  293|      0|        fastdds_log_ss_tmp__ << msg;                                                                                   \
  |  |  |  |  294|      0|        eprosima::fastdds::dds::Log::QueueLog(                                                                         \
  |  |  |  |  295|      0|            fastdds_log_ss_tmp__.str(), eprosima::fastdds::dds::Log::Context{__FILE__, __LINE__, __func__, #cat},      \
  |  |  |  |  296|      0|            eprosima::fastdds::dds::Log::Kind::Error);                                                                 \
  |  |  |  |  297|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (297:14): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 4615|      0|            ret = XMLP_ret::XML_ERROR;
 4616|      0|            break;
 4617|      0|        }
 4618|      0|    }
 4619|  7.15k|    return ret;
 4620|  7.15k|}
_ZN8eprosima7fastdds9xmlparser9XMLParser22getXMLEntityFactoryQosERN8tinyxml210XMLElementERNS0_3dds22EntityFactoryQosPolicyE:
 4625|     87|{
 4626|       |    /*
 4627|       |        <xs:complexType name="entityFactoryQosPolicyType">
 4628|       |            <xs:all>
 4629|       |                <xs:element name="autoenable_created_entities" type="boolean" minOccurs="0" maxOccurs="1"/>
 4630|       |            </xs:all>
 4631|       |        </xs:complexType>
 4632|       |     */
 4633|       |
 4634|       |    /*
 4635|       |     * The only allowed element is autoenable_created_entities, its min occurrences is 0, and its max is 1.
 4636|       |     */
 4637|     87|    const uint8_t ident = 1;
 4638|     87|    std::set<std::string> tags_present;
 4639|       |
 4640|     87|    for (tinyxml2::XMLElement* current_elem = elem.FirstChildElement(); current_elem != nullptr;
  ------------------
  |  Branch (4640:73): [True: 0, False: 87]
  ------------------
 4641|     87|            current_elem = current_elem->NextSiblingElement())
 4642|      0|    {
 4643|      0|        const char* name = current_elem->Name();
 4644|      0|        if (tags_present.count(name) != 0)
  ------------------
  |  Branch (4644:13): [True: 0, False: 0]
  ------------------
 4645|      0|        {
 4646|      0|            EPROSIMA_LOG_ERROR(XMLPARSER, "Duplicated element found in 'entityFactoryQosPolicyType'. Tag: " << name);
  ------------------
  |  |   45|      0|#define EPROSIMA_LOG_ERROR(cat, msg) EPROSIMA_LOG_ERROR_IMPL_(cat, msg)
  |  |  ------------------
  |  |  |  |  291|      0|    do {                                                                                                               \
  |  |  |  |  292|      0|        std::stringstream fastdds_log_ss_tmp__;                                                                        \
  |  |  |  |  293|      0|        fastdds_log_ss_tmp__ << msg;                                                                                   \
  |  |  |  |  294|      0|        eprosima::fastdds::dds::Log::QueueLog(                                                                         \
  |  |  |  |  295|      0|            fastdds_log_ss_tmp__.str(), eprosima::fastdds::dds::Log::Context{__FILE__, __LINE__, __func__, #cat},      \
  |  |  |  |  296|      0|            eprosima::fastdds::dds::Log::Kind::Error);                                                                 \
  |  |  |  |  297|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (297:14): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 4647|      0|            return XMLP_ret::XML_ERROR;
 4648|      0|        }
 4649|      0|        tags_present.emplace(name);
 4650|       |
 4651|      0|        if (strcmp(current_elem->Name(), AUTOENABLE_CREATED_ENTITIES) == 0)
  ------------------
  |  Branch (4651:13): [True: 0, False: 0]
  ------------------
 4652|      0|        {
 4653|       |            // autoenable_created_entities - boolean
 4654|      0|            if (XMLP_ret::XML_OK != getXMLBool(current_elem, &entity_factory.autoenable_created_entities, ident))
  ------------------
  |  Branch (4654:17): [True: 0, False: 0]
  ------------------
 4655|      0|            {
 4656|      0|                return XMLP_ret::XML_ERROR;
 4657|      0|            }
 4658|      0|        }
 4659|      0|        else
 4660|      0|        {
 4661|      0|            EPROSIMA_LOG_ERROR(XMLPARSER, "Found incorrect tag '" << current_elem->Name() << "'");
  ------------------
  |  |   45|      0|#define EPROSIMA_LOG_ERROR(cat, msg) EPROSIMA_LOG_ERROR_IMPL_(cat, msg)
  |  |  ------------------
  |  |  |  |  291|      0|    do {                                                                                                               \
  |  |  |  |  292|      0|        std::stringstream fastdds_log_ss_tmp__;                                                                        \
  |  |  |  |  293|      0|        fastdds_log_ss_tmp__ << msg;                                                                                   \
  |  |  |  |  294|      0|        eprosima::fastdds::dds::Log::QueueLog(                                                                         \
  |  |  |  |  295|      0|            fastdds_log_ss_tmp__.str(), eprosima::fastdds::dds::Log::Context{__FILE__, __LINE__, __func__, #cat},      \
  |  |  |  |  296|      0|            eprosima::fastdds::dds::Log::Kind::Error);                                                                 \
  |  |  |  |  297|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (297:14): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 4662|      0|            return XMLP_ret::XML_ERROR;
 4663|      0|        }
 4664|      0|    }
 4665|     87|    return XMLP_ret::XML_OK;
 4666|     87|}
_ZN8eprosima7fastdds9xmlparser9XMLParser23getXMLBuiltinTransportsEPN8tinyxml210XMLElementEPNS0_4rtps17BuiltinTransportsEPNS6_24BuiltinTransportsOptionsEh:
 4673|  32.6k|{
 4674|       |    /*
 4675|       |        <xs:simpleType name="builtinTransportKind">
 4676|       |            <xs:restriction base="xs:string">
 4677|       |                <xs:enumeration value="NONE" />
 4678|       |                <xs:enumeration value="DEFAULT" />
 4679|       |                <xs:enumeration value="DEFAULTv6" />
 4680|       |                <xs:enumeration value="SHM" />
 4681|       |                <xs:enumeration value="UDPv4" />
 4682|       |                <xs:enumeration value="UDPv6" />
 4683|       |                <xs:enumeration value="LARGE_DATA" />
 4684|       |                <xs:enumeration value="LARGE_DATAv6" />
 4685|       |                <xs:enumeration value="P2P" />
 4686|       |            </xs:restriction>
 4687|       |        </xs:simpleType>
 4688|       |
 4689|       |        <xs:complexType name="builtinTransportsType">
 4690|       |            <xs:simpleContent>
 4691|       |                <xs:extension base="builtinTransportKind">
 4692|       |                    <xs:attribute name="max_msg_size" type="string" use="optional"/>
 4693|       |                    <xs:attribute name="sockets_size" type="string" use="optional"/>
 4694|       |                    <xs:attribute name="non_blocking" type="bool" use="optional"/>
 4695|       |                    <xs:attribute name="tcp_negotiation_timeout" type="uint32" use="optional"/>
 4696|       |                </xs:extension>
 4697|       |            </xs:simpleContent>
 4698|       |        </xs:complexType>
 4699|       |     */
 4700|       |
 4701|  32.6k|    XMLP_ret ret = XMLP_ret::XML_OK;
 4702|  41.3k|    for (const tinyxml2::XMLAttribute* attrib = elem->FirstAttribute(); attrib != nullptr; attrib = attrib->Next())
  ------------------
  |  Branch (4702:73): [True: 33.0k, False: 8.36k]
  ------------------
 4703|  33.0k|    {
 4704|  33.0k|        if (strcmp(attrib->Name(), MAX_MSG_SIZE_LARGE_DATA) == 0)
  ------------------
  |  Branch (4704:13): [True: 14.4k, False: 18.5k]
  ------------------
 4705|  14.4k|        {
 4706|       |            // max_msg_size - stringType
 4707|  14.4k|            try
 4708|  14.4k|            {
 4709|  14.4k|                std::string temp = attrib->Value();
 4710|  14.4k|                temp.erase(std::remove_if(temp.begin(), temp.end(), [](unsigned char c)
 4711|  14.4k|                        {
 4712|  14.4k|                            return std::isspace(c);
 4713|  14.4k|                        }), temp.end());
 4714|  14.4k|                if (attrib->Value()[0] == '-')
  ------------------
  |  Branch (4714:21): [True: 208, False: 14.2k]
  ------------------
 4715|    208|                {
 4716|    208|                    throw std::invalid_argument("Negative value detected.");
 4717|    208|                }
 4718|  14.2k|                std::regex msg_size_regex(R"((\d+)(\w*))");
 4719|  14.2k|                std::smatch mr;
 4720|  14.2k|                if (std::regex_search(temp, mr, msg_size_regex, std::regex_constants::match_not_null))
  ------------------
  |  Branch (4720:21): [True: 13.9k, False: 294]
  ------------------
 4721|  13.9k|                {
 4722|  13.9k|                    std::string value = mr[1];
 4723|  13.9k|                    std::string unit = mr[2].str();
 4724|  13.9k|                    bt_opts->maxMessageSize = eprosima::fastdds::dds::utils::parse_value_and_units(value, unit);
 4725|  13.9k|                }
 4726|  14.2k|            }
 4727|  14.4k|            catch (std::invalid_argument& except)
 4728|  14.4k|            {
 4729|  10.6k|                EPROSIMA_LOG_ERROR(XMLPARSER,
  ------------------
  |  |   45|  10.6k|#define EPROSIMA_LOG_ERROR(cat, msg) EPROSIMA_LOG_ERROR_IMPL_(cat, msg)
  |  |  ------------------
  |  |  |  |  291|  10.6k|    do {                                                                                                               \
  |  |  |  |  292|  10.6k|        std::stringstream fastdds_log_ss_tmp__;                                                                        \
  |  |  |  |  293|  10.6k|        fastdds_log_ss_tmp__ << msg;                                                                                   \
  |  |  |  |  294|  10.6k|        eprosima::fastdds::dds::Log::QueueLog(                                                                         \
  |  |  |  |  295|  10.6k|            fastdds_log_ss_tmp__.str(), eprosima::fastdds::dds::Log::Context{__FILE__, __LINE__, __func__, #cat},      \
  |  |  |  |  296|  10.6k|            eprosima::fastdds::dds::Log::Kind::Error);                                                                 \
  |  |  |  |  297|  10.6k|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (297:14): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 4730|  10.6k|                        "Found wrong value " << attrib->Value() << " for max_msg_size attribute. " <<
 4731|  10.6k|                        except.what());
 4732|  10.6k|                ret = XMLP_ret::XML_ERROR;
 4733|  10.6k|                break;
 4734|  10.6k|            }
 4735|  14.4k|        }
 4736|  18.5k|        else if (strcmp(attrib->Name(), SOCKETS_SIZE_LARGE_DATA) == 0)
  ------------------
  |  Branch (4736:18): [True: 7.06k, False: 11.5k]
  ------------------
 4737|  7.06k|        {
 4738|       |            // sockets_size - stringType
 4739|  7.06k|            try
 4740|  7.06k|            {
 4741|  7.06k|                std::string temp = attrib->Value();
 4742|  7.06k|                temp.erase(std::remove_if(temp.begin(), temp.end(), [](unsigned char c)
 4743|  7.06k|                        {
 4744|  7.06k|                            return std::isspace(c);
 4745|  7.06k|                        }), temp.end());
 4746|  7.06k|                if (attrib->Value()[0] == '-')
  ------------------
  |  Branch (4746:21): [True: 210, False: 6.85k]
  ------------------
 4747|    210|                {
 4748|    210|                    throw std::invalid_argument("Negative value detected.");
 4749|    210|                }
 4750|  6.85k|                std::regex sockets_size_regex(R"((\d+)(\w*))");
 4751|  6.85k|                std::smatch mr;
 4752|  6.85k|                if (std::regex_search(temp, mr, sockets_size_regex, std::regex_constants::match_not_null))
  ------------------
  |  Branch (4752:21): [True: 6.56k, False: 286]
  ------------------
 4753|  6.56k|                {
 4754|  6.56k|                    std::string value = mr[1];
 4755|  6.56k|                    std::string unit = mr[2].str();
 4756|  6.56k|                    bt_opts->sockets_buffer_size = eprosima::fastdds::dds::utils::parse_value_and_units(value, unit);
 4757|  6.56k|                }
 4758|  6.85k|            }
 4759|  7.06k|            catch (std::invalid_argument& except)
 4760|  7.06k|            {
 4761|  4.50k|                EPROSIMA_LOG_ERROR(XMLPARSER,
  ------------------
  |  |   45|  4.50k|#define EPROSIMA_LOG_ERROR(cat, msg) EPROSIMA_LOG_ERROR_IMPL_(cat, msg)
  |  |  ------------------
  |  |  |  |  291|  4.50k|    do {                                                                                                               \
  |  |  |  |  292|  4.50k|        std::stringstream fastdds_log_ss_tmp__;                                                                        \
  |  |  |  |  293|  4.50k|        fastdds_log_ss_tmp__ << msg;                                                                                   \
  |  |  |  |  294|  4.50k|        eprosima::fastdds::dds::Log::QueueLog(                                                                         \
  |  |  |  |  295|  4.50k|            fastdds_log_ss_tmp__.str(), eprosima::fastdds::dds::Log::Context{__FILE__, __LINE__, __func__, #cat},      \
  |  |  |  |  296|  4.50k|            eprosima::fastdds::dds::Log::Kind::Error);                                                                 \
  |  |  |  |  297|  4.50k|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (297:14): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 4762|  4.50k|                        "Found wrong value " << attrib->Value() << " for sockets_size attribute. " <<
 4763|  4.50k|                        except.what());
 4764|  4.50k|                ret = XMLP_ret::XML_ERROR;
 4765|  4.50k|                break;
 4766|  4.50k|            }
 4767|  7.06k|        }
 4768|  11.5k|        else if (strcmp(attrib->Name(), NON_BLOCKING_LARGE_DATA) == 0)
  ------------------
  |  Branch (4768:18): [True: 5.66k, False: 5.86k]
  ------------------
 4769|  5.66k|        {
 4770|       |            // non_blocking - stringType
 4771|  5.66k|            try
 4772|  5.66k|            {
 4773|  5.66k|                std::string temp = attrib->Value();
 4774|  5.66k|                temp.erase(std::remove_if(temp.begin(), temp.end(), [](unsigned char c)
 4775|  5.66k|                        {
 4776|  5.66k|                            return std::isspace(c);
 4777|  5.66k|                        }), temp.end());
 4778|  5.66k|                if (temp != "true" && temp != "false")
  ------------------
  |  Branch (4778:21): [True: 4.31k, False: 1.35k]
  |  Branch (4778:39): [True: 4.26k, False: 49]
  ------------------
 4779|  4.26k|                {
 4780|  4.26k|                    throw std::invalid_argument("Only \"true\" or \"false\" values allowed.");
 4781|  4.26k|                }
 4782|  1.40k|                bt_opts->non_blocking_send = temp == "true" ? true : false;
  ------------------
  |  Branch (4782:46): [True: 1.35k, False: 49]
  ------------------
 4783|  1.40k|            }
 4784|  5.66k|            catch (std::invalid_argument& except)
 4785|  5.66k|            {
 4786|  4.26k|                EPROSIMA_LOG_ERROR(XMLPARSER,
  ------------------
  |  |   45|  4.26k|#define EPROSIMA_LOG_ERROR(cat, msg) EPROSIMA_LOG_ERROR_IMPL_(cat, msg)
  |  |  ------------------
  |  |  |  |  291|  4.26k|    do {                                                                                                               \
  |  |  |  |  292|  4.26k|        std::stringstream fastdds_log_ss_tmp__;                                                                        \
  |  |  |  |  293|  4.26k|        fastdds_log_ss_tmp__ << msg;                                                                                   \
  |  |  |  |  294|  4.26k|        eprosima::fastdds::dds::Log::QueueLog(                                                                         \
  |  |  |  |  295|  4.26k|            fastdds_log_ss_tmp__.str(), eprosima::fastdds::dds::Log::Context{__FILE__, __LINE__, __func__, #cat},      \
  |  |  |  |  296|  4.26k|            eprosima::fastdds::dds::Log::Kind::Error);                                                                 \
  |  |  |  |  297|  4.26k|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (297:14): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 4787|  4.26k|                        "Found wrong value " << attrib->Value() << " for non_blocking attribute. " <<
 4788|  4.26k|                        except.what());
 4789|  4.26k|                ret = XMLP_ret::XML_ERROR;
 4790|  4.26k|                break;
 4791|  4.26k|            }
 4792|  5.66k|        }
 4793|  5.86k|        else if (strcmp(attrib->Name(), TCP_NEGOTIATION_TIMEOUT) == 0)
  ------------------
  |  Branch (4793:18): [True: 2.72k, False: 3.14k]
  ------------------
 4794|  2.72k|        {
 4795|       |            // tcp_negotiation_timeout - stringType
 4796|  2.72k|            try
 4797|  2.72k|            {
 4798|  2.72k|                std::string temp = attrib->Value();
 4799|  2.72k|                temp.erase(std::remove_if(temp.begin(), temp.end(), [](unsigned char c)
 4800|  2.72k|                        {
 4801|  2.72k|                            return std::isspace(c);
 4802|  2.72k|                        }), temp.end());
 4803|  2.72k|                if (attrib->Value()[0] == '-')
  ------------------
  |  Branch (4803:21): [True: 1.00k, False: 1.71k]
  ------------------
 4804|  1.00k|                {
 4805|  1.00k|                    throw std::invalid_argument("Negative value detected.");
 4806|  1.00k|                }
 4807|  1.71k|                uint64_t value = std::stoull(temp);
 4808|  1.71k|                if (value > std::numeric_limits<std::uint32_t>::max())
  ------------------
  |  Branch (4808:21): [True: 586, False: 1.13k]
  ------------------
 4809|    586|                {
 4810|    586|                    throw std::out_of_range("Value for timeout out of range. Max uint32_t.");
 4811|    586|                }
 4812|  1.13k|                bt_opts->tcp_negotiation_timeout = static_cast<uint32_t>(std::stoul(temp));
 4813|  1.13k|            }
 4814|  2.72k|            catch (std::exception& except)
 4815|  2.72k|            {
 4816|  1.73k|                EPROSIMA_LOG_ERROR(XMLPARSER,
  ------------------
  |  |   45|  1.73k|#define EPROSIMA_LOG_ERROR(cat, msg) EPROSIMA_LOG_ERROR_IMPL_(cat, msg)
  |  |  ------------------
  |  |  |  |  291|  1.73k|    do {                                                                                                               \
  |  |  |  |  292|  1.73k|        std::stringstream fastdds_log_ss_tmp__;                                                                        \
  |  |  |  |  293|  1.73k|        fastdds_log_ss_tmp__ << msg;                                                                                   \
  |  |  |  |  294|  1.73k|        eprosima::fastdds::dds::Log::QueueLog(                                                                         \
  |  |  |  |  295|  1.73k|            fastdds_log_ss_tmp__.str(), eprosima::fastdds::dds::Log::Context{__FILE__, __LINE__, __func__, #cat},      \
  |  |  |  |  296|  1.73k|            eprosima::fastdds::dds::Log::Kind::Error);                                                                 \
  |  |  |  |  297|  1.73k|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (297:14): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 4817|  1.73k|                        "Found wrong value " << attrib->Value() << " for tcp_negotiation_timeout attribute. " <<
 4818|  1.73k|                        except.what());
 4819|  1.73k|                ret = XMLP_ret::XML_ERROR;
 4820|  1.73k|                break;
 4821|  1.73k|            }
 4822|  2.72k|        }
 4823|  3.14k|        else
 4824|  3.14k|        {
 4825|  3.14k|            EPROSIMA_LOG_ERROR(XMLPARSER, "Found wrong attribute " << attrib->Name() << " in 'builtin_transports");
  ------------------
  |  |   45|  3.14k|#define EPROSIMA_LOG_ERROR(cat, msg) EPROSIMA_LOG_ERROR_IMPL_(cat, msg)
  |  |  ------------------
  |  |  |  |  291|  3.14k|    do {                                                                                                               \
  |  |  |  |  292|  3.14k|        std::stringstream fastdds_log_ss_tmp__;                                                                        \
  |  |  |  |  293|  3.14k|        fastdds_log_ss_tmp__ << msg;                                                                                   \
  |  |  |  |  294|  3.14k|        eprosima::fastdds::dds::Log::QueueLog(                                                                         \
  |  |  |  |  295|  3.14k|            fastdds_log_ss_tmp__.str(), eprosima::fastdds::dds::Log::Context{__FILE__, __LINE__, __func__, #cat},      \
  |  |  |  |  296|  3.14k|            eprosima::fastdds::dds::Log::Kind::Error);                                                                 \
  |  |  |  |  297|  3.14k|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (297:14): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 4826|  3.14k|            ret = XMLP_ret::XML_ERROR;
 4827|  3.14k|            break;
 4828|  3.14k|        }
 4829|  33.0k|    }
 4830|       |
 4831|  32.6k|    std::string mode = get_element_text(elem);
 4832|       |
 4833|  32.6k|    if (mode.empty())
  ------------------
  |  Branch (4833:9): [True: 32.6k, False: 0]
  ------------------
 4834|  32.6k|    {
 4835|  32.6k|        EPROSIMA_LOG_ERROR(XMLPARSER, "Node '" << KIND << "' without content");
  ------------------
  |  |   45|  32.6k|#define EPROSIMA_LOG_ERROR(cat, msg) EPROSIMA_LOG_ERROR_IMPL_(cat, msg)
  |  |  ------------------
  |  |  |  |  291|  32.6k|    do {                                                                                                               \
  |  |  |  |  292|  32.6k|        std::stringstream fastdds_log_ss_tmp__;                                                                        \
  |  |  |  |  293|  32.6k|        fastdds_log_ss_tmp__ << msg;                                                                                   \
  |  |  |  |  294|  32.6k|        eprosima::fastdds::dds::Log::QueueLog(                                                                         \
  |  |  |  |  295|  32.6k|            fastdds_log_ss_tmp__.str(), eprosima::fastdds::dds::Log::Context{__FILE__, __LINE__, __func__, #cat},      \
  |  |  |  |  296|  32.6k|            eprosima::fastdds::dds::Log::Kind::Error);                                                                 \
  |  |  |  |  297|  32.6k|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (297:14): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 4836|  32.6k|        return XMLP_ret::XML_ERROR;
 4837|  32.6k|    }
 4838|       |
 4839|      0|    if (!get_element_enum_value(mode.c_str(), *bt,
  ------------------
  |  Branch (4839:9): [True: 0, False: 0]
  ------------------
 4840|      0|            NONE, eprosima::fastdds::rtps::BuiltinTransports::NONE,
 4841|      0|            DEFAULT_C, eprosima::fastdds::rtps::BuiltinTransports::DEFAULT,
 4842|      0|            DEFAULTv6, eprosima::fastdds::rtps::BuiltinTransports::DEFAULTv6,
 4843|      0|            SHM, eprosima::fastdds::rtps::BuiltinTransports::SHM,
 4844|      0|            UDPv4, eprosima::fastdds::rtps::BuiltinTransports::UDPv4,
 4845|      0|            UDPv6, eprosima::fastdds::rtps::BuiltinTransports::UDPv6,
 4846|      0|            LARGE_DATA, eprosima::fastdds::rtps::BuiltinTransports::LARGE_DATA,
 4847|      0|            LARGE_DATAv6, eprosima::fastdds::rtps::BuiltinTransports::LARGE_DATAv6,
 4848|      0|            P2P, eprosima::fastdds::rtps::BuiltinTransports::P2P))
 4849|      0|    {
 4850|      0|        EPROSIMA_LOG_ERROR(XMLPARSER, "Node '" << KIND << "' bad content");
  ------------------
  |  |   45|      0|#define EPROSIMA_LOG_ERROR(cat, msg) EPROSIMA_LOG_ERROR_IMPL_(cat, msg)
  |  |  ------------------
  |  |  |  |  291|      0|    do {                                                                                                               \
  |  |  |  |  292|      0|        std::stringstream fastdds_log_ss_tmp__;                                                                        \
  |  |  |  |  293|      0|        fastdds_log_ss_tmp__ << msg;                                                                                   \
  |  |  |  |  294|      0|        eprosima::fastdds::dds::Log::QueueLog(                                                                         \
  |  |  |  |  295|      0|            fastdds_log_ss_tmp__.str(), eprosima::fastdds::dds::Log::Context{__FILE__, __LINE__, __func__, #cat},      \
  |  |  |  |  296|      0|            eprosima::fastdds::dds::Log::Kind::Error);                                                                 \
  |  |  |  |  297|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (297:14): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 4851|      0|        ret = XMLP_ret::XML_ERROR;
 4852|      0|    }
 4853|       |
 4854|      0|    return ret;
 4855|  32.6k|}
XMLElementParser.cpp:_ZN8eprosima7fastdds3xml6detailL19process_environmentERKNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEE:
   46|  40.5k|{
   47|       |    /* From [IEEE Std 1003.1]:(https://pubs.opengroup.org/onlinepubs/000095399/basedefs/xbd_chap08.html)
   48|       |     * Environment variable names used ... consist solely of uppercase letters, digits, and the '_' (underscore)
   49|       |     * from the characters defined in Portable Character Set and do not begin with a digit.
   50|       |     */
   51|  40.5k|    std::regex expression("\\$\\{([A-Z_][A-Z0-9_]*)\\}");
   52|       |
   53|       |    // Algorithm inspired by https://stackoverflow.com/a/37516316/559350
   54|       |
   55|       |    // This will hold the accumulated substitution result
   56|  40.5k|    std::string ret_val{};
   57|       |
   58|       |    // Iterators to first and last character of the input string
   59|  40.5k|    auto first = input.cbegin();
   60|  40.5k|    auto last = input.cend();
   61|       |
   62|       |    // Position of last match in the input string
   63|  40.5k|    std::smatch::difference_type last_match_position = 0;
   64|       |
   65|       |    // Iterator to the character after the last match in the input string
   66|  40.5k|    auto last_match_end = first;
   67|       |
   68|       |    // Functor called to process each match
   69|  40.5k|    auto match_cb = [&](const std::smatch& match)
   70|  40.5k|            {
   71|       |                // Compute substitution value
   72|  40.5k|                std::string var_name = match[1];
   73|  40.5k|                std::string value = "";
   74|  40.5k|                if (var_name == "_")
   75|  40.5k|                {
   76|       |                    // Silently ignore ${_} since it might expose sensitive information (full path to executable).
   77|  40.5k|                    EPROSIMA_LOG_WARNING(XMLPARSER, "Ignoring environment variable ${_}");
   78|  40.5k|                }
   79|  40.5k|                else if (dds::RETCODE_OK != SystemInfo::get_env(var_name, value))
   80|  40.5k|                {
   81|  40.5k|                    EPROSIMA_LOG_ERROR(XMLPARSER, "Could not find a value for environment variable " << var_name);
   82|  40.5k|                }
   83|       |
   84|       |                // Compute number of non-matching characters between this match and the last one
   85|  40.5k|                auto this_match_position = match.position();
   86|  40.5k|                auto diff = this_match_position - last_match_position;
   87|       |
   88|       |                // Append non-matching characters to return value
   89|  40.5k|                auto this_match_start = last_match_end;
   90|  40.5k|                std::advance(this_match_start, diff);
   91|  40.5k|                ret_val.append(last_match_end, this_match_start);
   92|       |
   93|       |                // Append substitution value to return value
   94|  40.5k|                ret_val.append(value);
   95|       |
   96|       |                // Prepare for next iteration
   97|  40.5k|                auto match_length = match.length();
   98|  40.5k|                last_match_position = this_match_position + match_length;
   99|  40.5k|                last_match_end = this_match_start;
  100|  40.5k|                std::advance(last_match_end, match_length);
  101|  40.5k|            };
  102|       |
  103|       |    // Substitute all matches
  104|  40.5k|    std::sregex_iterator begin(first, last, expression);
  105|  40.5k|    std::sregex_iterator end;
  106|  40.5k|    std::for_each(begin, end, match_cb);
  107|       |
  108|       |    // Append characters after last match
  109|  40.5k|    ret_val.append(last_match_end, last);
  110|       |
  111|  40.5k|    return ret_val;
  112|  40.5k|}
XMLElementParser.cpp:_ZZN8eprosima7fastdds3xml6detailL19process_environmentERKNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEENK3$_0clERKNS3_13match_resultsINS3_11__wrap_iterIPKcEENS7_INS3_9sub_matchISH_EEEEEE:
   70|   265k|            {
   71|       |                // Compute substitution value
   72|   265k|                std::string var_name = match[1];
   73|   265k|                std::string value = "";
   74|   265k|                if (var_name == "_")
  ------------------
  |  Branch (74:21): [True: 2.23k, False: 263k]
  ------------------
   75|  2.23k|                {
   76|       |                    // Silently ignore ${_} since it might expose sensitive information (full path to executable).
   77|  2.23k|                    EPROSIMA_LOG_WARNING(XMLPARSER, "Ignoring environment variable ${_}");
  ------------------
  |  |   43|  2.23k|#define EPROSIMA_LOG_WARNING(cat, msg) EPROSIMA_LOG_WARNING_IMPL_(cat, msg)
  |  |  ------------------
  |  |  |  |  322|  2.23k|    do {                                                                                                              \
  |  |  |  |  323|  2.23k|        if (eprosima::fastdds::dds::Log::GetVerbosity() >= eprosima::fastdds::dds::Log::Kind::Warning)                \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (323:13): [True: 0, False: 2.23k]
  |  |  |  |  ------------------
  |  |  |  |  324|  2.23k|        {                                                                                                             \
  |  |  |  |  325|      0|            std::stringstream fastdds_log_ss_tmp__;                                                                   \
  |  |  |  |  326|      0|            fastdds_log_ss_tmp__ << msg;                                                                              \
  |  |  |  |  327|      0|            eprosima::fastdds::dds::Log::QueueLog(                                                                    \
  |  |  |  |  328|      0|                fastdds_log_ss_tmp__.str(), eprosima::fastdds::dds::Log::Context{__FILE__, __LINE__, __func__, #cat}, \
  |  |  |  |  329|      0|                eprosima::fastdds::dds::Log::Kind::Warning);                                                          \
  |  |  |  |  330|      0|        }                                                                                                             \
  |  |  |  |  331|  2.23k|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (331:14): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
   78|  2.23k|                }
   79|   263k|                else if (dds::RETCODE_OK != SystemInfo::get_env(var_name, value))
  ------------------
  |  Branch (79:26): [True: 263k, False: 0]
  ------------------
   80|   263k|                {
   81|   263k|                    EPROSIMA_LOG_ERROR(XMLPARSER, "Could not find a value for environment variable " << var_name);
  ------------------
  |  |   45|   263k|#define EPROSIMA_LOG_ERROR(cat, msg) EPROSIMA_LOG_ERROR_IMPL_(cat, msg)
  |  |  ------------------
  |  |  |  |  291|   263k|    do {                                                                                                               \
  |  |  |  |  292|   263k|        std::stringstream fastdds_log_ss_tmp__;                                                                        \
  |  |  |  |  293|   263k|        fastdds_log_ss_tmp__ << msg;                                                                                   \
  |  |  |  |  294|   263k|        eprosima::fastdds::dds::Log::QueueLog(                                                                         \
  |  |  |  |  295|   263k|            fastdds_log_ss_tmp__.str(), eprosima::fastdds::dds::Log::Context{__FILE__, __LINE__, __func__, #cat},      \
  |  |  |  |  296|   263k|            eprosima::fastdds::dds::Log::Kind::Error);                                                                 \
  |  |  |  |  297|   263k|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (297:14): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
   82|   263k|                }
   83|       |
   84|       |                // Compute number of non-matching characters between this match and the last one
   85|   265k|                auto this_match_position = match.position();
   86|   265k|                auto diff = this_match_position - last_match_position;
   87|       |
   88|       |                // Append non-matching characters to return value
   89|   265k|                auto this_match_start = last_match_end;
   90|   265k|                std::advance(this_match_start, diff);
   91|   265k|                ret_val.append(last_match_end, this_match_start);
   92|       |
   93|       |                // Append substitution value to return value
   94|   265k|                ret_val.append(value);
   95|       |
   96|       |                // Prepare for next iteration
   97|   265k|                auto match_length = match.length();
   98|   265k|                last_match_position = this_match_position + match_length;
   99|   265k|                last_match_end = this_match_start;
  100|   265k|                std::advance(last_match_end, match_length);
  101|   265k|            };
XMLElementParser.cpp:_ZZN8eprosima7fastdds9xmlparser9XMLParser28getXMLThreadSettingsWithPortERN8tinyxml210XMLElementERNS0_4rtps14ThreadSettingsERjENK3$_0clEh:
 4517|  1.78M|                        {
 4518|  1.78M|                            return std::isspace(c);
 4519|  1.78M|                        }), temp.end());
XMLElementParser.cpp:_ZZN8eprosima7fastdds9xmlparser9XMLParser23getXMLBuiltinTransportsEPN8tinyxml210XMLElementEPNS0_4rtps17BuiltinTransportsEPNS6_24BuiltinTransportsOptionsEhENK3$_0clEh:
 4711|  7.41M|                        {
 4712|  7.41M|                            return std::isspace(c);
 4713|  7.41M|                        }), temp.end());
XMLElementParser.cpp:_ZZN8eprosima7fastdds9xmlparser9XMLParser23getXMLBuiltinTransportsEPN8tinyxml210XMLElementEPNS0_4rtps17BuiltinTransportsEPNS6_24BuiltinTransportsOptionsEhENK3$_1clEh:
 4743|  8.02M|                        {
 4744|  8.02M|                            return std::isspace(c);
 4745|  8.02M|                        }), temp.end());
XMLElementParser.cpp:_ZZN8eprosima7fastdds9xmlparser9XMLParser23getXMLBuiltinTransportsEPN8tinyxml210XMLElementEPNS0_4rtps17BuiltinTransportsEPNS6_24BuiltinTransportsOptionsEhENK3$_2clEh:
 4775|  1.91M|                        {
 4776|  1.91M|                            return std::isspace(c);
 4777|  1.91M|                        }), temp.end());
XMLElementParser.cpp:_ZZN8eprosima7fastdds9xmlparser9XMLParser23getXMLBuiltinTransportsEPN8tinyxml210XMLElementEPNS0_4rtps17BuiltinTransportsEPNS6_24BuiltinTransportsOptionsEhENK3$_3clEh:
 4800|  2.08M|                        {
 4801|  2.08M|                            return std::isspace(c);
 4802|  2.08M|                        }), temp.end());

_ZN8eprosima7fastdds9xmlparser9XMLParser8parseXMLERN8tinyxml211XMLDocumentERNSt3__110unique_ptrINS1_8BaseNodeENS6_14default_deleteIS8_EEEE:
   88|  19.9k|{
   89|  19.9k|    XMLP_ret ret = XMLP_ret::XML_OK;
   90|  19.9k|    tinyxml2::XMLElement* p_root = xmlDoc.FirstChildElement(ROOT);
   91|  19.9k|    if (nullptr == p_root)
  ------------------
  |  Branch (91:9): [True: 15.1k, False: 4.78k]
  ------------------
   92|  15.1k|    {
   93|       |        // Just profiles in the XML.
   94|  15.1k|        if (nullptr == (p_root = xmlDoc.FirstChildElement(PROFILES)))
  ------------------
  |  Branch (94:13): [True: 1.77k, False: 13.3k]
  ------------------
   95|  1.77k|        {
   96|       |            // Just types in the XML.
   97|  1.77k|            if (nullptr == (p_root = xmlDoc.FirstChildElement(TYPES)))
  ------------------
  |  Branch (97:17): [True: 445, False: 1.33k]
  ------------------
   98|    445|            {
   99|       |                // Just log config in the XML.
  100|    445|                if (nullptr == (p_root = xmlDoc.FirstChildElement(LOG)))
  ------------------
  |  Branch (100:21): [True: 33, False: 412]
  ------------------
  101|     33|                {
  102|       |                    // Just library_settings config in the XML.
  103|     33|                    if (nullptr == (p_root = xmlDoc.FirstChildElement(LIBRARY_SETTINGS)))
  ------------------
  |  Branch (103:25): [True: 30, False: 3]
  ------------------
  104|     30|                    {
  105|     30|                        EPROSIMA_LOG_ERROR(XMLPARSER, "Not found root tag");
  ------------------
  |  |   45|     30|#define EPROSIMA_LOG_ERROR(cat, msg) EPROSIMA_LOG_ERROR_IMPL_(cat, msg)
  |  |  ------------------
  |  |  |  |  291|     30|    do {                                                                                                               \
  |  |  |  |  292|     30|        std::stringstream fastdds_log_ss_tmp__;                                                                        \
  |  |  |  |  293|     30|        fastdds_log_ss_tmp__ << msg;                                                                                   \
  |  |  |  |  294|     30|        eprosima::fastdds::dds::Log::QueueLog(                                                                         \
  |  |  |  |  295|     30|            fastdds_log_ss_tmp__.str(), eprosima::fastdds::dds::Log::Context{__FILE__, __LINE__, __func__, #cat},      \
  |  |  |  |  296|     30|            eprosima::fastdds::dds::Log::Kind::Error);                                                                 \
  |  |  |  |  297|     30|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (297:14): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  106|     30|                        ret = XMLP_ret::XML_ERROR;
  107|     30|                    }
  108|      3|                    else
  109|      3|                    {
  110|      3|                        root.reset(new BaseNode{NodeType::LIBRARY_SETTINGS});
  111|      3|                        ret  = parseXMLLibrarySettings(p_root);
  112|      3|                    }
  113|     33|                }
  114|    412|                else
  115|    412|                {
  116|    412|                    root.reset(new BaseNode{NodeType::LOG});
  117|    412|                    ret  = parseLogConfig(p_root);
  118|    412|                }
  119|    445|            }
  120|  1.33k|            else
  121|  1.33k|            {
  122|  1.33k|                root.reset(new BaseNode{ NodeType::TYPES });
  123|  1.33k|                ret = parseDynamicTypes(p_root);
  124|  1.33k|            }
  125|  1.77k|        }
  126|  13.3k|        else
  127|  13.3k|        {
  128|  13.3k|            root.reset(new BaseNode{ NodeType::PROFILES });
  129|  13.3k|            ret = parseProfiles(p_root, *root);
  130|  13.3k|        }
  131|  15.1k|    }
  132|  4.78k|    else
  133|  4.78k|    {
  134|  4.78k|        root.reset(new BaseNode{ NodeType::ROOT });
  135|  4.78k|        tinyxml2::XMLElement* node = p_root->FirstChildElement();
  136|  4.78k|        const char* tag = nullptr;
  137|  30.4k|        while ((nullptr != node) && (ret == XMLP_ret::XML_OK))
  ------------------
  |  Branch (137:16): [True: 25.7k, False: 4.69k]
  |  Branch (137:37): [True: 25.7k, False: 82]
  ------------------
  138|  25.7k|        {
  139|  25.7k|            if (nullptr != (tag = node->Value()))
  ------------------
  |  Branch (139:17): [True: 25.7k, False: 0]
  ------------------
  140|  25.7k|            {
  141|  25.7k|                if (strcmp(tag, PROFILES) == 0)
  ------------------
  |  Branch (141:21): [True: 1.24k, False: 24.4k]
  ------------------
  142|  1.24k|                {
  143|  1.24k|                    up_base_node_t profiles_node = up_base_node_t{ new BaseNode{NodeType::PROFILES} };
  144|  1.24k|                    if (XMLP_ret::XML_OK == (ret = parseProfiles(node, *profiles_node)))
  ------------------
  |  Branch (144:25): [True: 1.22k, False: 13]
  ------------------
  145|  1.22k|                    {
  146|  1.22k|                        root->addChild(std::move(profiles_node));
  147|  1.22k|                    }
  148|  1.24k|                }
  149|  24.4k|                else if (strcmp(tag, LIBRARY_SETTINGS) == 0)
  ------------------
  |  Branch (149:26): [True: 1, False: 24.4k]
  ------------------
  150|      1|                {
  151|       |                    // TODO Workaround to propagate the return code upstream. A refactor is needed to propagate the
  152|       |                    // return code in some other more sensible way or populate the object and change code upstream to
  153|       |                    // read this new object.
  154|      1|                    up_base_node_t library_node = up_base_node_t{ new BaseNode{NodeType::LIBRARY_SETTINGS} };
  155|      1|                    if (XMLP_ret::XML_OK == (ret = parseXMLLibrarySettings(node)))
  ------------------
  |  Branch (155:25): [True: 0, False: 1]
  ------------------
  156|      0|                    {
  157|      0|                        root->addChild(std::move(library_node));
  158|      0|                    }
  159|      1|                }
  160|  24.4k|                else if (strcmp(tag, DOMAINPARTICIPANT_FACTORY) == 0)
  ------------------
  |  Branch (160:26): [True: 268, False: 24.1k]
  ------------------
  161|    268|                {
  162|    268|                    ret = parseXMLDomainParticipantFactoryProf(node, *root);
  163|    268|                }
  164|  24.1k|                else if (strcmp(tag, PARTICIPANT) == 0)
  ------------------
  |  Branch (164:26): [True: 376, False: 23.8k]
  ------------------
  165|    376|                {
  166|    376|                    ret = parseXMLParticipantProf(node, *root);
  167|    376|                }
  168|  23.8k|                else if (strcmp(tag, PUBLISHER) == 0 || strcmp(tag, DATA_WRITER) == 0)
  ------------------
  |  Branch (168:26): [True: 1.62k, False: 22.1k]
  |  Branch (168:57): [True: 3.70k, False: 18.4k]
  ------------------
  169|  5.32k|                {
  170|  5.32k|                    ret = parseXMLPublisherProf(node, *root);
  171|  5.32k|                }
  172|  18.4k|                else if (strcmp(tag, SUBSCRIBER) == 0 || strcmp(tag, DATA_READER) == 0)
  ------------------
  |  Branch (172:26): [True: 3.14k, False: 15.3k]
  |  Branch (172:58): [True: 4.44k, False: 10.9k]
  ------------------
  173|  7.58k|                {
  174|  7.58k|                    ret = parseXMLSubscriberProf(node, *root);
  175|  7.58k|                }
  176|  10.9k|                else if (strcmp(tag, TOPIC) == 0)
  ------------------
  |  Branch (176:26): [True: 1.23k, False: 9.67k]
  ------------------
  177|  1.23k|                {
  178|  1.23k|                    ret = parseXMLTopicData(node, *root);
  179|  1.23k|                }
  180|  9.67k|                else if (strcmp(tag, REQUESTER) == 0)
  ------------------
  |  Branch (180:26): [True: 266, False: 9.40k]
  ------------------
  181|    266|                {
  182|    266|                    ret = parseXMLRequesterProf(node, *root);
  183|    266|                }
  184|  9.40k|                else if (strcmp(tag, REPLIER) == 0)
  ------------------
  |  Branch (184:26): [True: 353, False: 9.05k]
  ------------------
  185|    353|                {
  186|    353|                    ret = parseXMLReplierProf(node, *root);
  187|    353|                }
  188|  9.05k|                else if (strcmp(tag, TYPES) == 0)
  ------------------
  |  Branch (188:26): [True: 450, False: 8.60k]
  ------------------
  189|    450|                {
  190|       |                    // TODO Workaround to propagate the return code upstream. A refactor is needed to propagate the
  191|       |                    // return code in some other more sensible way or populate the object and change code upstream to
  192|       |                    // read this new object.
  193|    450|                    up_base_node_t types_node = up_base_node_t{ new BaseNode{NodeType::TYPES} };
  194|    450|                    if (XMLP_ret::XML_OK == (ret = parseXMLTypes(node)))
  ------------------
  |  Branch (194:25): [True: 446, False: 4]
  ------------------
  195|    446|                    {
  196|    446|                        root->addChild(std::move(types_node));
  197|    446|                    }
  198|    450|                }
  199|  8.60k|                else if (strcmp(tag, LOG) == 0)
  ------------------
  |  Branch (199:26): [True: 7.83k, False: 776]
  ------------------
  200|  7.83k|                {
  201|       |                    // TODO Workaround to propagate the return code upstream. A refactor is needed to propagate the
  202|       |                    // return code in some other more sensible way or populate the object and change code upstream to
  203|       |                    // read this new object.
  204|  7.83k|                    up_base_node_t log_node = up_base_node_t{ new BaseNode{NodeType::LOG} };
  205|  7.83k|                    if (XMLP_ret::XML_OK == (ret = parseLogConfig(node)))
  ------------------
  |  Branch (205:25): [True: 7.81k, False: 15]
  ------------------
  206|  7.81k|                    {
  207|  7.81k|                        root->addChild(std::move(log_node));
  208|  7.81k|                    }
  209|  7.83k|                }
  210|    776|                else
  211|    776|                {
  212|    776|                    EPROSIMA_LOG_ERROR(XMLPARSER, "Not expected tag: '" << tag << "'");
  ------------------
  |  |   45|    776|#define EPROSIMA_LOG_ERROR(cat, msg) EPROSIMA_LOG_ERROR_IMPL_(cat, msg)
  |  |  ------------------
  |  |  |  |  291|    776|    do {                                                                                                               \
  |  |  |  |  292|    776|        std::stringstream fastdds_log_ss_tmp__;                                                                        \
  |  |  |  |  293|    776|        fastdds_log_ss_tmp__ << msg;                                                                                   \
  |  |  |  |  294|    776|        eprosima::fastdds::dds::Log::QueueLog(                                                                         \
  |  |  |  |  295|    776|            fastdds_log_ss_tmp__.str(), eprosima::fastdds::dds::Log::Context{__FILE__, __LINE__, __func__, #cat},      \
  |  |  |  |  296|    776|            eprosima::fastdds::dds::Log::Kind::Error);                                                                 \
  |  |  |  |  297|    776|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (297:14): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  213|    776|                    ret = XMLP_ret::XML_ERROR;
  214|    776|                }
  215|  25.7k|            }
  216|       |
  217|  25.7k|            node = node->NextSiblingElement();
  218|  25.7k|        }
  219|  4.78k|    }
  220|  19.9k|    return ret;
  221|  19.9k|}
_ZN8eprosima7fastdds9xmlparser9XMLParser22parseXMLTransportsProfEPN8tinyxml210XMLElementE:
  235|    233|{
  236|       |    /*
  237|       |        <xs:complexType name="TransportDescriptorListType">
  238|       |            <xs:sequence>
  239|       |                <xs:element name="transport_descriptor" type="rtpsTransportDescriptorType"/>
  240|       |            </xs:sequence>
  241|       |        </xs:complexType>
  242|       |     */
  243|       |
  244|    233|    XMLP_ret ret = XMLP_ret::XML_OK;
  245|    233|    tinyxml2::XMLElement* p_element = p_root->FirstChildElement(TRANSPORT_DESCRIPTOR);
  246|    233|    while (p_element != nullptr)
  ------------------
  |  Branch (246:12): [True: 0, False: 233]
  ------------------
  247|      0|    {
  248|      0|        ret = parseXMLTransportData(p_element);
  249|      0|        if (ret != XMLP_ret::XML_OK)
  ------------------
  |  Branch (249:13): [True: 0, False: 0]
  ------------------
  250|      0|        {
  251|      0|            EPROSIMA_LOG_ERROR(XMLPARSER, "Error parsing transports");
  ------------------
  |  |   45|      0|#define EPROSIMA_LOG_ERROR(cat, msg) EPROSIMA_LOG_ERROR_IMPL_(cat, msg)
  |  |  ------------------
  |  |  |  |  291|      0|    do {                                                                                                               \
  |  |  |  |  292|      0|        std::stringstream fastdds_log_ss_tmp__;                                                                        \
  |  |  |  |  293|      0|        fastdds_log_ss_tmp__ << msg;                                                                                   \
  |  |  |  |  294|      0|        eprosima::fastdds::dds::Log::QueueLog(                                                                         \
  |  |  |  |  295|      0|            fastdds_log_ss_tmp__.str(), eprosima::fastdds::dds::Log::Context{__FILE__, __LINE__, __func__, #cat},      \
  |  |  |  |  296|      0|            eprosima::fastdds::dds::Log::Kind::Error);                                                                 \
  |  |  |  |  297|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (297:14): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  252|      0|            return ret;
  253|      0|        }
  254|      0|        p_element = p_element->NextSiblingElement(TRANSPORT_DESCRIPTOR);
  255|      0|    }
  256|    233|    return ret;
  257|    233|}
_ZN8eprosima7fastdds9xmlparser9XMLParser23parseXMLLibrarySettingsEPN8tinyxml210XMLElementE:
 1531|     69|{
 1532|       |    /*
 1533|       |        <xs:complexType name="LibrarySettingsType">
 1534|       |            <xs:all minOccurs="0">
 1535|       |                <xs:element name="intraprocess_delivery" type="IntraprocessDeliveryType"/>
 1536|       |            </xs:all>
 1537|       |        </xs:complexType>
 1538|       |     */
 1539|       |
 1540|     69|    XMLP_ret ret = XMLP_ret::XML_OK;
 1541|     69|    std::string sId = "";
 1542|       |
 1543|     69|    uint8_t ident = 1;
 1544|     69|    tinyxml2::XMLElement* p_aux0 = nullptr;
 1545|     69|    p_aux0 = p_root->FirstChildElement(INTRAPROCESS_DELIVERY);
 1546|     69|    if (nullptr == p_aux0)
  ------------------
  |  Branch (1546:9): [True: 69, False: 0]
  ------------------
 1547|     69|    {
 1548|     69|        EPROSIMA_LOG_ERROR(XMLPARSER, "Not found '" << INTRAPROCESS_DELIVERY << "' attribute");
  ------------------
  |  |   45|     69|#define EPROSIMA_LOG_ERROR(cat, msg) EPROSIMA_LOG_ERROR_IMPL_(cat, msg)
  |  |  ------------------
  |  |  |  |  291|     69|    do {                                                                                                               \
  |  |  |  |  292|     69|        std::stringstream fastdds_log_ss_tmp__;                                                                        \
  |  |  |  |  293|     69|        fastdds_log_ss_tmp__ << msg;                                                                                   \
  |  |  |  |  294|     69|        eprosima::fastdds::dds::Log::QueueLog(                                                                         \
  |  |  |  |  295|     69|            fastdds_log_ss_tmp__.str(), eprosima::fastdds::dds::Log::Context{__FILE__, __LINE__, __func__, #cat},      \
  |  |  |  |  296|     69|            eprosima::fastdds::dds::Log::Kind::Error);                                                                 \
  |  |  |  |  297|     69|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (297:14): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1549|     69|        return XMLP_ret::XML_ERROR;
 1550|     69|    }
 1551|      0|    else
 1552|      0|    {
 1553|      0|        fastdds::LibrarySettings library_settings;
 1554|      0|        if (XMLP_ret::XML_OK != getXMLEnum(p_aux0, &library_settings.intraprocess_delivery, ident))
  ------------------
  |  Branch (1554:13): [True: 0, False: 0]
  ------------------
 1555|      0|        {
 1556|      0|            return XMLP_ret::XML_ERROR;
 1557|      0|        }
 1558|       |
 1559|      0|        XMLProfileManager::library_settings(library_settings);
 1560|      0|    }
 1561|       |
 1562|      0|    return ret;
 1563|     69|}
_ZN8eprosima7fastdds9xmlparser9XMLParser36parseXMLDomainParticipantFactoryProfEPN8tinyxml210XMLElementERNS1_8BaseNodeE:
 1568|  12.8k|{
 1569|  12.8k|    XMLP_ret ret = XMLP_ret::XML_OK;
 1570|  12.8k|    up_participantfactory_t factory_qos{new fastdds::dds::DomainParticipantFactoryQos};
 1571|  12.8k|    up_node_participantfactory_t factory_node{new node_participantfactory_t{NodeType::DOMAINPARTICIPANT_FACTORY,
 1572|  12.8k|                                                                            std::move(factory_qos)}};
 1573|  12.8k|    if (XMLP_ret::XML_OK == fillDataNode(p_root, *factory_node))
  ------------------
  |  Branch (1573:9): [True: 9.92k, False: 2.92k]
  ------------------
 1574|  9.92k|    {
 1575|  9.92k|        rootNode.addChild(std::move(factory_node));
 1576|  9.92k|    }
 1577|  2.92k|    else
 1578|  2.92k|    {
 1579|  2.92k|        EPROSIMA_LOG_ERROR(XMLPARSER, "Error parsing participant profile");
  ------------------
  |  |   45|  2.92k|#define EPROSIMA_LOG_ERROR(cat, msg) EPROSIMA_LOG_ERROR_IMPL_(cat, msg)
  |  |  ------------------
  |  |  |  |  291|  2.92k|    do {                                                                                                               \
  |  |  |  |  292|  2.92k|        std::stringstream fastdds_log_ss_tmp__;                                                                        \
  |  |  |  |  293|  2.92k|        fastdds_log_ss_tmp__ << msg;                                                                                   \
  |  |  |  |  294|  2.92k|        eprosima::fastdds::dds::Log::QueueLog(                                                                         \
  |  |  |  |  295|  2.92k|            fastdds_log_ss_tmp__.str(), eprosima::fastdds::dds::Log::Context{__FILE__, __LINE__, __func__, #cat},      \
  |  |  |  |  296|  2.92k|            eprosima::fastdds::dds::Log::Kind::Error);                                                                 \
  |  |  |  |  297|  2.92k|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (297:14): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1580|  2.92k|        ret = XMLP_ret::XML_ERROR;
 1581|  2.92k|    }
 1582|       |
 1583|  12.8k|    return ret;
 1584|  12.8k|}
_ZN8eprosima7fastdds9xmlparser9XMLParser23parseXMLParticipantProfEPN8tinyxml210XMLElementERNS1_8BaseNodeE:
 1589|   105k|{
 1590|   105k|    XMLP_ret ret = XMLP_ret::XML_OK;
 1591|   105k|    up_participant_t participant_atts{new fastdds::xmlparser::ParticipantAttributes};
 1592|   105k|    up_node_participant_t participant_node{new node_participant_t{NodeType::PARTICIPANT, std::move(participant_atts)}};
 1593|   105k|    if (XMLP_ret::XML_OK == fillDataNode(p_root, *participant_node))
  ------------------
  |  Branch (1593:9): [True: 45.0k, False: 60.1k]
  ------------------
 1594|  45.0k|    {
 1595|  45.0k|        rootNode.addChild(std::move(participant_node));
 1596|  45.0k|    }
 1597|  60.1k|    else
 1598|  60.1k|    {
 1599|  60.1k|        EPROSIMA_LOG_ERROR(XMLPARSER, "Error parsing participant profile");
  ------------------
  |  |   45|  60.1k|#define EPROSIMA_LOG_ERROR(cat, msg) EPROSIMA_LOG_ERROR_IMPL_(cat, msg)
  |  |  ------------------
  |  |  |  |  291|  60.1k|    do {                                                                                                               \
  |  |  |  |  292|  60.1k|        std::stringstream fastdds_log_ss_tmp__;                                                                        \
  |  |  |  |  293|  60.1k|        fastdds_log_ss_tmp__ << msg;                                                                                   \
  |  |  |  |  294|  60.1k|        eprosima::fastdds::dds::Log::QueueLog(                                                                         \
  |  |  |  |  295|  60.1k|            fastdds_log_ss_tmp__.str(), eprosima::fastdds::dds::Log::Context{__FILE__, __LINE__, __func__, #cat},      \
  |  |  |  |  296|  60.1k|            eprosima::fastdds::dds::Log::Kind::Error);                                                                 \
  |  |  |  |  297|  60.1k|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (297:14): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1600|  60.1k|        ret = XMLP_ret::XML_ERROR;
 1601|  60.1k|    }
 1602|       |
 1603|   105k|    return ret;
 1604|   105k|}
_ZN8eprosima7fastdds9xmlparser9XMLParser21parseXMLPublisherProfEPN8tinyxml210XMLElementERNS1_8BaseNodeE:
 1609|  35.3k|{
 1610|  35.3k|    XMLP_ret ret = XMLP_ret::XML_OK;
 1611|  35.3k|    up_publisher_t publisher_atts{new fastdds::xmlparser::PublisherAttributes};
 1612|  35.3k|    up_node_publisher_t publisher_node{new node_publisher_t{NodeType::PUBLISHER, std::move(publisher_atts)}};
 1613|  35.3k|    if (XMLP_ret::XML_OK == fillDataNode(p_root, *publisher_node))
  ------------------
  |  Branch (1613:9): [True: 20.8k, False: 14.4k]
  ------------------
 1614|  20.8k|    {
 1615|  20.8k|        rootNode.addChild(std::move(publisher_node));
 1616|  20.8k|    }
 1617|  14.4k|    else
 1618|  14.4k|    {
 1619|  14.4k|        EPROSIMA_LOG_ERROR(XMLPARSER, "Error parsing publisher profile");
  ------------------
  |  |   45|  14.4k|#define EPROSIMA_LOG_ERROR(cat, msg) EPROSIMA_LOG_ERROR_IMPL_(cat, msg)
  |  |  ------------------
  |  |  |  |  291|  14.4k|    do {                                                                                                               \
  |  |  |  |  292|  14.4k|        std::stringstream fastdds_log_ss_tmp__;                                                                        \
  |  |  |  |  293|  14.4k|        fastdds_log_ss_tmp__ << msg;                                                                                   \
  |  |  |  |  294|  14.4k|        eprosima::fastdds::dds::Log::QueueLog(                                                                         \
  |  |  |  |  295|  14.4k|            fastdds_log_ss_tmp__.str(), eprosima::fastdds::dds::Log::Context{__FILE__, __LINE__, __func__, #cat},      \
  |  |  |  |  296|  14.4k|            eprosima::fastdds::dds::Log::Kind::Error);                                                                 \
  |  |  |  |  297|  14.4k|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (297:14): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1620|  14.4k|        ret = XMLP_ret::XML_ERROR;
 1621|  14.4k|    }
 1622|  35.3k|    return ret;
 1623|  35.3k|}
_ZN8eprosima7fastdds9xmlparser9XMLParser22parseXMLSubscriberProfEPN8tinyxml210XMLElementERNS1_8BaseNodeE:
 1628|  81.6k|{
 1629|  81.6k|    XMLP_ret ret = XMLP_ret::XML_OK;
 1630|  81.6k|    up_subscriber_t subscriber_atts{new fastdds::xmlparser::SubscriberAttributes};
 1631|  81.6k|    up_node_subscriber_t subscriber_node{new node_subscriber_t{NodeType::SUBSCRIBER, std::move(subscriber_atts)}};
 1632|  81.6k|    if (XMLP_ret::XML_OK == fillDataNode(p_root, *subscriber_node))
  ------------------
  |  Branch (1632:9): [True: 68.2k, False: 13.4k]
  ------------------
 1633|  68.2k|    {
 1634|  68.2k|        rootNode.addChild(std::move(subscriber_node));
 1635|  68.2k|    }
 1636|  13.4k|    else
 1637|  13.4k|    {
 1638|  13.4k|        EPROSIMA_LOG_ERROR(XMLPARSER, "Error parsing subscriber profile");
  ------------------
  |  |   45|  13.4k|#define EPROSIMA_LOG_ERROR(cat, msg) EPROSIMA_LOG_ERROR_IMPL_(cat, msg)
  |  |  ------------------
  |  |  |  |  291|  13.4k|    do {                                                                                                               \
  |  |  |  |  292|  13.4k|        std::stringstream fastdds_log_ss_tmp__;                                                                        \
  |  |  |  |  293|  13.4k|        fastdds_log_ss_tmp__ << msg;                                                                                   \
  |  |  |  |  294|  13.4k|        eprosima::fastdds::dds::Log::QueueLog(                                                                         \
  |  |  |  |  295|  13.4k|            fastdds_log_ss_tmp__.str(), eprosima::fastdds::dds::Log::Context{__FILE__, __LINE__, __func__, #cat},      \
  |  |  |  |  296|  13.4k|            eprosima::fastdds::dds::Log::Kind::Error);                                                                 \
  |  |  |  |  297|  13.4k|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (297:14): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1639|  13.4k|        ret = XMLP_ret::XML_ERROR;
 1640|  13.4k|    }
 1641|  81.6k|    return ret;
 1642|  81.6k|}
_ZN8eprosima7fastdds9xmlparser9XMLParser17parseXMLTopicDataEPN8tinyxml210XMLElementERNS1_8BaseNodeE:
 1647|  23.9k|{
 1648|  23.9k|    XMLP_ret ret = XMLP_ret::XML_OK;
 1649|  23.9k|    up_topic_t topic_atts{new TopicAttributes};
 1650|  23.9k|    up_node_topic_t topic_node{new node_topic_t{NodeType::TOPIC, std::move(topic_atts)}};
 1651|  23.9k|    if (XMLP_ret::XML_OK == fillDataNode(p_root, *topic_node))
  ------------------
  |  Branch (1651:9): [True: 20.1k, False: 3.77k]
  ------------------
 1652|  20.1k|    {
 1653|  20.1k|        rootNode.addChild(std::move(topic_node));
 1654|  20.1k|    }
 1655|  3.77k|    else
 1656|  3.77k|    {
 1657|  3.77k|        EPROSIMA_LOG_ERROR(XMLPARSER, "Error parsing topic data node");
  ------------------
  |  |   45|  3.77k|#define EPROSIMA_LOG_ERROR(cat, msg) EPROSIMA_LOG_ERROR_IMPL_(cat, msg)
  |  |  ------------------
  |  |  |  |  291|  3.77k|    do {                                                                                                               \
  |  |  |  |  292|  3.77k|        std::stringstream fastdds_log_ss_tmp__;                                                                        \
  |  |  |  |  293|  3.77k|        fastdds_log_ss_tmp__ << msg;                                                                                   \
  |  |  |  |  294|  3.77k|        eprosima::fastdds::dds::Log::QueueLog(                                                                         \
  |  |  |  |  295|  3.77k|            fastdds_log_ss_tmp__.str(), eprosima::fastdds::dds::Log::Context{__FILE__, __LINE__, __func__, #cat},      \
  |  |  |  |  296|  3.77k|            eprosima::fastdds::dds::Log::Kind::Error);                                                                 \
  |  |  |  |  297|  3.77k|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (297:14): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1658|  3.77k|        ret = XMLP_ret::XML_ERROR;
 1659|  3.77k|    }
 1660|  23.9k|    return ret;
 1661|  23.9k|}
_ZN8eprosima7fastdds9xmlparser9XMLParser21parseXMLRequesterProfEPN8tinyxml210XMLElementERNS1_8BaseNodeE:
 1666|  12.8k|{
 1667|  12.8k|    XMLP_ret ret = XMLP_ret::XML_OK;
 1668|  12.8k|    up_requester_t requester_atts{new fastdds::xmlparser::RequesterAttributes};
 1669|  12.8k|    up_node_requester_t requester_node{new node_requester_t{NodeType::REQUESTER, std::move(requester_atts)}};
 1670|  12.8k|    if (XMLP_ret::XML_OK == fillDataNode(p_root, *requester_node))
  ------------------
  |  Branch (1670:9): [True: 7.93k, False: 4.91k]
  ------------------
 1671|  7.93k|    {
 1672|  7.93k|        rootNode.addChild(std::move(requester_node));
 1673|  7.93k|    }
 1674|  4.91k|    else
 1675|  4.91k|    {
 1676|  4.91k|        EPROSIMA_LOG_ERROR(XMLPARSER, "Error parsing requester profile");
  ------------------
  |  |   45|  4.91k|#define EPROSIMA_LOG_ERROR(cat, msg) EPROSIMA_LOG_ERROR_IMPL_(cat, msg)
  |  |  ------------------
  |  |  |  |  291|  4.91k|    do {                                                                                                               \
  |  |  |  |  292|  4.91k|        std::stringstream fastdds_log_ss_tmp__;                                                                        \
  |  |  |  |  293|  4.91k|        fastdds_log_ss_tmp__ << msg;                                                                                   \
  |  |  |  |  294|  4.91k|        eprosima::fastdds::dds::Log::QueueLog(                                                                         \
  |  |  |  |  295|  4.91k|            fastdds_log_ss_tmp__.str(), eprosima::fastdds::dds::Log::Context{__FILE__, __LINE__, __func__, #cat},      \
  |  |  |  |  296|  4.91k|            eprosima::fastdds::dds::Log::Kind::Error);                                                                 \
  |  |  |  |  297|  4.91k|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (297:14): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1677|  4.91k|        ret = XMLP_ret::XML_ERROR;
 1678|  4.91k|    }
 1679|  12.8k|    return ret;
 1680|  12.8k|}
_ZN8eprosima7fastdds9xmlparser9XMLParser19parseXMLReplierProfEPN8tinyxml210XMLElementERNS1_8BaseNodeE:
 1685|  15.4k|{
 1686|  15.4k|    XMLP_ret ret = XMLP_ret::XML_OK;
 1687|  15.4k|    up_replier_t replier_atts{new fastdds::xmlparser::ReplierAttributes};
 1688|  15.4k|    up_node_replier_t replier_node{new node_replier_t{NodeType::REPLIER, std::move(replier_atts)}};
 1689|  15.4k|    if (XMLP_ret::XML_OK == fillDataNode(p_root, *replier_node))
  ------------------
  |  Branch (1689:9): [True: 7.32k, False: 8.17k]
  ------------------
 1690|  7.32k|    {
 1691|  7.32k|        rootNode.addChild(std::move(replier_node));
 1692|  7.32k|    }
 1693|  8.17k|    else
 1694|  8.17k|    {
 1695|  8.17k|        EPROSIMA_LOG_ERROR(XMLPARSER, "Error parsing replier profile");
  ------------------
  |  |   45|  8.17k|#define EPROSIMA_LOG_ERROR(cat, msg) EPROSIMA_LOG_ERROR_IMPL_(cat, msg)
  |  |  ------------------
  |  |  |  |  291|  8.17k|    do {                                                                                                               \
  |  |  |  |  292|  8.17k|        std::stringstream fastdds_log_ss_tmp__;                                                                        \
  |  |  |  |  293|  8.17k|        fastdds_log_ss_tmp__ << msg;                                                                                   \
  |  |  |  |  294|  8.17k|        eprosima::fastdds::dds::Log::QueueLog(                                                                         \
  |  |  |  |  295|  8.17k|            fastdds_log_ss_tmp__.str(), eprosima::fastdds::dds::Log::Context{__FILE__, __LINE__, __func__, #cat},      \
  |  |  |  |  296|  8.17k|            eprosima::fastdds::dds::Log::Kind::Error);                                                                 \
  |  |  |  |  297|  8.17k|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (297:14): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1696|  8.17k|        ret = XMLP_ret::XML_ERROR;
 1697|  8.17k|    }
 1698|  15.4k|    return ret;
 1699|  15.4k|}
_ZN8eprosima7fastdds9xmlparser9XMLParser13parseProfilesEPN8tinyxml210XMLElementERNS1_8BaseNodeE:
 1704|  14.5k|{
 1705|       |    /*
 1706|       |        <xs:element name="profiles">
 1707|       |            <xs:complexType>
 1708|       |                <xs:sequence>
 1709|       |                    <xs:element name="library_settings" type="LibrarySettingsType" minOccurs="0" maxOccurs="unbounded"/>
 1710|       |                    <xs:element name="transport_descriptors" type="TransportDescriptorListType" minOccurs="0" maxOccurs="unbounded"/>
 1711|       |                    <xs:element name="participant" type="participantProfileType" minOccurs="0" maxOccurs="unbounded"/>
 1712|       |                    <xs:element name="publisher" type="publisherProfileType" minOccurs="0" maxOccurs="unbounded"/>
 1713|       |                    <xs:element name="subscriber" type="subscriberProfileType" minOccurs="0" maxOccurs="unbounded"/>
 1714|       |                    <xs:element name="topic" type="topicAttributesType" minOccurs="0" maxOccurs="unbounded"/>
 1715|       |                </xs:sequence>
 1716|       |            </xs:complexType>
 1717|       |        </xs:element>
 1718|       |     */
 1719|       |
 1720|  14.5k|    tinyxml2::XMLElement* p_profile = p_root->FirstChildElement();
 1721|  14.5k|    const char* tag = nullptr;
 1722|  14.5k|    bool parseOk = true;
 1723|  14.5k|    XMLP_ret ret = XMLP_ret::XML_OK;
 1724|   460k|    while (nullptr != p_profile)
  ------------------
  |  Branch (1724:12): [True: 445k, False: 14.5k]
  ------------------
 1725|   445k|    {
 1726|   445k|        if (nullptr != (tag = p_profile->Value()))
  ------------------
  |  Branch (1726:13): [True: 445k, False: 0]
  ------------------
 1727|   445k|        {
 1728|       |            // If profile parsing functions fails, log and continue.
 1729|   445k|            if (strcmp(tag, TRANSPORT_DESCRIPTORS) == 0)
  ------------------
  |  Branch (1729:17): [True: 233, False: 445k]
  ------------------
 1730|    233|            {
 1731|    233|                parseOk &= parseXMLTransportsProf(p_profile) == XMLP_ret::XML_OK;
 1732|    233|            }
 1733|   445k|            else if (strcmp(tag, LIBRARY_SETTINGS) == 0)
  ------------------
  |  Branch (1733:22): [True: 65, False: 445k]
  ------------------
 1734|     65|            {
 1735|     65|                parseOk &= parseXMLLibrarySettings(p_profile) == XMLP_ret::XML_OK;
 1736|     65|            }
 1737|   445k|            else if (strcmp(tag, DOMAINPARTICIPANT_FACTORY) == 0)
  ------------------
  |  Branch (1737:22): [True: 12.5k, False: 432k]
  ------------------
 1738|  12.5k|            {
 1739|  12.5k|                parseOk &= parseXMLDomainParticipantFactoryProf(p_profile, profilesNode) == XMLP_ret::XML_OK;
 1740|  12.5k|            }
 1741|   432k|            else if (strcmp(tag, PARTICIPANT) == 0)
  ------------------
  |  Branch (1741:22): [True: 104k, False: 327k]
  ------------------
 1742|   104k|            {
 1743|   104k|                parseOk &= parseXMLParticipantProf(p_profile, profilesNode) == XMLP_ret::XML_OK;
 1744|   104k|            }
 1745|   327k|            else if (strcmp(tag, PUBLISHER) == 0 || strcmp(tag, DATA_WRITER) == 0)
  ------------------
  |  Branch (1745:22): [True: 20.8k, False: 306k]
  |  Branch (1745:53): [True: 9.23k, False: 297k]
  ------------------
 1746|  30.0k|            {
 1747|  30.0k|                parseOk &= parseXMLPublisherProf(p_profile, profilesNode) == XMLP_ret::XML_OK;
 1748|  30.0k|            }
 1749|   297k|            else if (strcmp(tag, SUBSCRIBER) == 0 || strcmp(tag, DATA_READER) == 0)
  ------------------
  |  Branch (1749:22): [True: 23.2k, False: 274k]
  |  Branch (1749:54): [True: 50.8k, False: 223k]
  ------------------
 1750|  74.0k|            {
 1751|  74.0k|                parseOk &= parseXMLSubscriberProf(p_profile, profilesNode) == XMLP_ret::XML_OK;
 1752|  74.0k|            }
 1753|   223k|            else if (strcmp(tag, TOPIC) == 0)
  ------------------
  |  Branch (1753:22): [True: 22.6k, False: 200k]
  ------------------
 1754|  22.6k|            {
 1755|  22.6k|                parseOk &= parseXMLTopicData(p_profile, profilesNode) == XMLP_ret::XML_OK;
 1756|  22.6k|            }
 1757|   200k|            else if (strcmp(tag, TYPES) == 0)
  ------------------
  |  Branch (1757:22): [True: 126k, False: 74.2k]
  ------------------
 1758|   126k|            {
 1759|   126k|                parseOk &= parseXMLTypes(p_profile) == XMLP_ret::XML_OK;
 1760|   126k|            }
 1761|  74.2k|            else if (strcmp(tag, REQUESTER) == 0)
  ------------------
  |  Branch (1761:22): [True: 12.5k, False: 61.6k]
  ------------------
 1762|  12.5k|            {
 1763|  12.5k|                parseOk &= parseXMLRequesterProf(p_profile, profilesNode) == XMLP_ret::XML_OK;
 1764|  12.5k|            }
 1765|  61.6k|            else if (strcmp(tag, REPLIER) == 0)
  ------------------
  |  Branch (1765:22): [True: 15.1k, False: 46.4k]
  ------------------
 1766|  15.1k|            {
 1767|  15.1k|                parseOk &= parseXMLReplierProf(p_profile, profilesNode) == XMLP_ret::XML_OK;
 1768|  15.1k|            }
 1769|  46.4k|            else if (strcmp(tag, QOS_PROFILE) == 0)
  ------------------
  |  Branch (1769:22): [True: 956, False: 45.5k]
  ------------------
 1770|    956|            {
 1771|    956|                EPROSIMA_LOG_ERROR(XMLPARSER, "Field 'QOS_PROFILE' do not supported for now");
  ------------------
  |  |   45|    956|#define EPROSIMA_LOG_ERROR(cat, msg) EPROSIMA_LOG_ERROR_IMPL_(cat, msg)
  |  |  ------------------
  |  |  |  |  291|    956|    do {                                                                                                               \
  |  |  |  |  292|    956|        std::stringstream fastdds_log_ss_tmp__;                                                                        \
  |  |  |  |  293|    956|        fastdds_log_ss_tmp__ << msg;                                                                                   \
  |  |  |  |  294|    956|        eprosima::fastdds::dds::Log::QueueLog(                                                                         \
  |  |  |  |  295|    956|            fastdds_log_ss_tmp__.str(), eprosima::fastdds::dds::Log::Context{__FILE__, __LINE__, __func__, #cat},      \
  |  |  |  |  296|    956|            eprosima::fastdds::dds::Log::Kind::Error);                                                                 \
  |  |  |  |  297|    956|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (297:14): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1772|    956|            }
 1773|  45.5k|            else if (strcmp(tag, APPLICATION) == 0)
  ------------------
  |  Branch (1773:22): [True: 643, False: 44.8k]
  ------------------
 1774|    643|            {
 1775|    643|                EPROSIMA_LOG_ERROR(XMLPARSER, "Field 'APPLICATION' do not supported for now");
  ------------------
  |  |   45|    643|#define EPROSIMA_LOG_ERROR(cat, msg) EPROSIMA_LOG_ERROR_IMPL_(cat, msg)
  |  |  ------------------
  |  |  |  |  291|    643|    do {                                                                                                               \
  |  |  |  |  292|    643|        std::stringstream fastdds_log_ss_tmp__;                                                                        \
  |  |  |  |  293|    643|        fastdds_log_ss_tmp__ << msg;                                                                                   \
  |  |  |  |  294|    643|        eprosima::fastdds::dds::Log::QueueLog(                                                                         \
  |  |  |  |  295|    643|            fastdds_log_ss_tmp__.str(), eprosima::fastdds::dds::Log::Context{__FILE__, __LINE__, __func__, #cat},      \
  |  |  |  |  296|    643|            eprosima::fastdds::dds::Log::Kind::Error);                                                                 \
  |  |  |  |  297|    643|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (297:14): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1776|    643|            }
 1777|  44.8k|            else if (strcmp(tag, TYPE) == 0)
  ------------------
  |  Branch (1777:22): [True: 856, False: 44.0k]
  ------------------
 1778|    856|            {
 1779|    856|                EPROSIMA_LOG_ERROR(XMLPARSER, "Field 'TYPE' do not supported for now");
  ------------------
  |  |   45|    856|#define EPROSIMA_LOG_ERROR(cat, msg) EPROSIMA_LOG_ERROR_IMPL_(cat, msg)
  |  |  ------------------
  |  |  |  |  291|    856|    do {                                                                                                               \
  |  |  |  |  292|    856|        std::stringstream fastdds_log_ss_tmp__;                                                                        \
  |  |  |  |  293|    856|        fastdds_log_ss_tmp__ << msg;                                                                                   \
  |  |  |  |  294|    856|        eprosima::fastdds::dds::Log::QueueLog(                                                                         \
  |  |  |  |  295|    856|            fastdds_log_ss_tmp__.str(), eprosima::fastdds::dds::Log::Context{__FILE__, __LINE__, __func__, #cat},      \
  |  |  |  |  296|    856|            eprosima::fastdds::dds::Log::Kind::Error);                                                                 \
  |  |  |  |  297|    856|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (297:14): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1780|    856|            }
 1781|  44.0k|            else
 1782|  44.0k|            {
 1783|  44.0k|                parseOk = false;
 1784|  44.0k|                EPROSIMA_LOG_ERROR(XMLPARSER, "Not expected tag: '" << tag << "'");
  ------------------
  |  |   45|  44.0k|#define EPROSIMA_LOG_ERROR(cat, msg) EPROSIMA_LOG_ERROR_IMPL_(cat, msg)
  |  |  ------------------
  |  |  |  |  291|  44.0k|    do {                                                                                                               \
  |  |  |  |  292|  44.0k|        std::stringstream fastdds_log_ss_tmp__;                                                                        \
  |  |  |  |  293|  44.0k|        fastdds_log_ss_tmp__ << msg;                                                                                   \
  |  |  |  |  294|  44.0k|        eprosima::fastdds::dds::Log::QueueLog(                                                                         \
  |  |  |  |  295|  44.0k|            fastdds_log_ss_tmp__.str(), eprosima::fastdds::dds::Log::Context{__FILE__, __LINE__, __func__, #cat},      \
  |  |  |  |  296|  44.0k|            eprosima::fastdds::dds::Log::Kind::Error);                                                                 \
  |  |  |  |  297|  44.0k|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (297:14): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1785|  44.0k|            }
 1786|   445k|        }
 1787|       |
 1788|   445k|        if (!parseOk)
  ------------------
  |  Branch (1788:13): [True: 362k, False: 83.2k]
  ------------------
 1789|   362k|        {
 1790|   362k|            EPROSIMA_LOG_ERROR(XMLPARSER, "Error parsing profile's tag " << tag);
  ------------------
  |  |   45|   362k|#define EPROSIMA_LOG_ERROR(cat, msg) EPROSIMA_LOG_ERROR_IMPL_(cat, msg)
  |  |  ------------------
  |  |  |  |  291|   362k|    do {                                                                                                               \
  |  |  |  |  292|   362k|        std::stringstream fastdds_log_ss_tmp__;                                                                        \
  |  |  |  |  293|   362k|        fastdds_log_ss_tmp__ << msg;                                                                                   \
  |  |  |  |  294|   362k|        eprosima::fastdds::dds::Log::QueueLog(                                                                         \
  |  |  |  |  295|   362k|            fastdds_log_ss_tmp__.str(), eprosima::fastdds::dds::Log::Context{__FILE__, __LINE__, __func__, #cat},      \
  |  |  |  |  296|   362k|            eprosima::fastdds::dds::Log::Kind::Error);                                                                 \
  |  |  |  |  297|   362k|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (297:14): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1791|   362k|            ret = XMLP_ret::XML_ERROR;
 1792|   362k|        }
 1793|   445k|        p_profile = p_profile->NextSiblingElement();
 1794|   445k|    }
 1795|  14.5k|    return ret;
 1796|  14.5k|}
_ZN8eprosima7fastdds9xmlparser9XMLParser14parseLogConfigEPN8tinyxml210XMLElementE:
 1800|  8.24k|{
 1801|       |    /*
 1802|       |        <xs:element name="log" type="logType"/>
 1803|       |        <xs:complexType name="logType">
 1804|       |            <xs:sequence minOccurs="1" maxOccurs="unbounded">
 1805|       |                <xs:choice minOccurs="1">
 1806|       |                    <xs:element name="use_default" type="booleanCaps" minOccurs="0" maxOccurs="1"/>
 1807|       |                    <xs:element name="consumer" type="logConsumerType" minOccurs="0" maxOccurs="unbounded"/>
 1808|       |                    <xs:element name="thread_settings" type="threadSettingsType" minOccurs="0" maxOccurs="1"/>
 1809|       |                </xs:choice>
 1810|       |            </xs:sequence>
 1811|       |        </xs:complexType>
 1812|       |     */
 1813|       |
 1814|       |    /*
 1815|       |     * TODO(eduponz): Uphold XSD validation in parsing
 1816|       |     *   Even though the XSD above enforces the log tag to have at least one consumer,
 1817|       |     *   the parsing allows for an empty log tag (e.g. `<log></log>`).
 1818|       |     *   This inconsistency is kept to keep a backwards compatible behaviour.
 1819|       |     *   In fact, test XMLParserTests.parseXMLNoRoot even checks that an empty log tag
 1820|       |     *   is valid.
 1821|       |     */
 1822|       |
 1823|  8.24k|    XMLP_ret ret = XMLP_ret::XML_OK;
 1824|       |
 1825|  8.24k|    tinyxml2::XMLElement* p_aux0 = p_root->FirstChildElement(LOG);
 1826|  8.24k|    if (p_aux0 == nullptr)
  ------------------
  |  Branch (1826:9): [True: 8.18k, False: 60]
  ------------------
 1827|  8.18k|    {
 1828|  8.18k|        p_aux0 = p_root;
 1829|  8.18k|    }
 1830|       |
 1831|  8.24k|    std::set<std::string> tags_present;
 1832|  8.24k|    tinyxml2::XMLElement* p_element = p_aux0->FirstChildElement();
 1833|  8.24k|    fastdds::rtps::ThreadSettings thread_settings;
 1834|  8.24k|    bool set_thread_settings = false;
 1835|       |
 1836|  9.60k|    while (ret == XMLP_ret::XML_OK && nullptr != p_element)
  ------------------
  |  Branch (1836:12): [True: 9.19k, False: 407]
  |  Branch (1836:39): [True: 1.36k, False: 7.83k]
  ------------------
 1837|  1.36k|    {
 1838|  1.36k|        const char* name = p_element->Name();
 1839|  1.36k|        const char* tag = p_element->Value();
 1840|       |
 1841|       |        // Fail on duplicated not allowed elements
 1842|  1.36k|        if (strcmp(tag, CONSUMER) != 0 && tags_present.count(name) != 0)
  ------------------
  |  Branch (1842:13): [True: 1.06k, False: 293]
  |  Branch (1842:13): [True: 1, False: 1.36k]
  |  Branch (1842:43): [True: 1, False: 1.06k]
  ------------------
 1843|      1|        {
 1844|      1|            EPROSIMA_LOG_ERROR(XMLPARSER, "Duplicated element found in 'log'. Tag: " << name);
  ------------------
  |  |   45|      1|#define EPROSIMA_LOG_ERROR(cat, msg) EPROSIMA_LOG_ERROR_IMPL_(cat, msg)
  |  |  ------------------
  |  |  |  |  291|      1|    do {                                                                                                               \
  |  |  |  |  292|      1|        std::stringstream fastdds_log_ss_tmp__;                                                                        \
  |  |  |  |  293|      1|        fastdds_log_ss_tmp__ << msg;                                                                                   \
  |  |  |  |  294|      1|        eprosima::fastdds::dds::Log::QueueLog(                                                                         \
  |  |  |  |  295|      1|            fastdds_log_ss_tmp__.str(), eprosima::fastdds::dds::Log::Context{__FILE__, __LINE__, __func__, #cat},      \
  |  |  |  |  296|      1|            eprosima::fastdds::dds::Log::Kind::Error);                                                                 \
  |  |  |  |  297|      1|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (297:14): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1845|      1|            return XMLP_ret::XML_ERROR;
 1846|      1|        }
 1847|  1.36k|        tags_present.emplace(name);
 1848|       |
 1849|  1.36k|        if (nullptr != tag)
  ------------------
  |  Branch (1849:13): [True: 1.36k, False: 0]
  ------------------
 1850|  1.36k|        {
 1851|  1.36k|            if (strcmp(tag, USE_DEFAULT) == 0)
  ------------------
  |  Branch (1851:17): [True: 3, False: 1.35k]
  ------------------
 1852|      3|            {
 1853|      3|                std::string auxBool = get_element_text(p_element);
 1854|      3|                if (auxBool.empty())
  ------------------
  |  Branch (1854:21): [True: 3, False: 0]
  ------------------
 1855|      3|                {
 1856|      3|                    EPROSIMA_LOG_ERROR(XMLPARSER, "Cannot get text from tag: '" << tag << "'");
  ------------------
  |  |   45|      3|#define EPROSIMA_LOG_ERROR(cat, msg) EPROSIMA_LOG_ERROR_IMPL_(cat, msg)
  |  |  ------------------
  |  |  |  |  291|      3|    do {                                                                                                               \
  |  |  |  |  292|      3|        std::stringstream fastdds_log_ss_tmp__;                                                                        \
  |  |  |  |  293|      3|        fastdds_log_ss_tmp__ << msg;                                                                                   \
  |  |  |  |  294|      3|        eprosima::fastdds::dds::Log::QueueLog(                                                                         \
  |  |  |  |  295|      3|            fastdds_log_ss_tmp__.str(), eprosima::fastdds::dds::Log::Context{__FILE__, __LINE__, __func__, #cat},      \
  |  |  |  |  296|      3|            eprosima::fastdds::dds::Log::Kind::Error);                                                                 \
  |  |  |  |  297|      3|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (297:14): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1857|      3|                    ret = XMLP_ret::XML_ERROR;
 1858|      3|                }
 1859|       |
 1860|      3|                if (ret == XMLP_ret::XML_OK)
  ------------------
  |  Branch (1860:21): [True: 0, False: 3]
  ------------------
 1861|      0|                {
 1862|      0|                    bool use_default = true;
 1863|      0|                    if (std::strcmp(auxBool.c_str(), "FALSE") == 0)
  ------------------
  |  Branch (1863:25): [True: 0, False: 0]
  ------------------
 1864|      0|                    {
 1865|      0|                        use_default = false;
 1866|      0|                    }
 1867|      0|                    if (!use_default)
  ------------------
  |  Branch (1867:25): [True: 0, False: 0]
  ------------------
 1868|      0|                    {
 1869|      0|                        eprosima::fastdds::dds::Log::ClearConsumers();
 1870|      0|                    }
 1871|      0|                }
 1872|      3|            }
 1873|  1.35k|            else if (strcmp(tag, CONSUMER) == 0)
  ------------------
  |  Branch (1873:22): [True: 293, False: 1.06k]
  ------------------
 1874|    293|            {
 1875|    293|                ret = parseXMLConsumer(*p_element);
 1876|    293|            }
 1877|  1.06k|            else if (strcmp(tag, THREAD_SETTINGS) == 0)
  ------------------
  |  Branch (1877:22): [True: 722, False: 343]
  ------------------
 1878|    722|            {
 1879|    722|                ret = getXMLThreadSettings(*p_element, thread_settings);
 1880|    722|                if (ret == XMLP_ret::XML_OK)
  ------------------
  |  Branch (1880:21): [True: 661, False: 61]
  ------------------
 1881|    661|                {
 1882|    661|                    set_thread_settings = true;
 1883|    661|                }
 1884|     61|                else
 1885|     61|                {
 1886|     61|                    EPROSIMA_LOG_ERROR(XMLPARSER, "Incorrect thread settings");
  ------------------
  |  |   45|     61|#define EPROSIMA_LOG_ERROR(cat, msg) EPROSIMA_LOG_ERROR_IMPL_(cat, msg)
  |  |  ------------------
  |  |  |  |  291|     61|    do {                                                                                                               \
  |  |  |  |  292|     61|        std::stringstream fastdds_log_ss_tmp__;                                                                        \
  |  |  |  |  293|     61|        fastdds_log_ss_tmp__ << msg;                                                                                   \
  |  |  |  |  294|     61|        eprosima::fastdds::dds::Log::QueueLog(                                                                         \
  |  |  |  |  295|     61|            fastdds_log_ss_tmp__.str(), eprosima::fastdds::dds::Log::Context{__FILE__, __LINE__, __func__, #cat},      \
  |  |  |  |  296|     61|            eprosima::fastdds::dds::Log::Kind::Error);                                                                 \
  |  |  |  |  297|     61|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (297:14): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1887|     61|                }
 1888|    722|            }
 1889|    343|            else
 1890|    343|            {
 1891|    343|                EPROSIMA_LOG_ERROR(XMLPARSER, "Not expected tag: '" << tag << "'");
  ------------------
  |  |   45|    343|#define EPROSIMA_LOG_ERROR(cat, msg) EPROSIMA_LOG_ERROR_IMPL_(cat, msg)
  |  |  ------------------
  |  |  |  |  291|    343|    do {                                                                                                               \
  |  |  |  |  292|    343|        std::stringstream fastdds_log_ss_tmp__;                                                                        \
  |  |  |  |  293|    343|        fastdds_log_ss_tmp__ << msg;                                                                                   \
  |  |  |  |  294|    343|        eprosima::fastdds::dds::Log::QueueLog(                                                                         \
  |  |  |  |  295|    343|            fastdds_log_ss_tmp__.str(), eprosima::fastdds::dds::Log::Context{__FILE__, __LINE__, __func__, #cat},      \
  |  |  |  |  296|    343|            eprosima::fastdds::dds::Log::Kind::Error);                                                                 \
  |  |  |  |  297|    343|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (297:14): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1892|    343|                ret = XMLP_ret::XML_ERROR;
 1893|    343|            }
 1894|  1.36k|        }
 1895|       |
 1896|  1.36k|        if (ret == XMLP_ret::XML_OK)
  ------------------
  |  Branch (1896:13): [True: 954, False: 407]
  ------------------
 1897|    954|        {
 1898|    954|            p_element = p_element->NextSiblingElement();
 1899|    954|        }
 1900|  1.36k|    }
 1901|       |
 1902|  8.24k|    if (ret == XMLP_ret::XML_OK && set_thread_settings)
  ------------------
  |  Branch (1902:9): [True: 7.83k, False: 407]
  |  Branch (1902:36): [True: 644, False: 7.19k]
  ------------------
 1903|    644|    {
 1904|    644|        fastdds::dds::Log::SetThreadConfig(thread_settings);
 1905|    644|    }
 1906|       |
 1907|  8.24k|    return ret;
 1908|  8.24k|}
_ZN8eprosima7fastdds9xmlparser9XMLParser16parseXMLConsumerERN8tinyxml210XMLElementE:
 1912|    293|{
 1913|    293|    using namespace eprosima::fastdds::dds;
 1914|       |
 1915|    293|    XMLP_ret ret = XMLP_ret::XML_OK;
 1916|    293|    tinyxml2::XMLElement* p_element = consumer.FirstChildElement(CLASS);
 1917|       |
 1918|    293|    if (p_element != nullptr)
  ------------------
  |  Branch (1918:9): [True: 0, False: 293]
  ------------------
 1919|      0|    {
 1920|      0|        std::string classStr = get_element_text(p_element);
 1921|       |
 1922|      0|        if (std::strcmp(classStr.c_str(), "StdoutConsumer") == 0)
  ------------------
  |  Branch (1922:13): [True: 0, False: 0]
  ------------------
 1923|      0|        {
 1924|      0|            Log::RegisterConsumer(std::unique_ptr<LogConsumer>(new StdoutConsumer));
 1925|      0|        }
 1926|      0|        else if (std::strcmp(classStr.c_str(), "StdoutErrConsumer") == 0)
  ------------------
  |  Branch (1926:18): [True: 0, False: 0]
  ------------------
 1927|      0|        {
 1928|       |            /* Register a StdoutErrConsumer */
 1929|       |
 1930|       |            // Get first property
 1931|      0|            tinyxml2::XMLElement* property = consumer.FirstChildElement(PROPERTY);
 1932|      0|            if (nullptr == property)
  ------------------
  |  Branch (1932:17): [True: 0, False: 0]
  ------------------
 1933|      0|            {
 1934|       |                // If no properties are specified, create the consumer with default values
 1935|      0|                Log::RegisterConsumer(std::unique_ptr<LogConsumer>(new StdoutErrConsumer));
 1936|      0|            }
 1937|      0|            else
 1938|      0|            {
 1939|       |                // Only one property is supported. Its name is `stderr_threshold`, and its value is a log kind specified
 1940|       |                // as a string in the form `Log::Kind::<Kind>`.
 1941|      0|                tinyxml2::XMLElement* p_auxName = nullptr;    // Property name
 1942|      0|                tinyxml2::XMLElement* p_auxValue = nullptr;   // Property value
 1943|      0|                uint8_t stderr_threshold_property_count = 0;  // Occurrences count. Only one is allowed
 1944|       |
 1945|       |                // Get default threshold
 1946|      0|                Log::Kind threshold = StdoutErrConsumer::STDERR_THRESHOLD_DEFAULT;
 1947|       |
 1948|       |                // Iterate over the properties
 1949|      0|                while (nullptr != property)
  ------------------
  |  Branch (1949:24): [True: 0, False: 0]
  ------------------
 1950|      0|                {
 1951|      0|                    if (nullptr != (p_auxName = property->FirstChildElement(NAME)))
  ------------------
  |  Branch (1951:25): [True: 0, False: 0]
  ------------------
 1952|      0|                    {
 1953|       |                        // Get property name
 1954|      0|                        std::string s = get_element_text(p_auxName);
 1955|       |
 1956|      0|                        if (std::strcmp(s.c_str(), "stderr_threshold") == 0)
  ------------------
  |  Branch (1956:29): [True: 0, False: 0]
  ------------------
 1957|      0|                        {
 1958|       |                            /* Property is a `stderr_threshold` */
 1959|       |
 1960|       |                            // Update occurrence count and check how many encountered. Only the first one applies, the
 1961|       |                            // rest are ignored.
 1962|      0|                            stderr_threshold_property_count++;
 1963|      0|                            if (stderr_threshold_property_count > 1)
  ------------------
  |  Branch (1963:33): [True: 0, False: 0]
  ------------------
 1964|      0|                            {
 1965|       |                                // Continue with the next property if `stderr_threshold` had been already specified.
 1966|      0|                                EPROSIMA_LOG_ERROR(XMLParser, classStr << " only supports one occurrence of 'stderr_threshold'."
  ------------------
  |  |   45|      0|#define EPROSIMA_LOG_ERROR(cat, msg) EPROSIMA_LOG_ERROR_IMPL_(cat, msg)
  |  |  ------------------
  |  |  |  |  291|      0|    do {                                                                                                               \
  |  |  |  |  292|      0|        std::stringstream fastdds_log_ss_tmp__;                                                                        \
  |  |  |  |  293|      0|        fastdds_log_ss_tmp__ << msg;                                                                                   \
  |  |  |  |  294|      0|        eprosima::fastdds::dds::Log::QueueLog(                                                                         \
  |  |  |  |  295|      0|            fastdds_log_ss_tmp__.str(), eprosima::fastdds::dds::Log::Context{__FILE__, __LINE__, __func__, #cat},      \
  |  |  |  |  296|      0|            eprosima::fastdds::dds::Log::Kind::Error);                                                                 \
  |  |  |  |  297|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (297:14): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1967|      0|                                                                       << " Only the first one is applied.");
 1968|      0|                                property = property->NextSiblingElement(PROPERTY);
 1969|      0|                                ret = XMLP_ret::XML_NOK;
 1970|      0|                                continue;
 1971|      0|                            }
 1972|       |
 1973|       |                            // Get the property value. It should be a Log::Kind.
 1974|      0|                            if (nullptr != (p_auxValue = property->FirstChildElement(VALUE)))
  ------------------
  |  Branch (1974:33): [True: 0, False: 0]
  ------------------
 1975|      0|                            {
 1976|       |                                // Get property value and use it to set the threshold.
 1977|      0|                                std::string threshold_str = get_element_text(p_auxValue);
 1978|      0|                                if (std::strcmp(threshold_str.c_str(), "Log::Kind::Error") == 0)
  ------------------
  |  Branch (1978:37): [True: 0, False: 0]
  ------------------
 1979|      0|                                {
 1980|      0|                                    threshold = Log::Kind::Error;
 1981|      0|                                }
 1982|      0|                                else if (std::strcmp(threshold_str.c_str(), "Log::Kind::Warning") == 0)
  ------------------
  |  Branch (1982:42): [True: 0, False: 0]
  ------------------
 1983|      0|                                {
 1984|      0|                                    threshold = Log::Kind::Warning;
 1985|      0|                                }
 1986|      0|                                else if (std::strcmp(threshold_str.c_str(), "Log::Kind::Info") == 0)
  ------------------
  |  Branch (1986:42): [True: 0, False: 0]
  ------------------
 1987|      0|                                {
 1988|      0|                                    threshold = Log::Kind::Info;
 1989|      0|                                }
 1990|      0|                                else
 1991|      0|                                {
 1992|      0|                                    EPROSIMA_LOG_ERROR(XMLParser, "Unkown Log::Kind '" << threshold_str
  ------------------
  |  |   45|      0|#define EPROSIMA_LOG_ERROR(cat, msg) EPROSIMA_LOG_ERROR_IMPL_(cat, msg)
  |  |  ------------------
  |  |  |  |  291|      0|    do {                                                                                                               \
  |  |  |  |  292|      0|        std::stringstream fastdds_log_ss_tmp__;                                                                        \
  |  |  |  |  293|      0|        fastdds_log_ss_tmp__ << msg;                                                                                   \
  |  |  |  |  294|      0|        eprosima::fastdds::dds::Log::QueueLog(                                                                         \
  |  |  |  |  295|      0|            fastdds_log_ss_tmp__.str(), eprosima::fastdds::dds::Log::Context{__FILE__, __LINE__, __func__, #cat},      \
  |  |  |  |  296|      0|            eprosima::fastdds::dds::Log::Kind::Error);                                                                 \
  |  |  |  |  297|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (297:14): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1993|      0|                                                                                       << "'. Using default threshold.");
 1994|      0|                                    ret = XMLP_ret::XML_NOK;
 1995|      0|                                }
 1996|      0|                            }
 1997|      0|                        }
 1998|      0|                        else
 1999|      0|                        {
 2000|      0|                            EPROSIMA_LOG_ERROR(XMLParser, "Unkown property value '" << s << "' in " << classStr
  ------------------
  |  |   45|      0|#define EPROSIMA_LOG_ERROR(cat, msg) EPROSIMA_LOG_ERROR_IMPL_(cat, msg)
  |  |  ------------------
  |  |  |  |  291|      0|    do {                                                                                                               \
  |  |  |  |  292|      0|        std::stringstream fastdds_log_ss_tmp__;                                                                        \
  |  |  |  |  293|      0|        fastdds_log_ss_tmp__ << msg;                                                                                   \
  |  |  |  |  294|      0|        eprosima::fastdds::dds::Log::QueueLog(                                                                         \
  |  |  |  |  295|      0|            fastdds_log_ss_tmp__.str(), eprosima::fastdds::dds::Log::Context{__FILE__, __LINE__, __func__, #cat},      \
  |  |  |  |  296|      0|            eprosima::fastdds::dds::Log::Kind::Error);                                                                 \
  |  |  |  |  297|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (297:14): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 2001|      0|                                                                                    << " log consumer");
 2002|      0|                            ret = XMLP_ret::XML_NOK;
 2003|      0|                        }
 2004|      0|                    }
 2005|       |                    // Continue with the next property
 2006|      0|                    property = property->NextSiblingElement(PROPERTY);
 2007|      0|                }
 2008|       |
 2009|       |                // Create consumer with the specified `stderr_threshold` and register it.
 2010|      0|                StdoutErrConsumer* log_consumer = new StdoutErrConsumer;
 2011|      0|                log_consumer->stderr_threshold(threshold);
 2012|      0|                Log::RegisterConsumer(std::unique_ptr<LogConsumer>(log_consumer));
 2013|      0|            }
 2014|      0|        }
 2015|      0|        else if (std::strcmp(classStr.c_str(), "FileConsumer") == 0)
  ------------------
  |  Branch (2015:18): [True: 0, False: 0]
  ------------------
 2016|      0|        {
 2017|      0|            std::string outputFile = "output.log";
 2018|      0|            bool append = false;
 2019|       |
 2020|      0|            tinyxml2::XMLElement* property = consumer.FirstChildElement(PROPERTY);
 2021|      0|            if (nullptr == property)
  ------------------
  |  Branch (2021:17): [True: 0, False: 0]
  ------------------
 2022|      0|            {
 2023|      0|                Log::RegisterConsumer(std::unique_ptr<LogConsumer>(new FileConsumer));
 2024|      0|            }
 2025|      0|            else
 2026|      0|            {
 2027|      0|                tinyxml2::XMLElement* p_auxName = nullptr;
 2028|      0|                tinyxml2::XMLElement* p_auxValue = nullptr;
 2029|      0|                while (nullptr != property)
  ------------------
  |  Branch (2029:24): [True: 0, False: 0]
  ------------------
 2030|      0|                {
 2031|       |                    // name - stringType
 2032|      0|                    if (nullptr != (p_auxName = property->FirstChildElement(NAME)))
  ------------------
  |  Branch (2032:25): [True: 0, False: 0]
  ------------------
 2033|      0|                    {
 2034|      0|                        std::string s = get_element_text(p_auxName);
 2035|       |
 2036|      0|                        if (std::strcmp(s.c_str(), "filename") == 0)
  ------------------
  |  Branch (2036:29): [True: 0, False: 0]
  ------------------
 2037|      0|                        {
 2038|      0|                            if (nullptr == (p_auxValue = property->FirstChildElement(VALUE)) ||
  ------------------
  |  Branch (2038:33): [True: 0, False: 0]
  ------------------
 2039|      0|                                    !get_element_text(p_auxValue, outputFile))
  ------------------
  |  Branch (2039:37): [True: 0, False: 0]
  ------------------
 2040|      0|                            {
 2041|      0|                                EPROSIMA_LOG_ERROR(XMLParser, "Filename value cannot be found for " << classStr
  ------------------
  |  |   45|      0|#define EPROSIMA_LOG_ERROR(cat, msg) EPROSIMA_LOG_ERROR_IMPL_(cat, msg)
  |  |  ------------------
  |  |  |  |  291|      0|    do {                                                                                                               \
  |  |  |  |  292|      0|        std::stringstream fastdds_log_ss_tmp__;                                                                        \
  |  |  |  |  293|      0|        fastdds_log_ss_tmp__ << msg;                                                                                   \
  |  |  |  |  294|      0|        eprosima::fastdds::dds::Log::QueueLog(                                                                         \
  |  |  |  |  295|      0|            fastdds_log_ss_tmp__.str(), eprosima::fastdds::dds::Log::Context{__FILE__, __LINE__, __func__, #cat},      \
  |  |  |  |  296|      0|            eprosima::fastdds::dds::Log::Kind::Error);                                                                 \
  |  |  |  |  297|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (297:14): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 2042|      0|                                                                                                    << " log consumer.");
 2043|      0|                                ret = XMLP_ret::XML_NOK;
 2044|      0|                            }
 2045|      0|                        }
 2046|      0|                        else if (std::strcmp(s.c_str(), "append") == 0)
  ------------------
  |  Branch (2046:34): [True: 0, False: 0]
  ------------------
 2047|      0|                        {
 2048|      0|                            std::string auxBool;
 2049|      0|                            if (nullptr != (p_auxValue = property->FirstChildElement(VALUE)) &&
  ------------------
  |  Branch (2049:33): [True: 0, False: 0]
  ------------------
 2050|      0|                                    get_element_text(p_auxValue, auxBool))
  ------------------
  |  Branch (2050:37): [True: 0, False: 0]
  ------------------
 2051|      0|                            {
 2052|      0|                                if (std::strcmp(auxBool.c_str(), "TRUE") == 0)
  ------------------
  |  Branch (2052:37): [True: 0, False: 0]
  ------------------
 2053|      0|                                {
 2054|      0|                                    append = true;
 2055|      0|                                }
 2056|      0|                            }
 2057|      0|                            else
 2058|      0|                            {
 2059|      0|                                EPROSIMA_LOG_ERROR(XMLParser, "Append value cannot be found for " << classStr
  ------------------
  |  |   45|      0|#define EPROSIMA_LOG_ERROR(cat, msg) EPROSIMA_LOG_ERROR_IMPL_(cat, msg)
  |  |  ------------------
  |  |  |  |  291|      0|    do {                                                                                                               \
  |  |  |  |  292|      0|        std::stringstream fastdds_log_ss_tmp__;                                                                        \
  |  |  |  |  293|      0|        fastdds_log_ss_tmp__ << msg;                                                                                   \
  |  |  |  |  294|      0|        eprosima::fastdds::dds::Log::QueueLog(                                                                         \
  |  |  |  |  295|      0|            fastdds_log_ss_tmp__.str(), eprosima::fastdds::dds::Log::Context{__FILE__, __LINE__, __func__, #cat},      \
  |  |  |  |  296|      0|            eprosima::fastdds::dds::Log::Kind::Error);                                                                 \
  |  |  |  |  297|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (297:14): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 2060|      0|                                                                                                  << " log consumer.");
 2061|      0|                                ret = XMLP_ret::XML_NOK;
 2062|      0|                            }
 2063|      0|                        }
 2064|      0|                        else
 2065|      0|                        {
 2066|      0|                            EPROSIMA_LOG_ERROR(XMLParser, "Unknown property " << s << " in " << classStr
  ------------------
  |  |   45|      0|#define EPROSIMA_LOG_ERROR(cat, msg) EPROSIMA_LOG_ERROR_IMPL_(cat, msg)
  |  |  ------------------
  |  |  |  |  291|      0|    do {                                                                                                               \
  |  |  |  |  292|      0|        std::stringstream fastdds_log_ss_tmp__;                                                                        \
  |  |  |  |  293|      0|        fastdds_log_ss_tmp__ << msg;                                                                                   \
  |  |  |  |  294|      0|        eprosima::fastdds::dds::Log::QueueLog(                                                                         \
  |  |  |  |  295|      0|            fastdds_log_ss_tmp__.str(), eprosima::fastdds::dds::Log::Context{__FILE__, __LINE__, __func__, #cat},      \
  |  |  |  |  296|      0|            eprosima::fastdds::dds::Log::Kind::Error);                                                                 \
  |  |  |  |  297|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (297:14): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 2067|      0|                                                                              << " log consumer.");
 2068|      0|                            ret = XMLP_ret::XML_NOK;
 2069|      0|                        }
 2070|      0|                    }
 2071|      0|                    property = property->NextSiblingElement(PROPERTY);
 2072|      0|                }
 2073|       |
 2074|      0|                Log::RegisterConsumer(std::unique_ptr<LogConsumer>(new FileConsumer(outputFile, append)));
 2075|      0|            }
 2076|      0|        }
 2077|      0|        else
 2078|      0|        {
 2079|      0|            EPROSIMA_LOG_ERROR(XMLParser, "Unknown log consumer class: " << classStr);
  ------------------
  |  |   45|      0|#define EPROSIMA_LOG_ERROR(cat, msg) EPROSIMA_LOG_ERROR_IMPL_(cat, msg)
  |  |  ------------------
  |  |  |  |  291|      0|    do {                                                                                                               \
  |  |  |  |  292|      0|        std::stringstream fastdds_log_ss_tmp__;                                                                        \
  |  |  |  |  293|      0|        fastdds_log_ss_tmp__ << msg;                                                                                   \
  |  |  |  |  294|      0|        eprosima::fastdds::dds::Log::QueueLog(                                                                         \
  |  |  |  |  295|      0|            fastdds_log_ss_tmp__.str(), eprosima::fastdds::dds::Log::Context{__FILE__, __LINE__, __func__, #cat},      \
  |  |  |  |  296|      0|            eprosima::fastdds::dds::Log::Kind::Error);                                                                 \
  |  |  |  |  297|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (297:14): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 2080|      0|            ret = XMLP_ret::XML_ERROR;
 2081|      0|        }
 2082|      0|    }
 2083|       |
 2084|    293|    return ret;
 2085|    293|}
_ZN8eprosima7fastdds9xmlparser9XMLParser7loadXMLEPKcmRNSt3__110unique_ptrINS1_8BaseNodeENS5_14default_deleteIS7_EEEE:
 2137|  20.0k|{
 2138|  20.0k|    tinyxml2::XMLDocument xmlDoc;
 2139|  20.0k|    if (tinyxml2::XMLError::XML_SUCCESS != xmlDoc.Parse(data, length))
  ------------------
  |  Branch (2139:9): [True: 97, False: 19.9k]
  ------------------
 2140|     97|    {
 2141|     97|        EPROSIMA_LOG_ERROR(XMLPARSER, "Error parsing XML buffer");
  ------------------
  |  |   45|     97|#define EPROSIMA_LOG_ERROR(cat, msg) EPROSIMA_LOG_ERROR_IMPL_(cat, msg)
  |  |  ------------------
  |  |  |  |  291|     97|    do {                                                                                                               \
  |  |  |  |  292|     97|        std::stringstream fastdds_log_ss_tmp__;                                                                        \
  |  |  |  |  293|     97|        fastdds_log_ss_tmp__ << msg;                                                                                   \
  |  |  |  |  294|     97|        eprosima::fastdds::dds::Log::QueueLog(                                                                         \
  |  |  |  |  295|     97|            fastdds_log_ss_tmp__.str(), eprosima::fastdds::dds::Log::Context{__FILE__, __LINE__, __func__, #cat},      \
  |  |  |  |  296|     97|            eprosima::fastdds::dds::Log::Kind::Error);                                                                 \
  |  |  |  |  297|     97|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (297:14): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 2142|     97|        return XMLP_ret::XML_ERROR;
 2143|     97|    }
 2144|  19.9k|    return parseXML(xmlDoc, root);
 2145|  20.0k|}
_ZN8eprosima7fastdds9xmlparser9XMLParser12fillDataNodeEPN8tinyxml210XMLElementERNS1_8DataNodeINS1_15TopicAttributesEEE:
 2162|  23.9k|{
 2163|  23.9k|    if (nullptr == node)
  ------------------
  |  Branch (2163:9): [True: 0, False: 23.9k]
  ------------------
 2164|      0|    {
 2165|      0|        EPROSIMA_LOG_ERROR(XMLPARSER, "Bad parameters!");
  ------------------
  |  |   45|      0|#define EPROSIMA_LOG_ERROR(cat, msg) EPROSIMA_LOG_ERROR_IMPL_(cat, msg)
  |  |  ------------------
  |  |  |  |  291|      0|    do {                                                                                                               \
  |  |  |  |  292|      0|        std::stringstream fastdds_log_ss_tmp__;                                                                        \
  |  |  |  |  293|      0|        fastdds_log_ss_tmp__ << msg;                                                                                   \
  |  |  |  |  294|      0|        eprosima::fastdds::dds::Log::QueueLog(                                                                         \
  |  |  |  |  295|      0|            fastdds_log_ss_tmp__.str(), eprosima::fastdds::dds::Log::Context{__FILE__, __LINE__, __func__, #cat},      \
  |  |  |  |  296|      0|            eprosima::fastdds::dds::Log::Kind::Error);                                                                 \
  |  |  |  |  297|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (297:14): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 2166|      0|        return XMLP_ret::XML_ERROR;
 2167|      0|    }
 2168|       |
 2169|  23.9k|    addAllAttributes(node, topic_node);
 2170|       |
 2171|  23.9k|    uint8_t ident = 1;
 2172|  23.9k|    if (XMLP_ret::XML_OK != getXMLTopicAttributes(node, *topic_node.get(), ident))
  ------------------
  |  Branch (2172:9): [True: 3.77k, False: 20.1k]
  ------------------
 2173|  3.77k|    {
 2174|  3.77k|        return XMLP_ret::XML_ERROR;
 2175|  3.77k|    }
 2176|       |
 2177|  20.1k|    return XMLP_ret::XML_OK;
 2178|  23.9k|}
_ZN8eprosima7fastdds9xmlparser9XMLParser12fillDataNodeEPN8tinyxml210XMLElementERNS1_8DataNodeINS0_3dds27DomainParticipantFactoryQosEEE:
 2183|  12.8k|{
 2184|       |    /*
 2185|       |       <xs:complexType name="domainParticipantFactoryProfileType">
 2186|       |        <xs:all>
 2187|       |            <xs:element name="qos" type="domainParticipantFactoryQosPoliciesType" minOccurs="0" maxOccurs="1"/>
 2188|       |        </xs:all>
 2189|       |        <xs:attribute name="profile_name" type="string" use="required"/>
 2190|       |        <xs:attribute name="is_default_profile" type="boolean" use="optional"/>
 2191|       |       </xs:complexType>
 2192|       |     */
 2193|       |
 2194|  12.8k|    if (nullptr == p_profile)
  ------------------
  |  Branch (2194:9): [True: 0, False: 12.8k]
  ------------------
 2195|      0|    {
 2196|      0|        EPROSIMA_LOG_ERROR(XMLPARSER, "Bad parameters!");
  ------------------
  |  |   45|      0|#define EPROSIMA_LOG_ERROR(cat, msg) EPROSIMA_LOG_ERROR_IMPL_(cat, msg)
  |  |  ------------------
  |  |  |  |  291|      0|    do {                                                                                                               \
  |  |  |  |  292|      0|        std::stringstream fastdds_log_ss_tmp__;                                                                        \
  |  |  |  |  293|      0|        fastdds_log_ss_tmp__ << msg;                                                                                   \
  |  |  |  |  294|      0|        eprosima::fastdds::dds::Log::QueueLog(                                                                         \
  |  |  |  |  295|      0|            fastdds_log_ss_tmp__.str(), eprosima::fastdds::dds::Log::Context{__FILE__, __LINE__, __func__, #cat},      \
  |  |  |  |  296|      0|            eprosima::fastdds::dds::Log::Kind::Error);                                                                 \
  |  |  |  |  297|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (297:14): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 2197|      0|        return XMLP_ret::XML_ERROR;
 2198|      0|    }
 2199|       |
 2200|  12.8k|    addAllAttributes(p_profile, factory_node);
 2201|       |
 2202|       |    /*
 2203|       |     * The only allowed element <qos>, and its max is 1; look for it.
 2204|       |     */
 2205|  12.8k|    std::set<std::string> tags_present;
 2206|  24.3k|    for (tinyxml2::XMLElement* p_element = p_profile->FirstChildElement(); p_element != nullptr;
  ------------------
  |  Branch (2206:76): [True: 14.3k, False: 9.92k]
  ------------------
 2207|  12.8k|            p_element = p_element->NextSiblingElement())
 2208|  14.3k|    {
 2209|  14.3k|        const char* name = p_element->Name();
 2210|  14.3k|        if (tags_present.count(name) != 0)
  ------------------
  |  Branch (2210:13): [True: 697, False: 13.6k]
  ------------------
 2211|    697|        {
 2212|    697|            EPROSIMA_LOG_ERROR(XMLPARSER, "Duplicated element found in 'participant'. Tag: " << name);
  ------------------
  |  |   45|    697|#define EPROSIMA_LOG_ERROR(cat, msg) EPROSIMA_LOG_ERROR_IMPL_(cat, msg)
  |  |  ------------------
  |  |  |  |  291|    697|    do {                                                                                                               \
  |  |  |  |  292|    697|        std::stringstream fastdds_log_ss_tmp__;                                                                        \
  |  |  |  |  293|    697|        fastdds_log_ss_tmp__ << msg;                                                                                   \
  |  |  |  |  294|    697|        eprosima::fastdds::dds::Log::QueueLog(                                                                         \
  |  |  |  |  295|    697|            fastdds_log_ss_tmp__.str(), eprosima::fastdds::dds::Log::Context{__FILE__, __LINE__, __func__, #cat},      \
  |  |  |  |  296|    697|            eprosima::fastdds::dds::Log::Kind::Error);                                                                 \
  |  |  |  |  297|    697|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (297:14): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 2213|    697|            return XMLP_ret::XML_ERROR;
 2214|    697|        }
 2215|  13.6k|        tags_present.emplace(name);
 2216|       |
 2217|  13.6k|        if (strcmp(p_element->Name(), QOS) == 0)
  ------------------
  |  Branch (2217:13): [True: 2.81k, False: 10.8k]
  ------------------
 2218|  2.81k|        {
 2219|  2.81k|            if (XMLP_ret::XML_OK != getXMLDomainParticipantFactoryQos(*p_element, *factory_node.get()))
  ------------------
  |  Branch (2219:17): [True: 2.23k, False: 585]
  ------------------
 2220|  2.23k|            {
 2221|  2.23k|                return XMLP_ret::XML_ERROR;
 2222|  2.23k|            }
 2223|  2.81k|        }
 2224|  13.6k|    }
 2225|  9.92k|    return XMLP_ret::XML_OK;
 2226|  12.8k|}
_ZN8eprosima7fastdds9xmlparser9XMLParser12fillDataNodeEPN8tinyxml210XMLElementERNS1_8DataNodeINS1_21ParticipantAttributesEEE:
 2231|   105k|{
 2232|       |    /*
 2233|       |        <xs:complexType name="participantProfileType">
 2234|       |            <xs:all>
 2235|       |                <xs:element name="domainId" type="domainIDType" minOccurs="0" maxOccurs="1"/>
 2236|       |                <xs:element name="rtps" minOccurs="0" maxOccurs="1">
 2237|       |                    <xs:complexType>
 2238|       |                        <xs:all>
 2239|       |                            <xs:element name="name" type="string" minOccurs="0" maxOccurs="1"/>
 2240|       |                            <xs:element name="defaultUnicastLocatorList" type="locatorListType" minOccurs="0" maxOccurs="1"/>
 2241|       |                            <xs:element name="defaultMulticastLocatorList" type="locatorListType" minOccurs="0" maxOccurs="1"/>
 2242|       |                            <xs:element name="default_external_unicast_locators" type="externalLocatorListType" minOccurs="0" maxOccurs="1"/>
 2243|       |                            <xs:element name="ignore_non_matching_locators" type="boolean" minOccurs="0" maxOccurs="1"/>
 2244|       |                            <xs:element name="sendSocketBufferSize" type="uint32" minOccurs="0" maxOccurs="1"/>
 2245|       |                            <xs:element name="listenSocketBufferSize" type="uint32" minOccurs="0" maxOccurs="1"/>
 2246|       |                            <xs:element name="netmask_filter" minOccurs="0" maxOccurs="1">
 2247|       |                                <xs:simpleType>
 2248|       |                                    <xs:restriction base="xs:string">
 2249|       |                                        <xs:enumeration value="OFF"/>
 2250|       |                                        <xs:enumeration value="AUTO"/>
 2251|       |                                        <xs:enumeration value="ON"/>
 2252|       |                                    </xs:restriction>
 2253|       |                                </xs:simpleType>
 2254|       |                            </xs:element>
 2255|       |                            <xs:element name="builtin" type="builtinAttributesType" minOccurs="0" maxOccurs="1"/>
 2256|       |                            <xs:element name="port" type="portType" minOccurs="0" maxOccurs="1"/>
 2257|       |                            <xs:element name="participantID" type="int32" minOccurs="0" maxOccurs="1"/>
 2258|       |                            <xs:element name="easy_mode_ip" type="string" minOccurs="0" maxOccurs="1"/>
 2259|       |                            <xs:element name="userTransports" minOccurs="0" maxOccurs="1">
 2260|       |                                <xs:complexType>
 2261|       |                                    <xs:sequence>
 2262|       |                                        <xs:element name="transport_id" type="string" minOccurs="1" maxOccurs="unbounded"/>
 2263|       |                                    </xs:sequence>
 2264|       |                                </xs:complexType>
 2265|       |                            </xs:element>
 2266|       |                            <xs:element name="useBuiltinTransports" type="boolean" minOccurs="0" maxOccurs="1"/>
 2267|       |                            <xs:element name="builtinTransports" type="builtinTransportsType" minOccurs="0" maxOccurs="1"/>
 2268|       |                            <xs:element name="propertiesPolicy" type="propertyPolicyType" minOccurs="0" maxOccurs="1"/>
 2269|       |                            <xs:element name="allocation" type="rtpsParticipantAllocationAttributesType"  minOccurs="0" maxOccurs="1"/>
 2270|       |                            <xs:element name="userData" type="octectVectorQosPolicyType" minOccurs="0" maxOccurs="1"/>
 2271|       |                            <xs:element name="prefix" type="prefixType" minOccurs="0" maxOccurs="1"/>
 2272|       |                            <xs:element name="flow_controller_descriptor_list" type="flowControllerDescriptorListType" minOccurs="0" maxOccurs="1"/>
 2273|       |                            <xs:element name="builtin_controllers_sender_thread" type="threadSettingsType" minOccurs="0" maxOccurs="1"/>
 2274|       |                            <xs:element name="timed_events_thread" type="threadSettingsType" minOccurs="0" maxOccurs="1"/>
 2275|       |                            <xs:element name="discovery_server_thread" type="threadSettingsType" minOccurs="0" maxOccurs="1"/>
 2276|       |                            <xs:element name="typelookup_service_thread" type="threadSettingsType" minOccurs="0" maxOccurs="1"/>
 2277|       |                            <xs:element name="builtin_transports_reception_threads" type="threadSettingsType" minOccurs="0" maxOccurs="1"/>
 2278|       |                            <xs:element name="security_log_thread" type="threadSettingsType" minOccurs="0" maxOccurs="1"/>
 2279|       |                        </xs:all>
 2280|       |                    </xs:complexType>
 2281|       |                </xs:element>
 2282|       |            </xs:all>
 2283|       |        </xs:complexType>
 2284|       |     */
 2285|       |
 2286|   105k|    if (nullptr == p_profile)
  ------------------
  |  Branch (2286:9): [True: 0, False: 105k]
  ------------------
 2287|      0|    {
 2288|      0|        EPROSIMA_LOG_ERROR(XMLPARSER, "Bad parameters!");
  ------------------
  |  |   45|      0|#define EPROSIMA_LOG_ERROR(cat, msg) EPROSIMA_LOG_ERROR_IMPL_(cat, msg)
  |  |  ------------------
  |  |  |  |  291|      0|    do {                                                                                                               \
  |  |  |  |  292|      0|        std::stringstream fastdds_log_ss_tmp__;                                                                        \
  |  |  |  |  293|      0|        fastdds_log_ss_tmp__ << msg;                                                                                   \
  |  |  |  |  294|      0|        eprosima::fastdds::dds::Log::QueueLog(                                                                         \
  |  |  |  |  295|      0|            fastdds_log_ss_tmp__.str(), eprosima::fastdds::dds::Log::Context{__FILE__, __LINE__, __func__, #cat},      \
  |  |  |  |  296|      0|            eprosima::fastdds::dds::Log::Kind::Error);                                                                 \
  |  |  |  |  297|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (297:14): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 2289|      0|        return XMLP_ret::XML_ERROR;
 2290|      0|    }
 2291|       |
 2292|   105k|    addAllAttributes(p_profile, participant_node);
 2293|       |
 2294|   105k|    uint8_t ident = 1;
 2295|   105k|    tinyxml2::XMLElement* p_element;
 2296|   105k|    tinyxml2::XMLElement* p_aux0 = nullptr;
 2297|   105k|    const char* name = nullptr;
 2298|   105k|    std::set<std::string> tags_present;
 2299|       |
 2300|       |    /*
 2301|       |     * The only allowed elements are <domainId> and <rtps>
 2302|       |     *   - The min occurrences of <domainId> are 0, and its max is 1; look for it.
 2303|       |     *   - The min occurrences of <rtps> are 0, and its max is 1; look for it.
 2304|       |     */
 2305|   171k|    for (p_element = p_profile->FirstChildElement(); p_element != nullptr; p_element = p_element->NextSiblingElement())
  ------------------
  |  Branch (2305:54): [True: 68.0k, False: 103k]
  ------------------
 2306|  68.0k|    {
 2307|  68.0k|        name = p_element->Name();
 2308|  68.0k|        if (tags_present.count(name) != 0)
  ------------------
  |  Branch (2308:13): [True: 636, False: 67.3k]
  ------------------
 2309|    636|        {
 2310|    636|            EPROSIMA_LOG_ERROR(XMLPARSER, "Duplicated element found in 'participant'. Tag: " << name);
  ------------------
  |  |   45|    636|#define EPROSIMA_LOG_ERROR(cat, msg) EPROSIMA_LOG_ERROR_IMPL_(cat, msg)
  |  |  ------------------
  |  |  |  |  291|    636|    do {                                                                                                               \
  |  |  |  |  292|    636|        std::stringstream fastdds_log_ss_tmp__;                                                                        \
  |  |  |  |  293|    636|        fastdds_log_ss_tmp__ << msg;                                                                                   \
  |  |  |  |  294|    636|        eprosima::fastdds::dds::Log::QueueLog(                                                                         \
  |  |  |  |  295|    636|            fastdds_log_ss_tmp__.str(), eprosima::fastdds::dds::Log::Context{__FILE__, __LINE__, __func__, #cat},      \
  |  |  |  |  296|    636|            eprosima::fastdds::dds::Log::Kind::Error);                                                                 \
  |  |  |  |  297|    636|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (297:14): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 2311|    636|            return XMLP_ret::XML_ERROR;
 2312|    636|        }
 2313|  67.3k|        tags_present.emplace(name);
 2314|       |
 2315|  67.3k|        if (strcmp(p_element->Name(), DOMAIN_ID) == 0)
  ------------------
  |  Branch (2315:13): [True: 1.09k, False: 66.2k]
  ------------------
 2316|  1.09k|        {
 2317|       |            // domainId - uint32
 2318|  1.09k|            if (XMLP_ret::XML_OK != getXMLUint(p_element, &participant_node.get()->domainId, ident))
  ------------------
  |  Branch (2318:17): [True: 223, False: 874]
  ------------------
 2319|    223|            {
 2320|    223|                return XMLP_ret::XML_ERROR;
 2321|    223|            }
 2322|  1.09k|        }
 2323|  66.2k|        else if (strcmp(p_element->Name(), RTPS) == 0)
  ------------------
  |  Branch (2323:18): [True: 65.5k, False: 725]
  ------------------
 2324|  65.5k|        {
 2325|  65.5k|            p_aux0 = p_element;
 2326|  65.5k|        }
 2327|    725|        else
 2328|    725|        {
 2329|    725|            EPROSIMA_LOG_ERROR(XMLPARSER, "Found incorrect tag '" << p_element->Name() << "'");
  ------------------
  |  |   45|    725|#define EPROSIMA_LOG_ERROR(cat, msg) EPROSIMA_LOG_ERROR_IMPL_(cat, msg)
  |  |  ------------------
  |  |  |  |  291|    725|    do {                                                                                                               \
  |  |  |  |  292|    725|        std::stringstream fastdds_log_ss_tmp__;                                                                        \
  |  |  |  |  293|    725|        fastdds_log_ss_tmp__ << msg;                                                                                   \
  |  |  |  |  294|    725|        eprosima::fastdds::dds::Log::QueueLog(                                                                         \
  |  |  |  |  295|    725|            fastdds_log_ss_tmp__.str(), eprosima::fastdds::dds::Log::Context{__FILE__, __LINE__, __func__, #cat},      \
  |  |  |  |  296|    725|            eprosima::fastdds::dds::Log::Kind::Error);                                                                 \
  |  |  |  |  297|    725|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (297:14): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 2330|    725|            return XMLP_ret::XML_ERROR;
 2331|    725|        }
 2332|  67.3k|    }
 2333|   103k|    tags_present.clear();
 2334|       |
 2335|       |    // <rtps> is not present, but that's OK
 2336|   103k|    if (nullptr == p_aux0)
  ------------------
  |  Branch (2336:9): [True: 38.3k, False: 65.3k]
  ------------------
 2337|  38.3k|    {
 2338|  38.3k|        return XMLP_ret::XML_OK;
 2339|  38.3k|    }
 2340|       |
 2341|       |    // Check contents of <rtps>
 2342|  74.0k|    for (p_aux0 = p_aux0->FirstChildElement(); p_aux0 != nullptr; p_aux0 = p_aux0->NextSiblingElement())
  ------------------
  |  Branch (2342:48): [True: 67.3k, False: 6.72k]
  ------------------
 2343|  67.3k|    {
 2344|  67.3k|        name = p_aux0->Name();
 2345|       |
 2346|  67.3k|        if (tags_present.count(name) != 0)
  ------------------
  |  Branch (2346:13): [True: 480, False: 66.8k]
  ------------------
 2347|    480|        {
 2348|    480|            EPROSIMA_LOG_ERROR(XMLPARSER,
  ------------------
  |  |   45|    480|#define EPROSIMA_LOG_ERROR(cat, msg) EPROSIMA_LOG_ERROR_IMPL_(cat, msg)
  |  |  ------------------
  |  |  |  |  291|    480|    do {                                                                                                               \
  |  |  |  |  292|    480|        std::stringstream fastdds_log_ss_tmp__;                                                                        \
  |  |  |  |  293|    480|        fastdds_log_ss_tmp__ << msg;                                                                                   \
  |  |  |  |  294|    480|        eprosima::fastdds::dds::Log::QueueLog(                                                                         \
  |  |  |  |  295|    480|            fastdds_log_ss_tmp__.str(), eprosima::fastdds::dds::Log::Context{__FILE__, __LINE__, __func__, #cat},      \
  |  |  |  |  296|    480|            eprosima::fastdds::dds::Log::Kind::Error);                                                                 \
  |  |  |  |  297|    480|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (297:14): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 2349|    480|                    "Duplicated element found in 'rtpsParticipantAttributesType'. Tag: " << name);
 2350|    480|            return XMLP_ret::XML_ERROR;
 2351|    480|        }
 2352|  66.8k|        tags_present.emplace(name);
 2353|       |
 2354|  66.8k|        if (strcmp(name, ALLOCATION) == 0)
  ------------------
  |  Branch (2354:13): [True: 71, False: 66.7k]
  ------------------
 2355|     71|        {
 2356|       |            // allocation
 2357|     71|            if (XMLP_ret::XML_OK !=
  ------------------
  |  Branch (2357:17): [True: 0, False: 71]
  ------------------
 2358|     71|                    getXMLParticipantAllocationAttributes(p_aux0, participant_node.get()->rtps.allocation, ident))
 2359|      0|            {
 2360|      0|                return XMLP_ret::XML_ERROR;
 2361|      0|            }
 2362|     71|        }
 2363|  66.7k|        else if (strcmp(name, PREFIX) == 0)
  ------------------
  |  Branch (2363:18): [True: 146, False: 66.6k]
  ------------------
 2364|    146|        {
 2365|       |            // prefix
 2366|    146|            if (XMLP_ret::XML_OK !=
  ------------------
  |  Branch (2366:17): [True: 146, False: 0]
  ------------------
 2367|    146|                    getXMLguidPrefix(p_aux0, participant_node.get()->rtps.prefix, ident))
 2368|    146|            {
 2369|    146|                return XMLP_ret::XML_ERROR;
 2370|    146|            }
 2371|    146|        }
 2372|  66.6k|        else if (strcmp(name, IGN_NON_MATCHING_LOCS) == 0)
  ------------------
  |  Branch (2372:18): [True: 87, False: 66.5k]
  ------------------
 2373|     87|        {
 2374|       |            // ignore_non_matching_locators - boolean
 2375|     87|            if (XMLP_ret::XML_OK !=
  ------------------
  |  Branch (2375:17): [True: 87, False: 0]
  ------------------
 2376|     87|                    getXMLBool(p_aux0, &participant_node.get()->rtps.ignore_non_matching_locators, ident))
 2377|     87|            {
 2378|     87|                return XMLP_ret::XML_ERROR;
 2379|     87|            }
 2380|     87|        }
 2381|  66.5k|        else if (strcmp(name, DEF_EXT_UNI_LOC_LIST) == 0)
  ------------------
  |  Branch (2381:18): [True: 448, False: 66.0k]
  ------------------
 2382|    448|        {
 2383|       |            // default_external_unicast_locators - externalLocatorListType
 2384|    448|            if (XMLP_ret::XML_OK !=
  ------------------
  |  Branch (2384:17): [True: 0, False: 448]
  ------------------
 2385|    448|                    getXMLExternalLocatorList(p_aux0, participant_node.get()->rtps.default_external_unicast_locators,
 2386|    448|                    ident))
 2387|      0|            {
 2388|      0|                return XMLP_ret::XML_ERROR;
 2389|      0|            }
 2390|    448|        }
 2391|  66.0k|        else if (strcmp(name, DEF_UNI_LOC_LIST) == 0)
  ------------------
  |  Branch (2391:18): [True: 130, False: 65.9k]
  ------------------
 2392|    130|        {
 2393|       |            // defaultUnicastLocatorList
 2394|    130|            if (XMLP_ret::XML_OK !=
  ------------------
  |  Branch (2394:17): [True: 130, False: 0]
  ------------------
 2395|    130|                    getXMLLocatorList(p_aux0, participant_node.get()->rtps.defaultUnicastLocatorList, ident))
 2396|    130|            {
 2397|    130|                return XMLP_ret::XML_ERROR;
 2398|    130|            }
 2399|    130|        }
 2400|  65.9k|        else if (strcmp(name, DEF_MULTI_LOC_LIST) == 0)
  ------------------
  |  Branch (2400:18): [True: 295, False: 65.6k]
  ------------------
 2401|    295|        {
 2402|       |            // defaultMulticastLocatorList
 2403|    295|            if (XMLP_ret::XML_OK !=
  ------------------
  |  Branch (2403:17): [True: 295, False: 0]
  ------------------
 2404|    295|                    getXMLLocatorList(p_aux0, participant_node.get()->rtps.defaultMulticastLocatorList, ident))
 2405|    295|            {
 2406|    295|                return XMLP_ret::XML_ERROR;
 2407|    295|            }
 2408|    295|        }
 2409|  65.6k|        else if (strcmp(name, SEND_SOCK_BUF_SIZE) == 0)
  ------------------
  |  Branch (2409:18): [True: 148, False: 65.5k]
  ------------------
 2410|    148|        {
 2411|       |            // sendSocketBufferSize - uint32
 2412|    148|            if (XMLP_ret::XML_OK != getXMLUint(p_aux0, &participant_node.get()->rtps.sendSocketBufferSize, ident))
  ------------------
  |  Branch (2412:17): [True: 148, False: 0]
  ------------------
 2413|    148|            {
 2414|    148|                return XMLP_ret::XML_ERROR;
 2415|    148|            }
 2416|    148|        }
 2417|  65.5k|        else if (strcmp(name, LIST_SOCK_BUF_SIZE) == 0)
  ------------------
  |  Branch (2417:18): [True: 75, False: 65.4k]
  ------------------
 2418|     75|        {
 2419|       |            // listenSocketBufferSize - uint32
 2420|     75|            if (XMLP_ret::XML_OK != getXMLUint(p_aux0, &participant_node.get()->rtps.listenSocketBufferSize, ident))
  ------------------
  |  Branch (2420:17): [True: 75, False: 0]
  ------------------
 2421|     75|            {
 2422|     75|                return XMLP_ret::XML_ERROR;
 2423|     75|            }
 2424|     75|        }
 2425|  65.4k|        else if (strcmp(name, NETMASK_FILTER) == 0)
  ------------------
  |  Branch (2425:18): [True: 148, False: 65.2k]
  ------------------
 2426|    148|        {
 2427|    148|            std::string netmask_filter_str;
 2428|    148|            if (XMLP_ret::XML_OK != getXMLString(p_aux0, &netmask_filter_str, 0))
  ------------------
  |  Branch (2428:17): [True: 148, False: 0]
  ------------------
 2429|    148|            {
 2430|    148|                EPROSIMA_LOG_ERROR(XMLPARSER, "Invalid element found into 'netmask_filter'.");
  ------------------
  |  |   45|    148|#define EPROSIMA_LOG_ERROR(cat, msg) EPROSIMA_LOG_ERROR_IMPL_(cat, msg)
  |  |  ------------------
  |  |  |  |  291|    148|    do {                                                                                                               \
  |  |  |  |  292|    148|        std::stringstream fastdds_log_ss_tmp__;                                                                        \
  |  |  |  |  293|    148|        fastdds_log_ss_tmp__ << msg;                                                                                   \
  |  |  |  |  294|    148|        eprosima::fastdds::dds::Log::QueueLog(                                                                         \
  |  |  |  |  295|    148|            fastdds_log_ss_tmp__.str(), eprosima::fastdds::dds::Log::Context{__FILE__, __LINE__, __func__, #cat},      \
  |  |  |  |  296|    148|            eprosima::fastdds::dds::Log::Kind::Error);                                                                 \
  |  |  |  |  297|    148|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (297:14): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 2431|    148|                return XMLP_ret::XML_ERROR;
 2432|    148|            }
 2433|       |
 2434|      0|            try
 2435|      0|            {
 2436|      0|                participant_node.get()->rtps.netmaskFilter =
 2437|      0|                        fastdds::rtps::network::netmask_filter::string_to_netmask_filter_kind(netmask_filter_str);
 2438|      0|            }
 2439|      0|            catch (const std::invalid_argument& e)
 2440|      0|            {
 2441|      0|                EPROSIMA_LOG_ERROR(XMLPARSER, "Invalid element found into 'netmask_filter' : " << e.what());
  ------------------
  |  |   45|      0|#define EPROSIMA_LOG_ERROR(cat, msg) EPROSIMA_LOG_ERROR_IMPL_(cat, msg)
  |  |  ------------------
  |  |  |  |  291|      0|    do {                                                                                                               \
  |  |  |  |  292|      0|        std::stringstream fastdds_log_ss_tmp__;                                                                        \
  |  |  |  |  293|      0|        fastdds_log_ss_tmp__ << msg;                                                                                   \
  |  |  |  |  294|      0|        eprosima::fastdds::dds::Log::QueueLog(                                                                         \
  |  |  |  |  295|      0|            fastdds_log_ss_tmp__.str(), eprosima::fastdds::dds::Log::Context{__FILE__, __LINE__, __func__, #cat},      \
  |  |  |  |  296|      0|            eprosima::fastdds::dds::Log::Kind::Error);                                                                 \
  |  |  |  |  297|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (297:14): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 2442|      0|                return XMLP_ret::XML_ERROR;
 2443|      0|            }
 2444|      0|        }
 2445|  65.2k|        else if (strcmp(name, BUILTIN) == 0)
  ------------------
  |  Branch (2445:18): [True: 11.9k, False: 53.3k]
  ------------------
 2446|  11.9k|        {
 2447|       |            // builtin
 2448|  11.9k|            if (XMLP_ret::XML_OK != getXMLBuiltinAttributes(p_aux0, participant_node.get()->rtps.builtin, ident))
  ------------------
  |  Branch (2448:17): [True: 9.23k, False: 2.74k]
  ------------------
 2449|  9.23k|            {
 2450|  9.23k|                return XMLP_ret::XML_ERROR;
 2451|  9.23k|            }
 2452|  11.9k|        }
 2453|  53.3k|        else if (strcmp(name, PORT) == 0)
  ------------------
  |  Branch (2453:18): [True: 1.00k, False: 52.3k]
  ------------------
 2454|  1.00k|        {
 2455|       |            // port
 2456|  1.00k|            if (XMLP_ret::XML_OK != getXMLPortParameters(p_aux0, participant_node.get()->rtps.port, ident))
  ------------------
  |  Branch (2456:17): [True: 0, False: 1.00k]
  ------------------
 2457|      0|            {
 2458|      0|                return XMLP_ret::XML_ERROR;
 2459|      0|            }
 2460|  1.00k|        }
 2461|  52.3k|        else if (0 == strcmp(name, USER_DATA))
  ------------------
  |  Branch (2461:18): [True: 478, False: 51.8k]
  ------------------
 2462|    478|        {
 2463|       |            // userData
 2464|    478|            if (XMLP_ret::XML_OK != getXMLOctetVector(p_aux0, participant_node.get()->rtps.userData, ident))
  ------------------
  |  Branch (2464:17): [True: 0, False: 478]
  ------------------
 2465|      0|            {
 2466|      0|                return XMLP_ret::XML_ERROR;
 2467|      0|            }
 2468|    478|        }
 2469|  51.8k|        else if (strcmp(name, PART_ID) == 0)
  ------------------
  |  Branch (2469:18): [True: 21, False: 51.8k]
  ------------------
 2470|     21|        {
 2471|       |            // participantID - int32
 2472|     21|            if (XMLP_ret::XML_OK != getXMLInt(p_aux0, &participant_node.get()->rtps.participantID, ident))
  ------------------
  |  Branch (2472:17): [True: 21, False: 0]
  ------------------
 2473|     21|            {
 2474|     21|                return XMLP_ret::XML_ERROR;
 2475|     21|            }
 2476|     21|        }
 2477|  51.8k|        else if (strcmp(name, EASY_MODE_IP) == 0)
  ------------------
  |  Branch (2477:18): [True: 24, False: 51.7k]
  ------------------
 2478|     24|        {
 2479|       |            // easy_mode_ip - string
 2480|     24|            std::string str_aux;
 2481|     24|            if (XMLP_ret::XML_OK != getXMLString(p_aux0, &str_aux, ident))
  ------------------
  |  Branch (2481:17): [True: 24, False: 0]
  ------------------
 2482|     24|            {
 2483|     24|                return XMLP_ret::XML_ERROR;
 2484|     24|            }
 2485|       |
 2486|       |            // Check that the string is a valid IPv4 address
 2487|      0|            if (!fastdds::rtps::IPLocator::isIPv4(str_aux))
  ------------------
  |  Branch (2487:17): [True: 0, False: 0]
  ------------------
 2488|      0|            {
 2489|      0|                EPROSIMA_LOG_ERROR(XMLPARSER, "'easy_mode_ip' is not a valid IPv4 address.");
  ------------------
  |  |   45|      0|#define EPROSIMA_LOG_ERROR(cat, msg) EPROSIMA_LOG_ERROR_IMPL_(cat, msg)
  |  |  ------------------
  |  |  |  |  291|      0|    do {                                                                                                               \
  |  |  |  |  292|      0|        std::stringstream fastdds_log_ss_tmp__;                                                                        \
  |  |  |  |  293|      0|        fastdds_log_ss_tmp__ << msg;                                                                                   \
  |  |  |  |  294|      0|        eprosima::fastdds::dds::Log::QueueLog(                                                                         \
  |  |  |  |  295|      0|            fastdds_log_ss_tmp__.str(), eprosima::fastdds::dds::Log::Context{__FILE__, __LINE__, __func__, #cat},      \
  |  |  |  |  296|      0|            eprosima::fastdds::dds::Log::Kind::Error);                                                                 \
  |  |  |  |  297|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (297:14): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 2490|      0|                return XMLP_ret::XML_ERROR;
 2491|      0|            }
 2492|       |
 2493|      0|            participant_node.get()->rtps.easy_mode_ip = str_aux;
 2494|      0|        }
 2495|  51.7k|        else if (strcmp(name, FLOW_CONTROLLER_DESCRIPTOR_LIST) == 0)
  ------------------
  |  Branch (2495:18): [True: 135, False: 51.6k]
  ------------------
 2496|    135|        {
 2497|       |            // flow_controller_descriptors
 2498|    135|            if (XMLP_ret::XML_OK !=
  ------------------
  |  Branch (2498:17): [True: 135, False: 0]
  ------------------
 2499|    135|                    getXMLFlowControllerDescriptorList(p_aux0, participant_node.get()->rtps.flow_controllers, ident))
 2500|    135|            {
 2501|    135|                return XMLP_ret::XML_ERROR;
 2502|    135|            }
 2503|    135|        }
 2504|  51.6k|        else if (strcmp(name, USER_TRANS) == 0)
  ------------------
  |  Branch (2504:18): [True: 377, False: 51.2k]
  ------------------
 2505|    377|        {
 2506|       |            // userTransports
 2507|    377|            if (XMLP_ret::XML_OK != getXMLTransports(p_aux0, participant_node.get()->rtps.userTransports, ident))
  ------------------
  |  Branch (2507:17): [True: 377, False: 0]
  ------------------
 2508|    377|            {
 2509|    377|                return XMLP_ret::XML_ERROR;
 2510|    377|            }
 2511|    377|        }
 2512|  51.2k|        else if (strcmp(name, USE_BUILTIN_TRANS) == 0)
  ------------------
  |  Branch (2512:18): [True: 615, False: 50.6k]
  ------------------
 2513|    615|        {
 2514|       |            // useBuiltinTransports - boolean
 2515|    615|            if (XMLP_ret::XML_OK != getXMLBool(p_aux0, &participant_node.get()->rtps.useBuiltinTransports, ident))
  ------------------
  |  Branch (2515:17): [True: 615, False: 0]
  ------------------
 2516|    615|            {
 2517|    615|                return XMLP_ret::XML_ERROR;
 2518|    615|            }
 2519|    615|        }
 2520|  50.6k|        else if (strcmp(name, BUILTIN_TRANS) == 0)
  ------------------
  |  Branch (2520:18): [True: 32.6k, False: 18.0k]
  ------------------
 2521|  32.6k|        {
 2522|       |            // builtinTransports
 2523|  32.6k|            eprosima::fastdds::rtps::BuiltinTransports bt;
 2524|  32.6k|            eprosima::fastdds::rtps::BuiltinTransportsOptions bt_opts;
 2525|  32.6k|            if (XMLP_ret::XML_OK != getXMLBuiltinTransports(p_aux0, &bt, &bt_opts, ident))
  ------------------
  |  Branch (2525:17): [True: 32.6k, False: 0]
  ------------------
 2526|  32.6k|            {
 2527|  32.6k|                return XMLP_ret::XML_ERROR;
 2528|  32.6k|            }
 2529|      0|            participant_node.get()->rtps.setup_transports(bt, bt_opts);
 2530|      0|        }
 2531|  18.0k|        else if (strcmp(name, PROPERTIES_POLICY) == 0)
  ------------------
  |  Branch (2531:18): [True: 595, False: 17.4k]
  ------------------
 2532|    595|        {
 2533|       |            // propertiesPolicy
 2534|    595|            if (XMLP_ret::XML_OK != getXMLPropertiesPolicy(p_aux0, participant_node.get()->rtps.properties, ident))
  ------------------
  |  Branch (2534:17): [True: 0, False: 595]
  ------------------
 2535|      0|            {
 2536|      0|                return XMLP_ret::XML_ERROR;
 2537|      0|            }
 2538|    595|        }
 2539|  17.4k|        else if (strcmp(name, NAME) == 0)
  ------------------
  |  Branch (2539:18): [True: 3.32k, False: 14.1k]
  ------------------
 2540|  3.32k|        {
 2541|       |            // name - string
 2542|  3.32k|            std::string s;
 2543|  3.32k|            if (XMLP_ret::XML_OK != getXMLString(p_aux0, &s, ident))
  ------------------
  |  Branch (2543:17): [True: 1.41k, False: 1.90k]
  ------------------
 2544|  1.41k|            {
 2545|  1.41k|                return XMLP_ret::XML_ERROR;
 2546|  1.41k|            }
 2547|  1.90k|            participant_node.get()->rtps.setName(s.c_str());
 2548|  1.90k|        }
 2549|  14.1k|        else if (strcmp(name, BUILTIN_CONTROLLERS_SENDER_THREAD) == 0)
  ------------------
  |  Branch (2549:18): [True: 1.88k, False: 12.2k]
  ------------------
 2550|  1.88k|        {
 2551|  1.88k|            if (XMLP_ret::XML_OK !=
  ------------------
  |  Branch (2551:17): [True: 1.72k, False: 158]
  ------------------
 2552|  1.88k|                    getXMLThreadSettings(*p_aux0,
 2553|  1.88k|                    participant_node.get()->rtps.builtin_controllers_sender_thread))
 2554|  1.72k|            {
 2555|  1.72k|                return XMLP_ret::XML_ERROR;
 2556|  1.72k|            }
 2557|  1.88k|        }
 2558|  12.2k|        else if (strcmp(name, TIMED_EVENTS_THREAD) == 0)
  ------------------
  |  Branch (2558:18): [True: 283, False: 11.9k]
  ------------------
 2559|    283|        {
 2560|    283|            if (XMLP_ret::XML_OK != getXMLThreadSettings(*p_aux0, participant_node.get()->rtps.timed_events_thread))
  ------------------
  |  Branch (2560:17): [True: 58, False: 225]
  ------------------
 2561|     58|            {
 2562|     58|                return XMLP_ret::XML_ERROR;
 2563|     58|            }
 2564|    283|        }
 2565|  11.9k|        else if (strcmp(name, DISCOVERY_SERVER_THREAD) == 0)
  ------------------
  |  Branch (2565:18): [True: 560, False: 11.3k]
  ------------------
 2566|    560|        {
 2567|    560|            if (XMLP_ret::XML_OK != getXMLThreadSettings(*p_aux0, participant_node.get()->rtps.discovery_server_thread))
  ------------------
  |  Branch (2567:17): [True: 98, False: 462]
  ------------------
 2568|     98|            {
 2569|     98|                return XMLP_ret::XML_ERROR;
 2570|     98|            }
 2571|    560|        }
 2572|  11.3k|        else if (strcmp(name, TYPELOOKUP_SERVICE_THREAD) == 0)
  ------------------
  |  Branch (2572:18): [True: 415, False: 10.9k]
  ------------------
 2573|    415|        {
 2574|    415|            if (XMLP_ret::XML_OK !=
  ------------------
  |  Branch (2574:17): [True: 258, False: 157]
  ------------------
 2575|    415|                    getXMLThreadSettings(*p_aux0, participant_node.get()->rtps.typelookup_service_thread))
 2576|    258|            {
 2577|    258|                return XMLP_ret::XML_ERROR;
 2578|    258|            }
 2579|    415|        }
 2580|  10.9k|        else if (strcmp(name, BUILTIN_TRANSPORTS_RECEPTION_THREADS) == 0)
  ------------------
  |  Branch (2580:18): [True: 323, False: 10.6k]
  ------------------
 2581|    323|        {
 2582|    323|            if (XMLP_ret::XML_OK !=
  ------------------
  |  Branch (2582:17): [True: 69, False: 254]
  ------------------
 2583|    323|                    getXMLThreadSettings(*p_aux0,
 2584|    323|                    participant_node.get()->rtps.builtin_transports_reception_threads))
 2585|     69|            {
 2586|     69|                return XMLP_ret::XML_ERROR;
 2587|     69|            }
 2588|    323|        }
 2589|  10.6k|        else if (strcmp(name, SECURITY_LOG_THREAD) == 0)
  ------------------
  |  Branch (2589:18): [True: 220, False: 10.4k]
  ------------------
 2590|    220|        {
 2591|       |#if HAVE_SECURITY
 2592|       |            if (XMLP_ret::XML_OK != getXMLThreadSettings(*p_aux0, participant_node.get()->rtps.security_log_thread))
 2593|       |            {
 2594|       |                return XMLP_ret::XML_ERROR;
 2595|       |            }
 2596|       |#else
 2597|    220|            EPROSIMA_LOG_WARNING(XMLPARSER, "Ignoring '" << SECURITY_LOG_THREAD << "' since security is disabled");
  ------------------
  |  |   43|    220|#define EPROSIMA_LOG_WARNING(cat, msg) EPROSIMA_LOG_WARNING_IMPL_(cat, msg)
  |  |  ------------------
  |  |  |  |  322|    220|    do {                                                                                                              \
  |  |  |  |  323|    220|        if (eprosima::fastdds::dds::Log::GetVerbosity() >= eprosima::fastdds::dds::Log::Kind::Warning)                \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (323:13): [True: 0, False: 220]
  |  |  |  |  ------------------
  |  |  |  |  324|    220|        {                                                                                                             \
  |  |  |  |  325|      0|            std::stringstream fastdds_log_ss_tmp__;                                                                   \
  |  |  |  |  326|      0|            fastdds_log_ss_tmp__ << msg;                                                                              \
  |  |  |  |  327|      0|            eprosima::fastdds::dds::Log::QueueLog(                                                                    \
  |  |  |  |  328|      0|                fastdds_log_ss_tmp__.str(), eprosima::fastdds::dds::Log::Context{__FILE__, __LINE__, __func__, #cat}, \
  |  |  |  |  329|      0|                eprosima::fastdds::dds::Log::Kind::Warning);                                                          \
  |  |  |  |  330|      0|        }                                                                                                             \
  |  |  |  |  331|    220|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (331:14): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 2598|    220|#endif // if HAVE_SECURITY
 2599|    220|        }
 2600|  10.4k|        else
 2601|  10.4k|        {
 2602|  10.4k|            EPROSIMA_LOG_ERROR(XMLPARSER, "Invalid element found into 'rtpsParticipantAttributesType'. Name: " << name);
  ------------------
  |  |   45|  10.4k|#define EPROSIMA_LOG_ERROR(cat, msg) EPROSIMA_LOG_ERROR_IMPL_(cat, msg)
  |  |  ------------------
  |  |  |  |  291|  10.4k|    do {                                                                                                               \
  |  |  |  |  292|  10.4k|        std::stringstream fastdds_log_ss_tmp__;                                                                        \
  |  |  |  |  293|  10.4k|        fastdds_log_ss_tmp__ << msg;                                                                                   \
  |  |  |  |  294|  10.4k|        eprosima::fastdds::dds::Log::QueueLog(                                                                         \
  |  |  |  |  295|  10.4k|            fastdds_log_ss_tmp__.str(), eprosima::fastdds::dds::Log::Context{__FILE__, __LINE__, __func__, #cat},      \
  |  |  |  |  296|  10.4k|            eprosima::fastdds::dds::Log::Kind::Error);                                                                 \
  |  |  |  |  297|  10.4k|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (297:14): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 2603|  10.4k|            return XMLP_ret::XML_ERROR;
 2604|  10.4k|        }
 2605|  66.8k|    }
 2606|  6.72k|    return XMLP_ret::XML_OK;
 2607|  65.3k|}
_ZN8eprosima7fastdds9xmlparser9XMLParser12fillDataNodeEPN8tinyxml210XMLElementERNS1_8DataNodeINS1_19PublisherAttributesEEE:
 2612|  35.3k|{
 2613|  35.3k|    if (nullptr == p_profile)
  ------------------
  |  Branch (2613:9): [True: 0, False: 35.3k]
  ------------------
 2614|      0|    {
 2615|      0|        EPROSIMA_LOG_ERROR(XMLPARSER, "Bad parameters!");
  ------------------
  |  |   45|      0|#define EPROSIMA_LOG_ERROR(cat, msg) EPROSIMA_LOG_ERROR_IMPL_(cat, msg)
  |  |  ------------------
  |  |  |  |  291|      0|    do {                                                                                                               \
  |  |  |  |  292|      0|        std::stringstream fastdds_log_ss_tmp__;                                                                        \
  |  |  |  |  293|      0|        fastdds_log_ss_tmp__ << msg;                                                                                   \
  |  |  |  |  294|      0|        eprosima::fastdds::dds::Log::QueueLog(                                                                         \
  |  |  |  |  295|      0|            fastdds_log_ss_tmp__.str(), eprosima::fastdds::dds::Log::Context{__FILE__, __LINE__, __func__, #cat},      \
  |  |  |  |  296|      0|            eprosima::fastdds::dds::Log::Kind::Error);                                                                 \
  |  |  |  |  297|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (297:14): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 2616|      0|        return XMLP_ret::XML_ERROR;
 2617|      0|    }
 2618|       |
 2619|  35.3k|    addAllAttributes(p_profile, publisher_node);
 2620|       |
 2621|  35.3k|    uint8_t ident = 1;
 2622|  35.3k|    if (XMLP_ret::XML_OK != getXMLPublisherAttributes(p_profile, *publisher_node.get(), ident))
  ------------------
  |  Branch (2622:9): [True: 14.4k, False: 20.8k]
  ------------------
 2623|  14.4k|    {
 2624|  14.4k|        return XMLP_ret::XML_ERROR;
 2625|  14.4k|    }
 2626|       |
 2627|  20.8k|    return XMLP_ret::XML_OK;
 2628|  35.3k|}
_ZN8eprosima7fastdds9xmlparser9XMLParser12fillDataNodeEPN8tinyxml210XMLElementERNS1_8DataNodeINS1_20SubscriberAttributesEEE:
 2633|  81.6k|{
 2634|  81.6k|    if (nullptr == p_profile)
  ------------------
  |  Branch (2634:9): [True: 0, False: 81.6k]
  ------------------
 2635|      0|    {
 2636|      0|        EPROSIMA_LOG_ERROR(XMLPARSER, "Bad parameters!");
  ------------------
  |  |   45|      0|#define EPROSIMA_LOG_ERROR(cat, msg) EPROSIMA_LOG_ERROR_IMPL_(cat, msg)
  |  |  ------------------
  |  |  |  |  291|      0|    do {                                                                                                               \
  |  |  |  |  292|      0|        std::stringstream fastdds_log_ss_tmp__;                                                                        \
  |  |  |  |  293|      0|        fastdds_log_ss_tmp__ << msg;                                                                                   \
  |  |  |  |  294|      0|        eprosima::fastdds::dds::Log::QueueLog(                                                                         \
  |  |  |  |  295|      0|            fastdds_log_ss_tmp__.str(), eprosima::fastdds::dds::Log::Context{__FILE__, __LINE__, __func__, #cat},      \
  |  |  |  |  296|      0|            eprosima::fastdds::dds::Log::Kind::Error);                                                                 \
  |  |  |  |  297|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (297:14): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 2637|      0|        return XMLP_ret::XML_ERROR;
 2638|      0|    }
 2639|       |
 2640|  81.6k|    addAllAttributes(p_profile, subscriber_node);
 2641|       |
 2642|  81.6k|    uint8_t ident = 1;
 2643|  81.6k|    if (XMLP_ret::XML_OK != getXMLSubscriberAttributes(p_profile, *subscriber_node.get(), ident))
  ------------------
  |  Branch (2643:9): [True: 13.4k, False: 68.2k]
  ------------------
 2644|  13.4k|    {
 2645|  13.4k|        return XMLP_ret::XML_ERROR;
 2646|  13.4k|    }
 2647|       |
 2648|  68.2k|    return XMLP_ret::XML_OK;
 2649|  81.6k|}
_ZN8eprosima7fastdds9xmlparser9XMLParser12fillDataNodeEPN8tinyxml210XMLElementERNS1_8DataNodeINS1_19RequesterAttributesEEE:
 2654|  12.8k|{
 2655|       |    /*
 2656|       |        <xs:complexType name="replierRequesterProfileType">
 2657|       |            <xs:all minOccurs="0">
 2658|       |                <xs:element name="request_topic_name" type="string" minOccurs="0"/>
 2659|       |                <xs:element name="reply_topic_name" type="string" minOccurs="0"/>
 2660|       |                <xs:element name="data_writer" type="publisherProfileNoAttributesType" minOccurs="0"/>
 2661|       |                <xs:element name="data_reader" type="subscriberProfileNoAttributesType" minOccurs="0"/>
 2662|       |            </xs:all>
 2663|       |            <xs:attribute name="profile_name" type="string" use="required"/>
 2664|       |            <xs:attribute name="service_name" type="string" use="required"/>
 2665|       |            <xs:attribute name="request_type" type="string" use="required"/>
 2666|       |            <xs:attribute name="reply_type" type="string" use="required"/>
 2667|       |        </xs:complexType>
 2668|       |     */
 2669|       |
 2670|  12.8k|    if (nullptr == p_profile)
  ------------------
  |  Branch (2670:9): [True: 0, False: 12.8k]
  ------------------
 2671|      0|    {
 2672|      0|        EPROSIMA_LOG_ERROR(XMLPARSER, "Bad parameters!");
  ------------------
  |  |   45|      0|#define EPROSIMA_LOG_ERROR(cat, msg) EPROSIMA_LOG_ERROR_IMPL_(cat, msg)
  |  |  ------------------
  |  |  |  |  291|      0|    do {                                                                                                               \
  |  |  |  |  292|      0|        std::stringstream fastdds_log_ss_tmp__;                                                                        \
  |  |  |  |  293|      0|        fastdds_log_ss_tmp__ << msg;                                                                                   \
  |  |  |  |  294|      0|        eprosima::fastdds::dds::Log::QueueLog(                                                                         \
  |  |  |  |  295|      0|            fastdds_log_ss_tmp__.str(), eprosima::fastdds::dds::Log::Context{__FILE__, __LINE__, __func__, #cat},      \
  |  |  |  |  296|      0|            eprosima::fastdds::dds::Log::Kind::Error);                                                                 \
  |  |  |  |  297|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (297:14): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 2673|      0|        return XMLP_ret::XML_ERROR;
 2674|      0|    }
 2675|       |
 2676|  12.8k|    addAllAttributes(p_profile, requester_node);
 2677|  12.8k|    auto found_attributes = requester_node.getAttributes();
 2678|       |
 2679|  12.8k|    auto it_attributes = found_attributes.find(SERVICE_NAME);
 2680|  12.8k|    if (found_attributes.end() != it_attributes)
  ------------------
  |  Branch (2680:9): [True: 11.0k, False: 1.85k]
  ------------------
 2681|  11.0k|    {
 2682|  11.0k|        requester_node.get()->service_name = it_attributes->second;
 2683|  11.0k|        requester_node.get()->request_topic_name = it_attributes->second + "_Request";
 2684|  11.0k|        requester_node.get()->reply_topic_name = it_attributes->second + "_Reply";
 2685|  11.0k|    }
 2686|  1.85k|    else
 2687|  1.85k|    {
 2688|  1.85k|        EPROSIMA_LOG_ERROR(XMLPARSER, "Not found required attribute " << SERVICE_NAME);
  ------------------
  |  |   45|  1.85k|#define EPROSIMA_LOG_ERROR(cat, msg) EPROSIMA_LOG_ERROR_IMPL_(cat, msg)
  |  |  ------------------
  |  |  |  |  291|  1.85k|    do {                                                                                                               \
  |  |  |  |  292|  1.85k|        std::stringstream fastdds_log_ss_tmp__;                                                                        \
  |  |  |  |  293|  1.85k|        fastdds_log_ss_tmp__ << msg;                                                                                   \
  |  |  |  |  294|  1.85k|        eprosima::fastdds::dds::Log::QueueLog(                                                                         \
  |  |  |  |  295|  1.85k|            fastdds_log_ss_tmp__.str(), eprosima::fastdds::dds::Log::Context{__FILE__, __LINE__, __func__, #cat},      \
  |  |  |  |  296|  1.85k|            eprosima::fastdds::dds::Log::Kind::Error);                                                                 \
  |  |  |  |  297|  1.85k|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (297:14): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 2689|  1.85k|        return XMLP_ret::XML_ERROR;
 2690|  1.85k|    }
 2691|       |
 2692|  11.0k|    it_attributes = found_attributes.find(REQUEST_TYPE);
 2693|  11.0k|    if (found_attributes.end() != it_attributes)
  ------------------
  |  Branch (2693:9): [True: 9.78k, False: 1.21k]
  ------------------
 2694|  9.78k|    {
 2695|  9.78k|        requester_node.get()->request_type = it_attributes->second;
 2696|  9.78k|    }
 2697|  1.21k|    else
 2698|  1.21k|    {
 2699|  1.21k|        EPROSIMA_LOG_ERROR(XMLPARSER, "Not found required attribute " << REQUEST_TYPE);
  ------------------
  |  |   45|  1.21k|#define EPROSIMA_LOG_ERROR(cat, msg) EPROSIMA_LOG_ERROR_IMPL_(cat, msg)
  |  |  ------------------
  |  |  |  |  291|  1.21k|    do {                                                                                                               \
  |  |  |  |  292|  1.21k|        std::stringstream fastdds_log_ss_tmp__;                                                                        \
  |  |  |  |  293|  1.21k|        fastdds_log_ss_tmp__ << msg;                                                                                   \
  |  |  |  |  294|  1.21k|        eprosima::fastdds::dds::Log::QueueLog(                                                                         \
  |  |  |  |  295|  1.21k|            fastdds_log_ss_tmp__.str(), eprosima::fastdds::dds::Log::Context{__FILE__, __LINE__, __func__, #cat},      \
  |  |  |  |  296|  1.21k|            eprosima::fastdds::dds::Log::Kind::Error);                                                                 \
  |  |  |  |  297|  1.21k|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (297:14): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 2700|  1.21k|        return XMLP_ret::XML_ERROR;
 2701|  1.21k|    }
 2702|       |
 2703|  9.78k|    it_attributes = found_attributes.find(REPLY_TYPE);
 2704|  9.78k|    if (found_attributes.end() != it_attributes)
  ------------------
  |  Branch (2704:9): [True: 9.33k, False: 442]
  ------------------
 2705|  9.33k|    {
 2706|  9.33k|        requester_node.get()->reply_type = it_attributes->second;
 2707|  9.33k|    }
 2708|    442|    else
 2709|    442|    {
 2710|    442|        EPROSIMA_LOG_ERROR(XMLPARSER, "Not found required attribute " << REPLY_TYPE);
  ------------------
  |  |   45|    442|#define EPROSIMA_LOG_ERROR(cat, msg) EPROSIMA_LOG_ERROR_IMPL_(cat, msg)
  |  |  ------------------
  |  |  |  |  291|    442|    do {                                                                                                               \
  |  |  |  |  292|    442|        std::stringstream fastdds_log_ss_tmp__;                                                                        \
  |  |  |  |  293|    442|        fastdds_log_ss_tmp__ << msg;                                                                                   \
  |  |  |  |  294|    442|        eprosima::fastdds::dds::Log::QueueLog(                                                                         \
  |  |  |  |  295|    442|            fastdds_log_ss_tmp__.str(), eprosima::fastdds::dds::Log::Context{__FILE__, __LINE__, __func__, #cat},      \
  |  |  |  |  296|    442|            eprosima::fastdds::dds::Log::Kind::Error);                                                                 \
  |  |  |  |  297|    442|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (297:14): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 2711|    442|        return XMLP_ret::XML_ERROR;
 2712|    442|    }
 2713|       |
 2714|  9.33k|    uint8_t ident = 1;
 2715|  9.33k|    tinyxml2::XMLElement* p_aux0 = nullptr;
 2716|  9.33k|    const char* name = nullptr;
 2717|       |
 2718|  10.2k|    for (p_aux0 = p_profile->FirstChildElement(); p_aux0 != nullptr; p_aux0 = p_aux0->NextSiblingElement())
  ------------------
  |  Branch (2718:51): [True: 2.34k, False: 7.93k]
  ------------------
 2719|  2.34k|    {
 2720|  2.34k|        name = p_aux0->Name();
 2721|  2.34k|        if (strcmp(name, REQUEST_TOPIC_NAME) == 0)
  ------------------
  |  Branch (2721:13): [True: 87, False: 2.26k]
  ------------------
 2722|     87|        {
 2723|     87|            if (XMLP_ret::XML_OK != getXMLString(p_aux0, &requester_node.get()->request_topic_name, ident))
  ------------------
  |  Branch (2723:17): [True: 87, False: 0]
  ------------------
 2724|     87|            {
 2725|     87|                return XMLP_ret::XML_ERROR;
 2726|     87|            }
 2727|     87|        }
 2728|  2.26k|        else if (strcmp(name, REPLY_TOPIC_NAME) == 0)
  ------------------
  |  Branch (2728:18): [True: 349, False: 1.91k]
  ------------------
 2729|    349|        {
 2730|    349|            if (XMLP_ret::XML_OK != getXMLString(p_aux0, &requester_node.get()->reply_topic_name, ident))
  ------------------
  |  Branch (2730:17): [True: 349, False: 0]
  ------------------
 2731|    349|            {
 2732|    349|                return XMLP_ret::XML_ERROR;
 2733|    349|            }
 2734|    349|        }
 2735|  1.91k|        else if (strcmp(name, PUBLISHER) == 0 || strcmp(name, DATA_WRITER) == 0)
  ------------------
  |  Branch (2735:18): [True: 249, False: 1.66k]
  |  Branch (2735:50): [True: 296, False: 1.36k]
  ------------------
 2736|    545|        {
 2737|    545|            if (XMLP_ret::XML_OK != getXMLPublisherAttributes(p_aux0, requester_node.get()->publisher, ident))
  ------------------
  |  Branch (2737:17): [True: 10, False: 535]
  ------------------
 2738|     10|            {
 2739|     10|                return XMLP_ret::XML_ERROR;
 2740|     10|            }
 2741|    545|        }
 2742|  1.36k|        else if (strcmp(name, SUBSCRIBER) == 0 || strcmp(name, DATA_READER) == 0)
  ------------------
  |  Branch (2742:18): [True: 340, False: 1.02k]
  |  Branch (2742:51): [True: 113, False: 913]
  ------------------
 2743|    453|        {
 2744|    453|            if (XMLP_ret::XML_OK != getXMLSubscriberAttributes(p_aux0, requester_node.get()->subscriber, ident))
  ------------------
  |  Branch (2744:17): [True: 46, False: 407]
  ------------------
 2745|     46|            {
 2746|     46|                return XMLP_ret::XML_ERROR;
 2747|     46|            }
 2748|    453|        }
 2749|    913|        else
 2750|    913|        {
 2751|    913|            EPROSIMA_LOG_ERROR(XMLPARSER, "Not expected tag: '" << name << "'");
  ------------------
  |  |   45|    913|#define EPROSIMA_LOG_ERROR(cat, msg) EPROSIMA_LOG_ERROR_IMPL_(cat, msg)
  |  |  ------------------
  |  |  |  |  291|    913|    do {                                                                                                               \
  |  |  |  |  292|    913|        std::stringstream fastdds_log_ss_tmp__;                                                                        \
  |  |  |  |  293|    913|        fastdds_log_ss_tmp__ << msg;                                                                                   \
  |  |  |  |  294|    913|        eprosima::fastdds::dds::Log::QueueLog(                                                                         \
  |  |  |  |  295|    913|            fastdds_log_ss_tmp__.str(), eprosima::fastdds::dds::Log::Context{__FILE__, __LINE__, __func__, #cat},      \
  |  |  |  |  296|    913|            eprosima::fastdds::dds::Log::Kind::Error);                                                                 \
  |  |  |  |  297|    913|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (297:14): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 2752|    913|            return XMLP_ret::XML_ERROR;
 2753|    913|        }
 2754|       |
 2755|  2.34k|    }
 2756|       |
 2757|  7.93k|    requester_node.get()->publisher.topic.topicDataType = requester_node.get()->request_type;
 2758|  7.93k|    requester_node.get()->publisher.topic.topicName = requester_node.get()->request_topic_name;
 2759|       |
 2760|  7.93k|    requester_node.get()->subscriber.topic.topicDataType = requester_node.get()->reply_type;
 2761|  7.93k|    requester_node.get()->subscriber.topic.topicName = requester_node.get()->reply_topic_name;
 2762|       |
 2763|  7.93k|    return XMLP_ret::XML_OK;
 2764|  9.33k|}
_ZN8eprosima7fastdds9xmlparser9XMLParser12fillDataNodeEPN8tinyxml210XMLElementERNS1_8DataNodeINS1_17ReplierAttributesEEE:
 2769|  15.4k|{
 2770|       |    /*
 2771|       |        <xs:complexType name="replierRequesterProfileType">
 2772|       |            <xs:all minOccurs="0">
 2773|       |                <xs:element name="request_topic_name" type="string" minOccurs="0"/>
 2774|       |                <xs:element name="reply_topic_name" type="string" minOccurs="0"/>
 2775|       |                <xs:element name="data_writer" type="publisherProfileNoAttributesType" minOccurs="0"/>
 2776|       |                <xs:element name="data_reader" type="subscriberProfileNoAttributesType" minOccurs="0"/>
 2777|       |            </xs:all>
 2778|       |            <xs:attribute name="profile_name" type="string" use="required"/>
 2779|       |            <xs:attribute name="service_name" type="string" use="required"/>
 2780|       |            <xs:attribute name="request_type" type="string" use="required"/>
 2781|       |            <xs:attribute name="reply_type" type="string" use="required"/>
 2782|       |        </xs:complexType>
 2783|       |     */
 2784|       |
 2785|  15.4k|    if (nullptr == p_profile)
  ------------------
  |  Branch (2785:9): [True: 0, False: 15.4k]
  ------------------
 2786|      0|    {
 2787|      0|        EPROSIMA_LOG_ERROR(XMLPARSER, "Bad parameters!");
  ------------------
  |  |   45|      0|#define EPROSIMA_LOG_ERROR(cat, msg) EPROSIMA_LOG_ERROR_IMPL_(cat, msg)
  |  |  ------------------
  |  |  |  |  291|      0|    do {                                                                                                               \
  |  |  |  |  292|      0|        std::stringstream fastdds_log_ss_tmp__;                                                                        \
  |  |  |  |  293|      0|        fastdds_log_ss_tmp__ << msg;                                                                                   \
  |  |  |  |  294|      0|        eprosima::fastdds::dds::Log::QueueLog(                                                                         \
  |  |  |  |  295|      0|            fastdds_log_ss_tmp__.str(), eprosima::fastdds::dds::Log::Context{__FILE__, __LINE__, __func__, #cat},      \
  |  |  |  |  296|      0|            eprosima::fastdds::dds::Log::Kind::Error);                                                                 \
  |  |  |  |  297|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (297:14): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 2788|      0|        return XMLP_ret::XML_ERROR;
 2789|      0|    }
 2790|       |
 2791|  15.4k|    addAllAttributes(p_profile, replier_node);
 2792|  15.4k|    auto found_attributes = replier_node.getAttributes();
 2793|       |
 2794|  15.4k|    auto it_attributes = found_attributes.find(SERVICE_NAME);
 2795|  15.4k|    if (found_attributes.end() != it_attributes)
  ------------------
  |  Branch (2795:9): [True: 10.7k, False: 4.72k]
  ------------------
 2796|  10.7k|    {
 2797|  10.7k|        replier_node.get()->service_name = it_attributes->second;
 2798|  10.7k|        replier_node.get()->request_topic_name = it_attributes->second + "_Request";
 2799|  10.7k|        replier_node.get()->reply_topic_name = it_attributes->second + "_Reply";
 2800|  10.7k|    }
 2801|  4.72k|    else
 2802|  4.72k|    {
 2803|  4.72k|        EPROSIMA_LOG_ERROR(XMLPARSER, "Not found required attribute " << SERVICE_NAME);
  ------------------
  |  |   45|  4.72k|#define EPROSIMA_LOG_ERROR(cat, msg) EPROSIMA_LOG_ERROR_IMPL_(cat, msg)
  |  |  ------------------
  |  |  |  |  291|  4.72k|    do {                                                                                                               \
  |  |  |  |  292|  4.72k|        std::stringstream fastdds_log_ss_tmp__;                                                                        \
  |  |  |  |  293|  4.72k|        fastdds_log_ss_tmp__ << msg;                                                                                   \
  |  |  |  |  294|  4.72k|        eprosima::fastdds::dds::Log::QueueLog(                                                                         \
  |  |  |  |  295|  4.72k|            fastdds_log_ss_tmp__.str(), eprosima::fastdds::dds::Log::Context{__FILE__, __LINE__, __func__, #cat},      \
  |  |  |  |  296|  4.72k|            eprosima::fastdds::dds::Log::Kind::Error);                                                                 \
  |  |  |  |  297|  4.72k|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (297:14): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 2804|  4.72k|        return XMLP_ret::XML_ERROR;
 2805|  4.72k|    }
 2806|       |
 2807|  10.7k|    it_attributes = found_attributes.find(REQUEST_TYPE);
 2808|  10.7k|    if (found_attributes.end() != it_attributes)
  ------------------
  |  Branch (2808:9): [True: 9.40k, False: 1.36k]
  ------------------
 2809|  9.40k|    {
 2810|  9.40k|        replier_node.get()->request_type = it_attributes->second;
 2811|  9.40k|    }
 2812|  1.36k|    else
 2813|  1.36k|    {
 2814|  1.36k|        EPROSIMA_LOG_ERROR(XMLPARSER, "Not found required attribute " << REQUEST_TYPE);
  ------------------
  |  |   45|  1.36k|#define EPROSIMA_LOG_ERROR(cat, msg) EPROSIMA_LOG_ERROR_IMPL_(cat, msg)
  |  |  ------------------
  |  |  |  |  291|  1.36k|    do {                                                                                                               \
  |  |  |  |  292|  1.36k|        std::stringstream fastdds_log_ss_tmp__;                                                                        \
  |  |  |  |  293|  1.36k|        fastdds_log_ss_tmp__ << msg;                                                                                   \
  |  |  |  |  294|  1.36k|        eprosima::fastdds::dds::Log::QueueLog(                                                                         \
  |  |  |  |  295|  1.36k|            fastdds_log_ss_tmp__.str(), eprosima::fastdds::dds::Log::Context{__FILE__, __LINE__, __func__, #cat},      \
  |  |  |  |  296|  1.36k|            eprosima::fastdds::dds::Log::Kind::Error);                                                                 \
  |  |  |  |  297|  1.36k|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (297:14): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 2815|  1.36k|        return XMLP_ret::XML_ERROR;
 2816|  1.36k|    }
 2817|       |
 2818|  9.40k|    it_attributes = found_attributes.find(REPLY_TYPE);
 2819|  9.40k|    if (found_attributes.end() != it_attributes)
  ------------------
  |  Branch (2819:9): [True: 8.95k, False: 457]
  ------------------
 2820|  8.95k|    {
 2821|  8.95k|        replier_node.get()->reply_type = it_attributes->second;
 2822|  8.95k|    }
 2823|    457|    else
 2824|    457|    {
 2825|    457|        EPROSIMA_LOG_ERROR(XMLPARSER, "Not found required attribute " << REPLY_TYPE);
  ------------------
  |  |   45|    457|#define EPROSIMA_LOG_ERROR(cat, msg) EPROSIMA_LOG_ERROR_IMPL_(cat, msg)
  |  |  ------------------
  |  |  |  |  291|    457|    do {                                                                                                               \
  |  |  |  |  292|    457|        std::stringstream fastdds_log_ss_tmp__;                                                                        \
  |  |  |  |  293|    457|        fastdds_log_ss_tmp__ << msg;                                                                                   \
  |  |  |  |  294|    457|        eprosima::fastdds::dds::Log::QueueLog(                                                                         \
  |  |  |  |  295|    457|            fastdds_log_ss_tmp__.str(), eprosima::fastdds::dds::Log::Context{__FILE__, __LINE__, __func__, #cat},      \
  |  |  |  |  296|    457|            eprosima::fastdds::dds::Log::Kind::Error);                                                                 \
  |  |  |  |  297|    457|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (297:14): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 2826|    457|        return XMLP_ret::XML_ERROR;
 2827|    457|    }
 2828|       |
 2829|  8.95k|    uint8_t ident = 1;
 2830|  8.95k|    tinyxml2::XMLElement* p_aux0 = nullptr;
 2831|  8.95k|    const char* name = nullptr;
 2832|       |
 2833|  10.6k|    for (p_aux0 = p_profile->FirstChildElement(); p_aux0 != nullptr; p_aux0 = p_aux0->NextSiblingElement())
  ------------------
  |  Branch (2833:51): [True: 3.28k, False: 7.32k]
  ------------------
 2834|  3.28k|    {
 2835|  3.28k|        name = p_aux0->Name();
 2836|  3.28k|        if (strcmp(name, REQUEST_TOPIC_NAME) == 0)
  ------------------
  |  Branch (2836:13): [True: 220, False: 3.06k]
  ------------------
 2837|    220|        {
 2838|    220|            if (XMLP_ret::XML_OK != getXMLString(p_aux0, &replier_node.get()->request_topic_name, ident))
  ------------------
  |  Branch (2838:17): [True: 220, False: 0]
  ------------------
 2839|    220|            {
 2840|    220|                return XMLP_ret::XML_ERROR;
 2841|    220|            }
 2842|    220|        }
 2843|  3.06k|        else if (strcmp(name, REPLY_TOPIC_NAME) == 0)
  ------------------
  |  Branch (2843:18): [True: 199, False: 2.86k]
  ------------------
 2844|    199|        {
 2845|    199|            if (XMLP_ret::XML_OK != getXMLString(p_aux0, &replier_node.get()->reply_topic_name, ident))
  ------------------
  |  Branch (2845:17): [True: 199, False: 0]
  ------------------
 2846|    199|            {
 2847|    199|                return XMLP_ret::XML_ERROR;
 2848|    199|            }
 2849|    199|        }
 2850|  2.86k|        else if (strcmp(name, PUBLISHER) == 0 || strcmp(name, DATA_WRITER) == 0)
  ------------------
  |  Branch (2850:18): [True: 307, False: 2.55k]
  |  Branch (2850:50): [True: 340, False: 2.21k]
  ------------------
 2851|    647|        {
 2852|    647|            if (XMLP_ret::XML_OK != getXMLPublisherAttributes(p_aux0, replier_node.get()->publisher, ident))
  ------------------
  |  Branch (2852:17): [True: 204, False: 443]
  ------------------
 2853|    204|            {
 2854|    204|                return XMLP_ret::XML_ERROR;
 2855|    204|            }
 2856|    647|        }
 2857|  2.21k|        else if (strcmp(name, SUBSCRIBER) == 0 || strcmp(name, DATA_READER) == 0)
  ------------------
  |  Branch (2857:18): [True: 457, False: 1.76k]
  |  Branch (2857:51): [True: 825, False: 937]
  ------------------
 2858|  1.28k|        {
 2859|  1.28k|            if (XMLP_ret::XML_OK != getXMLSubscriberAttributes(p_aux0, replier_node.get()->subscriber, ident))
  ------------------
  |  Branch (2859:17): [True: 66, False: 1.21k]
  ------------------
 2860|     66|            {
 2861|     66|                return XMLP_ret::XML_ERROR;
 2862|     66|            }
 2863|  1.28k|        }
 2864|    937|        else
 2865|    937|        {
 2866|    937|            EPROSIMA_LOG_ERROR(XMLPARSER, "Not expected tag: '" << name << "'");
  ------------------
  |  |   45|    937|#define EPROSIMA_LOG_ERROR(cat, msg) EPROSIMA_LOG_ERROR_IMPL_(cat, msg)
  |  |  ------------------
  |  |  |  |  291|    937|    do {                                                                                                               \
  |  |  |  |  292|    937|        std::stringstream fastdds_log_ss_tmp__;                                                                        \
  |  |  |  |  293|    937|        fastdds_log_ss_tmp__ << msg;                                                                                   \
  |  |  |  |  294|    937|        eprosima::fastdds::dds::Log::QueueLog(                                                                         \
  |  |  |  |  295|    937|            fastdds_log_ss_tmp__.str(), eprosima::fastdds::dds::Log::Context{__FILE__, __LINE__, __func__, #cat},      \
  |  |  |  |  296|    937|            eprosima::fastdds::dds::Log::Kind::Error);                                                                 \
  |  |  |  |  297|    937|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (297:14): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 2867|    937|            return XMLP_ret::XML_ERROR;
 2868|    937|        }
 2869|  3.28k|    }
 2870|       |
 2871|  7.32k|    replier_node.get()->subscriber.topic.topicDataType = replier_node.get()->request_type;
 2872|  7.32k|    replier_node.get()->subscriber.topic.topicName = replier_node.get()->request_topic_name;
 2873|       |
 2874|  7.32k|    replier_node.get()->publisher.topic.topicDataType = replier_node.get()->reply_type;
 2875|  7.32k|    replier_node.get()->publisher.topic.topicName = replier_node.get()->reply_topic_name;
 2876|       |
 2877|  7.32k|    return XMLP_ret::XML_OK;
 2878|  8.95k|}
_ZN8eprosima7fastdds9xmlparser9XMLParser16addAllAttributesINS1_15TopicAttributesEEEvPN8tinyxml210XMLElementERNS1_8DataNodeIT_EE:
 2151|  23.9k|{
 2152|  23.9k|    const tinyxml2::XMLAttribute* attrib;
 2153|  45.3k|    for (attrib = p_profile->FirstAttribute(); attrib != nullptr; attrib = attrib->Next())
  ------------------
  |  Branch (2153:48): [True: 21.4k, False: 23.9k]
  ------------------
 2154|  21.4k|    {
 2155|  21.4k|        node.addAttribute(attrib->Name(), attrib->Value());
 2156|  21.4k|    }
 2157|  23.9k|}
_ZN8eprosima7fastdds9xmlparser9XMLParser16addAllAttributesINS0_3dds27DomainParticipantFactoryQosEEEvPN8tinyxml210XMLElementERNS1_8DataNodeIT_EE:
 2151|  12.8k|{
 2152|  12.8k|    const tinyxml2::XMLAttribute* attrib;
 2153|  24.8k|    for (attrib = p_profile->FirstAttribute(); attrib != nullptr; attrib = attrib->Next())
  ------------------
  |  Branch (2153:48): [True: 11.9k, False: 12.8k]
  ------------------
 2154|  11.9k|    {
 2155|  11.9k|        node.addAttribute(attrib->Name(), attrib->Value());
 2156|  11.9k|    }
 2157|  12.8k|}
_ZN8eprosima7fastdds9xmlparser9XMLParser16addAllAttributesINS1_21ParticipantAttributesEEEvPN8tinyxml210XMLElementERNS1_8DataNodeIT_EE:
 2151|   105k|{
 2152|   105k|    const tinyxml2::XMLAttribute* attrib;
 2153|   128k|    for (attrib = p_profile->FirstAttribute(); attrib != nullptr; attrib = attrib->Next())
  ------------------
  |  Branch (2153:48): [True: 23.3k, False: 105k]
  ------------------
 2154|  23.3k|    {
 2155|  23.3k|        node.addAttribute(attrib->Name(), attrib->Value());
 2156|  23.3k|    }
 2157|   105k|}
_ZN8eprosima7fastdds9xmlparser9XMLParser16addAllAttributesINS1_19PublisherAttributesEEEvPN8tinyxml210XMLElementERNS1_8DataNodeIT_EE:
 2151|  35.3k|{
 2152|  35.3k|    const tinyxml2::XMLAttribute* attrib;
 2153|  52.5k|    for (attrib = p_profile->FirstAttribute(); attrib != nullptr; attrib = attrib->Next())
  ------------------
  |  Branch (2153:48): [True: 17.1k, False: 35.3k]
  ------------------
 2154|  17.1k|    {
 2155|  17.1k|        node.addAttribute(attrib->Name(), attrib->Value());
 2156|  17.1k|    }
 2157|  35.3k|}
_ZN8eprosima7fastdds9xmlparser9XMLParser16addAllAttributesINS1_20SubscriberAttributesEEEvPN8tinyxml210XMLElementERNS1_8DataNodeIT_EE:
 2151|  81.6k|{
 2152|  81.6k|    const tinyxml2::XMLAttribute* attrib;
 2153|   115k|    for (attrib = p_profile->FirstAttribute(); attrib != nullptr; attrib = attrib->Next())
  ------------------
  |  Branch (2153:48): [True: 33.8k, False: 81.6k]
  ------------------
 2154|  33.8k|    {
 2155|  33.8k|        node.addAttribute(attrib->Name(), attrib->Value());
 2156|  33.8k|    }
 2157|  81.6k|}
_ZN8eprosima7fastdds9xmlparser9XMLParser16addAllAttributesINS1_19RequesterAttributesEEEvPN8tinyxml210XMLElementERNS1_8DataNodeIT_EE:
 2151|  12.8k|{
 2152|  12.8k|    const tinyxml2::XMLAttribute* attrib;
 2153|  60.5k|    for (attrib = p_profile->FirstAttribute(); attrib != nullptr; attrib = attrib->Next())
  ------------------
  |  Branch (2153:48): [True: 47.7k, False: 12.8k]
  ------------------
 2154|  47.7k|    {
 2155|  47.7k|        node.addAttribute(attrib->Name(), attrib->Value());
 2156|  47.7k|    }
 2157|  12.8k|}
_ZN8eprosima7fastdds9xmlparser9XMLParser16addAllAttributesINS1_17ReplierAttributesEEEvPN8tinyxml210XMLElementERNS1_8DataNodeIT_EE:
 2151|  15.4k|{
 2152|  15.4k|    const tinyxml2::XMLAttribute* attrib;
 2153|  82.3k|    for (attrib = p_profile->FirstAttribute(); attrib != nullptr; attrib = attrib->Next())
  ------------------
  |  Branch (2153:48): [True: 66.8k, False: 15.4k]
  ------------------
 2154|  66.8k|    {
 2155|  66.8k|        node.addAttribute(attrib->Name(), attrib->Value());
 2156|  66.8k|    }
 2157|  15.4k|}

_ZN8eprosima7fastdds9xmlparser17XMLProfileManager13loadXMLStringEPKcm:
  741|  20.0k|{
  742|  20.0k|    up_base_node_t root_node;
  743|  20.0k|    XMLP_ret loaded_ret = XMLParser::loadXML(data, length, root_node);
  744|  20.0k|    if (!root_node || loaded_ret != XMLP_ret::XML_OK)
  ------------------
  |  Branch (744:9): [True: 127, False: 19.8k]
  |  Branch (744:23): [True: 16.7k, False: 3.14k]
  ------------------
  745|  16.8k|    {
  746|  16.8k|        EPROSIMA_LOG_ERROR(XMLPARSER, "Error parsing string");
  ------------------
  |  |   45|  16.8k|#define EPROSIMA_LOG_ERROR(cat, msg) EPROSIMA_LOG_ERROR_IMPL_(cat, msg)
  |  |  ------------------
  |  |  |  |  291|  16.8k|    do {                                                                                                               \
  |  |  |  |  292|  16.8k|        std::stringstream fastdds_log_ss_tmp__;                                                                        \
  |  |  |  |  293|  16.8k|        fastdds_log_ss_tmp__ << msg;                                                                                   \
  |  |  |  |  294|  16.8k|        eprosima::fastdds::dds::Log::QueueLog(                                                                         \
  |  |  |  |  295|  16.8k|            fastdds_log_ss_tmp__.str(), eprosima::fastdds::dds::Log::Context{__FILE__, __LINE__, __func__, #cat},      \
  |  |  |  |  296|  16.8k|            eprosima::fastdds::dds::Log::Kind::Error);                                                                 \
  |  |  |  |  297|  16.8k|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (297:14): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  747|  16.8k|        return XMLP_ret::XML_ERROR;
  748|  16.8k|    }
  749|       |
  750|  3.14k|    if (NodeType::ROOT == root_node->getType())
  ------------------
  |  Branch (750:9): [True: 699, False: 2.44k]
  ------------------
  751|    699|    {
  752|    699|        for (auto&& child: root_node->getChildren())
  ------------------
  |  Branch (752:26): [True: 3.52k, False: 657]
  ------------------
  753|  3.52k|        {
  754|  3.52k|            if (NodeType::PROFILES == child.get()->getType())
  ------------------
  |  Branch (754:17): [True: 42, False: 3.48k]
  ------------------
  755|     42|            {
  756|     42|                return XMLProfileManager::extractProfiles(std::move(child), "inmem");
  757|     42|            }
  758|  3.52k|        }
  759|    657|        return loaded_ret;
  760|    699|    }
  761|  2.44k|    else if (NodeType::PROFILES == root_node->getType())
  ------------------
  |  Branch (761:14): [True: 2.21k, False: 235]
  ------------------
  762|  2.21k|    {
  763|  2.21k|        return XMLProfileManager::extractProfiles(std::move(root_node), "inmem");
  764|  2.21k|    }
  765|       |
  766|    235|    return loaded_ret;
  767|  3.14k|}
_ZN8eprosima7fastdds9xmlparser17XMLProfileManager15extractProfilesENSt3__110unique_ptrINS1_8BaseNodeENS3_14default_deleteIS5_EEEERKNS3_12basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEE:
  772|  2.25k|{
  773|  2.25k|    assert(profiles != nullptr);
  774|       |
  775|  2.25k|    unsigned int profile_count = 0u;
  776|       |
  777|  2.25k|    XMLP_ret ret = XMLP_ret::XML_OK;
  778|  2.25k|    for (auto&& profile: profiles->getChildren())
  ------------------
  |  Branch (778:24): [True: 72.3k, False: 2.25k]
  ------------------
  779|  72.3k|    {
  780|  72.3k|        if (NodeType::DOMAINPARTICIPANT_FACTORY == profile->getType())
  ------------------
  |  Branch (780:13): [True: 6.19k, False: 66.1k]
  ------------------
  781|  6.19k|        {
  782|  6.19k|            if (XMLP_ret::XML_OK == extractDomainParticipantFactoryProfile(profile, filename))
  ------------------
  |  Branch (782:17): [True: 870, False: 5.32k]
  ------------------
  783|    870|            {
  784|    870|                ++profile_count;
  785|    870|            }
  786|  5.32k|            else
  787|  5.32k|            {
  788|  5.32k|                ret = XMLP_ret::XML_NOK;
  789|  5.32k|            }
  790|  6.19k|        }
  791|  66.1k|        else if (NodeType::PARTICIPANT == profile->getType())
  ------------------
  |  Branch (791:18): [True: 10.8k, False: 55.3k]
  ------------------
  792|  10.8k|        {
  793|  10.8k|            if (XMLP_ret::XML_OK == extractParticipantProfile(profile, filename))
  ------------------
  |  Branch (793:17): [True: 1.18k, False: 9.62k]
  ------------------
  794|  1.18k|            {
  795|  1.18k|                ++profile_count;
  796|  1.18k|            }
  797|  9.62k|            else
  798|  9.62k|            {
  799|  9.62k|                ret = XMLP_ret::XML_NOK;
  800|  9.62k|            }
  801|  10.8k|        }
  802|  55.3k|        else if (NodeType::PUBLISHER == profile.get()->getType())
  ------------------
  |  Branch (802:18): [True: 9.77k, False: 45.5k]
  ------------------
  803|  9.77k|        {
  804|  9.77k|            if (XMLP_ret::XML_OK == extractPublisherProfile(profile, filename))
  ------------------
  |  Branch (804:17): [True: 1.16k, False: 8.60k]
  ------------------
  805|  1.16k|            {
  806|  1.16k|                ++profile_count;
  807|  1.16k|            }
  808|  8.60k|            else
  809|  8.60k|            {
  810|  8.60k|                ret = XMLP_ret::XML_NOK;
  811|  8.60k|            }
  812|  9.77k|        }
  813|  45.5k|        else if (NodeType::SUBSCRIBER == profile.get()->getType())
  ------------------
  |  Branch (813:18): [True: 18.1k, False: 27.4k]
  ------------------
  814|  18.1k|        {
  815|  18.1k|            if (XMLP_ret::XML_OK == extractSubscriberProfile(profile, filename))
  ------------------
  |  Branch (815:17): [True: 1.21k, False: 16.9k]
  ------------------
  816|  1.21k|            {
  817|  1.21k|                ++profile_count;
  818|  1.21k|            }
  819|  16.9k|            else
  820|  16.9k|            {
  821|  16.9k|                ret = XMLP_ret::XML_NOK;
  822|  16.9k|            }
  823|  18.1k|        }
  824|  27.4k|        else if (NodeType::TOPIC == profile.get()->getType())
  ------------------
  |  Branch (824:18): [True: 15.6k, False: 11.8k]
  ------------------
  825|  15.6k|        {
  826|  15.6k|            if (XMLP_ret::XML_OK == extractTopicProfile(profile, filename))
  ------------------
  |  Branch (826:17): [True: 1.00k, False: 14.6k]
  ------------------
  827|  1.00k|            {
  828|  1.00k|                ++profile_count;
  829|  1.00k|            }
  830|  14.6k|            else
  831|  14.6k|            {
  832|  14.6k|                ret = XMLP_ret::XML_NOK;
  833|  14.6k|            }
  834|  15.6k|        }
  835|  11.8k|        else if (NodeType::REQUESTER == profile.get()->getType())
  ------------------
  |  Branch (835:18): [True: 6.48k, False: 5.38k]
  ------------------
  836|  6.48k|        {
  837|  6.48k|            if (XMLP_ret::XML_OK == extractRequesterProfile(profile, filename))
  ------------------
  |  Branch (837:17): [True: 402, False: 6.07k]
  ------------------
  838|    402|            {
  839|    402|                ++profile_count;
  840|    402|            }
  841|  6.07k|            else
  842|  6.07k|            {
  843|  6.07k|                ret = XMLP_ret::XML_NOK;
  844|  6.07k|            }
  845|  6.48k|        }
  846|  5.38k|        else if (NodeType::REPLIER == profile.get()->getType())
  ------------------
  |  Branch (846:18): [True: 5.38k, False: 0]
  ------------------
  847|  5.38k|        {
  848|  5.38k|            if (XMLP_ret::XML_OK == extractReplierProfile(profile, filename))
  ------------------
  |  Branch (848:17): [True: 421, False: 4.96k]
  ------------------
  849|    421|            {
  850|    421|                ++profile_count;
  851|    421|            }
  852|  4.96k|            else
  853|  4.96k|            {
  854|  4.96k|                ret = XMLP_ret::XML_NOK;
  855|  4.96k|            }
  856|  5.38k|        }
  857|  72.3k|    }
  858|       |
  859|  2.25k|    profile_count += static_cast<unsigned int>(transport_profiles_.size()); // Count transport profiles
  860|       |
  861|  2.25k|    if (profile_count == 0)
  ------------------
  |  Branch (861:9): [True: 889, False: 1.36k]
  ------------------
  862|    889|    {
  863|    889|        EPROSIMA_LOG_ERROR(XMLProfileManager, "Could not extract any profile");
  ------------------
  |  |   45|    889|#define EPROSIMA_LOG_ERROR(cat, msg) EPROSIMA_LOG_ERROR_IMPL_(cat, msg)
  |  |  ------------------
  |  |  |  |  291|    889|    do {                                                                                                               \
  |  |  |  |  292|    889|        std::stringstream fastdds_log_ss_tmp__;                                                                        \
  |  |  |  |  293|    889|        fastdds_log_ss_tmp__ << msg;                                                                                   \
  |  |  |  |  294|    889|        eprosima::fastdds::dds::Log::QueueLog(                                                                         \
  |  |  |  |  295|    889|            fastdds_log_ss_tmp__.str(), eprosima::fastdds::dds::Log::Context{__FILE__, __LINE__, __func__, #cat},      \
  |  |  |  |  296|    889|            eprosima::fastdds::dds::Log::Kind::Error);                                                                 \
  |  |  |  |  297|    889|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (297:14): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  864|    889|        ret = XMLP_ret::XML_ERROR;
  865|    889|    }
  866|       |
  867|  2.25k|    xml_files_.emplace(filename, ret);
  868|       |
  869|  2.25k|    return ret;
  870|  2.25k|}
_ZN8eprosima7fastdds9xmlparser17XMLProfileManager38extractDomainParticipantFactoryProfileERNSt3__110unique_ptrINS1_8BaseNodeENS3_14default_deleteIS5_EEEERKNS3_12basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEE:
  875|  6.19k|{
  876|  6.19k|    static_cast<void>(filename);
  877|  6.19k|    std::string profile_name = "";
  878|       |
  879|  6.19k|    p_node_participantfactory_t node_factory = dynamic_cast<p_node_participantfactory_t>(profile.get());
  880|  6.19k|    node_att_map_cit_t it = node_factory->getAttributes().find(PROFILE_NAME);
  881|  6.19k|    if (it == node_factory->getAttributes().end() || it->second.empty())
  ------------------
  |  Branch (881:9): [True: 925, False: 5.26k]
  |  Branch (881:9): [True: 1.39k, False: 4.79k]
  |  Branch (881:54): [True: 470, False: 4.79k]
  ------------------
  882|  1.39k|    {
  883|  1.39k|        EPROSIMA_LOG_ERROR(XMLPARSER, "Error adding profile from file '" << filename << "': no name found");
  ------------------
  |  |   45|  1.39k|#define EPROSIMA_LOG_ERROR(cat, msg) EPROSIMA_LOG_ERROR_IMPL_(cat, msg)
  |  |  ------------------
  |  |  |  |  291|  1.39k|    do {                                                                                                               \
  |  |  |  |  292|  1.39k|        std::stringstream fastdds_log_ss_tmp__;                                                                        \
  |  |  |  |  293|  1.39k|        fastdds_log_ss_tmp__ << msg;                                                                                   \
  |  |  |  |  294|  1.39k|        eprosima::fastdds::dds::Log::QueueLog(                                                                         \
  |  |  |  |  295|  1.39k|            fastdds_log_ss_tmp__.str(), eprosima::fastdds::dds::Log::Context{__FILE__, __LINE__, __func__, #cat},      \
  |  |  |  |  296|  1.39k|            eprosima::fastdds::dds::Log::Kind::Error);                                                                 \
  |  |  |  |  297|  1.39k|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (297:14): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  884|  1.39k|        return XMLP_ret::XML_ERROR;
  885|  1.39k|    }
  886|       |
  887|  4.79k|    profile_name = it->second;
  888|       |
  889|  4.79k|    std::pair<part_factory_map_iterator_t, bool> emplace = participant_factory_profiles_.emplace(profile_name,
  890|  4.79k|                    node_factory->getData());
  891|  4.79k|    if (false == emplace.second)
  ------------------
  |  Branch (891:9): [True: 3.92k, False: 870]
  ------------------
  892|  3.92k|    {
  893|  3.92k|        EPROSIMA_LOG_ERROR(XMLPARSER, "Error adding profile '" << profile_name << "' from file '" << filename << "'");
  ------------------
  |  |   45|  3.92k|#define EPROSIMA_LOG_ERROR(cat, msg) EPROSIMA_LOG_ERROR_IMPL_(cat, msg)
  |  |  ------------------
  |  |  |  |  291|  3.92k|    do {                                                                                                               \
  |  |  |  |  292|  3.92k|        std::stringstream fastdds_log_ss_tmp__;                                                                        \
  |  |  |  |  293|  3.92k|        fastdds_log_ss_tmp__ << msg;                                                                                   \
  |  |  |  |  294|  3.92k|        eprosima::fastdds::dds::Log::QueueLog(                                                                         \
  |  |  |  |  295|  3.92k|            fastdds_log_ss_tmp__.str(), eprosima::fastdds::dds::Log::Context{__FILE__, __LINE__, __func__, #cat},      \
  |  |  |  |  296|  3.92k|            eprosima::fastdds::dds::Log::Kind::Error);                                                                 \
  |  |  |  |  297|  3.92k|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (297:14): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  894|  3.92k|        return XMLP_ret::XML_ERROR;
  895|  3.92k|    }
  896|       |
  897|    870|    it = node_factory->getAttributes().find(DEFAULT_PROF);
  898|    870|    if (it != node_factory->getAttributes().end() && it->second == "true") // Set as default profile
  ------------------
  |  Branch (898:9): [True: 246, False: 624]
  |  Branch (898:9): [True: 59, False: 811]
  |  Branch (898:54): [True: 59, False: 187]
  ------------------
  899|     59|    {
  900|     59|        default_participant_factory_qos = *(emplace.first->second.get());
  901|     59|    }
  902|    870|    return XMLP_ret::XML_OK;
  903|  4.79k|}
_ZN8eprosima7fastdds9xmlparser17XMLProfileManager25extractParticipantProfileERNSt3__110unique_ptrINS1_8BaseNodeENS3_14default_deleteIS5_EEEERKNS3_12basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEE:
  908|  10.8k|{
  909|  10.8k|    (void)(filename);
  910|  10.8k|    std::string profile_name = "";
  911|       |
  912|  10.8k|    p_node_participant_t node_part = dynamic_cast<p_node_participant_t>(profile.get());
  913|  10.8k|    node_att_map_cit_t it = node_part->getAttributes().find(PROFILE_NAME);
  914|  10.8k|    if (it == node_part->getAttributes().end() || it->second.empty())
  ------------------
  |  Branch (914:9): [True: 2.10k, False: 8.70k]
  |  Branch (914:9): [True: 2.32k, False: 8.48k]
  |  Branch (914:51): [True: 225, False: 8.48k]
  ------------------
  915|  2.32k|    {
  916|  2.32k|        EPROSIMA_LOG_ERROR(XMLPARSER, "Error adding profile from file '" << filename << "': no name found");
  ------------------
  |  |   45|  2.32k|#define EPROSIMA_LOG_ERROR(cat, msg) EPROSIMA_LOG_ERROR_IMPL_(cat, msg)
  |  |  ------------------
  |  |  |  |  291|  2.32k|    do {                                                                                                               \
  |  |  |  |  292|  2.32k|        std::stringstream fastdds_log_ss_tmp__;                                                                        \
  |  |  |  |  293|  2.32k|        fastdds_log_ss_tmp__ << msg;                                                                                   \
  |  |  |  |  294|  2.32k|        eprosima::fastdds::dds::Log::QueueLog(                                                                         \
  |  |  |  |  295|  2.32k|            fastdds_log_ss_tmp__.str(), eprosima::fastdds::dds::Log::Context{__FILE__, __LINE__, __func__, #cat},      \
  |  |  |  |  296|  2.32k|            eprosima::fastdds::dds::Log::Kind::Error);                                                                 \
  |  |  |  |  297|  2.32k|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (297:14): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  917|  2.32k|        return XMLP_ret::XML_ERROR;
  918|  2.32k|    }
  919|       |
  920|  8.48k|    profile_name = it->second;
  921|       |
  922|  8.48k|    std::pair<part_map_iterator_t, bool> emplace = participant_profiles_.emplace(profile_name, node_part->getData());
  923|  8.48k|    if (false == emplace.second)
  ------------------
  |  Branch (923:9): [True: 7.30k, False: 1.18k]
  ------------------
  924|  7.30k|    {
  925|  7.30k|        EPROSIMA_LOG_ERROR(XMLPARSER, "Error adding profile '" << profile_name << "' from file '" << filename << "'");
  ------------------
  |  |   45|  7.30k|#define EPROSIMA_LOG_ERROR(cat, msg) EPROSIMA_LOG_ERROR_IMPL_(cat, msg)
  |  |  ------------------
  |  |  |  |  291|  7.30k|    do {                                                                                                               \
  |  |  |  |  292|  7.30k|        std::stringstream fastdds_log_ss_tmp__;                                                                        \
  |  |  |  |  293|  7.30k|        fastdds_log_ss_tmp__ << msg;                                                                                   \
  |  |  |  |  294|  7.30k|        eprosima::fastdds::dds::Log::QueueLog(                                                                         \
  |  |  |  |  295|  7.30k|            fastdds_log_ss_tmp__.str(), eprosima::fastdds::dds::Log::Context{__FILE__, __LINE__, __func__, #cat},      \
  |  |  |  |  296|  7.30k|            eprosima::fastdds::dds::Log::Kind::Error);                                                                 \
  |  |  |  |  297|  7.30k|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (297:14): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  926|  7.30k|        return XMLP_ret::XML_ERROR;
  927|  7.30k|    }
  928|       |
  929|  1.18k|    it = node_part->getAttributes().find(DEFAULT_PROF);
  930|  1.18k|    if (it != node_part->getAttributes().end() && it->second == "true") // Set as default profile
  ------------------
  |  Branch (930:9): [True: 430, False: 753]
  |  Branch (930:9): [True: 237, False: 946]
  |  Branch (930:51): [True: 237, False: 193]
  ------------------
  931|    237|    {
  932|       |        // +V+ TODO: LOG ERROR IN SECOND ATTEMPT
  933|    237|        default_participant_attributes = *(emplace.first->second.get());
  934|    237|    }
  935|  1.18k|    return XMLP_ret::XML_OK;
  936|  8.48k|}
_ZN8eprosima7fastdds9xmlparser17XMLProfileManager23extractPublisherProfileERNSt3__110unique_ptrINS1_8BaseNodeENS3_14default_deleteIS5_EEEERKNS3_12basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEE:
  941|  9.77k|{
  942|  9.77k|    (void)(filename);
  943|  9.77k|    std::string profile_name = "";
  944|       |
  945|  9.77k|    p_node_publisher_t node_part = dynamic_cast<p_node_publisher_t>(profile.get());
  946|  9.77k|    node_att_map_cit_t it = node_part->getAttributes().find(PROFILE_NAME);
  947|  9.77k|    if (it == node_part->getAttributes().end() || it->second.empty())
  ------------------
  |  Branch (947:9): [True: 1.44k, False: 8.33k]
  |  Branch (947:9): [True: 1.80k, False: 7.96k]
  |  Branch (947:51): [True: 365, False: 7.96k]
  ------------------
  948|  1.80k|    {
  949|  1.80k|        EPROSIMA_LOG_ERROR(XMLPARSER, "Error adding profile from file '" << filename << "': no name found");
  ------------------
  |  |   45|  1.80k|#define EPROSIMA_LOG_ERROR(cat, msg) EPROSIMA_LOG_ERROR_IMPL_(cat, msg)
  |  |  ------------------
  |  |  |  |  291|  1.80k|    do {                                                                                                               \
  |  |  |  |  292|  1.80k|        std::stringstream fastdds_log_ss_tmp__;                                                                        \
  |  |  |  |  293|  1.80k|        fastdds_log_ss_tmp__ << msg;                                                                                   \
  |  |  |  |  294|  1.80k|        eprosima::fastdds::dds::Log::QueueLog(                                                                         \
  |  |  |  |  295|  1.80k|            fastdds_log_ss_tmp__.str(), eprosima::fastdds::dds::Log::Context{__FILE__, __LINE__, __func__, #cat},      \
  |  |  |  |  296|  1.80k|            eprosima::fastdds::dds::Log::Kind::Error);                                                                 \
  |  |  |  |  297|  1.80k|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (297:14): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  950|  1.80k|        return XMLP_ret::XML_ERROR;
  951|  1.80k|    }
  952|       |
  953|  7.96k|    profile_name = it->second;
  954|       |
  955|  7.96k|    std::pair<publ_map_iterator_t, bool> emplace = publisher_profiles_.emplace(profile_name, node_part->getData());
  956|  7.96k|    if (false == emplace.second)
  ------------------
  |  Branch (956:9): [True: 6.79k, False: 1.16k]
  ------------------
  957|  6.79k|    {
  958|  6.79k|        EPROSIMA_LOG_ERROR(XMLPARSER, "Error adding profile '" << profile_name << "' from file '" << filename << "'");
  ------------------
  |  |   45|  6.79k|#define EPROSIMA_LOG_ERROR(cat, msg) EPROSIMA_LOG_ERROR_IMPL_(cat, msg)
  |  |  ------------------
  |  |  |  |  291|  6.79k|    do {                                                                                                               \
  |  |  |  |  292|  6.79k|        std::stringstream fastdds_log_ss_tmp__;                                                                        \
  |  |  |  |  293|  6.79k|        fastdds_log_ss_tmp__ << msg;                                                                                   \
  |  |  |  |  294|  6.79k|        eprosima::fastdds::dds::Log::QueueLog(                                                                         \
  |  |  |  |  295|  6.79k|            fastdds_log_ss_tmp__.str(), eprosima::fastdds::dds::Log::Context{__FILE__, __LINE__, __func__, #cat},      \
  |  |  |  |  296|  6.79k|            eprosima::fastdds::dds::Log::Kind::Error);                                                                 \
  |  |  |  |  297|  6.79k|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (297:14): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  959|  6.79k|        return XMLP_ret::XML_ERROR;
  960|  6.79k|    }
  961|       |
  962|  1.16k|    it = node_part->getAttributes().find(DEFAULT_PROF);
  963|  1.16k|    if (it != node_part->getAttributes().end() && it->second == "true") // Set as default profile
  ------------------
  |  Branch (963:9): [True: 423, False: 744]
  |  Branch (963:9): [True: 230, False: 937]
  |  Branch (963:51): [True: 230, False: 193]
  ------------------
  964|    230|    {
  965|       |        // +V+ TODO: LOG ERROR IN SECOND ATTEMPT
  966|    230|        default_publisher_attributes = *(emplace.first->second.get());
  967|    230|    }
  968|  1.16k|    return XMLP_ret::XML_OK;
  969|  7.96k|}
_ZN8eprosima7fastdds9xmlparser17XMLProfileManager24extractSubscriberProfileERNSt3__110unique_ptrINS1_8BaseNodeENS3_14default_deleteIS5_EEEERKNS3_12basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEE:
  974|  18.1k|{
  975|  18.1k|    (void)(filename);
  976|  18.1k|    std::string profile_name = "";
  977|       |
  978|  18.1k|    p_node_subscriber_t node_part = dynamic_cast<p_node_subscriber_t>(profile.get());
  979|  18.1k|    node_att_map_cit_t it = node_part->getAttributes().find(PROFILE_NAME);
  980|  18.1k|    if (it == node_part->getAttributes().end() || it->second.empty())
  ------------------
  |  Branch (980:9): [True: 1.47k, False: 16.6k]
  |  Branch (980:9): [True: 1.71k, False: 16.3k]
  |  Branch (980:51): [True: 245, False: 16.3k]
  ------------------
  981|  1.71k|    {
  982|  1.71k|        EPROSIMA_LOG_ERROR(XMLPARSER, "Error adding profile from file '" << filename << "': no name found");
  ------------------
  |  |   45|  1.71k|#define EPROSIMA_LOG_ERROR(cat, msg) EPROSIMA_LOG_ERROR_IMPL_(cat, msg)
  |  |  ------------------
  |  |  |  |  291|  1.71k|    do {                                                                                                               \
  |  |  |  |  292|  1.71k|        std::stringstream fastdds_log_ss_tmp__;                                                                        \
  |  |  |  |  293|  1.71k|        fastdds_log_ss_tmp__ << msg;                                                                                   \
  |  |  |  |  294|  1.71k|        eprosima::fastdds::dds::Log::QueueLog(                                                                         \
  |  |  |  |  295|  1.71k|            fastdds_log_ss_tmp__.str(), eprosima::fastdds::dds::Log::Context{__FILE__, __LINE__, __func__, #cat},      \
  |  |  |  |  296|  1.71k|            eprosima::fastdds::dds::Log::Kind::Error);                                                                 \
  |  |  |  |  297|  1.71k|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (297:14): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  983|  1.71k|        return XMLP_ret::XML_ERROR;
  984|  1.71k|    }
  985|       |
  986|  16.3k|    profile_name = it->second;
  987|       |
  988|  16.3k|    std::pair<subs_map_iterator_t, bool> emplace = subscriber_profiles_.emplace(profile_name, node_part->getData());
  989|  16.3k|    if (false == emplace.second)
  ------------------
  |  Branch (989:9): [True: 15.1k, False: 1.21k]
  ------------------
  990|  15.1k|    {
  991|  15.1k|        EPROSIMA_LOG_ERROR(XMLPARSER, "Error adding profile '" << profile_name << "' from file '" << filename << "'");
  ------------------
  |  |   45|  15.1k|#define EPROSIMA_LOG_ERROR(cat, msg) EPROSIMA_LOG_ERROR_IMPL_(cat, msg)
  |  |  ------------------
  |  |  |  |  291|  15.1k|    do {                                                                                                               \
  |  |  |  |  292|  15.1k|        std::stringstream fastdds_log_ss_tmp__;                                                                        \
  |  |  |  |  293|  15.1k|        fastdds_log_ss_tmp__ << msg;                                                                                   \
  |  |  |  |  294|  15.1k|        eprosima::fastdds::dds::Log::QueueLog(                                                                         \
  |  |  |  |  295|  15.1k|            fastdds_log_ss_tmp__.str(), eprosima::fastdds::dds::Log::Context{__FILE__, __LINE__, __func__, #cat},      \
  |  |  |  |  296|  15.1k|            eprosima::fastdds::dds::Log::Kind::Error);                                                                 \
  |  |  |  |  297|  15.1k|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (297:14): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  992|  15.1k|        return XMLP_ret::XML_ERROR;
  993|  15.1k|    }
  994|       |
  995|  1.21k|    it = node_part->getAttributes().find(DEFAULT_PROF);
  996|  1.21k|    if (it != node_part->getAttributes().end() && it->second == "true") // Set as default profile
  ------------------
  |  Branch (996:9): [True: 571, False: 640]
  |  Branch (996:9): [True: 242, False: 969]
  |  Branch (996:51): [True: 242, False: 329]
  ------------------
  997|    242|    {
  998|       |        // +V+ TODO: LOG ERROR IN SECOND ATTEMPT
  999|    242|        default_subscriber_attributes = *(emplace.first->second.get());
 1000|    242|    }
 1001|  1.21k|    return XMLP_ret::XML_OK;
 1002|  16.3k|}
_ZN8eprosima7fastdds9xmlparser17XMLProfileManager30insertDynamicTypeBuilderByNameERKNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEERKNS3_10shared_ptrINS0_3dds18DynamicTypeBuilderEEE:
 1042|  1.30k|{
 1043|  1.30k|    if (dynamic_types_.find(type_name) == dynamic_types_.end())
  ------------------
  |  Branch (1043:9): [True: 1.30k, False: 0]
  ------------------
 1044|  1.30k|    {
 1045|  1.30k|        dynamic_types_.emplace(std::make_pair(type_name, type));
 1046|  1.30k|        return true;
 1047|  1.30k|    }
 1048|      0|    EPROSIMA_LOG_ERROR(XMLPARSER, "Error adding the type " << type_name << ". There is other type with the same name.");
  ------------------
  |  |   45|      0|#define EPROSIMA_LOG_ERROR(cat, msg) EPROSIMA_LOG_ERROR_IMPL_(cat, msg)
  |  |  ------------------
  |  |  |  |  291|      0|    do {                                                                                                               \
  |  |  |  |  292|      0|        std::stringstream fastdds_log_ss_tmp__;                                                                        \
  |  |  |  |  293|      0|        fastdds_log_ss_tmp__ << msg;                                                                                   \
  |  |  |  |  294|      0|        eprosima::fastdds::dds::Log::QueueLog(                                                                         \
  |  |  |  |  295|      0|            fastdds_log_ss_tmp__.str(), eprosima::fastdds::dds::Log::Context{__FILE__, __LINE__, __func__, #cat},      \
  |  |  |  |  296|      0|            eprosima::fastdds::dds::Log::Kind::Error);                                                                 \
  |  |  |  |  297|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (297:14): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1049|      0|    return false;
 1050|  1.30k|}
_ZN8eprosima7fastdds9xmlparser17XMLProfileManager27getDynamicTypeBuilderByNameERNSt3__110shared_ptrINS0_3dds18DynamicTypeBuilderEEERKNS3_12basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEE:
 1055|  85.7k|{
 1056|  85.7k|    if (dynamic_types_.find(type_name) != dynamic_types_.end())
  ------------------
  |  Branch (1056:9): [True: 18.6k, False: 67.0k]
  ------------------
 1057|  18.6k|    {
 1058|  18.6k|        dynamic_type = dynamic_types_[type_name];
 1059|  18.6k|        return XMLP_ret::XML_OK;
 1060|  18.6k|    }
 1061|       |
 1062|  67.0k|    return XMLP_ret::XML_ERROR;
 1063|  85.7k|}
_ZN8eprosima7fastdds9xmlparser17XMLProfileManager19extractTopicProfileERNSt3__110unique_ptrINS1_8BaseNodeENS3_14default_deleteIS5_EEEERKNS3_12basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEE:
 1068|  15.6k|{
 1069|  15.6k|    (void)(filename);
 1070|  15.6k|    std::string profile_name = "";
 1071|       |
 1072|  15.6k|    p_node_topic_t node_topic = dynamic_cast<p_node_topic_t>(profile.get());
 1073|  15.6k|    node_att_map_cit_t it = node_topic->getAttributes().find(PROFILE_NAME);
 1074|  15.6k|    if (it == node_topic->getAttributes().end() || it->second.empty())
  ------------------
  |  Branch (1074:9): [True: 3.35k, False: 12.2k]
  |  Branch (1074:9): [True: 3.77k, False: 11.8k]
  |  Branch (1074:52): [True: 426, False: 11.8k]
  ------------------
 1075|  3.77k|    {
 1076|  3.77k|        EPROSIMA_LOG_ERROR(XMLPARSER, "Error adding profile from file '" << filename << "': no name found");
  ------------------
  |  |   45|  3.77k|#define EPROSIMA_LOG_ERROR(cat, msg) EPROSIMA_LOG_ERROR_IMPL_(cat, msg)
  |  |  ------------------
  |  |  |  |  291|  3.77k|    do {                                                                                                               \
  |  |  |  |  292|  3.77k|        std::stringstream fastdds_log_ss_tmp__;                                                                        \
  |  |  |  |  293|  3.77k|        fastdds_log_ss_tmp__ << msg;                                                                                   \
  |  |  |  |  294|  3.77k|        eprosima::fastdds::dds::Log::QueueLog(                                                                         \
  |  |  |  |  295|  3.77k|            fastdds_log_ss_tmp__.str(), eprosima::fastdds::dds::Log::Context{__FILE__, __LINE__, __func__, #cat},      \
  |  |  |  |  296|  3.77k|            eprosima::fastdds::dds::Log::Kind::Error);                                                                 \
  |  |  |  |  297|  3.77k|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (297:14): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1077|  3.77k|        return XMLP_ret::XML_ERROR;
 1078|  3.77k|    }
 1079|       |
 1080|  11.8k|    profile_name = it->second;
 1081|       |
 1082|  11.8k|    std::pair<topic_map_iterator_t, bool> emplace = topic_profiles_.emplace(profile_name, node_topic->getData());
 1083|  11.8k|    if (false == emplace.second)
  ------------------
  |  Branch (1083:9): [True: 10.8k, False: 1.00k]
  ------------------
 1084|  10.8k|    {
 1085|  10.8k|        EPROSIMA_LOG_ERROR(XMLPARSER, "Error adding profile '" << profile_name << "' from file '" << filename << "'");
  ------------------
  |  |   45|  10.8k|#define EPROSIMA_LOG_ERROR(cat, msg) EPROSIMA_LOG_ERROR_IMPL_(cat, msg)
  |  |  ------------------
  |  |  |  |  291|  10.8k|    do {                                                                                                               \
  |  |  |  |  292|  10.8k|        std::stringstream fastdds_log_ss_tmp__;                                                                        \
  |  |  |  |  293|  10.8k|        fastdds_log_ss_tmp__ << msg;                                                                                   \
  |  |  |  |  294|  10.8k|        eprosima::fastdds::dds::Log::QueueLog(                                                                         \
  |  |  |  |  295|  10.8k|            fastdds_log_ss_tmp__.str(), eprosima::fastdds::dds::Log::Context{__FILE__, __LINE__, __func__, #cat},      \
  |  |  |  |  296|  10.8k|            eprosima::fastdds::dds::Log::Kind::Error);                                                                 \
  |  |  |  |  297|  10.8k|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (297:14): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1086|  10.8k|        return XMLP_ret::XML_ERROR;
 1087|  10.8k|    }
 1088|       |
 1089|  1.00k|    it = node_topic->getAttributes().find(DEFAULT_PROF);
 1090|  1.00k|    if (it != node_topic->getAttributes().end() && it->second == "true")
  ------------------
  |  Branch (1090:9): [True: 270, False: 738]
  |  Branch (1090:9): [True: 88, False: 920]
  |  Branch (1090:52): [True: 88, False: 182]
  ------------------
 1091|     88|    {
 1092|       |        // +V+ TODO: LOG ERROR IN SECOND ATTEMPT
 1093|     88|        default_topic_attributes = *(emplace.first->second.get());
 1094|     88|    }
 1095|  1.00k|    return XMLP_ret::XML_OK;
 1096|  11.8k|}
_ZN8eprosima7fastdds9xmlparser17XMLProfileManager23extractRequesterProfileERNSt3__110unique_ptrINS1_8BaseNodeENS3_14default_deleteIS5_EEEERKNS3_12basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEE:
 1101|  6.48k|{
 1102|  6.48k|    (void)(filename);
 1103|  6.48k|    std::string profile_name = "";
 1104|       |
 1105|  6.48k|    p_node_requester_t node_requester = dynamic_cast<p_node_requester_t>(profile.get());
 1106|  6.48k|    node_att_map_cit_t it = node_requester->getAttributes().find(PROFILE_NAME);
 1107|  6.48k|    if (it == node_requester->getAttributes().end() || it->second.empty())
  ------------------
  |  Branch (1107:9): [True: 1.16k, False: 5.31k]
  |  Branch (1107:9): [True: 1.50k, False: 4.97k]
  |  Branch (1107:56): [True: 344, False: 4.97k]
  ------------------
 1108|  1.50k|    {
 1109|  1.50k|        EPROSIMA_LOG_ERROR(XMLPARSER, "Error adding profile from file '" << filename << "': no name found");
  ------------------
  |  |   45|  1.50k|#define EPROSIMA_LOG_ERROR(cat, msg) EPROSIMA_LOG_ERROR_IMPL_(cat, msg)
  |  |  ------------------
  |  |  |  |  291|  1.50k|    do {                                                                                                               \
  |  |  |  |  292|  1.50k|        std::stringstream fastdds_log_ss_tmp__;                                                                        \
  |  |  |  |  293|  1.50k|        fastdds_log_ss_tmp__ << msg;                                                                                   \
  |  |  |  |  294|  1.50k|        eprosima::fastdds::dds::Log::QueueLog(                                                                         \
  |  |  |  |  295|  1.50k|            fastdds_log_ss_tmp__.str(), eprosima::fastdds::dds::Log::Context{__FILE__, __LINE__, __func__, #cat},      \
  |  |  |  |  296|  1.50k|            eprosima::fastdds::dds::Log::Kind::Error);                                                                 \
  |  |  |  |  297|  1.50k|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (297:14): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1110|  1.50k|        return XMLP_ret::XML_ERROR;
 1111|  1.50k|    }
 1112|       |
 1113|  4.97k|    profile_name = it->second;
 1114|       |
 1115|  4.97k|    std::pair<requester_map_iterator_t, bool> emplace = requester_profiles_.emplace(profile_name,
 1116|  4.97k|                    node_requester->getData());
 1117|  4.97k|    if (false == emplace.second)
  ------------------
  |  Branch (1117:9): [True: 4.57k, False: 402]
  ------------------
 1118|  4.57k|    {
 1119|  4.57k|        EPROSIMA_LOG_ERROR(XMLPARSER, "Error adding profile '" << profile_name << "' from file '" << filename << "'");
  ------------------
  |  |   45|  4.57k|#define EPROSIMA_LOG_ERROR(cat, msg) EPROSIMA_LOG_ERROR_IMPL_(cat, msg)
  |  |  ------------------
  |  |  |  |  291|  4.57k|    do {                                                                                                               \
  |  |  |  |  292|  4.57k|        std::stringstream fastdds_log_ss_tmp__;                                                                        \
  |  |  |  |  293|  4.57k|        fastdds_log_ss_tmp__ << msg;                                                                                   \
  |  |  |  |  294|  4.57k|        eprosima::fastdds::dds::Log::QueueLog(                                                                         \
  |  |  |  |  295|  4.57k|            fastdds_log_ss_tmp__.str(), eprosima::fastdds::dds::Log::Context{__FILE__, __LINE__, __func__, #cat},      \
  |  |  |  |  296|  4.57k|            eprosima::fastdds::dds::Log::Kind::Error);                                                                 \
  |  |  |  |  297|  4.57k|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (297:14): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1120|  4.57k|        return XMLP_ret::XML_ERROR;
 1121|  4.57k|    }
 1122|       |
 1123|    402|    return XMLP_ret::XML_OK;
 1124|  4.97k|}
_ZN8eprosima7fastdds9xmlparser17XMLProfileManager21extractReplierProfileERNSt3__110unique_ptrINS1_8BaseNodeENS3_14default_deleteIS5_EEEERKNS3_12basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEE:
 1129|  5.38k|{
 1130|  5.38k|    (void)(filename);
 1131|  5.38k|    std::string profile_name = "";
 1132|       |
 1133|  5.38k|    p_node_replier_t node_replier = dynamic_cast<p_node_replier_t>(profile.get());
 1134|  5.38k|    node_att_map_cit_t it = node_replier->getAttributes().find(PROFILE_NAME);
 1135|  5.38k|    if (it == node_replier->getAttributes().end() || it->second.empty())
  ------------------
  |  Branch (1135:9): [True: 1.17k, False: 4.21k]
  |  Branch (1135:9): [True: 1.23k, False: 4.14k]
  |  Branch (1135:54): [True: 67, False: 4.14k]
  ------------------
 1136|  1.23k|    {
 1137|  1.23k|        EPROSIMA_LOG_ERROR(XMLPARSER, "Error adding profile from file '" << filename << "': no name found");
  ------------------
  |  |   45|  1.23k|#define EPROSIMA_LOG_ERROR(cat, msg) EPROSIMA_LOG_ERROR_IMPL_(cat, msg)
  |  |  ------------------
  |  |  |  |  291|  1.23k|    do {                                                                                                               \
  |  |  |  |  292|  1.23k|        std::stringstream fastdds_log_ss_tmp__;                                                                        \
  |  |  |  |  293|  1.23k|        fastdds_log_ss_tmp__ << msg;                                                                                   \
  |  |  |  |  294|  1.23k|        eprosima::fastdds::dds::Log::QueueLog(                                                                         \
  |  |  |  |  295|  1.23k|            fastdds_log_ss_tmp__.str(), eprosima::fastdds::dds::Log::Context{__FILE__, __LINE__, __func__, #cat},      \
  |  |  |  |  296|  1.23k|            eprosima::fastdds::dds::Log::Kind::Error);                                                                 \
  |  |  |  |  297|  1.23k|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (297:14): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1138|  1.23k|        return XMLP_ret::XML_ERROR;
 1139|  1.23k|    }
 1140|       |
 1141|  4.14k|    profile_name = it->second;
 1142|       |
 1143|  4.14k|    std::pair<replier_map_iterator_t, bool> emplace = replier_profiles_.emplace(profile_name, node_replier->getData());
 1144|  4.14k|    if (false == emplace.second)
  ------------------
  |  Branch (1144:9): [True: 3.72k, False: 421]
  ------------------
 1145|  3.72k|    {
 1146|  3.72k|        EPROSIMA_LOG_ERROR(XMLPARSER, "Error adding profile '" << profile_name << "' from file '" << filename << "'");
  ------------------
  |  |   45|  3.72k|#define EPROSIMA_LOG_ERROR(cat, msg) EPROSIMA_LOG_ERROR_IMPL_(cat, msg)
  |  |  ------------------
  |  |  |  |  291|  3.72k|    do {                                                                                                               \
  |  |  |  |  292|  3.72k|        std::stringstream fastdds_log_ss_tmp__;                                                                        \
  |  |  |  |  293|  3.72k|        fastdds_log_ss_tmp__ << msg;                                                                                   \
  |  |  |  |  294|  3.72k|        eprosima::fastdds::dds::Log::QueueLog(                                                                         \
  |  |  |  |  295|  3.72k|            fastdds_log_ss_tmp__.str(), eprosima::fastdds::dds::Log::Context{__FILE__, __LINE__, __func__, #cat},      \
  |  |  |  |  296|  3.72k|            eprosima::fastdds::dds::Log::Kind::Error);                                                                 \
  |  |  |  |  297|  3.72k|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (297:14): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1147|  3.72k|        return XMLP_ret::XML_ERROR;
 1148|  3.72k|    }
 1149|       |
 1150|    421|    return XMLP_ret::XML_OK;
 1151|  4.14k|}

_ZNK8eprosima7fastdds9xmlparser8BaseNode7getTypeEv:
   59|   293k|    {
   60|   293k|        return data_type_;
   61|   293k|    }
_ZN8eprosima7fastdds9xmlparser8BaseNode11getChildrenEv:
  111|  2.95k|    {
  112|  2.95k|        return children;
  113|  2.95k|    }
_ZN8eprosima7fastdds9xmlparser8DataNodeINS0_3dds27DomainParticipantFactoryQosEE13getAttributesEv:
  213|  14.1k|{
  214|  14.1k|    return attributes_;
  215|  14.1k|}
_ZN8eprosima7fastdds9xmlparser8DataNodeINS0_3dds27DomainParticipantFactoryQosEE7getDataEv:
  192|  4.79k|{
  193|  4.79k|    return std::move(data_);
  194|  4.79k|}
_ZN8eprosima7fastdds9xmlparser8DataNodeINS1_21ParticipantAttributesEE13getAttributesEv:
  213|  23.9k|{
  214|  23.9k|    return attributes_;
  215|  23.9k|}
_ZN8eprosima7fastdds9xmlparser8DataNodeINS1_21ParticipantAttributesEE7getDataEv:
  192|  8.48k|{
  193|  8.48k|    return std::move(data_);
  194|  8.48k|}
_ZN8eprosima7fastdds9xmlparser8DataNodeINS1_19PublisherAttributesEE13getAttributesEv:
  213|  21.8k|{
  214|  21.8k|    return attributes_;
  215|  21.8k|}
_ZN8eprosima7fastdds9xmlparser8DataNodeINS1_19PublisherAttributesEE7getDataEv:
  192|  7.96k|{
  193|  7.96k|    return std::move(data_);
  194|  7.96k|}
_ZN8eprosima7fastdds9xmlparser8DataNodeINS1_20SubscriberAttributesEE13getAttributesEv:
  213|  38.6k|{
  214|  38.6k|    return attributes_;
  215|  38.6k|}
_ZN8eprosima7fastdds9xmlparser8DataNodeINS1_20SubscriberAttributesEE7getDataEv:
  192|  16.3k|{
  193|  16.3k|    return std::move(data_);
  194|  16.3k|}
_ZN8eprosima7fastdds9xmlparser8DataNodeINS1_15TopicAttributesEE13getAttributesEv:
  213|  33.2k|{
  214|  33.2k|    return attributes_;
  215|  33.2k|}
_ZN8eprosima7fastdds9xmlparser8DataNodeINS1_15TopicAttributesEE7getDataEv:
  192|  11.8k|{
  193|  11.8k|    return std::move(data_);
  194|  11.8k|}
_ZN8eprosima7fastdds9xmlparser8DataNodeINS1_19RequesterAttributesEE13getAttributesEv:
  213|  25.8k|{
  214|  25.8k|    return attributes_;
  215|  25.8k|}
_ZN8eprosima7fastdds9xmlparser8DataNodeINS1_19RequesterAttributesEE7getDataEv:
  192|  4.97k|{
  193|  4.97k|    return std::move(data_);
  194|  4.97k|}
_ZN8eprosima7fastdds9xmlparser8DataNodeINS1_17ReplierAttributesEE13getAttributesEv:
  213|  26.2k|{
  214|  26.2k|    return attributes_;
  215|  26.2k|}
_ZN8eprosima7fastdds9xmlparser8DataNodeINS1_17ReplierAttributesEE7getDataEv:
  192|  4.14k|{
  193|  4.14k|    return std::move(data_);
  194|  4.14k|}
_ZN8eprosima7fastdds9xmlparser8BaseNodeC2ENS1_8NodeTypeE:
   41|   316k|        : data_type_(type)
   42|   316k|        , parent_(nullptr)
   43|   316k|    {
   44|   316k|    }
_ZN8eprosima7fastdds9xmlparser8BaseNode8addChildENSt3__110unique_ptrIS2_NS3_14default_deleteIS2_EEEE:
   65|   189k|    {
   66|   189k|        child->setParent(this);
   67|   189k|        children.push_back(std::move(child));
   68|   189k|    }
_ZN8eprosima7fastdds9xmlparser8BaseNode9setParentEPS2_:
  101|   189k|    {
  102|   189k|        parent_ = parent;
  103|   189k|    }
_ZN8eprosima7fastdds9xmlparser8BaseNodeD2Ev:
   46|   316k|    virtual ~BaseNode() = default;
_ZN8eprosima7fastdds9xmlparser8DataNodeINS0_3dds27DomainParticipantFactoryQosEEC2ENS1_8NodeTypeENSt3__110unique_ptrIS4_NS7_14default_deleteIS4_EEEE:
  173|  12.8k|    : BaseNode(type)
  174|  12.8k|    , attributes_()
  175|  12.8k|    , data_(std::move(data))
  176|  12.8k|{
  177|  12.8k|}
_ZN8eprosima7fastdds9xmlparser8DataNodeINS0_3dds27DomainParticipantFactoryQosEED2Ev:
  181|  12.8k|{
  182|  12.8k|}
_ZN8eprosima7fastdds9xmlparser8DataNodeINS1_21ParticipantAttributesEEC2ENS1_8NodeTypeENSt3__110unique_ptrIS3_NS6_14default_deleteIS3_EEEE:
  173|   105k|    : BaseNode(type)
  174|   105k|    , attributes_()
  175|   105k|    , data_(std::move(data))
  176|   105k|{
  177|   105k|}
_ZN8eprosima7fastdds9xmlparser8DataNodeINS1_21ParticipantAttributesEED2Ev:
  181|   105k|{
  182|   105k|}
_ZN8eprosima7fastdds9xmlparser8DataNodeINS1_19PublisherAttributesEEC2ENS1_8NodeTypeENSt3__110unique_ptrIS3_NS6_14default_deleteIS3_EEEE:
  173|  35.3k|    : BaseNode(type)
  174|  35.3k|    , attributes_()
  175|  35.3k|    , data_(std::move(data))
  176|  35.3k|{
  177|  35.3k|}
_ZN8eprosima7fastdds9xmlparser8DataNodeINS1_19PublisherAttributesEED2Ev:
  181|  35.3k|{
  182|  35.3k|}
_ZN8eprosima7fastdds9xmlparser8DataNodeINS1_20SubscriberAttributesEEC2ENS1_8NodeTypeENSt3__110unique_ptrIS3_NS6_14default_deleteIS3_EEEE:
  173|  81.6k|    : BaseNode(type)
  174|  81.6k|    , attributes_()
  175|  81.6k|    , data_(std::move(data))
  176|  81.6k|{
  177|  81.6k|}
_ZN8eprosima7fastdds9xmlparser8DataNodeINS1_20SubscriberAttributesEED2Ev:
  181|  81.6k|{
  182|  81.6k|}
_ZN8eprosima7fastdds9xmlparser8DataNodeINS1_15TopicAttributesEEC2ENS1_8NodeTypeENSt3__110unique_ptrIS3_NS6_14default_deleteIS3_EEEE:
  173|  23.9k|    : BaseNode(type)
  174|  23.9k|    , attributes_()
  175|  23.9k|    , data_(std::move(data))
  176|  23.9k|{
  177|  23.9k|}
_ZN8eprosima7fastdds9xmlparser8DataNodeINS1_15TopicAttributesEED2Ev:
  181|  23.9k|{
  182|  23.9k|}
_ZN8eprosima7fastdds9xmlparser8DataNodeINS1_19RequesterAttributesEEC2ENS1_8NodeTypeENSt3__110unique_ptrIS3_NS6_14default_deleteIS3_EEEE:
  173|  12.8k|    : BaseNode(type)
  174|  12.8k|    , attributes_()
  175|  12.8k|    , data_(std::move(data))
  176|  12.8k|{
  177|  12.8k|}
_ZN8eprosima7fastdds9xmlparser8DataNodeINS1_19RequesterAttributesEED2Ev:
  181|  12.8k|{
  182|  12.8k|}
_ZN8eprosima7fastdds9xmlparser8DataNodeINS1_17ReplierAttributesEEC2ENS1_8NodeTypeENSt3__110unique_ptrIS3_NS6_14default_deleteIS3_EEEE:
  173|  15.4k|    : BaseNode(type)
  174|  15.4k|    , attributes_()
  175|  15.4k|    , data_(std::move(data))
  176|  15.4k|{
  177|  15.4k|}
_ZN8eprosima7fastdds9xmlparser8DataNodeINS1_17ReplierAttributesEED2Ev:
  181|  15.4k|{
  182|  15.4k|}
_ZN8eprosima7fastdds9xmlparser8DataNodeINS1_15TopicAttributesEE12addAttributeERKNSt3__112basic_stringIcNS5_11char_traitsIcEENS5_9allocatorIcEEEESD_:
  207|  21.4k|{
  208|  21.4k|    attributes_[name] = value;
  209|  21.4k|}
_ZNK8eprosima7fastdds9xmlparser8DataNodeINS1_15TopicAttributesEE3getEv:
  186|  23.9k|{
  187|  23.9k|    return data_.get();
  188|  23.9k|}
_ZN8eprosima7fastdds9xmlparser8DataNodeINS0_3dds27DomainParticipantFactoryQosEE12addAttributeERKNSt3__112basic_stringIcNS6_11char_traitsIcEENS6_9allocatorIcEEEESE_:
  207|  11.9k|{
  208|  11.9k|    attributes_[name] = value;
  209|  11.9k|}
_ZNK8eprosima7fastdds9xmlparser8DataNodeINS0_3dds27DomainParticipantFactoryQosEE3getEv:
  186|  2.81k|{
  187|  2.81k|    return data_.get();
  188|  2.81k|}
_ZN8eprosima7fastdds9xmlparser8DataNodeINS1_21ParticipantAttributesEE12addAttributeERKNSt3__112basic_stringIcNS5_11char_traitsIcEENS5_9allocatorIcEEEESD_:
  207|  23.3k|{
  208|  23.3k|    attributes_[name] = value;
  209|  23.3k|}
_ZNK8eprosima7fastdds9xmlparser8DataNodeINS1_21ParticipantAttributesEE3getEv:
  186|  23.0k|{
  187|  23.0k|    return data_.get();
  188|  23.0k|}
_ZN8eprosima7fastdds9xmlparser8DataNodeINS1_19PublisherAttributesEE12addAttributeERKNSt3__112basic_stringIcNS5_11char_traitsIcEENS5_9allocatorIcEEEESD_:
  207|  17.1k|{
  208|  17.1k|    attributes_[name] = value;
  209|  17.1k|}
_ZNK8eprosima7fastdds9xmlparser8DataNodeINS1_19PublisherAttributesEE3getEv:
  186|  35.3k|{
  187|  35.3k|    return data_.get();
  188|  35.3k|}
_ZN8eprosima7fastdds9xmlparser8DataNodeINS1_20SubscriberAttributesEE12addAttributeERKNSt3__112basic_stringIcNS5_11char_traitsIcEENS5_9allocatorIcEEEESD_:
  207|  33.8k|{
  208|  33.8k|    attributes_[name] = value;
  209|  33.8k|}
_ZNK8eprosima7fastdds9xmlparser8DataNodeINS1_20SubscriberAttributesEE3getEv:
  186|  81.6k|{
  187|  81.6k|    return data_.get();
  188|  81.6k|}
_ZN8eprosima7fastdds9xmlparser8DataNodeINS1_19RequesterAttributesEE12addAttributeERKNSt3__112basic_stringIcNS5_11char_traitsIcEENS5_9allocatorIcEEEESD_:
  207|  47.7k|{
  208|  47.7k|    attributes_[name] = value;
  209|  47.7k|}
_ZNK8eprosima7fastdds9xmlparser8DataNodeINS1_19RequesterAttributesEE3getEv:
  186|   117k|{
  187|   117k|    return data_.get();
  188|   117k|}
_ZN8eprosima7fastdds9xmlparser8DataNodeINS1_17ReplierAttributesEE12addAttributeERKNSt3__112basic_stringIcNS5_11char_traitsIcEENS5_9allocatorIcEEEESD_:
  207|  66.8k|{
  208|  66.8k|    attributes_[name] = value;
  209|  66.8k|}
_ZNK8eprosima7fastdds9xmlparser8DataNodeINS1_17ReplierAttributesEE3getEv:
  186|   111k|{
  187|   111k|    return data_.get();
  188|   111k|}

_ZN8eprosima7fastdds9xmlparser21ParticipantAttributesC2Ev:
   46|   105k|    {
   47|   105k|    }
_ZN8eprosima7fastdds9xmlparser21ParticipantAttributesD2Ev:
   50|   104k|    {
   51|   104k|    }

_ZN8eprosima7fastdds9xmlparser19PublisherAttributesC2Ev:
   45|  63.7k|    PublisherAttributes() = default;
_ZN8eprosima7fastdds9xmlparser19PublisherAttributesD2Ev:
   47|  61.7k|    virtual ~PublisherAttributes() = default;

_ZN8eprosima7fastdds9xmlparser17ReplierAttributesC2Ev:
   33|  15.4k|    ReplierAttributes() = default;

_ZN8eprosima7fastdds9xmlparser19RequesterAttributesC2Ev:
   33|  12.8k|    RequesterAttributes() = default;

_ZN8eprosima7fastdds9xmlparser20SubscriberAttributesC2Ev:
   81|   109k|    SubscriberAttributes() = default;
_ZN8eprosima7fastdds9xmlparser20SubscriberAttributesD2Ev:
   83|   107k|    virtual ~SubscriberAttributes() = default;

_ZN8eprosima7fastdds9xmlparser15TopicAttributesC2Ev:
   43|   197k|        : topicKind(rtps::NO_KEY)
   44|   197k|        , topicName("UNDEF")
   45|   197k|        , topicDataType("UNDEF")
   46|   197k|    {
   47|   197k|    }
_ZN8eprosima7fastdds9xmlparser15TopicAttributesD2Ev:
   61|   192k|    {
   62|   192k|    }

_ZN5boost12interprocess9ipcdetail13get_num_coresEv:
  457|      2|{
  458|      2|   #ifdef _SC_NPROCESSORS_ONLN
  459|      2|      long cores = ::sysconf(_SC_NPROCESSORS_ONLN);
  460|       |      // sysconf returns -1 if the name is invalid, the option does not exist or
  461|       |      // does not have a definite limit.
  462|       |      // if sysconf returns some other negative number, we have no idea
  463|       |      // what is going on. Default to something safe.
  464|      2|      if(cores <= 0){
  ------------------
  |  Branch (464:10): [True: 0, False: 2]
  ------------------
  465|      0|         return 1;
  466|      0|      }
  467|       |      //Check for overflow (unlikely)
  468|      2|      else if(static_cast<unsigned long>(cores) >=
  ------------------
  |  Branch (468:15): [True: 0, False: 2]
  ------------------
  469|      2|              static_cast<unsigned long>(static_cast<unsigned int>(-1))){
  470|      0|         return static_cast<unsigned int>(-1);
  471|      0|      }
  472|      2|      else{
  473|      2|         return static_cast<unsigned int>(cores);
  474|      2|      }
  475|       |   #elif defined(BOOST_INTERPROCESS_BSD_DERIVATIVE) && defined(HW_NCPU)
  476|       |      int request[2] = { CTL_HW, HW_NCPU };
  477|       |      int num_cores;
  478|       |      std::size_t result_len = sizeof(num_cores);
  479|       |      if ( (::sysctl (request, 2, &num_cores, &result_len, 0, 0) < 0) || (num_cores <= 0) ){
  480|       |         //Return a safe value
  481|       |         return 1;
  482|       |      }
  483|       |      else{
  484|       |         return static_cast<unsigned int>(num_cores);
  485|       |      }
  486|       |   #elif defined(__VXWORKS__)
  487|       |      cpuset_t set =  ::vxCpuEnabledGet();
  488|       |    #ifdef __DCC__
  489|       |      int i;
  490|       |      for( i = 0; set; ++i)
  491|       |          {
  492|       |               set &= set -1;
  493|       |          }
  494|       |      return(i);
  495|       |    #else  
  496|       |      return (__builtin_popcount(set) );
  497|       |    #endif  
  498|       |   #endif
  499|      2|}

_ZN5boost12interprocess13mapped_region16page_size_holderILi0EE13get_page_sizeEv:
  582|      2|{  return std::size_t(sysconf(_SC_PAGESIZE)); }