src/hpp/tdds/core/policy/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 <tdds/core/corefwd.hpp>
#include <dds/core/LengthUnlimited.hpp>
#include <dds/core/Value.hpp>
#include <dds/core/policy/PolicyKind.hpp>

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

//==============================================================================
template <typename D>
class UserData : public dds::core::Value<D> {
public:
        UserData() : dds::core::Value<D>() { }

        explicit UserData(const dds::core::ByteSeq& seq) : dds::core::Value<D>(seq) { }

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

public:
        void value(const dds::core::ByteSeq& seq) {
                this->delegate().value(seq);
        }

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

        const dds::core::ByteSeq value() const {
                return this->delegate().value();
        }

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

        const uint8_t* begin() const;
        const uint8_t* end() const;
};

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

template <typename D>
class GroupData : public dds::core::Value<D> {
public:
        GroupData() : dds::core::Value<D>() { }

        explicit GroupData(const dds::core::ByteSeq& seq) : dds::core::Value<D>(seq) { }

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

public:
        void value(const dds::core::ByteSeq& seq) {
                this->delegate().value(seq);
        }

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

        const dds::core::ByteSeq value() const {
                return this->delegate().value();
        }

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

        const uint8_t* begin() const;
        const uint8_t* end() const;
};

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

template <typename D>
class TopicData : public dds::core::Value<D> {
public:
        TopicData() : dds::core::Value<D>() { }

        explicit TopicData(const dds::core::ByteSeq& seq) : dds::core::Value<D>(seq) { }

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

public:
        void value(const dds::core::ByteSeq& seq) {
                this->delegate().value(seq);
        }

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

        const dds::core::ByteSeq value() const {
                return this->delegate().value();
        }

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

        const uint8_t* begin() const;
        const uint8_t* end() const;
};

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

template <typename D>
class EntityFactory : public dds::core::Value<D> {
public:
        EntityFactory() :dds::core::Value<D>(true) { }

        explicit EntityFactory(bool the_auto_enable)
        : dds::core::Value<D>(the_auto_enable) { }

public:
        void autoenable_created_entities(bool on) {
                this->delegate().auto_enable(on);
        }
        bool autoenable_created_entities() const {
                return this->delegate().auto_enable();
        }

public:
        static EntityFactory AutoEnable() {
                return EntityFactory(true);
        }
        static EntityFactory ManuallyEnable() {
                return EntityFactory(false);
        }
};

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

template <typename D>
class TransportPriority : public dds::core::Value<D> {
public:
        explicit TransportPriority(int32_t prio) : dds::core::Value<D>(prio) { }
        TransportPriority() : dds::core::Value<D>(0) { }
public:
        void value(int32_t prio) {
                this->delegate().value(prio);
        }
        int32_t value() const {
                return this->delegate().value();
        }
};

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

template <typename D>
class Lifespan : public dds::core::Value<D> {
public:
        explicit Lifespan(const dds::core::Duration& d) : dds::core::Value<D>(d) { }
        Lifespan() : dds::core::Value<D>(dds::core::Duration::infinite()) { }

public:
        void duration(const dds::core::Duration& d) {
                this->delegate().duration(d);
        }
        const dds::core::Duration duration() const {
                return this->delegate().duration();
        }
};

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

template <typename D>
class Deadline : public dds::core::Value<D> {
public:
        explicit Deadline(const dds::core::Duration& d) : dds::core::Value<D>(d) { }

        Deadline() : dds::core::Value<D>(dds::core::Duration::infinite()) { }

public:
        void period(const dds::core::Duration& d) {
                this->delegate().period(d);
        }
        const dds::core::Duration period() const {
                return this->delegate().period();
        }
};

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

template <typename D>
class LatencyBudget : public dds::core::Value<D>{
public:
        explicit LatencyBudget(const dds::core::Duration& d) : dds::core::Value<D>(d) { }
        LatencyBudget() : dds::core::Value<D>(dds::core::Duration::zero()) { }

public:
        void duration(const dds::core::Duration& d) {
                this->delegate().duration(d);
        }
        const dds::core::Duration duration() const {
                return this->delegate().duration();
        }
};

//==============================================================================
template <typename D>
class TimeBasedFilter : public dds::core::Value<D> {
public:
        TimeBasedFilter() : dds::core::Value<D>(dds::core::Duration::zero()) { }
        explicit TimeBasedFilter(const dds::core::Duration& the_min_separation)
        : dds::core::Value<D>(the_min_separation) { }

public:
        void minimum_separation(const dds::core::Duration& ms) {
                this->delegate().min_separation(ms);
        }
        const dds::core::Duration minimum_separation() const {
                return this->delegate().min_separation();
        }
};

//==============================================================================
template <typename D>
class Partition : public dds::core::Value<D> {
public:
        explicit Partition(const std::string& partition) : dds::core::Value<D>() {
                this->delegate().name().push_back(partition);
        }
        explicit Partition(const dds::core::StringSeq& partitions)
        : dds::core::Value<D>(partitions) { }

        Partition() : dds::core::Value<D>() {
                this->delegate().name().push_back("");
        }

public:
        void name(const dds::core::StringSeq& partitions) {
                this->delegate().name() = partitions;
        }

        const dds::core::StringSeq name() const {
                return this->delegate().name();
        }

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

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

template <typename D>
class Ownership : public dds::core::Value<D> {
public:
        explicit Ownership(dds::core::policy::OwnershipKind::Type the_kind)
        : dds::core::Value<D>(the_kind) { }
        Ownership() : dds::core::Value<D>(dds::core::policy::OwnershipKind::SHARED) { }

public:
    void kind(dds::core::policy::OwnershipKind::Type the_kind) {
        this->delegate().kind(the_kind);
    }
    dds::core::policy::OwnershipKind::Type kind() const {
        return this->delegate().kind();
    }

public:
        static Ownership Exclusive() {
                return Ownership(dds::core::policy::OwnershipKind::EXCLUSIVE);
        }
        static Ownership Shared() {
                return Ownership(dds::core::policy::OwnershipKind::SHARED);
        }
};
//==============================================================================

#ifdef OMG_DDS_OWNERSHIP_SUPPORT

template <typename D>
class OwnershipStrength : public dds::core::Value<D> {
public:
        explicit OwnershipStrength(int32_t s) : dds::core::Value<D>(s) { }

public:
        int32_t value() const { return this->delegate().strength(); }
        void value(int32_t s) { this->delegate().strength(s); }
};

#endif  // OMG_DDS_OWNERSHIP_SUPPORT


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

template <typename D>
class WriterDataLifecycle : public dds::core::Value<D> {
public:
        WriterDataLifecycle() :
                dds::core::Value<D>(true) { }

        explicit WriterDataLifecycle(bool the_autodispose)
        : dds::core::Value<D>(the_autodispose) { }

public:
    bool autodispose_unregistered_instances() const {
        return this->delegate().autodispose();
    }
    void autodispose_unregistered_instances(bool b) {
        this->delegate().autodispose(b);
    }

public:
        static WriterDataLifecycle AutoDisposeUnregisteredInstances() {
                return WriterDataLifecycle(true);
        }
        static WriterDataLifecycle ManuallyDisposeUnregisteredInstances() {
                return WriterDataLifecycle(false);
        }
};

template <typename D>
class ReaderDataLifecycle : public dds::core::Value<D> {
public:
        ReaderDataLifecycle() :
                dds::core::Value<D>(dds::core::Duration::infinite(),
                                dds::core::Duration::infinite())  { }

        ReaderDataLifecycle(const dds::core::Duration& the_nowriter_delay,
                        const dds::core::Duration& the_disposed_samples_delay)
        : dds::core::Value<D>(the_nowriter_delay, the_disposed_samples_delay) { }

public:
        const dds::core::Duration autopurge_nowriter_samples_delay() const {
                return this->delegate().nowriter_delay();
        }

        void autopurge_nowriter_samples_delay(const dds::core::Duration& d) {
                this->delegate().nowriter_delay(d);
        }

        const dds::core::Duration autopurge_disposed_samples_delay() const {
                return this->delegate().disposed_samples_delay();
        }

        void autopurge_disposed_samples_delay(const dds::core::Duration& d) {
                this->delegate().disposed_samples_delay(d);
        }
public:
        static ReaderDataLifecycle NoAutoPurgeDisposedSamples() {
                return ReaderDataLifecycle();
        }
        static ReaderDataLifecycle AutoPurgeDisposedSamples(const dds::core::Duration& d) {
                return ReaderDataLifecycle(d);
        }
};

//==============================================================================
template <typename D>
class Durability : public dds::core::Value<D> {
public:
        Durability(dds::core::policy::DurabilityKind::Type the_kind)
        : dds::core::Value<D>(the_kind) { }
        Durability() : dds::core::Value<D>(dds::core::policy::DurabilityKind::VOLATILE) { }

public:
        void kind(dds::core::policy::DurabilityKind::Type the_kind) {
                this->delegate().kind(the_kind);
        }

        dds::core::policy::DurabilityKind::Type  kind() const {
                return this->delegate().kind();
        }
public:
        static Durability Volatile() {
                return Durability(dds::core::policy::DurabilityKind::VOLATILE);
        }
        static Durability TransientLocal() {
                return Durability(dds::core::policy::DurabilityKind::TRANSIENT_LOCAL);
        }
        static Durability Transient() {
                return Durability(dds::core::policy::DurabilityKind::TRANSIENT);
        }
        static Durability Persistent() {
                return Durability(dds::core::policy::DurabilityKind::PERSISTENT);
        }
};
//==============================================================================
template <typename D>
class Presentation : public dds::core::Value<D> {
public:
        Presentation()
        :  dds::core::Value<D>(dds::core::policy::PresentationAccessScopeKind::INSTANCE,
                        false,
                        false) { }

        Presentation(dds::core::policy::PresentationAccessScopeKind::Type the_access_scope,
                        bool the_coherent_access,
                        bool the_ordered_access)
        :  dds::core::Value<D>(the_access_scope,
                        the_coherent_access,
                        the_ordered_access)
                        { }

public:
        void access_scope(dds::core::policy::PresentationAccessScopeKind::Type  as) {
                this->delegate().access_scope(as);
        }
        dds::core::policy::PresentationAccessScopeKind::Type  access_scope() const {
                return this->delegate().access_scope();
        }

        void coherent_access(bool on) {
                this->delegate().coherent_access(on);
        }
        bool coherent_access() const {
                return this->delegate().coherent_access();
        }

        void ordered_access(bool on) {
                this->delegate().ordered_access(on);
        }
        bool ordered_access() const {
                return this->delegate().ordered_access();
        }
public:
        static Presentation GroupAccessScope(bool coherent = false, bool ordered = false) {
                return GroupAccessScope(dds::core::policy::PresentationAccessScopeKind::GROUP,
                                coherent,
                                ordered);
        }
        static Presentation InstanceAccessScope(bool coherent = false, bool ordered = false) {
                return GroupAccessScope(dds::core::policy::PresentationAccessScopeKind::INSTANCE,
                                coherent,
                                ordered);
        }
        static Presentation TopicAccessScope(bool coherent = false, bool ordered = false) {
                return GroupAccessScope(dds::core::policy::PresentationAccessScopeKind::TOPIC,
                                coherent,
                                ordered);
        }
};

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

template <typename D>
class Reliability : public dds::core::Value<D> {
public:
        Reliability()
        :  dds::core::Value<D>(dds::core::policy::ReliabilityKind::BEST_EFFORT,
                        dds::core::Duration::zero()) { }

        Reliability(dds::core::policy::ReliabilityKind::Type the_kind,
                        const dds::core::Duration& the_max_blocking_time)
        :  dds::core::Value<D>(the_kind,
                        the_max_blocking_time)
                        { }

public:

        void kind(dds::core::policy::ReliabilityKind::Type the_kind) {
                this->delegate().kind(the_kind);
        }
        dds::core::policy::ReliabilityKind::Type  kind() const {
                return this->delegate().kind();
        }

        void max_blocking_time(const dds::core::Duration& d) {
                this->delegate().max_blocking_time(d);
        }
        const dds::core::Duration max_blocking_time() const {
                return this->delegate().max_blocking_time();
        }
public:
        static Reliability Reliable(const dds::core::Duration& d = dds::core::Duration::infinite()) {
                return Reliability(dds::core::policy::ReliabilityKind::RELIABLE, d);
        }
        static Reliability BestEffort() {
                return Reliability(dds::core::policy::ReliabilityKind::BEST_EFFORT);
        }
};


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

template <typename D>
class DestinationOrder : public dds::core::Value<D> {

public:
        explicit DestinationOrder(dds::core::policy::DestinationOrderKind::Type the_kind)
        : dds::core::Value<D>(the_kind) { }
        DestinationOrder() :
                dds::core::Value<D>(dds::core::policy::DestinationOrderKind::BY_SOURCE_TIMESTAMP) { }

public:
        void kind(dds::core::policy::DestinationOrderKind::Type the_kind) {
                this->delegate().kind(the_kind);
        }
        dds::core::policy::DestinationOrderKind::Type  kind() const {
                return this->delegate().kind();
        }
public:
        static DestinationOrder SourceTimestamp() {
                return DestinationOrder(dds::core::policy::DestinationOrderKind::BY_SOURCE_TIMESTAMP);
        }
        static DestinationOrder ReceptionTimestamp() {
                return DestinationOrder(dds::core::policy::DestinationOrderKind::BY_RECEPTION_TIMESTAMP);
        }
};

//==============================================================================
template <typename D>
class History : public dds::core::Value<D> {
public:
        History()
        :  dds::core::Value<D>(dds::core::policy::HistoryKind::KEEP_LAST, 1) { }


        History(dds::core::policy::HistoryKind::Type the_kind, int32_t the_depth)
        : dds::core::Value<D>(the_kind, the_depth) { }

public:
        dds::core::policy::HistoryKind::Type  kind() const {
                return this->delegate().kind();
        }
        void kind(dds::core::policy::HistoryKind::Type the_kind) {
                this->delegate().kind(the_kind);
        }

        int32_t depth() const {
                return this->delegate().depth();
        }
        void depth(int32_t the_depth) {
                this->delegate().depth(the_depth);
        }
public:
        static History KeepAll() {
                return History(dds::core::policy::HistoryKind::KEEP_ALL);
        }
        static History KeepLast(uint32_t depth) {
                return History(dds::core::policy::HistoryKind::KEEP_LAST, depth);
        }
};

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

template <typename D>
class ResourceLimits : public dds::core::Value<D> {
public:
        ResourceLimits()
        :  dds::core::Value<D>(dds::core::LENGTH_UNLIMITED,
                        dds::core::LENGTH_UNLIMITED,
                        dds::core::LENGTH_UNLIMITED) { }

        ResourceLimits(int32_t the_max_samples,
                        int32_t the_max_instances,
                        int32_t the_max_samples_per_instance)
        :  dds::core::Value<D>(the_max_samples,
                        the_max_instances,
                        the_max_samples_per_instance)
                        { }

public:
        void max_samples(int32_t samples) {
                this->delegate().max_samples(samples);
        }
        int32_t max_samples() const {
                return this->delegate().max_samples();
        }

        void max_instances(int32_t the_max_instances) {
                this->delegate().max_instances(the_max_instances);
        }
        int32_t max_instances() const {
                return this->delegate().max_instances();
        }

        void max_samples_per_instance(int32_t the_max_samples_per_instance) {
                this->delegate().max_samples_per_instance(the_max_samples_per_instance);
        }
        int32_t max_samples_per_instance() const {
                return this->delegate().max_samples_per_instance();
        }
};


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

template <typename D>
class Liveliness : public dds::core::Value<D> {
public:
        Liveliness()
        :  dds::core::Value<D>(dds::core::policy::LivelinessKind::AUTOMATIC,
                        dds::core::Duration::infinite()) { }

        Liveliness(dds::core::policy::LivelinessKind::Type the_kind,
                        const dds::core::Duration& the_lease_duration)
        :  dds::core::Value<D>(the_kind, the_lease_duration) { }

public:
        void kind(dds::core::policy::LivelinessKind::Type the_kind) {
                this->delegate().kind(kind);
        }
        dds::core::policy::LivelinessKind::Type kind() const {
                return this->delegate().kind();
        }

        void lease_duration(const dds::core::Duration& the_lease_duration){
                this->delegate().lease_duration(the_lease_duration);
        }
        const dds::core::Duration lease_duration() const {
                return this->delegate().lease_duration();
        }
public:
        static Liveliness Automatic() {
                return Liveliness(dds::core::policy::LivelinessKind::AUTOMATIC, dds::core::Duration::infinite());
        }
        static Liveliness ManualByParticipant(const dds::core::Duration& lease = dds::core::Duration::infinite()) {
                return Liveliness(dds::core::policy::LivelinessKind::MANUAL_BY_PARTICIPANT, lease);
        }
        static Liveliness ManualByTopic(const dds::core::Duration& lease = dds::core::Duration::infinite()) {
                return Liveliness(dds::core::policy::LivelinessKind::MANUAL_BY_TOPIC, lease);
        }
};


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

#ifdef OMG_DDS_PERSISTENCE_SUPPORT

template <typename D>
class DurabilityService : public dds::core::Value<D> {
public:
        DurabilityService() :
                dds::core::Value<D>() { }

        DurabilityService(
                        const dds::core::Duration& the_service_cleanup_delay,
                        dds::core::policy::HistoryKind::Type the_history_kind,
                        int32_t the_history_depth,
                        int32_t the_max_samples,
                        int32_t the_max_instances,
                        int32_t the_max_samples_per_instance)
        : dds::core::Value<D>(the_service_cleanup_delay,
                        the_history_kind,
                        the_history_depth,
                        the_max_samples,
                        the_max_instances,
                        the_max_samples_per_instance) { }

public:
        void service_cleanup_delay(const dds::core::Duration& d)  {
                this->delegate().service_cleanup_delay(d);
        }
        const dds::core::Duration service_cleanup_delay() const {
                return this->delegate().service_cleanup_delay();
        }

        void history_kind(dds::core::policy::HistoryKind::Type the_kind) {
                this->delegate().history_kind(the_kind);
        }
        dds::core::policy::HistoryKind::Type history_kind() const {
                return this->delegate().history_kind();
        }

        void history_depth(int32_t the_depth) {
                this->delegate().history_depth(the_depth);
        }
        int32_t history_depth() const {
                return this->delegate().history_depth();
        }

        void max_samples(int32_t the_max_samples) {
                this->delegate().max_samples(the_max_samples);
        }
        int32_t max_samples() const {
                return this->delegate().max_samples();
        }

        void max_instances(int32_t the_max_instances) {
                this->delegate().the_max_instances(the_max_instances);
        }
        int32_t max_instances() const {
                return this->delegate().max_instances();
        }

        void max_samples_per_instance(int32_t the_max_samples_per_instance) {
                this->delegate().the_max_instances(
                                the_max_samples_per_instance);
        }
        int32_t max_samples_per_instance() const {
                return this->delegate().max_samples_per_instance();
        }
};

#endif  // OMG_DDS_PERSISTENCE_SUPPORT


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

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

#ifdef OMG_DDS_EXTENSIBLE_AND_DYNAMIC_TOPIC_TYPE_SUPPORT

template <typename D>
class DataRepresentation : public dds::core::Value<D> {

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

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

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

    dds::core::policy::DataRepresentationIdSeq&
    value(dds::core::policy::DataRepresentationIdSeq& dst) const;
};

#endif  // defined(OMG_DDS_EXTENSIBLE_AND_DYNAMIC_TOPIC_TYPE_SUPPORT)


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

#ifdef OMG_DDS_EXTENSIBLE_AND_DYNAMIC_TOPIC_TYPE_SUPPORT

template <typename D>
class TypeConsistencyEnforcement : public dds::core::Value<D> {
public:
    explicit TypeConsistencyEnforcement(dds::core::policy::TypeConsistencyEnforcementKind::Type kind);

public:
    void kind(dds::core::policy::TypeConsistencyEnforcementKind::Type  value);
    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_ */