Network burst on multiple participants, partitions and computers

[erezdamari-bagira]

Hi,

in our system we use CycloneDDS implementation, commit hash - 16928eb.

Above the cyclone implementation we have our own cpp layer and above this we C# layer
In the system we ENV with around 100 computers and ~500 processes that uses DDS.

during the system run we create 20 partition - each partition has a round 20-25 processes
we experiencing the following issues:

1. on system star - we have some application that responsible to launch all applications and have watchdog on them to restart them if they crush - when we start all our applications we have a huge network burst on all out applications of around 50-100 MB/s
2. then on every time we create a new partition (notifying the relevant applications to subscribe to a specific partition - nothing was happening on this partition before), we have the same burst of network
3. after we have 15-16 partitions, the network use stays high - around ~50MB/s and even more on every app that uses DDS
4. after we new partition we load a scenario on the system - basically start using the system and sending DDS samples - in one of the application, the memory use keep rising up and up - in some cases it riches to 45 GB - sometimes it stays steady on 1-2 GB of RAM

we tried changing the domain id, we made sure we dispose Readers and Writers on partition change

this is our cyclonedds.xml

default 65500B 500kB severe config cyclonedds.log

	    <Partitioning>
  <NetworkPartitions>
    <!-- Empty DCPS partition stays on Cyclone's default multicast -->
    <NetworkPartition name="ex_empty" Address="239.255.0.1"/>

    <!-- One multicast group per exercise partition, starting at 239.255.0.2 -->
    <NetworkPartition name="ex1"  Address="239.255.0.2"/>
    <NetworkPartition name="ex2"  Address="239.255.0.3"/>
    <NetworkPartition name="ex3"  Address="239.255.0.4"/>
    <NetworkPartition name="ex4"  Address="239.255.0.5"/>
    <NetworkPartition name="ex5"  Address="239.255.0.6"/>
    <NetworkPartition name="ex6"  Address="239.255.0.7"/>
    <NetworkPartition name="ex7"  Address="239.255.0.8"/>
    <NetworkPartition name="ex8"  Address="239.255.0.9"/>
    <NetworkPartition name="ex9"  Address="239.255.0.10"/>
    <NetworkPartition name="ex10" Address="239.255.0.11"/>
    <NetworkPartition name="ex11" Address="239.255.0.12"/>
    <NetworkPartition name="ex12" Address="239.255.0.13"/>
    <NetworkPartition name="ex13" Address="239.255.0.14"/>
    <NetworkPartition name="ex14" Address="239.255.0.15"/>
    <NetworkPartition name="ex15" Address="239.255.0.16"/>
    <NetworkPartition name="ex16" Address="239.255.0.17"/>
    <NetworkPartition name="ex17" Address="239.255.0.18"/>
    <NetworkPartition name="ex18" Address="239.255.0.19"/>
    <NetworkPartition name="ex19" Address="239.255.0.20"/>
    <NetworkPartition name="ex20" Address="239.255.0.21"/>
    <NetworkPartition name="ex21" Address="239.255.0.22"/>
    <NetworkPartition name="ex22" Address="239.255.0.23"/>
    <NetworkPartition name="ex23" Address="239.255.0.24"/>
    <NetworkPartition name="ex24" Address="239.255.0.25"/>
    <NetworkPartition name="ex25" Address="239.255.0.26"/>
  </NetworkPartitions>

  <PartitionMappings>
    <!-- Specific partitions 1..25 -->
    <PartitionMapping DCPSPartitionTopic="1.*"  NetworkPartition="ex1"/>
    <PartitionMapping DCPSPartitionTopic="2.*"  NetworkPartition="ex2"/>
    <PartitionMapping DCPSPartitionTopic="3.*"  NetworkPartition="ex3"/>
    <PartitionMapping DCPSPartitionTopic="4.*"  NetworkPartition="ex4"/>
    <PartitionMapping DCPSPartitionTopic="5.*"  NetworkPartition="ex5"/>
    <PartitionMapping DCPSPartitionTopic="6.*"  NetworkPartition="ex6"/>
    <PartitionMapping DCPSPartitionTopic="7.*"  NetworkPartition="ex7"/>
    <PartitionMapping DCPSPartitionTopic="8.*"  NetworkPartition="ex8"/>
    <PartitionMapping DCPSPartitionTopic="9.*"  NetworkPartition="ex9"/>
    <PartitionMapping DCPSPartitionTopic="10.*" NetworkPartition="ex10"/>
    <PartitionMapping DCPSPartitionTopic="11.*" NetworkPartition="ex11"/>
    <PartitionMapping DCPSPartitionTopic="12.*" NetworkPartition="ex12"/>
    <PartitionMapping DCPSPartitionTopic="13.*" NetworkPartition="ex13"/>
    <PartitionMapping DCPSPartitionTopic="14.*" NetworkPartition="ex14"/>
    <PartitionMapping DCPSPartitionTopic="15.*" NetworkPartition="ex15"/>
    <PartitionMapping DCPSPartitionTopic="16.*" NetworkPartition="ex16"/>
    <PartitionMapping DCPSPartitionTopic="17.*" NetworkPartition="ex17"/>
    <PartitionMapping DCPSPartitionTopic="18.*" NetworkPartition="ex18"/>
    <PartitionMapping DCPSPartitionTopic="19.*" NetworkPartition="ex19"/>
    <PartitionMapping DCPSPartitionTopic="20.*" NetworkPartition="ex20"/>
    <PartitionMapping DCPSPartitionTopic="21.*" NetworkPartition="ex21"/>
    <PartitionMapping DCPSPartitionTopic="22.*" NetworkPartition="ex22"/>
    <PartitionMapping DCPSPartitionTopic="23.*" NetworkPartition="ex23"/>
    <PartitionMapping DCPSPartitionTopic="24.*" NetworkPartition="ex24"/>
    <PartitionMapping DCPSPartitionTopic="25.*" NetworkPartition="ex25"/>

    <!-- Catch-all for EMPTY DCPS partition (must be last) -->
    <PartitionMapping DCPSPartitionTopic=".*" NetworkPartition="ex_empty"/>
  </PartitionMappings>
</Partitioning>
</Domain>

this is our TopicReade.cpp file

#include <stdio.h>
#include "TopicReader.h"
#include "DataListener.h"
#include <memory.h>
#include "dds/dds.h"
#include "DdsGuid.h"

namespace Dds::Base
{

TopicReader::TopicReader( Dds::Ptr<Participant> participant, TTopicSettings* topicSettings, DataListener* listener, const char* partitionName )
{
	//printf("TopicReader()\n");

	_topicSettings = topicSettings;
	_participant = participant;

	_topic = dds_create_topic( _participant->GetNativeHandle(), topicSettings->descriptor, topicSettings->name, NULL, NULL);
	if( _topic < 0 )
	    DDS_FATAL("dds_create_topic %s: %s\n", topicSettings->name, dds_strretcode(-_topic));

	dds_qos_t *qos = dds_create_qos ();
	dds_qset_reliability( qos, topicSettings->reliability.kind, topicSettings->reliability.blocking_time );
	dds_qset_durability( qos, topicSettings->durability.kind );
	dds_qset_history( qos, topicSettings->history.kind, topicSettings->history.depth );

	const char* finalPartitionName = partitionName;
	if( !finalPartitionName ) finalPartitionName = participant->GetDefaultPartitionName();
	if( finalPartitionName )
	{
		dds_qset_partition1( qos, finalPartitionName );
	}

	_reader = dds_create_reader( _participant->GetNativeHandle(), _topic, qos, NULL );
	if (_reader < 0)
		DDS_FATAL("dds_create_reader %s: %s\n", topicSettings->name, dds_strretcode(-_reader));

    dds_delete_qos(qos);

	SetListener( listener );
}

TopicReader::~TopicReader()
{
	// dispose writer
	// dispose topic...
	printf("~TopicReader()\n");
	
	// unregister potential listener
	dds_set_listener( _reader, NULL );

	// free the sample buffer
	free( _samples );

	// delete reader & topic handles
	if( _reader >= 0 )
	{
		auto rc = dds_delete( _reader );
		if (rc != DDS_RETCODE_OK)
			DDS_FATAL("dds_delete(reader) %s: %s\n", _topicSettings->name, dds_strretcode(-rc));
	}

	if( _topic >= 0 )
	{
		auto rc = dds_delete( _topic );
		if (rc != DDS_RETCODE_OK)
			DDS_FATAL("dds_delete(topic): %s %s\n", _topicSettings->name, dds_strretcode(-rc));
	}
}

void TopicReader::ReturnLoan()
{
	if( _numSamplesReturned == 0 )
		return;

	void* sample = _samples;
	for( int i=0; i < _numSamplesReturned; i++ )
	{
		dds_sample_free( sample, _topicSettings->descriptor, DDS_FREE_CONTENTS );

		sample = (void*)((uint8_t*)sample + _topicSettings->descriptor->m_size);
	}

	// zero the used part of the sample buffer to make it ready for next GetSamples()
	memset( _samples, 0, _numSamplesReturned * _topicSettings->descriptor->m_size );

	_numSamplesReturned = 0;
}

int TopicReader::ReserveSamples( int minCapacity )
{
	if( minCapacity > _samplesCapacity ) // the buffer only grows
	{
		void* newBuf = realloc( _samples, minCapacity * _topicSettings->descriptor->m_size );
		if( newBuf )
		{
			// zero the extra allocated memory to make it ready for the GetSamples()
			memset(
				(uint8_t*)newBuf + _samplesCapacity * _topicSettings->descriptor->m_size,
				0,
				(minCapacity - _samplesCapacity) * _topicSettings->descriptor->m_size
			);

			_samplesCapacity = minCapacity;
			_samples = newBuf;
		}
	}
	return _samplesCapacity;
}

dds_return_t TopicReader::GetSamples(
	EAction action,
    void** samples, // [out] preallocated array of sample pointers (contained pointers can be null, will be replaced with pointers to dds-allocated memory)
    dds_sample_info_t* sampleInfos, // [out] preallocated array of SampleInfo structures
    int maxSamples,
    dds_instance_handle_t instanceHandle,
    uint32_t sampleStateMask
	)
{
	// free previously taken samples (if any)
	// and zero the used part of the sample buffer (mandatory - dds_read/take expects it !)
	ReturnLoan();

	// limit the request to the available memory we can get
	maxSamples = std::min( maxSamples, ReserveSamples( maxSamples ) );

	if ( maxSamples <= 0 )
		return DDS_RETCODE_ERROR;  // either bad parameter or failed to allocate buffer for samples

	// return the pointers to our internal buffer
	for(int i=0; i < maxSamples; i++ ) 
		samples[i] = (void*)((uint8_t*)_samples + i*_topicSettings->descriptor->m_size);

	// No need for zeroing here as the sample bufer is guaranteed to be already zeroed by ReturnLoan & ReserveSamples
	//// zero the sample memory so that dds does not try to reuse any dynamic structures
	//memset( _samples, 0, maxSamples * _topicSettings->descriptor->m_size );

	if( sampleStateMask == 0 )
		sampleStateMask = DDS_ANY_STATE;

	dds_return_t rc;
	switch( action )
	{
		case EAction::Read:
			rc = dds_read_mask( _reader, samples, sampleInfos, maxSamples, maxSamples, sampleStateMask );
			break;

		case EAction::Take:
			rc = dds_take_mask( _reader, samples, sampleInfos, maxSamples, maxSamples, sampleStateMask );
			break;

		case EAction::ReadInstance:
			rc = dds_read_instance_mask( _reader, samples, sampleInfos, maxSamples, maxSamples, instanceHandle, sampleStateMask );
			break;

		case EAction::TakeInstance:
			rc = dds_take_instance_mask( _reader, samples, sampleInfos, maxSamples, maxSamples, instanceHandle, sampleStateMask );
			break;

		default:
			rc = DDS_RETCODE_UNSUPPORTED;
			break;
	}

    if (rc < 0)
	{
		if ( rc != DDS_RETCODE_PRECONDITION_NOT_MET || action == EAction::Read || action == EAction::Take )
		{  
			// read/take_instance before writer is matched results DDS_RETCODE_PRECONDITION_NOT_MET.
			// However, this is a normal use case and the error stops once a writer is matched.
			dds_log(DDS_LC_ERROR, __FILE__, __LINE__, "dds read/take", "dds read/take %s: %s\n", _topicSettings->name, dds_strretcode(-rc));
		}
	}
	else
	{
		_numSamplesReturned = rc;

		//{
		//	for(int i=0; i < rc; i++ ) 
		//	{
		//		auto* info = sampleInfos + i;
		//		printf("[DDS READ]  topic=%s, sender=%s\n",
		//			GetTopicSettings()->GetTopicName(),
		//			GetSenderGuid(info->publication_handle).c_str()
		//		);
		//	}
		//}
	}

	return rc;
}

dds_instance_handle_t TopicReader::LookupInstance( void* sample )
{
	return dds_lookup_instance( _reader, sample );
}

void TopicReader::SetListener( DataListener* listener )
{
	if( listener ) listener->SetReader( this );

	dds_listener_t* ddsList = listener ? listener->GetNativeHandle() : NULL;

	dds_set_listener( _reader, ddsList );
}

int TopicReader::GetSenderGuid(dds_instance_handle_t publicationHandle, char* buf, int bufsize)
{
	dds_builtintopic_endpoint_t* publData = dds_get_matched_publication_data(_reader, publicationHandle);
	if (!publData)
	{
		dds_log(DDS_LC_ERROR, __FILE__, __LINE__, "dds_get_matched_publication_data", "dds_get_matched_publication_data could not be found from publication handle %0llx in reader of %s\n", publicationHandle, _topicSettings->name);
		return 0;
	}

	dds_guid_t senderGuid = publData->participant_key;
	int res = dds_guid_to_string(senderGuid, buf, bufsize );

	dds_free(publData); publData = nullptr;

	return res;
}


std::string TopicReader::GetSenderGuid( dds_instance_handle_t publicationHandle )
{
	char guidStr[100] = {0};
	GetSenderGuid( publicationHandle, guidStr, sizeof(guidStr) );
	return guidStr;
}


dds_return_t TopicReader::WaitForSubscriptionMatched(int timeoutMsec)
{
	auto ret = dds_set_status_mask(_reader, DDS_SUBSCRIPTION_MATCHED_STATUS);
	if (ret != DDS_RETCODE_OK)
		return ret;

	const int quantumMsec = 20;
	int timeRemaining = timeoutMsec;
	while (true)
	{
		uint32_t status;
		ret = dds_get_status_changes(_reader, &status);
		if (ret != DDS_RETCODE_OK)
			return ret;

		if (status == DDS_SUBSCRIPTION_MATCHED_STATUS) {
			break;
		}

		if (timeoutMsec >= 0) // do we wait for timeout?
		{
			if (timeRemaining <= 0)
				return DDS_RETCODE_TIMEOUT;
		}

		dds_sleepfor(DDS_MSECS(quantumMsec));

		if (timeoutMsec >= 0) // do we wait for timeout?
		{
			timeRemaining -= quantumMsec;

			if (timeRemaining <= 0)
				return DDS_RETCODE_TIMEOUT;
		}

	}
	return DDS_RETCODE_OK;
}

}

TopicWriter.cpp

#include <stdio.h>
#include "TopicWriter.h"
#include "dds/dds.h"
#include "SenderId/ParticInfoSender.h"

namespace Dds::Base
{

TopicWriter::TopicWriter( Participant* participant, TTopicSettings* topicSettings, const char* partitionName )
{
	//printf("TopicWriter()\n");

	_topicSettings = topicSettings;
	_participant = participant;

	_topic = dds_create_topic( _participant->GetNativeHandle(), topicSettings->descriptor, topicSettings->name, NULL, NULL);
	if( _topic < 0 )
	    DDS_FATAL("dds_create_topic %s: %s\n", topicSettings->name, dds_strretcode(-_topic));

	dds_qos_t *qos = dds_create_qos ();
	dds_qset_reliability( qos, topicSettings->reliability.kind, topicSettings->reliability.blocking_time );
	dds_qset_durability( qos, topicSettings->durability.kind );
	dds_qset_history( qos, topicSettings->history.kind, topicSettings->history.depth );
	dds_qset_writer_data_lifecycle( qos, topicSettings->writer_data_lifecycle.autodispose );

	const char* finalPartitionName = partitionName;
	if( !finalPartitionName ) finalPartitionName = participant->GetDefaultPartitionName();
	if( finalPartitionName )
	{
		dds_qset_partition1( qos, finalPartitionName );
	}

	_writer = dds_create_writer( _participant->GetNativeHandle(), _topic, qos, NULL );
	if (_writer < 0)
		DDS_FATAL("dds_create_writer %s: %s\n", topicSettings->name, dds_strretcode(-_writer));

    dds_delete_qos(qos);

	// publish the participant info
	ParticInfoSender::GetInstance()->RegisterParticipant( _participant );
}

TopicWriter::~TopicWriter()
{
	// dispose writer
	// dispose topic...
	printf("~TopicWriter()\n");

	// unpublish the participant info
	ParticInfoSender::GetInstance()->UnregisterParticipant(_participant);

	if( _writer >= 0 )
	{
		auto rc = dds_delete( _writer );
		if (rc != DDS_RETCODE_OK)
			DDS_FATAL("dds_delete(writer) %s: %s\n", _topicSettings->name, dds_strretcode(-rc));
	}

	if( _topic >= 0 )
	{
		auto rc = dds_delete( _topic );
		if (rc != DDS_RETCODE_OK)
			DDS_FATAL("dds_delete(topic) %s: %s\n", _topicSettings->name, dds_strretcode(-rc));
	}
}

int TopicWriter::Write( void* sample, bool dispose )
{
	//{
	//	printf("[DDS WRITE] topic=%s, sender=%s\n",
	//		_topicSettings->GetTopicName(),
	//		_participant->GetGuid()
	//	);
	//}

	if( dispose )
	{
		auto rc = dds_writedispose( _writer, sample );
		if( rc != DDS_RETCODE_OK )
		{
			dds_log(DDS_LC_ERROR, __FILE__, __LINE__, "dds writedispose", "dds writedispose %s: %s\n", _topicSettings->name, dds_strretcode(-rc));
		}
		return rc;
	}
	else
	{
		auto rc = dds_write( _writer, sample );
		if (rc != DDS_RETCODE_OK)
		{
			dds_log(DDS_LC_ERROR, __FILE__, __LINE__, "dds write", "dds write %s: %s\n", _topicSettings->name, dds_strretcode(-rc));
		}
		return rc;
	}
}

int TopicWriter::WriteWithTimeStamp( void* sample, dds_time_t timeStamp, bool dispose )
{
	if( dispose )
	{
		auto rc = dds_writedispose_ts( _writer, sample, timeStamp );
		if (rc != DDS_RETCODE_OK)
		{
			dds_log(DDS_LC_ERROR, __FILE__, __LINE__, "dds writedispose_ts", "dds writedispose_ts %s: %s\n", _topicSettings->name, dds_strretcode(-rc));
		}
		return rc;
	}
	else
	{
		auto rc = dds_write_ts( _writer, sample, timeStamp );
		if (rc != DDS_RETCODE_OK)
		{
			dds_log(DDS_LC_ERROR, __FILE__, __LINE__, "dds write_ts", "dds write_ts %s: %s\n", _topicSettings->name, dds_strretcode(-rc));
		}
		return rc;
	}
}

dds_instance_handle_t TopicWriter::LookupInstance( void* sample )
{
	return dds_lookup_instance(_writer, sample);
}

dds_instance_handle_t TopicWriter::RegisterInstance( void* sample )
{
	dds_instance_handle_t handle;

	dds_return_t rc = dds_register_instance( _writer, &handle, sample );
	if( rc == DDS_RETCODE_OK )
		return handle;
	return 0;
}


dds_return_t TopicWriter::UnregisterInstance( void* sample )
{
	return dds_unregister_instance( _writer, sample );
}

dds_return_t TopicWriter::UnregisterInstance( dds_instance_handle_t instanceHandle )
{
	return dds_unregister_instance_ih( _writer, instanceHandle );
}

dds_return_t TopicWriter::WaitForPublicationMatched( int timeoutMsec )
{
	auto ret = dds_set_status_mask( _writer, DDS_PUBLICATION_MATCHED_STATUS);
	if( ret != DDS_RETCODE_OK )
		return ret;
	
	const int quantumMsec = 20;
	int timeRemaining = timeoutMsec;
	while( true )
	{
		uint32_t status;
		ret = dds_get_status_changes (_writer, &status);
		if( ret != DDS_RETCODE_OK )
			return ret;
	
		if (status == DDS_PUBLICATION_MATCHED_STATUS) {
			break;
		}
		
		if( timeoutMsec >= 0 ) // do we wait for timeout?
		{
			if( timeRemaining <= 0 )
				return DDS_RETCODE_TIMEOUT;
		}

		dds_sleepfor (DDS_MSECS (quantumMsec));

		if( timeoutMsec >= 0 ) // do we wait for timeout?
		{
			timeRemaining -= quantumMsec;

			if( timeRemaining <= 0 )
				return DDS_RETCODE_TIMEOUT;
		}

	}
	return DDS_RETCODE_OK;
}


};

Participant.cpp

#include <stdio.h>
#include "Participant.h"
#include "dds/dds.h"
#include "DdsGuid.h"
#include <ostream>
#include <sstream>

namespace Dds
{

	Participant::Participant(const char* partitionName, int appDomainId, int appNodeId)
	{
		printf("Participant()\n");

		if (partitionName)
		{
			_partitionNameSet = true;
			_partitionName = partitionName;
		}

		_participant = dds_create_participant(DDS_DOMAIN_DEFAULT, NULL, NULL);
		if (_participant < 0)
		{
			_error = -_participant;
			dds_log(DDS_LC_ERROR, __FILE__, __LINE__, "Participant::ctor", "dds_create_participant: %s\n", dds_strretcode(-_participant));
		}

		// get the guid
		dds_guid_t nativeGuid;
		auto guid_rc = dds_get_guid(_participant, &nativeGuid);
		if (guid_rc < 0)
		{
			_error = -_participant;
			dds_log(DDS_LC_ERROR, __FILE__, __LINE__, "Participant::ctor", "dds_get_guid: %s\n", dds_strretcode(-guid_rc));
		}

		char guidStr[100]; dds_guid_to_string(nativeGuid, guidStr, sizeof(guidStr));
		_guid = guidStr;

		_appDomainId = appDomainId;
		_appNodeId = appNodeId;
	}

	Participant::~Participant()
	{
		printf("~Participant() guid=%s domainId=%d nodeId=%d\n", _guid.c_str(), _appDomainId, _appNodeId);

		if (_participant == 0) return;

		/* Deleting the participant will delete all its children recursively as well. */
		auto rc = dds_delete(_participant);
		if (rc != DDS_RETCODE_OK)
			DDS_FATAL("dds_delete(participant): %s\n", dds_strretcode(-rc));
	}
};

this is our API for the C# layer

using Communication.CustomException;
using Communication.CustomFilter;
using Dds;
using Dds.Base;
using Microsoft.Extensions.Logging;
using System;

namespace Communication
{
    public class DDS : Disposable, ICommunicationLayer
    {
        private int _readingPause;
        private bool _changeCPUClockResolution;
        private TopicDataManager _topicDataManager;
        private TopicReader _topicReader;
        private TopicWriter _topicWriter;
        private ILogger _logger;
        private bool _isDisposing;

        /// <summary>
        /// WARNING: Not thread safe!!! Topic samples delivered in static reader thread. One thread for App.
        /// </summary>
        /// <param name="provideSenderInfo">If true, SenderInfo will be provided in OnTopicChange</param>
        public DDS()
        {
            _readingPause = 15;
            _topicDataManager = new TopicDataManager();
            _topicReader = new TopicReader(_topicDataManager, _readingPause);
            _topicWriter = new TopicWriter(_topicDataManager);
        }

        public DDS(ILogger logger) : this()
        {
            _logger = logger;
            _topicReader.Logger = _logger;
            _topicWriter.Logger = _logger;
        }

        public DDS(bool changeCPUClockResolution) : this()
        {
            _changeCPUClockResolution = changeCPUClockResolution;
            if (_changeCPUClockResolution)
            {
                Win32API.SetCPUClockResolution(_logger);

                _readingPause = 1;
                _topicReader.UpdateReadingPause(_readingPause);
            }
        }

        public DDS(bool changeCPUClockResolution, bool provideSenderInfo) : this(changeCPUClockResolution)
        {
            _topicReader.ProvideSenderInfo = provideSenderInfo;
        }

        public DDS(bool changeCPUClockResolution, bool provideSenderInfo, ILogger logger) : this(changeCPUClockResolution, provideSenderInfo)
        {
            _logger = logger;
            _topicReader.Logger = _logger;
            _topicWriter.Logger = _logger;
        }

        /// <summary>
        /// Connect correct writer nad reader with given topic.
        /// </summary>
        /// <typeparam name="T">TopicBase</typeparam>
        /// <typeparam name="W">TopicWriter</typeparam>
        /// <typeparam name="R">TopicReader</typeparam>
        /// <exception cref="TopicNotRegisteredException">Throws if Topic is not registered yet.</exception>
        public void RegisterTopic<T, W, R, S>()
            where T : TopicBase, new()
            where W : Dds.Base.TopicWriter, new()
            where R : Dds.Base.TopicReader, new()
            where S : Dds.Base.TopicSettings, new()
        {
            _topicDataManager.RegisterHandlersForTopic<T, W, R, S>();
        }

        public void Subscribe<T>(Action<T, SampleInfo> onTopicChange, Func<T, bool> filter) where T : TopicBase
        {
            Subscribe(onTopicChange, string.Empty, filter);
        }

        /// <summary>
        /// Subscribe an action, with specific filter on topic data update. 
        /// An action is subscribed just once.
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="onTopicChange"></param>
        /// <param name="partition"></param>
        /// <param name="filter">Null if empty.</param>
        /// <exception cref="TopicRegistrationException">Throws if TopicWriter, or TopicReader are incorrect.</exception>
        public void Subscribe<T>(Action<T, SampleInfo> onTopicChange, IFilterHandler<T> filter, string partition = "") where T : TopicBase
        {
            Subscribe(typeof(T), onTopicChange, filter, partition);
        }

        public void Subscribe<T>(Action<T, SampleInfo> onTopicChange, string partition = "", Func<T, bool> filter = null) where T : TopicBase
        {
            Subscribe(onTopicChange, new GenericFilterHandler<T>(filter), partition);
        }

        /// <summary>
        /// Subscribe an action, with specific filter on topic data update. 
        /// An action is subscribed just once.
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="topicType"></param>
        /// <param name="onTopicChange"></param>
        /// <param name="partition"></param>
        /// <param name="filter">Null if empty.</param>
        /// <exception cref="TopicRegistrationException">Throws if TopicWriter, or TopicReader are incorrect.</exception>
        public void Subscribe<T>(Type topicType, Action<T, SampleInfo> onTopicChange, IFilterHandler<T> filter, string partition = "") where T : TopicBase
        {
            _topicReader.SubscribeTopic(topicType, (T sample, SampleInfo info, ParticInfo sender) => onTopicChange(sample, info), onTopicChange.Target, onTopicChange.Method.MetadataToken, partition, filter);
            _logger?.LogDebug("Topic = {topicName}, method = {methodName} Subscribed", typeof(T).Name, nameof(onTopicChange));
        }

        public void Subscribe<T>(Type topicType, Action<T, SampleInfo, ParticInfo> onTopicChange, IFilterHandler<T> filter, string partition = "") where T : TopicBase
        {
            _topicReader.SubscribeTopic(topicType, onTopicChange, onTopicChange.Target, onTopicChange.Method.MetadataToken, partition, filter);
            _logger?.LogDebug("Topic = {topicName}, method = {methodName} Subscribed", typeof(T).Name, nameof(onTopicChange));
        }


        /// <summary>
        /// Subscribe an action, with specific filter on topic data update. 
        /// An action is subscribed just once.
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="topicType"></param>
        /// <param name="onTopicChange"></param>
        /// <param name="partition"></param>
        /// <param name="filter">Null if empty.</param>
        /// <exception cref="TopicRegistrationException">Throws if TopicWriter, or TopicReader are incorrect.</exception>
        public void Subscribe<T>(Type topicType, Action<T, SampleInfo> onTopicChange, string partition = "", Func<T, bool> filter = null) where T : TopicBase
        {
            Subscribe(topicType, onTopicChange, new GenericFilterHandler<T>(filter), partition);
        }

        /// <summary>
        /// Remove subscription of an action on given topic.
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="onTopicChange"></param>
        /// <param name="partition"></param>
        public void Unsubscribe<T>(Action<T, SampleInfo> onTopicChange, string partition = "") where T : TopicBase
        {
            Unsubscribe(typeof(T), onTopicChange, partition);
        }

        /// <summary>
        /// Remove subscription of an action on given topic.
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="topicType"></param>
        /// <param name="onTopicChange"></param>
        /// <param name="partition"></param>
        public void Unsubscribe<T>(Type topicType, Action<T, SampleInfo> onTopicChange, string partition = "") where T : TopicBase
        {
            _topicReader.UnsubscribeTopic(topicType, (T sample, SampleInfo info, ParticInfo sender) => onTopicChange(sample, info), onTopicChange.Target, onTopicChange.Method.MetadataToken, partition);
            _logger?.LogDebug("Topic = {topicName}, method = {methodName} Unsubscribed", typeof(T).Name, nameof(onTopicChange));
        }

        public void Unsubscribe<T>(Type topicType, Action<T, SampleInfo, ParticInfo> onTopicChange, string partition = "") where T : TopicBase
        {
            _topicReader.UnsubscribeTopic(topicType, onTopicChange, onTopicChange.Target, onTopicChange.Method.MetadataToken, partition);
            _logger?.LogDebug("Topic = {topicName}, method = {methodName} Unsubscribed", typeof(T).Name, nameof(onTopicChange));
        }

        /// <summary>
        /// Publish topic change.
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="sample"></param>
        /// <param name="partition"></param>
        /// <exception cref="Exception">Thrown when return code is not Ok.</exception>
        /// <exception cref="TopicNotRegisteredException">Throws when topic is not registered yet</exception>
        public void Publish<T>(T sample, string partition = "") where T : TopicBase
        {
            Publish(sample.GetType(), sample, partition);
        }

        public void Publish(Type topicType, TopicBase sample, string partition = "")
        {
            ProcessPublish(topicType, sample, partition, false);
            _logger?.LogTrace("Sample = {topicName}, partition = {partition} Published", topicType.Name, partition);
        }

        private void ProcessPublish(Type topicType, TopicBase sample, string partition, bool dispose)
        {
            if (_isDisposing)
                throw new ObjectDisposedException("ICommunicationLayer; DDS");

            var result = _topicWriter.PublishTopicChange(topicType, sample, dispose, partition);
            if (result != ReturnCode.Ok)
            {
                string currentProcess = dispose ? "Dispose" : "Publish";
                throw new Exception($"{currentProcess} of topic={sample.GetType().Name} failed with returnCode={result}");
            }
        }

        /// <summary>
        /// Dispose concrete topic sample.
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="sample"></param>
        /// <param name="partition"></param>
        /// <exception cref="Exception">Throws if dispose failed</exception>
        public void DisposeTopicSample<T>(T sample, string partition = "") where T : TopicBase
        {
            ProcessPublish(sample.GetType(), sample, partition, true);
            _logger?.LogTrace("Sample = {topicName}, partition = {partition} Disposed", typeof(T).Name, partition);
        }

        /// <summary>
        /// Dispose the internal dds objects (reading thread, participants...)
        /// You need to call this explicitly when you no longer need to work with the DDS messages, latest at the end of the app.
        /// WARNING: Not thread safe!!! DO NOT call from multiple tasks/threads at the same time!
        /// </summary>
		protected override void Dispose(bool disposing)
        {
            base.Dispose(disposing);
            if (!disposing)
            {
                return;
            }
            _isDisposing = disposing;

            _topicReader?.Dispose();
            _topicWriter?.Dispose();
            _topicDataManager?.Dispose();
            if (_changeCPUClockResolution)
            {
                Win32API.ResetCPUClockResolution();
            }

            _logger?.LogDebug($"DDS communication Disposed");
        }

        /// <summary>
        /// Check if a type already subscribed with specific action
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="topicType"></param>
        /// <param name="onTopicChange"></param>
        /// <param name="partition"></param>
        public bool IsTopicSubscribedToAction<T>(Type topicType, Action<T, SampleInfo> onTopicChange, string partition = "") where T : TopicBase
        {
            return _topicReader.IsTopicSubscribedToAction(topicType, (T sample, SampleInfo info, ParticInfo sender) => onTopicChange(sample, info), onTopicChange.Target, onTopicChange.Method.MetadataToken, partition);
        }

        public void DisposeAllWrites()
        {
            _topicWriter.ResetAllWriters();
        }
    }
}

and here are some of the classes that may be relevant

TopicReader.cs

using Communication.CustomException;
using Dds.Base;
using Dds;
using System;
using System.Collections.Generic;
using System.Linq;
using Microsoft.Extensions.Logging;
using System.Collections.Immutable;

namespace Communication
{
    internal class TopicReader : Disposable
    {
        private TopicDataManager _topicDataManager;
        internal ParticInfoMonitor _particInfoMonitor;
        internal bool ProvideSenderInfo
        {
            set
            {
                if (value)
                {
                    _particInfoMonitor = new ParticInfoMonitor();
                }
            }
        }

        private ILogger _logger;
        internal ILogger Logger
        {
            set
            {
                _logger = value;
            }
        }

        internal TopicReader(TopicDataManager topicDataManager, int readingPause)
        {
            _topicDataManager = topicDataManager;
            // note: Max one thread runs per application, stopped on TopicDataManager disposal
            _topicDataManager.StartTopicReaderThreadIfNotAlreadyRunning(readingPause, ReadTopics);
        }


        protected override void Dispose(bool disposing)
        {
            if (disposing)
            {
                _particInfoMonitor?.Dispose();
                _particInfoMonitor = null;
            }
        }

        /// <summary>
        /// Polls incoming samples of all subscribed topics, for those passing the filter calls their action handlers
        /// </summary>
        protected void ReadTopics()
        {
            foreach (var topicCallbacks in _topicDataManager.GetActionDataCollection()) // iterate all subscriptions
            {
                ITopicHandler topicHandler = _topicDataManager.GetTopicHandlerOrDefault(topicCallbacks.Key);
                if (topicHandler != null)
                {
                    while(true) // read all msgs buffered in the dds reader
                    // Intentionally there is no limit on how many msgs to read per iteration.
                    // If we keep getting more messages than what we can process quickly enough,
                    // reading thread will freeze and no other msgs will be received,
                    // indicating the problem very clearly. Maybe better than if dying slowly,
                    // showing just increasing delays in msg reception.
                    {
                        var sample = topicHandler.Topic;
                        var sampleInfo = topicHandler.SampleInfo;
                        var result = topicHandler.Read(ref sample, ref sampleInfo);
                        if (result != ReturnCode.Ok)
                            break;

                        ParticInfo sender = null;
                        if (_particInfoMonitor != null)
                        {
                            string senderGuid = topicHandler.GetSenderGuid(sampleInfo.PublicationHandle);
                            sender = _particInfoMonitor.FindByGuid(senderGuid);
                        }

                        topicHandler.Topic = _topicDataManager.GetNewTopicInstance(topicHandler.TopicName);
                        foreach (var callbackData in topicCallbacks.Value)
                        {
                            if (callbackData.Filter(sample))
                            {
                                callbackData.OnTopicChange(sample, sampleInfo, sender);
                            }
                        }
                    }
                }
            }
        }

        internal void SubscribeTopic<T>(Type topicType, Action<T, SampleInfo, ParticInfo> OnTopicChange, object id1, int id2, string partition, IFilterHandler<T> filter) where T : TopicBase
        {
            var subscriptionKey = _topicDataManager.GetDataKey(topicType.FullName, partition);
            InitializeTopicHandler(topicType, _topicDataManager.GetParticipant(partition), subscriptionKey);
            SubscribeTopic(OnTopicChange, id1, id2, filter, subscriptionKey);
        }

        private void InitializeTopicHandler(Type topicType, Participant participant, string subscriptionKey)
        {
            if (TopicDataManager.SubscribedTopicHandlers.ContainsKey(subscriptionKey))
            {
                if (!TopicDataManager.TopicActionData.ContainsKey(subscriptionKey))
                {
                    TopicDataManager.TopicActionData[subscriptionKey] = ImmutableArray.Create<IActionData>();
                }

                return;
            }

            if (_topicDataManager.TryGetTopicHandler(topicType, participant, out ITopicHandler topicHandler))
            {
                TopicDataManager.TopicActionData[subscriptionKey] = ImmutableArray.Create<IActionData>();
                TopicDataManager.SubscribedTopicHandlers[subscriptionKey] = topicHandler;
                TopicDataManager.ExplicitlyUnsubscribedKeys.TryRemove(subscriptionKey, out _);
            }
            else
                throw new TopicNotRegisteredException($"TOPIC NOT REGISTERED - Subscribed topic={topicType.Name} has to be registered first.");
        }

        private void SubscribeTopic<T>(Action<T, SampleInfo, ParticInfo> onTopicChange, object id1, int id2, IFilterHandler<T> filter, string subscriptionKey) where T : TopicBase
        {
            IActionData subscribeData = new ActionData<T>(onTopicChange, id1, id2, filter);
            if (
                    TopicDataManager.TopicActionData.TryGetValue(subscriptionKey, out var actions) &&
                    !IsSubscribed(subscribeData, actions)
                )
            {
                TopicDataManager.TopicActionData[subscriptionKey] = actions.Add(subscribeData);
            }
        }

        private bool IsSubscribed(IActionData actionData, IEnumerable<IActionData> actions)
        {
          var isSubscribed = actions.Any(x => actionData.Equals(x));
            return isSubscribed;
        }

        internal void UnsubscribeTopic<T>(Type topicType, Action<T, SampleInfo, ParticInfo> onTopicChange, object id1, int id2, string partition) where T : TopicBase
        {
            var key = _topicDataManager.GetDataKey(topicType.FullName, partition);
            if (TopicDataManager.TopicActionData.TryGetValue(key, out var actions))
            {
                TopicDataManager.TopicActionData[key] = UnsubscribeTopic(onTopicChange, id1, id2, key, actions);
                if(TopicDataManager.TopicActionData[key].Count() == 0 )
                {
                    if(TopicDataManager.TopicActionData.TryRemove(key, out _))
                    {
                        if(TopicDataManager.SubscribedTopicHandlers.TryRemove(key, out var topicHandler))
                        {
                            topicHandler.Dispose();
                            TopicDataManager.ExplicitlyUnsubscribedKeys.TryAdd(key, 0);
                        }
                    }
                }
            }
        }

        private ImmutableArray<IActionData> UnsubscribeTopic<T>(Action<T, SampleInfo, ParticInfo> onTopicChange, object id1, int id2, string key, ImmutableArray<IActionData> actions) where T : TopicBase
        {
            IActionData actionData = new ActionData<T>(onTopicChange, id1, id2);
            var subscriptionData = actions.Where(x => actionData.Equals(x)).FirstOrDefault();
            if (subscriptionData != null)
            {
                return actions.Remove(subscriptionData);
            }

            return actions;
        }

        internal bool IsTopicSubscribedToAction<T>(Type topicType, Action<T, SampleInfo, ParticInfo> onTopicChange, object id1, int id2, string partition) where T : TopicBase
        {
            var subscriptionKey = _topicDataManager.GetDataKey(topicType.FullName, partition);
            IActionData subscribeData = new ActionData<T>(onTopicChange, id1, id2);
            bool subscribed = false;
            if (TopicDataManager.TopicActionData.TryGetValue(subscriptionKey, out var actions))
            {
                subscribed = IsSubscribed(subscribeData, actions);
            }

            return subscribed;
        }
        
        internal void UpdateReadingPause(int readingPause)
        {
            _topicDataManager.UpdateReadingPause(readingPause);
        }
    }
}

TopicDataManager.cs

using Dds;
using Dds.Base;
using System;
using System.Collections.Concurrent;
using System.Collections.Immutable;
using System.Threading;

namespace Communication
{
    /// <summary>
    /// Data storage for information on subscribed/published topics, keyed by topicName+partitionName. No logic.
    /// Data is static, shared shared by TopicReader & TopicWriter. Dispose() should be called in pair with the ctor
    /// to disposed the shared static data when no one is using it anymore.
    /// Maintains various info like
    ///   - instances od participant for each individual partition (one per partition)
    ///   - instances of internal readers and writers (one per topic type)
    ///   - actions to call on topic arrival and associated filter method 
    /// </summary>
    public class TopicDataManager : Disposable
    {
        public static ConcurrentDictionary<string, ImmutableArray<IActionData>> TopicActionData => TopicData.TopicActionData;
        public static ConcurrentDictionary<string, ITopicHandlerInitializer> TopicHandlerInitializers => TopicData.TopicHandlerInitializers;
        public static ConcurrentDictionary<string, ITopicHandler> SubscribedTopicHandlers => TopicData.SubscribedTopicHandlers;
        public static string CurrentParticipantPartition => _currentPartition;

        public static Participant Participant;        // single live participant
        private static string _currentPartition = "";   // last partition used for _participant
        public static ConcurrentDictionary<string, byte> ExplicitlyUnsubscribedKeys = new ConcurrentDictionary<string, byte>();
        public TopicDataManager()
        {
            TopicData.AddRef();

            // We found a bug that in some cases the first volative message sent is not being received correctly.
            // The problem seems to be fixed by creating a participant (any partition) a few ms before actually publishing the message.
            GetParticipant(string.Empty);
        }

        protected override void Dispose(bool disposing)
        {
            base.Dispose(disposing);
            if (!disposing) return;

            // note: TopicData is shared between TopicReader & TopicWriter, we never know who is still using it => disposes once refcnt drops to zero
            TopicData.RemoveRef();
        }

        internal void RegisterHandlersForTopic<T, W, R, S>()
            where T : TopicBase, new()
            where W : Dds.Base.TopicWriter, new()
            where R : Dds.Base.TopicReader, new()
            where S : Dds.Base.TopicSettings, new()
        {
            var key = GetDataKey(typeof(T).FullName, string.Empty);
            if (!TopicData.TopicHandlerInitializers.ContainsKey(key))
            {
                var topicBaseType = typeof(T).Name;
                var topicWriter = typeof(W).Name;
                var topicReader = typeof(R).Name;
                var topicSettings = typeof(S).Name;

                CheckCorrectTypes(topicBaseType, topicWriter, topicReader, topicSettings);
                TopicData.TopicHandlerInitializers[key] = new TopicHandlerInitializer<T, W, R, S>();
            }
        }

        public string GetDataKey<T>(string partition) where T : TopicBase
        {
            return GetDataKey(typeof(T).FullName, partition);
        }

        public string GetDataKey(string topicName, string partition)
        {
            if (string.IsNullOrEmpty(partition))
                return $"{topicName}";
            else
                return $"{topicName}_{partition}";
        }

        private void CheckCorrectTypes(string topicName, string writerName, string readerName, string settingsName)
        {
            string exceptionMessage = string.Empty;

            bool correctWriterType = writerName.StartsWith(topicName);
            if (!correctWriterType)
                exceptionMessage = $"Incorrect TopicWriter type={writerName}, for topic={topicName}";

            bool correctReaderType = readerName.StartsWith(topicName);
            if (!correctReaderType)
                exceptionMessage = $"{exceptionMessage}\n Incorrect TopicReader type={readerName}, for topic={topicName}";

            bool correctSettingsType = settingsName.StartsWith(topicName);
            if (!correctSettingsType)
                exceptionMessage = $"{exceptionMessage}\n Incorrect TopicSettings type={settingsName}, for topic={topicName}";

            if (!correctWriterType || !correctReaderType || !correctSettingsType)
                throw new Exception(exceptionMessage);
        }

        internal ITopicHandler GetTopicHandlerOrDefault<T>(T sample, string partition) where T : TopicBase
        {
            var key = GetDataKey(sample.GetType().FullName, partition);
            return GetTopicHandlerOrDefault(key);
        }

        internal ITopicHandler GetTopicHandlerOrDefault(string TopicHandlerKey)
        {
            if (TopicData.SubscribedTopicHandlers.TryGetValue(TopicHandlerKey, out var handler))
                return handler;

            return null;
        }

        // Disposes ONLY handlers that were explicitly unsubscribed by the application
        // and that belong to the specified partition.
        private void DisposeHandlersForPartition_ExplicitOnly(string partition)
        {
            // keys look like:
            //   empty partition: "Topic"
            //   non-empty:       "Topic_<partition>"
            string suffix = string.IsNullOrEmpty(partition) ? null : "_" + partition;

            foreach (var kv in TopicData.SubscribedTopicHandlers)
            {
                string key = kv.Key;

                // Must be explicitly unsubscribed:
                if (!ExplicitlyUnsubscribedKeys.ContainsKey(key))
                    continue;

                // Must belong to the old partition we are leaving:
                bool match =
                    suffix == null
                        ? !key.Contains("_")             // empty partition keys have no suffix
                        : key.EndsWith(suffix, StringComparison.Ordinal);

                if (!match)
                    continue;

                if (TopicData.SubscribedTopicHandlers.TryRemove(key, out var handler))
                {
                    try { handler.Dispose(); } catch { /* keep current behavior; swallow or log as you already do */ }
                }
            }
        }

        internal Participant GetParticipant(string partition)
        {
            if (partition == null)
            {
                partition = string.Empty;
            }

            // If we already have a participant for this exact partition, reuse it
            if (Participant != null && string.Equals(_currentPartition, partition, StringComparison.Ordinal))
            {
                return Participant;
            }

            // If there is an old participant (for a different partition), dispose it first
            if (Participant != null)
            {
                DisposeHandlersForPartition_ExplicitOnly(_currentPartition);

                try
                {
                    Participant.Dispose(); // IMPORTANT: this should delete contained entities as your wrapper already does
                }
                catch
                {
                    // swallow to keep behavior robust; logging is ok if you prefer
                }

                Participant = null;
            }

            // Create a fresh participant for the requested partition
            Participant = new Participant(partition);

            // Remember which partition this participant represents
            _currentPartition = partition;

            return Participant;
        }


        internal TopicBase GetNewTopicInstance(string topicName)
        {
            return TopicData.TopicHandlerInitializers[topicName].GetTopicInstance();
        }

        internal ConcurrentDictionary<string, ImmutableArray<IActionData>> GetActionDataCollection()
        {
            return TopicData.TopicActionData;
        }

        public bool IsRegistered(Type TopicType)
        {
            var key = GetDataKey(TopicType.FullName, string.Empty);
            return TopicData.TopicHandlerInitializers.ContainsKey(key);
        }

        public ITopicHandler InitializeTopicHandler(Type topicType, Participant participant)
        {
            if (TryGetTopicHandler(topicType, participant, out ITopicHandler topicHandler))
            {
                var topicHandlerKey = GetDataKey(topicType.FullName, participant.DefaultPartitionName);
                TopicData.SubscribedTopicHandlers[topicHandlerKey] = topicHandler;
                return topicHandler;
            }
            else
            {
                throw new Exception($"InitializeTopicHandler for {topicType.Name} and partition ={participant.DefaultPartitionName} FAILED.");
            }
        }
        internal bool TryGetTopicHandler(Type topicType, Participant participant, out ITopicHandler newTopicHandler)
        {
            newTopicHandler = null;
            var registrationKey = GetDataKey(topicType.FullName, string.Empty);
            if (TopicData.TopicHandlerInitializers.TryGetValue(registrationKey, out var topicInitializer))
            {
                newTopicHandler = topicInitializer.InitializeTopicHandler(participant);
                return true;
            }
            return false;
        }

        /// <summary>
        /// Starts the thread periodically reading incoming topics.
        /// Only one thread shall run per application, only first request is accepted, successive requests (coming from another instances od DDS class) are ignored.
        /// </summary>
        /// <param name="readingPause">number of msecs to sleep between ticks of the reading thread</param>
        /// <param name="topicReaderThreadTickCallback">delegate that should read the topics</param>
        internal void StartTopicReaderThreadIfNotAlreadyRunning(int readingPause, Action topicReaderThreadTickCallback)
        {
            TopicData.StartReaderThreadIfNotAlreadyRunning(readingPause, topicReaderThreadTickCallback);
        }

        internal void UpdateReadingPause(int readingPause)
        {
            TopicData.ReadingPauseMsec = readingPause;
        }

        /// <summary>
        /// Globally shared topic data including the one and only topic reading thread per app.
        /// Reference counting based disposal only when no one uses it anymore.
        /// 
        /// </summary>
        private static class TopicData
        {
            /// <summary>
            /// ActionData added each subscribe
            /// </summary>
            internal static ConcurrentDictionary<string, ImmutableArray<IActionData>> TopicActionData { get; }
            internal static ConcurrentDictionary<string, ITopicHandlerInitializer> TopicHandlerInitializers { get; }
            internal static ConcurrentDictionary<string, ITopicHandler> SubscribedTopicHandlers { get; }
            /// <summary> One per partition </summary>
            internal static ConcurrentDictionary<string, Participant> Participants { get; }

            internal static int ReadingPauseMsec { get; set; }

            // The one and only topic reading thread per app
            // Managed here (and not in the TopicReader) to ensure stopping it on the last Dispose (when no one needs it anymore).
            private static Thread _readerThread;
            private static volatile bool _stopRequired;
            private static Action _topicReaderThreadTickCallback;

            private static int _refCount;

            static TopicData()
            {
                _refCount = 0;
                TopicActionData = new ConcurrentDictionary<string, ImmutableArray<IActionData>>();
                TopicHandlerInitializers = new ConcurrentDictionary<string, ITopicHandlerInitializer>();
                SubscribedTopicHandlers = new ConcurrentDictionary<string, ITopicHandler>();
                Participants = new ConcurrentDictionary<string, Participant>();
            }

            /// <summary>
            /// This MUST be called from the ctor of anyone using the TopicData
            /// NOT thread safe!
            /// </summary>
            internal static void AddRef()
            {
                _refCount++;
            }

            /// <summary>
            /// This MUST be called from the dispose handler of anyone using the TopicData
            /// NOT thread safe!
            /// </summary>
            internal static void RemoveRef()
            {
                if (_refCount <= 0) throw new Exception("Trying to derefence TopicData which were already deleted.");
                _refCount--;

                // clear and dispose only if no one else is using the data anymore
                if (_refCount > 0) return;
                Clear();
            }

            // Do not Clear TopicHandlerInitializers, registration is processed once at start of application.
            private static void Clear()
            {
                StopReaderThread();

                TopicActionData.Clear();

                foreach (var subscribedTopicHandler in SubscribedTopicHandlers.Values)
                    subscribedTopicHandler.Dispose(); // properly dispose the low level dds readers/writes
                SubscribedTopicHandlers.Clear();

                foreach (var participant in Participants.Values)
                    participant.Dispose(); // properly dispose the low level dds participant
                Participants.Clear();
            }

            /// <summary>
            /// Starts the thread if not already existing. Periodically calls given callback until the thread is stopped.
            /// </summary>
		    internal static void StartReaderThreadIfNotAlreadyRunning(int readingPauseMsec, Action topicReaderThreadTickCallback)
            {
                if (_topicReaderThreadTickCallback != null)
                    return; // topic reading already requested, this must come from ctor of another instance of DDS class

                StartReaderThread(readingPauseMsec, topicReaderThreadTickCallback);
            }

            private static void StartReaderThread(int readingPauseMsec, Action topicReaderThreadTickCallback)
            {
                _topicReaderThreadTickCallback = topicReaderThreadTickCallback;
                ReadingPauseMsec = readingPauseMsec;

                _readerThread = new Thread(delegate () { TopicReaderLoop(); })
                {
                    Priority = ThreadPriority.Normal,
                    Name = "Topic_Reader_Thread",
                    IsBackground = true
                };
                _readerThread.Start();
            }

            private static void StopReaderThread()
            {
                if (_readerThread != null)
                {
                    _stopRequired = true;
                    _readerThread.Join();
                    _readerThread = null;
                    _topicReaderThreadTickCallback = null;
                }
            }

            private static void TopicReaderLoop()
            {
                while (!_stopRequired)
                {
                    _topicReaderThreadTickCallback(); // typically pointing to TopicReader.ReadTopics();
                    Thread.Sleep(ReadingPauseMsec);
                }
                System.Diagnostics.Debug.WriteLine("TopicReaderThread stopped.");

                _stopRequired = false;
            }

        }
    }
}

TopicHandler.cs

using Dds;
using Dds.Base;

namespace Communication
{
    internal class TopicHandler<T, W, R, S> : ITopicHandler
        where T : TopicBase, new()
        where W : Dds.Base.TopicWriter, new()
        where R : Dds.Base.TopicReader, new()
        where S : Dds.Base.TopicSettings, new()
    {
        public TopicBase Topic
        {
            get => _topic;
            set
            {
                if (value is T newTopic)
                    _topic = newTopic;
            }
        }
        public string TopicName { get; }
        private T _topic;
        private W _topicWriter;
        private R _topicReader;
        private S _topicSettings;
        private SampleInfo _sampleInfo;
        public SampleInfo SampleInfo => _sampleInfo;

        internal TopicHandler(T topic, W topicWriter, R topicReader, S topicSettings)
        {
            _topic = topic;
            _topicWriter = topicWriter;
            _topicReader = topicReader;
            _topicSettings = topicSettings;
            _sampleInfo = new SampleInfo();
            TopicName = typeof(T).FullName;
        }

        public ReturnCode Publish(TopicBase sample, bool dispose = false)
        {
            if (_topicWriter.IsDisposed)
            {
                return ReturnCode.AlreadyDeleted;
            }
            else
            {
                return _topicWriter.Write(sample, dispose);
            }
        }

        public ReturnCode Read(ref TopicBase sample, ref SampleInfo sampleInfo)
        {
            if (_topicReader.IsDisposed)
            {
                return ReturnCode.AlreadyDeleted;
            }
            else
            {
                return _topicReader.Take(ref sample, ref sampleInfo);
            }
        }

        public string GetSenderGuid( InstanceHandle publicationHandle )
        {
            return _topicReader.GetSenderGuid( publicationHandle );
        }

        public void ResetWriter()
        {
            if (_topicWriter != null && !_topicWriter.IsDisposed)
            {
                var participant = _topicWriter.Participant;
                _topicWriter.Dispose();
                _topicWriter = new W();
                _topicWriter.Initialize(participant);
            }
        }

        public void Dispose()
        {
            _topicReader?.Dispose();
            _topicWriter?.Dispose();
        }
    }
}

do you have any suggestions on what or where our problem is? how can we handle those network and memory bursts?

Thanks

[erezdamari-bagira]

someone? anything?

[eboasson]

someone? anything?

It isn't a trivial question! All the information you included is very welcome, but that, too, takes some time to digest.

Above the cyclone implementation we have our own cpp layer and above this we C# layer

Nice!

In the system we ENV with around 100 computers and ~500 processes that uses DDS.

That's a pretty substantial system that I may not even be able to reproduce.

during the system run we create 20 partition - each partition has a round 20-25 processes
we experiencing the following issues:

1. on system star - we have some application that responsible to launch all applications and have watchdog on them to restart them if they crush - when we start all our applications we have a huge network burst on all out applications of around 50-100 MB/s

All those 500 processes will have to discover each other and all their readers/writers — that is: each of those 500 processes communicates with 499 other processes, asking for discovery information and acknowledging it. That happens mostly at the same time. With that, I would expect a large burst, but I'm afraid I can't say whether 50-100MB/s is reasonable.

One thing is the amount of data that has to be sent (participant discovery, endpoint discovery, heartbeats, acknowledgements), and this can be estimated fairly easily. Then there is the potential message loss:

• in the network with many hosts multicasting and interfering with each other, network switches may well start dropping packets (this can often be monitored on switches);
• in the socket receive buffer if the processes can't keep up with the burst of traffic that 499 processes can generate (on Linux this can be seen as UDP receive errors in Linux);
• internally in Cyclone when some buffers fill up, either because of packet loss before, or because the processing can't keep up (not easily observable).

No matter the reason, message loss will cause retransmits. Those retransmits will only add to the load and possibly cause further packet loss, so it can get "exciting". Cyclone is usually fairly well-behaved these days (including for the version you're using), but at this scale it might be different.

What would be interesting to know is how long 50-100MB/s burst lasts. If it is short, then I would not really consider it a problem; if it is longish, then there is probably massive packet loss that gets worse because of the retransmit requests. Less aggressive retransmitting would then likely be the solution (not sure yet if this specific scenario would be tunable right now).

2. then on every time we create a new partition (notifying the relevant applications to subscribe to a specific partition - nothing was happening on this partition before), we have the same burst of network

For each reader that gets created, the information is sent to all 499 peers (and acknowledged). If there are several readers created by each of those 20 processes in the partition, that's basically still a big burst. My first assumption is that this is simply a variant of the first.

3. after we have 15-16 partitions, the network use stays high - around ~50MB/s and even more on every app that uses DDS

After all readers/writers have been discovered and without application data, that should be all the traffic.

There should be some load because of all the "keep alive" messages from 500 processes, and the acknowledgements sent in response to one type of them. Default keep alive interval is 8s (IIRC) so a few hundred packets/s for keep-alives, but the ACKs to one type are 500 times that. You could try capturing a few seconds worth of those 50MB/s with Wireshark and look at the message types there (possibly graphing them): rtps.sm.id==0x15 (that's DATA) and rtps.sm.id==0x6 (ACKNACK).

If it is this keep-alive stuff, the painful type is only sent because I read the spec as requiring them, not because they are really necessary. Disabling in the code is pretty easy, but then you need to reduce Discovery/SPDPInterval, so there's no free lunch.

4. after we new partition we load a scenario on the system - basically start using the system and sending DDS samples - in one of the application, the memory use keep rising up and up - in some cases it riches to 45 GB - sometimes it stays steady on 1-2 GB of RAM

Hard to say how much would be needed ... 1GB seems like quite a lot to me, 45GB seems excessive. I know of a pathological case where memory use can grow a lot in combination with substantial packet loss. That can be tweaked away by reduce a buffer size inside Cyclone: setting Sizing/ReceiveBufferSize to 128kB and Sizing/ReceiveBufferChunkSize to 100kB should change that. (Or even smaller, but then I would also reduce General/MaxMessageSize.)

Apologies for not having a ready-made answer ...

[erezdamari-bagira]

Thanks for the detailed response.

That's a pretty substantial system that I may not even be able to reproduce.

what is the limitation of the CycloneDDS? can we grow to even more bigger environments from here?
Are there any other suggestions on how to handle that kind of system while keep using DDS?

Regarding your final suggestion, I didn't understand how REDUCING the buffer sizes would help the memory use issue?

One more point, we define our Topic in an .idl files and we have some project that parse those files and generate c# and cpp projects out of it with all the topics ready to use. I'm attaching here couple of the classes that are auto generated, it's long so you can focus on 1 or 2 topics.

IDL file

module Bagira
{
	module Dds
	{
		module Test
		{
		    // test comment for TestEnum
		    enum TestEnum // sameline for TestEnum
		    {
		        // comment for EnumVal1
		        EnumVal1,
		        // comment for EnumVal2
                @value(4294967295)
		        EnumVal2 // big integer EnumVal2 (-1)
		    }; // this comments belong to nothing

		    // and this is isolated comment block so again it belongs nowhere

			struct PodStruct
			{
				float x; // a little float x
				// y - coordinate
				float y;
			};

		    struct NonPodStruct
		    {
		        string str1;
		    };

			struct TestMessage
			{
				
			    long int1;
				string string1;
			    PodStruct pod1;
			    NonPodStruct npod1; // structure with dynamic data
			    sequence<PodStruct> podSeq1;
				char staticCharArray1[70];
			   	string staticStringArray1[5];
			   	NonPodStruct staticNpodStructArray[2];
		        sequence<string> stringSeq;
		        sequence<long> intSeq;
		        sequence<char> charSeq;
		        sequence<boolean> boolSeq;
			    octet o1;
			    octet o2;
			    TestEnum enum1;
			};
			#pragma keylist TestMessage
			#pragma topic
			#pragma topic durability transient_local
			#pragma topic history keep_all 1
			#pragma topic reliability reliable

			struct TestInstance
			{
			    long Id;
			};
		    #pragma keylist TestInstance Id
			#pragma topic
                #pragma topic durability transient_local
                #pragma topic history keep_all 1
                #pragma topic reliability reliable

			struct SimpleTypesMessgae
			{
				float float1;
				long long1;
				string string1;
				octet octet1;
			};
			#pragma keylist SimpleTypesMessgae
			#pragma topic 
			#pragma topic durability transient_local
			#pragma topic history keep_all 1
			#pragma topic reliability reliable

			struct SequenceTypesMessage
			{
				sequence<string> stringSeq;
				sequence<long> intSeq;
				sequence<char> charSeq;
				sequence<boolean> boolSeq;
			};
			#pragma keylist SequenceTypesMessage
			#pragma topic 
                #pragma topic durability transient_local
                #pragma topic history keep_all 1
                #pragma topic reliability reliable

			struct ComplexTypesMessage
			{
				TestEnum enum1;
				SimpleTypesMessgae struct1;
				sequence<SimpleTypesMessgae> structsequence;
			};
			#pragma keylist ComplexTypesMessage 
			#pragma topic 
                #pragma topic durability transient_local
                #pragma topic history keep_all 1
                #pragma topic reliability reliable

		
			struct StructWithOptionalFields
			{
			    long longField;

			    @optional
				float optionalFloat;
			};


			struct OptionalFieldsMessage
			{
				@optional
				octet optionalByte;

				@optional
				long optionalInt;

				@optional
				boolean optionalBool;

				@optional
				float optionalFloat;

				@optional
				double optionalDouble;

				@optional
				TestEnum optionalEnum;

			    @optional
				PodStruct optionalPodStruct;

			    @optional
				NonPodStruct optionalNonPodStruct;

			    // intentionally NOT @optional!
				StructWithOptionalFields nonOptionalStructWithOptionalFields;

			    @optional
				StructWithOptionalFields optionalStructWithOptionalFields;

				// optional strings not safely supported - on C# side the nullptr is converted to en empty string
				//@optional
				//string optionalString;

				// optional sequences not supported - zero size sequence is a good enough alternative
				//@optional
				//sequence<SimpleTypesMessgae> optionalstructsequence;

				// optional arrays not supported - zero size array is a good enough alternative
				//@optional
				//char optionalCharArray[10];

			};
			#pragma keylist OptionalFieldsMessage
			#pragma topic 
            #pragma topic durability transient_local
            #pragma topic history keep_all 1
            #pragma topic reliability reliable
		};
	};
};

CS file

using System;
using System.Runtime.InteropServices;
using Bagira.Dds.Base;
using Bagira.Dds;

#pragma warning disable 612, 618 // [Obsolete] warnings

namespace Bagira
{

}


namespace Bagira.Dds
{

}


namespace Bagira.Dds.Test
{
    // test comment for TestEnum
    public enum TestEnum : uint // sameline for TestEnum
    {
    // comment for EnumVal1
        EnumVal1,
        EnumVal2 = 4294967295, // big integer EnumVal2 (-1)
    }



    public class PodStruct
    {
        public float x; // a little float x
    // y - coordinate
        public float y;
    }

    public class PodStructMarshaler
    {
        [StructLayout(LayoutKind.Sequential)]
        public struct PodStruct__
        {
            public float x;
            public float y;
        }

        public static void CopyIn( IntPtr to, PodStruct from )
        {
            var aux = new PodStruct__();
            CopyIn( ref aux, from );
            Marshal.StructureToPtr( aux, to, false );
        }

        public static void CopyIn( ref PodStruct__ to, PodStruct from )
        {
            if( from == null ) return;

            to.x = from.x;
            to.y = from.y;
        }

		public static void CopyInFree( IntPtr unmanagedDest )
        {
            var aux = Marshal.PtrToStructure<PodStruct__>( unmanagedDest );
            CopyInFree( ref aux );
        }

        public static void CopyInFree( ref PodStruct__ to )
        {
        }

        public static void CopyOut( ref PodStruct to, IntPtr from )
        {
            if( from == IntPtr.Zero ) return;
            var aux = Marshal.PtrToStructure<PodStruct__>( from );
            CopyOut( ref to, ref aux );
        }

        public static PodStruct FromNative( IntPtr from )
        {
            if( from == IntPtr.Zero ) return null;
            var to = new PodStruct();
            CopyOut( ref to, from );
            return to;
        }

        public static IntPtr ToNative( PodStruct sample )
        {
            if( sample == null ) return IntPtr.Zero;

            // alloc unmanaged memory for the sample
            var size = Marshal.SizeOf<PodStruct__>();
            IntPtr nativeSample = Bagira.Dds.Base.Native.StructAlloc( size );
            
            // copy managed sample to native memory
            CopyIn( nativeSample, sample );

            return nativeSample;
        }

        public static void FreeNative( IntPtr nativeSample )
        {
            if( nativeSample == IntPtr.Zero ) return;
              
            // clean the temporary unmanaged memory for the sample
            CopyInFree( nativeSample );
            Bagira.Dds.Base.Native.StructFree( nativeSample );
        }
        
        
        public static void CopyOut( ref PodStruct to, ref PodStruct__ from )
        {
            if( to == null ) to = new PodStruct();
            to.x = from.x;
            to.y = from.y;
        }
    }

    public class NonPodStruct
    {
        public string str1 = string.Empty;
    }

    public class NonPodStructMarshaler
    {
        [StructLayout(LayoutKind.Sequential)]
        public struct NonPodStruct__
        {
            public IntPtr str1;
        }

        public static void CopyIn( IntPtr to, NonPodStruct from )
        {
            var aux = new NonPodStruct__();
            CopyIn( ref aux, from );
            Marshal.StructureToPtr( aux, to, false );
        }

        public static void CopyIn( ref NonPodStruct__ to, NonPodStruct from )
        {
            if( from == null ) return;

            Bagira.Dds.Base.Native.StringCopyIn( ref to.str1, from.str1 );
        }

		public static void CopyInFree( IntPtr unmanagedDest )
        {
            var aux = Marshal.PtrToStructure<NonPodStruct__>( unmanagedDest );
            CopyInFree( ref aux );
        }

        public static void CopyInFree( ref NonPodStruct__ to )
        {
            Bagira.Dds.Base.Native.StringFree( ref to.str1 );
        }

        public static void CopyOut( ref NonPodStruct to, IntPtr from )
        {
            if( from == IntPtr.Zero ) return;
            var aux = Marshal.PtrToStructure<NonPodStruct__>( from );
            CopyOut( ref to, ref aux );
        }

        public static NonPodStruct FromNative( IntPtr from )
        {
            if( from == IntPtr.Zero ) return null;
            var to = new NonPodStruct();
            CopyOut( ref to, from );
            return to;
        }

        public static IntPtr ToNative( NonPodStruct sample )
        {
            if( sample == null ) return IntPtr.Zero;

            // alloc unmanaged memory for the sample
            var size = Marshal.SizeOf<NonPodStruct__>();
            IntPtr nativeSample = Bagira.Dds.Base.Native.StructAlloc( size );
            
            // copy managed sample to native memory
            CopyIn( nativeSample, sample );

            return nativeSample;
        }

        public static void FreeNative( IntPtr nativeSample )
        {
            if( nativeSample == IntPtr.Zero ) return;
              
            // clean the temporary unmanaged memory for the sample
            CopyInFree( nativeSample );
            Bagira.Dds.Base.Native.StructFree( nativeSample );
        }
        
        
        public static void CopyOut( ref NonPodStruct to, ref NonPodStruct__ from )
        {
            if( to == null ) to = new NonPodStruct();
            Bagira.Dds.Base.Native.StringCopyOut( ref to.str1, from.str1 );
        }
    }

    public class TestMessage:TopicBase
    {
        public int int1;
        public string string1 = string.Empty;
        public Bagira.Dds.Test.PodStruct pod1 = new Bagira.Dds.Test.PodStruct();
        public Bagira.Dds.Test.NonPodStruct npod1 = new Bagira.Dds.Test.NonPodStruct(); // structure with dynamic data
        public Bagira.Dds.Test.PodStruct[] podSeq1 = System.Array.Empty<Bagira.Dds.Test.PodStruct>();
        public char[] staticCharArray1 = new char[70];
        public string[] staticStringArray1 = new string[5];
        public Bagira.Dds.Test.NonPodStruct[] staticNpodStructArray = new Bagira.Dds.Test.NonPodStruct[2];
        public string[] stringSeq = System.Array.Empty<string>();
        public int[] intSeq = System.Array.Empty<int>();
        public char[] charSeq = System.Array.Empty<char>();
        public bool[] boolSeq = System.Array.Empty<bool>();
        public byte o1;
        public byte o2;
        public Bagira.Dds.Test.TestEnum enum1;
    }

    public class TestMessageMarshaler
    {
        [StructLayout(LayoutKind.Sequential)]
        public struct TestMessage__
        {
            public int int1;
            public IntPtr string1;
            public Bagira.Dds.Test.PodStructMarshaler.PodStruct__ pod1;
            public Bagira.Dds.Test.NonPodStructMarshaler.NonPodStruct__ npod1;
            public Bagira.Dds.Base.__Seq podSeq1;
            [MarshalAs(UnmanagedType.ByValArray, SizeConst = 70)]
            public char[] staticCharArray1;
            [MarshalAs(UnmanagedType.ByValArray, SizeConst = 5)]
            public IntPtr[] staticStringArray1;
            [MarshalAs(UnmanagedType.ByValArray, SizeConst = 2)]
            public Bagira.Dds.Test.NonPodStructMarshaler.NonPodStruct__[] staticNpodStructArray;
            public Bagira.Dds.Base.__Seq stringSeq;
            public Bagira.Dds.Base.__Seq intSeq;
            public Bagira.Dds.Base.__Seq charSeq;
            public Bagira.Dds.Base.__Seq boolSeq;
            public byte o1;
            public byte o2;
            public Bagira.Dds.Test.TestEnum enum1;
        }

        public static void CopyIn( IntPtr to, TestMessage from )
        {
            var aux = new TestMessage__();
            CopyIn( ref aux, from );
            Marshal.StructureToPtr( aux, to, false );
        }

        public static void CopyIn( ref TestMessage__ to, TestMessage from )
        {
            if( from == null ) return;

            to.int1 = from.int1;
            Bagira.Dds.Base.Native.StringCopyIn( ref to.string1, from.string1 );
            ;Bagira.Dds.Test.PodStructMarshaler.CopyIn( ref to.pod1, from.pod1 );
            ;Bagira.Dds.Test.NonPodStructMarshaler.CopyIn( ref to.npod1, from.npod1 );
            Bagira.Dds.Base.Native.StructSeqCopyIn( ref to.podSeq1, from.podSeq1, Marshal.SizeOf<Bagira.Dds.Test.PodStructMarshaler.PodStruct__>(), Bagira.Dds.Test.PodStructMarshaler.CopyIn );
             to.staticCharArray1 = from.staticCharArray1;
            Bagira.Dds.Base.Native.StringArrCopyIn( ref to.staticStringArray1, from.staticStringArray1, 5 );
            Bagira.Dds.Base.Native.StructArrCopyIn( ref to.staticNpodStructArray, from.staticNpodStructArray, 2, Marshal.SizeOf<Bagira.Dds.Test.NonPodStructMarshaler.NonPodStruct__>(), Bagira.Dds.Test.NonPodStructMarshaler.CopyIn );
            Bagira.Dds.Base.Native.StringSeqCopyIn( ref to.stringSeq, from.stringSeq );
            Bagira.Dds.Base.Native.PrimSeqCopyIn( ref to.intSeq, from.intSeq );
            Bagira.Dds.Base.Native.PrimSeqCopyIn( ref to.charSeq, from.charSeq );
            Bagira.Dds.Base.Native.PrimSeqCopyIn( ref to.boolSeq, from.boolSeq );
            to.o1 = from.o1;
            to.o2 = from.o2;
            to.enum1 = from.enum1;
        }

		public static void CopyInFree( IntPtr unmanagedDest )
        {
            var aux = Marshal.PtrToStructure<TestMessage__>( unmanagedDest );
            CopyInFree( ref aux );
        }

        public static void CopyInFree( ref TestMessage__ to )
        {
            Bagira.Dds.Base.Native.StringFree( ref to.string1 );
            ;Bagira.Dds.Test.PodStructMarshaler.CopyInFree( ref to.pod1 );
            ;Bagira.Dds.Test.NonPodStructMarshaler.CopyInFree( ref to.npod1 );
            Bagira.Dds.Base.Native.StructSeqCopyInFree( ref to.podSeq1, Marshal.SizeOf<Bagira.Dds.Test.PodStructMarshaler.PodStruct__>(), Bagira.Dds.Test.PodStructMarshaler.CopyInFree );
            Bagira.Dds.Base.Native.StringArrCopyInFree( to.staticStringArray1, 5 );
            Bagira.Dds.Base.Native.StructArrCopyInFree( to.staticNpodStructArray, 2, Marshal.SizeOf<Bagira.Dds.Test.NonPodStructMarshaler.NonPodStruct__>(), Bagira.Dds.Test.NonPodStructMarshaler.CopyInFree );
            Bagira.Dds.Base.Native.StringSeqCopyInFree( ref to.stringSeq );
            Bagira.Dds.Base.Native.PrimSeqCopyInFree( ref to.intSeq );
            Bagira.Dds.Base.Native.PrimSeqCopyInFree( ref to.charSeq );
            Bagira.Dds.Base.Native.PrimSeqCopyInFree( ref to.boolSeq );
        }

        public static void CopyOut( ref TestMessage to, IntPtr from )
        {
            if( from == IntPtr.Zero ) return;
            var aux = Marshal.PtrToStructure<TestMessage__>( from );
            CopyOut( ref to, ref aux );
        }

        public static TestMessage FromNative( IntPtr from )
        {
            if( from == IntPtr.Zero ) return null;
            var to = new TestMessage();
            CopyOut( ref to, from );
            return to;
        }

        public static IntPtr ToNative( TestMessage sample )
        {
            if( sample == null ) return IntPtr.Zero;

            // alloc unmanaged memory for the sample
            var size = Marshal.SizeOf<TestMessage__>();
            IntPtr nativeSample = Bagira.Dds.Base.Native.StructAlloc( size );
            
            // copy managed sample to native memory
            CopyIn( nativeSample, sample );

            return nativeSample;
        }

        public static void FreeNative( IntPtr nativeSample )
        {
            if( nativeSample == IntPtr.Zero ) return;
              
            // clean the temporary unmanaged memory for the sample
            CopyInFree( nativeSample );
            Bagira.Dds.Base.Native.StructFree( nativeSample );
        }
        
        
        public static void CopyOut( ref TestMessage to, ref TestMessage__ from )
        {
            if( to == null ) to = new TestMessage();
            to.int1 = from.int1;
            Bagira.Dds.Base.Native.StringCopyOut( ref to.string1, from.string1 );
            ;Bagira.Dds.Test.PodStructMarshaler.CopyOut( ref to.pod1, ref from.pod1 );
            ;Bagira.Dds.Test.NonPodStructMarshaler.CopyOut( ref to.npod1, ref from.npod1 );
            Bagira.Dds.Base.Native.StructSeqCopyOut( ref to.podSeq1, ref from.podSeq1, Marshal.SizeOf<Bagira.Dds.Test.PodStructMarshaler.PodStruct__>(), Bagira.Dds.Test.PodStructMarshaler.CopyOut );
            to.staticCharArray1 = from.staticCharArray1;
            Bagira.Dds.Base.Native.StringArrCopyOut( ref to.staticStringArray1, from.staticStringArray1, 5 );
            Bagira.Dds.Base.Native.StructArrCopyOut( ref to.staticNpodStructArray, from.staticNpodStructArray, 2, Marshal.SizeOf<Bagira.Dds.Test.NonPodStructMarshaler.NonPodStruct__>(), Bagira.Dds.Test.NonPodStructMarshaler.CopyOut );
            Bagira.Dds.Base.Native.StringSeqCopyOut( ref to.stringSeq, ref from.stringSeq );
            Bagira.Dds.Base.Native.PrimSeqCopyOut( ref to.intSeq, ref from.intSeq );
            Bagira.Dds.Base.Native.PrimSeqCopyOut( ref to.charSeq, ref from.charSeq );
            Bagira.Dds.Base.Native.PrimSeqCopyOut( ref to.boolSeq, ref from.boolSeq );
            to.o1 = from.o1;
            to.o2 = from.o2;
            to.enum1 = from.enum1;
        }
    }

    public class TestInstance:TopicBase
    {
        public int Id;
    }

    public class TestInstanceMarshaler
    {
        [StructLayout(LayoutKind.Sequential)]
        public struct TestInstance__
        {
            public int Id;
        }

        public static void CopyIn( IntPtr to, TestInstance from )
        {
            var aux = new TestInstance__();
            CopyIn( ref aux, from );
            Marshal.StructureToPtr( aux, to, false );
        }

        public static void CopyIn( ref TestInstance__ to, TestInstance from )
        {
            if( from == null ) return;

            to.Id = from.Id;
        }

		public static void CopyInFree( IntPtr unmanagedDest )
        {
            var aux = Marshal.PtrToStructure<TestInstance__>( unmanagedDest );
            CopyInFree( ref aux );
        }

        public static void CopyInFree( ref TestInstance__ to )
        {
        }

        public static void CopyOut( ref TestInstance to, IntPtr from )
        {
            if( from == IntPtr.Zero ) return;
            var aux = Marshal.PtrToStructure<TestInstance__>( from );
            CopyOut( ref to, ref aux );
        }

        public static TestInstance FromNative( IntPtr from )
        {
            if( from == IntPtr.Zero ) return null;
            var to = new TestInstance();
            CopyOut( ref to, from );
            return to;
        }

        public static IntPtr ToNative( TestInstance sample )
        {
            if( sample == null ) return IntPtr.Zero;

            // alloc unmanaged memory for the sample
            var size = Marshal.SizeOf<TestInstance__>();
            IntPtr nativeSample = Bagira.Dds.Base.Native.StructAlloc( size );
            
            // copy managed sample to native memory
            CopyIn( nativeSample, sample );

            return nativeSample;
        }

        public static void FreeNative( IntPtr nativeSample )
        {
            if( nativeSample == IntPtr.Zero ) return;
              
            // clean the temporary unmanaged memory for the sample
            CopyInFree( nativeSample );
            Bagira.Dds.Base.Native.StructFree( nativeSample );
        }
        
        
        public static void CopyOut( ref TestInstance to, ref TestInstance__ from )
        {
            if( to == null ) to = new TestInstance();
            to.Id = from.Id;
        }
    }

    public class SimpleTypesMessgae:TopicBase
    {
        public float float1;
        public int long1;
        public string string1 = string.Empty;
        public byte octet1;
    }

    public class SimpleTypesMessgaeMarshaler
    {
        [StructLayout(LayoutKind.Sequential)]
        public struct SimpleTypesMessgae__
        {
            public float float1;
            public int long1;
            public IntPtr string1;
            public byte octet1;
        }

        public static void CopyIn( IntPtr to, SimpleTypesMessgae from )
        {
            var aux = new SimpleTypesMessgae__();
            CopyIn( ref aux, from );
            Marshal.StructureToPtr( aux, to, false );
        }

        public static void CopyIn( ref SimpleTypesMessgae__ to, SimpleTypesMessgae from )
        {
            if( from == null ) return;

            to.float1 = from.float1;
            to.long1 = from.long1;
            Bagira.Dds.Base.Native.StringCopyIn( ref to.string1, from.string1 );
            to.octet1 = from.octet1;
        }

		public static void CopyInFree( IntPtr unmanagedDest )
        {
            var aux = Marshal.PtrToStructure<SimpleTypesMessgae__>( unmanagedDest );
            CopyInFree( ref aux );
        }

        public static void CopyInFree( ref SimpleTypesMessgae__ to )
        {
            Bagira.Dds.Base.Native.StringFree( ref to.string1 );
        }

        public static void CopyOut( ref SimpleTypesMessgae to, IntPtr from )
        {
            if( from == IntPtr.Zero ) return;
            var aux = Marshal.PtrToStructure<SimpleTypesMessgae__>( from );
            CopyOut( ref to, ref aux );
        }

        public static SimpleTypesMessgae FromNative( IntPtr from )
        {
            if( from == IntPtr.Zero ) return null;
            var to = new SimpleTypesMessgae();
            CopyOut( ref to, from );
            return to;
        }

        public static IntPtr ToNative( SimpleTypesMessgae sample )
        {
            if( sample == null ) return IntPtr.Zero;

            // alloc unmanaged memory for the sample
            var size = Marshal.SizeOf<SimpleTypesMessgae__>();
            IntPtr nativeSample = Bagira.Dds.Base.Native.StructAlloc( size );
            
            // copy managed sample to native memory
            CopyIn( nativeSample, sample );

            return nativeSample;
        }

        public static void FreeNative( IntPtr nativeSample )
        {
            if( nativeSample == IntPtr.Zero ) return;
              
            // clean the temporary unmanaged memory for the sample
            CopyInFree( nativeSample );
            Bagira.Dds.Base.Native.StructFree( nativeSample );
        }
        
        
        public static void CopyOut( ref SimpleTypesMessgae to, ref SimpleTypesMessgae__ from )
        {
            if( to == null ) to = new SimpleTypesMessgae();
            to.float1 = from.float1;
            to.long1 = from.long1;
            Bagira.Dds.Base.Native.StringCopyOut( ref to.string1, from.string1 );
            to.octet1 = from.octet1;
        }
    }

    public class SequenceTypesMessage:TopicBase
    {
        public string[] stringSeq = System.Array.Empty<string>();
        public int[] intSeq = System.Array.Empty<int>();
        public char[] charSeq = System.Array.Empty<char>();
        public bool[] boolSeq = System.Array.Empty<bool>();
    }

    public class SequenceTypesMessageMarshaler
    {
        [StructLayout(LayoutKind.Sequential)]
        public struct SequenceTypesMessage__
        {
            public Bagira.Dds.Base.__Seq stringSeq;
            public Bagira.Dds.Base.__Seq intSeq;
            public Bagira.Dds.Base.__Seq charSeq;
            public Bagira.Dds.Base.__Seq boolSeq;
        }

        public static void CopyIn( IntPtr to, SequenceTypesMessage from )
        {
            var aux = new SequenceTypesMessage__();
            CopyIn( ref aux, from );
            Marshal.StructureToPtr( aux, to, false );
        }

        public static void CopyIn( ref SequenceTypesMessage__ to, SequenceTypesMessage from )
        {
            if( from == null ) return;

            Bagira.Dds.Base.Native.StringSeqCopyIn( ref to.stringSeq, from.stringSeq );
            Bagira.Dds.Base.Native.PrimSeqCopyIn( ref to.intSeq, from.intSeq );
            Bagira.Dds.Base.Native.PrimSeqCopyIn( ref to.charSeq, from.charSeq );
            Bagira.Dds.Base.Native.PrimSeqCopyIn( ref to.boolSeq, from.boolSeq );
        }

		public static void CopyInFree( IntPtr unmanagedDest )
        {
            var aux = Marshal.PtrToStructure<SequenceTypesMessage__>( unmanagedDest );
            CopyInFree( ref aux );
        }

        public static void CopyInFree( ref SequenceTypesMessage__ to )
        {
            Bagira.Dds.Base.Native.StringSeqCopyInFree( ref to.stringSeq );
            Bagira.Dds.Base.Native.PrimSeqCopyInFree( ref to.intSeq );
            Bagira.Dds.Base.Native.PrimSeqCopyInFree( ref to.charSeq );
            Bagira.Dds.Base.Native.PrimSeqCopyInFree( ref to.boolSeq );
        }

        public static void CopyOut( ref SequenceTypesMessage to, IntPtr from )
        {
            if( from == IntPtr.Zero ) return;
            var aux = Marshal.PtrToStructure<SequenceTypesMessage__>( from );
            CopyOut( ref to, ref aux );
        }

        public static SequenceTypesMessage FromNative( IntPtr from )
        {
            if( from == IntPtr.Zero ) return null;
            var to = new SequenceTypesMessage();
            CopyOut( ref to, from );
            return to;
        }

        public static IntPtr ToNative( SequenceTypesMessage sample )
        {
            if( sample == null ) return IntPtr.Zero;

            // alloc unmanaged memory for the sample
            var size = Marshal.SizeOf<SequenceTypesMessage__>();
            IntPtr nativeSample = Bagira.Dds.Base.Native.StructAlloc( size );
            
            // copy managed sample to native memory
            CopyIn( nativeSample, sample );

            return nativeSample;
        }

        public static void FreeNative( IntPtr nativeSample )
        {
            if( nativeSample == IntPtr.Zero ) return;
              
            // clean the temporary unmanaged memory for the sample
            CopyInFree( nativeSample );
            Bagira.Dds.Base.Native.StructFree( nativeSample );
        }
        
        
        public static void CopyOut( ref SequenceTypesMessage to, ref SequenceTypesMessage__ from )
        {
            if( to == null ) to = new SequenceTypesMessage();
            Bagira.Dds.Base.Native.StringSeqCopyOut( ref to.stringSeq, ref from.stringSeq );
            Bagira.Dds.Base.Native.PrimSeqCopyOut( ref to.intSeq, ref from.intSeq );
            Bagira.Dds.Base.Native.PrimSeqCopyOut( ref to.charSeq, ref from.charSeq );
            Bagira.Dds.Base.Native.PrimSeqCopyOut( ref to.boolSeq, ref from.boolSeq );
        }
    }

    public class ComplexTypesMessage:TopicBase
    {
        public Bagira.Dds.Test.TestEnum enum1;
        public Bagira.Dds.Test.SimpleTypesMessgae struct1 = new Bagira.Dds.Test.SimpleTypesMessgae();
        public Bagira.Dds.Test.SimpleTypesMessgae[] structsequence = System.Array.Empty<Bagira.Dds.Test.SimpleTypesMessgae>();
    }

    public class ComplexTypesMessageMarshaler
    {
        [StructLayout(LayoutKind.Sequential)]
        public struct ComplexTypesMessage__
        {
            public Bagira.Dds.Test.TestEnum enum1;
            public Bagira.Dds.Test.SimpleTypesMessgaeMarshaler.SimpleTypesMessgae__ struct1;
            public Bagira.Dds.Base.__Seq structsequence;
        }

        public static void CopyIn( IntPtr to, ComplexTypesMessage from )
        {
            var aux = new ComplexTypesMessage__();
            CopyIn( ref aux, from );
            Marshal.StructureToPtr( aux, to, false );
        }

        public static void CopyIn( ref ComplexTypesMessage__ to, ComplexTypesMessage from )
        {
            if( from == null ) return;

            to.enum1 = from.enum1;
            ;Bagira.Dds.Test.SimpleTypesMessgaeMarshaler.CopyIn( ref to.struct1, from.struct1 );
            Bagira.Dds.Base.Native.StructSeqCopyIn( ref to.structsequence, from.structsequence, Marshal.SizeOf<Bagira.Dds.Test.SimpleTypesMessgaeMarshaler.SimpleTypesMessgae__>(), Bagira.Dds.Test.SimpleTypesMessgaeMarshaler.CopyIn );
        }

		public static void CopyInFree( IntPtr unmanagedDest )
        {
            var aux = Marshal.PtrToStructure<ComplexTypesMessage__>( unmanagedDest );
            CopyInFree( ref aux );
        }

        public static void CopyInFree( ref ComplexTypesMessage__ to )
        {
            ;Bagira.Dds.Test.SimpleTypesMessgaeMarshaler.CopyInFree( ref to.struct1 );
            Bagira.Dds.Base.Native.StructSeqCopyInFree( ref to.structsequence, Marshal.SizeOf<Bagira.Dds.Test.SimpleTypesMessgaeMarshaler.SimpleTypesMessgae__>(), Bagira.Dds.Test.SimpleTypesMessgaeMarshaler.CopyInFree );
        }

        public static void CopyOut( ref ComplexTypesMessage to, IntPtr from )
        {
            if( from == IntPtr.Zero ) return;
            var aux = Marshal.PtrToStructure<ComplexTypesMessage__>( from );
            CopyOut( ref to, ref aux );
        }

        public static ComplexTypesMessage FromNative( IntPtr from )
        {
            if( from == IntPtr.Zero ) return null;
            var to = new ComplexTypesMessage();
            CopyOut( ref to, from );
            return to;
        }

        public static IntPtr ToNative( ComplexTypesMessage sample )
        {
            if( sample == null ) return IntPtr.Zero;

            // alloc unmanaged memory for the sample
            var size = Marshal.SizeOf<ComplexTypesMessage__>();
            IntPtr nativeSample = Bagira.Dds.Base.Native.StructAlloc( size );
            
            // copy managed sample to native memory
            CopyIn( nativeSample, sample );

            return nativeSample;
        }

        public static void FreeNative( IntPtr nativeSample )
        {
            if( nativeSample == IntPtr.Zero ) return;
              
            // clean the temporary unmanaged memory for the sample
            CopyInFree( nativeSample );
            Bagira.Dds.Base.Native.StructFree( nativeSample );
        }
        
        
        public static void CopyOut( ref ComplexTypesMessage to, ref ComplexTypesMessage__ from )
        {
            if( to == null ) to = new ComplexTypesMessage();
            to.enum1 = from.enum1;
            ;Bagira.Dds.Test.SimpleTypesMessgaeMarshaler.CopyOut( ref to.struct1, ref from.struct1 );
            Bagira.Dds.Base.Native.StructSeqCopyOut( ref to.structsequence, ref from.structsequence, Marshal.SizeOf<Bagira.Dds.Test.SimpleTypesMessgaeMarshaler.SimpleTypesMessgae__>(), Bagira.Dds.Test.SimpleTypesMessgaeMarshaler.CopyOut );
        }
    }

    public class StructWithOptionalFields
    {
        public int longField;
        public float? optionalFloat;
    }

    public class StructWithOptionalFieldsMarshaler
    {
        [StructLayout(LayoutKind.Sequential)]
        public struct StructWithOptionalFields__
        {
            public int longField;
            public IntPtr optionalFloat; // nullable float
        }

        public static void CopyIn( IntPtr to, StructWithOptionalFields from )
        {
            var aux = new StructWithOptionalFields__();
            CopyIn( ref aux, from );
            Marshal.StructureToPtr( aux, to, false );
        }

        public static void CopyIn( ref StructWithOptionalFields__ to, StructWithOptionalFields from )
        {
            if( from == null ) return;

            to.longField = from.longField;
            to.optionalFloat = !from.optionalFloat.HasValue ? IntPtr.Zero : Bagira.Dds.Base.NullablePrimitiveMarshaler<float>.ToNative( from.optionalFloat.Value );
        }

		public static void CopyInFree( IntPtr unmanagedDest )
        {
            var aux = Marshal.PtrToStructure<StructWithOptionalFields__>( unmanagedDest );
            CopyInFree( ref aux );
        }

        public static void CopyInFree( ref StructWithOptionalFields__ to )
        {
        }

        public static void CopyOut( ref StructWithOptionalFields to, IntPtr from )
        {
            if( from == IntPtr.Zero ) return;
            var aux = Marshal.PtrToStructure<StructWithOptionalFields__>( from );
            CopyOut( ref to, ref aux );
        }

        public static StructWithOptionalFields FromNative( IntPtr from )
        {
            if( from == IntPtr.Zero ) return null;
            var to = new StructWithOptionalFields();
            CopyOut( ref to, from );
            return to;
        }

        public static IntPtr ToNative( StructWithOptionalFields sample )
        {
            if( sample == null ) return IntPtr.Zero;

            // alloc unmanaged memory for the sample
            var size = Marshal.SizeOf<StructWithOptionalFields__>();
            IntPtr nativeSample = Bagira.Dds.Base.Native.StructAlloc( size );
            
            // copy managed sample to native memory
            CopyIn( nativeSample, sample );

            return nativeSample;
        }

        public static void FreeNative( IntPtr nativeSample )
        {
            if( nativeSample == IntPtr.Zero ) return;
              
            // clean the temporary unmanaged memory for the sample
            CopyInFree( nativeSample );
            Bagira.Dds.Base.Native.StructFree( nativeSample );
        }
        
        
        public static void CopyOut( ref StructWithOptionalFields to, ref StructWithOptionalFields__ from )
        {
            if( to == null ) to = new StructWithOptionalFields();
            to.longField = from.longField;
            to.optionalFloat = from.optionalFloat == IntPtr.Zero ? (float?) null : Bagira.Dds.Base.NullablePrimitiveMarshaler<float>.FromNative( from.optionalFloat );
        }
    }

    public class OptionalFieldsMessage:TopicBase
    {
        public byte? optionalByte;
        public int? optionalInt;
        public bool? optionalBool;
        public float? optionalFloat;
        public double? optionalDouble;
        public Bagira.Dds.Test.TestEnum? optionalEnum;
        public Bagira.Dds.Test.PodStruct optionalPodStruct;
        public Bagira.Dds.Test.NonPodStruct optionalNonPodStruct;
    // intentionally NOT @optional!
        public Bagira.Dds.Test.StructWithOptionalFields nonOptionalStructWithOptionalFields = new Bagira.Dds.Test.StructWithOptionalFields();
        public Bagira.Dds.Test.StructWithOptionalFields optionalStructWithOptionalFields;
    }

    public class OptionalFieldsMessageMarshaler
    {
        [StructLayout(LayoutKind.Sequential)]
        public struct OptionalFieldsMessage__
        {
            public IntPtr optionalByte; // nullable byte
            public IntPtr optionalInt; // nullable int
            public IntPtr optionalBool; // nullable bool
            public IntPtr optionalFloat; // nullable float
            public IntPtr optionalDouble; // nullable double
            public IntPtr optionalEnum; // nullable Bagira.Dds.Test.TestEnum
            public IntPtr optionalPodStruct; // nullable Bagira.Dds.Test.PodStruct
            public IntPtr optionalNonPodStruct; // nullable Bagira.Dds.Test.NonPodStruct
            public Bagira.Dds.Test.StructWithOptionalFieldsMarshaler.StructWithOptionalFields__ nonOptionalStructWithOptionalFields;
            public IntPtr optionalStructWithOptionalFields; // nullable Bagira.Dds.Test.StructWithOptionalFields
        }

        public static void CopyIn( IntPtr to, OptionalFieldsMessage from )
        {
            var aux = new OptionalFieldsMessage__();
            CopyIn( ref aux, from );
            Marshal.StructureToPtr( aux, to, false );
        }

        public static void CopyIn( ref OptionalFieldsMessage__ to, OptionalFieldsMessage from )
        {
            if( from == null ) return;

            to.optionalByte = !from.optionalByte.HasValue ? IntPtr.Zero : Bagira.Dds.Base.NullablePrimitiveMarshaler<byte>.ToNative( from.optionalByte.Value );
            to.optionalInt = !from.optionalInt.HasValue ? IntPtr.Zero : Bagira.Dds.Base.NullablePrimitiveMarshaler<int>.ToNative( from.optionalInt.Value );
            to.optionalBool = !from.optionalBool.HasValue ? IntPtr.Zero : Bagira.Dds.Base.NullablePrimitiveMarshaler<sbyte>.ToNative( Convert.ToSByte(from.optionalBool.Value ));
            to.optionalFloat = !from.optionalFloat.HasValue ? IntPtr.Zero : Bagira.Dds.Base.NullablePrimitiveMarshaler<float>.ToNative( from.optionalFloat.Value );
            to.optionalDouble = !from.optionalDouble.HasValue ? IntPtr.Zero : Bagira.Dds.Base.NullablePrimitiveMarshaler<double>.ToNative( from.optionalDouble.Value );
            to.optionalEnum = !from.optionalEnum.HasValue ? IntPtr.Zero : Bagira.Dds.Base.NullableEnumMarshaler<Bagira.Dds.Test.TestEnum>.ToNative( from.optionalEnum.Value );
            ;to.optionalPodStruct = from.optionalPodStruct == null ? IntPtr.Zero : Bagira.Dds.Test.PodStructMarshaler.ToNative( from.optionalPodStruct );
            ;to.optionalNonPodStruct = from.optionalNonPodStruct == null ? IntPtr.Zero : Bagira.Dds.Test.NonPodStructMarshaler.ToNative( from.optionalNonPodStruct );
            ;Bagira.Dds.Test.StructWithOptionalFieldsMarshaler.CopyIn( ref to.nonOptionalStructWithOptionalFields, from.nonOptionalStructWithOptionalFields );
            ;to.optionalStructWithOptionalFields = from.optionalStructWithOptionalFields == null ? IntPtr.Zero : Bagira.Dds.Test.StructWithOptionalFieldsMarshaler.ToNative( from.optionalStructWithOptionalFields );
        }

		public static void CopyInFree( IntPtr unmanagedDest )
        {
            var aux = Marshal.PtrToStructure<OptionalFieldsMessage__>( unmanagedDest );
            CopyInFree( ref aux );
        }

        public static void CopyInFree( ref OptionalFieldsMessage__ to )
        {
            Bagira.Dds.Base.NullablePrimitiveMarshaler<sbyte>.FreeNative( to.optionalBool ); to.optionalBool = IntPtr.Zero;
            Bagira.Dds.Base.NullableEnumMarshaler<Bagira.Dds.Test.TestEnum>.FreeNative( to.optionalEnum ); to.optionalEnum = IntPtr.Zero;
            ;Bagira.Dds.Test.PodStructMarshaler.FreeNative( to.optionalPodStruct ); to.optionalPodStruct = IntPtr.Zero;
            ;Bagira.Dds.Test.NonPodStructMarshaler.FreeNative( to.optionalNonPodStruct ); to.optionalNonPodStruct = IntPtr.Zero;
            ;Bagira.Dds.Test.StructWithOptionalFieldsMarshaler.CopyInFree( ref to.nonOptionalStructWithOptionalFields );
            ;Bagira.Dds.Test.StructWithOptionalFieldsMarshaler.FreeNative( to.optionalStructWithOptionalFields ); to.optionalStructWithOptionalFields = IntPtr.Zero;
        }

        public static void CopyOut( ref OptionalFieldsMessage to, IntPtr from )
        {
            if( from == IntPtr.Zero ) return;
            var aux = Marshal.PtrToStructure<OptionalFieldsMessage__>( from );
            CopyOut( ref to, ref aux );
        }

        public static OptionalFieldsMessage FromNative( IntPtr from )
        {
            if( from == IntPtr.Zero ) return null;
            var to = new OptionalFieldsMessage();
            CopyOut( ref to, from );
            return to;
        }

        public static IntPtr ToNative( OptionalFieldsMessage sample )
        {
            if( sample == null ) return IntPtr.Zero;

            // alloc unmanaged memory for the sample
            var size = Marshal.SizeOf<OptionalFieldsMessage__>();
            IntPtr nativeSample = Bagira.Dds.Base.Native.StructAlloc( size );
            
            // copy managed sample to native memory
            CopyIn( nativeSample, sample );

            return nativeSample;
        }

        public static void FreeNative( IntPtr nativeSample )
        {
            if( nativeSample == IntPtr.Zero ) return;
              
            // clean the temporary unmanaged memory for the sample
            CopyInFree( nativeSample );
            Bagira.Dds.Base.Native.StructFree( nativeSample );
        }
        
        
        public static void CopyOut( ref OptionalFieldsMessage to, ref OptionalFieldsMessage__ from )
        {
            if( to == null ) to = new OptionalFieldsMessage();
            to.optionalByte = from.optionalByte == IntPtr.Zero ? (byte?) null : Bagira.Dds.Base.NullablePrimitiveMarshaler<byte>.FromNative( from.optionalByte );
            to.optionalInt = from.optionalInt == IntPtr.Zero ? (int?) null : Bagira.Dds.Base.NullablePrimitiveMarshaler<int>.FromNative( from.optionalInt );
            to.optionalBool = from.optionalBool == IntPtr.Zero ? (bool?) null : Convert.ToBoolean(Bagira.Dds.Base.NullablePrimitiveMarshaler<sbyte>.FromNative( from.optionalBool ));
            to.optionalFloat = from.optionalFloat == IntPtr.Zero ? (float?) null : Bagira.Dds.Base.NullablePrimitiveMarshaler<float>.FromNative( from.optionalFloat );
            to.optionalDouble = from.optionalDouble == IntPtr.Zero ? (double?) null : Bagira.Dds.Base.NullablePrimitiveMarshaler<double>.FromNative( from.optionalDouble );
            to.optionalEnum = from.optionalEnum == IntPtr.Zero ? (Bagira.Dds.Test.TestEnum?) null : Bagira.Dds.Base.NullableEnumMarshaler<Bagira.Dds.Test.TestEnum>.FromNative( from.optionalEnum );
            ;to.optionalPodStruct = from.optionalPodStruct == IntPtr.Zero ? null : Bagira.Dds.Test.PodStructMarshaler.FromNative( from.optionalPodStruct );
            ;to.optionalNonPodStruct = from.optionalNonPodStruct == IntPtr.Zero ? null : Bagira.Dds.Test.NonPodStructMarshaler.FromNative( from.optionalNonPodStruct );
            ;Bagira.Dds.Test.StructWithOptionalFieldsMarshaler.CopyOut( ref to.nonOptionalStructWithOptionalFields, ref from.nonOptionalStructWithOptionalFields );
            ;to.optionalStructWithOptionalFields = from.optionalStructWithOptionalFields == IntPtr.Zero ? null : Bagira.Dds.Test.StructWithOptionalFieldsMarshaler.FromNative( from.optionalStructWithOptionalFields );
        }
    }
}


  

namespace Bagira.Dds.Test
{
    public class TestMessageTopicSettings : Bagira.Dds.Base.TopicSettings
    {
        [DllImport(Bagira.Dds.DM.Test.InternalStatics.NativeDllPath)]
        private static extern IntPtr Bagira_Dds_Test_TestMessage_GetTopicSettings();

        public TestMessageTopicSettings()
            : base( Bagira_Dds_Test_TestMessage_GetTopicSettings() )
        {
        }

        public override Bagira.Dds.Base.TopicReader CreateReader() => new TestMessageReader();
        public override Bagira.Dds.Base.TopicWriter CreateWriter() => new TestMessageWriter();
        public override Bagira.Dds.Base.TopicBase FromNative( IntPtr sampleNative ) => Bagira.Dds.Test.TestMessageMarshaler.FromNative( sampleNative );
        public override IntPtr ToNative( Bagira.Dds.Base.TopicBase sample ) => Bagira.Dds.Test.TestMessageMarshaler.ToNative( sample as Bagira.Dds.Test.TestMessage );
        public override void FreeNative( IntPtr sampleNative ) => Bagira.Dds.Test.TestMessageMarshaler.FreeNative( sampleNative );
        public override System.Type SampleType => typeof( Bagira.Dds.Test.TestMessage );
    }

    public class TestMessageWriter : Bagira.Dds.Base.TopicWriter
    {
        
        public TestMessageWriter( ) : base( )
        {
      
        }
              
        public TestMessageWriter( Bagira.Dds.Participant participant, string partitionName=null )
            : base( participant, TopicSettings, partitionName )
        {
            
        }

        public override void Initialize(Participant participant)
        {
            base.Initialize(participant, TopicSettings, null);
        }

        
        public static IntPtr TopicSettings => Bagira_Dds_Test_TestMessage_GetTopicSettings();

        [DllImport(Bagira.Dds.DM.Test.InternalStatics.NativeDllPath)]
        private static extern IntPtr Bagira_Dds_Test_TestMessage_GetTopicSettings();

        protected static IntPtr ToNative( Bagira.Dds.Test.TestMessage sample )
        {
            return Bagira.Dds.Test.TestMessageMarshaler.ToNative( sample );
        }

        protected static void FreeNative( IntPtr nativeSample )
        {
            Bagira.Dds.Test.TestMessageMarshaler.FreeNative( nativeSample );
        }
        
        public override ReturnCode Write(TopicBase sample, bool dispose = false)
        {
            if (sample is Bagira.Dds.Test.TestMessage topic)
                return Write(topic, dispose);

            return ReturnCode.Error;
        }

        public Bagira.Dds.ReturnCode Write( Bagira.Dds.Test.TestMessage sample, bool dispose=false )
        {
            var nativeSample = ToNative( sample );
            var rc = base.Write( nativeSample, dispose );
            FreeNative( nativeSample );
            return rc;
        }

        public Bagira.Dds.InstanceHandle RegisterInstance( Bagira.Dds.Test.TestMessage sample )
        {
            var nativeSample = ToNative( sample );
            var instanceHandle = base.RegisterInstance( nativeSample );
            FreeNative( nativeSample );
            return instanceHandle;
        }

        public Bagira.Dds.ReturnCode UnregisterInstance( Bagira.Dds.Test.TestMessage sample )
        {
            var nativeSample = ToNative( sample );
            var instanceHandle = base.UnregisterInstance( nativeSample );
            FreeNative( nativeSample );
            return instanceHandle;
        }
    }


    public class TestMessageReader : Bagira.Dds.Base.TopicReader
    {
        public TestMessageReader( Bagira.Dds.Participant participant, Bagira.Dds.Base.DataListener listener=null, string partitionName=null )
            : base( participant, TopicSettings, listener, partitionName )
        {
            
        }
        
        public TestMessageReader() : base( )
        {
        
        }
        
        public static IntPtr TopicSettings => Bagira_Dds_Test_TestMessage_GetTopicSettings();

        public override void Initialize(Participant participant)
        {
            base.Initialize(participant, TopicSettings, null, null);
        }

        [DllImport(Bagira.Dds.DM.Test.InternalStatics.NativeDllPath)]
        private static extern IntPtr Bagira_Dds_Test_TestMessage_GetTopicSettings();

        protected static IntPtr ToNative( Bagira.Dds.Test.TestMessage sample )
        {
            return Bagira.Dds.Test.TestMessageMarshaler.ToNative( sample );
        }

        protected static void FreeNative( IntPtr nativeSample )
        {
            Bagira.Dds.Test.TestMessageMarshaler.FreeNative( nativeSample );
        }

        /// <summary>
        /// Takes one incoming sample, including disposed instances.
        /// Use if you want to handle keyed dds instances and/or if you need to handle different return codes.
        /// </summary>
        /// <remarks>
        /// You can check if instance is disposed by querying sampleInfo.InstanceState.
        /// The memory allocated for the content of the sample (strings, sequence buffers) needs to be released
        /// by calling ReturnLoan() before Take is called next time.
        /// </remarks>
        /// <returns>
        ///	ReturnCode.Ok (0) if the sample was succesfully taken.
        ///	Negative error code on error, for example:
        ///	ReturnCode.NoData if no sample is available.
        ///	</returns>
        /// <example>
        ///   while( reader.Take( out var sample, out var info ) == Dds.ReturnCode.Ok ))
        ///   {
        ///       if( info.InstanceState == InstanceStateKind.Alive )
        ///       {
        ///         ... process live instance of the sample
        ///       } 
        ///       if( info.InstanceState == InstanceStateKind.NotAliveDisposed )
        ///       {
        ///         ... process disposal of the sample's instance
        ///       } 
        ///       reader.ReturnLoan();
        ///   }
        public unsafe Bagira.Dds.ReturnCode Take( out Bagira.Dds.Test.TestMessage sample, out Bagira.Dds.SampleInfo sampleInfo )
        {
            const int MAX_SAMPLES = 1;
            var samples = new Bagira.Dds.Test.TestMessage[MAX_SAMPLES];
            var sampleInfos = new Bagira.Dds.SampleInfo[MAX_SAMPLES];
            int numSamplesRead;

            var rc = GetSamples(
              Bagira.Dds.TopicReaderAction.Take,
              ref samples,
              ref sampleInfos,
              MAX_SAMPLES,
              out numSamplesRead,
              Bagira.Dds.InstanceHandle.Nil
            );

            sample = samples[0];
            sampleInfo = sampleInfos[0];

            return rc;

        }

        /// <summary>
        /// Untyped version of Take to be used in generic code.
        /// </summary>
        /// <returns>same as for <see cref="Take" /></returns>
        public override ReturnCode Take(ref TopicBase sample, ref SampleInfo sampleInfo)
        {
            ReturnCode ret = ReturnCode.Error;
            if (sample is Bagira.Dds.Test.TestMessage data)
            {
              ret = Take(out data, out sampleInfo);
              sample = data;
              ReturnLoan();
            }

            return ret;
        }

        /// <summary>
        /// Reads or takes samples, optionally for given instance handle.
        /// Data and sample arrays are expected to be preallocated at least to maxSamples size.
        /// </summary>
        /// <returns>
        ///	ReturnCode.Ok (0) if at least one sample succesfully read.
        ///	Other value (negative) in case of other error, for example
        ///	ReturnCode.NoData if no sample is available.
        /// </returns>
        public unsafe Bagira.Dds.ReturnCode GetSamples(
			  Bagira.Dds.TopicReaderAction action,
            ref Bagira.Dds.Test.TestMessage[] samples,
            ref Bagira.Dds.SampleInfo[] sampleInfos,
            int maxSamples,
            out int numSamplesRead,
            Bagira.Dds.InstanceHandle instanceHandle,
            Bagira.Dds.SampleStateKind sampleStates = Bagira.Dds.SampleStateKind.Any,
            Bagira.Dds.ViewStateKind viewStates = Bagira.Dds.ViewStateKind.Any,
            Bagira.Dds.InstanceStateKind instanceStates = Bagira.Dds.InstanceStateKind.Any
            )
        {
            // init data arrays
            IntPtr[] tmp_nativeSamples = new IntPtr[maxSamples];
            for(int i=0; i < maxSamples; i++) sampleInfos[i] = new Bagira.Dds.SampleInfo();

            // get samples as unmanaged memory
            var result = base.GetSamples(
                action,
                ref tmp_nativeSamples,
                ref sampleInfos,
                maxSamples,
                out numSamplesRead,
                instanceHandle,
                sampleStates,
                viewStates,
                instanceStates );

            if( result == Bagira.Dds.ReturnCode.Ok )
            {
                // copy samples into managed memory
                for (int i = 0; i < numSamplesRead; i++)
                {
                  samples[i] = new Bagira.Dds.Test.TestMessage();
                  Bagira.Dds.Test.TestMessageMarshaler.CopyOut( ref samples[i], tmp_nativeSamples[i] );
                }
                
                // unmanaged sample memory no longer needed, should be freed by calling ReturnLoan()
            }

            return result;
        }

	    /// <summary>
	    /// Takes one incoming sample that is ALIVE. Skips DISPOSED saples. 
	    /// Use for polling plain mesages (keyless dds instances).
	    /// </summary>
        /// <remarks>
	    /// The memory allocated for the content of the sample (strings, sequence buffers) needs to be released
	    /// by calling ReturnLoan() before Take is called next time.
        /// </remarks>
        /// <returns>true if sample was read, otherwise false</returns>
        /// <example>
        ///   while( reader.TakeNextAlive( out var msg ) )
        ///   {
        ///       ... process the message here
        ///       reader.ReturnLoan();
        ///   }
        /// </example>
        public bool TakeNextAlive( out Bagira.Dds.Test.TestMessage sample )
        {
	        while(true)
	        {
		        if( Take( out sample, out var info ) != Bagira.Dds.ReturnCode.Ok )
			        return false;
				
		        if( info.InstanceState == Bagira.Dds.InstanceStateKind.Alive )
			        return true;
	        }
        }

        /// <summary>
        /// Finds an instance handle using the key fields from given sample.
        /// </summary>
        /// <returns>Instance handle if found, InstanceHandle.Nil if not found</returns>
        public Bagira.Dds.InstanceHandle LookupInstance( Bagira.Dds.Test.TestMessage sample )
        {
            var nativeSample = ToNative( sample );
            var instanceHandle = base.LookupInstance( nativeSample );
            FreeNative( nativeSample );
            return instanceHandle;
        }
  }
}


namespace Bagira.Dds.Test
{
    public class TestInstanceTopicSettings : Bagira.Dds.Base.TopicSettings
    {
        [DllImport(Bagira.Dds.DM.Test.InternalStatics.NativeDllPath)]
        private static extern IntPtr Bagira_Dds_Test_TestInstance_GetTopicSettings();

        public TestInstanceTopicSettings()
            : base( Bagira_Dds_Test_TestInstance_GetTopicSettings() )
        {
        }

        public override Bagira.Dds.Base.TopicReader CreateReader() => new TestInstanceReader();
        public override Bagira.Dds.Base.TopicWriter CreateWriter() => new TestInstanceWriter();
        public override Bagira.Dds.Base.TopicBase FromNative( IntPtr sampleNative ) => Bagira.Dds.Test.TestInstanceMarshaler.FromNative( sampleNative );
        public override IntPtr ToNative( Bagira.Dds.Base.TopicBase sample ) => Bagira.Dds.Test.TestInstanceMarshaler.ToNative( sample as Bagira.Dds.Test.TestInstance );
        public override void FreeNative( IntPtr sampleNative ) => Bagira.Dds.Test.TestInstanceMarshaler.FreeNative( sampleNative );
        public override System.Type SampleType => typeof( Bagira.Dds.Test.TestInstance );
    }

    public class TestInstanceWriter : Bagira.Dds.Base.TopicWriter
    {
        
        public TestInstanceWriter( ) : base( )
        {
      
        }
              
        public TestInstanceWriter( Bagira.Dds.Participant participant, string partitionName=null )
            : base( participant, TopicSettings, partitionName )
        {
            
        }

        public override void Initialize(Participant participant)
        {
            base.Initialize(participant, TopicSettings, null);
        }

        
        public static IntPtr TopicSettings => Bagira_Dds_Test_TestInstance_GetTopicSettings();

        [DllImport(Bagira.Dds.DM.Test.InternalStatics.NativeDllPath)]
        private static extern IntPtr Bagira_Dds_Test_TestInstance_GetTopicSettings();

        protected static IntPtr ToNative( Bagira.Dds.Test.TestInstance sample )
        {
            return Bagira.Dds.Test.TestInstanceMarshaler.ToNative( sample );
        }

        protected static void FreeNative( IntPtr nativeSample )
        {
            Bagira.Dds.Test.TestInstanceMarshaler.FreeNative( nativeSample );
        }
        
        public override ReturnCode Write(TopicBase sample, bool dispose = false)
        {
            if (sample is Bagira.Dds.Test.TestInstance topic)
                return Write(topic, dispose);

            return ReturnCode.Error;
        }

        public Bagira.Dds.ReturnCode Write( Bagira.Dds.Test.TestInstance sample, bool dispose=false )
        {
            var nativeSample = ToNative( sample );
            var rc = base.Write( nativeSample, dispose );
            FreeNative( nativeSample );
            return rc;
        }

        public Bagira.Dds.InstanceHandle RegisterInstance( Bagira.Dds.Test.TestInstance sample )
        {
            var nativeSample = ToNative( sample );
            var instanceHandle = base.RegisterInstance( nativeSample );
            FreeNative( nativeSample );
            return instanceHandle;
        }

        public Bagira.Dds.ReturnCode UnregisterInstance( Bagira.Dds.Test.TestInstance sample )
        {
            var nativeSample = ToNative( sample );
            var instanceHandle = base.UnregisterInstance( nativeSample );
            FreeNative( nativeSample );
            return instanceHandle;
        }
    }


    public class TestInstanceReader : Bagira.Dds.Base.TopicReader
    {
        public TestInstanceReader( Bagira.Dds.Participant participant, Bagira.Dds.Base.DataListener listener=null, string partitionName=null )
            : base( participant, TopicSettings, listener, partitionName )
        {
            
        }
        
        public TestInstanceReader() : base( )
        {
        
        }
        
        public static IntPtr TopicSettings => Bagira_Dds_Test_TestInstance_GetTopicSettings();

        public override void Initialize(Participant participant)
        {
            base.Initialize(participant, TopicSettings, null, null);
        }

        [DllImport(Bagira.Dds.DM.Test.InternalStatics.NativeDllPath)]
        private static extern IntPtr Bagira_Dds_Test_TestInstance_GetTopicSettings();

        protected static IntPtr ToNative( Bagira.Dds.Test.TestInstance sample )
        {
            return Bagira.Dds.Test.TestInstanceMarshaler.ToNative( sample );
        }

        protected static void FreeNative( IntPtr nativeSample )
        {
            Bagira.Dds.Test.TestInstanceMarshaler.FreeNative( nativeSample );
        }

        /// <summary>
        /// Takes one incoming sample, including disposed instances.
        /// Use if you want to handle keyed dds instances and/or if you need to handle different return codes.
        /// </summary>
        /// <remarks>
        /// You can check if instance is disposed by querying sampleInfo.InstanceState.
        /// The memory allocated for the content of the sample (strings, sequence buffers) needs to be released
        /// by calling ReturnLoan() before Take is called next time.
        /// </remarks>
        /// <returns>
        ///	ReturnCode.Ok (0) if the sample was succesfully taken.
        ///	Negative error code on error, for example:
        ///	ReturnCode.NoData if no sample is available.
        ///	</returns>
        /// <example>
        ///   while( reader.Take( out var sample, out var info ) == Dds.ReturnCode.Ok ))
        ///   {
        ///       if( info.InstanceState == InstanceStateKind.Alive )
        ///       {
        ///         ... process live instance of the sample
        ///       } 
        ///       if( info.InstanceState == InstanceStateKind.NotAliveDisposed )
        ///       {
        ///         ... process disposal of the sample's instance
        ///       } 
        ///       reader.ReturnLoan();
        ///   }
        public unsafe Bagira.Dds.ReturnCode Take( out Bagira.Dds.Test.TestInstance sample, out Bagira.Dds.SampleInfo sampleInfo )
        {
            const int MAX_SAMPLES = 1;
            var samples = new Bagira.Dds.Test.TestInstance[MAX_SAMPLES];
            var sampleInfos = new Bagira.Dds.SampleInfo[MAX_SAMPLES];
            int numSamplesRead;

            var rc = GetSamples(
              Bagira.Dds.TopicReaderAction.Take,
              ref samples,
              ref sampleInfos,
              MAX_SAMPLES,
              out numSamplesRead,
              Bagira.Dds.InstanceHandle.Nil
            );

            sample = samples[0];
            sampleInfo = sampleInfos[0];

            return rc;

        }

        /// <summary>
        /// Untyped version of Take to be used in generic code.
        /// </summary>
        /// <returns>same as for <see cref="Take" /></returns>
        public override ReturnCode Take(ref TopicBase sample, ref SampleInfo sampleInfo)
        {
            ReturnCode ret = ReturnCode.Error;
            if (sample is Bagira.Dds.Test.TestInstance data)
            {
              ret = Take(out data, out sampleInfo);
              sample = data;
              ReturnLoan();
            }

            return ret;
        }

        /// <summary>
        /// Reads or takes samples, optionally for given instance handle.
        /// Data and sample arrays are expected to be preallocated at least to maxSamples size.
        /// </summary>
        /// <returns>
        ///	ReturnCode.Ok (0) if at least one sample succesfully read.
        ///	Other value (negative) in case of other error, for example
        ///	ReturnCode.NoData if no sample is available.
        /// </returns>
        public unsafe Bagira.Dds.ReturnCode GetSamples(
			  Bagira.Dds.TopicReaderAction action,
            ref Bagira.Dds.Test.TestInstance[] samples,
            ref Bagira.Dds.SampleInfo[] sampleInfos,
            int maxSamples,
            out int numSamplesRead,
            Bagira.Dds.InstanceHandle instanceHandle,
            Bagira.Dds.SampleStateKind sampleStates = Bagira.Dds.SampleStateKind.Any,
            Bagira.Dds.ViewStateKind viewStates = Bagira.Dds.ViewStateKind.Any,
            Bagira.Dds.InstanceStateKind instanceStates = Bagira.Dds.InstanceStateKind.Any
            )
        {
            // init data arrays
            IntPtr[] tmp_nativeSamples = new IntPtr[maxSamples];
            for(int i=0; i < maxSamples; i++) sampleInfos[i] = new Bagira.Dds.SampleInfo();

            // get samples as unmanaged memory
            var result = base.GetSamples(
                action,
                ref tmp_nativeSamples,
                ref sampleInfos,
                maxSamples,
                out numSamplesRead,
                instanceHandle,
                sampleStates,
                viewStates,
                instanceStates );

            if( result == Bagira.Dds.ReturnCode.Ok )
            {
                // copy samples into managed memory
                for (int i = 0; i < numSamplesRead; i++)
                {
                  samples[i] = new Bagira.Dds.Test.TestInstance();
                  Bagira.Dds.Test.TestInstanceMarshaler.CopyOut( ref samples[i], tmp_nativeSamples[i] );
                }
                
                // unmanaged sample memory no longer needed, should be freed by calling ReturnLoan()
            }

            return result;
        }

	    /// <summary>
	    /// Takes one incoming sample that is ALIVE. Skips DISPOSED saples. 
	    /// Use for polling plain mesages (keyless dds instances).
	    /// </summary>
        /// <remarks>
	    /// The memory allocated for the content of the sample (strings, sequence buffers) needs to be released
	    /// by calling ReturnLoan() before Take is called next time.
        /// </remarks>
        /// <returns>true if sample was read, otherwise false</returns>
        /// <example>
        ///   while( reader.TakeNextAlive( out var msg ) )
        ///   {
        ///       ... process the message here
        ///       reader.ReturnLoan();
        ///   }
        /// </example>
        public bool TakeNextAlive( out Bagira.Dds.Test.TestInstance sample )
        {
	        while(true)
	        {
		        if( Take( out sample, out var info ) != Bagira.Dds.ReturnCode.Ok )
			        return false;
				
		        if( info.InstanceState == Bagira.Dds.InstanceStateKind.Alive )
			        return true;
	        }
        }

        /// <summary>
        /// Finds an instance handle using the key fields from given sample.
        /// </summary>
        /// <returns>Instance handle if found, InstanceHandle.Nil if not found</returns>
        public Bagira.Dds.InstanceHandle LookupInstance( Bagira.Dds.Test.TestInstance sample )
        {
            var nativeSample = ToNative( sample );
            var instanceHandle = base.LookupInstance( nativeSample );
            FreeNative( nativeSample );
            return instanceHandle;
        }
  }
}


namespace Bagira.Dds.Test
{
    public class SimpleTypesMessgaeTopicSettings : Bagira.Dds.Base.TopicSettings
    {
        [DllImport(Bagira.Dds.DM.Test.InternalStatics.NativeDllPath)]
        private static extern IntPtr Bagira_Dds_Test_SimpleTypesMessgae_GetTopicSettings();

        public SimpleTypesMessgaeTopicSettings()
            : base( Bagira_Dds_Test_SimpleTypesMessgae_GetTopicSettings() )
        {
        }

        public override Bagira.Dds.Base.TopicReader CreateReader() => new SimpleTypesMessgaeReader();
        public override Bagira.Dds.Base.TopicWriter CreateWriter() => new SimpleTypesMessgaeWriter();
        public override Bagira.Dds.Base.TopicBase FromNative( IntPtr sampleNative ) => Bagira.Dds.Test.SimpleTypesMessgaeMarshaler.FromNative( sampleNative );
        public override IntPtr ToNative( Bagira.Dds.Base.TopicBase sample ) => Bagira.Dds.Test.SimpleTypesMessgaeMarshaler.ToNative( sample as Bagira.Dds.Test.SimpleTypesMessgae );
        public override void FreeNative( IntPtr sampleNative ) => Bagira.Dds.Test.SimpleTypesMessgaeMarshaler.FreeNative( sampleNative );
        public override System.Type SampleType => typeof( Bagira.Dds.Test.SimpleTypesMessgae );
    }

    public class SimpleTypesMessgaeWriter : Bagira.Dds.Base.TopicWriter
    {
        
        public SimpleTypesMessgaeWriter( ) : base( )
        {
      
        }
              
        public SimpleTypesMessgaeWriter( Bagira.Dds.Participant participant, string partitionName=null )
            : base( participant, TopicSettings, partitionName )
        {
            
        }

        public override void Initialize(Participant participant)
        {
            base.Initialize(participant, TopicSettings, null);
        }

        
        public static IntPtr TopicSettings => Bagira_Dds_Test_SimpleTypesMessgae_GetTopicSettings();

        [DllImport(Bagira.Dds.DM.Test.InternalStatics.NativeDllPath)]
        private static extern IntPtr Bagira_Dds_Test_SimpleTypesMessgae_GetTopicSettings();

        protected static IntPtr ToNative( Bagira.Dds.Test.SimpleTypesMessgae sample )
        {
            return Bagira.Dds.Test.SimpleTypesMessgaeMarshaler.ToNative( sample );
        }

        protected static void FreeNative( IntPtr nativeSample )
        {
            Bagira.Dds.Test.SimpleTypesMessgaeMarshaler.FreeNative( nativeSample );
        }
        
        public override ReturnCode Write(TopicBase sample, bool dispose = false)
        {
            if (sample is Bagira.Dds.Test.SimpleTypesMessgae topic)
                return Write(topic, dispose);

            return ReturnCode.Error;
        }

        public Bagira.Dds.ReturnCode Write( Bagira.Dds.Test.SimpleTypesMessgae sample, bool dispose=false )
        {
            var nativeSample = ToNative( sample );
            var rc = base.Write( nativeSample, dispose );
            FreeNative( nativeSample );
            return rc;
        }

        public Bagira.Dds.InstanceHandle RegisterInstance( Bagira.Dds.Test.SimpleTypesMessgae sample )
        {
            var nativeSample = ToNative( sample );
            var instanceHandle = base.RegisterInstance( nativeSample );
            FreeNative( nativeSample );
            return instanceHandle;
        }

        public Bagira.Dds.ReturnCode UnregisterInstance( Bagira.Dds.Test.SimpleTypesMessgae sample )
        {
            var nativeSample = ToNative( sample );
            var instanceHandle = base.UnregisterInstance( nativeSample );
            FreeNative( nativeSample );
            return instanceHandle;
        }
    }


    public class SimpleTypesMessgaeReader : Bagira.Dds.Base.TopicReader
    {
        public SimpleTypesMessgaeReader( Bagira.Dds.Participant participant, Bagira.Dds.Base.DataListener listener=null, string partitionName=null )
            : base( participant, TopicSettings, listener, partitionName )
        {
            
        }
        
        public SimpleTypesMessgaeReader() : base( )
        {
        
        }
        
        public static IntPtr TopicSettings => Bagira_Dds_Test_SimpleTypesMessgae_GetTopicSettings();

        public override void Initialize(Participant participant)
        {
            base.Initialize(participant, TopicSettings, null, null);
        }

        [DllImport(Bagira.Dds.DM.Test.InternalStatics.NativeDllPath)]
        private static extern IntPtr Bagira_Dds_Test_SimpleTypesMessgae_GetTopicSettings();

        protected static IntPtr ToNative( Bagira.Dds.Test.SimpleTypesMessgae sample )
        {
            return Bagira.Dds.Test.SimpleTypesMessgaeMarshaler.ToNative( sample );
        }

        protected static void FreeNative( IntPtr nativeSample )
        {
            Bagira.Dds.Test.SimpleTypesMessgaeMarshaler.FreeNative( nativeSample );
        }

        /// <summary>
        /// Takes one incoming sample, including disposed instances.
        /// Use if you want to handle keyed dds instances and/or if you need to handle different return codes.
        /// </summary>
        /// <remarks>
        /// You can check if instance is disposed by querying sampleInfo.InstanceState.
        /// The memory allocated for the content of the sample (strings, sequence buffers) needs to be released
        /// by calling ReturnLoan() before Take is called next time.
        /// </remarks>
        /// <returns>
        ///	ReturnCode.Ok (0) if the sample was succesfully taken.
        ///	Negative error code on error, for example:
        ///	ReturnCode.NoData if no sample is available.
        ///	</returns>
        /// <example>
        ///   while( reader.Take( out var sample, out var info ) == Dds.ReturnCode.Ok ))
        ///   {
        ///       if( info.InstanceState == InstanceStateKind.Alive )
        ///       {
        ///         ... process live instance of the sample
        ///       } 
        ///       if( info.InstanceState == InstanceStateKind.NotAliveDisposed )
        ///       {
        ///         ... process disposal of the sample's instance
        ///       } 
        ///       reader.ReturnLoan();
        ///   }
        public unsafe Bagira.Dds.ReturnCode Take( out Bagira.Dds.Test.SimpleTypesMessgae sample, out Bagira.Dds.SampleInfo sampleInfo )
        {
            const int MAX_SAMPLES = 1;
            var samples = new Bagira.Dds.Test.SimpleTypesMessgae[MAX_SAMPLES];
            var sampleInfos = new Bagira.Dds.SampleInfo[MAX_SAMPLES];
            int numSamplesRead;

            var rc = GetSamples(
              Bagira.Dds.TopicReaderAction.Take,
              ref samples,
              ref sampleInfos,
              MAX_SAMPLES,
              out numSamplesRead,
              Bagira.Dds.InstanceHandle.Nil
            );

            sample = samples[0];
            sampleInfo = sampleInfos[0];

            return rc;

        }

        /// <summary>
        /// Untyped version of Take to be used in generic code.
        /// </summary>
        /// <returns>same as for <see cref="Take" /></returns>
        public override ReturnCode Take(ref TopicBase sample, ref SampleInfo sampleInfo)
        {
            ReturnCode ret = ReturnCode.Error;
            if (sample is Bagira.Dds.Test.SimpleTypesMessgae data)
            {
              ret = Take(out data, out sampleInfo);
              sample = data;
              ReturnLoan();
            }

            return ret;
        }

        /// <summary>
        /// Reads or takes samples, optionally for given instance handle.
        /// Data and sample arrays are expected to be preallocated at least to maxSamples size.
        /// </summary>
        /// <returns>
        ///	ReturnCode.Ok (0) if at least one sample succesfully read.
        ///	Other value (negative) in case of other error, for example
        ///	ReturnCode.NoData if no sample is available.
        /// </returns>
        public unsafe Bagira.Dds.ReturnCode GetSamples(
			  Bagira.Dds.TopicReaderAction action,
            ref Bagira.Dds.Test.SimpleTypesMessgae[] samples,
            ref Bagira.Dds.SampleInfo[] sampleInfos,
            int maxSamples,
            out int numSamplesRead,
            Bagira.Dds.InstanceHandle instanceHandle,
            Bagira.Dds.SampleStateKind sampleStates = Bagira.Dds.SampleStateKind.Any,
            Bagira.Dds.ViewStateKind viewStates = Bagira.Dds.ViewStateKind.Any,
            Bagira.Dds.InstanceStateKind instanceStates = Bagira.Dds.InstanceStateKind.Any
            )
        {
            // init data arrays
            IntPtr[] tmp_nativeSamples = new IntPtr[maxSamples];
            for(int i=0; i < maxSamples; i++) sampleInfos[i] = new Bagira.Dds.SampleInfo();

            // get samples as unmanaged memory
            var result = base.GetSamples(
                action,
                ref tmp_nativeSamples,
                ref sampleInfos,
                maxSamples,
                out numSamplesRead,
                instanceHandle,
                sampleStates,
                viewStates,
                instanceStates );

            if( result == Bagira.Dds.ReturnCode.Ok )
            {
                // copy samples into managed memory
                for (int i = 0; i < numSamplesRead; i++)
                {
                  samples[i] = new Bagira.Dds.Test.SimpleTypesMessgae();
                  Bagira.Dds.Test.SimpleTypesMessgaeMarshaler.CopyOut( ref samples[i], tmp_nativeSamples[i] );
                }
                
                // unmanaged sample memory no longer needed, should be freed by calling ReturnLoan()
            }

            return result;
        }

	    /// <summary>
	    /// Takes one incoming sample that is ALIVE. Skips DISPOSED saples. 
	    /// Use for polling plain mesages (keyless dds instances).
	    /// </summary>
        /// <remarks>
	    /// The memory allocated for the content of the sample (strings, sequence buffers) needs to be released
	    /// by calling ReturnLoan() before Take is called next time.
        /// </remarks>
        /// <returns>true if sample was read, otherwise false</returns>
        /// <example>
        ///   while( reader.TakeNextAlive( out var msg ) )
        ///   {
        ///       ... process the message here
        ///       reader.ReturnLoan();
        ///   }
        /// </example>
        public bool TakeNextAlive( out Bagira.Dds.Test.SimpleTypesMessgae sample )
        {
	        while(true)
	        {
		        if( Take( out sample, out var info ) != Bagira.Dds.ReturnCode.Ok )
			        return false;
				
		        if( info.InstanceState == Bagira.Dds.InstanceStateKind.Alive )
			        return true;
	        }
        }

        /// <summary>
        /// Finds an instance handle using the key fields from given sample.
        /// </summary>
        /// <returns>Instance handle if found, InstanceHandle.Nil if not found</returns>
        public Bagira.Dds.InstanceHandle LookupInstance( Bagira.Dds.Test.SimpleTypesMessgae sample )
        {
            var nativeSample = ToNative( sample );
            var instanceHandle = base.LookupInstance( nativeSample );
            FreeNative( nativeSample );
            return instanceHandle;
        }
  }
}


namespace Bagira.Dds.Test
{
    public class SequenceTypesMessageTopicSettings : Bagira.Dds.Base.TopicSettings
    {
        [DllImport(Bagira.Dds.DM.Test.InternalStatics.NativeDllPath)]
        private static extern IntPtr Bagira_Dds_Test_SequenceTypesMessage_GetTopicSettings();

        public SequenceTypesMessageTopicSettings()
            : base( Bagira_Dds_Test_SequenceTypesMessage_GetTopicSettings() )
        {
        }

        public override Bagira.Dds.Base.TopicReader CreateReader() => new SequenceTypesMessageReader();
        public override Bagira.Dds.Base.TopicWriter CreateWriter() => new SequenceTypesMessageWriter();
        public override Bagira.Dds.Base.TopicBase FromNative( IntPtr sampleNative ) => Bagira.Dds.Test.SequenceTypesMessageMarshaler.FromNative( sampleNative );
        public override IntPtr ToNative( Bagira.Dds.Base.TopicBase sample ) => Bagira.Dds.Test.SequenceTypesMessageMarshaler.ToNative( sample as Bagira.Dds.Test.SequenceTypesMessage );
        public override void FreeNative( IntPtr sampleNative ) => Bagira.Dds.Test.SequenceTypesMessageMarshaler.FreeNative( sampleNative );
        public override System.Type SampleType => typeof( Bagira.Dds.Test.SequenceTypesMessage );
    }

    public class SequenceTypesMessageWriter : Bagira.Dds.Base.TopicWriter
    {
        
        public SequenceTypesMessageWriter( ) : base( )
        {
      
        }
              
        public SequenceTypesMessageWriter( Bagira.Dds.Participant participant, string partitionName=null )
            : base( participant, TopicSettings, partitionName )
        {
            
        }

        public override void Initialize(Participant participant)
        {
            base.Initialize(participant, TopicSettings, null);
        }

        
        public static IntPtr TopicSettings => Bagira_Dds_Test_SequenceTypesMessage_GetTopicSettings();

        [DllImport(Bagira.Dds.DM.Test.InternalStatics.NativeDllPath)]
        private static extern IntPtr Bagira_Dds_Test_SequenceTypesMessage_GetTopicSettings();

        protected static IntPtr ToNative( Bagira.Dds.Test.SequenceTypesMessage sample )
        {
            return Bagira.Dds.Test.SequenceTypesMessageMarshaler.ToNative( sample );
        }

        protected static void FreeNative( IntPtr nativeSample )
        {
            Bagira.Dds.Test.SequenceTypesMessageMarshaler.FreeNative( nativeSample );
        }
        
        public override ReturnCode Write(TopicBase sample, bool dispose = false)
        {
            if (sample is Bagira.Dds.Test.SequenceTypesMessage topic)
                return Write(topic, dispose);

            return ReturnCode.Error;
        }

        public Bagira.Dds.ReturnCode Write( Bagira.Dds.Test.SequenceTypesMessage sample, bool dispose=false )
        {
            var nativeSample = ToNative( sample );
            var rc = base.Write( nativeSample, dispose );
            FreeNative( nativeSample );
            return rc;
        }

        public Bagira.Dds.InstanceHandle RegisterInstance( Bagira.Dds.Test.SequenceTypesMessage sample )
        {
            var nativeSample = ToNative( sample );
            var instanceHandle = base.RegisterInstance( nativeSample );
            FreeNative( nativeSample );
            return instanceHandle;
        }

        public Bagira.Dds.ReturnCode UnregisterInstance( Bagira.Dds.Test.SequenceTypesMessage sample )
        {
            var nativeSample = ToNative( sample );
            var instanceHandle = base.UnregisterInstance( nativeSample );
            FreeNative( nativeSample );
            return instanceHandle;
        }
    }


    public class SequenceTypesMessageReader : Bagira.Dds.Base.TopicReader
    {
        public SequenceTypesMessageReader( Bagira.Dds.Participant participant, Bagira.Dds.Base.DataListener listener=null, string partitionName=null )
            : base( participant, TopicSettings, listener, partitionName )
        {
            
        }
        
        public SequenceTypesMessageReader() : base( )
        {
        
        }
        
        public static IntPtr TopicSettings => Bagira_Dds_Test_SequenceTypesMessage_GetTopicSettings();

        public override void Initialize(Participant participant)
        {
            base.Initialize(participant, TopicSettings, null, null);
        }

        [DllImport(Bagira.Dds.DM.Test.InternalStatics.NativeDllPath)]
        private static extern IntPtr Bagira_Dds_Test_SequenceTypesMessage_GetTopicSettings();

        protected static IntPtr ToNative( Bagira.Dds.Test.SequenceTypesMessage sample )
        {
            return Bagira.Dds.Test.SequenceTypesMessageMarshaler.ToNative( sample );
        }

        protected static void FreeNative( IntPtr nativeSample )
        {
            Bagira.Dds.Test.SequenceTypesMessageMarshaler.FreeNative( nativeSample );
        }

        /// <summary>
        /// Takes one incoming sample, including disposed instances.
        /// Use if you want to handle keyed dds instances and/or if you need to handle different return codes.
        /// </summary>
        /// <remarks>
        /// You can check if instance is disposed by querying sampleInfo.InstanceState.
        /// The memory allocated for the content of the sample (strings, sequence buffers) needs to be released
        /// by calling ReturnLoan() before Take is called next time.
        /// </remarks>
        /// <returns>
        ///	ReturnCode.Ok (0) if the sample was succesfully taken.
        ///	Negative error code on error, for example:
        ///	ReturnCode.NoData if no sample is available.
        ///	</returns>
        /// <example>
        ///   while( reader.Take( out var sample, out var info ) == Dds.ReturnCode.Ok ))
        ///   {
        ///       if( info.InstanceState == InstanceStateKind.Alive )
        ///       {
        ///         ... process live instance of the sample
        ///       } 
        ///       if( info.InstanceState == InstanceStateKind.NotAliveDisposed )
        ///       {
        ///         ... process disposal of the sample's instance
        ///       } 
        ///       reader.ReturnLoan();
        ///   }
        public unsafe Bagira.Dds.ReturnCode Take( out Bagira.Dds.Test.SequenceTypesMessage sample, out Bagira.Dds.SampleInfo sampleInfo )
        {
            const int MAX_SAMPLES = 1;
            var samples = new Bagira.Dds.Test.SequenceTypesMessage[MAX_SAMPLES];
            var sampleInfos = new Bagira.Dds.SampleInfo[MAX_SAMPLES];
            int numSamplesRead;

            var rc = GetSamples(
              Bagira.Dds.TopicReaderAction.Take,
              ref samples,
              ref sampleInfos,
              MAX_SAMPLES,
              out numSamplesRead,
              Bagira.Dds.InstanceHandle.Nil
            );

            sample = samples[0];
            sampleInfo = sampleInfos[0];

            return rc;

        }

        /// <summary>
        /// Untyped version of Take to be used in generic code.
        /// </summary>
        /// <returns>same as for <see cref="Take" /></returns>
        public override ReturnCode Take(ref TopicBase sample, ref SampleInfo sampleInfo)
        {
            ReturnCode ret = ReturnCode.Error;
            if (sample is Bagira.Dds.Test.SequenceTypesMessage data)
            {
              ret = Take(out data, out sampleInfo);
              sample = data;
              ReturnLoan();
            }

            return ret;
        }

        /// <summary>
        /// Reads or takes samples, optionally for given instance handle.
        /// Data and sample arrays are expected to be preallocated at least to maxSamples size.
        /// </summary>
        /// <returns>
        ///	ReturnCode.Ok (0) if at least one sample succesfully read.
        ///	Other value (negative) in case of other error, for example
        ///	ReturnCode.NoData if no sample is available.
        /// </returns>
        public unsafe Bagira.Dds.ReturnCode GetSamples(
			  Bagira.Dds.TopicReaderAction action,
            ref Bagira.Dds.Test.SequenceTypesMessage[] samples,
            ref Bagira.Dds.SampleInfo[] sampleInfos,
            int maxSamples,
            out int numSamplesRead,
            Bagira.Dds.InstanceHandle instanceHandle,
            Bagira.Dds.SampleStateKind sampleStates = Bagira.Dds.SampleStateKind.Any,
            Bagira.Dds.ViewStateKind viewStates = Bagira.Dds.ViewStateKind.Any,
            Bagira.Dds.InstanceStateKind instanceStates = Bagira.Dds.InstanceStateKind.Any
            )
        {
            // init data arrays
            IntPtr[] tmp_nativeSamples = new IntPtr[maxSamples];
            for(int i=0; i < maxSamples; i++) sampleInfos[i] = new Bagira.Dds.SampleInfo();

            // get samples as unmanaged memory
            var result = base.GetSamples(
                action,
                ref tmp_nativeSamples,
                ref sampleInfos,
                maxSamples,
                out numSamplesRead,
                instanceHandle,
                sampleStates,
                viewStates,
                instanceStates );

            if( result == Bagira.Dds.ReturnCode.Ok )
            {
                // copy samples into managed memory
                for (int i = 0; i < numSamplesRead; i++)
                {
                  samples[i] = new Bagira.Dds.Test.SequenceTypesMessage();
                  Bagira.Dds.Test.SequenceTypesMessageMarshaler.CopyOut( ref samples[i], tmp_nativeSamples[i] );
                }
                
                // unmanaged sample memory no longer needed, should be freed by calling ReturnLoan()
            }

            return result;
        }

	    /// <summary>
	    /// Takes one incoming sample that is ALIVE. Skips DISPOSED saples. 
	    /// Use for polling plain mesages (keyless dds instances).
	    /// </summary>
        /// <remarks>
	    /// The memory allocated for the content of the sample (strings, sequence buffers) needs to be released
	    /// by calling ReturnLoan() before Take is called next time.
        /// </remarks>
        /// <returns>true if sample was read, otherwise false</returns>
        /// <example>
        ///   while( reader.TakeNextAlive( out var msg ) )
        ///   {
        ///       ... process the message here
        ///       reader.ReturnLoan();
        ///   }
        /// </example>
        public bool TakeNextAlive( out Bagira.Dds.Test.SequenceTypesMessage sample )
        {
	        while(true)
	        {
		        if( Take( out sample, out var info ) != Bagira.Dds.ReturnCode.Ok )
			        return false;
				
		        if( info.InstanceState == Bagira.Dds.InstanceStateKind.Alive )
			        return true;
	        }
        }

        /// <summary>
        /// Finds an instance handle using the key fields from given sample.
        /// </summary>
        /// <returns>Instance handle if found, InstanceHandle.Nil if not found</returns>
        public Bagira.Dds.InstanceHandle LookupInstance( Bagira.Dds.Test.SequenceTypesMessage sample )
        {
            var nativeSample = ToNative( sample );
            var instanceHandle = base.LookupInstance( nativeSample );
            FreeNative( nativeSample );
            return instanceHandle;
        }
  }
}


namespace Bagira.Dds.Test
{
    public class ComplexTypesMessageTopicSettings : Bagira.Dds.Base.TopicSettings
    {
        [DllImport(Bagira.Dds.DM.Test.InternalStatics.NativeDllPath)]
        private static extern IntPtr Bagira_Dds_Test_ComplexTypesMessage_GetTopicSettings();

        public ComplexTypesMessageTopicSettings()
            : base( Bagira_Dds_Test_ComplexTypesMessage_GetTopicSettings() )
        {
        }

        public override Bagira.Dds.Base.TopicReader CreateReader() => new ComplexTypesMessageReader();
        public override Bagira.Dds.Base.TopicWriter CreateWriter() => new ComplexTypesMessageWriter();
        public override Bagira.Dds.Base.TopicBase FromNative( IntPtr sampleNative ) => Bagira.Dds.Test.ComplexTypesMessageMarshaler.FromNative( sampleNative );
        public override IntPtr ToNative( Bagira.Dds.Base.TopicBase sample ) => Bagira.Dds.Test.ComplexTypesMessageMarshaler.ToNative( sample as Bagira.Dds.Test.ComplexTypesMessage );
        public override void FreeNative( IntPtr sampleNative ) => Bagira.Dds.Test.ComplexTypesMessageMarshaler.FreeNative( sampleNative );
        public override System.Type SampleType => typeof( Bagira.Dds.Test.ComplexTypesMessage );
    }

    public class ComplexTypesMessageWriter : Bagira.Dds.Base.TopicWriter
    {
        
        public ComplexTypesMessageWriter( ) : base( )
        {
      
        }
              
        public ComplexTypesMessageWriter( Bagira.Dds.Participant participant, string partitionName=null )
            : base( participant, TopicSettings, partitionName )
        {
            
        }

        public override void Initialize(Participant participant)
        {
            base.Initialize(participant, TopicSettings, null);
        }

        
        public static IntPtr TopicSettings => Bagira_Dds_Test_ComplexTypesMessage_GetTopicSettings();

        [DllImport(Bagira.Dds.DM.Test.InternalStatics.NativeDllPath)]
        private static extern IntPtr Bagira_Dds_Test_ComplexTypesMessage_GetTopicSettings();

        protected static IntPtr ToNative( Bagira.Dds.Test.ComplexTypesMessage sample )
        {
            return Bagira.Dds.Test.ComplexTypesMessageMarshaler.ToNative( sample );
        }

        protected static void FreeNative( IntPtr nativeSample )
        {
            Bagira.Dds.Test.ComplexTypesMessageMarshaler.FreeNative( nativeSample );
        }
        
        public override ReturnCode Write(TopicBase sample, bool dispose = false)
        {
            if (sample is Bagira.Dds.Test.ComplexTypesMessage topic)
                return Write(topic, dispose);

            return ReturnCode.Error;
        }

        public Bagira.Dds.ReturnCode Write( Bagira.Dds.Test.ComplexTypesMessage sample, bool dispose=false )
        {
            var nativeSample = ToNative( sample );
            var rc = base.Write( nativeSample, dispose );
            FreeNative( nativeSample );
            return rc;
        }

        public Bagira.Dds.InstanceHandle RegisterInstance( Bagira.Dds.Test.ComplexTypesMessage sample )
        {
            var nativeSample = ToNative( sample );
            var instanceHandle = base.RegisterInstance( nativeSample );
            FreeNative( nativeSample );
            return instanceHandle;
        }

        public Bagira.Dds.ReturnCode UnregisterInstance( Bagira.Dds.Test.ComplexTypesMessage sample )
        {
            var nativeSample = ToNative( sample );
            var instanceHandle = base.UnregisterInstance( nativeSample );
            FreeNative( nativeSample );
            return instanceHandle;
        }
    }


    public class ComplexTypesMessageReader : Bagira.Dds.Base.TopicReader
    {
        public ComplexTypesMessageReader( Bagira.Dds.Participant participant, Bagira.Dds.Base.DataListener listener=null, string partitionName=null )
            : base( participant, TopicSettings, listener, partitionName )
        {
            
        }
        
        public ComplexTypesMessageReader() : base( )
        {
        
        }
        
        public static IntPtr TopicSettings => Bagira_Dds_Test_ComplexTypesMessage_GetTopicSettings();

        public override void Initialize(Participant participant)
        {
            base.Initialize(participant, TopicSettings, null, null);
        }

        [DllImport(Bagira.Dds.DM.Test.InternalStatics.NativeDllPath)]
        private static extern IntPtr Bagira_Dds_Test_ComplexTypesMessage_GetTopicSettings();

        protected static IntPtr ToNative( Bagira.Dds.Test.ComplexTypesMessage sample )
        {
            return Bagira.Dds.Test.ComplexTypesMessageMarshaler.ToNative( sample );
        }

        protected static void FreeNative( IntPtr nativeSample )
        {
            Bagira.Dds.Test.ComplexTypesMessageMarshaler.FreeNative( nativeSample );
        }

        /// <summary>
        /// Takes one incoming sample, including disposed instances.
        /// Use if you want to handle keyed dds instances and/or if you need to handle different return codes.
        /// </summary>
        /// <remarks>
        /// You can check if instance is disposed by querying sampleInfo.InstanceState.
        /// The memory allocated for the content of the sample (strings, sequence buffers) needs to be released
        /// by calling ReturnLoan() before Take is called next time.
        /// </remarks>
        /// <returns>
        ///	ReturnCode.Ok (0) if the sample was succesfully taken.
        ///	Negative error code on error, for example:
        ///	ReturnCode.NoData if no sample is available.
        ///	</returns>
        /// <example>
        ///   while( reader.Take( out var sample, out var info ) == Dds.ReturnCode.Ok ))
        ///   {
        ///       if( info.InstanceState == InstanceStateKind.Alive )
        ///       {
        ///         ... process live instance of the sample
        ///       } 
        ///       if( info.InstanceState == InstanceStateKind.NotAliveDisposed )
        ///       {
        ///         ... process disposal of the sample's instance
        ///       } 
        ///       reader.ReturnLoan();
        ///   }
        public unsafe Bagira.Dds.ReturnCode Take( out Bagira.Dds.Test.ComplexTypesMessage sample, out Bagira.Dds.SampleInfo sampleInfo )
        {
            const int MAX_SAMPLES = 1;
            var samples = new Bagira.Dds.Test.ComplexTypesMessage[MAX_SAMPLES];
            var sampleInfos = new Bagira.Dds.SampleInfo[MAX_SAMPLES];
            int numSamplesRead;

            var rc = GetSamples(
              Bagira.Dds.TopicReaderAction.Take,
              ref samples,
              ref sampleInfos,
              MAX_SAMPLES,
              out numSamplesRead,
              Bagira.Dds.InstanceHandle.Nil
            );

            sample = samples[0];
            sampleInfo = sampleInfos[0];

            return rc;

        }

        /// <summary>
        /// Untyped version of Take to be used in generic code.
        /// </summary>
        /// <returns>same as for <see cref="Take" /></returns>
        public override ReturnCode Take(ref TopicBase sample, ref SampleInfo sampleInfo)
        {
            ReturnCode ret = ReturnCode.Error;
            if (sample is Bagira.Dds.Test.ComplexTypesMessage data)
            {
              ret = Take(out data, out sampleInfo);
              sample = data;
              ReturnLoan();
            }

            return ret;
        }

        /// <summary>
        /// Reads or takes samples, optionally for given instance handle.
        /// Data and sample arrays are expected to be preallocated at least to maxSamples size.
        /// </summary>
        /// <returns>
        ///	ReturnCode.Ok (0) if at least one sample succesfully read.
        ///	Other value (negative) in case of other error, for example
        ///	ReturnCode.NoData if no sample is available.
        /// </returns>
        public unsafe Bagira.Dds.ReturnCode GetSamples(
			  Bagira.Dds.TopicReaderAction action,
            ref Bagira.Dds.Test.ComplexTypesMessage[] samples,
            ref Bagira.Dds.SampleInfo[] sampleInfos,
            int maxSamples,
            out int numSamplesRead,
            Bagira.Dds.InstanceHandle instanceHandle,
            Bagira.Dds.SampleStateKind sampleStates = Bagira.Dds.SampleStateKind.Any,
            Bagira.Dds.ViewStateKind viewStates = Bagira.Dds.ViewStateKind.Any,
            Bagira.Dds.InstanceStateKind instanceStates = Bagira.Dds.InstanceStateKind.Any
            )
        {
            // init data arrays
            IntPtr[] tmp_nativeSamples = new IntPtr[maxSamples];
            for(int i=0; i < maxSamples; i++) sampleInfos[i] = new Bagira.Dds.SampleInfo();

            // get samples as unmanaged memory
            var result = base.GetSamples(
                action,
                ref tmp_nativeSamples,
                ref sampleInfos,
                maxSamples,
                out numSamplesRead,
                instanceHandle,
                sampleStates,
                viewStates,
                instanceStates );

            if( result == Bagira.Dds.ReturnCode.Ok )
            {
                // copy samples into managed memory
                for (int i = 0; i < numSamplesRead; i++)
                {
                  samples[i] = new Bagira.Dds.Test.ComplexTypesMessage();
                  Bagira.Dds.Test.ComplexTypesMessageMarshaler.CopyOut( ref samples[i], tmp_nativeSamples[i] );
                }
                
                // unmanaged sample memory no longer needed, should be freed by calling ReturnLoan()
            }

            return result;
        }

	    /// <summary>
	    /// Takes one incoming sample that is ALIVE. Skips DISPOSED saples. 
	    /// Use for polling plain mesages (keyless dds instances).
	    /// </summary>
        /// <remarks>
	    /// The memory allocated for the content of the sample (strings, sequence buffers) needs to be released
	    /// by calling ReturnLoan() before Take is called next time.
        /// </remarks>
        /// <returns>true if sample was read, otherwise false</returns>
        /// <example>
        ///   while( reader.TakeNextAlive( out var msg ) )
        ///   {
        ///       ... process the message here
        ///       reader.ReturnLoan();
        ///   }
        /// </example>
        public bool TakeNextAlive( out Bagira.Dds.Test.ComplexTypesMessage sample )
        {
	        while(true)
	        {
		        if( Take( out sample, out var info ) != Bagira.Dds.ReturnCode.Ok )
			        return false;
				
		        if( info.InstanceState == Bagira.Dds.InstanceStateKind.Alive )
			        return true;
	        }
        }

        /// <summary>
        /// Finds an instance handle using the key fields from given sample.
        /// </summary>
        /// <returns>Instance handle if found, InstanceHandle.Nil if not found</returns>
        public Bagira.Dds.InstanceHandle LookupInstance( Bagira.Dds.Test.ComplexTypesMessage sample )
        {
            var nativeSample = ToNative( sample );
            var instanceHandle = base.LookupInstance( nativeSample );
            FreeNative( nativeSample );
            return instanceHandle;
        }
  }
}


namespace Bagira.Dds.Test
{
    public class OptionalFieldsMessageTopicSettings : Bagira.Dds.Base.TopicSettings
    {
        [DllImport(Bagira.Dds.DM.Test.InternalStatics.NativeDllPath)]
        private static extern IntPtr Bagira_Dds_Test_OptionalFieldsMessage_GetTopicSettings();

        public OptionalFieldsMessageTopicSettings()
            : base( Bagira_Dds_Test_OptionalFieldsMessage_GetTopicSettings() )
        {
        }

        public override Bagira.Dds.Base.TopicReader CreateReader() => new OptionalFieldsMessageReader();
        public override Bagira.Dds.Base.TopicWriter CreateWriter() => new OptionalFieldsMessageWriter();
        public override Bagira.Dds.Base.TopicBase FromNative( IntPtr sampleNative ) => Bagira.Dds.Test.OptionalFieldsMessageMarshaler.FromNative( sampleNative );
        public override IntPtr ToNative( Bagira.Dds.Base.TopicBase sample ) => Bagira.Dds.Test.OptionalFieldsMessageMarshaler.ToNative( sample as Bagira.Dds.Test.OptionalFieldsMessage );
        public override void FreeNative( IntPtr sampleNative ) => Bagira.Dds.Test.OptionalFieldsMessageMarshaler.FreeNative( sampleNative );
        public override System.Type SampleType => typeof( Bagira.Dds.Test.OptionalFieldsMessage );
    }

    public class OptionalFieldsMessageWriter : Bagira.Dds.Base.TopicWriter
    {
        
        public OptionalFieldsMessageWriter( ) : base( )
        {
      
        }
              
        public OptionalFieldsMessageWriter( Bagira.Dds.Participant participant, string partitionName=null )
            : base( participant, TopicSettings, partitionName )
        {
            
        }

        public override void Initialize(Participant participant)
        {
            base.Initialize(participant, TopicSettings, null);
        }

        
        public static IntPtr TopicSettings => Bagira_Dds_Test_OptionalFieldsMessage_GetTopicSettings();

        [DllImport(Bagira.Dds.DM.Test.InternalStatics.NativeDllPath)]
        private static extern IntPtr Bagira_Dds_Test_OptionalFieldsMessage_GetTopicSettings();

        protected static IntPtr ToNative( Bagira.Dds.Test.OptionalFieldsMessage sample )
        {
            return Bagira.Dds.Test.OptionalFieldsMessageMarshaler.ToNative( sample );
        }

        protected static void FreeNative( IntPtr nativeSample )
        {
            Bagira.Dds.Test.OptionalFieldsMessageMarshaler.FreeNative( nativeSample );
        }
        
        public override ReturnCode Write(TopicBase sample, bool dispose = false)
        {
            if (sample is Bagira.Dds.Test.OptionalFieldsMessage topic)
                return Write(topic, dispose);

            return ReturnCode.Error;
        }

        public Bagira.Dds.ReturnCode Write( Bagira.Dds.Test.OptionalFieldsMessage sample, bool dispose=false )
        {
            var nativeSample = ToNative( sample );
            var rc = base.Write( nativeSample, dispose );
            FreeNative( nativeSample );
            return rc;
        }

        public Bagira.Dds.InstanceHandle RegisterInstance( Bagira.Dds.Test.OptionalFieldsMessage sample )
        {
            var nativeSample = ToNative( sample );
            var instanceHandle = base.RegisterInstance( nativeSample );
            FreeNative( nativeSample );
            return instanceHandle;
        }

        public Bagira.Dds.ReturnCode UnregisterInstance( Bagira.Dds.Test.OptionalFieldsMessage sample )
        {
            var nativeSample = ToNative( sample );
            var instanceHandle = base.UnregisterInstance( nativeSample );
            FreeNative( nativeSample );
            return instanceHandle;
        }
    }


    public class OptionalFieldsMessageReader : Bagira.Dds.Base.TopicReader
    {
        public OptionalFieldsMessageReader( Bagira.Dds.Participant participant, Bagira.Dds.Base.DataListener listener=null, string partitionName=null )
            : base( participant, TopicSettings, listener, partitionName )
        {
            
        }
        
        public OptionalFieldsMessageReader() : base( )
        {
        
        }
        
        public static IntPtr TopicSettings => Bagira_Dds_Test_OptionalFieldsMessage_GetTopicSettings();

        public override void Initialize(Participant participant)
        {
            base.Initialize(participant, TopicSettings, null, null);
        }

        [DllImport(Bagira.Dds.DM.Test.InternalStatics.NativeDllPath)]
        private static extern IntPtr Bagira_Dds_Test_OptionalFieldsMessage_GetTopicSettings();

        protected static IntPtr ToNative( Bagira.Dds.Test.OptionalFieldsMessage sample )
        {
            return Bagira.Dds.Test.OptionalFieldsMessageMarshaler.ToNative( sample );
        }

        protected static void FreeNative( IntPtr nativeSample )
        {
            Bagira.Dds.Test.OptionalFieldsMessageMarshaler.FreeNative( nativeSample );
        }

        /// <summary>
        /// Takes one incoming sample, including disposed instances.
        /// Use if you want to handle keyed dds instances and/or if you need to handle different return codes.
        /// </summary>
        /// <remarks>
        /// You can check if instance is disposed by querying sampleInfo.InstanceState.
        /// The memory allocated for the content of the sample (strings, sequence buffers) needs to be released
        /// by calling ReturnLoan() before Take is called next time.
        /// </remarks>
        /// <returns>
        ///	ReturnCode.Ok (0) if the sample was succesfully taken.
        ///	Negative error code on error, for example:
        ///	ReturnCode.NoData if no sample is available.
        ///	</returns>
        /// <example>
        ///   while( reader.Take( out var sample, out var info ) == Dds.ReturnCode.Ok ))
        ///   {
        ///       if( info.InstanceState == InstanceStateKind.Alive )
        ///       {
        ///         ... process live instance of the sample
        ///       } 
        ///       if( info.InstanceState == InstanceStateKind.NotAliveDisposed )
        ///       {
        ///         ... process disposal of the sample's instance
        ///       } 
        ///       reader.ReturnLoan();
        ///   }
        public unsafe Bagira.Dds.ReturnCode Take( out Bagira.Dds.Test.OptionalFieldsMessage sample, out Bagira.Dds.SampleInfo sampleInfo )
        {
            const int MAX_SAMPLES = 1;
            var samples = new Bagira.Dds.Test.OptionalFieldsMessage[MAX_SAMPLES];
            var sampleInfos = new Bagira.Dds.SampleInfo[MAX_SAMPLES];
            int numSamplesRead;

            var rc = GetSamples(
              Bagira.Dds.TopicReaderAction.Take,
              ref samples,
              ref sampleInfos,
              MAX_SAMPLES,
              out numSamplesRead,
              Bagira.Dds.InstanceHandle.Nil
            );

            sample = samples[0];
            sampleInfo = sampleInfos[0];

            return rc;

        }

        /// <summary>
        /// Untyped version of Take to be used in generic code.
        /// </summary>
        /// <returns>same as for <see cref="Take" /></returns>
        public override ReturnCode Take(ref TopicBase sample, ref SampleInfo sampleInfo)
        {
            ReturnCode ret = ReturnCode.Error;
            if (sample is Bagira.Dds.Test.OptionalFieldsMessage data)
            {
              ret = Take(out data, out sampleInfo);
              sample = data;
              ReturnLoan();
            }

            return ret;
        }

        /// <summary>
        /// Reads or takes samples, optionally for given instance handle.
        /// Data and sample arrays are expected to be preallocated at least to maxSamples size.
        /// </summary>
        /// <returns>
        ///	ReturnCode.Ok (0) if at least one sample succesfully read.
        ///	Other value (negative) in case of other error, for example
        ///	ReturnCode.NoData if no sample is available.
        /// </returns>
        public unsafe Bagira.Dds.ReturnCode GetSamples(
			  Bagira.Dds.TopicReaderAction action,
            ref Bagira.Dds.Test.OptionalFieldsMessage[] samples,
            ref Bagira.Dds.SampleInfo[] sampleInfos,
            int maxSamples,
            out int numSamplesRead,
            Bagira.Dds.InstanceHandle instanceHandle,
            Bagira.Dds.SampleStateKind sampleStates = Bagira.Dds.SampleStateKind.Any,
            Bagira.Dds.ViewStateKind viewStates = Bagira.Dds.ViewStateKind.Any,
            Bagira.Dds.InstanceStateKind instanceStates = Bagira.Dds.InstanceStateKind.Any
            )
        {
            // init data arrays
            IntPtr[] tmp_nativeSamples = new IntPtr[maxSamples];
            for(int i=0; i < maxSamples; i++) sampleInfos[i] = new Bagira.Dds.SampleInfo();

            // get samples as unmanaged memory
            var result = base.GetSamples(
                action,
                ref tmp_nativeSamples,
                ref sampleInfos,
                maxSamples,
                out numSamplesRead,
                instanceHandle,
                sampleStates,
                viewStates,
                instanceStates );

            if( result == Bagira.Dds.ReturnCode.Ok )
            {
                // copy samples into managed memory
                for (int i = 0; i < numSamplesRead; i++)
                {
                  samples[i] = new Bagira.Dds.Test.OptionalFieldsMessage();
                  Bagira.Dds.Test.OptionalFieldsMessageMarshaler.CopyOut( ref samples[i], tmp_nativeSamples[i] );
                }
                
                // unmanaged sample memory no longer needed, should be freed by calling ReturnLoan()
            }

            return result;
        }

	    /// <summary>
	    /// Takes one incoming sample that is ALIVE. Skips DISPOSED saples. 
	    /// Use for polling plain mesages (keyless dds instances).
	    /// </summary>
        /// <remarks>
	    /// The memory allocated for the content of the sample (strings, sequence buffers) needs to be released
	    /// by calling ReturnLoan() before Take is called next time.
        /// </remarks>
        /// <returns>true if sample was read, otherwise false</returns>
        /// <example>
        ///   while( reader.TakeNextAlive( out var msg ) )
        ///   {
        ///       ... process the message here
        ///       reader.ReturnLoan();
        ///   }
        /// </example>
        public bool TakeNextAlive( out Bagira.Dds.Test.OptionalFieldsMessage sample )
        {
	        while(true)
	        {
		        if( Take( out sample, out var info ) != Bagira.Dds.ReturnCode.Ok )
			        return false;
				
		        if( info.InstanceState == Bagira.Dds.InstanceStateKind.Alive )
			        return true;
	        }
        }

        /// <summary>
        /// Finds an instance handle using the key fields from given sample.
        /// </summary>
        /// <returns>Instance handle if found, InstanceHandle.Nil if not found</returns>
        public Bagira.Dds.InstanceHandle LookupInstance( Bagira.Dds.Test.OptionalFieldsMessage sample )
        {
            var nativeSample = ToNative( sample );
            var instanceHandle = base.LookupInstance( nativeSample );
            FreeNative( nativeSample );
            return instanceHandle;
        }
  }
}

CPP file

#include "../Test.h"
#include "Test_cpp.h"
#include "Test_c.h"


namespace Bagira::Dds::Test
{
	TestMessageReader::TestMessageReader( ::Bagira::Dds::Participant* participant )
		: ::Bagira::Dds::Base::TopicReader(
			participant, 
			Bagira_Dds_Test_TestMessage_GetTopicSettings()
		)
	{
	}

	dds_return_t TestMessageReader::Take( Bagira_Dds_Test_TestMessage* sample, dds_sample_info* info )
	{
		Bagira_Dds_Test_TestMessage* samples[1];
		dds_sample_info_t infos[1];

		auto rc = GetSamples(
			::Bagira::Dds::Base::TopicReader::EAction::Take,
			(void**)samples,
			infos,
			1,
			0,
			(uint32_t)-1
		);

		if( rc > 0 )
		{
			// copy the resulting data to provided buffers
			*sample = *samples[0];
			*info = infos[0];

			return DDS_RETCODE_OK;
		}

		if( rc == 0 )
		{
			return DDS_RETCODE_NO_DATA;
		}

		return rc;
	}

	bool TestMessageReader::TakeNextAlive( Bagira_Dds_Test_TestMessage* sample )
	{
		dds_sample_info_t info;
		dds_return_t rc;
		while(true)
		{
			rc = Take( sample, &info );

			if( rc != DDS_RETCODE_OK )
				return false;
				
			if( info.instance_state == DDS_IST_ALIVE )
				return true;
		}
	}


	TestMessageWriter::TestMessageWriter( ::Bagira::Dds::Participant* participant )
		: ::Bagira::Dds::Base::TopicWriter(
			participant, 
			Bagira_Dds_Test_TestMessage_GetTopicSettings()
		)
	{
	}
		
	void TestMessageWriter::FreeSampleContent( Bagira_Dds_Test_TestMessage* sample )
	{
		dds_sample_free( sample, _topicSettings->descriptor, DDS_FREE_CONTENTS );
	}

}


namespace Bagira::Dds::Test
{
	TestInstanceReader::TestInstanceReader( ::Bagira::Dds::Participant* participant )
		: ::Bagira::Dds::Base::TopicReader(
			participant, 
			Bagira_Dds_Test_TestInstance_GetTopicSettings()
		)
	{
	}

	dds_return_t TestInstanceReader::Take( Bagira_Dds_Test_TestInstance* sample, dds_sample_info* info )
	{
		Bagira_Dds_Test_TestInstance* samples[1];
		dds_sample_info_t infos[1];

		auto rc = GetSamples(
			::Bagira::Dds::Base::TopicReader::EAction::Take,
			(void**)samples,
			infos,
			1,
			0,
			(uint32_t)-1
		);

		if( rc > 0 )
		{
			// copy the resulting data to provided buffers
			*sample = *samples[0];
			*info = infos[0];

			return DDS_RETCODE_OK;
		}

		if( rc == 0 )
		{
			return DDS_RETCODE_NO_DATA;
		}

		return rc;
	}

	bool TestInstanceReader::TakeNextAlive( Bagira_Dds_Test_TestInstance* sample )
	{
		dds_sample_info_t info;
		dds_return_t rc;
		while(true)
		{
			rc = Take( sample, &info );

			if( rc != DDS_RETCODE_OK )
				return false;
				
			if( info.instance_state == DDS_IST_ALIVE )
				return true;
		}
	}


	TestInstanceWriter::TestInstanceWriter( ::Bagira::Dds::Participant* participant )
		: ::Bagira::Dds::Base::TopicWriter(
			participant, 
			Bagira_Dds_Test_TestInstance_GetTopicSettings()
		)
	{
	}
		
	void TestInstanceWriter::FreeSampleContent( Bagira_Dds_Test_TestInstance* sample )
	{
		dds_sample_free( sample, _topicSettings->descriptor, DDS_FREE_CONTENTS );
	}

}


namespace Bagira::Dds::Test
{
	SimpleTypesMessgaeReader::SimpleTypesMessgaeReader( ::Bagira::Dds::Participant* participant )
		: ::Bagira::Dds::Base::TopicReader(
			participant, 
			Bagira_Dds_Test_SimpleTypesMessgae_GetTopicSettings()
		)
	{
	}

	dds_return_t SimpleTypesMessgaeReader::Take( Bagira_Dds_Test_SimpleTypesMessgae* sample, dds_sample_info* info )
	{
		Bagira_Dds_Test_SimpleTypesMessgae* samples[1];
		dds_sample_info_t infos[1];

		auto rc = GetSamples(
			::Bagira::Dds::Base::TopicReader::EAction::Take,
			(void**)samples,
			infos,
			1,
			0,
			(uint32_t)-1
		);

		if( rc > 0 )
		{
			// copy the resulting data to provided buffers
			*sample = *samples[0];
			*info = infos[0];

			return DDS_RETCODE_OK;
		}

		if( rc == 0 )
		{
			return DDS_RETCODE_NO_DATA;
		}

		return rc;
	}

	bool SimpleTypesMessgaeReader::TakeNextAlive( Bagira_Dds_Test_SimpleTypesMessgae* sample )
	{
		dds_sample_info_t info;
		dds_return_t rc;
		while(true)
		{
			rc = Take( sample, &info );

			if( rc != DDS_RETCODE_OK )
				return false;
				
			if( info.instance_state == DDS_IST_ALIVE )
				return true;
		}
	}


	SimpleTypesMessgaeWriter::SimpleTypesMessgaeWriter( ::Bagira::Dds::Participant* participant )
		: ::Bagira::Dds::Base::TopicWriter(
			participant, 
			Bagira_Dds_Test_SimpleTypesMessgae_GetTopicSettings()
		)
	{
	}
		
	void SimpleTypesMessgaeWriter::FreeSampleContent( Bagira_Dds_Test_SimpleTypesMessgae* sample )
	{
		dds_sample_free( sample, _topicSettings->descriptor, DDS_FREE_CONTENTS );
	}

}


namespace Bagira::Dds::Test
{
	SequenceTypesMessageReader::SequenceTypesMessageReader( ::Bagira::Dds::Participant* participant )
		: ::Bagira::Dds::Base::TopicReader(
			participant, 
			Bagira_Dds_Test_SequenceTypesMessage_GetTopicSettings()
		)
	{
	}

	dds_return_t SequenceTypesMessageReader::Take( Bagira_Dds_Test_SequenceTypesMessage* sample, dds_sample_info* info )
	{
		Bagira_Dds_Test_SequenceTypesMessage* samples[1];
		dds_sample_info_t infos[1];

		auto rc = GetSamples(
			::Bagira::Dds::Base::TopicReader::EAction::Take,
			(void**)samples,
			infos,
			1,
			0,
			(uint32_t)-1
		);

		if( rc > 0 )
		{
			// copy the resulting data to provided buffers
			*sample = *samples[0];
			*info = infos[0];

			return DDS_RETCODE_OK;
		}

		if( rc == 0 )
		{
			return DDS_RETCODE_NO_DATA;
		}

		return rc;
	}

	bool SequenceTypesMessageReader::TakeNextAlive( Bagira_Dds_Test_SequenceTypesMessage* sample )
	{
		dds_sample_info_t info;
		dds_return_t rc;
		while(true)
		{
			rc = Take( sample, &info );

			if( rc != DDS_RETCODE_OK )
				return false;
				
			if( info.instance_state == DDS_IST_ALIVE )
				return true;
		}
	}


	SequenceTypesMessageWriter::SequenceTypesMessageWriter( ::Bagira::Dds::Participant* participant )
		: ::Bagira::Dds::Base::TopicWriter(
			participant, 
			Bagira_Dds_Test_SequenceTypesMessage_GetTopicSettings()
		)
	{
	}
		
	void SequenceTypesMessageWriter::FreeSampleContent( Bagira_Dds_Test_SequenceTypesMessage* sample )
	{
		dds_sample_free( sample, _topicSettings->descriptor, DDS_FREE_CONTENTS );
	}

}


namespace Bagira::Dds::Test
{
	ComplexTypesMessageReader::ComplexTypesMessageReader( ::Bagira::Dds::Participant* participant )
		: ::Bagira::Dds::Base::TopicReader(
			participant, 
			Bagira_Dds_Test_ComplexTypesMessage_GetTopicSettings()
		)
	{
	}

	dds_return_t ComplexTypesMessageReader::Take( Bagira_Dds_Test_ComplexTypesMessage* sample, dds_sample_info* info )
	{
		Bagira_Dds_Test_ComplexTypesMessage* samples[1];
		dds_sample_info_t infos[1];

		auto rc = GetSamples(
			::Bagira::Dds::Base::TopicReader::EAction::Take,
			(void**)samples,
			infos,
			1,
			0,
			(uint32_t)-1
		);

		if( rc > 0 )
		{
			// copy the resulting data to provided buffers
			*sample = *samples[0];
			*info = infos[0];

			return DDS_RETCODE_OK;
		}

		if( rc == 0 )
		{
			return DDS_RETCODE_NO_DATA;
		}

		return rc;
	}

	bool ComplexTypesMessageReader::TakeNextAlive( Bagira_Dds_Test_ComplexTypesMessage* sample )
	{
		dds_sample_info_t info;
		dds_return_t rc;
		while(true)
		{
			rc = Take( sample, &info );

			if( rc != DDS_RETCODE_OK )
				return false;
				
			if( info.instance_state == DDS_IST_ALIVE )
				return true;
		}
	}


	ComplexTypesMessageWriter::ComplexTypesMessageWriter( ::Bagira::Dds::Participant* participant )
		: ::Bagira::Dds::Base::TopicWriter(
			participant, 
			Bagira_Dds_Test_ComplexTypesMessage_GetTopicSettings()
		)
	{
	}
		
	void ComplexTypesMessageWriter::FreeSampleContent( Bagira_Dds_Test_ComplexTypesMessage* sample )
	{
		dds_sample_free( sample, _topicSettings->descriptor, DDS_FREE_CONTENTS );
	}

}


namespace Bagira::Dds::Test
{
	OptionalFieldsMessageReader::OptionalFieldsMessageReader( ::Bagira::Dds::Participant* participant )
		: ::Bagira::Dds::Base::TopicReader(
			participant, 
			Bagira_Dds_Test_OptionalFieldsMessage_GetTopicSettings()
		)
	{
	}

	dds_return_t OptionalFieldsMessageReader::Take( Bagira_Dds_Test_OptionalFieldsMessage* sample, dds_sample_info* info )
	{
		Bagira_Dds_Test_OptionalFieldsMessage* samples[1];
		dds_sample_info_t infos[1];

		auto rc = GetSamples(
			::Bagira::Dds::Base::TopicReader::EAction::Take,
			(void**)samples,
			infos,
			1,
			0,
			(uint32_t)-1
		);

		if( rc > 0 )
		{
			// copy the resulting data to provided buffers
			*sample = *samples[0];
			*info = infos[0];

			return DDS_RETCODE_OK;
		}

		if( rc == 0 )
		{
			return DDS_RETCODE_NO_DATA;
		}

		return rc;
	}

	bool OptionalFieldsMessageReader::TakeNextAlive( Bagira_Dds_Test_OptionalFieldsMessage* sample )
	{
		dds_sample_info_t info;
		dds_return_t rc;
		while(true)
		{
			rc = Take( sample, &info );

			if( rc != DDS_RETCODE_OK )
				return false;
				
			if( info.instance_state == DDS_IST_ALIVE )
				return true;
		}
	}


	OptionalFieldsMessageWriter::OptionalFieldsMessageWriter( ::Bagira::Dds::Participant* participant )
		: ::Bagira::Dds::Base::TopicWriter(
			participant, 
			Bagira_Dds_Test_OptionalFieldsMessage_GetTopicSettings()
		)
	{
	}
		
	void OptionalFieldsMessageWriter::FreeSampleContent( Bagira_Dds_Test_OptionalFieldsMessage* sample )
	{
		dds_sample_free( sample, _topicSettings->descriptor, DDS_FREE_CONTENTS );
	}

}


//
// Clone functions
//

namespace Bagira::Dds::Test
{
	Bagira_Dds_Test_PodStruct Clone( const Bagira_Dds_Test_PodStruct& src )
	{
 		// bitwise copy of the plain-C struct first
		Bagira_Dds_Test_PodStruct dest = src;

 



	    return dest;
	}
}
namespace Bagira::Dds::Test
{
		Bagira_Dds_Test_NonPodStruct Clone( const Bagira_Dds_Test_NonPodStruct& src )
	{
 		// bitwise copy of the plain-C struct first
		Bagira_Dds_Test_NonPodStruct dest = src;

 

		if( src.str1 )
		{
			dest.str1 = dds_string_dup( src.str1 );
		}

	    return dest;
	}
}
namespace Bagira::Dds::Test
{
		Bagira_Dds_Test_TestMessage Clone( const Bagira_Dds_Test_TestMessage& src )
	{
 		// bitwise copy of the plain-C struct first
		Bagira_Dds_Test_TestMessage dest = src;

 


		if( src.string1 )
		{
			dest.string1 = dds_string_dup( src.string1 );
		}

				dest.pod1 = ::Bagira::Dds::Test::Clone( src.pod1 );

				dest.npod1 = ::Bagira::Dds::Test::Clone( src.npod1 );

		if( src.podSeq1._buffer )
		{
						dest.podSeq1._buffer = (Bagira_Dds_Test_PodStruct*) dds_alloc( src.podSeq1._maximum * sizeof(Bagira_Dds_Test_PodStruct) );
			for( unsigned i=0; i < src.podSeq1._length; i++ )
			{
				dest.podSeq1._buffer[i] = ::Bagira::Dds::Test::Clone( src.podSeq1._buffer[i] );
			}
		}





		if( src.stringSeq._buffer )
		{
						dest.stringSeq._buffer = (char**) dds_alloc( src.stringSeq._maximum * sizeof(char*) );
			for( unsigned i=0; i < src.stringSeq._length; i++ )
			{
			    if ( src.stringSeq._buffer[i] )
					dest.stringSeq._buffer[i] = dds_string_dup( src.stringSeq._buffer[i] );
				else
					dest.stringSeq._buffer[i] = nullptr;
			}
		}


		if( src.intSeq._buffer )
		{
						dest.intSeq._buffer = (int32_t*) dds_alloc( src.intSeq._maximum * sizeof(int32_t) );
			for( unsigned i=0; i < src.intSeq._length; i++ )
			{
				dest.intSeq._buffer[i] = src.intSeq._buffer[i];
			}
		}


		if( src.charSeq._buffer )
		{
						dest.charSeq._buffer = (char*) dds_alloc( src.charSeq._maximum * sizeof(char) );
			for( unsigned i=0; i < src.charSeq._length; i++ )
			{
				dest.charSeq._buffer[i] = src.charSeq._buffer[i];
			}
		}


		if( src.boolSeq._buffer )
		{
						dest.boolSeq._buffer = (bool*) dds_alloc( src.boolSeq._maximum * sizeof(bool) );
			for( unsigned i=0; i < src.boolSeq._length; i++ )
			{
				dest.boolSeq._buffer[i] = src.boolSeq._buffer[i];
			}
		}





	    return dest;
	}
}
namespace Bagira::Dds::Test
{
		Bagira_Dds_Test_TestInstance Clone( const Bagira_Dds_Test_TestInstance& src )
	{
 		// bitwise copy of the plain-C struct first
		Bagira_Dds_Test_TestInstance dest = src;

 


	    return dest;
	}
}
namespace Bagira::Dds::Test
{
		Bagira_Dds_Test_SimpleTypesMessgae Clone( const Bagira_Dds_Test_SimpleTypesMessgae& src )
	{
 		// bitwise copy of the plain-C struct first
		Bagira_Dds_Test_SimpleTypesMessgae dest = src;

 



		if( src.string1 )
		{
			dest.string1 = dds_string_dup( src.string1 );
		}


	    return dest;
	}
}
namespace Bagira::Dds::Test
{
		Bagira_Dds_Test_SequenceTypesMessage Clone( const Bagira_Dds_Test_SequenceTypesMessage& src )
	{
 		// bitwise copy of the plain-C struct first
		Bagira_Dds_Test_SequenceTypesMessage dest = src;

 

		if( src.stringSeq._buffer )
		{
			dest.stringSeq._buffer = (char**) dds_alloc( src.stringSeq._maximum * sizeof(char*) );
			for( unsigned i=0; i < src.stringSeq._length; i++ )
			{
			    if ( src.stringSeq._buffer[i] )
					dest.stringSeq._buffer[i] = dds_string_dup( src.stringSeq._buffer[i] );
				else
					dest.stringSeq._buffer[i] = nullptr;
			}
		}


		if( src.intSeq._buffer )
		{
						dest.intSeq._buffer = (int32_t*) dds_alloc( src.intSeq._maximum * sizeof(int32_t) );
			for( unsigned i=0; i < src.intSeq._length; i++ )
			{
				dest.intSeq._buffer[i] = src.intSeq._buffer[i];
			}
		}


		if( src.charSeq._buffer )
		{
						dest.charSeq._buffer = (char*) dds_alloc( src.charSeq._maximum * sizeof(char) );
			for( unsigned i=0; i < src.charSeq._length; i++ )
			{
				dest.charSeq._buffer[i] = src.charSeq._buffer[i];
			}
		}


		if( src.boolSeq._buffer )
		{
						dest.boolSeq._buffer = (bool*) dds_alloc( src.boolSeq._maximum * sizeof(bool) );
			for( unsigned i=0; i < src.boolSeq._length; i++ )
			{
				dest.boolSeq._buffer[i] = src.boolSeq._buffer[i];
			}
		}


	    return dest;
	}
}
namespace Bagira::Dds::Test
{
		Bagira_Dds_Test_ComplexTypesMessage Clone( const Bagira_Dds_Test_ComplexTypesMessage& src )
	{
 		// bitwise copy of the plain-C struct first
		Bagira_Dds_Test_ComplexTypesMessage dest = src;

 


				dest.struct1 = ::Bagira::Dds::Test::Clone( src.struct1 );

		if( src.structsequence._buffer )
		{
						dest.structsequence._buffer = (Bagira_Dds_Test_SimpleTypesMessgae*) dds_alloc( src.structsequence._maximum * sizeof(Bagira_Dds_Test_SimpleTypesMessgae) );
			for( unsigned i=0; i < src.structsequence._length; i++ )
			{
				dest.structsequence._buffer[i] = ::Bagira::Dds::Test::Clone( src.structsequence._buffer[i] );
			}
		}


	    return dest;
	}
}
namespace Bagira::Dds::Test
{
		Bagira_Dds_Test_StructWithOptionalFields Clone( const Bagira_Dds_Test_StructWithOptionalFields& src )
	{
 		// bitwise copy of the plain-C struct first
		Bagira_Dds_Test_StructWithOptionalFields dest = src;

 


		if( src.optionalFloat )
		{
			dest.optionalFloat = (float*) dds_alloc( sizeof( float ) );
		}

	    return dest;
	}
}
namespace Bagira::Dds::Test
{
		Bagira_Dds_Test_OptionalFieldsMessage Clone( const Bagira_Dds_Test_OptionalFieldsMessage& src )
	{
 		// bitwise copy of the plain-C struct first
		Bagira_Dds_Test_OptionalFieldsMessage dest = src;

 

		if( src.optionalByte )
		{
			dest.optionalByte = (uint8_t*) dds_alloc( sizeof( uint8_t ) );
		}

		if( src.optionalInt )
		{
			dest.optionalInt = (int32_t*) dds_alloc( sizeof( int32_t ) );
		}

		if( src.optionalBool )
		{
			dest.optionalBool = (bool*) dds_alloc( sizeof( bool ) );
		}

		if( src.optionalFloat )
		{
			dest.optionalFloat = (float*) dds_alloc( sizeof( float ) );
		}

		if( src.optionalDouble )
		{
			dest.optionalDouble = (double*) dds_alloc( sizeof( double ) );
		}

		if( src.optionalEnum )
		{
			dest.optionalEnum = (Bagira_Dds_Test_TestEnum*) dds_alloc( sizeof( Bagira_Dds_Test_TestEnum ) );
		}

		if( src.optionalPodStruct )
		{
			dest.optionalPodStruct = (Bagira_Dds_Test_PodStruct*) dds_alloc( sizeof( Bagira_Dds_Test_PodStruct ) );
    		(*dest.optionalPodStruct) = ::Bagira::Dds::Test::Clone( (*src.optionalPodStruct) );
		}

		if( src.optionalNonPodStruct )
		{
			dest.optionalNonPodStruct = (Bagira_Dds_Test_NonPodStruct*) dds_alloc( sizeof( Bagira_Dds_Test_NonPodStruct ) );
    		(*dest.optionalNonPodStruct) = ::Bagira::Dds::Test::Clone( (*src.optionalNonPodStruct) );
		}

				dest.nonOptionalStructWithOptionalFields = ::Bagira::Dds::Test::Clone( src.nonOptionalStructWithOptionalFields );

		if( src.optionalStructWithOptionalFields )
		{
			dest.optionalStructWithOptionalFields = (Bagira_Dds_Test_StructWithOptionalFields*) dds_alloc( sizeof( Bagira_Dds_Test_StructWithOptionalFields ) );
    		(*dest.optionalStructWithOptionalFields) = ::Bagira::Dds::Test::Clone( (*src.optionalStructWithOptionalFields) );
		}

	    return dest;
	}
}

h file

#pragma once
#include <array>
#include "./exports.h"
#include "../Test.h" // generated by ilc compiler
#include "Dds.Base.C/TopicWriter.h"
#include "Dds.Base.C/TopicReader.h"



namespace Bagira::Dds::Test
{
	class BAGIRA_DDS_DM_TEST_EXPORT TestMessageReader : public ::Bagira::Dds::Base::TopicReader
	{
	public:
		TestMessageReader( ::Bagira::Dds::Participant* participant );

		// Takes one incoming sample, including disposed instances.
		// You can check if instance is disposed with if(info.instance_state == DDS_IST_NOT_ALIVE_DISPOSED) { ... }
		// Fills provided memory with the sample data and sample info.
		//
		// Returns DDS_RETCODE_OK (0) if sample was read, otherwise negative error code, for example:
		// DDS_RETCODE_NO_DATA if no sample is available.
		//
		// The memory allocated for the content of the sample (strings, sequence buffers s) needs to be released
		// by calling ReturnLoan() before Take() is called next time.
		dds_return_t Take( Bagira_Dds_Test_TestMessage* sample, dds_sample_info* info );

		// Takes one incoming sample that is ALIVE (it skips DISPOSED saples). 
		// Fills provided memory with the sample data.
		// Returns true if sample was read, otherwise false.
		// The memory allocated for the content of the sample (strings, sequence buffers s) needs to be released
		// by calling ReturnLoan() before Take is called next time.
		bool TakeNextAlive( Bagira_Dds_Test_TestMessage* sample );
	};

	class BAGIRA_DDS_DM_TEST_EXPORT TestMessageWriter : public ::Bagira::Dds::Base::TopicWriter
	{
	public:
		TestMessageWriter( ::Bagira::Dds::Participant* participant );
		
		// frees the content of the sample (like the sequence buffers), but not the sample struct itself
		void FreeSampleContent( Bagira_Dds_Test_TestMessage* sample );
	};

	struct BAGIRA_DDS_DM_TEST_EXPORT TestMessage //: public Bagira_Dds_Test_TestMessage
	{
		typedef Bagira_Dds_Test_TestMessage Sample;
		typedef TestMessageReader Reader;
		typedef TestMessageWriter Writer;

	};

}



namespace Bagira::Dds::Test
{
	class BAGIRA_DDS_DM_TEST_EXPORT TestInstanceReader : public ::Bagira::Dds::Base::TopicReader
	{
	public:
		TestInstanceReader( ::Bagira::Dds::Participant* participant );

		// Takes one incoming sample, including disposed instances.
		// You can check if instance is disposed with if(info.instance_state == DDS_IST_NOT_ALIVE_DISPOSED) { ... }
		// Fills provided memory with the sample data and sample info.
		//
		// Returns DDS_RETCODE_OK (0) if sample was read, otherwise negative error code, for example:
		// DDS_RETCODE_NO_DATA if no sample is available.
		//
		// The memory allocated for the content of the sample (strings, sequence buffers s) needs to be released
		// by calling ReturnLoan() before Take() is called next time.
		dds_return_t Take( Bagira_Dds_Test_TestInstance* sample, dds_sample_info* info );

		// Takes one incoming sample that is ALIVE (it skips DISPOSED saples). 
		// Fills provided memory with the sample data.
		// Returns true if sample was read, otherwise false.
		// The memory allocated for the content of the sample (strings, sequence buffers s) needs to be released
		// by calling ReturnLoan() before Take is called next time.
		bool TakeNextAlive( Bagira_Dds_Test_TestInstance* sample );
	};

	class BAGIRA_DDS_DM_TEST_EXPORT TestInstanceWriter : public ::Bagira::Dds::Base::TopicWriter
	{
	public:
		TestInstanceWriter( ::Bagira::Dds::Participant* participant );
		
		// frees the content of the sample (like the sequence buffers), but not the sample struct itself
		void FreeSampleContent( Bagira_Dds_Test_TestInstance* sample );
	};

	struct BAGIRA_DDS_DM_TEST_EXPORT TestInstance //: public Bagira_Dds_Test_TestInstance
	{
		typedef Bagira_Dds_Test_TestInstance Sample;
		typedef TestInstanceReader Reader;
		typedef TestInstanceWriter Writer;

	};

}



namespace Bagira::Dds::Test
{
	class BAGIRA_DDS_DM_TEST_EXPORT SimpleTypesMessgaeReader : public ::Bagira::Dds::Base::TopicReader
	{
	public:
		SimpleTypesMessgaeReader( ::Bagira::Dds::Participant* participant );

		// Takes one incoming sample, including disposed instances.
		// You can check if instance is disposed with if(info.instance_state == DDS_IST_NOT_ALIVE_DISPOSED) { ... }
		// Fills provided memory with the sample data and sample info.
		//
		// Returns DDS_RETCODE_OK (0) if sample was read, otherwise negative error code, for example:
		// DDS_RETCODE_NO_DATA if no sample is available.
		//
		// The memory allocated for the content of the sample (strings, sequence buffers s) needs to be released
		// by calling ReturnLoan() before Take() is called next time.
		dds_return_t Take( Bagira_Dds_Test_SimpleTypesMessgae* sample, dds_sample_info* info );

		// Takes one incoming sample that is ALIVE (it skips DISPOSED saples). 
		// Fills provided memory with the sample data.
		// Returns true if sample was read, otherwise false.
		// The memory allocated for the content of the sample (strings, sequence buffers s) needs to be released
		// by calling ReturnLoan() before Take is called next time.
		bool TakeNextAlive( Bagira_Dds_Test_SimpleTypesMessgae* sample );
	};

	class BAGIRA_DDS_DM_TEST_EXPORT SimpleTypesMessgaeWriter : public ::Bagira::Dds::Base::TopicWriter
	{
	public:
		SimpleTypesMessgaeWriter( ::Bagira::Dds::Participant* participant );
		
		// frees the content of the sample (like the sequence buffers), but not the sample struct itself
		void FreeSampleContent( Bagira_Dds_Test_SimpleTypesMessgae* sample );
	};

	struct BAGIRA_DDS_DM_TEST_EXPORT SimpleTypesMessgae //: public Bagira_Dds_Test_SimpleTypesMessgae
	{
		typedef Bagira_Dds_Test_SimpleTypesMessgae Sample;
		typedef SimpleTypesMessgaeReader Reader;
		typedef SimpleTypesMessgaeWriter Writer;

	};

}



namespace Bagira::Dds::Test
{
	class BAGIRA_DDS_DM_TEST_EXPORT SequenceTypesMessageReader : public ::Bagira::Dds::Base::TopicReader
	{
	public:
		SequenceTypesMessageReader( ::Bagira::Dds::Participant* participant );

		// Takes one incoming sample, including disposed instances.
		// You can check if instance is disposed with if(info.instance_state == DDS_IST_NOT_ALIVE_DISPOSED) { ... }
		// Fills provided memory with the sample data and sample info.
		//
		// Returns DDS_RETCODE_OK (0) if sample was read, otherwise negative error code, for example:
		// DDS_RETCODE_NO_DATA if no sample is available.
		//
		// The memory allocated for the content of the sample (strings, sequence buffers s) needs to be released
		// by calling ReturnLoan() before Take() is called next time.
		dds_return_t Take( Bagira_Dds_Test_SequenceTypesMessage* sample, dds_sample_info* info );

		// Takes one incoming sample that is ALIVE (it skips DISPOSED saples). 
		// Fills provided memory with the sample data.
		// Returns true if sample was read, otherwise false.
		// The memory allocated for the content of the sample (strings, sequence buffers s) needs to be released
		// by calling ReturnLoan() before Take is called next time.
		bool TakeNextAlive( Bagira_Dds_Test_SequenceTypesMessage* sample );
	};

	class BAGIRA_DDS_DM_TEST_EXPORT SequenceTypesMessageWriter : public ::Bagira::Dds::Base::TopicWriter
	{
	public:
		SequenceTypesMessageWriter( ::Bagira::Dds::Participant* participant );
		
		// frees the content of the sample (like the sequence buffers), but not the sample struct itself
		void FreeSampleContent( Bagira_Dds_Test_SequenceTypesMessage* sample );
	};

	struct BAGIRA_DDS_DM_TEST_EXPORT SequenceTypesMessage //: public Bagira_Dds_Test_SequenceTypesMessage
	{
		typedef Bagira_Dds_Test_SequenceTypesMessage Sample;
		typedef SequenceTypesMessageReader Reader;
		typedef SequenceTypesMessageWriter Writer;

	};

}



namespace Bagira::Dds::Test
{
	class BAGIRA_DDS_DM_TEST_EXPORT ComplexTypesMessageReader : public ::Bagira::Dds::Base::TopicReader
	{
	public:
		ComplexTypesMessageReader( ::Bagira::Dds::Participant* participant );

		// Takes one incoming sample, including disposed instances.
		// You can check if instance is disposed with if(info.instance_state == DDS_IST_NOT_ALIVE_DISPOSED) { ... }
		// Fills provided memory with the sample data and sample info.
		//
		// Returns DDS_RETCODE_OK (0) if sample was read, otherwise negative error code, for example:
		// DDS_RETCODE_NO_DATA if no sample is available.
		//
		// The memory allocated for the content of the sample (strings, sequence buffers s) needs to be released
		// by calling ReturnLoan() before Take() is called next time.
		dds_return_t Take( Bagira_Dds_Test_ComplexTypesMessage* sample, dds_sample_info* info );

		// Takes one incoming sample that is ALIVE (it skips DISPOSED saples). 
		// Fills provided memory with the sample data.
		// Returns true if sample was read, otherwise false.
		// The memory allocated for the content of the sample (strings, sequence buffers s) needs to be released
		// by calling ReturnLoan() before Take is called next time.
		bool TakeNextAlive( Bagira_Dds_Test_ComplexTypesMessage* sample );
	};

	class BAGIRA_DDS_DM_TEST_EXPORT ComplexTypesMessageWriter : public ::Bagira::Dds::Base::TopicWriter
	{
	public:
		ComplexTypesMessageWriter( ::Bagira::Dds::Participant* participant );
		
		// frees the content of the sample (like the sequence buffers), but not the sample struct itself
		void FreeSampleContent( Bagira_Dds_Test_ComplexTypesMessage* sample );
	};

	struct BAGIRA_DDS_DM_TEST_EXPORT ComplexTypesMessage //: public Bagira_Dds_Test_ComplexTypesMessage
	{
		typedef Bagira_Dds_Test_ComplexTypesMessage Sample;
		typedef ComplexTypesMessageReader Reader;
		typedef ComplexTypesMessageWriter Writer;

	};

}



namespace Bagira::Dds::Test
{
	class BAGIRA_DDS_DM_TEST_EXPORT OptionalFieldsMessageReader : public ::Bagira::Dds::Base::TopicReader
	{
	public:
		OptionalFieldsMessageReader( ::Bagira::Dds::Participant* participant );

		// Takes one incoming sample, including disposed instances.
		// You can check if instance is disposed with if(info.instance_state == DDS_IST_NOT_ALIVE_DISPOSED) { ... }
		// Fills provided memory with the sample data and sample info.
		//
		// Returns DDS_RETCODE_OK (0) if sample was read, otherwise negative error code, for example:
		// DDS_RETCODE_NO_DATA if no sample is available.
		//
		// The memory allocated for the content of the sample (strings, sequence buffers s) needs to be released
		// by calling ReturnLoan() before Take() is called next time.
		dds_return_t Take( Bagira_Dds_Test_OptionalFieldsMessage* sample, dds_sample_info* info );

		// Takes one incoming sample that is ALIVE (it skips DISPOSED saples). 
		// Fills provided memory with the sample data.
		// Returns true if sample was read, otherwise false.
		// The memory allocated for the content of the sample (strings, sequence buffers s) needs to be released
		// by calling ReturnLoan() before Take is called next time.
		bool TakeNextAlive( Bagira_Dds_Test_OptionalFieldsMessage* sample );
	};

	class BAGIRA_DDS_DM_TEST_EXPORT OptionalFieldsMessageWriter : public ::Bagira::Dds::Base::TopicWriter
	{
	public:
		OptionalFieldsMessageWriter( ::Bagira::Dds::Participant* participant );
		
		// frees the content of the sample (like the sequence buffers), but not the sample struct itself
		void FreeSampleContent( Bagira_Dds_Test_OptionalFieldsMessage* sample );
	};

	struct BAGIRA_DDS_DM_TEST_EXPORT OptionalFieldsMessage //: public Bagira_Dds_Test_OptionalFieldsMessage
	{
		typedef Bagira_Dds_Test_OptionalFieldsMessage Sample;
		typedef OptionalFieldsMessageReader Reader;
		typedef OptionalFieldsMessageWriter Writer;

	};

}


//
// Clone functions
//

namespace Bagira::Dds::Test
{
	BAGIRA_DDS_DM_TEST_EXPORT Bagira_Dds_Test_PodStruct Clone( const Bagira_Dds_Test_PodStruct& src );
}
namespace Bagira::Dds::Test
{
	BAGIRA_DDS_DM_TEST_EXPORT Bagira_Dds_Test_NonPodStruct Clone( const Bagira_Dds_Test_NonPodStruct& src );
}
namespace Bagira::Dds::Test
{
	BAGIRA_DDS_DM_TEST_EXPORT Bagira_Dds_Test_TestMessage Clone( const Bagira_Dds_Test_TestMessage& src );
}
namespace Bagira::Dds::Test
{
	BAGIRA_DDS_DM_TEST_EXPORT Bagira_Dds_Test_TestInstance Clone( const Bagira_Dds_Test_TestInstance& src );
}
namespace Bagira::Dds::Test
{
	BAGIRA_DDS_DM_TEST_EXPORT Bagira_Dds_Test_SimpleTypesMessgae Clone( const Bagira_Dds_Test_SimpleTypesMessgae& src );
}
namespace Bagira::Dds::Test
{
	BAGIRA_DDS_DM_TEST_EXPORT Bagira_Dds_Test_SequenceTypesMessage Clone( const Bagira_Dds_Test_SequenceTypesMessage& src );
}
namespace Bagira::Dds::Test
{
	BAGIRA_DDS_DM_TEST_EXPORT Bagira_Dds_Test_ComplexTypesMessage Clone( const Bagira_Dds_Test_ComplexTypesMessage& src );
}
namespace Bagira::Dds::Test
{
	BAGIRA_DDS_DM_TEST_EXPORT Bagira_Dds_Test_StructWithOptionalFields Clone( const Bagira_Dds_Test_StructWithOptionalFields& src );
}
namespace Bagira::Dds::Test
{
	BAGIRA_DDS_DM_TEST_EXPORT Bagira_Dds_Test_OptionalFieldsMessage Clone( const Bagira_Dds_Test_OptionalFieldsMessage& src );
}

In general, any suggestion on how to better handle such big system is welcome.

Thanks in advanced for the help