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/AnyDataWriter.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>
class dds::pub::DataWriter : public ::dds::pub::AnyDataWriter
{
 
public:
    typedef dds::pub::DataWriterListener<T>              Listener;
 
public:
    OMG_DDS_REF_TYPE_PROTECTED_DC_T(DataWriter, dds::pub::AnyDataWriter, T)
    OMG_DDS_IMPLICIT_REF_BASE(DataWriter)
 
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::none());
 
public:
    virtual ~DataWriter();
public:
    //==========================================================================
    //== Write API
 
    void write(const T& sample);
 
    void write(const T& sample, const dds::core::Time& timestamp);
 
    void write(const T& sample, 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& timestamp);
 
    DataWriter& unregister_instance(const ::dds::core::InstanceHandle& i);
 
    DataWriter& unregister_instance(const ::dds::core::InstanceHandle& i,
                                    const dds::core::Time& timestamp);
 
    DataWriter& unregister_instance(const T& key);
 
    DataWriter& unregister_instance(const T& key,
                                    const dds::core::Time& timestamp);
 
    DataWriter& dispose_instance(const ::dds::core::InstanceHandle& i);
 
    DataWriter& dispose_instance(const ::dds::core::InstanceHandle& i,
                                 const dds::core::Time& timestamp);
 
    DataWriter& dispose_instance(const T& key);
 
    DataWriter& dispose_instance(const T& key,
                                 const dds::core::Time& timestamp);
 
    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
 
    DataWriter& operator <<(const ::dds::pub::qos::DataWriterQos& qos);
 
 
    //==========================================================================
    //== Entity Navigation
 
    const dds::topic::Topic<T>& topic() const;
 
    //==========================================================================
    //== Listeners Management
 
    void listener(DataWriterListener<T>* listener,
                  const ::dds::core::status::StatusMask& mask);
 
    DataWriterListener<T>* listener() const;
};
 
#endif /* OMG_DDS_PUB_DATA_WRITER_HPP_ */