Foo.hpp

The definition of the C++ types create from Foo.idl

See Also

Working with IDL types

/*
WARNING: THIS FILE IS AUTO-GENERATED. DO NOT MODIFY.

This file was generated from Foo.idl using "rtiddsgen".
The rtiddsgen tool is part of the RTI Connext distribution.
For more information, type 'rtiddsgen -help' at a command shell
or consult the RTI Connext manual.
*/

#ifndef Foo_982569687_hpp
#define Foo_982569687_hpp

#include <iosfwd>
#include "FooImpl.h"

#if (defined(RTI_WIN32) || defined (RTI_WINCE)) && defined(NDDS_USER_DLL_EXPORT)
/* If the code is building on Windows, start exporting symbols.
*/
#undef RTIUSERDllExport
#define RTIUSERDllExport __declspec(dllexport)
#endif

#include "dds/domain/DomainParticipant.hpp"
#include "dds/topic/TopicTraits.hpp"
#include "dds/core/SafeEnumeration.hpp"
#include "dds/core/String.hpp"
#include "dds/core/array.hpp"
#include "dds/core/vector.hpp"
#include "dds/core/Optional.hpp"
#include "dds/core/xtypes/DynamicType.hpp"
#include "dds/core/xtypes/StructType.hpp"
#include "dds/core/xtypes/UnionType.hpp"
#include "dds/core/xtypes/EnumType.hpp"
#include "dds/core/xtypes/AliasType.hpp"
#include "rti/core/array.hpp"
#include "rti/util/StreamFlagSaver.hpp"
#include "rti/domain/PluginSupport.hpp"
#include "rti/core/LongDouble.hpp"
#include "rti/core/Pointer.hpp"
#include "rti/topic/TopicTraits.hpp"
#if (defined(RTI_WIN32) || defined (RTI_WINCE)) && defined(NDDS_USER_DLL_EXPORT)
/* If the code is building on Windows, stop exporting symbols.
*/
#undef RTIUSERDllExport
#define RTIUSERDllExport
#endif

#if (defined(RTI_WIN32) || defined (RTI_WINCE)) && defined(NDDS_USER_DLL_EXPORT)
/* If the code is building on Windows, start exporting symbols.
*/
#undef NDDSUSERDllExport
#define NDDSUSERDllExport __declspec(dllexport)
#endif

class NDDSUSERDllExport Foo {

  public:
    Foo();
    Foo(
        int32_t x,
        int32_t y);

    #ifdef RTI_CXX11_RVALUE_REFERENCES
    #ifndef RTI_CXX11_NO_IMPLICIT_MOVE_OPERATIONS
    Foo (Foo&& other_) = default;
    Foo& operator=(Foo&&  other_) = default;
    Foo& operator=(const Foo&) = default;
    Foo(const Foo&) = default;
    #else
    Foo(Foo&& other_) OMG_NOEXCEPT;  
    Foo& operator=(Foo&&  other_) OMG_NOEXCEPT;
    #endif
    #endif 

    int32_t x() const OMG_NOEXCEPT;
    void x(int32_t value);

    int32_t y() const OMG_NOEXCEPT;
    void y(int32_t value);

    bool operator == (const Foo& other_) const;
    bool operator != (const Foo& other_) const;

    void swap(Foo& other_) OMG_NOEXCEPT ;

  private:

    int32_t m_x_;
    int32_t m_y_;

};

inline void swap(Foo& a, Foo& b)  OMG_NOEXCEPT 
{
    a.swap(b);
}

NDDSUSERDllExport std::ostream& operator << (std::ostream& o,const Foo& sample);

class NDDSUSERDllExport MyType {

  public:
    MyType();
    MyType(
        int32_t my_long,
        const dds::core::string& my_string,
        const Foo& my_foo,
        const dds::core::vector<int32_t>& my_sequence,
        const dds::core::array<Foo, 5>& my_array,
        const dds::core::optional<Foo>& my_optional);

    #ifdef RTI_CXX11_RVALUE_REFERENCES
    #ifndef RTI_CXX11_NO_IMPLICIT_MOVE_OPERATIONS
    MyType (MyType&& other_) = default;
    MyType& operator=(MyType&&  other_) = default;
    MyType& operator=(const MyType&) = default;
    MyType(const MyType&) = default;
    #else
    MyType(MyType&& other_) OMG_NOEXCEPT;  
    MyType& operator=(MyType&&  other_) OMG_NOEXCEPT;
    #endif
    #endif 

    int32_t my_long() const OMG_NOEXCEPT;
    void my_long(int32_t value);

    dds::core::string& my_string() OMG_NOEXCEPT; 
    const dds::core::string& my_string() const OMG_NOEXCEPT;
    void my_string(const dds::core::string& value);

    Foo& my_foo() OMG_NOEXCEPT; 
    const Foo& my_foo() const OMG_NOEXCEPT;
    void my_foo(const Foo& value);

    dds::core::vector<int32_t>& my_sequence() OMG_NOEXCEPT; 
    const dds::core::vector<int32_t>& my_sequence() const OMG_NOEXCEPT;
    void my_sequence(const dds::core::vector<int32_t>& value);

    dds::core::array<Foo, 5>& my_array() OMG_NOEXCEPT; 
    const dds::core::array<Foo, 5>& my_array() const OMG_NOEXCEPT;
    void my_array(const dds::core::array<Foo, 5>& value);

    dds::core::optional<Foo>& my_optional() OMG_NOEXCEPT; 
    const dds::core::optional<Foo>& my_optional() const OMG_NOEXCEPT;
    void my_optional(const dds::core::optional<Foo>& value);

    bool operator == (const MyType& other_) const;
    bool operator != (const MyType& other_) const;

    void swap(MyType& other_) OMG_NOEXCEPT ;

  private:

    int32_t m_my_long_;
    dds::core::string m_my_string_;
    Foo m_my_foo_;
    dds::core::vector<int32_t> m_my_sequence_;
    dds::core::array<Foo, 5> m_my_array_;
    dds::core::optional<Foo> m_my_optional_;

};

inline void swap(MyType& a, MyType& b)  OMG_NOEXCEPT 
{
    a.swap(b);
}

NDDSUSERDllExport std::ostream& operator << (std::ostream& o,const MyType& sample);

class NDDSUSERDllExport MyOtherType {

  public:
    MyOtherType();
    MyOtherType(
        int32_t m1,
        double m2,
        const dds::core::string& m3);

    #ifdef RTI_CXX11_RVALUE_REFERENCES
    #ifndef RTI_CXX11_NO_IMPLICIT_MOVE_OPERATIONS
    MyOtherType (MyOtherType&& other_) = default;
    MyOtherType& operator=(MyOtherType&&  other_) = default;
    MyOtherType& operator=(const MyOtherType&) = default;
    MyOtherType(const MyOtherType&) = default;
    #else
    MyOtherType(MyOtherType&& other_) OMG_NOEXCEPT;  
    MyOtherType& operator=(MyOtherType&&  other_) OMG_NOEXCEPT;
    #endif
    #endif 

    int32_t m1() const OMG_NOEXCEPT;
    void m1(int32_t value);

    double m2() const OMG_NOEXCEPT;
    void m2(double value);

    dds::core::string& m3() OMG_NOEXCEPT; 
    const dds::core::string& m3() const OMG_NOEXCEPT;
    void m3(const dds::core::string& value);

    bool operator == (const MyOtherType& other_) const;
    bool operator != (const MyOtherType& other_) const;

    void swap(MyOtherType& other_) OMG_NOEXCEPT ;

  private:

    int32_t m_m1_;
    double m_m2_;
    dds::core::string m_m3_;

};

inline void swap(MyOtherType& a, MyOtherType& b)  OMG_NOEXCEPT 
{
    a.swap(b);
}

NDDSUSERDllExport std::ostream& operator << (std::ostream& o,const MyOtherType& sample);

namespace dds { 
    namespace topic {

        template<>
        struct topic_type_name<Foo> {
            NDDSUSERDllExport static std::string value() {
                return "Foo";
            }
        };

        template<>
        struct is_topic_type<Foo> : public dds::core::true_type {};

        template<>
        struct topic_type_support<Foo> {

            NDDSUSERDllExport static void initialize_sample(Foo& sample);

            NDDSUSERDllExport static void register_type(
                dds::domain::DomainParticipant& participant,
                const std::string & type_name);

            NDDSUSERDllExport static std::vector<char>& to_cdr_buffer(
                std::vector<char>& buffer, const Foo& sample);

            NDDSUSERDllExport static void from_cdr_buffer(Foo& sample, const std::vector<char>& buffer);
        };

        template<>
        struct topic_type_name<MyType> {
            NDDSUSERDllExport static std::string value() {
                return "MyType";
            }
        };

        template<>
        struct is_topic_type<MyType> : public dds::core::true_type {};

        template<>
        struct topic_type_support<MyType> {

            NDDSUSERDllExport static void initialize_sample(MyType& sample);

            NDDSUSERDllExport static void register_type(
                dds::domain::DomainParticipant& participant,
                const std::string & type_name);

            NDDSUSERDllExport static std::vector<char>& to_cdr_buffer(
                std::vector<char>& buffer, const MyType& sample);

            NDDSUSERDllExport static void from_cdr_buffer(MyType& sample, const std::vector<char>& buffer);
        };

        template<>
        struct topic_type_name<MyOtherType> {
            NDDSUSERDllExport static std::string value() {
                return "MyOtherType";
            }
        };

        template<>
        struct is_topic_type<MyOtherType> : public dds::core::true_type {};

        template<>
        struct topic_type_support<MyOtherType> {

            NDDSUSERDllExport static void initialize_sample(MyOtherType& sample);

            NDDSUSERDllExport static void register_type(
                dds::domain::DomainParticipant& participant,
                const std::string & type_name);

            NDDSUSERDllExport static std::vector<char>& to_cdr_buffer(
                std::vector<char>& buffer, const MyOtherType& sample);

            NDDSUSERDllExport static void from_cdr_buffer(MyOtherType& sample, const std::vector<char>& buffer);
        };

    }
}

namespace rti { 
    namespace topic {
        template<>
        struct dynamic_type<Foo> {
            typedef dds::core::xtypes::StructType type;
            NDDSUSERDllExport static const dds::core::xtypes::StructType& get();
        };

        template<>
        struct impl_type<Foo> {
            typedef Foo_c type;
        };

        template<>
        struct dynamic_type<MyType> {
            typedef dds::core::xtypes::StructType type;
            NDDSUSERDllExport static const dds::core::xtypes::StructType& get();
        };

        template<>
        struct impl_type<MyType> {
            typedef MyType_c type;
        };

        template<>
        struct dynamic_type<MyOtherType> {
            typedef dds::core::xtypes::StructType type;
            NDDSUSERDllExport static const dds::core::xtypes::StructType& get();
        };

        template<>
        struct impl_type<MyOtherType> {
            typedef MyOtherType_c type;
        };

    }
}

#if (defined(RTI_WIN32) || defined (RTI_WINCE)) && defined(NDDS_USER_DLL_EXPORT)
/* If the code is building on Windows, stop exporting symbols.
*/
#undef NDDSUSERDllExport
#define NDDSUSERDllExport
#endif

#endif // Foo_982569687_hpp