CorePolicy.hpp

Go to the documentation of this file.

#ifndef OMG_TDDS_CORE_POLICY_CORE_POLICY_HPP_
#define OMG_TDDS_CORE_POLICY_CORE_POLICY_HPP_

/* Copyright 2010, Object Management Group, Inc.
 * Copyright 2010, PrismTech, Corp.
 * Copyright 2010, Real-Time Innovations, Inc.
 * 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.
 */

#include <dds/core/detail/conformance.hpp>
#include <dds/core/LengthUnlimited.hpp>
#include <dds/core/detail/Value.hpp>
#include <dds/core/policy/PolicyKind.hpp>

//==============================================================================
// DDS Policy Classes
namespace dds
{
namespace core
{
namespace policy
{

//==============================================================================
class UserData : public dds::core::Value
{
public:
    UserData();

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

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

    UserData(const UserData& other);

public:
    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
{
public:
    GroupData();

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

    GroupData(const GroupData& other);

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

public:
    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
{
public:
    TopicData();

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

    TopicData(const TopicData& other);

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

public:
    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
{
public:
    explicit EntityFactory(bool autoenable_created_entities = true);

    EntityFactory(const EntityFactory& other);

public:
    EntityFactory& autoenable_created_entities(bool autoenable_created_entities);

    bool autoenable_created_entities() const;

public:
    static EntityFactory AutoEnable();

    static EntityFactory ManuallyEnable();
};

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

class TransportPriority : public dds::core::Value
{
public:
    explicit TransportPriority(int32_t priority = 0);

    TransportPriority(const TransportPriority& other);

public:
    TransportPriority& value(int32_t priority);

    int32_t value() const;
};

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

class Lifespan : public dds::core::Value
{
public:
    explicit Lifespan(const dds::core::Duration& duration = dds::core::Duration::infinite());

    Lifespan(const Lifespan& other);

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

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

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

class Deadline : public dds::core::Value
{
public:
    explicit Deadline(const dds::core::Duration& period = dds::core::Duration::infinite());

    Deadline(const Deadline& other);

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

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

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

class LatencyBudget : public dds::core::Value
{
public:
    explicit LatencyBudget(const dds::core::Duration& duration = dds::core::Duration::zero());

    LatencyBudget(const LatencyBudget& other);

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

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

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

class TimeBasedFilter : public dds::core::Value
{
public:
    explicit TimeBasedFilter(
        const dds::core::Duration& period = dds::core::Duration::zero());

    TimeBasedFilter(const TimeBasedFilter& other);

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

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


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

class Partition : public dds::core::Value
{
public:
    explicit Partition(const std::string& name = "");

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

    Partition(const Partition& other);

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

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

    const dds::core::StringSeq name() const;
};

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

class Ownership : public dds::core::Value
{
public:
    #   if defined (__SUNPRO_CC) && defined(SHARED)
#       undef SHARED
    #   endif

    explicit Ownership(
        dds::core::policy::OwnershipKind::Type kind = dds::core::policy::OwnershipKind::SHARED);

    Ownership(const Ownership& other);

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

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

public:
    static Ownership Exclusive();

    static Ownership Shared();
};


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

class OwnershipStrength : public dds::core::Value
{
public:
    explicit OwnershipStrength(int32_t strength = 0);

    OwnershipStrength(const OwnershipStrength& other);

public:
    int32_t value() const;

    OwnershipStrength& value(int32_t strength);
};

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

class WriterDataLifecycle : public dds::core::Value
{
public:
    explicit WriterDataLifecycle(bool autodispose_unregistered_instances = true);

    WriterDataLifecycle(const WriterDataLifecycle& other);

public:
    bool autodispose_unregistered_instances() const;

    WriterDataLifecycle& autodispose_unregistered_instances(
        bool autodispose_unregistered_instances);

public:
    static WriterDataLifecycle AutoDisposeUnregisteredInstances();

    static WriterDataLifecycle ManuallyDisposeUnregisteredInstances();

#ifdef DOXYGEN_FOR_ISOCPP2
public:
    /*
     * The above macro is never (and must never) be defined in normal compilation.
     *
     * The following code is for documenting proprietary API only.
     */

    void autopurge_suspended_samples_delay(const dds::core::Duration& d);

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

    void autounregister_instance_delay(const dds::core::Duration& d);

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

#endif /* DOXYGEN_FOR_ISOCPP2 */

};

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

class ReaderDataLifecycle : public dds::core::Value
{
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);
public:
    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);

public:
    static ReaderDataLifecycle NoAutoPurgeDisposedSamples();

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

#ifdef DOXYGEN_FOR_ISOCPP2
public:
    /*
     * The above macro is never (and must never) be defined in normal compilation.
     *
     * The following code is for documenting proprietary API only.
     */

    /*
     * Although enable_invalid_samples is available in the delegate, that feature is
     * actually deprecated. So, don't add it to the API documentation.
     */

    bool autopurge_dispose_all() const;

    void autopurge_dispose_all(bool b);

    org::opensplice::core::policy::InvalidSampleVisibility::Type invalid_sample_visibility() const;

    void invalid_sample_visibility(org::opensplice::core::policy::InvalidSampleVisibility::Type visibility);

#endif /* DOXYGEN_FOR_ISOCPP2 */

};

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

class Durability : public dds::core::Value
{
public:
    explicit Durability(
        dds::core::policy::DurabilityKind::Type kind = dds::core::policy::DurabilityKind::VOLATILE);

    Durability(const Durability& other);

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

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

public:
    static Durability Volatile();

    static Durability TransientLocal();

    static Durability Transient();

    static Durability Persistent();
};

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

class Presentation : public dds::core::Value
{
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);

public:
    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;

public:
    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);
};

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

class Reliability : public dds::core::Value
{
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);

public:
    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;

public:
    static 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));

#ifdef DOXYGEN_FOR_ISOCPP2
public:
    /*
     * The above macro is never (and must never) be defined in normal compilation.
     *
     * The following code is for documenting proprietary API only.
     */


    bool synchronous() const;

    void synchronous(bool b);

#endif /* DOXYGEN_FOR_ISOCPP2 */

};

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

class DestinationOrder : public dds::core::Value
{
public:
    explicit DestinationOrder(
        dds::core::policy::DestinationOrderKind::Type kind
        = dds::core::policy::DestinationOrderKind::BY_RECEPTION_TIMESTAMP);

    DestinationOrder(const DestinationOrder& other);

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

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

public:
    static DestinationOrder SourceTimestamp();

    static DestinationOrder ReceptionTimestamp();
};

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

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

    History(const History& other);

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

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

    int32_t depth() const;

    History& depth(int32_t depth);

public:
    static History KeepAll();

    static History KeepLast(uint32_t depth);
};

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

class ResourceLimits : public dds::core::Value
{
public:
    ResourceLimits(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);

    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
{
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);

public:
    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;

public:
    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());
};


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

class DurabilityService : public dds::core::Value
{
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);

public:
    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


class DataRepresentation : public dds::core::Value
{

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

    DataRepresentation(const DataRepresentation& other)
        : dds::core::Value(other.value())
    { }
public:
    DataRepresentation& value(const dds::core::policy::DataRepresentationIdSeq& value);

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

    dds::core::policy::DataRepresentationIdSeq&
};

#endif  // defined(OMG_DDS_EXTENSIBLE_AND_DYNAMIC_TOPIC_TYPE_SUPPORT)


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

#ifdef OMG_DDS_EXTENSIBLE_AND_DYNAMIC_TOPIC_TYPE_SUPPORT


class TypeConsistencyEnforcement : public dds::core::Value
{
public:
    explicit TypeConsistencyEnforcement(dds::core::policy::TypeConsistencyEnforcementKind::Type kind);

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

#endif  // defined(OMG_DDS_EXTENSIBLE_AND_DYNAMIC_TOPIC_TYPE_SUPPORT)


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


}
}
}

#endif /* OMG_TDDS_CORE_POLICY_CORE_POLICY_HPP_ */