src/hpp/tdds/domain/DomainParticipant.hpp

Go to the documentation of this file.

#ifndef OMG_TDDS_DOMAIN_DOMAIN_PARTICIPANT_HPP_
#define OMG_TDDS_DOMAIN_DOMAIN_PARTICIPANT_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 <string>

#include <dds/core/detail/conformance.hpp>
#include <tdds/core/Entity.hpp>
#include <dds/core/cond/StatusCondition.hpp>
#include <dds/topic/qos/TopicQos.hpp>
#include <dds/topic/Topic.hpp>
#include <dds/topic/ContentFilteredTopic.hpp>
#include <dds/topic/MultiTopic.hpp>
#include <dds/pub/pubfwd.hpp>
#include <dds/pub/qos/PublisherQos.hpp>
#include <dds/pub/Publisher.hpp>
#include <dds/sub/qos/SubscriberQos.hpp>
#include <dds/sub/Subscriber.hpp>
#include <dds/domain/domainfwd.hpp>
#include <dds/domain/qos/DomainParticipantQos.hpp>
#include <dds/core/macros.hpp>

namespace tdds { namespace domain {


template <typename DELEGATE>
class DomainParticipant : public tdds::core::Entity<DELEGATE> {
public:
    typedef dds::domain::DomainParticipantListener Listener;

    typedef dds::core::cond::StatusCondition<DomainParticipant>
    StatusCondition;

public:
    OMG_DDS_REF_TYPE(DomainParticipant, tdds::core::Entity, DELEGATE)

public:
    ~DomainParticipant() {
        OMG_DDS_LOG("MM", "~DomainParticipant()");
    }

public:
    StatusCondition status_condition() const{
        return this->delegate()->template status_condition<DomainParticipant>(*this);
    }

    void listener(
            Listener* the_listener,
            const dds::core::status::StatusMask& event_mask) {
        this->delegate()->listener(the_listener, event_mask);
    }

    Listener* listener() const {
        return this->delegate()->listener();
    }

    using tdds::core::Entity<DELEGATE>::qos;

    const dds::domain::qos::DomainParticipantQos
    qos() const {
        return this->delegate()->qos();
    }

    void qos(const dds::domain::qos::DomainParticipantQos& the_qos) {
        this->delegate()->qos(the_qos);
    }

    dds::domain::DomainId domain_id() const {
        return this->delegate()->domain_id();
    }


    void
    assert_liveliness() {
        this->delegate()->assert_liveliness();
    }


    bool
    contains_entity(const dds::core::InstanceHandle& handle) {
        return this->delegate()->contains_entity();
    }

    const dds::core::Time
    current_time() {
        return this->delegate()->current_time();
    }

    // --- Publisher Factory Methods: --- //
public:
    dds::pub::Publisher create_publisher();

    dds::pub::Publisher create_publisher(
            const dds::pub::qos::PublisherQos& pub_qos,
            dds::pub::PublisherListener* pub_listener = NULL,
            const dds::core::status::StatusMask& event_mask =
                    dds::core::status::StatusMask::all());

    dds::pub::Publisher create_publisher(
            const std::string& qos_library_name,
            const std::string& qos_profile_name,
            const dds::pub::PublisherListener* a_listener = NULL,
            const dds::core::status::StatusMask& mask =
                    dds::core::status::StatusMask::all());

    const dds::pub::qos::PublisherQos default_publisher_qos() const;
    void default_publisher_qos(const dds::pub::qos::PublisherQos& qos);
    void default_publisher_qos(const std::string& qos_library_name,
                               const std::string& qos_profile_name);

    // --- Subscriber Factory Methods: --- //
public:
    dds::sub::Subscriber create_subscriber();

    dds::sub::Subscriber create_subscriber(
            const dds::sub::qos::SubscriberQos& qos,
            dds::sub::SubscriberListener* a_listener = NULL,
            const dds::core::status::StatusMask& a_mask =
                    dds::core::status::StatusMask::all());

    dds::sub::Subscriber create_subscriber(
            const std::string& qos_library_name,
            const std::string& qos_profile_name,
            dds::sub::SubscriberListener* a_listener = NULL,
            const dds::core::status::StatusMask& a_mask =
                    dds::core::status::StatusMask::all());

    const dds::sub::qos::SubscriberQos default_subscriber_qos() const;
    void default_subscriber_qos(const dds::sub::qos::SubscriberQos& qos);
    void default_subscriber_qos(const std::string& qos_library_name,
                                const std::string& qos_profile_name);

    // --- Topic Factory Methods: --- //
public:
    template <typename T>
    dds::topic::Topic<T> create_topic(
            const std::string& topic_name);

    template <typename T>
    dds::topic::Topic<T> create_topic(
            const std::string& topic_name,
            const std::string& type_name_name);

    template <typename T>
    dds::topic::Topic<T> create_topic(
            const std::string& topic_name,
            const std::string& type_name, 
            const dds::topic::qos::TopicQos& topic_qos,
            dds::topic::TopicListener<T>* a_listener = NULL,
            const dds::core::status::StatusMask& mask =
            dds::core::status::StatusMask::all());

    template <typename T>
    dds::topic::Topic<T> create_topic(
            const std::string& topic_name,
            const std::string& type_name_name, 
            const std::string& qos_library_name,
            const std::string& qos_profile_name,
            dds::topic::TopicListener<T>* a_listener = NULL,
            const dds::core::status::StatusMask& mask =
            dds::core::status::StatusMask::all());
                                    

    const dds::topic::qos::TopicQos default_topic_qos() const;
    void default_topic_qos(const dds::topic::qos::TopicQos& topic_qos);
    void default_topic_qos(const std::string& qos_library_name,
                           const std::string& qos_profile_name);

    // --- ContentFilteredTopic Factory Methods: --- //
public:
#ifdef OMG_DDS_CONTENT_SUBSCRIPTION_SUPPORT
    template <typename T>
    dds::topic::ContentFilteredTopic<T> create_contentfilteredtopic(
        const std::string& name,
        const dds::topic::Topic<T>& related_topic,
        const std::string& filter_expression,
        const dds::core::StringSeq& expression_parameters);
#endif  // OMG_DDS_CONTENT_SUBSCRIPTION_SUPPORT

     // --- MultiTopic Factory Methods: --- //
public:
#ifdef OMG_DDS_CONTENT_SUBSCRIPTION_SUPPORT
    template <typename T>
    dds::topic::MultiTopic<T> create_multitopic(
        const std::string& name,
        const std::string& type_name, 
        const std::string& subscription_expression,
        const dds::core::StringSeq& expression_parameters);
#endif  // OMG_DDS_CONTENT_SUBSCRIPTION_SUPPORT
};

} } /* namespace tdds / namespace domain */

#endif /* OMG_TDDS_DOMAIN_DOMAIN_PARTICIPANT_HPP_ */