DataWriter.hpp

Go to the documentation of this file.

#ifndef OMG_DDS_PUB_DATA_WRITER_HPP_
#define OMG_DDS_PUB_DATA_WRITER_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/InstanceHandle.hpp>
#include <dds/topic/Topic.hpp>
#include <dds/topic/TopicInstance.hpp>
#include <dds/topic/BuiltinTopic.hpp>
#include <dds/pub/Publisher.hpp>

#include <dds/pub/detail/DataWriter.hpp>

namespace dds {
  namespace pub {
    template <typename T,
    template <typename Q> class DELEGATE = dds::pub::detail::DataWriter >
    class DataWriter;

    template <typename T> class DataWriterListener;
  }
}

template <typename T, template <typename Q> class DELEGATE>
class dds::pub::DataWriter : public ::dds::core::TEntity< DELEGATE<T> > {

public:
  typedef dds::pub::DataWriterListener<T>              Listener;

public:
  OMG_DDS_REF_TYPE(DataWriter, ::dds::core::TEntity, DELEGATE<T>)

public:

  DataWriter(const dds::pub::Publisher& pub,
      const ::dds::topic::Topic<T>& topic);

  DataWriter(const dds::pub::Publisher& pub,
      const ::dds::topic::Topic<T>& topic,
      const dds::pub::qos::DataWriterQos& qos,
      dds::pub::DataWriterListener<T>* listener = NULL,
      const dds::core::status::StatusMask& mask = ::dds::core::status::StatusMask::all());

public:
  ~DataWriter();


public:
  //==========================================================================
  //== Write API

  void write(const T& sample);

  void write(const T& sample, const dds::core::Time& timestamp);

  void write(const T& data, const ::dds::core::InstanceHandle& instance);

  void write(const T& data,
      const ::dds::core::InstanceHandle& instance,
      const dds::core::Time& timestamp);


  void write(const dds::topic::TopicInstance<T>& i);

  void write(const dds::topic::TopicInstance<T>& i,
      const dds::core::Time& timestamp);

  template <typename FWIterator>
  void write(const FWIterator& begin, const FWIterator& end);

  template <typename FWIterator>
  void write(const FWIterator& begin, const FWIterator& end,
      const dds::core::Time& timestamp);

  template <typename SamplesFWIterator, typename HandlesFWIterator>
  void write(const SamplesFWIterator& data_begin,
      const SamplesFWIterator& data_end,
      const HandlesFWIterator& handle_begin,
      const HandlesFWIterator& handle_end);

  template <typename SamplesFWIterator, typename HandlesFWIterator>
  void write(const SamplesFWIterator& data_begin,
      const SamplesFWIterator& data_end,
      const HandlesFWIterator& handle_begin,
      const HandlesFWIterator& handle_end,
      const dds::core::Time& timestamp);


  DataWriter& operator << (const T& data);

  DataWriter& operator << (const std::pair<T, dds::core::Time>& data);

  DataWriter& operator << (const std::pair<T, ::dds::core::InstanceHandle>& data);

  DataWriter&
  operator <<(DataWriter& (*manipulator)(DataWriter&));

  //==========================================================================
  //== Instance Management
  const ::dds::core::InstanceHandle register_instance(const T& key);

  const ::dds::core::InstanceHandle register_instance(const T& key,
      const dds::core::Time& ts);

  DataWriter& unregister_instance(const ::dds::core::InstanceHandle& i);

  DataWriter& unregister_instance(const ::dds::core::InstanceHandle& i,
      const dds::core::Time& ts);

  DataWriter& dispose_instance(const ::dds::core::InstanceHandle& i);

  DataWriter& dispose_instance(const ::dds::core::InstanceHandle& i,
      const dds::core::Time& ts);

  dds::topic::TopicInstance<T>& key_value(dds::topic::TopicInstance<T>& i,
      const ::dds::core::InstanceHandle& h);

  T& key_value(T& sample, const ::dds::core::InstanceHandle& h);

  dds::core::InstanceHandle lookup_instance(const T& key);

  //==========================================================================
  //== QoS Management

  const ::dds::pub::qos::DataWriterQos& qos() const;

  void qos(const ::dds::pub::qos::DataWriterQos& the_qos);

  DataWriter& operator <<(const ::dds::pub::qos::DataWriterQos& the_qos);

  const DataWriter& operator >> (::dds::pub::qos::DataWriterQos& the_qos) const;


  //==========================================================================
  //== Entity Navigation

  const dds::topic::Topic<T>& topic() const;

  const dds::pub::Publisher& publisher() const;

  //==========================================================================
  //== ACKs

  void wait_for_acknowledgments(const dds::core::Duration& timeout);

  //==========================================================================
  //== Listeners Management

  void listener(DataWriterListener<T>* the_listener,
      const ::dds::core::status::StatusMask& mask);

  DataWriterListener<T>* listener() const;

  //==========================================================================
  //== Status Management

  const ::dds::core::status::LivelinessLostStatus liveliness_lost_status();

  const ::dds::core::status::OfferedDeadlineMissedStatus offered_deadlined_missed_status();

  const ::dds::core::status::OfferedIncompatibleQosStatus offered_incompatible_qos_staus();

  const ::dds::core::status::PublicationMatchedStatus publication_matched_status();


  //==========================================================================
  //== Liveliness Management

  void assert_liveliness();
};

#endif /* OMG_DDS_PUB_DATA_WRITER_HPP_ */