Feature/dynamic types

examples/C++/Benchmark/DynamicTypesHelper.h

@@ -0,0 +1,65 @@
+// Copyright 2016 Proyectos y Sistemas de Mantenimiento SL (eProsima).
+//
+// 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.
+
+/**
+ * @file BenchMarkPublisher.h
+ *
+ */
+
+#ifndef DYNAMIC_TYPES_HELPER_H_
+#define DYNAMIC_TYPES_HELPER_H_
+
+#include <fastrtps/fastrtps_fwd.h>
+
+namespace eprosima
+{
+    namespace fastrtps
+    {
+        namespace types
+        {
+            class DynamicData;
+            class DynamicType_ptr;
+        }
+    }
+}
+
+class DynamicTypesHelper
+{
+public:
+    static eprosima::fastrtps::types::DynamicData* CreateSmallData();
+    static eprosima::fastrtps::types::DynamicData* CreateData();
+    static eprosima::fastrtps::types::DynamicData* CreateMediumData();
+    static eprosima::fastrtps::types::DynamicData* CreateBigData();
+protected:
+
+    static eprosima::fastrtps::types::DynamicType_ptr GetMyMiniArrayType();
+    static eprosima::fastrtps::types::DynamicType_ptr GetBSAlias5Type();
+    static eprosima::fastrtps::types::DynamicType_ptr GetBasicStructType();
+    static eprosima::fastrtps::types::DynamicType_ptr GetMyOctetArray500Type();
+    static eprosima::fastrtps::types::DynamicType_ptr GetMySequenceLongType();
+    static eprosima::fastrtps::types::DynamicType_ptr GetMyEnumType();
+    static eprosima::fastrtps::types::DynamicType_ptr GetMyAliasEnumType();
+    static eprosima::fastrtps::types::DynamicType_ptr GetMA3Type();
+    static eprosima::fastrtps::types::DynamicType_ptr GetMyAliasEnum3Type();
+    static eprosima::fastrtps::types::DynamicType_ptr GetMyAliasEnum2Type();
+    static eprosima::fastrtps::types::DynamicType_ptr GetUnionSwitchType();
+    static eprosima::fastrtps::types::DynamicType_ptr GetUnion2SwitchType();
+    static eprosima::fastrtps::types::DynamicType_ptr GetComplexStructType();
+
+
+};
+
+
+
+#endif /* DYNAMIC_TYPES_HELPER_H_ */

examples/C++/DynamicHelloWorldExample/CMakeLists.txt

@@ -0,0 +1,51 @@
+# Copyright 2016 Proyectos y Sistemas de Mantenimiento SL (eProsima).
+#
+# 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.
+
+cmake_minimum_required(VERSION 2.8.12)
+
+if(NOT CMAKE_VERSION VERSION_LESS 3.0)
+    cmake_policy(SET CMP0048 NEW)
+endif()
+
+project(DynamicHelloWorldExample)
+
+# Find requirements
+if(NOT fastcdr_FOUND)
+    find_package(fastcdr REQUIRED)
+endif()
+
+if(NOT fastrtps_FOUND)
+    find_package(fastrtps REQUIRED)
+endif()
+
+# Set C++11
+include(CheckCXXCompilerFlag)
+if(CMAKE_COMPILER_IS_GNUCXX OR CMAKE_COMPILER_IS_CLANG OR
+        CMAKE_CXX_COMPILER_ID MATCHES "Clang")
+    check_cxx_compiler_flag(-std=c++11 SUPPORTS_CXX11)
+    if(SUPPORTS_CXX11)
+        add_compile_options(-std=c++11)
+    else()
+        message(FATAL_ERROR "Compiler doesn't support C++11")
+    endif()
+endif()
+
+message(STATUS "Configuring HelloWorld example...")
+file(GLOB HELLOWORLD_EXAMPLE_SOURCES_CXX "*.cxx")
+file(GLOB HELLOWORLD_EXAMPLE_SOURCES_CPP "*.cpp")
+
+add_executable(DynamicHelloWorldExample ${HELLOWORLD_EXAMPLE_SOURCES_CXX} ${HELLOWORLD_EXAMPLE_SOURCES_CPP})
+target_link_libraries(DynamicHelloWorldExample fastrtps fastcdr)
+install(TARGETS DynamicHelloWorldExample
+    RUNTIME DESTINATION examples/C++/DynamicHelloWorldExample/${BIN_INSTALL_DIR})

examples/C++/DynamicHelloWorldExample/HelloWorld.idl

@@ -0,0 +1,5 @@
+struct HelloWorld
+{
+	unsigned long index;
+	string message;
+};

examples/C++/DynamicHelloWorldExample/HelloWorldPublisher.cpp

@@ -0,0 +1,173 @@
+// Copyright 2016 Proyectos y Sistemas de Mantenimiento SL (eProsima).
+//
+// 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.
+
+/**
+ * @file HelloWorldPublisher.cpp
+ *
+ */
+
+#include "HelloWorldPublisher.h"
+#include <fastrtps/attributes/ParticipantAttributes.h>
+#include <fastrtps/attributes/PublisherAttributes.h>
+#include <fastrtps/publisher/Publisher.h>
+#include <fastrtps/Domain.h>
+#include <fastrtps/utils/eClock.h>
+#include <fastrtps/types/DynamicTypeBuilderFactory.h>
+#include <fastrtps/types/DynamicDataFactory.h>
+#include <fastrtps/types/DynamicTypeBuilder.h>
+#include <fastrtps/types/DynamicTypeBuilderPtr.h>
+#include <fastrtps/types/TypeDescriptor.h>
+#include <fastrtps/types/MemberDescriptor.h>
+#include <fastrtps/types/DynamicType.h>
+
+using namespace eprosima::fastrtps;
+using namespace eprosima::fastrtps::rtps;
+
+HelloWorldPublisher::HelloWorldPublisher()
+    : mp_participant(nullptr)
+    , mp_publisher(nullptr)
+    , m_DynType(nullptr)
+{
+}
+
+bool HelloWorldPublisher::init()
+{
+    // Create basic builders
+    DynamicTypeBuilder_ptr struct_type_builder(DynamicTypeBuilderFactory::GetInstance()->CreateStructBuilder());
+
+    // Add members to the struct.
+    struct_type_builder->AddMember(0, "index", DynamicTypeBuilderFactory::GetInstance()->CreateUint32Type());
+    struct_type_builder->AddMember(1, "message", DynamicTypeBuilderFactory::GetInstance()->CreateStringType());
+    struct_type_builder->SetName("HelloWorld");
+
+    DynamicType_ptr dynType = struct_type_builder->Build();
+    m_DynType.SetDynamicType(dynType);
+    m_DynHello = DynamicDataFactory::GetInstance()->CreateData(dynType);
+    m_DynHello->SetUint32Value(0, 0);
+    m_DynHello->SetStringValue("HelloWorld", 1);
+
+    ParticipantAttributes PParam;
+    PParam.rtps.builtin.domainId = 0;
+    PParam.rtps.setName("DynHelloWorld_pub");
+    mp_participant = Domain::createParticipant(PParam, (ParticipantListener*)&m_part_list);
+
+    if(mp_participant==nullptr)
+        return false;
+
+    //REGISTER THE TYPE
+    Domain::registerDynamicType(mp_participant, &m_DynType);
+
+    //CREATE THE PUBLISHER
+    PublisherAttributes Wparam;
+    Wparam.topic.topicKind = NO_KEY;
+    Wparam.topic.topicDataType = "HelloWorld";
+    Wparam.topic.topicName = "HelloWorldTopic";
+    //Wparam.topic.topicDiscoveryKind = NO_CHECK;  // Do it compatible with other HelloWorlds
+    mp_publisher = Domain::createPublisher(mp_participant,Wparam,(PublisherListener*)&m_listener);
+    if(mp_publisher == nullptr)
+        return false;
+
+    return true;
+
+}
+
+HelloWorldPublisher::~HelloWorldPublisher()
+{
+    Domain::removeParticipant(mp_participant);
+
+    DynamicDataFactory::GetInstance()->DeleteData(m_DynHello);
+
+    Domain::stopAll();
+}
+
+void HelloWorldPublisher::PubListener::onPublicationMatched(Publisher* /*pub*/,MatchingInfo& info)
+{
+    if(info.status == MATCHED_MATCHING)
+    {
+        n_matched++;
+        firstConnected = true;
+        std::cout << "Publisher matched"<<std::endl;
+    }
+    else
+    {
+        n_matched--;
+        std::cout << "Publisher unmatched"<<std::endl;
+    }
+}
+
+void HelloWorldPublisher::PartListener::onParticipantDiscovery(Participant*, ParticipantDiscoveryInfo info)
+{
+    if (info.rtps.m_status == DISCOVERED_RTPSPARTICIPANT)
+    {
+        std::cout << "Participant " << info.rtps.m_RTPSParticipantName << " discovered" << std::endl;
+    }
+    else if (info.rtps.m_status == REMOVED_RTPSPARTICIPANT)
+    {
+        std::cout << "Participant removed" << std::endl;
+    }
+    else if (info.rtps.m_status == DROPPED_RTPSPARTICIPANT)
+    {
+        std::cout << "Participant " << info.rtps.m_RTPSParticipantName << " dropped" << std::endl;
+    }
+}
+
+void HelloWorldPublisher::runThread(uint32_t samples, uint32_t sleep)
+{
+    uint32_t i = 0;
+
+    while(!stop && (i < samples || samples == 0))
+    {
+        if(publish(samples != 0))
+        {
+            std::string message;
+            m_DynHello->GetStringValue(message, 1);
+            uint32_t index;
+            m_DynHello->GetUint32Value(index, 0);
+
+            std::cout << "Message: " << message << " with index: " << index << " SENT" << std::endl;
+            ++i;
+        }
+        eClock::my_sleep(sleep);
+    }
+}
+
+void HelloWorldPublisher::run(uint32_t samples, uint32_t sleep)
+{
+    stop = false;
+    std::thread thread(&HelloWorldPublisher::runThread, this, samples, sleep);
+    if (samples == 0)
+    {
+        std::cout << "Publisher running. Please press enter to stop the Publisher at any time." << std::endl;
+        std::cin.ignore();
+        stop = true;
+    }
+    else
+    {
+        std::cout << "Publisher running " << samples << " samples." << std::endl;
+    }
+    thread.join();
+}
+
+bool HelloWorldPublisher::publish(bool waitForListener)
+{
+    if(m_listener.firstConnected || !waitForListener || m_listener.n_matched>0)
+    {
+        uint32_t index;
+        m_DynHello->GetUint32Value(index, 0);
+        m_DynHello->SetUint32Value(index+1, 0);
+        mp_publisher->write((void*)m_DynHello);
+        return true;
+    }
+    return false;
+}

examples/C++/DynamicHelloWorldExample/HelloWorldPublisher.h

@@ -0,0 +1,69 @@
+// Copyright 2016 Proyectos y Sistemas de Mantenimiento SL (eProsima).
+//
+// 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.
+
+/**
+ * @file HelloWorldPublisher.h
+ *
+ */
+
+#ifndef HELLOWORLDPUBLISHER_H_
+#define HELLOWORLDPUBLISHER_H_
+
+#include <fastrtps/fastrtps_fwd.h>
+#include <fastrtps/attributes/PublisherAttributes.h>
+#include <fastrtps/publisher/PublisherListener.h>
+#include <fastrtps/participant/ParticipantListener.h>
+#include <fastrtps/participant/Participant.h>
+#include <fastrtps/types/DynamicData.h>
+#include <fastrtps/types/DynamicPubSubType.h>
+
+
+class HelloWorldPublisher {
+public:
+	HelloWorldPublisher();
+	virtual ~HelloWorldPublisher();
+	//!Initialize
+	bool init();
+	//!Publish a sample
+	bool publish(bool waitForListener = true);
+	//!Run for number samples
+	void run(uint32_t number, uint32_t sleep);
+private:
+	eprosima::fastrtps::Participant* mp_participant;
+	eprosima::fastrtps::Publisher* mp_publisher;
+	bool stop;
+	class PubListener:public eprosima::fastrtps::PublisherListener
+	{
+	public:
+		PubListener():n_matched(0),firstConnected(false){};
+		~PubListener(){};
+		void onPublicationMatched(eprosima::fastrtps::Publisher* pub, eprosima::fastrtps::rtps::MatchingInfo& info);
+		int n_matched;
+        bool firstConnected;
+	}m_listener;
+	class PartListener : public eprosima::fastrtps::ParticipantListener
+	{
+		void onParticipantDiscovery(eprosima::fastrtps::Participant* p,
+			eprosima::fastrtps::ParticipantDiscoveryInfo info) override;
+	}m_part_list;
+	void runThread(uint32_t number, uint32_t sleep);
+
+	// Dynamic Types
+	eprosima::fastrtps::types::DynamicData* m_DynHello;
+	eprosima::fastrtps::types::DynamicPubSubType m_DynType;
+};
+
+
+
+#endif /* HELLOWORLDPUBLISHER_H_ */