TCorePolicy.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/Value.hpp>
#include <dds/core/policy/PolicyKind.hpp>

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

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

    explicit TUserData(const dds::core::ByteSeq& seq);

    //@TODO Implement
    TUserData(const uint8_t* value_begin, const uint8_t* value_end);

    TUserData(const TUserData& other);

  public:
    TUserData& value(const dds::core::ByteSeq& seq);

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

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

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

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

  template <typename D>
  class TGroupData : public dds::core::Value<D> {
  public:
    TGroupData() : dds::core::Value<D>();

    explicit TGroupData(const dds::core::ByteSeq& seq) : dds::core::Value<D>(seq);

    TGroupData(const TGroupData& other);

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

  public:
    TGroupData& value(const dds::core::ByteSeq& seq);

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

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

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

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

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

  template <typename D>
  class TTopicData : public dds::core::Value<D> {
  public:
    TTopicData() : dds::core::Value<D>();

    explicit TTopicData(const dds::core::ByteSeq& seq);

    TTopicData(const TTopicData& other);

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

  public:
    TTopicData& value(const dds::core::ByteSeq& seq);

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

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

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

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


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

  template <typename D>
  class TEntityFactory : public dds::core::Value<D> {
  public:
    TEntityFactory() :dds::core::Value<D>(true);
    explicit TEntityFactory(bool the_auto_enable);
    TEntityFactory(const TEntityFactory& other);

  public:
    TEntityFactory& autoenable_created_entities(bool on);
    bool autoenable_created_entities() const;

  public:
    static TEntityFactory AutoEnable();
    static TEntityFactory ManuallyEnable();
  };

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

  template <typename D>
  class TTransportPriority : public dds::core::Value<D> {
  public:
    explicit TTransportPriority(int32_t prio);

    TTransportPriority() : dds::core::Value<D>(0);

    TTransportPriority(const TTransportPriority& other);

  public:
    TTransportPriority& value(int32_t prio);
    int32_t value() const;
  };

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

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

    TLifespan();
    TLifespan(const TLifespan& other);

  public:
    TLifespan& duration(const dds::core::Duration& d);
    const dds::core::Duration duration() const;
  };

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

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

    TDeadline(const TDeadline& other);

    TDeadline();

  public:
    TDeadline& period(const dds::core::Duration& d);
    const dds::core::Duration period() const;
  };

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

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

    TLatencyBudget();
    TLatencyBudget(const TLatencyBudget& other);

  public:
    TLatencyBudget& duration(const dds::core::Duration& d);
    const dds::core::Duration duration() const;
  };

  //==============================================================================
  template <typename D>
  class TTimeBasedFilter : public dds::core::Value<D> {
  public:
    TTimeBasedFilter();
    explicit TTimeBasedFilter(const dds::core::Duration& the_min_separation);
    TTimeBasedFilter(const TTimeBasedFilter& other);

  public:
    TTimeBasedFilter& minimum_separation(const dds::core::Duration& ms);
    const dds::core::Duration minimum_separation() const;
  };


  //==============================================================================
  template <typename D>
  class TPartition : public dds::core::Value<D> {
  public:
    TPartition();
    explicit TPartition(const std::string& partition);
    explicit TPartition(const dds::core::StringSeq& partitions);
    TPartition(const TPartition& other);

  public:
    TPartition& name(const dds::core::StringSeq& partitions);

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

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

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

  template <typename D>
  class TOwnership : public dds::core::Value<D> {
  public:
    TOwnership();
    explicit TOwnership(dds::core::policy::OwnershipKind::Type the_kind);
    TOwnership(const TOwnership& other);



  public:
    TOwnership& kind(dds::core::policy::OwnershipKind::Type the_kind);
    dds::core::policy::OwnershipKind::Type kind() const;

  public:
    static TOwnership Exclusive();
    static TOwnership Shared();
  };


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


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

    TOwnershipStrength(const TOwnershipStrength& other);

  public:
    int32_t value() const;
    TOwnershipStrength& value(int32_t s);
  };

#endif  // OMG_DDS_OWNERSHIP_SUPPORT


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

  template <typename D>
  class TWriterDataLifecycle : public dds::core::Value<D> {
  public:
    TWriterDataLifecycle();
    explicit TWriterDataLifecycle(bool the_autodispose);
    TWriterDataLifecycle(const TWriterDataLifecycle& other);

  public:
    bool autodispose_unregistered_instances() const;
    TWriterDataLifecycle& autodispose_unregistered_instances(bool b);

  public:
    static TWriterDataLifecycle AutoDisposeUnregisteredInstances();
    static TWriterDataLifecycle ManuallyDisposeUnregisteredInstances();
  };

  template <typename D>
  class TReaderDataLifecycle : public dds::core::Value<D> {
  public:
    TReaderDataLifecycle();
    TReaderDataLifecycle(const dds::core::Duration& the_nowriter_delay,
        const dds::core::Duration& the_disposed_samples_delay);
    TReaderDataLifecycle(const TReaderDataLifecycle& other);
  public:
    const dds::core::Duration autopurge_nowriter_samples_delay() const;
    TReaderDataLifecycle& autopurge_nowriter_samples_delay(const dds::core::Duration& d);

    const dds::core::Duration autopurge_disposed_samples_delay() const;
    TReaderDataLifecycle& autopurge_disposed_samples_delay(const dds::core::Duration& d);

  public:
    static TReaderDataLifecycle NoAutoPurgeDisposedSamples();
    static TReaderDataLifecycle AutoPurgeDisposedSamples(const dds::core::Duration& d);
  };

  //==============================================================================
  template <typename D>
  class TDurability : public dds::core::Value<D> {
  public:
    TDurability();
    explicit TDurability(dds::core::policy::DurabilityKind::Type the_kind);
    TDurability(const TDurability& other);

  public:
    TDurability& kind(dds::core::policy::DurabilityKind::Type the_kind);
    dds::core::policy::DurabilityKind::Type  kind() const;

  public:
    static TDurability Volatile();
    static TDurability TransientLocal();
    static TDurability Transient();
    static TDurability Persistent();
  };
  //==============================================================================
  template <typename D>
  class TPresentation : public dds::core::Value<D> {
  public:
    TPresentation();
    TPresentation(dds::core::policy::PresentationAccessScopeKind::Type the_access_scope,
        bool the_coherent_access,
        bool the_ordered_access);

    TPresentation(const TPresentation& other);


  public:
    TPresentation& access_scope(dds::core::policy::PresentationAccessScopeKind::Type  as);
    dds::core::policy::PresentationAccessScopeKind::Type  access_scope() const;

    TPresentation& coherent_access(bool on);
    bool coherent_access() const;

    TPresentation& ordered_access(bool on);
    bool ordered_access() const;

  public:
    static TPresentation GroupAccessScope(bool coherent = false, bool ordered = false);
    static TPresentation InstanceAccessScope(bool coherent = false, bool ordered = false);
    static TPresentation TopicAccessScope(bool coherent = false, bool ordered = false);
  };

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

  template <typename D>
  class TReliability : public dds::core::Value<D> {
  public:
    TReliability();
    TReliability(dds::core::policy::ReliabilityKind::Type the_kind,
        const dds::core::Duration& the_max_blocking_time);
    TReliability(const TReliability& other);

  public:

    TReliability& kind(dds::core::policy::ReliabilityKind::Type the_kind);
    dds::core::policy::ReliabilityKind::Type  kind() const;

    TReliability& max_blocking_time(const dds::core::Duration& d);
    const dds::core::Duration max_blocking_time() const;

  public:
    static TReliability Reliable(const dds::core::Duration& d = dds::core::Duration::infinite());
    static TReliability BestEffort();
  };


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

  template <typename D>
  class TDestinationOrder : public dds::core::Value<D> {
  public:
    TDestinationOrder();
    explicit TDestinationOrder(dds::core::policy::DestinationOrderKind::Type the_kind);

    TDestinationOrder(const TDestinationOrder& other);

  public:
    TDestinationOrder& kind(dds::core::policy::DestinationOrderKind::Type the_kind);
    dds::core::policy::DestinationOrderKind::Type  kind() const;

  public:
    static TDestinationOrder SourceTimestamp();
    static TDestinationOrder ReceptionTimestamp();
  };

  //==============================================================================
  template <typename D>
  class THistory : public dds::core::Value<D> {
  public:
    THistory();
    THistory(dds::core::policy::HistoryKind::Type the_kind, int32_t the_depth);
    THistory(const THistory& other);

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

    int32_t depth() const;
    THistory& depth(int32_t the_depth);

  public:
    static THistory KeepAll();
    static THistory KeepLast(uint32_t depth);
  };

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

  template <typename D>
  class TResourceLimits : public dds::core::Value<D> {
  public:
    TResourceLimits();
    TResourceLimits(int32_t the_max_samples,
        int32_t the_max_instances,
        int32_t the_max_samples_per_instance);
    TResourceLimits(const TResourceLimits& other);

  public:
    TResourceLimits& max_samples(int32_t samples);
    int32_t max_samples() const;

    TResourceLimits& max_instances(int32_t the_max_instances);
    int32_t max_instances() const;

    TResourceLimits& max_samples_per_instance(int32_t the_max_samples_per_instance);
    int32_t max_samples_per_instance() const;
  };



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

  template <typename D>
  class TLiveliness : public dds::core::Value<D> {
  public:
    TLiveliness();
    TLiveliness(dds::core::policy::LivelinessKind::Type the_kind,
        const dds::core::Duration& the_lease_duration);
    TLiveliness(const TLiveliness& other);

  public:
    TLiveliness& kind(dds::core::policy::LivelinessKind::Type the_kind);
    dds::core::policy::LivelinessKind::Type kind() const;

    TLiveliness& lease_duration(const dds::core::Duration& the_lease_duration);
    const dds::core::Duration lease_duration() const;

  public:
    static TLiveliness Automatic();
    static TLiveliness ManualByParticipant(const dds::core::Duration& lease = dds::core::Duration::infinite());
    static TLiveliness ManualByTopic(const dds::core::Duration& lease = dds::core::Duration::infinite());
  };


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

#ifdef OMG_DDS_PERSISTENCE_SUPPORT

  template <typename D>
  class TDurabilityService : public dds::core::Value<D> {
  public:
    TDurabilityService();

    TDurabilityService(
        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);

    TDurabilityService(const TDurabilityService& other);


  public:
    TDurabilityService& service_cleanup_delay(const dds::core::Duration& d);
    const dds::core::Duration service_cleanup_delay() const;

    TDurabilityService& history_kind(dds::core::policy::HistoryKind::Type the_kind);
    dds::core::policy::HistoryKind::Type history_kind() const;

    TDurabilityService& history_depth(int32_t the_depth);

    int32_t history_depth() const;

    TDurabilityService& max_samples(int32_t the_max_samples);
    int32_t max_samples() const;

    TDurabilityService& max_instances(int32_t the_max_instances);
    int32_t max_instances() const;

    TDurabilityService& max_samples_per_instance(int32_t the_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

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

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

    TDataRepresentation(const TDataRepresentation& other)
    : dds::core::Value<D>(other.value())
      { }
  public:
    TDataRepresentation& 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 TTypeConsistencyEnforcement : public dds::core::Value<D> {
  public:
    explicit TTypeConsistencyEnforcement(dds::core::policy::TypeConsistencyEnforcementKind::Type kind);

  public:
    TTypeConsistencyEnforcement& 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_ */