Program Listing for File CorePolicy.hpp

↰ Return to documentation for file (/tmp/ws/src/fastrtps/include/dds/core/policy/CorePolicy.hpp)

/*
 * Copyright 2010, Object Management Group, Inc.
 * Copyright 2010, PrismTech, Corp.
 * Copyright 2010, Real-Time Innovations, Inc.
 * Copyright 2019, Proyectos y Sistemas de Mantenimiento SL (eProsima).
 * All rights reserved.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

#ifndef OMG_DDS_CORE_POLICY_CORE_POLICY_HPP_
#define OMG_DDS_CORE_POLICY_CORE_POLICY_HPP_

#include <dds/core/policy/PolicyKind.hpp>
#include <dds/core/policy/detail/CorePolicy.hpp>
#include <dds/core/policy/QosPolicyCount.hpp>

#include <dds/core/detail/inttypes.hpp>
#include <dds/core/types.hpp>
#include <dds/core/LengthUnlimited.hpp>
#include <dds/core/detail/Value.hpp>
#include <dds/core/Duration.hpp>

//==============================================================================
// MACROS
// *INDENT-OFF*
#define OMG_DDS_POLICY_TRAITS(POLICY, ID) \
    template<> \
    class policy_id<POLICY> { \
    public: \
        static const dds::core::policy::QosPolicyId value = ID; \
    }; \
    template<> \
    class policy_name<POLICY> { \
    public: \
        static const std::string& name(); \
    };

#define OMG_DDS_DEFINE_POLICY_TRAITS(POLICY, NAME) \
    const std::string& dds::core::policy::policy_name<POLICY>::name() { \
        static std::string name = #NAME; \
        return name; \
    }
// *INDENT-OFF*


namespace dds {
namespace core {
namespace policy {

//==============================================================================
class UserData : public dds::core::Value<detail::UserData>
{
public:

    UserData();

    explicit UserData(
            const dds::core::ByteSeq& sequence);

    UserData(
            const uint8_t* value_begin,
            const uint8_t* value_end);

    UserData(
            const UserData& other);

    UserData& value(
            const dds::core::ByteSeq& sequence);

    template<typename OCTET_ITER>
    UserData& value(
            OCTET_ITER begin,
            OCTET_ITER end);

    const dds::core::ByteSeq value() const;

    const uint8_t* begin() const;

    const uint8_t* end() const;
};

//==============================================================================

class GroupData : public dds::core::Value<detail::GroupData>
{
public:

    GroupData();

    explicit GroupData(
            const dds::core::ByteSeq& sequence);

    GroupData(
            const GroupData& other);

    GroupData(
            const uint8_t* value_begin,
            const uint8_t* value_end);

    GroupData& value(
            const dds::core::ByteSeq& sequence);

    template<typename OCTET_ITER>
    GroupData& value(
            OCTET_ITER begin,
            OCTET_ITER end);

    const dds::core::ByteSeq value() const;

    const uint8_t* begin() const;

    const uint8_t* end() const;
};

//==============================================================================

class TopicData : public dds::core::Value<detail::TopicData>
{
public:

    TopicData();

    explicit TopicData(
            const dds::core::ByteSeq& sequence);

    TopicData(
            const TopicData& other);

    TopicData(
            const uint8_t* value_begin,
            const uint8_t* value_end);

    TopicData& value(
            const dds::core::ByteSeq& sequence);

    template<typename OCTET_ITER>
    TopicData& value(
            OCTET_ITER begin,
            OCTET_ITER end);

    const dds::core::ByteSeq value() const;

    const uint8_t* begin() const;

    const uint8_t* end() const;
};


//==============================================================================

class EntityFactory : public dds::core::Value<detail::EntityFactory>
{
public:

    explicit EntityFactory(
            bool autoenable_created_entities = true);

    EntityFactory(
            const EntityFactory& other);

    EntityFactory& autoenable_created_entities(
            bool autoenable_created_entities);

    bool autoenable_created_entities() const;

    static EntityFactory AutoEnable();

    static EntityFactory ManuallyEnable();
};

//==============================================================================

class TransportPriority : public dds::core::Value<detail::TransportPriority>
{
public:

    explicit TransportPriority(
            int32_t priority = 0);

    TransportPriority(
            const TransportPriority& other);

    TransportPriority& value(
            int32_t priority);

    int32_t value() const;
};

//==============================================================================

class Lifespan : public dds::core::Value<detail::Lifespan>
{
public:

    explicit Lifespan(
            const dds::core::Duration& duration = dds::core::Duration::infinite());

    Lifespan(
            const Lifespan& other);

    Lifespan& duration(
            const dds::core::Duration& duration);

    const dds::core::Duration duration() const;
};

//==============================================================================

class Deadline : public dds::core::Value<detail::Deadline>
{
public:

    explicit Deadline(
            const dds::core::Duration& period = dds::core::Duration::infinite());

    Deadline(
            const Deadline& other);

    Deadline& period(
            const dds::core::Duration& period);

    const dds::core::Duration period() const;
};

//==============================================================================

class LatencyBudget : public dds::core::Value<detail::LatencyBudget>
{
public:

    explicit LatencyBudget(
            const dds::core::Duration& duration = dds::core::Duration::zero());

    LatencyBudget(
            const LatencyBudget& other);

    LatencyBudget& duration(
            const dds::core::Duration& duration);

    const dds::core::Duration duration() const;
};

//==============================================================================

class TimeBasedFilter : public dds::core::Value<detail::TimeBasedFilter>
{
public:

    explicit TimeBasedFilter(
            const dds::core::Duration& period = dds::core::Duration::zero());

    TimeBasedFilter(
            const TimeBasedFilter& other);

    TimeBasedFilter& minimum_separation(
            const dds::core::Duration& period);

    const dds::core::Duration minimum_separation() const;
};


//==============================================================================

class Partition : public dds::core::Value<detail::Partition>
{
public:

    Partition();

    explicit Partition(
            uint16_t in_length);

    Partition(
            const Partition& other);

    Partition& name(
            const std::string& name);

    Partition& names(
            dds::core::StringSeq& names);

    const dds::core::StringSeq names() const;

    void push_back(
            const char* name);

    void clear();
};

//==============================================================================
//#ifdef OMG_DDS_OWNERSHIP_SUPPORT

class Ownership : public dds::core::Value<detail::Ownership>
{
public:

    #   if defined (__SUNPRO_CC) && defined(SHARED)
    #   undef SHARED
    #   endif // if defined (__SUNPRO_CC) && defined(SHARED)
    explicit Ownership(
            dds::core::policy::OwnershipKind::Type kind = dds::core::policy::OwnershipKind::SHARED);

    Ownership(
            const Ownership& other);

    Ownership& kind(
            dds::core::policy::OwnershipKind::Type kind);

    dds::core::policy::OwnershipKind::Type kind() const;

    static Ownership Exclusive();

    static Ownership Shared();

private:

    static eprosima::fastdds::dds::OwnershipQosPolicyKind to_native(
            OwnershipKind::Type kind);

    static OwnershipKind::Type from_native(
            eprosima::fastdds::dds::OwnershipQosPolicyKind kind);
};


//==============================================================================

class OwnershipStrength : public dds::core::Value<detail::OwnershipStrength>
{
public:

    explicit OwnershipStrength(
            int32_t strength = 0);

    OwnershipStrength(
            const OwnershipStrength& other);

    int32_t value() const;

    OwnershipStrength& value(
            int32_t strength);
};

//#endif  // OMG_DDS_OWNERSHIP_SUPPORT
//==============================================================================

class WriterDataLifecycle : public dds::core::Value<detail::WriterDataLifecycle>
{
public:

    explicit WriterDataLifecycle(
            bool autodispose_unregistered_instances = true);

    WriterDataLifecycle(
            const WriterDataLifecycle& other);

    bool autodispose_unregistered_instances() const;

    WriterDataLifecycle& autodispose_unregistered_instances(
            bool autodispose_unregistered_instances);

    static WriterDataLifecycle AutoDisposeUnregisteredInstances();

    static WriterDataLifecycle ManuallyDisposeUnregisteredInstances();

};

//==============================================================================

class ReaderDataLifecycle : public dds::core::Value<detail::ReaderDataLifecycle>
{
public:

    ReaderDataLifecycle(
            const dds::core::Duration& autopurge_nowriter_samples_delay = dds::core::Duration::infinite(),
            const dds::core::Duration& autopurge_disposed_samples_delay = dds::core::Duration::infinite());

    ReaderDataLifecycle(
            const ReaderDataLifecycle& other);
    const dds::core::Duration autopurge_nowriter_samples_delay() const;

    ReaderDataLifecycle& autopurge_nowriter_samples_delay(
            const dds::core::Duration& autopurge_nowriter_samples_delay);

    const dds::core::Duration autopurge_disposed_samples_delay() const;

    ReaderDataLifecycle& autopurge_disposed_samples_delay(
            const dds::core::Duration& autopurge_disposed_samples_delay);

    static ReaderDataLifecycle NoAutoPurgeDisposedSamples();

    static ReaderDataLifecycle AutoPurgeDisposedSamples(
            const dds::core::Duration& autopurge_disposed_samples_delay);

};

//==============================================================================

class Durability : public dds::core::Value<detail::Durability>
{
public:

    explicit Durability(
            dds::core::policy::DurabilityKind::Type kind = dds::core::policy::DurabilityKind::VOLATILE);

    Durability(
            const Durability& other);

    Durability& kind(
            dds::core::policy::DurabilityKind::Type kind);

    dds::core::policy::DurabilityKind::Type  kind() const;

    static Durability Volatile();

    static Durability TransientLocal();

    static Durability Transient();

    static Durability Persistent();

private:

    static eprosima::fastdds::dds::DurabilityQosPolicyKind to_native(
            DurabilityKind::Type kind);

    static DurabilityKind::Type from_native(
            eprosima::fastdds::dds::DurabilityQosPolicyKind kind);

};

//==============================================================================

class Presentation : public dds::core::Value<detail::Presentation>
{
public:

    Presentation(
            dds::core::policy::PresentationAccessScopeKind::Type access_scope =
                dds::core::policy::PresentationAccessScopeKind::INSTANCE,
            bool coherent_access = false,
            bool ordered_access = false);

    Presentation(
            const Presentation& other);

    Presentation& access_scope(
            dds::core::policy::PresentationAccessScopeKind::Type access_scope);

    dds::core::policy::PresentationAccessScopeKind::Type access_scope() const;

    Presentation& coherent_access(
            bool coherent_access);

    bool coherent_access() const;

    Presentation& ordered_access(
            bool ordered_access);

    bool ordered_access() const;

    static Presentation GroupAccessScope(
            bool coherent_access = false,
            bool ordered_access = false);

    static Presentation InstanceAccessScope(
            bool coherent_access = false,
            bool ordered_access = false);

    static Presentation TopicAccessScope(
            bool coherent_access = false,
            bool ordered_access = false);

private:

    static eprosima::fastdds::dds::PresentationQosPolicyAccessScopeKind to_native(
            PresentationAccessScopeKind::Type kind);

    static PresentationAccessScopeKind::Type from_native(
            eprosima::fastdds::dds::PresentationQosPolicyAccessScopeKind kind);
};

//==============================================================================

class Reliability : public dds::core::Value<detail::Reliability>
{
public:

    Reliability(
            dds::core::policy::ReliabilityKind::Type kind = dds::core::policy::ReliabilityKind::BEST_EFFORT,
            const dds::core::Duration& max_blocking_time = dds::core::Duration::from_millisecs(100));

    Reliability(
            const Reliability& other);

    Reliability& kind(
            dds::core::policy::ReliabilityKind::Type kind);

    dds::core::policy::ReliabilityKind::Type kind() const;

    Reliability& max_blocking_time(
            const dds::core::Duration& max_blocking_time);

    const dds::core::Duration max_blocking_time() const;

    static OMG_DDS_API Reliability Reliable(
            const dds::core::Duration& max_blocking_time = dds::core::Duration::from_millisecs(100));

    static Reliability BestEffort(
            const dds::core::Duration& max_blocking_time = dds::core::Duration::from_millisecs(100));

private:

    static ReliabilityKind::Type from_native(
            eprosima::fastdds::dds::ReliabilityQosPolicyKind kind);

    static eprosima::fastdds::dds::ReliabilityQosPolicyKind to_native(
            ReliabilityKind::Type kind);

};

//==============================================================================

class DestinationOrder : public dds::core::Value<detail::DestinationOrder>
{
public:

    explicit DestinationOrder(
            dds::core::policy::DestinationOrderKind::Type kind =
                dds::core::policy::DestinationOrderKind::BY_RECEPTION_TIMESTAMP);

    DestinationOrder(
            const DestinationOrder& other);

    DestinationOrder& kind(
            dds::core::policy::DestinationOrderKind::Type kind);

    dds::core::policy::DestinationOrderKind::Type kind() const;

    static DestinationOrder SourceTimestamp();

    static DestinationOrder ReceptionTimestamp();

private:

    static eprosima::fastdds::dds::DestinationOrderQosPolicyKind to_native(
            DestinationOrderKind::Type kind);

    static DestinationOrderKind::Type from_native(
            eprosima::fastdds::dds::DestinationOrderQosPolicyKind kind);

};

//==============================================================================

class History : public dds::core::Value<detail::History>
{
public:

    History(
            dds::core::policy::HistoryKind::Type kind = dds::core::policy::HistoryKind::KEEP_LAST,
            int32_t depth = 1);

    History(
            const History& other);

    dds::core::policy::HistoryKind::Type kind() const;

    History& kind(
            dds::core::policy::HistoryKind::Type kind);

    int32_t depth() const;

    History& depth(
            int32_t depth);

    static History KeepAll();

    static History KeepLast(
            uint32_t depth);

private:

    friend class DurabilityService;

    static eprosima::fastdds::dds::HistoryQosPolicyKind to_native(
            HistoryKind::Type kind);

    static HistoryKind::Type from_native(
            eprosima::fastdds::dds::HistoryQosPolicyKind kind);

};

//==============================================================================

class ResourceLimits : public dds::core::Value<detail::ResourceLimits>
{
public:

    ResourceLimits(
            uint32_t max_samples = dds::core::LENGTH_UNLIMITED,
            uint32_t max_instances = dds::core::LENGTH_UNLIMITED,
            uint32_t max_samples_per_instance = dds::core::LENGTH_UNLIMITED);

    ResourceLimits(
            const ResourceLimits& other);

public:

    ResourceLimits& max_samples(
            int32_t max_samples);

    int32_t max_samples() const;

    ResourceLimits& max_instances(
            int32_t max_instances);

    int32_t max_instances() const;

    ResourceLimits& max_samples_per_instance(
            int32_t max_samples_per_instance);

    int32_t max_samples_per_instance() const;
};

//==============================================================================

class Liveliness : public dds::core::Value<detail::Liveliness>
{
public:

    Liveliness(
            dds::core::policy::LivelinessKind::Type kind = dds::core::policy::LivelinessKind::AUTOMATIC,
            const dds::core::Duration& lease_duration = dds::core::Duration::infinite());

    Liveliness(
            const Liveliness& other);

    Liveliness& kind(
            dds::core::policy::LivelinessKind::Type kind);

    dds::core::policy::LivelinessKind::Type kind() const;

    Liveliness& lease_duration(
            const dds::core::Duration& lease_duration);

    const dds::core::Duration lease_duration() const;

    static Liveliness Automatic();

    static Liveliness ManualByParticipant(
            const dds::core::Duration& lease_duration = dds::core::Duration::infinite());

    static Liveliness ManualByTopic(
            const dds::core::Duration& lease_duration = dds::core::Duration::infinite());

private:

    static eprosima::fastdds::dds::LivelinessQosPolicyKind to_native(
            LivelinessKind::Type kind);

    static LivelinessKind::Type from_native(
            eprosima::fastdds::dds::LivelinessQosPolicyKind kind);

};


//==============================================================================
//#ifdef OMG_DDS_PERSISTENCE_SUPPORT

class DurabilityService : public dds::core::Value<detail::DurabilityService>
{
public:

    DurabilityService(
            const dds::core::Duration& service_cleanup_delay = dds::core::Duration::zero(),
            dds::core::policy::HistoryKind::Type history_kind = dds::core::policy::HistoryKind::KEEP_LAST,
            int32_t history_depth = 1,
            int32_t max_samples = dds::core::LENGTH_UNLIMITED,
            int32_t max_instances = dds::core::LENGTH_UNLIMITED,
            int32_t max_samples_per_instance = dds::core::LENGTH_UNLIMITED);

    DurabilityService(
            const DurabilityService& other);

    DurabilityService& service_cleanup_delay(
            const dds::core::Duration& service_cleanup_delay);

    const dds::core::Duration service_cleanup_delay() const;

    DurabilityService& history_kind(
            dds::core::policy::HistoryKind::Type history_kind);

    dds::core::policy::HistoryKind::Type history_kind() const;

    DurabilityService& history_depth(
            int32_t history_depth);

    int32_t history_depth() const;

    DurabilityService& max_samples(
            int32_t max_samples);

    int32_t max_samples() const;

    DurabilityService& max_instances(
            int32_t max_instances);

    int32_t max_instances() const;

    DurabilityService& max_samples_per_instance(
            int32_t max_samples_per_instance);

    int32_t max_samples_per_instance() const;
};

//#endif  //OMG_DDS_PERSISTENCE_SUPPORT

//==============================================================================

//#ifdef OMG_DDS_EXTENSIBLE_AND_DYNAMIC_TOPIC_TYPE_SUPPORT

typedef uint16_t DataRepresentationId;

typedef std::vector<DataRepresentationId> DataRepresentationIdSeq;

class DataRepresentation : public dds::core::Value<detail::DataRepresentation>
{

public:

    explicit DataRepresentation(
            const dds::core::policy::DataRepresentationIdSeq& value);

    DataRepresentation(
            const DataRepresentation& other)
        : dds::core::Value<detail::DataRepresentation>(other)
    {
    }

    DataRepresentation& value(
            const dds::core::policy::DataRepresentationIdSeq& value);

    const dds::core::policy::DataRepresentationIdSeq value() const;

    dds::core::policy::DataRepresentationIdSeq& value();

private:

    static std::vector<eprosima::fastdds::dds::DataRepresentationId> to_native(
            const DataRepresentationIdSeq& seq);

};

//#endif  //OMG_DDS_EXTENSIBLE_AND_DYNAMIC_TOPIC_TYPE_SUPPORT


//============================================================================

//#ifdef OMG_DDS_EXTENSIBLE_AND_DYNAMIC_TOPIC_TYPE_SUPPORT

class TypeConsistencyEnforcement : public dds::core::Value<detail::TypeConsistencyEnforcement>
{
public:

    explicit TypeConsistencyEnforcement(
            dds::core::policy::TypeConsistencyEnforcementKind::Type kind);

    TypeConsistencyEnforcement& kind(
            dds::core::policy::TypeConsistencyEnforcementKind::Type kind);

    dds::core::policy::TypeConsistencyEnforcementKind::Type  kind() const;

    TypeConsistencyEnforcement& ignore_sequence_bounds(
            bool ignore_sequence_bounds);

    TypeConsistencyEnforcement& ignore_string_bounds(
            bool ignore_string_bounds);

    TypeConsistencyEnforcement& ignore_member_names(
            bool ignore_member_names);

    TypeConsistencyEnforcement& prevent_type_widening(
            bool prevent_type_widening);

    TypeConsistencyEnforcement& force_type_validation(
            bool force_type_validation);

    bool ignore_sequence_bounds();

    bool ignore_string_bounds();

    bool ignore_member_names();

    bool prevent_type_widening();

    bool force_type_validation();

};

//#endif  //OMG_DDS_EXTENSIBLE_AND_DYNAMIC_TOPIC_TYPE_SUPPORT

//==============================================================================
// Policy Trait Classes

template<typename Policy>
class policy_id;

template<typename Policy>
class policy_name;

#ifdef OMG_DDS_EXTENSIBLE_AND_DYNAMIC_TOPIC_TYPE_SUPPORT
#endif // ifdef OMG_DDS_EXTENSIBLE_AND_DYNAMIC_TOPIC_TYPE_SUPPORT

OMG_DDS_POLICY_TRAITS(UserData,             eprosima::fastdds::dds::USERDATA_QOS_POLICY_ID)
OMG_DDS_POLICY_TRAITS(Durability,           eprosima::fastdds::dds::DURABILITY_QOS_POLICY_ID)
OMG_DDS_POLICY_TRAITS(Presentation,         eprosima::fastdds::dds::PRESENTATION_QOS_POLICY_ID)
OMG_DDS_POLICY_TRAITS(Deadline,             eprosima::fastdds::dds::DEADLINE_QOS_POLICY_ID)
OMG_DDS_POLICY_TRAITS(LatencyBudget,        eprosima::fastdds::dds::LATENCYBUDGET_QOS_POLICY_ID)
OMG_DDS_POLICY_TRAITS(Ownership,            eprosima::fastdds::dds::OWNERSHIP_QOS_POLICY_ID)

//#ifdef OMG_DDS_OWNERSHIP_SUPPORT
OMG_DDS_POLICY_TRAITS(OwnershipStrength,    eprosima::fastdds::dds::OWNERSHIPSTRENGTH_QOS_POLICY_ID)
//#endif  //OMG_DDS_OWNERSHIP_SUPPORT

OMG_DDS_POLICY_TRAITS(Liveliness,           eprosima::fastdds::dds::LIVELINESS_QOS_POLICY_ID)
OMG_DDS_POLICY_TRAITS(TimeBasedFilter,      eprosima::fastdds::dds::TIMEBASEDFILTER_QOS_POLICY_ID)
OMG_DDS_POLICY_TRAITS(Partition,            eprosima::fastdds::dds::PARTITION_QOS_POLICY_ID)
OMG_DDS_POLICY_TRAITS(Reliability,          eprosima::fastdds::dds::RELIABILITY_QOS_POLICY_ID)
OMG_DDS_POLICY_TRAITS(DestinationOrder,     eprosima::fastdds::dds::DESTINATIONORDER_QOS_POLICY_ID)
OMG_DDS_POLICY_TRAITS(History,              eprosima::fastdds::dds::HISTORY_QOS_POLICY_ID)
OMG_DDS_POLICY_TRAITS(ResourceLimits,       eprosima::fastdds::dds::RESOURCELIMITS_QOS_POLICY_ID)
OMG_DDS_POLICY_TRAITS(EntityFactory,        eprosima::fastdds::dds::ENTITYFACTORY_QOS_POLICY_ID)
OMG_DDS_POLICY_TRAITS(WriterDataLifecycle,  eprosima::fastdds::dds::WRITERDATALIFECYCLE_QOS_POLICY_ID)
OMG_DDS_POLICY_TRAITS(ReaderDataLifecycle,  eprosima::fastdds::dds::READERDATALIFECYCLE_QOS_POLICY_ID)
OMG_DDS_POLICY_TRAITS(TopicData,            eprosima::fastdds::dds::TOPICDATA_QOS_POLICY_ID)
OMG_DDS_POLICY_TRAITS(GroupData,            eprosima::fastdds::dds::GROUPDATA_QOS_POLICY_ID)
OMG_DDS_POLICY_TRAITS(TransportPriority,    eprosima::fastdds::dds::TRANSPORTPRIORITY_QOS_POLICY_ID)
OMG_DDS_POLICY_TRAITS(Lifespan,             eprosima::fastdds::dds::LIFESPAN_QOS_POLICY_ID)

//#ifdef  OMG_DDS_PERSISTENCE_SUPPORT
OMG_DDS_POLICY_TRAITS(DurabilityService,    eprosima::fastdds::dds::DURABILITYSERVICE_QOS_POLICY_ID)
//#endif  //OMG_DDS_PERSISTENCE_SUPPORT

} //namespace policy
} //namespace core
} //namespace dds


#endif //OMG_DDS_CORE_POLICY_CORE_POLICY_HPP_