DataReaderQos.hpp

// Copyright 2019 Proyectos y Sistemas de Mantenimiento SL (eProsima).
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//     http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
 
#ifndef FASTDDS_DDS_SUBSCRIBER_QOS__DATAREADERQOS_HPP
#define FASTDDS_DDS_SUBSCRIBER_QOS__DATAREADERQOS_HPP
 
#include <fastdds/dds/core/policy/QosPolicies.hpp>
#include <fastdds/dds/core/policy/ReaderDataLifecycleQosPolicy.hpp>
#include <fastdds/dds/core/policy/ReaderResourceLimitsQos.hpp>
#include <fastdds/dds/core/policy/RTPSReliableReaderQos.hpp>
#include <fastdds/dds/subscriber/qos/ReaderQos.hpp>
#include <fastdds/dds/subscriber/qos/SubscriberQos.hpp>
#include <fastdds/fastdds_dll.hpp>
#include <fastdds/rtps/attributes/ReaderAttributes.hpp>
 
namespace eprosima {
namespace fastdds {
namespace dds {
 
class DataReaderQos
{
public:
 
    FASTDDS_EXPORTED_API DataReaderQos()
        : expects_inline_qos_(false)
    {
    }
 
    FASTDDS_EXPORTED_API bool operator ==(
            const DataReaderQos& b) const
    {
        return (durability_ == b.durability()) &&
               (deadline_ == b.deadline()) &&
               (latency_budget_ == b.latency_budget()) &&
               (liveliness_ == b.liveliness()) &&
               (reliability_ == b.reliability()) &&
               (destination_order_ == b.destination_order()) &&
               (history_ == b.history()) &&
               (resource_limits_ == b.resource_limits()) &&
               (user_data_ == b.user_data()) &&
               (ownership_ == b.ownership()) &&
               (time_based_filter_ == b.time_based_filter()) &&
               (reader_data_lifecycle_ == b.reader_data_lifecycle()) &&
               (lifespan_ == b.lifespan()) &&
               (durability_service_ == b.durability_service()) &&
               (reliable_reader_qos_ == b.reliable_reader_qos()) &&
               (type_consistency_ == b.type_consistency()) &&
               (representation_ == b.representation()) &&
               (expects_inline_qos_ == b.expects_inline_qos()) &&
               (properties_ == b.properties()) &&
               (endpoint_ == b.endpoint()) &&
               (reader_resource_limits_ == b.reader_resource_limits()) &&
               (data_sharing_ == b.data_sharing());
    }
 
    FASTDDS_EXPORTED_API ReaderQos get_readerqos(
            const SubscriberQos& sqos) const;
 
    FASTDDS_EXPORTED_API DurabilityQosPolicy& durability()
    {
        return durability_;
    }
 
    FASTDDS_EXPORTED_API const DurabilityQosPolicy& durability() const
    {
        return durability_;
    }
 
    FASTDDS_EXPORTED_API void durability(
            const DurabilityQosPolicy& new_value)
    {
        durability_ = new_value;
    }
 
    FASTDDS_EXPORTED_API DeadlineQosPolicy& deadline()
    {
        return deadline_;
    }
 
    FASTDDS_EXPORTED_API const DeadlineQosPolicy& deadline() const
    {
        return deadline_;
    }
 
    FASTDDS_EXPORTED_API void deadline(
            const DeadlineQosPolicy& new_value)
    {
        deadline_ = new_value;
    }
 
    FASTDDS_EXPORTED_API LatencyBudgetQosPolicy& latency_budget()
    {
        return latency_budget_;
    }
 
    FASTDDS_EXPORTED_API const LatencyBudgetQosPolicy& latency_budget() const
    {
        return latency_budget_;
    }
 
    FASTDDS_EXPORTED_API void latency_budget(
            const LatencyBudgetQosPolicy& new_value)
    {
        latency_budget_ = new_value;
    }
 
    FASTDDS_EXPORTED_API LivelinessQosPolicy& liveliness()
    {
        return liveliness_;
    }
 
    FASTDDS_EXPORTED_API const LivelinessQosPolicy& liveliness() const
    {
        return liveliness_;
    }
 
    FASTDDS_EXPORTED_API void liveliness(
            const LivelinessQosPolicy& new_value)
    {
        liveliness_ = new_value;
    }
 
    FASTDDS_EXPORTED_API ReliabilityQosPolicy& reliability()
    {
        return reliability_;
    }
 
    FASTDDS_EXPORTED_API const ReliabilityQosPolicy& reliability() const
    {
        return reliability_;
    }
 
    FASTDDS_EXPORTED_API void reliability(
            const ReliabilityQosPolicy& new_value)
    {
        reliability_ = new_value;
    }
 
    FASTDDS_EXPORTED_API DestinationOrderQosPolicy& destination_order()
    {
        return destination_order_;
    }
 
    FASTDDS_EXPORTED_API const DestinationOrderQosPolicy& destination_order() const
    {
        return destination_order_;
    }
 
    FASTDDS_EXPORTED_API void destination_order(
            const DestinationOrderQosPolicy& new_value)
    {
        destination_order_ = new_value;
    }
 
    FASTDDS_EXPORTED_API HistoryQosPolicy& history()
    {
        return history_;
    }
 
    FASTDDS_EXPORTED_API const HistoryQosPolicy& history() const
    {
        return history_;
    }
 
    FASTDDS_EXPORTED_API void history(
            const HistoryQosPolicy& new_value)
    {
        history_ = new_value;
    }
 
    FASTDDS_EXPORTED_API ResourceLimitsQosPolicy& resource_limits()
    {
        return resource_limits_;
    }
 
    FASTDDS_EXPORTED_API const ResourceLimitsQosPolicy& resource_limits() const
    {
        return resource_limits_;
    }
 
    FASTDDS_EXPORTED_API void resource_limits(
            const ResourceLimitsQosPolicy& new_value)
    {
        resource_limits_ = new_value;
    }
 
    FASTDDS_EXPORTED_API UserDataQosPolicy& user_data()
    {
        return user_data_;
    }
 
    FASTDDS_EXPORTED_API const UserDataQosPolicy& user_data() const
    {
        return user_data_;
    }
 
    FASTDDS_EXPORTED_API void user_data(
            const UserDataQosPolicy& new_value)
    {
        user_data_ = new_value;
    }
 
    FASTDDS_EXPORTED_API OwnershipQosPolicy& ownership()
    {
        return ownership_;
    }
 
    FASTDDS_EXPORTED_API const OwnershipQosPolicy& ownership() const
    {
        return ownership_;
    }
 
    FASTDDS_EXPORTED_API void ownership(
            const OwnershipQosPolicy& new_value)
    {
        ownership_ = new_value;
    }
 
    FASTDDS_EXPORTED_API TimeBasedFilterQosPolicy& time_based_filter()
    {
        return time_based_filter_;
    }
 
    FASTDDS_EXPORTED_API const TimeBasedFilterQosPolicy& time_based_filter() const
    {
        return time_based_filter_;
    }
 
    FASTDDS_EXPORTED_API void time_based_filter(
            const TimeBasedFilterQosPolicy& new_value)
    {
        time_based_filter_ = new_value;
    }
 
    FASTDDS_EXPORTED_API ReaderDataLifecycleQosPolicy& reader_data_lifecycle()
    {
        return reader_data_lifecycle_;
    }
 
    FASTDDS_EXPORTED_API const ReaderDataLifecycleQosPolicy& reader_data_lifecycle() const
    {
        return reader_data_lifecycle_;
    }
 
    FASTDDS_EXPORTED_API void reader_data_lifecycle(
            const ReaderDataLifecycleQosPolicy& new_value)
    {
        reader_data_lifecycle_ = new_value;
    }
 
    FASTDDS_EXPORTED_API LifespanQosPolicy& lifespan()
    {
        return lifespan_;
    }
 
    FASTDDS_EXPORTED_API const LifespanQosPolicy& lifespan() const
    {
        return lifespan_;
    }
 
    FASTDDS_EXPORTED_API void lifespan(
            const LifespanQosPolicy& new_value)
    {
        lifespan_ = new_value;
    }
 
    FASTDDS_EXPORTED_API DurabilityServiceQosPolicy& durability_service()
    {
        return durability_service_;
    }
 
    FASTDDS_EXPORTED_API const DurabilityServiceQosPolicy& durability_service() const
    {
        return durability_service_;
    }
 
    FASTDDS_EXPORTED_API void durability_service(
            const DurabilityServiceQosPolicy& new_value)
    {
        durability_service_ = new_value;
    }
 
    FASTDDS_EXPORTED_API RTPSReliableReaderQos& reliable_reader_qos()
    {
        return reliable_reader_qos_;
    }
 
    FASTDDS_EXPORTED_API const RTPSReliableReaderQos& reliable_reader_qos() const
    {
        return reliable_reader_qos_;
    }
 
    FASTDDS_EXPORTED_API void reliable_reader_qos(
            const RTPSReliableReaderQos& new_value)
    {
        reliable_reader_qos_ = new_value;
    }
 
    FASTDDS_EXPORTED_API TypeConsistencyEnforcementQosPolicy& type_consistency()
    {
        return type_consistency_;
    }
 
    FASTDDS_EXPORTED_API const TypeConsistencyEnforcementQosPolicy& type_consistency() const
    {
        return type_consistency_;
    }
 
    FASTDDS_EXPORTED_API void type_consistency(
            const TypeConsistencyEnforcementQosPolicy& new_value)
    {
        type_consistency_ = new_value;
    }
 
    FASTDDS_EXPORTED_API const DataRepresentationQosPolicy& representation() const
    {
        return representation_;
    }
 
    FASTDDS_EXPORTED_API DataRepresentationQosPolicy& representation()
    {
        return representation_;
    }
 
    FASTDDS_EXPORTED_API void representation(
            const DataRepresentationQosPolicy& representation)
    {
        representation_ = representation;
    }
 
    FASTDDS_EXPORTED_API bool expects_inline_qos() const
    {
        return expects_inline_qos_;
    }
 
    FASTDDS_EXPORTED_API void expects_inline_qos(
            bool new_value)
    {
        expects_inline_qos_ = new_value;
    }
 
    FASTDDS_EXPORTED_API PropertyPolicyQos& properties()
    {
        return properties_;
    }
 
    FASTDDS_EXPORTED_API const PropertyPolicyQos& properties() const
    {
        return properties_;
    }
 
    FASTDDS_EXPORTED_API void properties(
            const PropertyPolicyQos& new_value)
    {
        properties_ = new_value;
    }
 
    FASTDDS_EXPORTED_API RTPSEndpointQos& endpoint()
    {
        return endpoint_;
    }
 
    FASTDDS_EXPORTED_API const RTPSEndpointQos& endpoint() const
    {
        return endpoint_;
    }
 
    FASTDDS_EXPORTED_API void endpoint(
            const RTPSEndpointQos& new_value)
    {
        endpoint_ = new_value;
    }
 
    FASTDDS_EXPORTED_API ReaderResourceLimitsQos& reader_resource_limits()
    {
        return reader_resource_limits_;
    }
 
    FASTDDS_EXPORTED_API const ReaderResourceLimitsQos& reader_resource_limits() const
    {
        return reader_resource_limits_;
    }
 
    FASTDDS_EXPORTED_API void reader_resource_limits(
            const ReaderResourceLimitsQos& new_value)
    {
        reader_resource_limits_ = new_value;
    }
 
    FASTDDS_EXPORTED_API DataSharingQosPolicy& data_sharing()
    {
        return data_sharing_;
    }
 
    FASTDDS_EXPORTED_API const DataSharingQosPolicy& data_sharing() const
    {
        return data_sharing_;
    }
 
    FASTDDS_EXPORTED_API void data_sharing(
            const DataSharingQosPolicy& data_sharing)
    {
        data_sharing_ = data_sharing;
    }
 
private:
 
    DurabilityQosPolicy durability_;
 
    DeadlineQosPolicy deadline_;
 
    LatencyBudgetQosPolicy latency_budget_;
 
    LivelinessQosPolicy liveliness_;
 
    ReliabilityQosPolicy reliability_;
 
    DestinationOrderQosPolicy destination_order_;
 
    HistoryQosPolicy history_;
 
    ResourceLimitsQosPolicy resource_limits_;
 
    UserDataQosPolicy user_data_;
 
    OwnershipQosPolicy ownership_;
 
    TimeBasedFilterQosPolicy time_based_filter_;
 
    ReaderDataLifecycleQosPolicy reader_data_lifecycle_;
 
    LifespanQosPolicy lifespan_;
 
    DurabilityServiceQosPolicy durability_service_;
 
    RTPSReliableReaderQos reliable_reader_qos_;
 
    TypeConsistencyEnforcementQosPolicy type_consistency_;
 
    DataRepresentationQosPolicy representation_;
 
    bool expects_inline_qos_;
 
    PropertyPolicyQos properties_;
 
    RTPSEndpointQos endpoint_;
 
    ReaderResourceLimitsQos reader_resource_limits_;
 
    DataSharingQosPolicy data_sharing_;
};
 
FASTDDS_EXPORTED_API extern const DataReaderQos DATAREADER_QOS_DEFAULT;
FASTDDS_EXPORTED_API extern const DataReaderQos DATAREADER_QOS_USE_TOPIC_QOS;
 
} // namespace dds
} // namespace fastdds
} // namespace eprosima
 
#endif // FASTDDS_DDS_SUBSCRIBER_QOS__DATAREADERQOS_HPP