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 RTI Code Generator (rtiddsgen) version 4.3.0.
The rtiddsgen tool is part of the RTI Connext DDS distribution.
For more information, type 'rtiddsgen -help' at a command shell
or consult the Code Generator User's Manual.
*/
 
#ifndef Foo_982570024_hpp
#define Foo_982570024_hpp
 
#include <iosfwd>
 
#if (defined(RTI_WIN32) || defined (RTI_WINCE) || defined(RTI_INTIME)) && defined(NDDS_USER_DLL_EXPORT)
/* If the code is building on Windows, start exporting symbols.
*/
#undef RTIUSERDllExport
#define RTIUSERDllExport __declspec(dllexport)
#endif
 
#include "dds/core/SafeEnumeration.hpp"
#include "dds/core/String.hpp"
#include "dds/core/array.hpp"
#include "dds/core/vector.hpp"
#include "dds/core/External.hpp"
#include "rti/core/LongDouble.hpp"
#include "rti/core/Pointer.hpp"
#include "rti/core/array.hpp"
#include "rti/topic/TopicTraits.hpp"
 
#include "omg/types/string_view.hpp"
 
#include "rti/core/BoundedSequence.hpp"
#include "dds/core/Optional.hpp"
 
#ifndef NDDS_STANDALONE_TYPE
#include "dds/domain/DomainParticipant.hpp"
#include "dds/topic/TopicTraits.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/util/StreamFlagSaver.hpp"
#include "rti/domain/PluginSupport.hpp"
#endif
 
#if (defined(RTI_WIN32) || defined (RTI_WINCE) || defined(RTI_INTIME)) && 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(RTI_INTIME)) && 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_);
 
    int32_t& x() noexcept {
        return m_x_;
    }
 
    const int32_t& x() const noexcept {
        return m_x_;
    }
 
    void x(int32_t value) {
 
        m_x_ = value;
    }
 
    int32_t& y() noexcept {
        return m_y_;
    }
 
    const int32_t& y() const noexcept {
        return m_y_;
    }
 
    void y(int32_t value) {
 
        m_y_ = value;
    }
 
    bool operator == (const Foo& other_) const;
    bool operator != (const Foo& other_) const;
 
    void swap(Foo& other_) noexcept ;
 
  private:
 
    int32_t m_x_;
    int32_t m_y_;
 
};
 
inline void swap(Foo& a, Foo& b)  noexcept 
{
    a.swap(b);
}
 
NDDSUSERDllExport std::ostream& operator<<(std::ostream& o, const Foo& sample);
 
#if (defined(RTI_WIN32) || defined (RTI_WINCE)) && defined(NDDS_USER_DLL_EXPORT)
// On Windows, dll-export template instantiations of standard types used by
// other dll-exported types
template class NDDSUSERDllExport std::allocator< int32_t >;
template class NDDSUSERDllExport std::vector< int32_t >;
#endif
class NDDSUSERDllExport MyType {
  public:
 
    MyType();
 
    MyType(int32_t my_long_,const std::string& my_string_,const ::Foo& my_foo_,const ::rti::core::bounded_sequence< int32_t, 10L >& my_sequence_,const ::dds::core::array< ::Foo, 5L>& my_array_,const ::dds::core::optional< ::Foo >& my_optional_);
 
    int32_t& my_long() noexcept {
        return m_my_long_;
    }
 
    const int32_t& my_long() const noexcept {
        return m_my_long_;
    }
 
    void my_long(int32_t value) {
 
        m_my_long_ = value;
    }
 
    std::string& my_string() noexcept {
        return m_my_string_;
    }
 
    const std::string& my_string() const noexcept {
        return m_my_string_;
    }
 
    void my_string(const std::string& value) {
 
        m_my_string_ = value;
    }
 
    void my_string(std::string&& value) {
        m_my_string_ = std::move(value);
    }
    ::Foo& my_foo() noexcept {
        return m_my_foo_;
    }
 
    const ::Foo& my_foo() const noexcept {
        return m_my_foo_;
    }
 
    void my_foo(const ::Foo& value) {
 
        m_my_foo_ = value;
    }
 
    void my_foo(::Foo&& value) {
        m_my_foo_ = std::move(value);
    }
    ::rti::core::bounded_sequence< int32_t, 10L >& my_sequence() noexcept {
        return m_my_sequence_;
    }
 
    const ::rti::core::bounded_sequence< int32_t, 10L >& my_sequence() const noexcept {
        return m_my_sequence_;
    }
 
    void my_sequence(const ::rti::core::bounded_sequence< int32_t, 10L >& value) {
 
        m_my_sequence_ = value;
    }
 
    void my_sequence(::rti::core::bounded_sequence< int32_t, 10L >&& value) {
        m_my_sequence_ = std::move(value);
    }
    ::dds::core::array< ::Foo, 5L>& my_array() noexcept {
        return m_my_array_;
    }
 
    const ::dds::core::array< ::Foo, 5L>& my_array() const noexcept {
        return m_my_array_;
    }
 
    void my_array(const ::dds::core::array< ::Foo, 5L>& value) {
 
        m_my_array_ = value;
    }
 
    void my_array(::dds::core::array< ::Foo, 5L>&& value) {
        m_my_array_ = std::move(value);
    }
    ::dds::core::optional< ::Foo >& my_optional() noexcept {
        return m_my_optional_;
    }
 
    const ::dds::core::optional< ::Foo >& my_optional() const noexcept {
        return m_my_optional_;
    }
 
    void my_optional(const ::dds::core::optional< ::Foo >& value) {
 
        m_my_optional_ = value;
    }
 
    void my_optional(::dds::core::optional< ::Foo >&& value) {
        m_my_optional_ = std::move(value);
    }
    bool operator == (const MyType& other_) const;
    bool operator != (const MyType& other_) const;
 
    void swap(MyType& other_) noexcept ;
 
  private:
 
    int32_t m_my_long_;
    std::string m_my_string_;
    ::Foo m_my_foo_;
    ::rti::core::bounded_sequence< int32_t, 10L > m_my_sequence_;
    ::dds::core::array< ::Foo, 5L> m_my_array_;
    ::dds::core::optional< ::Foo > m_my_optional_;
 
};
 
inline void swap(MyType& a, MyType& b)  noexcept 
{
    a.swap(b);
}
 
NDDSUSERDllExport std::ostream& operator<<(std::ostream& o, const MyType& sample);
 
enum class Color {
    RED, 
    GREEN, 
    BLUE
};
 
NDDSUSERDllExport std::ostream& operator << (std::ostream& o,const Color& sample);
enum class MyUnionDiscriminator {
    USE_LONG, 
    USE_STRING, 
    USE_FOO
};
 
NDDSUSERDllExport std::ostream& operator << (std::ostream& o,const MyUnionDiscriminator& sample);
 
class NDDSUSERDllExport MyUnion {
  public:
 
    MyUnion();
 
    ::MyUnionDiscriminator& _d()  {
        return m_d_;
    }
 
    const ::MyUnionDiscriminator& _d() const  {
        return m_d_;
    }
 
    void _d(::MyUnionDiscriminator value) {
 
        m_d_ = value;
    }
 
    int32_t& my_long()  {
 
        if (_d() != (MyUnionDiscriminator::USE_LONG) ) {
 
            throw ::dds::core::PreconditionNotMetError(
                "::MyUnion::my_long not selected by the discriminator" );
        }
        return m_u_.m_my_long_;
    }
 
    const int32_t& my_long() const  {
 
        if (_d() != (MyUnionDiscriminator::USE_LONG) ) {
 
            throw ::dds::core::PreconditionNotMetError(
                "::MyUnion::my_long not selected by the discriminator" );
        }
        return m_u_.m_my_long_;
    }
 
    void my_long(int32_t value) {
        m_u_.m_my_long_ = value;
        m_d_= (MyUnionDiscriminator::USE_LONG);
    }
 
    std::string& my_string()  {
 
        if (_d() != (MyUnionDiscriminator::USE_STRING) ) {
 
            throw ::dds::core::PreconditionNotMetError(
                "::MyUnion::my_string not selected by the discriminator" );
        }
        return m_u_.m_my_string_;
    }
 
    const std::string& my_string() const  {
 
        if (_d() != (MyUnionDiscriminator::USE_STRING) ) {
 
            throw ::dds::core::PreconditionNotMetError(
                "::MyUnion::my_string not selected by the discriminator" );
        }
        return m_u_.m_my_string_;
    }
 
    void my_string(const std::string& value) {
        m_u_.m_my_string_ = value;
        m_d_= (MyUnionDiscriminator::USE_STRING);
    }
 
    void my_string(std::string&& value) {
        m_u_.m_my_string_ = std::move(value);
        m_d_= (MyUnionDiscriminator::USE_STRING);
    }
    ::Foo& my_foo()  {
 
        if (_d() != (MyUnionDiscriminator::USE_FOO) ) {
 
            throw ::dds::core::PreconditionNotMetError(
                "::MyUnion::my_foo not selected by the discriminator" );
        }
        return m_u_.m_my_foo_;
    }
 
    const ::Foo& my_foo() const  {
 
        if (_d() != (MyUnionDiscriminator::USE_FOO) ) {
 
            throw ::dds::core::PreconditionNotMetError(
                "::MyUnion::my_foo not selected by the discriminator" );
        }
        return m_u_.m_my_foo_;
    }
 
    void my_foo(const ::Foo& value) {
        m_u_.m_my_foo_ = value;
        m_d_= (MyUnionDiscriminator::USE_FOO);
    }
 
    void my_foo(::Foo&& value) {
        m_u_.m_my_foo_ = std::move(value);
        m_d_= (MyUnionDiscriminator::USE_FOO);
    }
    bool operator == (const MyUnion& other_) const;
    bool operator != (const MyUnion& other_) const;
    static ::MyUnionDiscriminator default_discriminator();
 
    void swap(MyUnion& other_) noexcept ;
 
  private:
 
    ::MyUnionDiscriminator m_d_;
    struct NDDSUSERDllExport Union_ {
        int32_t m_my_long_;
        std::string m_my_string_;
        ::Foo m_my_foo_;
        Union_();
        Union_(int32_t my_long_,const std::string& my_string_,const ::Foo& my_foo_);
    };
    Union_ m_u_;
 
};
 
inline void swap(MyUnion& a, MyUnion& b)  noexcept 
{
    a.swap(b);
}
 
NDDSUSERDllExport std::ostream& operator<<(std::ostream& o, const MyUnion& sample);
 
class NDDSUSERDllExport MyOtherType {
  public:
 
    MyOtherType();
 
    MyOtherType(int32_t m1_,double m2_,const std::string& m3_);
 
    int32_t& m1() noexcept {
        return m_m1_;
    }
 
    const int32_t& m1() const noexcept {
        return m_m1_;
    }
 
    void m1(int32_t value) {
 
        m_m1_ = value;
    }
 
    double& m2() noexcept {
        return m_m2_;
    }
 
    const double& m2() const noexcept {
        return m_m2_;
    }
 
    void m2(double value) {
 
        m_m2_ = value;
    }
 
    std::string& m3() noexcept {
        return m_m3_;
    }
 
    const std::string& m3() const noexcept {
        return m_m3_;
    }
 
    void m3(const std::string& value) {
 
        m_m3_ = value;
    }
 
    void m3(std::string&& value) {
        m_m3_ = std::move(value);
    }
    bool operator == (const MyOtherType& other_) const;
    bool operator != (const MyOtherType& other_) const;
 
    void swap(MyOtherType& other_) noexcept ;
 
  private:
 
    int32_t m_m1_;
    double m_m2_;
    std::string m_m3_;
 
};
 
inline void swap(MyOtherType& a, MyOtherType& b)  noexcept 
{
    a.swap(b);
}
 
NDDSUSERDllExport std::ostream& operator<<(std::ostream& o, const MyOtherType& sample);
 
#ifdef NDDS_STANDALONE_TYPE
namespace rti { 
    namespace topic {
        template <>
        struct default_enumerator< ::Color>
        {
            static const ::Color value;
        };
        template <>
        struct default_enumerator< ::MyUnionDiscriminator>
        {
            static const ::MyUnionDiscriminator value;
        };
    }
}
#else
 
namespace rti {
    namespace flat {
        namespace topic {
        }
    }
}
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 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,
                ::dds::core::policy::DataRepresentationId representation 
                = ::dds::core::policy::DataRepresentation::auto_id());
 
            NDDSUSERDllExport 
            static void from_cdr_buffer(::Foo& sample, const std::vector<char>& buffer);
            NDDSUSERDllExport 
            static void reset_sample(::Foo& sample);
 
            NDDSUSERDllExport 
            static void allocate_sample(::Foo& sample, int, int);
 
            static const ::rti::topic::TypePluginKind::type type_plugin_kind = 
            ::rti::topic::TypePluginKind::STL;
        };
        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 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,
                ::dds::core::policy::DataRepresentationId representation 
                = ::dds::core::policy::DataRepresentation::auto_id());
 
            NDDSUSERDllExport 
            static void from_cdr_buffer(::MyType& sample, const std::vector<char>& buffer);
            NDDSUSERDllExport 
            static void reset_sample(::MyType& sample);
 
            NDDSUSERDllExport 
            static void allocate_sample(::MyType& sample, int, int);
 
            static const ::rti::topic::TypePluginKind::type type_plugin_kind = 
            ::rti::topic::TypePluginKind::STL;
        };
        template<>
        struct topic_type_name< ::MyUnion > {
            NDDSUSERDllExport static std::string value() {
                return "MyUnion";
            }
        };
 
        template<>
        struct is_topic_type< ::MyUnion > : public ::dds::core::true_type {};
 
        template<>
        struct topic_type_support< ::MyUnion > {
            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 ::MyUnion& sample,
                ::dds::core::policy::DataRepresentationId representation 
                = ::dds::core::policy::DataRepresentation::auto_id());
 
            NDDSUSERDllExport 
            static void from_cdr_buffer(::MyUnion& sample, const std::vector<char>& buffer);
            NDDSUSERDllExport 
            static void reset_sample(::MyUnion& sample);
 
            NDDSUSERDllExport 
            static void allocate_sample(::MyUnion& sample, int, int);
 
            static const ::rti::topic::TypePluginKind::type type_plugin_kind = 
            ::rti::topic::TypePluginKind::STL;
        };
        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 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,
                ::dds::core::policy::DataRepresentationId representation 
                = ::dds::core::policy::DataRepresentation::auto_id());
 
            NDDSUSERDllExport 
            static void from_cdr_buffer(::MyOtherType& sample, const std::vector<char>& buffer);
            NDDSUSERDllExport 
            static void reset_sample(::MyOtherType& sample);
 
            NDDSUSERDllExport 
            static void allocate_sample(::MyOtherType& sample, int, int);
 
            static const ::rti::topic::TypePluginKind::type type_plugin_kind = 
            ::rti::topic::TypePluginKind::STL;
        };
    }
}
 
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 extensibility< ::Foo > {
            static const ::dds::core::xtypes::ExtensibilityKind::type kind =
            ::dds::core::xtypes::ExtensibilityKind::EXTENSIBLE;    };
 
        template<>
        struct dynamic_type< ::MyType > {
            typedef ::dds::core::xtypes::StructType type;
            NDDSUSERDllExport static const ::dds::core::xtypes::StructType& get();
        };
 
        template <>
        struct extensibility< ::MyType > {
            static const ::dds::core::xtypes::ExtensibilityKind::type kind =
            ::dds::core::xtypes::ExtensibilityKind::EXTENSIBLE;    };
 
        template <>
        struct default_enumerator< ::Color>
        {
            static const ::Color value;
        };
        template<>
        struct dynamic_type< ::Color > {
            typedef ::dds::core::xtypes::EnumType type;
            NDDSUSERDllExport static const ::dds::core::xtypes::EnumType& get();
        };
 
        template <>
        struct extensibility< ::Color > {
            static const ::dds::core::xtypes::ExtensibilityKind::type kind =
            ::dds::core::xtypes::ExtensibilityKind::EXTENSIBLE;    };
 
        template <>
        struct default_enumerator< ::MyUnionDiscriminator>
        {
            static const ::MyUnionDiscriminator value;
        };
        template<>
        struct dynamic_type< ::MyUnionDiscriminator > {
            typedef ::dds::core::xtypes::EnumType type;
            NDDSUSERDllExport static const ::dds::core::xtypes::EnumType& get();
        };
 
        template <>
        struct extensibility< ::MyUnionDiscriminator > {
            static const ::dds::core::xtypes::ExtensibilityKind::type kind =
            ::dds::core::xtypes::ExtensibilityKind::EXTENSIBLE;    };
 
        template<>
        struct dynamic_type< ::MyUnion > {
            typedef ::dds::core::xtypes::UnionType type;
            NDDSUSERDllExport static const ::dds::core::xtypes::UnionType& get();
        };
 
        template <>
        struct extensibility< ::MyUnion > {
            static const ::dds::core::xtypes::ExtensibilityKind::type kind =
            ::dds::core::xtypes::ExtensibilityKind::EXTENSIBLE;    };
 
        template<>
        struct dynamic_type< ::MyOtherType > {
            typedef ::dds::core::xtypes::StructType type;
            NDDSUSERDllExport static const ::dds::core::xtypes::StructType& get();
        };
 
        template <>
        struct extensibility< ::MyOtherType > {
            static const ::dds::core::xtypes::ExtensibilityKind::type kind =
            ::dds::core::xtypes::ExtensibilityKind::EXTENSIBLE;    };
 
    }
}
 
#endif // NDDS_STANDALONE_TYPE
#if (defined(RTI_WIN32) || defined (RTI_WINCE) || defined(RTI_INTIME)) && defined(NDDS_USER_DLL_EXPORT)
/* If the code is building on Windows, stop exporting symbols.
*/
#undef NDDSUSERDllExport
#define NDDSUSERDllExport
#endif
 
#endif // Foo_982570024_hpp