Initial import.

git-svn-id: svn+ssh://mecka.net/home/svn/dds@2 c30cbac5-9f56-4f76-8ed5-5c34e48a65ae

32 files changed, 6645 insertions, 0 deletions

diff --git a/dds_io_sub/.cdtbuild b/dds_io_sub/.cdtbuild
new file mode 100644
index 0000000..d2e6110
--- /dev/null
+++ b/dds_io_sub/.cdtbuild
@@ -0,0 +1,51 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<?fileVersion 3.1.0?>
+
+<ManagedProjectBuildInfo>
+<project id="dds_io_sub.cdt.managedbuild.target.gnu.exe.1587408287" name="Executable (Gnu)" projectType="cdt.managedbuild.target.gnu.exe">
+<configuration artifactName="dds_io_sub" cleanCommand="rm -rf" description="" errorParsers="org.eclipse.cdt.core.MakeErrorParser;org.eclipse.cdt.core.GCCErrorParser;org.eclipse.cdt.core.GLDErrorParser;org.eclipse.cdt.core.GASErrorParser" id="cdt.managedbuild.config.gnu.exe.debug.1495543528" name="Debug" parent="cdt.managedbuild.config.gnu.exe.debug">
+<toolChain id="cdt.managedbuild.toolchain.gnu.exe.debug.1199063220" name="GCC Tool Chain" superClass="cdt.managedbuild.toolchain.gnu.exe.debug">
+<tool id="cdt.managedbuild.tool.gnu.cpp.compiler.exe.debug.116016170" name="GCC C++ Compiler" superClass="cdt.managedbuild.tool.gnu.cpp.compiler.exe.debug">
+<option id="gnu.cpp.compiler.option.include.paths.1464029935" superClass="gnu.cpp.compiler.option.include.paths" valueType="includePath">
+<listOptionValue builtIn="false" value="/opt/ACE_wrappers"/>
+<listOptionValue builtIn="false" value="/opt/ACE_wrappers/TAO"/>
+<listOptionValue builtIn="false" value="/opt/DDS"/>
+</option>
+</tool>
+<tool id="cdt.managedbuild.tool.gnu.c.compiler.exe.debug.1759225083" name="GCC C Compiler" superClass="cdt.managedbuild.tool.gnu.c.compiler.exe.debug"/>
+<tool id="cdt.managedbuild.tool.gnu.c.linker.exe.debug.945226777" name="GCC C Linker" superClass="cdt.managedbuild.tool.gnu.c.linker.exe.debug"/>
+<tool id="cdt.managedbuild.tool.gnu.cpp.linker.exe.debug.180299039" name="GCC C++ Linker" superClass="cdt.managedbuild.tool.gnu.cpp.linker.exe.debug">
+<option id="gnu.cpp.link.option.libs.768145728" superClass="gnu.cpp.link.option.libs" valueType="libs">
+<listOptionValue builtIn="false" value="OpenDDS_Dcps"/>
+<listOptionValue builtIn="false" value="TAO_PI"/>
+<listOptionValue builtIn="false" value="TAO_PortableServer"/>
+<listOptionValue builtIn="false" value="TAO_AnyTypeCode"/>
+<listOptionValue builtIn="false" value="TAO_IFR_Client"/>
+<listOptionValue builtIn="false" value="TAO_TypeCodeFactory"/>
+<listOptionValue builtIn="false" value="TAO_CodecFactory"/>
+<listOptionValue builtIn="false" value="TAO"/>
+<listOptionValue builtIn="false" value="TAO_RTCORBA"/>
+<listOptionValue builtIn="false" value="ACE"/>
+<listOptionValue builtIn="false" value="SimpleTcp"/>
+<listOptionValue builtIn="false" value="SimpleUnreliableDgram"/>
+</option>
+<option id="gnu.cpp.link.option.paths.773575242" superClass="gnu.cpp.link.option.paths" valueType="stringList">
+<listOptionValue builtIn="false" value="/opt/DDS/lib"/>
+<listOptionValue builtIn="false" value="/opt/ACE_wrappers/lib"/>
+</option>
+</tool>
+<tool id="cdt.managedbuild.tool.gnu.assembler.exe.debug.123969843" name="GCC Assembler" superClass="cdt.managedbuild.tool.gnu.assembler.exe.debug"/>
+<macros/>
+</toolChain>
+</configuration>
+<configuration artifactName="dds_io_sub" cleanCommand="rm -rf" description="" errorParsers="org.eclipse.cdt.core.MakeErrorParser;org.eclipse.cdt.core.GCCErrorParser;org.eclipse.cdt.core.GLDErrorParser;org.eclipse.cdt.core.GASErrorParser" id="cdt.managedbuild.config.gnu.exe.release.1115328087" name="Release" parent="cdt.managedbuild.config.gnu.exe.release">
+<toolChain id="cdt.managedbuild.toolchain.gnu.exe.release.1850177850" name="GCC Tool Chain" superClass="cdt.managedbuild.toolchain.gnu.exe.release">
+<tool id="cdt.managedbuild.tool.gnu.cpp.compiler.exe.release.1655339216" name="GCC C++ Compiler" superClass="cdt.managedbuild.tool.gnu.cpp.compiler.exe.release"/>
+<tool id="cdt.managedbuild.tool.gnu.c.compiler.exe.release.563732115" name="GCC C Compiler" superClass="cdt.managedbuild.tool.gnu.c.compiler.exe.release"/>
+<tool id="cdt.managedbuild.tool.gnu.c.linker.exe.release.1617451725" name="GCC C Linker" superClass="cdt.managedbuild.tool.gnu.c.linker.exe.release"/>
+<tool id="cdt.managedbuild.tool.gnu.cpp.linker.exe.release.1783377509" name="GCC C++ Linker" superClass="cdt.managedbuild.tool.gnu.cpp.linker.exe.release"/>
+<tool id="cdt.managedbuild.tool.gnu.assembler.exe.release.1203467" name="GCC Assembler" superClass="cdt.managedbuild.tool.gnu.assembler.exe.release"/>
+</toolChain>
+</configuration>
+</project>
+</ManagedProjectBuildInfo>
diff --git a/dds_io_sub/.cdtproject b/dds_io_sub/.cdtproject
new file mode 100644
index 0000000..5552453
--- /dev/null
+++ b/dds_io_sub/.cdtproject
@@ -0,0 +1,14 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<?eclipse-cdt version="2.0"?>
+
+<cdtproject id="org.eclipse.cdt.managedbuilder.core.managedMake">
+<extension id="org.eclipse.cdt.managedbuilder.core.ManagedBuildManager" point="org.eclipse.cdt.core.ScannerInfoProvider"/>
+<extension id="org.eclipse.cdt.core.ELF" point="org.eclipse.cdt.core.BinaryParser"/>
+<data>
+<item id="org.eclipse.cdt.core.pathentry">
+<pathentry kind="src" path=""/>
+<pathentry kind="out" path=""/>
+<pathentry kind="con" path="org.eclipse.cdt.managedbuilder.MANAGED_CONTAINER"/>
+</item>
+</data>
+</cdtproject>
diff --git a/dds_io_sub/.project b/dds_io_sub/.project
new file mode 100644
index 0000000..db33e90
--- /dev/null
+++ b/dds_io_sub/.project
@@ -0,0 +1,19 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<projectDescription>
+	<name>dds_io_sub</name>
+	<comment></comment>
+	<projects>
+	</projects>
+	<buildSpec>
+		<buildCommand>
+			<name>org.eclipse.cdt.managedbuilder.core.genmakebuilder</name>
+			<arguments>
+			</arguments>
+		</buildCommand>
+	</buildSpec>
+	<natures>
+		<nature>org.eclipse.cdt.core.cnature</nature>
+		<nature>org.eclipse.cdt.managedbuilder.core.managedBuildNature</nature>
+		<nature>org.eclipse.cdt.core.ccnature</nature>
+	</natures>
+</projectDescription>
diff --git a/dds_io_sub/.settings/org.eclipse.cdt.core.prefs b/dds_io_sub/.settings/org.eclipse.cdt.core.prefs
new file mode 100644
index 0000000..938f831
--- /dev/null
+++ b/dds_io_sub/.settings/org.eclipse.cdt.core.prefs
@@ -0,0 +1,3 @@
+#Fri Oct 05 19:00:29 CEST 2007
+eclipse.preferences.version=1
+indexerId=org.eclipse.cdt.core.nullindexer
diff --git a/dds_io_sub/.settings/org.eclipse.cdt.managedbuilder.core.prefs b/dds_io_sub/.settings/org.eclipse.cdt.managedbuilder.core.prefs
new file mode 100644
index 0000000..2172669
--- /dev/null
+++ b/dds_io_sub/.settings/org.eclipse.cdt.managedbuilder.core.prefs
@@ -0,0 +1,10 @@
+#Fri Oct 05 18:59:01 CEST 2007
+cdt.managedbuild.config.gnu.exe.debug.1495543528/internalBuilder/enabled=false
+cdt.managedbuild.config.gnu.exe.debug.1495543528/internalBuilder/ignoreErr=true
+cdt.managedbuild.config.gnu.exe.release.1115328087/internalBuilder/enabled=false
+cdt.managedbuild.config.gnu.exe.release.1115328087/internalBuilder/ignoreErr=true
+eclipse.preferences.version=1
+environment/buildEnvironmentInclude/cdt.managedbuild.config.gnu.exe.debug.1495543528=<?xml version\="1.0" encoding\="UTF-8"?>\n<environment>\n<variable name\="CPATH" operation\="remove"/>\n<variable name\="C_INCLUDE_PATH" operation\="remove"/>\n<variable name\="CPLUS_INCLUDE_PATH" operation\="remove"/>\n</environment>\n
+environment/buildEnvironmentLibrary/cdt.managedbuild.config.gnu.exe.debug.1495543528=<?xml version\="1.0" encoding\="UTF-8"?>\n<environment>\n<variable name\="LIBRARY_PATH" operation\="remove"/>\n</environment>\n
+environment/project=<?xml version\="1.0" encoding\="UTF-8"?>\n<environment/>\n
+environment/project/cdt.managedbuild.config.gnu.exe.debug.1495543528=<?xml version\="1.0" encoding\="UTF-8"?>\n<environment/>\n
diff --git a/dds_io_sub/DataReaderListener.cpp b/dds_io_sub/DataReaderListener.cpp
new file mode 100644
index 0000000..c110174
--- /dev/null
+++ b/dds_io_sub/DataReaderListener.cpp
@@ -0,0 +1,104 @@
+// -*- C++ -*-
+//
+// $Id: DataReaderListener.cpp 889 2007-06-29 21:55:06Z johnc $
+#include "DataReaderListener.h"
+#include "PortTypeSupportC.h"
+#include "PortTypeSupportImpl.h"
+#include <dds/DCPS/Service_Participant.h>
+#include <ace/streams.h>
+
+using namespace IOTest;
+
+// Implementation skeleton constructor
+DataReaderListenerImpl::DataReaderListenerImpl()
+  : num_reads_(0)
+{
+}
+
+// Implementation skeleton destructor
+DataReaderListenerImpl::~DataReaderListenerImpl ()
+{
+}
+
+void DataReaderListenerImpl::on_data_available(DDS::DataReader_ptr reader)
+  throw (CORBA::SystemException)
+{
+  num_reads_ ++;
+
+  try {
+    ::IOTest::PortDataReader_var port_dr = ::IOTest::PortDataReader::_narrow(reader);
+    if (CORBA::is_nil (port_dr.in ())) {
+      cerr << "read: _narrow failed." << endl;
+      exit(1);
+    }
+
+    IOTest::Port port_obj;
+    DDS::SampleInfo si ;
+    DDS::ReturnCode_t status = port_dr->take_next_sample(port_obj, si) ;
+
+    if (status == DDS::RETCODE_OK) {
+      cout << "Port: no:     = " << port_obj.no << endl
+           << "      value:  = " << port_obj.value   << endl;
+      cout << "  sample_rank = " << si.sample_rank << endl;
+      
+      if(port_obj.no == 1)
+    	  io.set(port_obj.value);
+      
+    } else if (status == DDS::RETCODE_NO_DATA) {
+      cerr << "ERROR: reader received DDS::RETCODE_NO_DATA!" << endl;
+    } else {
+      cerr << "ERROR: read Message: Error: " <<  status << endl;
+    }
+  } catch (CORBA::Exception& e) {
+    cerr << "Exception caught in read:" << endl << e << endl;
+    exit(1);
+  }
+}
+
+void DataReaderListenerImpl::on_requested_deadline_missed (
+    DDS::DataReader_ptr,
+    const DDS::RequestedDeadlineMissedStatus &)
+  throw (CORBA::SystemException)
+{
+  cerr << "DataReaderListenerImpl::on_requested_deadline_missed" << endl;
+}
+
+void DataReaderListenerImpl::on_requested_incompatible_qos (
+    DDS::DataReader_ptr,
+    const DDS::RequestedIncompatibleQosStatus &)
+  throw (CORBA::SystemException)
+{
+  cerr << "DataReaderListenerImpl::on_requested_incompatible_qos" << endl;
+}
+
+void DataReaderListenerImpl::on_liveliness_changed (
+    DDS::DataReader_ptr,
+    const DDS::LivelinessChangedStatus &)
+  throw (CORBA::SystemException)
+{
+  cerr << "DataReaderListenerImpl::on_liveliness_changed" << endl;
+}
+
+void DataReaderListenerImpl::on_subscription_match (
+    DDS::DataReader_ptr,
+    const DDS::SubscriptionMatchStatus &)
+  throw (CORBA::SystemException)
+{
+  cerr << "DataReaderListenerImpl::on_subscription_match" << endl;
+}
+
+void DataReaderListenerImpl::on_sample_rejected(
+    DDS::DataReader_ptr,
+    const DDS::SampleRejectedStatus&)
+  throw (CORBA::SystemException)
+{
+  cerr << "DataReaderListenerImpl::on_sample_rejected" << endl;
+}
+
+void DataReaderListenerImpl::on_sample_lost(
+  DDS::DataReader_ptr,
+  const DDS::SampleLostStatus&)
+  throw (CORBA::SystemException)
+{
+  cerr << "DataReaderListenerImpl::on_sample_lost" << endl;
+}
diff --git a/dds_io_sub/DataReaderListener.h b/dds_io_sub/DataReaderListener.h
new file mode 100644
index 0000000..355e2cd
--- /dev/null
+++ b/dds_io_sub/DataReaderListener.h
@@ -0,0 +1,75 @@
+// -*- C++ -*-
+//
+// $Id: DataReaderListener.h 899 2007-07-05 16:36:52Z mitza $
+#ifndef DATAREADER_LISTENER_IMPL
+#define DATAREADER_LISTENER_IMPL
+
+#include <dds/DdsDcpsSubscriptionS.h>
+
+#include "diasio.h"
+
+#if !defined (ACE_LACKS_PRAGMA_ONCE)
+#pragma once
+#endif /* ACE_LACKS_PRAGMA_ONCE */
+
+
+//Class DataReaderListenerImpl
+class DataReaderListenerImpl
+  : public virtual OpenDDS::DCPS::LocalObject<DDS::DataReaderListener>
+{
+public:
+  //Constructor
+  DataReaderListenerImpl ();
+
+  //Destructor
+  virtual ~DataReaderListenerImpl (void);
+
+  virtual void on_requested_deadline_missed (
+    DDS::DataReader_ptr reader,
+    const DDS::RequestedDeadlineMissedStatus & status)
+    throw (CORBA::SystemException);
+
+  virtual void on_requested_incompatible_qos (
+    DDS::DataReader_ptr reader,
+    const DDS::RequestedIncompatibleQosStatus & status)
+  throw (CORBA::SystemException);
+
+  virtual void on_liveliness_changed (
+    DDS::DataReader_ptr reader,
+    const DDS::LivelinessChangedStatus & status)
+  throw (CORBA::SystemException);
+
+  virtual void on_subscription_match (
+    DDS::DataReader_ptr reader,
+    const DDS::SubscriptionMatchStatus & status
+  )
+  throw (CORBA::SystemException);
+
+  virtual void on_sample_rejected(
+    DDS::DataReader_ptr reader,
+    const DDS::SampleRejectedStatus& status
+  )
+  throw (CORBA::SystemException);
+
+  virtual void on_data_available(
+    DDS::DataReader_ptr reader
+  )
+  throw (CORBA::SystemException);
+
+  virtual void on_sample_lost(
+    DDS::DataReader_ptr reader,
+    const DDS::SampleLostStatus& status
+  )
+  throw (CORBA::SystemException);
+
+  long num_reads() const {
+    return num_reads_;
+  }
+
+private:
+  DIASIO io;
+  DDS::DataReader_var reader_;
+  long                  num_reads_;
+};
+
+#endif /* DATAREADER_LISTENER_IMPL  */
diff --git a/dds_io_sub/IOTest.idl b/dds_io_sub/IOTest.idl
new file mode 100644
index 0000000..82f4025
--- /dev/null
+++ b/dds_io_sub/IOTest.idl
@@ -0,0 +1,12 @@
+module IOTest{
+
+#pragma DCPS_DATA_TYPE "IOTest::Port"
+#pragma DCPS_DATA_KEY "IOTest::Port no"
+
+  struct Port {
+    long no;
+    long value;
+  };
+
+};
+
diff --git a/dds_io_sub/IOTestC.cpp b/dds_io_sub/IOTestC.cpp
new file mode 100644
index 0000000..03b24b1
--- /dev/null
+++ b/dds_io_sub/IOTestC.cpp
@@ -0,0 +1,254 @@
+// -*- C++ -*-
+//
+// $Id$
+
+// ****  Code generated by the The ACE ORB (TAO) IDL Compiler ****
+// TAO and the TAO IDL Compiler have been developed by:
+//       Center for Distributed Object Computing
+//       Washington University
+//       St. Louis, MO
+//       USA
+//       http://www.cs.wustl.edu/~schmidt/doc-center.html
+// and
+//       Distributed Object Computing Laboratory
+//       University of California at Irvine
+//       Irvine, CA
+//       USA
+//       http://doc.ece.uci.edu/
+// and
+//       Institute for Software Integrated Systems
+//       Vanderbilt University
+//       Nashville, TN
+//       USA
+//       http://www.isis.vanderbilt.edu/
+//
+// Information about TAO is available at:
+//     http://www.cs.wustl.edu/~schmidt/TAO.html
+
+// TAO_IDL - Generated from
+// be/be_codegen.cpp:381
+
+
+#include "IOTestC.h"
+#include "tao/AnyTypeCode/Null_RefCount_Policy.h"
+#include "tao/AnyTypeCode/TypeCode_Constants.h"
+#include "tao/AnyTypeCode/Alias_TypeCode_Static.h"
+#include "tao/AnyTypeCode/Struct_TypeCode_Static.h"
+#include "tao/AnyTypeCode/TypeCode_Struct_Field.h"
+#include "tao/CDR.h"
+#include "tao/CDR.h"
+#include "tao/AnyTypeCode/Any_Dual_Impl_T.h"
+
+#if !defined (__ACE_INLINE__)
+#include "IOTestC.inl"
+#endif /* !defined INLINE */
+
+// TAO_IDL - Generated from
+// be/be_visitor_arg_traits.cpp:72
+
+TAO_BEGIN_VERSIONED_NAMESPACE_DECL
+
+
+// Arg traits specializations.
+namespace TAO
+{
+}
+
+TAO_END_VERSIONED_NAMESPACE_DECL
+
+
+
+// TAO_IDL - Generated from
+// be/be_visitor_typecode/struct_typecode.cpp:84
+
+static TAO::TypeCode::Struct_Field<
+  char const *,
+  ::CORBA::TypeCode_ptr const *> const 
+    _tao_fields_IOTest_Port[] =
+      {
+        { "no", &CORBA::_tc_long },
+        { "value", &CORBA::_tc_long }
+      };
+  
+static TAO::TypeCode::Struct<
+  char const *,
+  ::CORBA::TypeCode_ptr const *,
+  TAO::TypeCode::Struct_Field<
+    char const *,
+    ::CORBA::TypeCode_ptr const *> const *,
+  TAO::Null_RefCount_Policy>
+_tao_tc_IOTest_Port (
+  ::CORBA::tk_struct,
+  "IDL:IOTest/Port:1.0",
+  "Port",
+  _tao_fields_IOTest_Port,
+  2);
+
+namespace IOTest
+{
+  ::CORBA::TypeCode_ptr const _tc_Port =
+    &_tao_tc_IOTest_Port;
+}
+
+
+
+// TAO_IDL - Generated from 
+// be/be_visitor_structure/structure_cs.cpp:66
+
+void 
+IOTest::Port::_tao_any_destructor (
+    void *_tao_void_pointer
+  )
+{
+  Port *_tao_tmp_pointer =
+    static_cast<Port *> (_tao_void_pointer);
+  delete _tao_tmp_pointer;
+}
+
+// TAO_IDL - Generated from 
+// be/be_visitor_structure/any_op_cs.cpp:54
+
+
+TAO_BEGIN_VERSIONED_NAMESPACE_DECL
+
+// Copying insertion.
+void operator<<= (
+    ::CORBA::Any &_tao_any,
+    const IOTest::Port &_tao_elem
+  )
+{
+  if (0 == &_tao_elem) // Trying to de-reference NULL object
+    _tao_any <<= static_cast<IOTest::Port *>( 0 ); // Use non-copying insertion of a NULL
+  else
+    TAO::Any_Dual_Impl_T<IOTest::Port>::insert_copy (
+        _tao_any,
+        IOTest::Port::_tao_any_destructor,
+        IOTest::_tc_Port,
+        _tao_elem
+      );
+}
+
+// Non-copying insertion.
+void operator<<= (
+    ::CORBA::Any &_tao_any,
+    IOTest::Port *_tao_elem
+  )
+{
+  TAO::Any_Dual_Impl_T<IOTest::Port>::insert (
+      _tao_any,
+      IOTest::Port::_tao_any_destructor,
+      IOTest::_tc_Port,
+      _tao_elem
+    );
+}
+
+// Extraction to non-const pointer (deprecated).
+::CORBA::Boolean operator>>= (
+    const ::CORBA::Any &_tao_any,
+    IOTest::Port *&_tao_elem
+  )
+{
+  return _tao_any >>= const_cast<
+      const IOTest::Port *&> (
+      _tao_elem
+    );
+}
+
+// Extraction to const pointer.
+::CORBA::Boolean operator>>= (
+    const ::CORBA::Any &_tao_any,
+    const IOTest::Port *&_tao_elem
+  )
+{
+  return
+    TAO::Any_Dual_Impl_T<IOTest::Port>::extract (
+        _tao_any,
+        IOTest::Port::_tao_any_destructor,
+        IOTest::_tc_Port,
+        _tao_elem
+      );
+}
+TAO_END_VERSIONED_NAMESPACE_DECL
+
+
+
+// TAO_IDL - Generated from
+// be/be_visitor_structure/cdr_op_cs.cpp:61
+
+
+TAO_BEGIN_VERSIONED_NAMESPACE_DECL
+
+::CORBA::Boolean operator<< (
+    TAO_OutputCDR &strm,
+    const IOTest::Port &_tao_aggregate
+  )
+{
+  return
+    (strm << _tao_aggregate.no) &&
+    (strm << _tao_aggregate.value);
+}
+
+::CORBA::Boolean operator>> (
+    TAO_InputCDR &strm,
+    IOTest::Port &_tao_aggregate
+  )
+{
+  return
+    (strm >> _tao_aggregate.no) &&
+    (strm >> _tao_aggregate.value);
+}
+
+TAO_END_VERSIONED_NAMESPACE_DECL
+
+
+
+// TAO_IDL - Generated from
+// be/be_visitor_structure/serializer_op_cs.cpp:61
+
+::CORBA::Boolean _dcps_has_key (const IOTest::Port& ) { 
+  return true;
+}
+size_t _dcps_max_marshaled_size (const IOTest::Port& _tao_aggregate)
+{
+  ACE_UNUSED_ARG (_tao_aggregate); // sometimes not used - avoid warning
+  return 
+    _dcps_max_marshaled_size (_tao_aggregate.no) +
+    _dcps_max_marshaled_size (_tao_aggregate.value);
+}
+
+::CORBA::Boolean _tao_is_bounded_size (const IOTest::Port& _tao_aggregate)
+{
+  ACE_UNUSED_ARG (_tao_aggregate); // often not used - avoid warning
+  return
+     true  &&
+     true ;
+}
+
+size_t _dcps_find_size(const IOTest::Port& _tao_aggregate)
+{
+  ACE_UNUSED_ARG(_tao_aggregate); // sometimes not used - avoid warning
+  return 
+    _dcps_max_marshaled_size (_tao_aggregate.no) +
+    _dcps_max_marshaled_size (_tao_aggregate.value);
+}
+
+::CORBA::Boolean operator<< (
+    TAO::DCPS::Serializer &strm,
+    const IOTest::Port &_tao_aggregate
+  )
+{
+  return
+    (strm << _tao_aggregate.no) &&
+    (strm << _tao_aggregate.value);
+}
+
+::CORBA::Boolean operator>> (
+    TAO::DCPS::Serializer &strm,
+    IOTest::Port &_tao_aggregate
+  )
+{
+  return
+    (strm >> _tao_aggregate.no) &&
+    (strm >> _tao_aggregate.value);
+}
+
diff --git a/dds_io_sub/IOTestC.h b/dds_io_sub/IOTestC.h
new file mode 100644
index 0000000..3803d83
--- /dev/null
+++ b/dds_io_sub/IOTestC.h
@@ -0,0 +1,168 @@
+// -*- C++ -*-
+//
+// $Id$
+
+// ****  Code generated by the The ACE ORB (TAO) IDL Compiler ****
+// TAO and the TAO IDL Compiler have been developed by:
+//       Center for Distributed Object Computing
+//       Washington University
+//       St. Louis, MO
+//       USA
+//       http://www.cs.wustl.edu/~schmidt/doc-center.html
+// and
+//       Distributed Object Computing Laboratory
+//       University of California at Irvine
+//       Irvine, CA
+//       USA
+//       http://doc.ece.uci.edu/
+// and
+//       Institute for Software Integrated Systems
+//       Vanderbilt University
+//       Nashville, TN
+//       USA
+//       http://www.isis.vanderbilt.edu/
+//
+// Information about TAO is available at:
+//     http://www.cs.wustl.edu/~schmidt/TAO.html
+
+// TAO_IDL - Generated from
+// be/be_codegen.cpp:135
+
+#ifndef _TAO_IDL_IOTESTC_H_
+#define _TAO_IDL_IOTESTC_H_
+
+
+#include /**/ "ace/config-all.h"
+
+#if !defined (ACE_LACKS_PRAGMA_ONCE)
+# pragma once
+#endif /* ACE_LACKS_PRAGMA_ONCE */
+
+
+#include "tao/AnyTypeCode/AnyTypeCode_methods.h"
+#include "tao/ORB.h"
+#include "tao/Basic_Types.h"
+#include "dds/DCPS/Serializer.h"
+#include "tao/VarOut_T.h"
+#include /**/ "tao/Versioned_Namespace.h"
+
+#if defined (TAO_EXPORT_MACRO)
+#undef TAO_EXPORT_MACRO
+#endif
+#define TAO_EXPORT_MACRO 
+
+// TAO_IDL - Generated from
+// be/be_visitor_module/module_ch.cpp:49
+
+namespace IOTest
+{
+  
+  // TAO_IDL - Generated from
+  // be/be_type.cpp:269
+  
+  struct Port;
+  
+  typedef
+    TAO_Fixed_Var_T<
+        Port
+      >
+    Port_var;
+  
+  typedef
+    Port &
+    Port_out;
+  
+  // TAO_IDL - Generated from
+  // be/be_visitor_structure/structure_ch.cpp:57
+  
+  struct  Port
+  {
+    typedef Port_var _var_type;
+    typedef Port_out _out_type;
+    
+    static void _tao_any_destructor (void *);
+    ::CORBA::Long no;
+    ::CORBA::Long value;
+  };
+  
+  // TAO_IDL - Generated from
+  // be/be_visitor_typecode/typecode_decl.cpp:49
+  
+  extern  ::CORBA::TypeCode_ptr const _tc_Port;
+
+// TAO_IDL - Generated from
+// be/be_visitor_module/module_ch.cpp:78
+
+} // module IOTest
+
+// TAO_IDL - Generated from
+// be/be_visitor_traits.cpp:64
+
+TAO_BEGIN_VERSIONED_NAMESPACE_DECL
+
+// Traits specializations.
+namespace TAO
+{
+}
+TAO_END_VERSIONED_NAMESPACE_DECL
+
+
+
+// TAO_IDL - Generated from
+// be/be_visitor_structure/any_op_ch.cpp:53
+
+
+TAO_BEGIN_VERSIONED_NAMESPACE_DECL
+
+ void operator<<= (::CORBA::Any &, const IOTest::Port &); // copying version
+ void operator<<= (::CORBA::Any &, IOTest::Port*); // noncopying version
+ ::CORBA::Boolean operator>>= (const ::CORBA::Any &, IOTest::Port *&); // deprecated
+ ::CORBA::Boolean operator>>= (const ::CORBA::Any &, const IOTest::Port *&);
+TAO_END_VERSIONED_NAMESPACE_DECL
+
+
+
+// TAO_IDL - Generated from
+// be/be_visitor_structure/cdr_op_ch.cpp:54
+
+
+TAO_BEGIN_VERSIONED_NAMESPACE_DECL
+
+ ::CORBA::Boolean operator<< (TAO_OutputCDR &, const IOTest::Port &);
+ ::CORBA::Boolean operator>> (TAO_InputCDR &, IOTest::Port &);
+
+TAO_END_VERSIONED_NAMESPACE_DECL
+
+
+
+// TAO_IDL - Generated from
+// be/be_visitor_structure/serializer_op_ch.cpp:56
+
+ ::CORBA::Boolean _dcps_has_key(const IOTest::Port& val);
+// This structure supports use of std::map with a key
+// defined by one or more #pragma DCPS_DATA_KEY lines.
+struct  PortKeyLessThan 
+{
+  bool operator() (
+      const IOTest::Port& v1,
+      const IOTest::Port& v2) const
+  {
+    return (v1.no < v2.no);
+  }
+};
+
+ size_t _dcps_max_marshaled_size (const IOTest::Port& _tao_aggregate);
+ ::CORBA::Boolean _tao_is_bounded_size (const IOTest::Port& _tao_aggregate);
+ size_t _dcps_find_size (const IOTest::Port& _tao_aggregate);
+ ::CORBA::Boolean operator<< (TAO::DCPS::Serializer &, const IOTest::Port &);
+ ::CORBA::Boolean operator>> (TAO::DCPS::Serializer &, IOTest::Port &);
+
+// TAO_IDL - Generated from
+// be/be_codegen.cpp:1219
+#if defined (__ACE_INLINE__)
+#include "IOTestC.inl"
+#endif /* defined INLINE */
+
+#endif /* ifndef */
+
+
diff --git a/dds_io_sub/IOTestC.inl b/dds_io_sub/IOTestC.inl
new file mode 100644
index 0000000..38aa325
--- /dev/null
+++ b/dds_io_sub/IOTestC.inl
@@ -0,0 +1,28 @@
+// -*- C++ -*-
+//
+// $Id$
+
+// ****  Code generated by the The ACE ORB (TAO) IDL Compiler ****
+// TAO and the TAO IDL Compiler have been developed by:
+//       Center for Distributed Object Computing
+//       Washington University
+//       St. Louis, MO
+//       USA
+//       http://www.cs.wustl.edu/~schmidt/doc-center.html
+// and
+//       Distributed Object Computing Laboratory
+//       University of California at Irvine
+//       Irvine, CA
+//       USA
+//       http://doc.ece.uci.edu/
+// and
+//       Institute for Software Integrated Systems
+//       Vanderbilt University
+//       Nashville, TN
+//       USA
+//       http://www.isis.vanderbilt.edu/
+//
+// Information about TAO is available at:
+//     http://www.cs.wustl.edu/~schmidt/TAO.html
+
+
diff --git a/dds_io_sub/IOTestS.cpp b/dds_io_sub/IOTestS.cpp
new file mode 100644
index 0000000..f1c0a06
--- /dev/null
+++ b/dds_io_sub/IOTestS.cpp
@@ -0,0 +1,73 @@
+// -*- C++ -*-
+//
+// $Id$
+
+// ****  Code generated by the The ACE ORB (TAO) IDL Compiler ****
+// TAO and the TAO IDL Compiler have been developed by:
+//       Center for Distributed Object Computing
+//       Washington University
+//       St. Louis, MO
+//       USA
+//       http://www.cs.wustl.edu/~schmidt/doc-center.html
+// and
+//       Distributed Object Computing Laboratory
+//       University of California at Irvine
+//       Irvine, CA
+//       USA
+//       http://doc.ece.uci.edu/
+// and
+//       Institute for Software Integrated Systems
+//       Vanderbilt University
+//       Nashville, TN
+//       USA
+//       http://www.isis.vanderbilt.edu/
+//
+// Information about TAO is available at:
+//     http://www.cs.wustl.edu/~schmidt/TAO.html
+
+
+// TAO_IDL - Generated from 
+// be/be_codegen.cpp:703
+
+#ifndef _TAO_IDL_IOTESTS_CPP_
+#define _TAO_IDL_IOTESTS_CPP_
+
+
+#include "IOTestS.h"
+
+#if !defined (__ACE_INLINE__)
+#include "IOTestS.inl"
+#endif /* !defined INLINE */
+
+// TAO_IDL - Generated from
+// be/be_visitor_arg_traits.cpp:72
+
+TAO_BEGIN_VERSIONED_NAMESPACE_DECL
+
+
+// Arg traits specializations.
+namespace TAO
+{
+}
+
+TAO_END_VERSIONED_NAMESPACE_DECL
+
+
+
+// TAO_IDL - Generated from
+// be/be_visitor_arg_traits.cpp:72
+
+TAO_BEGIN_VERSIONED_NAMESPACE_DECL
+
+
+// Arg traits specializations.
+namespace TAO
+{
+}
+
+TAO_END_VERSIONED_NAMESPACE_DECL
+
+
+
+#endif /* ifndef */
+
diff --git a/dds_io_sub/IOTestS.h b/dds_io_sub/IOTestS.h
new file mode 100644
index 0000000..44fb047
--- /dev/null
+++ b/dds_io_sub/IOTestS.h
@@ -0,0 +1,63 @@
+// -*- C++ -*-
+//
+// $Id$
+
+// ****  Code generated by the The ACE ORB (TAO) IDL Compiler ****
+// TAO and the TAO IDL Compiler have been developed by:
+//       Center for Distributed Object Computing
+//       Washington University
+//       St. Louis, MO
+//       USA
+//       http://www.cs.wustl.edu/~schmidt/doc-center.html
+// and
+//       Distributed Object Computing Laboratory
+//       University of California at Irvine
+//       Irvine, CA
+//       USA
+//       http://doc.ece.uci.edu/
+// and
+//       Institute for Software Integrated Systems
+//       Vanderbilt University
+//       Nashville, TN
+//       USA
+//       http://www.isis.vanderbilt.edu/
+//
+// Information about TAO is available at:
+//     http://www.cs.wustl.edu/~schmidt/TAO.html
+
+// TAO_IDL - Generated from
+// be/be_codegen.cpp:487
+
+#ifndef _TAO_IDL_IOTESTS_H_
+#define _TAO_IDL_IOTESTS_H_
+
+
+#include "IOTestC.h"
+
+#if !defined (ACE_LACKS_PRAGMA_ONCE)
+# pragma once
+#endif /* ACE_LACKS_PRAGMA_ONCE */
+
+
+// TAO_IDL - Generated from
+// be/be_visitor_module/module_sh.cpp:49
+
+namespace POA_IOTest
+{
+  
+
+// TAO_IDL - Generated from
+// be/be_visitor_module/module_sh.cpp:80
+
+} // module IOTest
+
+// TAO_IDL - Generated from 
+// be/be_codegen.cpp:1281
+
+
+#if defined (__ACE_INLINE__)
+#include "IOTestS.inl"
+#endif /* defined INLINE */
+
+#endif /* ifndef */
+
diff --git a/dds_io_sub/IOTestS.inl b/dds_io_sub/IOTestS.inl
new file mode 100644
index 0000000..38aa325
--- /dev/null
+++ b/dds_io_sub/IOTestS.inl
@@ -0,0 +1,28 @@
+// -*- C++ -*-
+//
+// $Id$
+
+// ****  Code generated by the The ACE ORB (TAO) IDL Compiler ****
+// TAO and the TAO IDL Compiler have been developed by:
+//       Center for Distributed Object Computing
+//       Washington University
+//       St. Louis, MO
+//       USA
+//       http://www.cs.wustl.edu/~schmidt/doc-center.html
+// and
+//       Distributed Object Computing Laboratory
+//       University of California at Irvine
+//       Irvine, CA
+//       USA
+//       http://doc.ece.uci.edu/
+// and
+//       Institute for Software Integrated Systems
+//       Vanderbilt University
+//       Nashville, TN
+//       USA
+//       http://www.isis.vanderbilt.edu/
+//
+// Information about TAO is available at:
+//     http://www.cs.wustl.edu/~schmidt/TAO.html
+
+
diff --git a/dds_io_sub/PortTypeSupport.idl b/dds_io_sub/PortTypeSupport.idl
new file mode 100644
index 0000000..dd4f75d
--- /dev/null
+++ b/dds_io_sub/PortTypeSupport.idl
@@ -0,0 +1,162 @@
+
+// $Id: IDLTemplate.pm 899 2007-07-05 16:36:52Z mitza $
+
+// Generated by dcps_ts.pl
+
+#include "dds/DdsDcpsInfrastructure.idl"
+#include "dds/DdsDcpsTopic.idl"
+#include "dds/DdsDcpsPublication.idl"
+#include "dds/DdsDcpsSubscription.idl"
+#include "dds/DdsDcpsTypeSupportExt.idl"
+
+#include "IOTest.idl"
+
+module IOTest {
+
+
+#pragma DCPS_SUPPORT_ZERO_COPY_READ
+#pragma DCPS_GEN_ZERO_COPY_READ
+//typedef sequence<IOTest::Port> PortSeq;
+native PortSeq;
+
+/** Support topic registartion for Port data type.
+ *
+ * See the DDS specification, OMG formal/04-12-02, for a description of  
+ * this interface.
+ */
+local interface PortTypeSupport : OpenDDS::DCPS::TypeSupport {
+    DDS::ReturnCode_t register_type(
+                in DDS::DomainParticipant participant,
+                in string type_name);
+};
+
+/** DataWriter interface for Port data type.
+ *
+ * See the DDS specification, OMG formal/04-12-02, for a description of  
+ * this interface.
+ */
+local interface PortDataWriter : DDS::DataWriter {
+    DDS::InstanceHandle_t register(
+                in IOTest::Port instance_data);
+
+    DDS::InstanceHandle_t register_w_timestamp(
+                in IOTest::Port instance_data,
+                in DDS::InstanceHandle_t handle,
+                in DDS::Time_t source_timestamp);
+
+    DDS::ReturnCode_t unregister(
+                in IOTest::Port instance_data,
+                in DDS::InstanceHandle_t handle);
+
+    DDS::ReturnCode_t unregister_w_timestamp(
+                in IOTest::Port instance_data,
+                in DDS::InstanceHandle_t handle,
+                in DDS::Time_t source_timestamp);
+
+    //WARNING: If the handle is non-nil and the instance is not registered
+    //         then this operation may cause an access violation.
+    //         This lack of safety helps performance.
+    DDS::ReturnCode_t write(
+                in IOTest::Port instance_data,
+                in DDS::InstanceHandle_t handle);
+
+    //WARNING: If the handle is non-nil and the instance is not registered
+    //         then this operation may cause an access violation.
+    //         This lack of safety helps performance.
+    DDS::ReturnCode_t write_w_timestamp(
+                in IOTest::Port instance_data,
+                in DDS::InstanceHandle_t handle,
+                in DDS::Time_t source_timestamp);
+
+    DDS::ReturnCode_t dispose(
+                in IOTest::Port instance_data,
+                in DDS::InstanceHandle_t instance_handle);
+
+    DDS::ReturnCode_t dispose_w_timestamp(
+                in IOTest::Port instance_data,
+                in DDS::InstanceHandle_t instance_handle,
+                in DDS::Time_t source_timestamp);
+
+    DDS::ReturnCode_t get_key_value(
+                inout IOTest::Port key_holder,
+                in DDS::InstanceHandle_t handle);
+};
+
+/** DataReader interface for Port data type.
+ *
+ * See the DDS specification, OMG formal/04-12-02, for a description of  
+ * this interface.
+ */
+local interface PortDataReader : DDS::DataReader {
+    DDS::ReturnCode_t read(
+                inout PortSeq received_data,
+                inout DDS::SampleInfoSeq info_seq,
+                in long max_samples,
+                in DDS::SampleStateMask sample_states,
+                in DDS::ViewStateMask view_states,
+                in DDS::InstanceStateMask instance_states);
+
+    DDS::ReturnCode_t take(
+                inout PortSeq received_data,
+                inout DDS::SampleInfoSeq info_seq,
+                in long max_samples,
+                in DDS::SampleStateMask sample_states,
+                in DDS::ViewStateMask view_states,
+                in DDS::InstanceStateMask instance_states);
+
+    DDS::ReturnCode_t read_next_sample(
+                inout IOTest::Port received_data,
+                inout DDS::SampleInfo sample_info);
+
+    DDS::ReturnCode_t take_next_sample(
+                inout IOTest::Port received_data,
+                inout DDS::SampleInfo sample_info);
+
+    DDS::ReturnCode_t read_instance(
+                inout PortSeq received_data,
+                inout DDS::SampleInfoSeq info_seq,
+                in long max_samples,
+                in DDS::InstanceHandle_t a_handle,
+                in DDS::SampleStateMask sample_states,
+                in DDS::ViewStateMask view_states,
+                in DDS::InstanceStateMask instance_states);
+
+    DDS::ReturnCode_t take_instance(
+                inout PortSeq received_data,
+                inout DDS::SampleInfoSeq info_seq,
+                in long max_samples,
+                in DDS::InstanceHandle_t a_handle,
+                in DDS::SampleStateMask sample_states,
+                in DDS::ViewStateMask view_states,
+                in DDS::InstanceStateMask instance_states);
+
+    DDS::ReturnCode_t read_next_instance(
+                inout PortSeq received_data,
+                inout DDS::SampleInfoSeq info_seq,
+                in long max_samples,
+                in DDS::InstanceHandle_t a_handle,
+                in DDS::SampleStateMask sample_states,
+                in DDS::ViewStateMask view_states,
+                in DDS::InstanceStateMask instance_states);
+
+    DDS::ReturnCode_t take_next_instance(
+                inout PortSeq received_data,
+                inout DDS::SampleInfoSeq info_seq,
+                in long max_samples,
+                in DDS::InstanceHandle_t a_handle,
+                in DDS::SampleStateMask sample_states,
+                in DDS::ViewStateMask view_states,
+                in DDS::InstanceStateMask instance_states);
+
+    DDS::ReturnCode_t return_loan(
+                inout PortSeq received_data,
+                inout DDS::SampleInfoSeq info_seq);
+
+    DDS::ReturnCode_t get_key_value(
+                inout IOTest::Port key_holder,
+                in DDS::InstanceHandle_t handle);
+};
+
+};
+
+
diff --git a/dds_io_sub/PortTypeSupportC.cpp b/dds_io_sub/PortTypeSupportC.cpp
new file mode 100644
index 0000000..c20cc82
--- /dev/null
+++ b/dds_io_sub/PortTypeSupportC.cpp
@@ -0,0 +1,902 @@
+// -*- C++ -*-
+//
+// $Id$
+
+// ****  Code generated by the The ACE ORB (TAO) IDL Compiler ****
+// TAO and the TAO IDL Compiler have been developed by:
+//       Center for Distributed Object Computing
+//       Washington University
+//       St. Louis, MO
+//       USA
+//       http://www.cs.wustl.edu/~schmidt/doc-center.html
+// and
+//       Distributed Object Computing Laboratory
+//       University of California at Irvine
+//       Irvine, CA
+//       USA
+//       http://doc.ece.uci.edu/
+// and
+//       Institute for Software Integrated Systems
+//       Vanderbilt University
+//       Nashville, TN
+//       USA
+//       http://www.isis.vanderbilt.edu/
+//
+// Information about TAO is available at:
+//     http://www.cs.wustl.edu/~schmidt/TAO.html
+
+// TAO_IDL - Generated from
+// be/be_codegen.cpp:381
+
+
+#include "PortTypeSupportC.h"
+#include "tao/AnyTypeCode/Null_RefCount_Policy.h"
+#include "tao/AnyTypeCode/TypeCode_Constants.h"
+#include "tao/AnyTypeCode/Alias_TypeCode_Static.h"
+#include "tao/AnyTypeCode/Objref_TypeCode_Static.h"
+#include "tao/AnyTypeCode/String_TypeCode_Static.h"
+#include "tao/AnyTypeCode/Struct_TypeCode_Static.h"
+#include "tao/AnyTypeCode/TypeCode_Struct_Field.h"
+#include "tao/CDR.h"
+#include "tao/CDR.h"
+#include "tao/AnyTypeCode/Any.h"
+#include "tao/AnyTypeCode/Any_Impl_T.h"
+#include "tao/AnyTypeCode/Any_Dual_Impl_T.h"
+#include "ace/OS_NS_string.h"
+
+#if !defined (__ACE_INLINE__)
+#include "PortTypeSupportC.inl"
+#endif /* !defined INLINE */
+
+// TAO_IDL - Generated from
+// be/be_visitor_arg_traits.cpp:72
+
+TAO_BEGIN_VERSIONED_NAMESPACE_DECL
+
+
+// Arg traits specializations.
+namespace TAO
+{
+}
+
+TAO_END_VERSIONED_NAMESPACE_DECL
+
+
+
+// TAO_IDL - Generated from
+// be/be_visitor_interface/interface_cs.cpp:60
+
+// Traits specializations for IOTest::PortTypeSupport.
+
+IOTest::PortTypeSupport_ptr
+TAO::Objref_Traits<IOTest::PortTypeSupport>::duplicate (
+    IOTest::PortTypeSupport_ptr p)
+{
+  return IOTest::PortTypeSupport::_duplicate (p);
+}
+
+void
+TAO::Objref_Traits<IOTest::PortTypeSupport>::release (
+    IOTest::PortTypeSupport_ptr p)
+{
+  ::CORBA::release (p);
+}
+
+IOTest::PortTypeSupport_ptr
+TAO::Objref_Traits<IOTest::PortTypeSupport>::nil (void)
+{
+  return IOTest::PortTypeSupport::_nil ();
+}
+
+::CORBA::Boolean
+TAO::Objref_Traits<IOTest::PortTypeSupport>::marshal (
+    const IOTest::PortTypeSupport_ptr p,
+    TAO_OutputCDR & cdr)
+{
+  return ::CORBA::Object::marshal (p, cdr);
+}
+
+IOTest::PortTypeSupport::PortTypeSupport (void)
+{}
+
+IOTest::PortTypeSupport::~PortTypeSupport (void)
+{}
+
+void 
+IOTest::PortTypeSupport::_tao_any_destructor (void *_tao_void_pointer)
+{
+  PortTypeSupport *_tao_tmp_pointer =
+    static_cast<PortTypeSupport *> (_tao_void_pointer);
+  ::CORBA::release (_tao_tmp_pointer);
+}
+
+IOTest::PortTypeSupport_ptr
+IOTest::PortTypeSupport::_narrow (
+    ::CORBA::Object_ptr _tao_objref
+  )
+{
+  return PortTypeSupport::_duplicate (
+      dynamic_cast<PortTypeSupport_ptr> (_tao_objref)
+    );
+}
+
+IOTest::PortTypeSupport_ptr
+IOTest::PortTypeSupport::_unchecked_narrow (
+    ::CORBA::Object_ptr _tao_objref
+  )
+{
+  return PortTypeSupport::_duplicate (
+      dynamic_cast<PortTypeSupport_ptr> (_tao_objref)
+    );
+}
+
+IOTest::PortTypeSupport_ptr
+IOTest::PortTypeSupport::_duplicate (PortTypeSupport_ptr obj)
+{
+  if (! ::CORBA::is_nil (obj))
+    {
+      obj->_add_ref ();
+    }
+  
+  return obj;
+}
+
+void
+IOTest::PortTypeSupport::_tao_release (PortTypeSupport_ptr obj)
+{
+  ::CORBA::release (obj);
+}
+
+::CORBA::Boolean
+IOTest::PortTypeSupport::_is_a (const char *value)
+{
+  if (
+      !ACE_OS::strcmp (
+          value,
+          "IDL:DDS/TypeSupport:1.0"
+        ) ||
+      !ACE_OS::strcmp (
+          value,
+          "IDL:OpenDDS/DCPS/TypeSupport:1.0"
+        ) ||
+      !ACE_OS::strcmp (
+          value,
+          "IDL:IOTest/PortTypeSupport:1.0"
+        ) ||
+      !ACE_OS::strcmp (
+          value,
+          "IDL:omg.org/CORBA/LocalObject:1.0"
+        ) ||
+      !ACE_OS::strcmp (
+          value,
+          "IDL:omg.org/CORBA/Object:1.0"
+        )
+    )
+    {
+      return true; // success using local knowledge
+    }
+  else
+    {
+      return false;
+    }
+}
+
+const char* IOTest::PortTypeSupport::_interface_repository_id (void) const
+{
+  return "IDL:IOTest/PortTypeSupport:1.0";
+}
+
+::CORBA::Boolean
+IOTest::PortTypeSupport::marshal (TAO_OutputCDR &)
+{
+  return false;
+}
+
+// TAO_IDL - Generated from
+// be/be_visitor_typecode/objref_typecode.cpp:76
+
+static TAO::TypeCode::Objref<char const *,
+                             TAO::Null_RefCount_Policy>
+  _tao_tc_IOTest_PortTypeSupport (
+    ::CORBA::tk_local_interface,
+    "IDL:IOTest/PortTypeSupport:1.0",
+    "PortTypeSupport");
+  
+namespace IOTest
+{
+  ::CORBA::TypeCode_ptr const _tc_PortTypeSupport =
+    &_tao_tc_IOTest_PortTypeSupport;
+}
+
+
+
+// TAO_IDL - Generated from
+// be/be_visitor_interface/interface_cs.cpp:60
+
+// Traits specializations for IOTest::PortDataWriter.
+
+IOTest::PortDataWriter_ptr
+TAO::Objref_Traits<IOTest::PortDataWriter>::duplicate (
+    IOTest::PortDataWriter_ptr p)
+{
+  return IOTest::PortDataWriter::_duplicate (p);
+}
+
+void
+TAO::Objref_Traits<IOTest::PortDataWriter>::release (
+    IOTest::PortDataWriter_ptr p)
+{
+  ::CORBA::release (p);
+}
+
+IOTest::PortDataWriter_ptr
+TAO::Objref_Traits<IOTest::PortDataWriter>::nil (void)
+{
+  return IOTest::PortDataWriter::_nil ();
+}
+
+::CORBA::Boolean
+TAO::Objref_Traits<IOTest::PortDataWriter>::marshal (
+    const IOTest::PortDataWriter_ptr p,
+    TAO_OutputCDR & cdr)
+{
+  return ::CORBA::Object::marshal (p, cdr);
+}
+
+IOTest::PortDataWriter::PortDataWriter (void)
+{}
+
+IOTest::PortDataWriter::~PortDataWriter (void)
+{}
+
+void 
+IOTest::PortDataWriter::_tao_any_destructor (void *_tao_void_pointer)
+{
+  PortDataWriter *_tao_tmp_pointer =
+    static_cast<PortDataWriter *> (_tao_void_pointer);
+  ::CORBA::release (_tao_tmp_pointer);
+}
+
+IOTest::PortDataWriter_ptr
+IOTest::PortDataWriter::_narrow (
+    ::CORBA::Object_ptr _tao_objref
+  )
+{
+  return PortDataWriter::_duplicate (
+      dynamic_cast<PortDataWriter_ptr> (_tao_objref)
+    );
+}
+
+IOTest::PortDataWriter_ptr
+IOTest::PortDataWriter::_unchecked_narrow (
+    ::CORBA::Object_ptr _tao_objref
+  )
+{
+  return PortDataWriter::_duplicate (
+      dynamic_cast<PortDataWriter_ptr> (_tao_objref)
+    );
+}
+
+IOTest::PortDataWriter_ptr
+IOTest::PortDataWriter::_duplicate (PortDataWriter_ptr obj)
+{
+  if (! ::CORBA::is_nil (obj))
+    {
+      obj->_add_ref ();
+    }
+  
+  return obj;
+}
+
+void
+IOTest::PortDataWriter::_tao_release (PortDataWriter_ptr obj)
+{
+  ::CORBA::release (obj);
+}
+
+::CORBA::Boolean
+IOTest::PortDataWriter::_is_a (const char *value)
+{
+  if (
+      !ACE_OS::strcmp (
+          value,
+          "IDL:DDS/Entity:1.0"
+        ) ||
+      !ACE_OS::strcmp (
+          value,
+          "IDL:DDS/DataWriter:1.0"
+        ) ||
+      !ACE_OS::strcmp (
+          value,
+          "IDL:IOTest/PortDataWriter:1.0"
+        ) ||
+      !ACE_OS::strcmp (
+          value,
+          "IDL:omg.org/CORBA/LocalObject:1.0"
+        ) ||
+      !ACE_OS::strcmp (
+          value,
+          "IDL:omg.org/CORBA/Object:1.0"
+        )
+    )
+    {
+      return true; // success using local knowledge
+    }
+  else
+    {
+      return false;
+    }
+}
+
+const char* IOTest::PortDataWriter::_interface_repository_id (void) const
+{
+  return "IDL:IOTest/PortDataWriter:1.0";
+}
+
+::CORBA::Boolean
+IOTest::PortDataWriter::marshal (TAO_OutputCDR &)
+{
+  return false;
+}
+
+// TAO_IDL - Generated from
+// be/be_visitor_typecode/objref_typecode.cpp:76
+
+static TAO::TypeCode::Objref<char const *,
+                             TAO::Null_RefCount_Policy>
+  _tao_tc_IOTest_PortDataWriter (
+    ::CORBA::tk_local_interface,
+    "IDL:IOTest/PortDataWriter:1.0",
+    "PortDataWriter");
+  
+namespace IOTest
+{
+  ::CORBA::TypeCode_ptr const _tc_PortDataWriter =
+    &_tao_tc_IOTest_PortDataWriter;
+}
+
+
+
+// TAO_IDL - Generated from
+// be/be_visitor_interface/interface_cs.cpp:60
+
+// Traits specializations for IOTest::PortDataReader.
+
+IOTest::PortDataReader_ptr
+TAO::Objref_Traits<IOTest::PortDataReader>::duplicate (
+    IOTest::PortDataReader_ptr p)
+{
+  return IOTest::PortDataReader::_duplicate (p);
+}
+
+void
+TAO::Objref_Traits<IOTest::PortDataReader>::release (
+    IOTest::PortDataReader_ptr p)
+{
+  ::CORBA::release (p);
+}
+
+IOTest::PortDataReader_ptr
+TAO::Objref_Traits<IOTest::PortDataReader>::nil (void)
+{
+  return IOTest::PortDataReader::_nil ();
+}
+
+::CORBA::Boolean
+TAO::Objref_Traits<IOTest::PortDataReader>::marshal (
+    const IOTest::PortDataReader_ptr p,
+    TAO_OutputCDR & cdr)
+{
+  return ::CORBA::Object::marshal (p, cdr);
+}
+
+IOTest::PortDataReader::PortDataReader (void)
+{}
+
+IOTest::PortDataReader::~PortDataReader (void)
+{}
+
+void 
+IOTest::PortDataReader::_tao_any_destructor (void *_tao_void_pointer)
+{
+  PortDataReader *_tao_tmp_pointer =
+    static_cast<PortDataReader *> (_tao_void_pointer);
+  ::CORBA::release (_tao_tmp_pointer);
+}
+
+IOTest::PortDataReader_ptr
+IOTest::PortDataReader::_narrow (
+    ::CORBA::Object_ptr _tao_objref
+  )
+{
+  return PortDataReader::_duplicate (
+      dynamic_cast<PortDataReader_ptr> (_tao_objref)
+    );
+}
+
+IOTest::PortDataReader_ptr
+IOTest::PortDataReader::_unchecked_narrow (
+    ::CORBA::Object_ptr _tao_objref
+  )
+{
+  return PortDataReader::_duplicate (
+      dynamic_cast<PortDataReader_ptr> (_tao_objref)
+    );
+}
+
+IOTest::PortDataReader_ptr
+IOTest::PortDataReader::_duplicate (PortDataReader_ptr obj)
+{
+  if (! ::CORBA::is_nil (obj))
+    {
+      obj->_add_ref ();
+    }
+  
+  return obj;
+}
+
+void
+IOTest::PortDataReader::_tao_release (PortDataReader_ptr obj)
+{
+  ::CORBA::release (obj);
+}
+
+::CORBA::Boolean
+IOTest::PortDataReader::_is_a (const char *value)
+{
+  if (
+      !ACE_OS::strcmp (
+          value,
+          "IDL:DDS/Entity:1.0"
+        ) ||
+      !ACE_OS::strcmp (
+          value,
+          "IDL:DDS/DataReader:1.0"
+        ) ||
+      !ACE_OS::strcmp (
+          value,
+          "IDL:IOTest/PortDataReader:1.0"
+        ) ||
+      !ACE_OS::strcmp (
+          value,
+          "IDL:omg.org/CORBA/LocalObject:1.0"
+        ) ||
+      !ACE_OS::strcmp (
+          value,
+          "IDL:omg.org/CORBA/Object:1.0"
+        )
+    )
+    {
+      return true; // success using local knowledge
+    }
+  else
+    {
+      return false;
+    }
+}
+
+const char* IOTest::PortDataReader::_interface_repository_id (void) const
+{
+  return "IDL:IOTest/PortDataReader:1.0";
+}
+
+::CORBA::Boolean
+IOTest::PortDataReader::marshal (TAO_OutputCDR &)
+{
+  return false;
+}
+
+// TAO_IDL - Generated from
+// be/be_visitor_typecode/objref_typecode.cpp:76
+
+static TAO::TypeCode::Objref<char const *,
+                             TAO::Null_RefCount_Policy>
+  _tao_tc_IOTest_PortDataReader (
+    ::CORBA::tk_local_interface,
+    "IDL:IOTest/PortDataReader:1.0",
+    "PortDataReader");
+  
+namespace IOTest
+{
+  ::CORBA::TypeCode_ptr const _tc_PortDataReader =
+    &_tao_tc_IOTest_PortDataReader;
+}
+
+
+
+// TAO_IDL - Generated from
+// be/be_visitor_interface/any_op_cs.cpp:51
+TAO_BEGIN_VERSIONED_NAMESPACE_DECL
+
+
+
+namespace TAO
+{
+  template<>
+  ::CORBA::Boolean
+  Any_Impl_T<IOTest::PortTypeSupport>::to_object (
+      ::CORBA::Object_ptr &_tao_elem
+    ) const
+  {
+    _tao_elem = ::CORBA::Object::_duplicate (this->value_);
+    return true;
+  }
+}
+
+namespace TAO
+{
+  template<>
+  ::CORBA::Boolean
+  Any_Impl_T<IOTest::PortTypeSupport>::marshal_value (TAO_OutputCDR &)
+  {
+    return false;
+  }
+  
+  template<>
+  ::CORBA::Boolean
+  Any_Impl_T<IOTest::PortTypeSupport>::demarshal_value (TAO_InputCDR &)
+  {
+    return false;
+  }
+}
+TAO_END_VERSIONED_NAMESPACE_DECL
+
+
+
+#if defined (ACE_ANY_OPS_USE_NAMESPACE)
+
+namespace IOTest
+{
+  
+  
+  /// Copying insertion.
+  void
+  operator<<= (
+      ::CORBA::Any &_tao_any,
+      PortTypeSupport_ptr _tao_elem)
+  {
+    PortTypeSupport_ptr _tao_objptr =
+      PortTypeSupport::_duplicate (_tao_elem);
+    _tao_any <<= &_tao_objptr;
+  }
+  
+  /// Non-copying insertion.
+  void
+  operator<<= (
+      ::CORBA::Any &_tao_any,
+      PortTypeSupport_ptr *_tao_elem)
+  {
+    TAO::Any_Impl_T<PortTypeSupport>::insert (
+        _tao_any,
+        PortTypeSupport::_tao_any_destructor,
+        _tc_PortTypeSupport,
+        *_tao_elem)
+  }
+  
+  ::CORBA::Boolean
+  operator>>= (
+      const ::CORBA::Any &_tao_any,
+      PortTypeSupport_ptr &_tao_elem)
+  {
+    return
+      TAO::Any_Impl_T<PortTypeSupport>::extract (
+          _tao_any,
+          PortTypeSupport::_tao_any_destructor,
+          _tc_PortTypeSupport,
+          _tao_elem)
+  }
+}
+
+#else
+
+TAO_BEGIN_VERSIONED_NAMESPACE_DECL
+
+
+
+/// Copying insertion.
+void
+operator<<= (
+    ::CORBA::Any &_tao_any,
+    IOTest::PortTypeSupport_ptr _tao_elem)
+{
+  IOTest::PortTypeSupport_ptr _tao_objptr =
+    IOTest::PortTypeSupport::_duplicate (_tao_elem);
+  _tao_any <<= &_tao_objptr;
+}
+
+/// Non-copying insertion.
+void
+operator<<= (
+    ::CORBA::Any &_tao_any,
+    IOTest::PortTypeSupport_ptr *_tao_elem)
+{
+  TAO::Any_Impl_T<IOTest::PortTypeSupport>::insert (
+      _tao_any,
+      IOTest::PortTypeSupport::_tao_any_destructor,
+      IOTest::_tc_PortTypeSupport,
+      *_tao_elem);
+}
+
+::CORBA::Boolean
+operator>>= (
+    const ::CORBA::Any &_tao_any,
+    IOTest::PortTypeSupport_ptr &_tao_elem)
+{
+  return
+    TAO::Any_Impl_T<IOTest::PortTypeSupport>::extract (
+        _tao_any,
+        IOTest::PortTypeSupport::_tao_any_destructor,
+        IOTest::_tc_PortTypeSupport,
+        _tao_elem);
+}
+
+TAO_END_VERSIONED_NAMESPACE_DECL
+
+
+
+#endif
+
+// TAO_IDL - Generated from
+// be/be_visitor_interface/any_op_cs.cpp:51
+TAO_BEGIN_VERSIONED_NAMESPACE_DECL
+
+
+
+namespace TAO
+{
+  template<>
+  ::CORBA::Boolean
+  Any_Impl_T<IOTest::PortDataWriter>::to_object (
+      ::CORBA::Object_ptr &_tao_elem
+    ) const
+  {
+    _tao_elem = ::CORBA::Object::_duplicate (this->value_);
+    return true;
+  }
+}
+
+namespace TAO
+{
+  template<>
+  ::CORBA::Boolean
+  Any_Impl_T<IOTest::PortDataWriter>::marshal_value (TAO_OutputCDR &)
+  {
+    return false;
+  }
+  
+  template<>
+  ::CORBA::Boolean
+  Any_Impl_T<IOTest::PortDataWriter>::demarshal_value (TAO_InputCDR &)
+  {
+    return false;
+  }
+}
+TAO_END_VERSIONED_NAMESPACE_DECL
+
+
+
+#if defined (ACE_ANY_OPS_USE_NAMESPACE)
+
+namespace IOTest
+{
+  
+  
+  /// Copying insertion.
+  void
+  operator<<= (
+      ::CORBA::Any &_tao_any,
+      PortDataWriter_ptr _tao_elem)
+  {
+    PortDataWriter_ptr _tao_objptr =
+      PortDataWriter::_duplicate (_tao_elem);
+    _tao_any <<= &_tao_objptr;
+  }
+  
+  /// Non-copying insertion.
+  void
+  operator<<= (
+      ::CORBA::Any &_tao_any,
+      PortDataWriter_ptr *_tao_elem)
+  {
+    TAO::Any_Impl_T<PortDataWriter>::insert (
+        _tao_any,
+        PortDataWriter::_tao_any_destructor,
+        _tc_PortDataWriter,
+        *_tao_elem)
+  }
+  
+  ::CORBA::Boolean
+  operator>>= (
+      const ::CORBA::Any &_tao_any,
+      PortDataWriter_ptr &_tao_elem)
+  {
+    return
+      TAO::Any_Impl_T<PortDataWriter>::extract (
+          _tao_any,
+          PortDataWriter::_tao_any_destructor,
+          _tc_PortDataWriter,
+          _tao_elem)
+  }
+}
+
+#else
+
+TAO_BEGIN_VERSIONED_NAMESPACE_DECL
+
+
+
+/// Copying insertion.
+void
+operator<<= (
+    ::CORBA::Any &_tao_any,
+    IOTest::PortDataWriter_ptr _tao_elem)
+{
+  IOTest::PortDataWriter_ptr _tao_objptr =
+    IOTest::PortDataWriter::_duplicate (_tao_elem);
+  _tao_any <<= &_tao_objptr;
+}
+
+/// Non-copying insertion.
+void
+operator<<= (
+    ::CORBA::Any &_tao_any,
+    IOTest::PortDataWriter_ptr *_tao_elem)
+{
+  TAO::Any_Impl_T<IOTest::PortDataWriter>::insert (
+      _tao_any,
+      IOTest::PortDataWriter::_tao_any_destructor,
+      IOTest::_tc_PortDataWriter,
+      *_tao_elem);
+}
+
+::CORBA::Boolean
+operator>>= (
+    const ::CORBA::Any &_tao_any,
+    IOTest::PortDataWriter_ptr &_tao_elem)
+{
+  return
+    TAO::Any_Impl_T<IOTest::PortDataWriter>::extract (
+        _tao_any,
+        IOTest::PortDataWriter::_tao_any_destructor,
+        IOTest::_tc_PortDataWriter,
+        _tao_elem);
+}
+
+TAO_END_VERSIONED_NAMESPACE_DECL
+
+
+
+#endif
+
+// TAO_IDL - Generated from
+// be/be_visitor_interface/any_op_cs.cpp:51
+TAO_BEGIN_VERSIONED_NAMESPACE_DECL
+
+
+
+namespace TAO
+{
+  template<>
+  ::CORBA::Boolean
+  Any_Impl_T<IOTest::PortDataReader>::to_object (
+      ::CORBA::Object_ptr &_tao_elem
+    ) const
+  {
+    _tao_elem = ::CORBA::Object::_duplicate (this->value_);
+    return true;
+  }
+}
+
+namespace TAO
+{
+  template<>
+  ::CORBA::Boolean
+  Any_Impl_T<IOTest::PortDataReader>::marshal_value (TAO_OutputCDR &)
+  {
+    return false;
+  }
+  
+  template<>
+  ::CORBA::Boolean
+  Any_Impl_T<IOTest::PortDataReader>::demarshal_value (TAO_InputCDR &)
+  {
+    return false;
+  }
+}
+TAO_END_VERSIONED_NAMESPACE_DECL
+
+
+
+#if defined (ACE_ANY_OPS_USE_NAMESPACE)
+
+namespace IOTest
+{
+  
+  
+  /// Copying insertion.
+  void
+  operator<<= (
+      ::CORBA::Any &_tao_any,
+      PortDataReader_ptr _tao_elem)
+  {
+    PortDataReader_ptr _tao_objptr =
+      PortDataReader::_duplicate (_tao_elem);
+    _tao_any <<= &_tao_objptr;
+  }
+  
+  /// Non-copying insertion.
+  void
+  operator<<= (
+      ::CORBA::Any &_tao_any,
+      PortDataReader_ptr *_tao_elem)
+  {
+    TAO::Any_Impl_T<PortDataReader>::insert (
+        _tao_any,
+        PortDataReader::_tao_any_destructor,
+        _tc_PortDataReader,
+        *_tao_elem)
+  }
+  
+  ::CORBA::Boolean
+  operator>>= (
+      const ::CORBA::Any &_tao_any,
+      PortDataReader_ptr &_tao_elem)
+  {
+    return
+      TAO::Any_Impl_T<PortDataReader>::extract (
+          _tao_any,
+          PortDataReader::_tao_any_destructor,
+          _tc_PortDataReader,
+          _tao_elem)
+  }
+}
+
+#else
+
+TAO_BEGIN_VERSIONED_NAMESPACE_DECL
+
+
+
+/// Copying insertion.
+void
+operator<<= (
+    ::CORBA::Any &_tao_any,
+    IOTest::PortDataReader_ptr _tao_elem)
+{
+  IOTest::PortDataReader_ptr _tao_objptr =
+    IOTest::PortDataReader::_duplicate (_tao_elem);
+  _tao_any <<= &_tao_objptr;
+}
+
+/// Non-copying insertion.
+void
+operator<<= (
+    ::CORBA::Any &_tao_any,
+    IOTest::PortDataReader_ptr *_tao_elem)
+{
+  TAO::Any_Impl_T<IOTest::PortDataReader>::insert (
+      _tao_any,
+      IOTest::PortDataReader::_tao_any_destructor,
+      IOTest::_tc_PortDataReader,
+      *_tao_elem);
+}
+
+::CORBA::Boolean
+operator>>= (
+    const ::CORBA::Any &_tao_any,
+    IOTest::PortDataReader_ptr &_tao_elem)
+{
+  return
+    TAO::Any_Impl_T<IOTest::PortDataReader>::extract (
+        _tao_any,
+        IOTest::PortDataReader::_tao_any_destructor,
+        IOTest::_tc_PortDataReader,
+        _tao_elem);
+}
+
+TAO_END_VERSIONED_NAMESPACE_DECL
+
+
+
+#endif
+
diff --git a/dds_io_sub/PortTypeSupportC.h b/dds_io_sub/PortTypeSupportC.h
new file mode 100644
index 0000000..bed0641
--- /dev/null
+++ b/dds_io_sub/PortTypeSupportC.h
@@ -0,0 +1,656 @@
+// -*- C++ -*-
+//
+// $Id$
+
+// ****  Code generated by the The ACE ORB (TAO) IDL Compiler ****
+// TAO and the TAO IDL Compiler have been developed by:
+//       Center for Distributed Object Computing
+//       Washington University
+//       St. Louis, MO
+//       USA
+//       http://www.cs.wustl.edu/~schmidt/doc-center.html
+// and
+//       Distributed Object Computing Laboratory
+//       University of California at Irvine
+//       Irvine, CA
+//       USA
+//       http://doc.ece.uci.edu/
+// and
+//       Institute for Software Integrated Systems
+//       Vanderbilt University
+//       Nashville, TN
+//       USA
+//       http://www.isis.vanderbilt.edu/
+//
+// Information about TAO is available at:
+//     http://www.cs.wustl.edu/~schmidt/TAO.html
+
+// TAO_IDL - Generated from
+// be/be_codegen.cpp:135
+
+#ifndef _TAO_IDL_PORTTYPESUPPORTC_H_
+#define _TAO_IDL_PORTTYPESUPPORTC_H_
+
+
+#include /**/ "ace/config-all.h"
+
+#if !defined (ACE_LACKS_PRAGMA_ONCE)
+# pragma once
+#endif /* ACE_LACKS_PRAGMA_ONCE */
+
+// added by manut
+#include "dds/DdsDcpsTypeSupportExtC.h"
+
+#include "tao/AnyTypeCode/AnyTypeCode_methods.h"
+#include "tao/ORB.h"
+#include "tao/SystemException.h"
+#include "tao/UserException.h"
+#include "tao/Basic_Types.h"
+#include "tao/ORB_Constants.h"
+#include "dds/DCPS/ZeroCopyInfoSeq_T.h"
+#include "dds/DCPS/ZeroCopySeq_T.h"
+#include "tao/Object.h"
+#include "tao/String_Manager_T.h"
+#include "tao/Objref_VarOut_T.h"
+#include /**/ "tao/Versioned_Namespace.h"
+
+#include "IOTestC.h"
+
+#if defined (TAO_EXPORT_MACRO)
+#undef TAO_EXPORT_MACRO
+#endif
+#define TAO_EXPORT_MACRO 
+
+// TAO_IDL - Generated from
+// be/be_visitor_module/module_ch.cpp:49
+
+namespace IOTest
+{
+  
+  // TAO_IDL - Generated from
+  // be/be_visitor_native/native_ch.cpp:55
+  
+  
+  
+  typedef ::TAO::DCPS::ZeroCopyDataSeq< IOTest::Port, DCPS_ZERO_COPY_SEQ_DEFAULT_SIZE> PortSeq;
+  
+  
+  // TAO_IDL - Generated from
+  // be/be_interface.cpp:638
+
+#if !defined (_IOTEST_PORTTYPESUPPORT__VAR_OUT_CH_)
+#define _IOTEST_PORTTYPESUPPORT__VAR_OUT_CH_
+  
+  class PortTypeSupport;
+  typedef PortTypeSupport *PortTypeSupport_ptr;
+  
+  typedef
+    TAO_Objref_Var_T<
+        PortTypeSupport
+      >
+    PortTypeSupport_var;
+  
+  typedef
+    TAO_Objref_Out_T<
+        PortTypeSupport
+      >
+    PortTypeSupport_out;
+
+#endif /* end #if !defined */
+  
+  // TAO_IDL - Generated from
+  // be/be_visitor_interface/interface_ch.cpp:54
+
+#if !defined (_IOTEST_PORTTYPESUPPORT_CH_)
+#define _IOTEST_PORTTYPESUPPORT_CH_
+  
+  class  PortTypeSupport
+    : public virtual ::OpenDDS::DCPS::TypeSupport
+  {
+  public:
+    typedef PortTypeSupport_ptr _ptr_type;
+    typedef PortTypeSupport_var _var_type;
+    typedef PortTypeSupport_out _out_type;
+    
+    // The static operations.
+    static PortTypeSupport_ptr _duplicate (PortTypeSupport_ptr obj);
+    
+    static void _tao_release (PortTypeSupport_ptr obj);
+    
+    static PortTypeSupport_ptr _narrow (::CORBA::Object_ptr obj);
+    static PortTypeSupport_ptr _unchecked_narrow (::CORBA::Object_ptr obj);
+    static PortTypeSupport_ptr _nil (void)
+    {
+      return static_cast<PortTypeSupport_ptr> (0);
+    }
+    
+    static void _tao_any_destructor (void *);
+    
+    // TAO_IDL - Generated from
+    // be/be_visitor_operation/operation_ch.cpp:46
+    
+    virtual ::DDS::ReturnCode_t register_type (
+        ::DDS::DomainParticipant_ptr participant,
+        const char * type_name) = 0;
+    
+    // TAO_IDL - Generated from
+    // be/be_visitor_interface/interface_ch.cpp:216
+    
+    virtual ::CORBA::Boolean _is_a (const char *type_id);
+    virtual const char* _interface_repository_id (void) const;
+    virtual ::CORBA::Boolean marshal (TAO_OutputCDR &cdr);
+  
+  protected:
+    // Abstract or local interface only.
+    PortTypeSupport (void);
+    
+    virtual ~PortTypeSupport (void);
+  
+  private:
+    // Private and unimplemented for concrete interfaces.
+    PortTypeSupport (const PortTypeSupport &);
+    
+    void operator= (const PortTypeSupport &);
+  };
+
+#endif /* end #if !defined */
+  
+  // TAO_IDL - Generated from
+  // be/be_visitor_typecode/typecode_decl.cpp:49
+  
+  extern  ::CORBA::TypeCode_ptr const _tc_PortTypeSupport;
+  
+  // TAO_IDL - Generated from
+  // be/be_interface.cpp:638
+
+#if !defined (_IOTEST_PORTDATAWRITER__VAR_OUT_CH_)
+#define _IOTEST_PORTDATAWRITER__VAR_OUT_CH_
+  
+  class PortDataWriter;
+  typedef PortDataWriter *PortDataWriter_ptr;
+  
+  typedef
+    TAO_Objref_Var_T<
+        PortDataWriter
+      >
+    PortDataWriter_var;
+  
+  typedef
+    TAO_Objref_Out_T<
+        PortDataWriter
+      >
+    PortDataWriter_out;
+
+#endif /* end #if !defined */
+  
+  // TAO_IDL - Generated from
+  // be/be_visitor_interface/interface_ch.cpp:54
+
+#if !defined (_IOTEST_PORTDATAWRITER_CH_)
+#define _IOTEST_PORTDATAWRITER_CH_
+  
+  class  PortDataWriter
+    : public virtual ::DDS::DataWriter
+  {
+  public:
+    typedef PortDataWriter_ptr _ptr_type;
+    typedef PortDataWriter_var _var_type;
+    typedef PortDataWriter_out _out_type;
+    
+    // The static operations.
+    static PortDataWriter_ptr _duplicate (PortDataWriter_ptr obj);
+    
+    static void _tao_release (PortDataWriter_ptr obj);
+    
+    static PortDataWriter_ptr _narrow (::CORBA::Object_ptr obj);
+    static PortDataWriter_ptr _unchecked_narrow (::CORBA::Object_ptr obj);
+    static PortDataWriter_ptr _nil (void)
+    {
+      return static_cast<PortDataWriter_ptr> (0);
+    }
+    
+    static void _tao_any_destructor (void *);
+    
+    // TAO_IDL - Generated from
+    // be/be_visitor_operation/operation_ch.cpp:46
+    
+    virtual ::DDS::InstanceHandle_t _cxx_register (
+        const ::IOTest::Port & instance_data) = 0;
+    
+    // TAO_IDL - Generated from
+    // be/be_visitor_operation/operation_ch.cpp:46
+    
+    virtual ::DDS::InstanceHandle_t register_w_timestamp (
+        const ::IOTest::Port & instance_data,
+        ::DDS::InstanceHandle_t handle,
+        const ::DDS::Time_t & source_timestamp) = 0;
+    
+    // TAO_IDL - Generated from
+    // be/be_visitor_operation/operation_ch.cpp:46
+    
+    virtual ::DDS::ReturnCode_t unregister (
+        const ::IOTest::Port & instance_data,
+        ::DDS::InstanceHandle_t handle) = 0;
+    
+    // TAO_IDL - Generated from
+    // be/be_visitor_operation/operation_ch.cpp:46
+    
+    virtual ::DDS::ReturnCode_t unregister_w_timestamp (
+        const ::IOTest::Port & instance_data,
+        ::DDS::InstanceHandle_t handle,
+        const ::DDS::Time_t & source_timestamp) = 0;
+    
+    // TAO_IDL - Generated from
+    // be/be_visitor_operation/operation_ch.cpp:46
+    
+    virtual ::DDS::ReturnCode_t write (
+        const ::IOTest::Port & instance_data,
+        ::DDS::InstanceHandle_t handle) = 0;
+    
+    // TAO_IDL - Generated from
+    // be/be_visitor_operation/operation_ch.cpp:46
+    
+    virtual ::DDS::ReturnCode_t write_w_timestamp (
+        const ::IOTest::Port & instance_data,
+        ::DDS::InstanceHandle_t handle,
+        const ::DDS::Time_t & source_timestamp) = 0;
+    
+    // TAO_IDL - Generated from
+    // be/be_visitor_operation/operation_ch.cpp:46
+    
+    virtual ::DDS::ReturnCode_t dispose (
+        const ::IOTest::Port & instance_data,
+        ::DDS::InstanceHandle_t instance_handle) = 0;
+    
+    // TAO_IDL - Generated from
+    // be/be_visitor_operation/operation_ch.cpp:46
+    
+    virtual ::DDS::ReturnCode_t dispose_w_timestamp (
+        const ::IOTest::Port & instance_data,
+        ::DDS::InstanceHandle_t instance_handle,
+        const ::DDS::Time_t & source_timestamp) = 0;
+    
+    // TAO_IDL - Generated from
+    // be/be_visitor_operation/operation_ch.cpp:46
+    
+    virtual ::DDS::ReturnCode_t get_key_value (
+        ::IOTest::Port & key_holder,
+        ::DDS::InstanceHandle_t handle) = 0;
+    
+    // TAO_IDL - Generated from
+    // be/be_visitor_interface/interface_ch.cpp:216
+    
+    virtual ::CORBA::Boolean _is_a (const char *type_id);
+    virtual const char* _interface_repository_id (void) const;
+    virtual ::CORBA::Boolean marshal (TAO_OutputCDR &cdr);
+  
+  protected:
+    // Abstract or local interface only.
+    PortDataWriter (void);
+    
+    virtual ~PortDataWriter (void);
+  
+  private:
+    // Private and unimplemented for concrete interfaces.
+    PortDataWriter (const PortDataWriter &);
+    
+    void operator= (const PortDataWriter &);
+  };
+
+#endif /* end #if !defined */
+  
+  // TAO_IDL - Generated from
+  // be/be_visitor_typecode/typecode_decl.cpp:49
+  
+  extern  ::CORBA::TypeCode_ptr const _tc_PortDataWriter;
+  
+  // TAO_IDL - Generated from
+  // be/be_interface.cpp:638
+
+#if !defined (_IOTEST_PORTDATAREADER__VAR_OUT_CH_)
+#define _IOTEST_PORTDATAREADER__VAR_OUT_CH_
+  
+  class PortDataReader;
+  typedef PortDataReader *PortDataReader_ptr;
+  
+  typedef
+    TAO_Objref_Var_T<
+        PortDataReader
+      >
+    PortDataReader_var;
+  
+  typedef
+    TAO_Objref_Out_T<
+        PortDataReader
+      >
+    PortDataReader_out;
+
+#endif /* end #if !defined */
+  
+  // TAO_IDL - Generated from
+  // be/be_visitor_interface/interface_ch.cpp:54
+
+#if !defined (_IOTEST_PORTDATAREADER_CH_)
+#define _IOTEST_PORTDATAREADER_CH_
+  
+  class  PortDataReader
+    : public virtual ::DDS::DataReader
+  {
+  public:
+    typedef PortDataReader_ptr _ptr_type;
+    typedef PortDataReader_var _var_type;
+    typedef PortDataReader_out _out_type;
+    
+    // The static operations.
+    static PortDataReader_ptr _duplicate (PortDataReader_ptr obj);
+    
+    static void _tao_release (PortDataReader_ptr obj);
+    
+    static PortDataReader_ptr _narrow (::CORBA::Object_ptr obj);
+    static PortDataReader_ptr _unchecked_narrow (::CORBA::Object_ptr obj);
+    static PortDataReader_ptr _nil (void)
+    {
+      return static_cast<PortDataReader_ptr> (0);
+    }
+    
+    static void _tao_any_destructor (void *);
+    
+    // TAO_IDL - Generated from
+    // be/be_visitor_operation/operation_ch.cpp:46
+    
+    virtual ::DDS::ReturnCode_t read (
+        ::IOTest::PortSeq & received_data,
+        ::DDS::SampleInfoSeq & info_seq,
+        ::CORBA::Long max_samples,
+        ::DDS::SampleStateMask sample_states,
+        ::DDS::ViewStateMask view_states,
+        ::DDS::InstanceStateMask instance_states) = 0;
+    
+    // TAO_IDL - Generated from
+    // be/be_visitor_operation/operation_ch.cpp:46
+    
+    virtual ::DDS::ReturnCode_t take (
+        ::IOTest::PortSeq & received_data,
+        ::DDS::SampleInfoSeq & info_seq,
+        ::CORBA::Long max_samples,
+        ::DDS::SampleStateMask sample_states,
+        ::DDS::ViewStateMask view_states,
+        ::DDS::InstanceStateMask instance_states) = 0;
+    
+    // TAO_IDL - Generated from
+    // be/be_visitor_operation/operation_ch.cpp:46
+    
+    virtual ::DDS::ReturnCode_t read_next_sample (
+        ::IOTest::Port & received_data,
+        ::DDS::SampleInfo & sample_info) = 0;
+    
+    // TAO_IDL - Generated from
+    // be/be_visitor_operation/operation_ch.cpp:46
+    
+    virtual ::DDS::ReturnCode_t take_next_sample (
+        ::IOTest::Port & received_data,
+        ::DDS::SampleInfo & sample_info) = 0;
+    
+    // TAO_IDL - Generated from
+    // be/be_visitor_operation/operation_ch.cpp:46
+    
+    virtual ::DDS::ReturnCode_t read_instance (
+        ::IOTest::PortSeq & received_data,
+        ::DDS::SampleInfoSeq & info_seq,
+        ::CORBA::Long max_samples,
+        ::DDS::InstanceHandle_t a_handle,
+        ::DDS::SampleStateMask sample_states,
+        ::DDS::ViewStateMask view_states,
+        ::DDS::InstanceStateMask instance_states) = 0;
+    
+    // TAO_IDL - Generated from
+    // be/be_visitor_operation/operation_ch.cpp:46
+    
+    virtual ::DDS::ReturnCode_t take_instance (
+        ::IOTest::PortSeq & received_data,
+        ::DDS::SampleInfoSeq & info_seq,
+        ::CORBA::Long max_samples,
+        ::DDS::InstanceHandle_t a_handle,
+        ::DDS::SampleStateMask sample_states,
+        ::DDS::ViewStateMask view_states,
+        ::DDS::InstanceStateMask instance_states) = 0;
+    
+    // TAO_IDL - Generated from
+    // be/be_visitor_operation/operation_ch.cpp:46
+    
+    virtual ::DDS::ReturnCode_t read_next_instance (
+        ::IOTest::PortSeq & received_data,
+        ::DDS::SampleInfoSeq & info_seq,
+        ::CORBA::Long max_samples,
+        ::DDS::InstanceHandle_t a_handle,
+        ::DDS::SampleStateMask sample_states,
+        ::DDS::ViewStateMask view_states,
+        ::DDS::InstanceStateMask instance_states) = 0;
+    
+    // TAO_IDL - Generated from
+    // be/be_visitor_operation/operation_ch.cpp:46
+    
+    virtual ::DDS::ReturnCode_t take_next_instance (
+        ::IOTest::PortSeq & received_data,
+        ::DDS::SampleInfoSeq & info_seq,
+        ::CORBA::Long max_samples,
+        ::DDS::InstanceHandle_t a_handle,
+        ::DDS::SampleStateMask sample_states,
+        ::DDS::ViewStateMask view_states,
+        ::DDS::InstanceStateMask instance_states) = 0;
+    
+    // TAO_IDL - Generated from
+    // be/be_visitor_operation/operation_ch.cpp:46
+    
+    virtual ::DDS::ReturnCode_t return_loan (
+        ::IOTest::PortSeq & received_data,
+        ::DDS::SampleInfoSeq & info_seq) = 0;
+    
+    // TAO_IDL - Generated from
+    // be/be_visitor_operation/operation_ch.cpp:46
+    
+    virtual ::DDS::ReturnCode_t get_key_value (
+        ::IOTest::Port & key_holder,
+        ::DDS::InstanceHandle_t handle) = 0;
+    
+    // TAO_IDL - Generated from
+    // be/be_visitor_interface/interface_ch.cpp:216
+    
+    virtual ::CORBA::Boolean _is_a (const char *type_id);
+    virtual const char* _interface_repository_id (void) const;
+    virtual ::CORBA::Boolean marshal (TAO_OutputCDR &cdr);
+  
+  protected:
+    // Abstract or local interface only.
+    PortDataReader (void);
+    
+    virtual ~PortDataReader (void);
+  
+  private:
+    // Private and unimplemented for concrete interfaces.
+    PortDataReader (const PortDataReader &);
+    
+    void operator= (const PortDataReader &);
+  };
+
+#endif /* end #if !defined */
+  
+  // TAO_IDL - Generated from
+  // be/be_visitor_typecode/typecode_decl.cpp:49
+  
+  extern  ::CORBA::TypeCode_ptr const _tc_PortDataReader;
+
+// TAO_IDL - Generated from
+// be/be_visitor_module/module_ch.cpp:78
+
+} // module IOTest
+
+// TAO_IDL - Generated from
+// be/be_visitor_traits.cpp:64
+
+TAO_BEGIN_VERSIONED_NAMESPACE_DECL
+
+// Traits specializations.
+namespace TAO
+{
+
+#if !defined (_IOTEST_PORTTYPESUPPORT__TRAITS_)
+#define _IOTEST_PORTTYPESUPPORT__TRAITS_
+  
+  template<>
+  struct  Objref_Traits< ::IOTest::PortTypeSupport>
+  {
+    static ::IOTest::PortTypeSupport_ptr duplicate (
+        ::IOTest::PortTypeSupport_ptr
+      );
+    static void release (
+        ::IOTest::PortTypeSupport_ptr
+      );
+    static ::IOTest::PortTypeSupport_ptr nil (void);
+    static ::CORBA::Boolean marshal (
+        const ::IOTest::PortTypeSupport_ptr p,
+        TAO_OutputCDR & cdr
+      );
+  };
+
+#endif /* end #if !defined */
+
+#if !defined (_IOTEST_PORTDATAWRITER__TRAITS_)
+#define _IOTEST_PORTDATAWRITER__TRAITS_
+  
+  template<>
+  struct  Objref_Traits< ::IOTest::PortDataWriter>
+  {
+    static ::IOTest::PortDataWriter_ptr duplicate (
+        ::IOTest::PortDataWriter_ptr
+      );
+    static void release (
+        ::IOTest::PortDataWriter_ptr
+      );
+    static ::IOTest::PortDataWriter_ptr nil (void);
+    static ::CORBA::Boolean marshal (
+        const ::IOTest::PortDataWriter_ptr p,
+        TAO_OutputCDR & cdr
+      );
+  };
+
+#endif /* end #if !defined */
+
+#if !defined (_IOTEST_PORTDATAREADER__TRAITS_)
+#define _IOTEST_PORTDATAREADER__TRAITS_
+  
+  template<>
+  struct  Objref_Traits< ::IOTest::PortDataReader>
+  {
+    static ::IOTest::PortDataReader_ptr duplicate (
+        ::IOTest::PortDataReader_ptr
+      );
+    static void release (
+        ::IOTest::PortDataReader_ptr
+      );
+    static ::IOTest::PortDataReader_ptr nil (void);
+    static ::CORBA::Boolean marshal (
+        const ::IOTest::PortDataReader_ptr p,
+        TAO_OutputCDR & cdr
+      );
+  };
+
+#endif /* end #if !defined */
+}
+TAO_END_VERSIONED_NAMESPACE_DECL
+
+
+
+// TAO_IDL - Generated from
+// be/be_visitor_interface/any_op_ch.cpp:54
+
+
+
+#if defined (ACE_ANY_OPS_USE_NAMESPACE)
+
+namespace IOTest
+{
+   void operator<<= ( ::CORBA::Any &, PortTypeSupport_ptr); // copying
+   void operator<<= ( ::CORBA::Any &, PortTypeSupport_ptr *); // non-copying
+   ::CORBA::Boolean operator>>= (const ::CORBA::Any &, PortTypeSupport_ptr &);
+}
+
+#else
+
+
+TAO_BEGIN_VERSIONED_NAMESPACE_DECL
+
+ void operator<<= (::CORBA::Any &, IOTest::PortTypeSupport_ptr); // copying
+ void operator<<= (::CORBA::Any &, IOTest::PortTypeSupport_ptr *); // non-copying
+ ::CORBA::Boolean operator>>= (const ::CORBA::Any &, IOTest::PortTypeSupport_ptr &);
+TAO_END_VERSIONED_NAMESPACE_DECL
+
+
+
+#endif
+
+// TAO_IDL - Generated from
+// be/be_visitor_interface/any_op_ch.cpp:54
+
+
+
+#if defined (ACE_ANY_OPS_USE_NAMESPACE)
+
+namespace IOTest
+{
+   void operator<<= ( ::CORBA::Any &, PortDataWriter_ptr); // copying
+   void operator<<= ( ::CORBA::Any &, PortDataWriter_ptr *); // non-copying
+   ::CORBA::Boolean operator>>= (const ::CORBA::Any &, PortDataWriter_ptr &);
+}
+
+#else
+
+
+TAO_BEGIN_VERSIONED_NAMESPACE_DECL
+
+ void operator<<= (::CORBA::Any &, IOTest::PortDataWriter_ptr); // copying
+ void operator<<= (::CORBA::Any &, IOTest::PortDataWriter_ptr *); // non-copying
+ ::CORBA::Boolean operator>>= (const ::CORBA::Any &, IOTest::PortDataWriter_ptr &);
+TAO_END_VERSIONED_NAMESPACE_DECL
+
+
+
+#endif
+
+// TAO_IDL - Generated from
+// be/be_visitor_interface/any_op_ch.cpp:54
+
+
+
+#if defined (ACE_ANY_OPS_USE_NAMESPACE)
+
+namespace IOTest
+{
+   void operator<<= ( ::CORBA::Any &, PortDataReader_ptr); // copying
+   void operator<<= ( ::CORBA::Any &, PortDataReader_ptr *); // non-copying
+   ::CORBA::Boolean operator>>= (const ::CORBA::Any &, PortDataReader_ptr &);
+}
+
+#else
+
+
+TAO_BEGIN_VERSIONED_NAMESPACE_DECL
+
+ void operator<<= (::CORBA::Any &, IOTest::PortDataReader_ptr); // copying
+ void operator<<= (::CORBA::Any &, IOTest::PortDataReader_ptr *); // non-copying
+ ::CORBA::Boolean operator>>= (const ::CORBA::Any &, IOTest::PortDataReader_ptr &);
+TAO_END_VERSIONED_NAMESPACE_DECL
+
+
+
+#endif
+
+// TAO_IDL - Generated from
+// be/be_codegen.cpp:1219
+#if defined (__ACE_INLINE__)
+#include "PortTypeSupportC.inl"
+#endif /* defined INLINE */
+
+#endif /* ifndef */
+
+
diff --git a/dds_io_sub/PortTypeSupportC.inl b/dds_io_sub/PortTypeSupportC.inl
new file mode 100644
index 0000000..38aa325
--- /dev/null
+++ b/dds_io_sub/PortTypeSupportC.inl
@@ -0,0 +1,28 @@
+// -*- C++ -*-
+//
+// $Id$
+
+// ****  Code generated by the The ACE ORB (TAO) IDL Compiler ****
+// TAO and the TAO IDL Compiler have been developed by:
+//       Center for Distributed Object Computing
+//       Washington University
+//       St. Louis, MO
+//       USA
+//       http://www.cs.wustl.edu/~schmidt/doc-center.html
+// and
+//       Distributed Object Computing Laboratory
+//       University of California at Irvine
+//       Irvine, CA
+//       USA
+//       http://doc.ece.uci.edu/
+// and
+//       Institute for Software Integrated Systems
+//       Vanderbilt University
+//       Nashville, TN
+//       USA
+//       http://www.isis.vanderbilt.edu/
+//
+// Information about TAO is available at:
+//     http://www.cs.wustl.edu/~schmidt/TAO.html
+
+
diff --git a/dds_io_sub/PortTypeSupportI.cpp b/dds_io_sub/PortTypeSupportI.cpp
new file mode 100644
index 0000000..be0f12b
--- /dev/null
+++ b/dds_io_sub/PortTypeSupportI.cpp
@@ -0,0 +1,454 @@
+// -*- C++ -*-
+//
+// $Id$
+
+// ****  Code generated by the The ACE ORB (TAO) IDL Compiler ****
+// TAO and the TAO IDL Compiler have been developed by:
+//       Center for Distributed Object Computing
+//       Washington University
+//       St. Louis, MO
+//       USA
+//       http://www.cs.wustl.edu/~schmidt/doc-center.html
+// and
+//       Distributed Object Computing Laboratory
+//       University of California at Irvine
+//       Irvine, CA
+//       USA
+//       http://doc.ece.uci.edu/
+// and
+//       Institute for Software Integrated Systems
+//       Vanderbilt University
+//       Nashville, TN
+//       USA
+//       http://www.isis.vanderbilt.edu/
+//
+// Information about TAO is available at:
+//     http://www.cs.wustl.edu/~schmidt/TAO.html
+
+// TAO_IDL - Generated from 
+// be/be_codegen.cpp:1189
+
+#include "PortTypeSupportI.h"
+
+// Implementation skeleton constructor
+IOTest_PortTypeSupport_i::IOTest_PortTypeSupport_i (void)
+{
+}
+
+// Implementation skeleton destructor
+IOTest_PortTypeSupport_i::~IOTest_PortTypeSupport_i (void)
+{
+}
+
+::DDS::ReturnCode_t IOTest_PortTypeSupport_i::register_type (
+    ::DDS::DomainParticipant_ptr participant,
+    const char * type_name)
+{
+  // Add your implementation here
+}
+
+char * IOTest_PortTypeSupport_i::get_type_name (
+    void)
+{
+  // Add your implementation here
+}
+
+::DDS::DataWriter_ptr IOTest_PortTypeSupport_i::create_datawriter (
+    void)
+{
+  // Add your implementation here
+}
+
+::DDS::DataReader_ptr IOTest_PortTypeSupport_i::create_datareader (
+    void)
+{
+  // Add your implementation here
+}
+
+// Implementation skeleton constructor
+IOTest_PortDataWriter_i::IOTest_PortDataWriter_i (void)
+{
+}
+
+// Implementation skeleton destructor
+IOTest_PortDataWriter_i::~IOTest_PortDataWriter_i (void)
+{
+}
+
+::DDS::InstanceHandle_t IOTest_PortDataWriter_i::_cxx_register (
+    const ::IOTest::Port & instance_data)
+{
+  // Add your implementation here
+}
+
+::DDS::InstanceHandle_t IOTest_PortDataWriter_i::register_w_timestamp (
+    const ::IOTest::Port & instance_data,
+    ::DDS::InstanceHandle_t handle,
+    const ::DDS::Time_t & source_timestamp)
+{
+  // Add your implementation here
+}
+
+::DDS::ReturnCode_t IOTest_PortDataWriter_i::unregister (
+    const ::IOTest::Port & instance_data,
+    ::DDS::InstanceHandle_t handle)
+{
+  // Add your implementation here
+}
+
+::DDS::ReturnCode_t IOTest_PortDataWriter_i::unregister_w_timestamp (
+    const ::IOTest::Port & instance_data,
+    ::DDS::InstanceHandle_t handle,
+    const ::DDS::Time_t & source_timestamp)
+{
+  // Add your implementation here
+}
+
+::DDS::ReturnCode_t IOTest_PortDataWriter_i::write (
+    const ::IOTest::Port & instance_data,
+    ::DDS::InstanceHandle_t handle)
+{
+  // Add your implementation here
+}
+
+::DDS::ReturnCode_t IOTest_PortDataWriter_i::write_w_timestamp (
+    const ::IOTest::Port & instance_data,
+    ::DDS::InstanceHandle_t handle,
+    const ::DDS::Time_t & source_timestamp)
+{
+  // Add your implementation here
+}
+
+::DDS::ReturnCode_t IOTest_PortDataWriter_i::dispose (
+    const ::IOTest::Port & instance_data,
+    ::DDS::InstanceHandle_t instance_handle)
+{
+  // Add your implementation here
+}
+
+::DDS::ReturnCode_t IOTest_PortDataWriter_i::dispose_w_timestamp (
+    const ::IOTest::Port & instance_data,
+    ::DDS::InstanceHandle_t instance_handle,
+    const ::DDS::Time_t & source_timestamp)
+{
+  // Add your implementation here
+}
+
+::DDS::ReturnCode_t IOTest_PortDataWriter_i::get_key_value (
+    ::IOTest::Port & key_holder,
+    ::DDS::InstanceHandle_t handle)
+{
+  // Add your implementation here
+}
+
+::DDS::ReturnCode_t IOTest_PortDataWriter_i::enable (
+    void)
+{
+  // Add your implementation here
+}
+
+::DDS::StatusKindMask IOTest_PortDataWriter_i::get_status_changes (
+    void)
+{
+  // Add your implementation here
+}
+
+::DDS::ReturnCode_t IOTest_PortDataWriter_i::set_qos (
+    const ::DDS::DataWriterQos & qos)
+{
+  // Add your implementation here
+}
+
+void IOTest_PortDataWriter_i::get_qos (
+    ::DDS::DataWriterQos & qos)
+{
+  // Add your implementation here
+}
+
+::DDS::ReturnCode_t IOTest_PortDataWriter_i::set_listener (
+    ::DDS::DataWriterListener_ptr a_listener,
+    ::DDS::StatusKindMask mask)
+{
+  // Add your implementation here
+}
+
+::DDS::DataWriterListener_ptr IOTest_PortDataWriter_i::get_listener (
+    void)
+{
+  // Add your implementation here
+}
+
+::DDS::Topic_ptr IOTest_PortDataWriter_i::get_topic (
+    void)
+{
+  // Add your implementation here
+}
+
+::DDS::Publisher_ptr IOTest_PortDataWriter_i::get_publisher (
+    void)
+{
+  // Add your implementation here
+}
+
+::DDS::LivelinessLostStatus IOTest_PortDataWriter_i::get_liveliness_lost_status (
+    void)
+{
+  // Add your implementation here
+}
+
+::DDS::OfferedDeadlineMissedStatus IOTest_PortDataWriter_i::get_offered_deadline_missed_status (
+    void)
+{
+  // Add your implementation here
+}
+
+::DDS::OfferedIncompatibleQosStatus * IOTest_PortDataWriter_i::get_offered_incompatible_qos_status (
+    void)
+{
+  // Add your implementation here
+}
+
+::DDS::PublicationMatchStatus IOTest_PortDataWriter_i::get_publication_match_status (
+    void)
+{
+  // Add your implementation here
+}
+
+void IOTest_PortDataWriter_i::assert_liveliness (
+    void)
+{
+  // Add your implementation here
+}
+
+::DDS::ReturnCode_t IOTest_PortDataWriter_i::get_matched_subscriptions (
+    ::DDS::InstanceHandleSeq & subscription_handles)
+{
+  // Add your implementation here
+}
+
+::DDS::ReturnCode_t IOTest_PortDataWriter_i::get_matched_subscription_data (
+    ::DDS::SubscriptionBuiltinTopicData & subscription_data,
+    ::DDS::InstanceHandle_t subscription_handle)
+{
+  // Add your implementation here
+}
+
+// Implementation skeleton constructor
+IOTest_PortDataReader_i::IOTest_PortDataReader_i (void)
+{
+}
+
+// Implementation skeleton destructor
+IOTest_PortDataReader_i::~IOTest_PortDataReader_i (void)
+{
+}
+
+::DDS::ReturnCode_t IOTest_PortDataReader_i::read (
+    ::IOTest::PortSeq & received_data,
+    ::DDS::SampleInfoSeq & info_seq,
+    ::CORBA::Long max_samples,
+    ::DDS::SampleStateMask sample_states,
+    ::DDS::ViewStateMask view_states,
+    ::DDS::InstanceStateMask instance_states)
+{
+  // Add your implementation here
+}
+
+::DDS::ReturnCode_t IOTest_PortDataReader_i::take (
+    ::IOTest::PortSeq & received_data,
+    ::DDS::SampleInfoSeq & info_seq,
+    ::CORBA::Long max_samples,
+    ::DDS::SampleStateMask sample_states,
+    ::DDS::ViewStateMask view_states,
+    ::DDS::InstanceStateMask instance_states)
+{
+  // Add your implementation here
+}
+
+::DDS::ReturnCode_t IOTest_PortDataReader_i::read_next_sample (
+    ::IOTest::Port & received_data,
+    ::DDS::SampleInfo & sample_info)
+{
+  // Add your implementation here
+}
+
+::DDS::ReturnCode_t IOTest_PortDataReader_i::take_next_sample (
+    ::IOTest::Port & received_data,
+    ::DDS::SampleInfo & sample_info)
+{
+  // Add your implementation here
+}
+
+::DDS::ReturnCode_t IOTest_PortDataReader_i::read_instance (
+    ::IOTest::PortSeq & received_data,
+    ::DDS::SampleInfoSeq & info_seq,
+    ::CORBA::Long max_samples,
+    ::DDS::InstanceHandle_t a_handle,
+    ::DDS::SampleStateMask sample_states,
+    ::DDS::ViewStateMask view_states,
+    ::DDS::InstanceStateMask instance_states)
+{
+  // Add your implementation here
+}
+
+::DDS::ReturnCode_t IOTest_PortDataReader_i::take_instance (
+    ::IOTest::PortSeq & received_data,
+    ::DDS::SampleInfoSeq & info_seq,
+    ::CORBA::Long max_samples,
+    ::DDS::InstanceHandle_t a_handle,
+    ::DDS::SampleStateMask sample_states,
+    ::DDS::ViewStateMask view_states,
+    ::DDS::InstanceStateMask instance_states)
+{
+  // Add your implementation here
+}
+
+::DDS::ReturnCode_t IOTest_PortDataReader_i::read_next_instance (
+    ::IOTest::PortSeq & received_data,
+    ::DDS::SampleInfoSeq & info_seq,
+    ::CORBA::Long max_samples,
+    ::DDS::InstanceHandle_t a_handle,
+    ::DDS::SampleStateMask sample_states,
+    ::DDS::ViewStateMask view_states,
+    ::DDS::InstanceStateMask instance_states)
+{
+  // Add your implementation here
+}
+
+::DDS::ReturnCode_t IOTest_PortDataReader_i::take_next_instance (
+    ::IOTest::PortSeq & received_data,
+    ::DDS::SampleInfoSeq & info_seq,
+    ::CORBA::Long max_samples,
+    ::DDS::InstanceHandle_t a_handle,
+    ::DDS::SampleStateMask sample_states,
+    ::DDS::ViewStateMask view_states,
+    ::DDS::InstanceStateMask instance_states)
+{
+  // Add your implementation here
+}
+
+::DDS::ReturnCode_t IOTest_PortDataReader_i::return_loan (
+    ::IOTest::PortSeq & received_data,
+    ::DDS::SampleInfoSeq & info_seq)
+{
+  // Add your implementation here
+}
+
+::DDS::ReturnCode_t IOTest_PortDataReader_i::get_key_value (
+    ::IOTest::Port & key_holder,
+    ::DDS::InstanceHandle_t handle)
+{
+  // Add your implementation here
+}
+
+::DDS::ReturnCode_t IOTest_PortDataReader_i::enable (
+    void)
+{
+  // Add your implementation here
+}
+
+::DDS::StatusKindMask IOTest_PortDataReader_i::get_status_changes (
+    void)
+{
+  // Add your implementation here
+}
+
+::DDS::ReturnCode_t IOTest_PortDataReader_i::delete_contained_entities (
+    void)
+{
+  // Add your implementation here
+}
+
+::DDS::ReturnCode_t IOTest_PortDataReader_i::set_qos (
+    const ::DDS::DataReaderQos & qos)
+{
+  // Add your implementation here
+}
+
+void IOTest_PortDataReader_i::get_qos (
+    ::DDS::DataReaderQos & qos)
+{
+  // Add your implementation here
+}
+
+::DDS::ReturnCode_t IOTest_PortDataReader_i::set_listener (
+    ::DDS::DataReaderListener_ptr a_listener,
+    ::DDS::StatusKindMask mask)
+{
+  // Add your implementation here
+}
+
+::DDS::DataReaderListener_ptr IOTest_PortDataReader_i::get_listener (
+    void)
+{
+  // Add your implementation here
+}
+
+::DDS::TopicDescription_ptr IOTest_PortDataReader_i::get_topicdescription (
+    void)
+{
+  // Add your implementation here
+}
+
+::DDS::Subscriber_ptr IOTest_PortDataReader_i::get_subscriber (
+    void)
+{
+  // Add your implementation here
+}
+
+::DDS::SampleRejectedStatus IOTest_PortDataReader_i::get_sample_rejected_status (
+    void)
+{
+  // Add your implementation here
+}
+
+::DDS::LivelinessChangedStatus IOTest_PortDataReader_i::get_liveliness_changed_status (
+    void)
+{
+  // Add your implementation here
+}
+
+::DDS::RequestedDeadlineMissedStatus IOTest_PortDataReader_i::get_requested_deadline_missed_status (
+    void)
+{
+  // Add your implementation here
+}
+
+::DDS::RequestedIncompatibleQosStatus * IOTest_PortDataReader_i::get_requested_incompatible_qos_status (
+    void)
+{
+  // Add your implementation here
+}
+
+::DDS::SubscriptionMatchStatus IOTest_PortDataReader_i::get_subscription_match_status (
+    void)
+{
+  // Add your implementation here
+}
+
+::DDS::SampleLostStatus IOTest_PortDataReader_i::get_sample_lost_status (
+    void)
+{
+  // Add your implementation here
+}
+
+::DDS::ReturnCode_t IOTest_PortDataReader_i::wait_for_historical_data (
+    const ::DDS::Duration_t & max_wait)
+{
+  // Add your implementation here
+}
+
+::DDS::ReturnCode_t IOTest_PortDataReader_i::get_matched_publications (
+    ::DDS::InstanceHandleSeq & publication_handles)
+{
+  // Add your implementation here
+}
+
+::DDS::ReturnCode_t IOTest_PortDataReader_i::get_matched_publication_data (
+    ::DDS::PublicationBuiltinTopicData & publication_data,
+    ::DDS::InstanceHandle_t publication_handle)
+{
+  // Add your implementation here
+}
+
+
diff --git a/dds_io_sub/PortTypeSupportI.h b/dds_io_sub/PortTypeSupportI.h
new file mode 100644
index 0000000..ddd7c4f
--- /dev/null
+++ b/dds_io_sub/PortTypeSupportI.h
@@ -0,0 +1,359 @@
+// -*- C++ -*-
+//
+// $Id$
+
+// ****  Code generated by the The ACE ORB (TAO) IDL Compiler ****
+// TAO and the TAO IDL Compiler have been developed by:
+//       Center for Distributed Object Computing
+//       Washington University
+//       St. Louis, MO
+//       USA
+//       http://www.cs.wustl.edu/~schmidt/doc-center.html
+// and
+//       Distributed Object Computing Laboratory
+//       University of California at Irvine
+//       Irvine, CA
+//       USA
+//       http://doc.ece.uci.edu/
+// and
+//       Institute for Software Integrated Systems
+//       Vanderbilt University
+//       Nashville, TN
+//       USA
+//       http://www.isis.vanderbilt.edu/
+//
+// Information about TAO is available at:
+//     http://www.cs.wustl.edu/~schmidt/TAO.html
+
+// TAO_IDL - Generated from 
+// be/be_codegen.cpp:1126
+
+#ifndef PORTTYPESUPPORTI_H_
+#define PORTTYPESUPPORTI_H_
+
+#include "PortTypeSupportS.h"
+
+#if !defined (ACE_LACKS_PRAGMA_ONCE)
+#pragma once
+#endif /* ACE_LACKS_PRAGMA_ONCE */
+
+#include "tao/LocalObject.h"
+
+class  IOTest_PortTypeSupport_i
+  : public virtual IOTest::PortTypeSupport,
+    public virtual TAO_Local_RefCounted_Object
+{
+public:
+  // Constructor 
+  IOTest_PortTypeSupport_i (void);
+  
+  // Destructor 
+  virtual ~IOTest_PortTypeSupport_i (void);
+  
+  virtual
+  ::DDS::ReturnCode_t register_type (
+      ::DDS::DomainParticipant_ptr participant,
+      const char * type_name) = 0;
+  
+  virtual
+  char * get_type_name (
+      void) = 0;
+  
+  virtual
+  ::DDS::DataWriter_ptr create_datawriter (
+      void) = 0;
+  
+  virtual
+  ::DDS::DataReader_ptr create_datareader (
+      void) = 0;
+};
+
+class  IOTest_PortDataWriter_i
+  : public virtual IOTest::PortDataWriter,
+    public virtual TAO_Local_RefCounted_Object
+{
+public:
+  // Constructor 
+  IOTest_PortDataWriter_i (void);
+  
+  // Destructor 
+  virtual ~IOTest_PortDataWriter_i (void);
+  
+  virtual
+  ::DDS::InstanceHandle_t _cxx_register (
+      const ::IOTest::Port & instance_data) = 0;
+  
+  virtual
+  ::DDS::InstanceHandle_t register_w_timestamp (
+      const ::IOTest::Port & instance_data,
+      ::DDS::InstanceHandle_t handle,
+      const ::DDS::Time_t & source_timestamp) = 0;
+  
+  virtual
+  ::DDS::ReturnCode_t unregister (
+      const ::IOTest::Port & instance_data,
+      ::DDS::InstanceHandle_t handle) = 0;
+  
+  virtual
+  ::DDS::ReturnCode_t unregister_w_timestamp (
+      const ::IOTest::Port & instance_data,
+      ::DDS::InstanceHandle_t handle,
+      const ::DDS::Time_t & source_timestamp) = 0;
+  
+  virtual
+  ::DDS::ReturnCode_t write (
+      const ::IOTest::Port & instance_data,
+      ::DDS::InstanceHandle_t handle) = 0;
+  
+  virtual
+  ::DDS::ReturnCode_t write_w_timestamp (
+      const ::IOTest::Port & instance_data,
+      ::DDS::InstanceHandle_t handle,
+      const ::DDS::Time_t & source_timestamp) = 0;
+  
+  virtual
+  ::DDS::ReturnCode_t dispose (
+      const ::IOTest::Port & instance_data,
+      ::DDS::InstanceHandle_t instance_handle) = 0;
+  
+  virtual
+  ::DDS::ReturnCode_t dispose_w_timestamp (
+      const ::IOTest::Port & instance_data,
+      ::DDS::InstanceHandle_t instance_handle,
+      const ::DDS::Time_t & source_timestamp) = 0;
+  
+  virtual
+  ::DDS::ReturnCode_t get_key_value (
+      ::IOTest::Port & key_holder,
+      ::DDS::InstanceHandle_t handle) = 0;
+  
+  virtual
+  ::DDS::ReturnCode_t enable (
+      void) = 0;
+  
+  virtual
+  ::DDS::StatusKindMask get_status_changes (
+      void) = 0;
+  
+  virtual
+  ::DDS::ReturnCode_t set_qos (
+      const ::DDS::DataWriterQos & qos) = 0;
+  
+  virtual
+  void get_qos (
+      ::DDS::DataWriterQos & qos) = 0;
+  
+  virtual
+  ::DDS::ReturnCode_t set_listener (
+      ::DDS::DataWriterListener_ptr a_listener,
+      ::DDS::StatusKindMask mask) = 0;
+  
+  virtual
+  ::DDS::DataWriterListener_ptr get_listener (
+      void) = 0;
+  
+  virtual
+  ::DDS::Topic_ptr get_topic (
+      void) = 0;
+  
+  virtual
+  ::DDS::Publisher_ptr get_publisher (
+      void) = 0;
+  
+  virtual
+  ::DDS::LivelinessLostStatus get_liveliness_lost_status (
+      void) = 0;
+  
+  virtual
+  ::DDS::OfferedDeadlineMissedStatus get_offered_deadline_missed_status (
+      void) = 0;
+  
+  virtual
+  ::DDS::OfferedIncompatibleQosStatus * get_offered_incompatible_qos_status (
+      void) = 0;
+  
+  virtual
+  ::DDS::PublicationMatchStatus get_publication_match_status (
+      void) = 0;
+  
+  virtual
+  void assert_liveliness (
+      void) = 0;
+  
+  virtual
+  ::DDS::ReturnCode_t get_matched_subscriptions (
+      ::DDS::InstanceHandleSeq & subscription_handles) = 0;
+  
+  virtual
+  ::DDS::ReturnCode_t get_matched_subscription_data (
+      ::DDS::SubscriptionBuiltinTopicData & subscription_data,
+      ::DDS::InstanceHandle_t subscription_handle) = 0;
+};
+
+class  IOTest_PortDataReader_i
+  : public virtual IOTest::PortDataReader,
+    public virtual TAO_Local_RefCounted_Object
+{
+public:
+  // Constructor 
+  IOTest_PortDataReader_i (void);
+  
+  // Destructor 
+  virtual ~IOTest_PortDataReader_i (void);
+  
+  virtual
+  ::DDS::ReturnCode_t read (
+      ::IOTest::PortSeq & received_data,
+      ::DDS::SampleInfoSeq & info_seq,
+      ::CORBA::Long max_samples,
+      ::DDS::SampleStateMask sample_states,
+      ::DDS::ViewStateMask view_states,
+      ::DDS::InstanceStateMask instance_states) = 0;
+  
+  virtual
+  ::DDS::ReturnCode_t take (
+      ::IOTest::PortSeq & received_data,
+      ::DDS::SampleInfoSeq & info_seq,
+      ::CORBA::Long max_samples,
+      ::DDS::SampleStateMask sample_states,
+      ::DDS::ViewStateMask view_states,
+      ::DDS::InstanceStateMask instance_states) = 0;
+  
+  virtual
+  ::DDS::ReturnCode_t read_next_sample (
+      ::IOTest::Port & received_data,
+      ::DDS::SampleInfo & sample_info) = 0;
+  
+  virtual
+  ::DDS::ReturnCode_t take_next_sample (
+      ::IOTest::Port & received_data,
+      ::DDS::SampleInfo & sample_info) = 0;
+  
+  virtual
+  ::DDS::ReturnCode_t read_instance (
+      ::IOTest::PortSeq & received_data,
+      ::DDS::SampleInfoSeq & info_seq,
+      ::CORBA::Long max_samples,
+      ::DDS::InstanceHandle_t a_handle,
+      ::DDS::SampleStateMask sample_states,
+      ::DDS::ViewStateMask view_states,
+      ::DDS::InstanceStateMask instance_states) = 0;
+  
+  virtual
+  ::DDS::ReturnCode_t take_instance (
+      ::IOTest::PortSeq & received_data,
+      ::DDS::SampleInfoSeq & info_seq,
+      ::CORBA::Long max_samples,
+      ::DDS::InstanceHandle_t a_handle,
+      ::DDS::SampleStateMask sample_states,
+      ::DDS::ViewStateMask view_states,
+      ::DDS::InstanceStateMask instance_states) = 0;
+  
+  virtual
+  ::DDS::ReturnCode_t read_next_instance (
+      ::IOTest::PortSeq & received_data,
+      ::DDS::SampleInfoSeq & info_seq,
+      ::CORBA::Long max_samples,
+      ::DDS::InstanceHandle_t a_handle,
+      ::DDS::SampleStateMask sample_states,
+      ::DDS::ViewStateMask view_states,
+      ::DDS::InstanceStateMask instance_states) = 0;
+  
+  virtual
+  ::DDS::ReturnCode_t take_next_instance (
+      ::IOTest::PortSeq & received_data,
+      ::DDS::SampleInfoSeq & info_seq,
+      ::CORBA::Long max_samples,
+      ::DDS::InstanceHandle_t a_handle,
+      ::DDS::SampleStateMask sample_states,
+      ::DDS::ViewStateMask view_states,
+      ::DDS::InstanceStateMask instance_states) = 0;
+  
+  virtual
+  ::DDS::ReturnCode_t return_loan (
+      ::IOTest::PortSeq & received_data,
+      ::DDS::SampleInfoSeq & info_seq) = 0;
+  
+  virtual
+  ::DDS::ReturnCode_t get_key_value (
+      ::IOTest::Port & key_holder,
+      ::DDS::InstanceHandle_t handle) = 0;
+  
+  virtual
+  ::DDS::ReturnCode_t enable (
+      void) = 0;
+  
+  virtual
+  ::DDS::StatusKindMask get_status_changes (
+      void) = 0;
+  
+  virtual
+  ::DDS::ReturnCode_t delete_contained_entities (
+      void) = 0;
+  
+  virtual
+  ::DDS::ReturnCode_t set_qos (
+      const ::DDS::DataReaderQos & qos) = 0;
+  
+  virtual
+  void get_qos (
+      ::DDS::DataReaderQos & qos) = 0;
+  
+  virtual
+  ::DDS::ReturnCode_t set_listener (
+      ::DDS::DataReaderListener_ptr a_listener,
+      ::DDS::StatusKindMask mask) = 0;
+  
+  virtual
+  ::DDS::DataReaderListener_ptr get_listener (
+      void) = 0;
+  
+  virtual
+  ::DDS::TopicDescription_ptr get_topicdescription (
+      void) = 0;
+  
+  virtual
+  ::DDS::Subscriber_ptr get_subscriber (
+      void) = 0;
+  
+  virtual
+  ::DDS::SampleRejectedStatus get_sample_rejected_status (
+      void) = 0;
+  
+  virtual
+  ::DDS::LivelinessChangedStatus get_liveliness_changed_status (
+      void) = 0;
+  
+  virtual
+  ::DDS::RequestedDeadlineMissedStatus get_requested_deadline_missed_status (
+      void) = 0;
+  
+  virtual
+  ::DDS::RequestedIncompatibleQosStatus * get_requested_incompatible_qos_status (
+      void) = 0;
+  
+  virtual
+  ::DDS::SubscriptionMatchStatus get_subscription_match_status (
+      void) = 0;
+  
+  virtual
+  ::DDS::SampleLostStatus get_sample_lost_status (
+      void) = 0;
+  
+  virtual
+  ::DDS::ReturnCode_t wait_for_historical_data (
+      const ::DDS::Duration_t & max_wait) = 0;
+  
+  virtual
+  ::DDS::ReturnCode_t get_matched_publications (
+      ::DDS::InstanceHandleSeq & publication_handles) = 0;
+  
+  virtual
+  ::DDS::ReturnCode_t get_matched_publication_data (
+      ::DDS::PublicationBuiltinTopicData & publication_data,
+      ::DDS::InstanceHandle_t publication_handle) = 0;
+};
+
+
+#endif /* PORTTYPESUPPORTI_H_  */
+
diff --git a/dds_io_sub/PortTypeSupportImpl.cpp b/dds_io_sub/PortTypeSupportImpl.cpp
new file mode 100644
index 0000000..bcd2891
--- /dev/null
+++ b/dds_io_sub/PortTypeSupportImpl.cpp
@@ -0,0 +1,1939 @@
+// -*- C++ -*-
+//
+// $Id: CPPTemplate.pm 899 2007-07-05 16:36:52Z mitza $
+
+// Generated by dcsp_ts.pl
+
+
+#include "dds/DCPS/debug.h"
+#include "dds/DCPS/Registered_Data_Types.h"
+#include "dds/DdsDcpsDomainC.h"
+#include "dds/DCPS/Service_Participant.h"
+#include "dds/DCPS/Qos_Helper.h"
+#include "dds/DCPS/PublicationInstance.h"
+#include "dds/DCPS/PublisherImpl.h"
+#include "dds/DCPS/SubscriberImpl.h"
+#include "dds/DCPS/ReceivedDataElementList.h"
+#include "dds/DCPS/transport/framework/TransportInterface.h"
+#include "dds/DCPS/Util.h"
+#include "PortTypeSupportImpl.h"
+
+
+namespace
+{
+  using ::OpenDDS::DCPS::DataReaderImpl;
+
+  typedef ::IOTest::PortSeq::PrivateMemberAccess SequenceType;
+
+  struct LoanerGuard
+  {
+    LoanerGuard(SequenceType& seq, DataReaderImpl* dataReader)
+      : seq_(seq)
+      , dataReader_(dataReader)
+      , set_(false)
+    {}
+
+    void set() { set_ = true; }
+
+    ~LoanerGuard()
+    {
+      if(set_) seq_.set_loaner(dataReader_);
+    }
+
+    SequenceType& seq_;
+    DataReaderImpl* dataReader_;
+    bool set_;
+  };
+}
+
+
+namespace IOTest {
+
+
+// VC6 can not understand the baseclass calling syntax
+typedef OpenDDS::DCPS::DataWriterImpl OPENDDS_DCPS_DataWriterImpl;
+typedef OpenDDS::DCPS::DataReaderImpl OPENDDS_DCPS_DataReaderImpl;
+
+// Implementation skeleton constructor
+PortTypeSupportImpl::PortTypeSupportImpl (void)
+{
+}
+
+// Implementation skeleton destructor
+PortTypeSupportImpl::~PortTypeSupportImpl (void)
+{
+}
+
+DDS::ReturnCode_t
+PortTypeSupportImpl::register_type (
+    ::DDS::DomainParticipant_ptr participant,
+    const char * type_name
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  if (type_name == 0 || type_name[0] == '\0')
+     this->type_name_ = this->get_type_name();
+  else
+     this->type_name_ = CORBA::string_dup (type_name);
+
+  return ::OpenDDS::DCPS::Registered_Data_Types->register_type(participant,
+                                                           this->type_name_.in (),
+                                                           this);
+}
+
+
+char *
+PortTypeSupportImpl::get_type_name (
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  if (this->type_name_ == NULL)
+    return CORBA::string_dup (this->_interface_repository_id());
+  else
+    return CORBA::string_dup (this->type_name_.in ());
+}
+
+
+::DDS::DataWriter_ptr
+PortTypeSupportImpl::create_datawriter (
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+    PortDataWriterImpl* writer_impl;
+    ACE_NEW_RETURN(writer_impl,
+                   PortDataWriterImpl(),
+                   ::DDS::DataWriter::_nil());
+
+
+    ::DDS::DataWriter_ptr writer_obj
+        = ::OpenDDS::DCPS::servant_to_reference (writer_impl);
+
+    return writer_obj;
+}
+
+::DDS::DataReader_ptr
+PortTypeSupportImpl::create_datareader (
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+    PortDataReaderImpl* reader_impl = 0;
+    ACE_NEW_RETURN(reader_impl,
+                    PortDataReaderImpl(),
+                    ::DDS::DataReader::_nil());
+
+
+    ::DDS::DataReader_ptr reader_obj
+            = ::OpenDDS::DCPS::servant_to_reference (reader_impl);
+
+    return reader_obj;
+}
+
+}; // IOTest
+
+
+namespace IOTest {
+
+
+// Implementation skeleton constructor
+PortDataWriterImpl::PortDataWriterImpl (void)
+: marshaled_size_ (0),
+  db_lock_pool_(0),
+  data_allocator_ (0),
+  mb_allocator_ (0),
+  db_allocator_ (0)
+{
+}
+
+// Implementation skeleton destructor
+PortDataWriterImpl::~PortDataWriterImpl (void)
+{
+  delete data_allocator_;
+  delete mb_allocator_;
+  delete db_allocator_;
+  delete db_lock_pool_;
+}
+
+DDS::InstanceHandle_t
+PortDataWriterImpl::_cxx_register (
+    const ::IOTest::Port & instance_data
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  ::DDS::Time_t source_timestamp
+    = ::OpenDDS::DCPS::time_value_to_time (ACE_OS::gettimeofday ());
+  return register_w_timestamp (instance_data,
+                               ::OpenDDS::DCPS::HANDLE_NIL,
+                               source_timestamp);
+}
+
+DDS::InstanceHandle_t
+PortDataWriterImpl::register_w_timestamp (
+    const ::IOTest::Port & instance_data,
+    ::DDS::InstanceHandle_t handle,
+    const ::DDS::Time_t & source_timestamp
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  ACE_UNUSED_ARG (handle);
+  ACE_GUARD_RETURN (ACE_Recursive_Thread_Mutex,
+                    guard,
+                    get_lock (),
+                    ::DDS::RETCODE_ERROR);
+  ::DDS::InstanceHandle_t registered_handle;
+  ::DDS::ReturnCode_t ret
+    = this->get_or_create_instance_handle(registered_handle,
+                                          instance_data,
+                                          source_timestamp);
+  if (ret != ::DDS::RETCODE_OK)
+  {
+      ACE_ERROR ((LM_ERROR,
+                  ACE_TEXT("(%P|%t) ")
+                  ACE_TEXT("PortDataWriterImpl::register_w_timestamp, ")
+                  ACE_TEXT("register failed error=%d.\n"),
+                  ret));
+  }
+
+  return registered_handle;
+}
+
+
+DDS::ReturnCode_t
+PortDataWriterImpl::unregister (
+    const ::IOTest::Port & instance_data,
+    ::DDS::InstanceHandle_t handle
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  ::DDS::Time_t source_timestamp
+    = ::OpenDDS::DCPS::time_value_to_time (ACE_OS::gettimeofday ());
+  return unregister_w_timestamp (instance_data,
+                                 handle,
+                                 source_timestamp);
+}
+
+DDS::ReturnCode_t
+PortDataWriterImpl::unregister_w_timestamp (
+    const ::IOTest::Port & instance_data,
+    ::DDS::InstanceHandle_t handle,
+    const ::DDS::Time_t & source_timestamp
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  ACE_GUARD_RETURN (ACE_Recursive_Thread_Mutex,
+                    guard,
+                    get_lock (),
+                    ::DDS::RETCODE_ERROR);
+  ::DDS::InstanceHandle_t registered_handle
+      = this->get_instance_handle(instance_data);
+
+  if(registered_handle == ::OpenDDS::DCPS::HANDLE_NIL)
+  {
+    // This case could be the instance is not registered yet or
+    // already unregistered.
+    ACE_ERROR_RETURN ((LM_ERROR,
+                        ACE_TEXT("(%P|%t) ")
+                        ACE_TEXT("PortDataWriterImpl::unregister, ")
+                        ACE_TEXT("The instance is not registered.\n")),
+                        ::DDS::RETCODE_ERROR);
+  }
+  else if (handle != ::OpenDDS::DCPS::HANDLE_NIL && handle != registered_handle)
+  {
+    ACE_ERROR_RETURN ((LM_ERROR,
+                        ACE_TEXT("(%P|%t) ")
+                        ACE_TEXT("PortDataWriterImpl::unregister, ")
+                        ACE_TEXT("The given handle=%X is different from "
+                        "registered handle=%X.\n"),
+                        handle, registered_handle),
+                        ::DDS::RETCODE_ERROR);
+  }
+
+  // DataWriterImpl::unregister will call back to inform the PortDataWriter
+  // that the instance handle is removed from there and hence PortDataWriter
+  // can remove the instance here.
+  return this->OPENDDS_DCPS_DataWriterImpl::unregister(handle, source_timestamp);
+}
+
+DDS::ReturnCode_t
+PortDataWriterImpl::write (
+    const ::IOTest::Port & instance_data,
+    ::DDS::InstanceHandle_t handle
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  ::DDS::Time_t source_timestamp
+    = ::OpenDDS::DCPS::time_value_to_time (ACE_OS::gettimeofday ());
+  return write_w_timestamp (instance_data,
+                            handle,
+                            source_timestamp);
+}
+
+DDS::ReturnCode_t
+PortDataWriterImpl::write_w_timestamp (
+    const ::IOTest::Port & instance_data,
+    ::DDS::InstanceHandle_t handle,
+    const ::DDS::Time_t & source_timestamp
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  //  A lock is obtained on entering this method to serialize access to
+  //  the contained data storage and interfaces.  This lock protects the
+  //  marshaled data buffers as well as the instance data containers.
+
+  //  This operation assumes the provided handle is valid. The handle
+  //  provided will not be verified.
+
+  ACE_GUARD_RETURN (ACE_Recursive_Thread_Mutex,
+                    guard,
+                    get_lock (),
+                    ::DDS::RETCODE_ERROR);
+
+  ACE_Message_Block* marshalled = 0;
+
+  if (handle == ::DDS::HANDLE_NIL)
+  {
+    ::DDS::InstanceHandle_t registered_handle = ::DDS::HANDLE_NIL;
+    ::DDS::ReturnCode_t ret
+      = this->get_or_create_instance_handle(registered_handle,
+                                            instance_data,
+                                            source_timestamp);
+    if (ret != ::DDS::RETCODE_OK)
+    {
+      ACE_ERROR_RETURN ((LM_ERROR,
+                  ACE_TEXT("(%P|%t) ")
+                  ACE_TEXT("PortDataWriterImpl::write, ")
+                  ACE_TEXT("register failed err=%d.\n"),
+                  ret), ret);
+    }
+
+    handle = registered_handle;
+  }
+
+  marshalled = dds_marshal (instance_data); // FOR_WRITE - using cached allocators
+  return this->OPENDDS_DCPS_DataWriterImpl::write(marshalled, handle, source_timestamp);
+}
+
+DDS::ReturnCode_t
+PortDataWriterImpl::dispose (
+    const ::IOTest::Port & instance_data,
+    ::DDS::InstanceHandle_t instance_handle
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  ::DDS::Time_t source_timestamp
+    = ::OpenDDS::DCPS::time_value_to_time (ACE_OS::gettimeofday ());
+  return dispose_w_timestamp (instance_data,
+                              instance_handle,
+                              source_timestamp);
+}
+
+DDS::ReturnCode_t
+PortDataWriterImpl::dispose_w_timestamp (
+    const ::IOTest::Port & instance_data,
+    ::DDS::InstanceHandle_t instance_handle,
+    const ::DDS::Time_t & source_timestamp
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  ACE_GUARD_RETURN (ACE_Recursive_Thread_Mutex,
+                    guard,
+                    get_lock (),
+                    ::DDS::RETCODE_ERROR);
+
+  if(instance_handle == ::OpenDDS::DCPS::HANDLE_NIL)
+  {
+    instance_handle = this->get_instance_handle(instance_data);
+    if (instance_handle == ::OpenDDS::DCPS::HANDLE_NIL)
+    {
+      ACE_ERROR_RETURN ((LM_ERROR,
+                          ACE_TEXT("(%P|%t) ")
+                          ACE_TEXT("PortDataWriterImpl::dispose, ")
+                          ACE_TEXT("The instance sample is not registered.\n")),
+                          ::DDS::RETCODE_ERROR);
+    }
+  }
+
+  return this->OPENDDS_DCPS_DataWriterImpl::dispose(instance_handle, source_timestamp);
+}
+
+DDS::ReturnCode_t
+PortDataWriterImpl::get_key_value (
+    ::IOTest::Port & key_holder,
+    ::DDS::InstanceHandle_t handle
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  ACE_GUARD_RETURN (ACE_Recursive_Thread_Mutex,
+                    guard,
+                    get_lock (),
+                    ::DDS::RETCODE_ERROR);
+  InstanceMap::iterator it;
+  for (it = instance_map_.begin ();
+        it != instance_map_.end ();
+        it ++)
+  {
+    if (it->second == handle)
+    {
+      key_holder = it->first;
+      return ::DDS::RETCODE_OK;
+    }
+  }
+
+  return ::DDS::RETCODE_ERROR;
+}
+
+
+void
+PortDataWriterImpl::init (
+      ::DDS::Topic_ptr                       topic,
+      OpenDDS::DCPS::TopicImpl                   *topic_servant,
+      const ::DDS::DataWriterQos &           qos,
+      ::DDS::DataWriterListener_ptr          a_listener,
+      OpenDDS::DCPS::DomainParticipantImpl*      participant_servant,
+      ::DDS::Publisher_ptr                   publisher,
+      OpenDDS::DCPS::PublisherImpl*              publisher_servant,
+      ::DDS::DataWriter_ptr                  dw_objref,
+        ::OpenDDS::DCPS::DataWriterRemote_ptr    dw_remote_objref
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ))
+{
+  this->OPENDDS_DCPS_DataWriterImpl::init (topic,
+                                       topic_servant,
+                                       qos,
+                                       a_listener,
+                                       participant_servant,
+                                       publisher,
+                                       publisher_servant,
+                                       dw_objref,
+                                       dw_remote_objref);
+
+  ::IOTest::Port data;
+  if (_tao_is_bounded_size (data))
+  {
+    marshaled_size_ = _dcps_max_marshaled_size (data);
+  }
+  else
+  {
+    marshaled_size_ =  0;// should use _dcps_find_size when marshaling
+  }
+}
+
+
+::DDS::ReturnCode_t
+PortDataWriterImpl::enable_specific (
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  ::IOTest::Port data;
+  if (_tao_is_bounded_size (data))
+  {
+    data_allocator_ = new DataAllocator (n_chunks_, marshaled_size_);
+    if (::OpenDDS::DCPS::DCPS_debug_level >= 2)
+      ACE_DEBUG((LM_DEBUG,"(%P|%t) PortDataWriterImpl::enable_specific-data"
+          " Dynamic_Cached_Allocator_With_Overflow %x with %d chunks\n",
+          data_allocator_, n_chunks_));
+  }
+  else
+  {
+    if (::OpenDDS::DCPS::DCPS_debug_level >= 2)
+      ACE_DEBUG((LM_DEBUG,"(%P|%t) PortDataWriterImpl::enable_specific"
+          " is unbounded data - allocate from heap\n"));
+  }
+
+  mb_allocator_ =
+   new ::OpenDDS::DCPS::MessageBlockAllocator (n_chunks_ * association_chunk_multiplier_);
+  db_allocator_ = new ::OpenDDS::DCPS::DataBlockAllocator (n_chunks_);
+
+  if (::OpenDDS::DCPS::DCPS_debug_level >= 2)
+    {
+      ACE_DEBUG((LM_DEBUG,"(%P|%t) PortDataWriterImpl::enable_specific-mb"
+          " Cached_Allocator_With_Overflow %x with %d chunks\n",
+          mb_allocator_, n_chunks_ * association_chunk_multiplier_));
+      ACE_DEBUG((LM_DEBUG,"(%P|%t) PortDataWriterImpl::enable_specific-db"
+          " Cached_Allocator_With_Overflow %x with %d chunks\n",
+          db_allocator_, n_chunks_));
+    }
+
+
+  db_lock_pool_ = new DataBlockLockPool(n_chunks_);
+
+  return ::DDS::RETCODE_OK;
+}
+
+// Note: The PortDataWriter gives ownership of the marshalled data
+//       to the WriteDataContainer.
+ACE_Message_Block*
+ PortDataWriterImpl::dds_marshal(
+                const ::IOTest::Port& instance_data,
+                int  for_write)
+{
+  ACE_Message_Block* mb;
+  if (for_write)
+  {
+    ACE_NEW_MALLOC_RETURN (mb,
+                           static_cast<ACE_Message_Block*> (
+                               mb_allocator_->malloc (
+                               sizeof (ACE_Message_Block))),
+                           ACE_Message_Block(
+                               marshaled_size_ ? marshaled_size_ :
+                                           _dcps_find_size(instance_data),
+                               ACE_Message_Block::MB_DATA,
+                               0, //cont
+                               0, //data
+                               data_allocator_, //allocator_strategy
+                               db_lock_pool_->get_lock(), //data block locking_strategy
+                               ACE_DEFAULT_MESSAGE_BLOCK_PRIORITY,
+                               ACE_Time_Value::zero,
+                               ACE_Time_Value::max_time,
+                               db_allocator_,
+                               mb_allocator_),
+                            0);
+  }
+  else
+  { // Don't use the cached allocator for the registered sample message
+    // block.
+
+    ACE_NEW_RETURN (mb,
+                    ACE_Message_Block(
+                               marshaled_size_ ? marshaled_size_ :
+                                           _dcps_find_size(instance_data) ),
+                    0);
+  }
+
+  ::TAO::DCPS::Serializer serializer (mb,
+                                      this->get_publisher_servant()->swap_bytes());
+  serializer << instance_data;
+
+  return mb;
+}
+
+::DDS::ReturnCode_t
+ PortDataWriterImpl::get_or_create_instance_handle(
+                DDS::InstanceHandle_t& handle,
+                const ::IOTest::Port& instance_data,
+                const ::DDS::Time_t & source_timestamp)
+{
+  handle = ::OpenDDS::DCPS::HANDLE_NIL;
+  InstanceMap::const_iterator it = instance_map_.find(instance_data);
+
+  int needs_creation = 1;
+  int needs_registration = 1;
+
+  if (it != instance_map_.end())
+  {
+    needs_creation = 0;
+
+    handle = it->second;
+    OpenDDS::DCPS::PublicationInstance* instance =
+      this->OPENDDS_DCPS_DataWriterImpl::get_handle_instance(handle);
+
+    if (instance->unregistered_ == false)
+    {
+      needs_registration = 0;
+    }
+    // else: The instance is unregistered and now register again.
+  }
+
+  if (needs_registration)
+  {
+    // don't use fast allocator for registration.
+    ACE_Message_Block* marshalled = this->dds_marshal(instance_data, 0); //NOT_FOR_WRITE
+
+    // tell DataWriterLocal and Publisher about the instance.
+    ::DDS::ReturnCode_t ret = register_instance(handle, marshalled, source_timestamp);
+    // note: the WriteDataContainer/PublicationInstance maintains ownership
+    // of the marshalled sample.
+
+    if (ret != ::DDS::RETCODE_OK)
+    {
+      marshalled->release ();
+      return ret;
+    }
+
+    if (needs_creation)
+    {
+      std::pair<InstanceMap::iterator, bool> pair
+          = instance_map_.insert(InstanceMap::value_type(instance_data, handle));
+      if (pair.second == false)
+      {
+        ACE_ERROR_RETURN ((LM_ERROR,
+                            ACE_TEXT("(%P|%t) "
+                            "PortDataWriterImpl::get_or_create_instance_handle, ")
+                            ACE_TEXT("insert IOTest::Port failed. \n")),
+                            ::DDS::RETCODE_ERROR);
+      }
+    } // end of if (needs_creation)
+  } // end of if (needs_registration)
+
+  return ::DDS::RETCODE_OK;
+}
+
+::DDS::InstanceHandle_t
+ PortDataWriterImpl::get_instance_handle(
+                ::IOTest::Port instance_data)
+{
+  InstanceMap::const_iterator it = instance_map_.find(instance_data);
+
+  if (it == instance_map_.end())
+  {
+    return ::OpenDDS::DCPS::HANDLE_NIL;
+  }
+  else
+  {
+    return it->second;
+  }
+}
+
+
+void
+PortDataWriterImpl::unregistered(::DDS::InstanceHandle_t   instance_handle)
+{
+  // Previously this method removed the instance from the instance_map_.
+  // The instance handle will not be removed from the
+  // map so the instance for re-registration after unregistered
+  // will use the old handle.
+  ACE_UNUSED_ARG (instance_handle);
+}
+
+}; // IOTest
+
+
+namespace IOTest {
+
+
+// Implementation skeleton constructor
+PortDataReaderImpl::PortDataReaderImpl (void)
+{
+
+}
+
+void
+PortDataReaderImpl::init (
+        OpenDDS::DCPS::TopicImpl*         a_topic,
+        const ::DDS::DataReaderQos &  qos,
+        ::DDS::DataReaderListener_ptr a_listener,
+        OpenDDS::DCPS::DomainParticipantImpl* participant,
+        OpenDDS::DCPS::SubscriberImpl*        subscriber,
+        ::DDS::Subscriber_ptr             subscriber_objref,
+        ::DDS::DataReader_ptr             dr_objerf,
+        OpenDDS::DCPS::DataReaderRemote_ptr   dr_remote_objref
+      )
+        ACE_THROW_SPEC ((
+        CORBA::SystemException
+      ))
+{
+  this->OPENDDS_DCPS_DataReaderImpl::init(a_topic,
+                                      qos,
+                                      a_listener,
+                                      participant,
+                                      subscriber,
+                                      subscriber_objref,
+                                      dr_objerf,
+                                      dr_remote_objref) ;
+
+}
+
+::DDS::ReturnCode_t
+PortDataReaderImpl::enable_specific (
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  data_allocator_ = new DataAllocator(get_n_chunks ()) ;
+    if (::OpenDDS::DCPS::DCPS_debug_level >= 2)
+      ACE_DEBUG((LM_DEBUG,"PortDataReaderImpl::enable_specific-data"
+          " Cached_Allocator_With_Overflow %x with %d chunks\n",
+          data_allocator_, this->get_n_chunks () ));
+
+  return ::DDS::RETCODE_OK;
+}
+
+// Implementation skeleton destructor
+PortDataReaderImpl::~PortDataReaderImpl (void)
+{
+  InstanceMap::iterator it;
+  for (it = instance_map_.begin ();
+       it != instance_map_.end ();
+       it ++)
+    {
+      ::DDS::InstanceHandle_t handle = it->second;
+      OpenDDS::DCPS::SubscriptionInstance *ptr =
+          this->OPENDDS_DCPS_DataReaderImpl::get_handle_instance (handle) ;
+
+      while (ptr->rcvd_sample_.size_)
+        {
+          OpenDDS::DCPS::ReceivedDataElement *head_ptr = ptr->rcvd_sample_.head_ ;
+          ptr->rcvd_sample_.remove(head_ptr) ;
+          dec_ref_data_element(head_ptr);
+        }
+
+      delete ptr ;
+    }
+
+  delete data_allocator_ ;
+  //X SHH release the data samples in the instance_map_.
+}
+
+
+DDS::ReturnCode_t
+PortDataReaderImpl::delete_contained_entities (
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  return this->delete_contained_entities() ;
+}
+
+
+// ::IOTest:: IOTest::
+DDS::ReturnCode_t
+PortDataReaderImpl::read (
+    ::IOTest::PortSeq & received_data,
+    ::DDS::SampleInfoSeq & info_seq,
+    ::CORBA::Long max_samples,
+    ::DDS::SampleStateMask sample_states,
+    ::DDS::ViewStateMask view_states,
+    ::DDS::InstanceStateMask instance_states
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  DDS::ReturnCode_t precond = check_inputs("read", received_data, info_seq, max_samples);
+  if (::DDS::RETCODE_OK != precond)
+    {
+      return precond;
+    }
+
+  ::IOTest::PortSeq::PrivateMemberAccess received_data_p (received_data);
+
+  ::CORBA::Long count(0);
+
+  ACE_GUARD_RETURN (ACE_Recursive_Thread_Mutex,
+                    guard,
+                    this->sample_lock_,
+                    ::DDS::RETCODE_ERROR);
+
+  LoanerGuard loanerGuard(received_data_p, this);
+
+  InstanceMap::iterator it;
+  for (it = instance_map_.begin ();
+       it != instance_map_.end ();
+       it ++)
+  {
+    ::CORBA::Long start_samples_in_instance(count) ;
+    ::CORBA::Long samples_in_instance_count(0) ;
+    ::DDS::InstanceHandle_t handle = it->second;
+
+    OpenDDS::DCPS::SubscriptionInstance *ptr =
+      this->OPENDDS_DCPS_DataReaderImpl::get_handle_instance (handle) ;
+      
+    bool mrg = false; //most_recent_generation   
+      
+    if ((ptr->instance_state_.view_state() & view_states) &&
+        (ptr->instance_state_.instance_state() & instance_states))
+    {
+      
+      for (OpenDDS::DCPS::ReceivedDataElement *item = ptr->rcvd_sample_.head_ ;
+           item != 0 ; item = item->next_data_sample_)
+      {
+        if (item->sample_state_ & sample_states)
+        {
+          // Increase sequence length before adding new element to sequence.
+          received_data_p.internal_set_length (count + 1);
+          if (received_data.maximum() != 0)
+          {
+            received_data_p.assign_sample(count, 
+                *(::IOTest::Port *)item->registered_data_) ;
+          }
+          else 
+          {
+            received_data_p.assign_ptr(count, item);
+            loanerGuard.set();
+          }
+          // Increase sequence length before adding new element to sequence.
+          info_seq.length (count + 1);
+          ptr->instance_state_.sample_info(info_seq[count], item) ;
+
+          item->sample_state_ = ::DDS::READ_SAMPLE_STATE ;
+
+          if (! mrg)
+            mrg = ptr->instance_state_.most_recent_generation(item);
+
+          count++ ;
+          samples_in_instance_count++ ;
+        }
+        if (count == max_samples)
+        {
+          break ;
+        }
+      } // end matches sample state
+    }  // end matches view and instance state
+
+        
+    if (samples_in_instance_count)
+    {
+      if (mrg)
+        ptr->instance_state_.accessed() ;
+        
+      //
+      // Get the sample_ranks, generation_ranks, and
+      // absolute_generation_ranks for this info_seq
+      //
+      sample_info(info_seq, start_samples_in_instance,
+                  samples_in_instance_count,
+                  ptr->rcvd_sample_.tail_) ;
+    }
+
+    if (count == max_samples)
+    {
+      break ;
+    }
+  }
+
+  if (count)
+  {
+    return ::DDS::RETCODE_OK;
+  }
+  else
+  {
+    return ::DDS::RETCODE_NO_DATA ;
+  }
+}
+
+DDS::ReturnCode_t
+PortDataReaderImpl::take (
+    ::IOTest::PortSeq & received_data,
+    ::DDS::SampleInfoSeq & info_seq,
+    ::CORBA::Long max_samples,
+    ::DDS::SampleStateMask sample_states,
+    ::DDS::ViewStateMask view_states,
+    ::DDS::InstanceStateMask instance_states
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  DDS::ReturnCode_t precond = check_inputs("take", received_data, info_seq, max_samples);
+  if (::DDS::RETCODE_OK != precond)
+    {
+      return precond;
+    }
+
+  ::IOTest::PortSeq::PrivateMemberAccess received_data_p (received_data);
+
+  ::CORBA::Long count(0) ;
+
+  ACE_GUARD_RETURN (ACE_Recursive_Thread_Mutex,
+                    guard,
+                    this->sample_lock_,
+                    ::DDS::RETCODE_ERROR);
+
+  LoanerGuard loanerGuard(received_data_p, this);
+
+  InstanceMap::iterator it;
+  for (it = instance_map_.begin ();
+       it != instance_map_.end ();
+       it ++)
+    {
+      ::CORBA::Long start_samples_in_instance(count) ;
+      ::CORBA::Long samples_in_instance_count(0) ;
+      ::DDS::InstanceHandle_t handle = it->second;
+      OpenDDS::DCPS::SubscriptionInstance *ptr =
+        this->OPENDDS_DCPS_DataReaderImpl::get_handle_instance (handle) ;
+        
+      bool mrg = false; //most_recent_generation
+
+      OpenDDS::DCPS::ReceivedDataElement *tail = 0 ;
+      if ((ptr->instance_state_.view_state() & view_states) &&
+          (ptr->instance_state_.instance_state() & instance_states))
+      {
+        
+        OpenDDS::DCPS::ReceivedDataElement *next ;
+        tail = 0 ;
+        OpenDDS::DCPS::ReceivedDataElement *item = ptr->rcvd_sample_.head_ ;
+        while (item)
+        {
+          if (item->sample_state_ & sample_states)
+            {
+              // Increase sequence length before adding new element to sequence.
+              received_data_p.internal_set_length (count + 1);
+              if (received_data.maximum() != 0)
+              {
+                received_data_p.assign_sample(count,
+                    *(::IOTest::Port *)item->registered_data_) ;
+              }
+              else
+              {
+                received_data_p.assign_ptr(count, item);
+                loanerGuard.set();
+              }
+              // Increase sequence length before adding new element to sequence.
+              info_seq.length (count + 1);
+              ptr->instance_state_.sample_info(info_seq[count], item) ;
+
+              item->sample_state_ = ::DDS::READ_SAMPLE_STATE ;
+
+              if (! mrg)
+                mrg = ptr->instance_state_.most_recent_generation(item);
+              if (item == ptr->rcvd_sample_.tail_)
+                {
+                  tail = ptr->rcvd_sample_.tail_ ;
+                  item = item->next_data_sample_ ;
+                }
+              else
+                {
+                  next = item->next_data_sample_ ;
+
+                  ptr->rcvd_sample_.remove(item) ;
+                  dec_ref_data_element(item);
+
+                  item = next ;
+                }
+
+              samples_in_instance_count++ ;
+              count++ ;
+            }
+          if (count == max_samples)
+            {
+              break ;
+            }
+        }
+      }
+    
+    if (samples_in_instance_count)
+      {
+        if (mrg)
+        ptr->instance_state_.accessed() ;
+        
+        //
+        // Get the sample_ranks, generation_ranks, and
+        // absolute_generation_ranks for this info_seq
+        //
+        if (tail)
+          {
+            sample_info(info_seq, start_samples_in_instance,
+                        samples_in_instance_count,
+                        tail) ;
+
+            ptr->rcvd_sample_.remove(tail) ;
+            dec_ref_data_element(tail);
+
+          }
+        else
+          {
+            sample_info(info_seq, start_samples_in_instance,
+                        samples_in_instance_count,
+                        ptr->rcvd_sample_.tail_) ;
+          }
+        }
+      if (count == max_samples)
+        {
+          break ;
+        }
+    }
+
+  if (count)
+    {
+      return ::DDS::RETCODE_OK;
+    }
+    else
+    {
+      return ::DDS::RETCODE_NO_DATA ;
+    }
+}
+
+DDS::ReturnCode_t
+PortDataReaderImpl::read_next_sample (
+    ::IOTest::Port & received_data,
+    ::DDS::SampleInfo & sample_info
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+
+  bool found_data = false;
+
+  ACE_GUARD_RETURN (ACE_Recursive_Thread_Mutex,
+                    guard,
+                    this->sample_lock_,
+                    ::DDS::RETCODE_ERROR);
+
+  InstanceMap::iterator it;
+  for (it = instance_map_.begin ();
+       it != instance_map_.end ();
+       it ++)
+  {
+    ::DDS::InstanceHandle_t handle = it->second;
+    OpenDDS::DCPS::SubscriptionInstance *ptr =
+      this->OPENDDS_DCPS_DataReaderImpl::get_handle_instance (handle) ;
+
+    bool mrg = false; //most_recent_generation
+
+    if ((ptr->instance_state_.view_state() & ::DDS::ANY_VIEW_STATE) &&
+        (ptr->instance_state_.instance_state() & ::DDS::ANY_INSTANCE_STATE))
+    {
+      for (OpenDDS::DCPS::ReceivedDataElement *item = ptr->rcvd_sample_.head_ ;
+           item != 0 ; item = item->next_data_sample_)
+      {
+        if (item->sample_state_ & ::DDS::NOT_READ_SAMPLE_STATE)
+        {
+          received_data =
+              *((::IOTest::Port *)item->registered_data_) ;
+          ptr->instance_state_.sample_info(sample_info, item) ;
+
+          item->sample_state_ = ::DDS::READ_SAMPLE_STATE ;
+
+             
+          if (! mrg)
+            mrg = ptr->instance_state_.most_recent_generation(item);
+            
+          found_data = true ;
+        }
+        if (found_data)
+        {
+          break ;
+        }
+      }
+    }
+
+    if (found_data)
+    {
+      if (mrg)
+        ptr->instance_state_.accessed() ;
+
+      //
+      // Get the sample_ranks, generation_ranks, and
+      // absolute_generation_ranks for this info_seq
+      //
+      this->sample_info(sample_info, ptr->rcvd_sample_.tail_) ;
+
+      break ;
+    }
+  }
+
+  if (found_data)
+    {
+      return ::DDS::RETCODE_OK;
+    }
+
+  return ::DDS::RETCODE_NO_DATA ;
+}
+
+DDS::ReturnCode_t
+PortDataReaderImpl::take_next_sample (
+    ::IOTest::Port & received_data,
+    ::DDS::SampleInfo & sample_info
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  bool found_data = false;
+
+
+  ACE_GUARD_RETURN (ACE_Recursive_Thread_Mutex,
+                    guard,
+                    this->sample_lock_,
+                    ::DDS::RETCODE_ERROR);
+
+  InstanceMap::iterator it;
+  for (it = instance_map_.begin ();
+       it != instance_map_.end ();
+       it ++)
+    {
+      ::DDS::InstanceHandle_t handle = it->second;
+      OpenDDS::DCPS::SubscriptionInstance *ptr =
+        this->OPENDDS_DCPS_DataReaderImpl::get_handle_instance (handle) ;
+      
+      bool mrg = false; //most_recent_generation
+
+      OpenDDS::DCPS::ReceivedDataElement *tail = 0 ;
+      if ((ptr->instance_state_.view_state() & ::DDS::ANY_VIEW_STATE) &&
+          (ptr->instance_state_.instance_state() & ::DDS::ANY_INSTANCE_STATE))
+      {
+        
+        OpenDDS::DCPS::ReceivedDataElement *next ;
+        tail = 0 ;
+        OpenDDS::DCPS::ReceivedDataElement *item = ptr->rcvd_sample_.head_ ;
+        while (item)
+        {
+          if (item->sample_state_ & ::DDS::NOT_READ_SAMPLE_STATE)
+            {
+              received_data =
+                  *((::IOTest::Port *)item->registered_data_) ;
+              ptr->instance_state_.sample_info(sample_info, item) ;
+
+              item->sample_state_ = ::DDS::READ_SAMPLE_STATE ;
+
+              if (! mrg)
+                mrg = ptr->instance_state_.most_recent_generation(item);
+            
+              if (item == ptr->rcvd_sample_.tail_)
+                {
+                  tail = ptr->rcvd_sample_.tail_ ;
+                  item = item->next_data_sample_ ;
+                }
+              else
+                {
+                  next = item->next_data_sample_ ;
+
+                  ptr->rcvd_sample_.remove(item) ;
+                  dec_ref_data_element(item);
+
+                  item = next ;
+                }
+
+              found_data = true;
+            }
+          if (found_data)
+            {
+              break ;
+            }
+        }
+      }
+
+    if (found_data)
+      {
+        if (mrg)
+          ptr->instance_state_.accessed() ;
+
+        //
+        // Get the sample_ranks, generation_ranks, and
+        // absolute_generation_ranks for this info_seq
+        //
+        if (tail)
+          {
+            this->sample_info(sample_info, tail) ;
+
+            ptr->rcvd_sample_.remove(tail) ;
+            dec_ref_data_element(tail);
+          }
+        else
+          {
+            this->sample_info(sample_info, ptr->rcvd_sample_.tail_) ;
+          }
+
+          break ;
+        }
+    }
+
+
+
+  if (found_data)
+    {
+      return ::DDS::RETCODE_OK;
+    }
+    else
+    {
+      return ::DDS::RETCODE_NO_DATA ;
+    }
+}
+
+DDS::ReturnCode_t
+PortDataReaderImpl::read_instance (
+    ::IOTest::PortSeq & received_data,
+    ::DDS::SampleInfoSeq & info_seq,
+    ::CORBA::Long max_samples,
+    ::DDS::InstanceHandle_t a_handle,
+    ::DDS::SampleStateMask sample_states,
+    ::DDS::ViewStateMask view_states,
+    ::DDS::InstanceStateMask instance_states
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  DDS::ReturnCode_t precond = check_inputs("read_instance", received_data, info_seq, max_samples);
+  if (::DDS::RETCODE_OK != precond)
+    {
+      return precond;
+    }
+
+  ::IOTest::PortSeq::PrivateMemberAccess received_data_p (received_data);
+
+  ::CORBA::Long count(0) ;
+
+  ACE_GUARD_RETURN (ACE_Recursive_Thread_Mutex,
+                    guard,
+                    this->sample_lock_,
+                    ::DDS::RETCODE_ERROR);
+
+  LoanerGuard loanerGuard(received_data_p, this);
+
+  OpenDDS::DCPS::SubscriptionInstance * ptr =
+      this->OPENDDS_DCPS_DataReaderImpl::get_handle_instance (a_handle) ;
+      
+  bool mrg = false; //most_recent_generation
+  	
+  if ((ptr->instance_state_.view_state() & view_states) &&
+      (ptr->instance_state_.instance_state() & instance_states))
+  {
+    for (OpenDDS::DCPS::ReceivedDataElement *item = ptr->rcvd_sample_.head_ ;
+         item != 0 ; item = item->next_data_sample_)
+    {
+      if (item->sample_state_ & sample_states)
+      {
+          // Increase sequence length before adding new element to sequence.
+          received_data_p.internal_set_length (count + 1);
+          if (received_data.maximum() != 0)
+          {
+            received_data_p.assign_sample(count, 
+                *(::IOTest::Port *)item->registered_data_) ;
+          }
+          else 
+          {
+            received_data_p.assign_ptr(count, item);
+            loanerGuard.set();
+          }
+          // Increase sequence length before adding new element to sequence.
+          info_seq.length (count + 1);
+          ptr->instance_state_.sample_info(info_seq[count], item) ;
+
+          item->sample_state_ = ::DDS::READ_SAMPLE_STATE ;
+
+          if (! mrg)
+            mrg = ptr->instance_state_.most_recent_generation(item);
+            
+          count++ ;
+      }
+
+      if (count == max_samples)
+      {
+        break ;
+      }
+    }
+  }
+
+  if (count)
+  {
+    if (mrg)
+      ptr->instance_state_.accessed() ;
+
+    //
+    // Get the sample_ranks, generation_ranks, and
+    // absolute_generation_ranks for this info_seq
+    //
+    sample_info(info_seq, 0, count, ptr->rcvd_sample_.tail_) ;
+
+    return ::DDS::RETCODE_OK;
+  }
+  else
+  {
+    return ::DDS::RETCODE_NO_DATA ;
+  }
+}
+
+DDS::ReturnCode_t
+PortDataReaderImpl::take_instance (
+    ::IOTest::PortSeq & received_data,
+    ::DDS::SampleInfoSeq & info_seq,
+    ::CORBA::Long max_samples,
+    ::DDS::InstanceHandle_t a_handle,
+    ::DDS::SampleStateMask sample_states,
+    ::DDS::ViewStateMask view_states,
+    ::DDS::InstanceStateMask instance_states
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  DDS::ReturnCode_t precond = check_inputs("take_instance", received_data, info_seq, max_samples);
+  if (::DDS::RETCODE_OK != precond)
+    {
+      return precond;
+    }
+
+  ::IOTest::PortSeq::PrivateMemberAccess received_data_p (received_data);
+
+  ::CORBA::Long count(0) ;
+
+  ACE_GUARD_RETURN (ACE_Recursive_Thread_Mutex,
+                    guard,
+                    this->sample_lock_,
+                    ::DDS::RETCODE_ERROR);
+
+  LoanerGuard loanerGuard(received_data_p, this);
+
+  OpenDDS::DCPS::SubscriptionInstance * ptr =
+    this->OPENDDS_DCPS_DataReaderImpl::get_handle_instance (a_handle) ;
+
+  OpenDDS::DCPS::ReceivedDataElement *tail = 0 ;
+  
+  bool mrg = false; //most_recent_generation
+
+  if ((ptr->instance_state_.view_state() & view_states) &&
+      (ptr->instance_state_.instance_state() & instance_states))
+  {
+      OpenDDS::DCPS::ReceivedDataElement *next ;
+      tail = 0 ;
+      OpenDDS::DCPS::ReceivedDataElement *item = ptr->rcvd_sample_.head_ ;
+      while (item)
+      {
+        if (item->sample_state_ & sample_states)
+        {
+          // Increase sequence length before adding new element to sequence.
+          received_data_p.internal_set_length (count + 1);
+          if (received_data.maximum() != 0)
+          {
+            received_data_p.assign_sample(count, 
+                *(::IOTest::Port *)item->registered_data_) ;
+          }
+          else 
+          {
+            received_data_p.assign_ptr(count, item);
+            loanerGuard.set();
+          }
+              
+          // Increase sequence length before adding new element to sequence.
+          info_seq.length (count + 1);
+          ptr->instance_state_.sample_info(info_seq[count], item) ;
+
+          item->sample_state_ = ::DDS::READ_SAMPLE_STATE ;
+
+          if (! mrg)
+            mrg = ptr->instance_state_.most_recent_generation(item);
+            if (item == ptr->rcvd_sample_.tail_)
+            {
+                tail = ptr->rcvd_sample_.tail_ ;
+                item = item->next_data_sample_ ;
+            }
+            else
+            {
+                next = item->next_data_sample_ ;
+
+                ptr->rcvd_sample_.remove(item) ;
+                dec_ref_data_element(item);
+
+                item = next ;
+            }
+
+          count++ ;
+        }
+        if (count == max_samples)
+        {
+          break ;
+        }
+      } // while sample
+    } // if view/instance state
+
+    if (count)
+    {
+      if (mrg)
+        ptr->instance_state_.accessed() ;
+
+        //
+        // Get the sample_ranks, generation_ranks, and
+        // absolute_generation_ranks for this info_seq
+        //
+        if (tail)
+          {
+      sample_info(info_seq, 0,
+                        count,
+                        tail) ;
+
+            ptr->rcvd_sample_.remove(tail) ;
+            dec_ref_data_element(tail);
+          }
+        else
+          {
+      sample_info(info_seq, 0,
+                        count,
+                        ptr->rcvd_sample_.tail_) ;
+          }
+    }
+
+  if (count)
+  {
+    return ::DDS::RETCODE_OK;
+  }
+  else
+  {
+    return ::DDS::RETCODE_NO_DATA ;
+  }
+}
+
+DDS::ReturnCode_t
+PortDataReaderImpl::read_next_instance (
+    ::IOTest::PortSeq & received_data,
+    ::DDS::SampleInfoSeq & info_seq,
+    ::CORBA::Long max_samples,
+    ::DDS::InstanceHandle_t a_handle,
+    ::DDS::SampleStateMask sample_states,
+    ::DDS::ViewStateMask view_states,
+    ::DDS::InstanceStateMask instance_states
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  ::DDS::InstanceHandle_t handle(::OpenDDS::DCPS::HANDLE_NIL) ;
+
+  ACE_GUARD_RETURN (ACE_Recursive_Thread_Mutex,
+                    guard,
+                    this->sample_lock_,
+                    ::DDS::RETCODE_ERROR);
+
+  InstanceMap::iterator it;
+  if (a_handle == ::OpenDDS::DCPS::HANDLE_NIL)
+  {
+    it = instance_map_.begin () ;
+  }
+  else
+  {
+    for (it = instance_map_.begin () ; it != instance_map_.end ();
+            it ++)
+    {
+      if (a_handle == it->second)
+      {
+        it++ ;
+        break ;
+      }
+    }
+  }
+
+  DDS::ReturnCode_t status ;
+
+  for (; it != instance_map_.end () ; it++)
+  {
+    handle = it->second ;
+    status = read_instance(received_data, info_seq, max_samples,
+                           handle, sample_states, view_states,
+                           instance_states) ;
+    if (status != ::DDS::RETCODE_NO_DATA)
+    {
+      return status ;
+    }
+  }
+
+  return ::DDS::RETCODE_NO_DATA ;
+}
+
+DDS::ReturnCode_t
+PortDataReaderImpl::take_next_instance (
+    ::IOTest::PortSeq & received_data,
+    ::DDS::SampleInfoSeq & info_seq,
+    ::CORBA::Long max_samples,
+    ::DDS::InstanceHandle_t a_handle,
+    ::DDS::SampleStateMask sample_states,
+    ::DDS::ViewStateMask view_states,
+    ::DDS::InstanceStateMask instance_states
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+ ::DDS::InstanceHandle_t handle(::OpenDDS::DCPS::HANDLE_NIL) ;
+
+  ACE_GUARD_RETURN (ACE_Recursive_Thread_Mutex,
+                    guard,
+                    this->sample_lock_,
+                    ::DDS::RETCODE_ERROR);
+
+  InstanceMap::iterator it;
+  if (a_handle == ::OpenDDS::DCPS::HANDLE_NIL)
+  {
+    it = instance_map_.begin () ;
+  }
+  else
+  {
+    for (it = instance_map_.begin () ; it != instance_map_.end ();
+            it ++)
+    {
+      if (a_handle == it->second)
+      {
+        it++ ;
+        break ;
+      }
+    }
+  }
+
+  DDS::ReturnCode_t status ;
+
+  for (; it != instance_map_.end () ; it++)
+  {
+    handle = it->second ;
+    status = take_instance(received_data, info_seq, max_samples,
+                           handle, sample_states, view_states,
+                           instance_states) ;
+    if (status != ::DDS::RETCODE_NO_DATA)
+    {
+      total_samples() ;  // see if we are empty
+      return status ;
+    }
+  }
+
+  return ::DDS::RETCODE_NO_DATA ;
+}
+
+
+void
+PortDataReaderImpl::release_loan (
+           ::IOTest::PortSeq & received_data
+           )
+{
+  received_data.length(0);
+}
+
+
+void
+PortDataReaderImpl::dec_ref_data_element(
+  ::OpenDDS::DCPS::ReceivedDataElement* item
+  )
+{
+  if (0 == item->dec_ref())
+    {
+      ::IOTest::Port* ptr = static_cast< ::IOTest::Port* >(item->registered_data_);
+      ACE_DES_FREE (ptr,
+                    data_allocator_->free,
+                    Port );
+
+      ACE_DES_FREE (item,
+                    rd_allocator_->free,
+                    ReceivedDataElement);
+    }
+}
+
+
+DDS::ReturnCode_t
+PortDataReaderImpl::return_loan (
+    ::IOTest::PortSeq & received_data,
+    ::DDS::SampleInfoSeq & info_seq
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  // some incomplete tests to see that the data and info are from the same read.
+  if (received_data.length() != info_seq.length())
+    {
+      return ::DDS::RETCODE_PRECONDITION_NOT_MET;
+    }
+
+  if (received_data.release())
+    {
+      // nothing to do because this is not zero-copy data
+      return ::DDS::RETCODE_OK; 
+    }
+  else 
+    {
+      info_seq.length(0);
+      received_data.length(0);
+    }
+  return ::DDS::RETCODE_OK;
+}
+
+DDS::ReturnCode_t
+PortDataReaderImpl::get_key_value (
+    ::IOTest::Port & key_holder,
+    ::DDS::InstanceHandle_t handle
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  ACE_GUARD_RETURN (ACE_Recursive_Thread_Mutex,
+                    guard,
+                    this->sample_lock_,
+                    ::DDS::RETCODE_ERROR);
+
+  InstanceMap::iterator it;
+  for (it = instance_map_.begin ();
+        it != instance_map_.end ();
+        it ++)
+  {
+    if (it->second == handle)
+    {
+      key_holder = it->first;
+      return ::DDS::RETCODE_OK;
+    }
+  }
+
+  return ::DDS::RETCODE_ERROR;
+}
+
+void
+PortDataReaderImpl::dds_demarshal(const OpenDDS::DCPS::ReceivedDataSample& sample)
+{
+  ::IOTest::Port *data /* = new ::IOTest::Port(instance_data) */ ;
+
+  ACE_NEW_MALLOC_NORETURN (data,
+                         static_cast< ::IOTest::Port *> (
+                         data_allocator_->malloc (
+                              sizeof (::IOTest::Port))),
+                         ::IOTest::Port) ;
+
+  TAO::DCPS::Serializer ser(sample.sample_, sample.header_.byte_order_ != TAO_ENCAP_BYTE_ORDER) ;
+  ser >> *data ;
+
+  store_instance_data(data, sample.header_) ;
+}
+
+::DDS::ReturnCode_t
+PortDataReaderImpl::store_instance_data(
+    ::IOTest::Port *instance_data,
+    const OpenDDS::DCPS::DataSampleHeader& header )
+{
+  DDS::InstanceHandle_t handle(::OpenDDS::DCPS::HANDLE_NIL) ;
+
+  //!!! caller should already have the sample_lock_
+
+  InstanceMap::const_iterator it = instance_map_.find(*instance_data);
+
+  if (it == instance_map_.end())
+  {
+    OpenDDS::DCPS::SubscriptionInstance* instance = 0;
+    handle = this->OPENDDS_DCPS_DataReaderImpl::get_next_handle ();
+    ACE_NEW_RETURN (instance,
+                    OpenDDS::DCPS::SubscriptionInstance(this, handle),
+                    ::DDS::RETCODE_ERROR);
+
+    instance->instance_handle_ = handle;
+    int ret = bind(instances_, handle, instance);
+
+    if (ret != 0)
+    {
+      ACE_ERROR_RETURN ((LM_ERROR,
+                        ACE_TEXT("(%P|%t) "
+                        "PortDataReaderImpl::store_instance_data, ")
+                        ACE_TEXT("insert handle failed. \n")),
+                        ::DDS::RETCODE_ERROR);
+      return ::DDS::RETCODE_ERROR;
+    }
+
+    std::pair<InstanceMap::iterator, bool> bpair
+        = instance_map_.insert(InstanceMap::value_type(*instance_data,
+                               handle));
+    if (bpair.second == false)
+    {
+      ACE_ERROR_RETURN ((LM_ERROR,
+                        ACE_TEXT("(%P|%t) "
+                        "PortDataReaderImpl::store_instance_data, ")
+                        ACE_TEXT("insert ::IOTest::Port failed. \n")),
+                        ::DDS::RETCODE_ERROR);
+    }
+  }
+  else
+  {
+    handle = it->second;
+  }
+
+  if (header.message_id_ != OpenDDS::DCPS::INSTANCE_REGISTRATION)
+  {
+    OpenDDS::DCPS::SubscriptionInstance* instance_ptr =
+      this->OPENDDS_DCPS_DataReaderImpl::get_handle_instance (handle) ;
+
+    // TBD - we also need to reject for > RESOURCE_LIMITS.max_samples
+    //       and RESOURCE_LIMITS.max_instances.
+    if ((this->qos_.resource_limits.max_samples_per_instance !=
+          ::DDS::LENGTH_UNLIMITED) &&
+       (instance_ptr->rcvd_sample_.size_ >=
+        this->qos_.resource_limits.max_samples_per_instance))
+    {
+      if  (instance_ptr->rcvd_sample_.head_->sample_state_
+            == ::DDS::NOT_READ_SAMPLE_STATE)
+        {
+        // for now the implemented QoS means that if the head sample
+        // is NOT_READ then none are read.
+        // TBD - in future we will reads may not read in order so
+        //       just looking at the head will not be enough.
+        ::DDS::DataReaderListener* listener
+            = listener_for (::DDS::SAMPLE_REJECTED_STATUS);
+
+        sample_rejected_status_.last_reason =
+            ::DDS::REJECTED_BY_INSTANCE_LIMIT ;
+        sample_rejected_status_.total_count++ ;
+        sample_rejected_status_.total_count_change++ ;
+        sample_rejected_status_.last_instance_handle = handle ;
+
+        if (listener != 0)
+        {
+          ::DDS::DataReader_var dr = get_dr_obj_ref();
+          listener->on_sample_rejected(dr.in (),
+                                       sample_rejected_status_);
+        }  // do we want to do something if listener is nil???
+
+        ACE_DES_FREE (instance_data,
+                      data_allocator_->free,
+                      Port );
+
+        return ::DDS::RETCODE_OK ; //OK?
+       }
+       else
+       {
+         // Discard the oldest previously-read sample
+         OpenDDS::DCPS::ReceivedDataElement *item = instance_ptr->rcvd_sample_.head_;
+         instance_ptr->rcvd_sample_.remove(item) ;
+         dec_ref_data_element(item);
+      }
+    }
+
+    OpenDDS::DCPS::ReceivedDataElement *ptr /* = new OpenDDS::DCPS::ReceivedDataElement(data) */ ;
+    ACE_NEW_MALLOC_RETURN (ptr,
+                           static_cast<OpenDDS::DCPS::ReceivedDataElement *> (
+                           rd_allocator_->malloc (
+                              sizeof (OpenDDS::DCPS::ReceivedDataElement))),
+                           OpenDDS::DCPS::ReceivedDataElement(instance_data),
+                           ::DDS::RETCODE_ERROR);
+
+    instance_ptr->instance_state_.data_was_received() ;
+
+    ptr->source_timestamp_.sec = header.source_timestamp_sec_ ;
+    ptr->source_timestamp_.nanosec = header.source_timestamp_nanosec_ ;
+    ptr->disposed_generation_count_ =
+        instance_ptr->instance_state_.disposed_generation_count() ;
+    ptr->no_writers_generation_count_ =
+        instance_ptr->instance_state_.no_writers_generation_count() ;
+
+    ptr->sequence_ = header.sequence_ ;
+    instance_ptr->last_sequence_ = header.sequence_ ;
+
+    instance_ptr->rcvd_sample_.add(ptr) ;
+    ptr->inc_ref() ;
+
+    if (instance_ptr->rcvd_sample_.size_ > get_depth())
+    {
+      OpenDDS::DCPS::ReceivedDataElement *head_ptr =
+        instance_ptr->rcvd_sample_.head_ ;
+
+      instance_ptr->rcvd_sample_.remove(head_ptr) ;
+
+      if (head_ptr->sample_state_ == ::DDS::NOT_READ_SAMPLE_STATE)
+      {
+        ::DDS::DataReaderListener* listener
+            = listener_for (::DDS::SAMPLE_LOST_STATUS);
+
+        sample_lost_status_.total_count++ ;
+        sample_lost_status_.total_count_change++ ;
+
+        if (listener)
+        {
+          ::DDS::DataReader_var dr = get_dr_obj_ref();
+          listener->on_sample_lost(dr.in (), sample_lost_status_);
+        }
+      }
+
+      dec_ref_data_element(head_ptr);
+    }
+
+    OpenDDS::DCPS::SubscriberImpl* sub = get_subscriber_servant () ;
+    ::DDS::SubscriberListener* sub_listener =
+        sub->listener_for(::DDS::DATA_ON_READERS_STATUS) ;
+    if (sub_listener != 0)
+    {
+      sub_listener->on_data_on_readers(get_subscriber()) ;
+    }
+    else
+    {
+      ::DDS::DataReaderListener* listener
+            = listener_for (::DDS::DATA_AVAILABLE_STATUS);
+
+      if (listener != 0)
+      {
+        ::DDS::DataReader_var dr = get_dr_obj_ref();
+        listener->on_data_available(dr.in ());
+      }
+    }
+  }
+  else
+  {
+    OpenDDS::DCPS::SubscriptionInstance *instance_ptr =
+         this->OPENDDS_DCPS_DataReaderImpl::get_handle_instance (handle) ;
+    instance_ptr->instance_state_.lively(header.publication_id_) ;
+    ACE_DES_FREE (instance_data,
+                  data_allocator_->free,
+                  Port );
+  }
+
+  return ::DDS::RETCODE_OK;
+}
+
+void
+PortDataReaderImpl::dispose(const OpenDDS::DCPS::ReceivedDataSample& sample)
+{
+  //!!! caller should already have the sample_lock_
+
+  ::IOTest::Port *data /* = new ::IOTest::Port(instance_data) */ ;
+  ACE_NEW_MALLOC_NORETURN (data,
+                         static_cast< ::IOTest::Port *> (
+                         data_allocator_->malloc (
+                              sizeof (::IOTest::Port))),
+                         ::IOTest::Port) ;
+
+  TAO::DCPS::Serializer ser(sample.sample_, sample.header_.byte_order_ != TAO_ENCAP_BYTE_ORDER) ;
+  ser >> *data ;
+
+  DDS::InstanceHandle_t handle(::OpenDDS::DCPS::HANDLE_NIL) ;
+
+  InstanceMap::const_iterator it = instance_map_.find(*data);
+
+  if (it != instance_map_.end())
+  {
+    handle = it->second;
+    OpenDDS::DCPS::SubscriptionInstance* instance_ptr =
+          this->OPENDDS_DCPS_DataReaderImpl::get_handle_instance (handle) ;
+    instance_ptr->instance_state_.dispose_was_received() ;
+  }
+  else if (! this->is_bit ())
+  {
+    ACE_ERROR((LM_ERROR,
+              ACE_TEXT("(%P|%t) ")
+              ACE_TEXT("PortDataReaderImpl::disposed, ")
+              ACE_TEXT("The instance is not registered.\n")));
+  }
+
+  ACE_DES_FREE (data,
+                data_allocator_->free,
+                Port );
+}
+
+DDS::ReturnCode_t 
+PortDataReaderImpl::auto_return_loan(void* seq)
+{
+  ::IOTest::PortSeq& received_data = *(::IOTest::PortSeq*)seq;
+  
+  if (!received_data.release())
+    {
+      //      this->release_loan(received_data);
+      received_data.length(0);
+    }
+  return ::DDS::RETCODE_OK; 
+}
+
+DDS::ReturnCode_t
+PortDataReaderImpl::check_inputs (
+    const char* method_name,
+    ::IOTest::PortSeq & received_data,
+    ::DDS::SampleInfoSeq & info_seq,
+    ::CORBA::Long& max_samples
+  )
+{
+  ::IOTest::PortSeq::PrivateMemberAccess received_data_p (received_data);
+
+  //---- start of preconditions common to read and take -----
+  //SPEC ref v1.2 7.1.2.5.3.8 #1
+  //NOTE: we can't check maximum() or release() here since those are
+  //implementation details of the sequences.  In general, the info_seq will
+  //have release() == true and maximum() == 0.  If we're in zero-copy mode, the
+  //received_data will have release() == false and maximum() == 0.  If it's not
+  //zero-copy then received_data will have release == true() and maximum() ==
+  //anything.
+  if (received_data.length() != info_seq.length())
+    {
+      ACE_DEBUG((LM_DEBUG,"PortDataReaderImpl::%s PRECONDITION_NOT_MET sample and info input sequences do not match.\n",
+        method_name ));
+      return ::DDS::RETCODE_PRECONDITION_NOT_MET;
+    }
+
+  //SPEC ref v1.2 7.1.2.5.3.8 #4
+  if ((received_data.maximum() > 0) && (received_data.release() == false))
+    {
+        ACE_DEBUG((LM_DEBUG,"PortDataReaderImpl::%s PRECONDITION_NOT_MET mismatch of maximum %d  and owns %d\n",
+          method_name, received_data.maximum(), received_data.release() ));
+        return ::DDS::RETCODE_PRECONDITION_NOT_MET;
+    }
+
+  if (received_data.maximum() == 0)
+    {
+      // not in SPEC but needed.
+      if (max_samples == ::DDS::LENGTH_UNLIMITED)
+        {
+          max_samples = (::CORBA::Long)received_data_p.max_slots();
+        }
+    }
+    else
+    {
+      if (max_samples == ::DDS::LENGTH_UNLIMITED)
+        {
+          //SPEC ref v1.2 7.1.2.5.3.8 #5a
+          max_samples = received_data.maximum();
+        }
+      else if (max_samples > (::CORBA::Long)received_data.maximum())
+        {
+          //SPEC ref v1.2 7.1.2.5.3.8 #5c
+          ACE_DEBUG((LM_DEBUG,"PortDataReaderImpl::read PRECONDITION_NOT_MET max_samples %d > maximum %d\n",
+            method_name, max_samples, received_data.maximum() ));
+          return ::DDS::RETCODE_PRECONDITION_NOT_MET;
+
+        }
+      //else
+      //SPEC ref v1.2 7.1.2.5.3.8 #5b - is true by impl below.
+    }
+
+  // The spec does not say what to do in this case but it appears to be a good thing.
+  // Note: max_slots is the greater of the sequence's maximum and init_size.
+  if ((::CORBA::Long)received_data_p.max_slots() < max_samples)
+    {
+      max_samples = (::CORBA::Long)received_data_p.max_slots();
+    }
+  //---- end of preconditions common to read and take -----
+  
+  return ::DDS::RETCODE_OK;
+}
+
+void
+PortDataReaderImpl::release_instance_i (::DDS::InstanceHandle_t handle)
+{
+  InstanceMap::iterator it;
+  for (it = instance_map_.begin ();
+    it != instance_map_.end ();
+    it ++)
+  {
+    if (it->second == handle)
+      break;
+  }
+
+  if (it != instance_map_.end ())
+  {
+    instance_map_.erase (it);
+  }
+}
+
+
+//OpenDDS::DCPS::DataReaderRemote_ptr
+//PortDataReaderImpl::get_datareaderremote_obj_ref ()
+//{
+//  ::OpenDDS::DCPS::DataReaderRemote_ptr reader_obj
+//      = ::OpenDDS::DCPS::servant_to_reference
+//            (this);
+//  ACE_CHECK_RETURN (::OpenDDS::DCPS::DataReaderRemote::_nil());
+//
+//  // servant_to_reference does not duplicate when the object is already active
+//  return OpenDDS::DCPS::DataReaderRemote::_duplicate(reader_obj);
+//}
+}; // IOTest
+
+
+
diff --git a/dds_io_sub/PortTypeSupportImpl.h b/dds_io_sub/PortTypeSupportImpl.h
new file mode 100644
index 0000000..70c72c3
--- /dev/null
+++ b/dds_io_sub/PortTypeSupportImpl.h
@@ -0,0 +1,493 @@
+// -*- C++ -*-
+//
+// $Id: HTemplate.pm 899 2007-07-05 16:36:52Z mitza $
+
+// Generated by dcps_ts.pl
+
+#ifndef PORTTYPESUPPORTI_H_
+#define PORTTYPESUPPORTI_H_
+
+#include "PortTypeSupportS.h"
+#include "dds/DCPS/DataWriterImpl.h"
+#include "dds/DCPS/DataReaderImpl.h"
+#include "dds/DCPS/Dynamic_Cached_Allocator_With_Overflow_T.h"
+#include "dds/DCPS/DataBlockLockPool.h"
+
+#if !defined (ACE_LACKS_PRAGMA_ONCE)
+#pragma once
+#endif /* ACE_LACKS_PRAGMA_ONCE */
+
+namespace IOTest {
+
+/** Servant for TypeSuport interface of Port data type.
+ *
+ * See the DDS specification, OMG formal/04-12-02, for a description of
+ * this interface.
+ *
+ */
+class  PortTypeSupportImpl
+  : public virtual OpenDDS::DCPS::LocalObject<PortTypeSupport>
+{
+public:
+
+  //Constructor
+  PortTypeSupportImpl (void);
+
+  //Destructor
+  virtual ~PortTypeSupportImpl (void);
+
+  virtual
+  DDS::ReturnCode_t register_type (
+      ::DDS::DomainParticipant_ptr participant,
+      const char * type_name
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual
+  char * get_type_name (
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual
+  ::DDS::DataWriter_ptr create_datawriter (
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual
+  ::DDS::DataReader_ptr create_datareader (
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  private:
+    CORBA::String_var type_name_;
+};
+}; // IOTest
+
+
+namespace IOTest {
+
+
+/** Servant for DataWriter interface of the Port data type.
+ *
+ * See the DDS specification, OMG formal/04-12-02, for a description of
+ * this interface.
+ */
+class  PortDataWriterImpl
+  : public virtual OpenDDS::DCPS::LocalObject<PortDataWriter>,
+    public virtual OpenDDS::DCPS::DataWriterImpl
+{
+public:
+
+  typedef std::map<IOTest::Port, DDS::InstanceHandle_t,
+      PortKeyLessThan> InstanceMap;
+  typedef ::OpenDDS::DCPS::Dynamic_Cached_Allocator_With_Overflow<ACE_Null_Mutex>  DataAllocator;
+
+  //Constructor
+  PortDataWriterImpl (void);
+
+  //Destructor
+  virtual ~PortDataWriterImpl (void);
+
+  virtual
+  DDS::InstanceHandle_t _cxx_register (
+      const ::IOTest::Port & instance_data
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual
+  DDS::InstanceHandle_t register_w_timestamp (
+      const ::IOTest::Port & instance_data,
+      ::DDS::InstanceHandle_t handle,
+      const ::DDS::Time_t & source_timestamp
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual
+  DDS::ReturnCode_t unregister (
+      const ::IOTest::Port & instance_data,
+      ::DDS::InstanceHandle_t handle
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual
+  DDS::ReturnCode_t unregister_w_timestamp (
+      const ::IOTest::Port & instance_data,
+      ::DDS::InstanceHandle_t handle,
+      const ::DDS::Time_t & source_timestamp
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  //WARNING: If the handle is non-nil and the instance is not registered
+  //         then this operation may cause an access violation.
+  //         This lack of safety helps performance.
+  virtual
+  DDS::ReturnCode_t write (
+      const ::IOTest::Port & instance_data,
+      ::DDS::InstanceHandle_t handle
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  //WARNING: If the handle is non-nil and the instance is not registered
+  //         then this operation may cause an access violation.
+  //         This lack of safety helps performance.
+  virtual
+  DDS::ReturnCode_t write_w_timestamp (
+      const ::IOTest::Port & instance_data,
+      ::DDS::InstanceHandle_t handle,
+      const ::DDS::Time_t & source_timestamp
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual
+  DDS::ReturnCode_t dispose (
+      const ::IOTest::Port & instance_data,
+      ::DDS::InstanceHandle_t instance_handle
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual
+  DDS::ReturnCode_t dispose_w_timestamp (
+      const ::IOTest::Port & instance_data,
+      ::DDS::InstanceHandle_t instance_handle,
+      const ::DDS::Time_t & source_timestamp
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual
+  DDS::ReturnCode_t get_key_value (
+      ::IOTest::Port & key_holder,
+      ::DDS::InstanceHandle_t handle
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+
+  /**
+   * Initialize the DataWriter object.
+   * Called as part of create_datawriter.
+   */
+  virtual void init (
+        ::DDS::Topic_ptr                       topic,
+        OpenDDS::DCPS::TopicImpl                 *topic_servant,
+        const ::DDS::DataWriterQos &           qos,
+        ::DDS::DataWriterListener_ptr          a_listener,
+        OpenDDS::DCPS::DomainParticipantImpl*      participant_servant,
+        ::DDS::Publisher_ptr                   publisher,
+        OpenDDS::DCPS::PublisherImpl*              publisher_servant,
+        ::DDS::DataWriter_ptr                  dw_objref,
+        ::OpenDDS::DCPS::DataWriterRemote_ptr      dw_remote_objref
+      )
+        ACE_THROW_SPEC ((
+        CORBA::SystemException
+      ));
+
+  /**
+   * Do parts of enable specific to the datatype.
+   * Called by DataWriterImpl::enable().
+   */
+  virtual ::DDS::ReturnCode_t enable_specific (
+      )
+      ACE_THROW_SPEC ((
+        CORBA::SystemException
+      ));
+
+  /**
+   * The framework has completed its part of unregistering the
+   * given instance.
+   */
+  virtual void unregistered(::DDS::InstanceHandle_t   instance_handle);
+
+  /**
+   * Accessor to the marshalled data sample allocator.
+   */
+  ACE_INLINE
+  DataAllocator* data_allocator () const  {
+    return data_allocator_;
+  }
+
+private:
+
+  /**
+   * Serialize the instance data.
+   *
+   * @param instance_data The data to serialize.
+   * @param for_write If 1 use the fast allocator; otherwise use the heap.
+   * @return returns the serialized data.
+   */
+  ACE_Message_Block* dds_marshal(
+    const ::IOTest::Port& instance_data,
+    int  for_write = 1);
+
+  /**
+   * Find the instance handle for the given instance_data using
+   * the data type's key(s).  If the instance does not already exist
+   * create a new instance handle for it.
+   */
+  ::DDS::ReturnCode_t get_or_create_instance_handle(
+    DDS::InstanceHandle_t& handle,
+    const ::IOTest::Port& instance_data,
+    const ::DDS::Time_t & source_timestamp);
+
+  /**
+   * Get the InstanceHanle for the given data.
+   */
+  ::DDS::InstanceHandle_t get_instance_handle(
+    ::IOTest::Port instance_data);
+
+   InstanceMap  instance_map_;
+   size_t       marshaled_size_;
+   // The lock pool will be thread safe because
+   // only one write call is allowed at a time.
+   DataBlockLockPool*  db_lock_pool_;
+   DataAllocator* data_allocator_;
+   ::OpenDDS::DCPS::MessageBlockAllocator* mb_allocator_;
+   ::OpenDDS::DCPS::DataBlockAllocator*    db_allocator_;
+};
+}; // IOTest
+
+
+namespace IOTest {
+
+/** Servant for DataReader interface of Port data type.
+ *
+ * See the DDS specification, OMG formal/04-12-02, for a description of
+ * this interface.
+ *
+ */
+class  PortDataReaderImpl
+  : public virtual OpenDDS::DCPS::LocalObject<PortDataReader>,
+    public virtual OpenDDS::DCPS::DataReaderImpl
+{
+public:
+
+  typedef std::map<IOTest::Port, DDS::InstanceHandle_t,
+      PortKeyLessThan> InstanceMap;
+  typedef ::OpenDDS::DCPS::Cached_Allocator_With_Overflow<IOTest::Port, ACE_Null_Mutex>  DataAllocator;
+
+  //Constructor
+  PortDataReaderImpl (void);
+
+  //Destructor
+  virtual ~PortDataReaderImpl (void);
+
+  virtual
+  DDS::ReturnCode_t delete_contained_entities (
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  /**
+   * Initialize the DataReader object.
+   * Called as part of create_datareader.
+   */
+  virtual
+  void init (
+        OpenDDS::DCPS::TopicImpl*                    a_topic,
+        const ::DDS::DataReaderQos &             qos,
+        ::DDS::DataReaderListener_ptr            a_listener,
+        OpenDDS::DCPS::DomainParticipantImpl*        participant,
+        OpenDDS::DCPS::SubscriberImpl*               subscriber,
+        ::DDS::Subscriber_ptr                    subscriber_objref,
+        ::DDS::DataReader_ptr					 dr_objerf,
+        OpenDDS::DCPS::DataReaderRemote_ptr          dr_remote_objref
+      )
+        ACE_THROW_SPEC ((
+        CORBA::SystemException
+      ));
+
+  /**
+   * Do parts of enable specific to the datatype.
+   * Called by DataReaderImpl::enable().
+   */
+  virtual ::DDS::ReturnCode_t enable_specific (
+      )
+      ACE_THROW_SPEC ((
+        CORBA::SystemException
+      ));
+
+  virtual
+  DDS::ReturnCode_t read (
+      ::IOTest::PortSeq & received_data,
+      ::DDS::SampleInfoSeq & info_seq,
+      ::CORBA::Long max_samples,
+      ::DDS::SampleStateMask sample_states,
+      ::DDS::ViewStateMask view_states,
+      ::DDS::InstanceStateMask instance_states
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual
+  DDS::ReturnCode_t take (
+      ::IOTest::PortSeq & received_data,
+      ::DDS::SampleInfoSeq & info_seq,
+      ::CORBA::Long max_samples,
+      ::DDS::SampleStateMask sample_states,
+      ::DDS::ViewStateMask view_states,
+      ::DDS::InstanceStateMask instance_states
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual
+  DDS::ReturnCode_t read_next_sample (
+      ::IOTest::Port & received_data,
+      ::DDS::SampleInfo & sample_info
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual
+  DDS::ReturnCode_t take_next_sample (
+      ::IOTest::Port & received_data,
+      ::DDS::SampleInfo & sample_info
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual
+  DDS::ReturnCode_t read_instance (
+      ::IOTest::PortSeq & received_data,
+      ::DDS::SampleInfoSeq & info_seq,
+      ::CORBA::Long max_samples,
+      ::DDS::InstanceHandle_t a_handle,
+      ::DDS::SampleStateMask sample_states,
+      ::DDS::ViewStateMask view_states,
+      ::DDS::InstanceStateMask instance_states
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual
+  DDS::ReturnCode_t take_instance (
+      ::IOTest::PortSeq & received_data,
+      ::DDS::SampleInfoSeq & info_seq,
+      ::CORBA::Long max_samples,
+      ::DDS::InstanceHandle_t a_handle,
+      ::DDS::SampleStateMask sample_states,
+      ::DDS::ViewStateMask view_states,
+      ::DDS::InstanceStateMask instance_states
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual
+  DDS::ReturnCode_t read_next_instance (
+      ::IOTest::PortSeq & received_data,
+      ::DDS::SampleInfoSeq & info_seq,
+      ::CORBA::Long max_samples,
+      ::DDS::InstanceHandle_t a_handle,
+      ::DDS::SampleStateMask sample_states,
+      ::DDS::ViewStateMask view_states,
+      ::DDS::InstanceStateMask instance_states
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual
+  DDS::ReturnCode_t take_next_instance (
+      ::IOTest::PortSeq & received_data,
+      ::DDS::SampleInfoSeq & info_seq,
+      ::CORBA::Long max_samples,
+      ::DDS::InstanceHandle_t a_handle,
+      ::DDS::SampleStateMask sample_states,
+      ::DDS::ViewStateMask view_states,
+      ::DDS::InstanceStateMask instance_states
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual
+  DDS::ReturnCode_t return_loan (
+      ::IOTest::PortSeq & received_data,
+      ::DDS::SampleInfoSeq & info_seq
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual
+  DDS::ReturnCode_t get_key_value (
+      ::IOTest::Port & key_holder,
+      ::DDS::InstanceHandle_t handle
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual 
+  DDS::ReturnCode_t auto_return_loan(void* seq);
+
+  void release_loan (::IOTest::PortSeq & received_data);
+
+  void dec_ref_data_element(::OpenDDS::DCPS::ReceivedDataElement* r);
+
+ protected:
+
+    virtual void dds_demarshal(const OpenDDS::DCPS::ReceivedDataSample& sample) ;
+
+    virtual void dispose(const OpenDDS::DCPS::ReceivedDataSample& sample) ;
+
+    //virtual OpenDDS::DCPS::DataReaderRemote_ptr get_datareaderremote_obj_ref ();
+    
+    virtual void release_instance_i (::DDS::InstanceHandle_t handle);
+
+
+  private:
+    ::DDS::ReturnCode_t  store_instance_data(
+         ::IOTest::Port *instance_data,
+         const OpenDDS::DCPS::DataSampleHeader& header
+         ) ;
+
+    /// common input read* & take* input processing and precondition checks
+    ::DDS::ReturnCode_t check_inputs (
+        const char* method_name,
+        ::IOTest::PortSeq & received_data,
+        ::DDS::SampleInfoSeq & info_seq,
+        ::CORBA::Long& max_samples
+        ) ;
+
+   InstanceMap  instance_map_;
+   DataAllocator* data_allocator_;
+};
+
+}; // IOTest
+
+
+#endif /* PORTTYPESUPPORTI_H_  */
+
+
diff --git a/dds_io_sub/PortTypeSupportS.cpp b/dds_io_sub/PortTypeSupportS.cpp
new file mode 100644
index 0000000..239b5bb
--- /dev/null
+++ b/dds_io_sub/PortTypeSupportS.cpp
@@ -0,0 +1,73 @@
+// -*- C++ -*-
+//
+// $Id$
+
+// ****  Code generated by the The ACE ORB (TAO) IDL Compiler ****
+// TAO and the TAO IDL Compiler have been developed by:
+//       Center for Distributed Object Computing
+//       Washington University
+//       St. Louis, MO
+//       USA
+//       http://www.cs.wustl.edu/~schmidt/doc-center.html
+// and
+//       Distributed Object Computing Laboratory
+//       University of California at Irvine
+//       Irvine, CA
+//       USA
+//       http://doc.ece.uci.edu/
+// and
+//       Institute for Software Integrated Systems
+//       Vanderbilt University
+//       Nashville, TN
+//       USA
+//       http://www.isis.vanderbilt.edu/
+//
+// Information about TAO is available at:
+//     http://www.cs.wustl.edu/~schmidt/TAO.html
+
+
+// TAO_IDL - Generated from 
+// be/be_codegen.cpp:703
+
+#ifndef _TAO_IDL_PORTTYPESUPPORTS_CPP_
+#define _TAO_IDL_PORTTYPESUPPORTS_CPP_
+
+
+#include "PortTypeSupportS.h"
+
+#if !defined (__ACE_INLINE__)
+#include "PortTypeSupportS.inl"
+#endif /* !defined INLINE */
+
+// TAO_IDL - Generated from
+// be/be_visitor_arg_traits.cpp:72
+
+TAO_BEGIN_VERSIONED_NAMESPACE_DECL
+
+
+// Arg traits specializations.
+namespace TAO
+{
+}
+
+TAO_END_VERSIONED_NAMESPACE_DECL
+
+
+
+// TAO_IDL - Generated from
+// be/be_visitor_arg_traits.cpp:72
+
+TAO_BEGIN_VERSIONED_NAMESPACE_DECL
+
+
+// Arg traits specializations.
+namespace TAO
+{
+}
+
+TAO_END_VERSIONED_NAMESPACE_DECL
+
+
+
+#endif /* ifndef */
+
diff --git a/dds_io_sub/PortTypeSupportS.h b/dds_io_sub/PortTypeSupportS.h
new file mode 100644
index 0000000..5c70e37
--- /dev/null
+++ b/dds_io_sub/PortTypeSupportS.h
@@ -0,0 +1,64 @@
+// -*- C++ -*-
+//
+// $Id$
+
+// ****  Code generated by the The ACE ORB (TAO) IDL Compiler ****
+// TAO and the TAO IDL Compiler have been developed by:
+//       Center for Distributed Object Computing
+//       Washington University
+//       St. Louis, MO
+//       USA
+//       http://www.cs.wustl.edu/~schmidt/doc-center.html
+// and
+//       Distributed Object Computing Laboratory
+//       University of California at Irvine
+//       Irvine, CA
+//       USA
+//       http://doc.ece.uci.edu/
+// and
+//       Institute for Software Integrated Systems
+//       Vanderbilt University
+//       Nashville, TN
+//       USA
+//       http://www.isis.vanderbilt.edu/
+//
+// Information about TAO is available at:
+//     http://www.cs.wustl.edu/~schmidt/TAO.html
+
+// TAO_IDL - Generated from
+// be/be_codegen.cpp:487
+
+#ifndef _TAO_IDL_PORTTYPESUPPORTS_H_
+#define _TAO_IDL_PORTTYPESUPPORTS_H_
+
+
+#include "PortTypeSupportC.h"
+#include "IOTestS.h"
+
+#if !defined (ACE_LACKS_PRAGMA_ONCE)
+# pragma once
+#endif /* ACE_LACKS_PRAGMA_ONCE */
+
+
+// TAO_IDL - Generated from
+// be/be_visitor_module/module_sh.cpp:49
+
+namespace POA_IOTest
+{
+  
+
+// TAO_IDL - Generated from
+// be/be_visitor_module/module_sh.cpp:80
+
+} // module IOTest
+
+// TAO_IDL - Generated from 
+// be/be_codegen.cpp:1281
+
+
+#if defined (__ACE_INLINE__)
+#include "PortTypeSupportS.inl"
+#endif /* defined INLINE */
+
+#endif /* ifndef */
+
diff --git a/dds_io_sub/PortTypeSupportS.inl b/dds_io_sub/PortTypeSupportS.inl
new file mode 100644
index 0000000..38aa325
--- /dev/null
+++ b/dds_io_sub/PortTypeSupportS.inl
@@ -0,0 +1,28 @@
+// -*- C++ -*-
+//
+// $Id$
+
+// ****  Code generated by the The ACE ORB (TAO) IDL Compiler ****
+// TAO and the TAO IDL Compiler have been developed by:
+//       Center for Distributed Object Computing
+//       Washington University
+//       St. Louis, MO
+//       USA
+//       http://www.cs.wustl.edu/~schmidt/doc-center.html
+// and
+//       Distributed Object Computing Laboratory
+//       University of California at Irvine
+//       Irvine, CA
+//       USA
+//       http://doc.ece.uci.edu/
+// and
+//       Institute for Software Integrated Systems
+//       Vanderbilt University
+//       Nashville, TN
+//       USA
+//       http://www.isis.vanderbilt.edu/
+//
+// Information about TAO is available at:
+//     http://www.cs.wustl.edu/~schmidt/TAO.html
+
+
diff --git a/dds_io_sub/dds_io_sub.cpp b/dds_io_sub/dds_io_sub.cpp
new file mode 100644
index 0000000..6cdaabd
--- /dev/null
+++ b/dds_io_sub/dds_io_sub.cpp
@@ -0,0 +1,215 @@
+// -*- C++ -*-
+// ============================================================================
+/**
+ *  @file   subscriber.cpp
+ *
+ *  $Id: subscriber.cpp 899 2007-07-05 16:36:52Z mitza $
+ *
+ *
+ */
+// ============================================================================
+
+
+#include "DataReaderListener.h"
+#include "PortTypeSupportImpl.h"
+#include <dds/DCPS/Service_Participant.h>
+#include <dds/DCPS/Marked_Default_Qos.h>
+#include <dds/DCPS/SubscriberImpl.h>
+#include <dds/DCPS/transport/framework/TheTransportFactory.h>
+#include <dds/DCPS/transport/simpleTCP/SimpleTcpConfiguration.h>
+#ifdef ACE_AS_STATIC_LIBS
+#include <dds/DCPS/transport/simpleTCP/SimpleTcp.h>
+#include <dds/DCPS/transport/simpleUnreliableDgram/SimpleUnreliableDgram.h>
+#include <dds/DCPS/transport/ReliableMulticast/ReliableMulticast.h>
+#endif
+
+#include <ace/streams.h>
+#include "ace/Get_Opt.h"
+
+using namespace IOTest;
+
+OpenDDS::DCPS::TransportIdType transport_impl_id = 1;
+
+int
+parse_args (int argc, char *argv[])
+{
+  ACE_Get_Opt get_opts (argc, argv, "t:");
+  int c;
+
+  while ((c = get_opts ()) != -1)
+  {
+    switch (c)
+    {
+    case 't':
+      if (ACE_OS::strcmp (get_opts.opt_arg (), "udp") == 0) {
+        transport_impl_id = 2;
+      }
+      else if (ACE_OS::strcmp (get_opts.opt_arg (), "mcast") == 0) {
+        transport_impl_id = 3;
+      }
+      else if (ACE_OS::strcmp (get_opts.opt_arg (), "reliable_mcast") == 0) {
+        transport_impl_id = 4;
+      }
+      // test with DEFAULT_SIMPLE_TCP_ID.
+      else if (ACE_OS::strcmp (get_opts.opt_arg (), "default_tcp") == 0) {
+        transport_impl_id = OpenDDS::DCPS::DEFAULT_SIMPLE_TCP_ID;
+      }
+      // test with DEFAULT_SIMPLE_UDP_ID.
+      else if (ACE_OS::strcmp (get_opts.opt_arg (), "default_udp") == 0) {
+        transport_impl_id = OpenDDS::DCPS::DEFAULT_SIMPLE_UDP_ID;
+      }
+      else if (ACE_OS::strcmp (get_opts.opt_arg (), "default_mcast_sub") == 0) {
+        transport_impl_id = OpenDDS::DCPS::DEFAULT_SIMPLE_MCAST_SUB_ID;
+      }
+      break;
+    case '?':
+    default:
+      ACE_ERROR_RETURN ((LM_ERROR,
+        "usage:  %s "
+        "-t <tcp/udp/default> "
+        "\n",
+        argv [0]),
+        -1);
+    }
+  }
+  // Indicates sucessful parsing of the command line
+  return 0;
+}
+
+
+int main (int argc, char *argv[])
+{
+  try
+    {
+      DDS::DomainParticipantFactory_var dpf;
+      DDS::DomainParticipant_var participant;
+
+      dpf = TheParticipantFactoryWithArgs(argc, argv);
+      if (CORBA::is_nil (dpf.in ())){
+    	  cerr << "get ParticipantFactory failed." << endl;
+    	  return 1;
+      }
+      
+      participant = dpf->create_participant(411,
+                                            PARTICIPANT_QOS_DEFAULT,
+                                            DDS::DomainParticipantListener::_nil());
+      if (CORBA::is_nil (participant.in ())) {
+        cerr << "create_participant failed." << endl;
+        return 1 ;
+      }
+
+      if (parse_args (argc, argv) == -1) {
+        return -1;
+      }
+
+      PortTypeSupport_var port = new PortTypeSupportImpl();
+
+      if (DDS::RETCODE_OK != port->register_type(participant.in (), "")) {
+          cerr << "Failed to register the PortTypeTypeSupport." << endl;
+          exit(1);
+        }
+
+      CORBA::String_var type_name = port->get_type_name ();
+
+      DDS::TopicQos topic_qos;
+      participant->get_default_topic_qos(topic_qos);
+      DDS::Topic_var topic = participant->create_topic("IOTest",
+                                                        type_name.in (),
+                                                        topic_qos,
+                                                        DDS::TopicListener::_nil());
+      if (CORBA::is_nil (topic.in ())) {
+        cerr << "Failed to create_topic." << endl;
+        exit(1);
+      }
+
+      // Initialize the transport
+      OpenDDS::DCPS::TransportImpl_rch transport_impl =
+      TheTransportFactory->create_transport_impl (transport_impl_id,
+                                                    ::OpenDDS::DCPS::AUTO_CONFIG);
+
+      // Create the subscriber and attach to the corresponding
+      // transport.
+      DDS::Subscriber_var sub =
+        participant->create_subscriber(SUBSCRIBER_QOS_DEFAULT,
+                                       DDS::SubscriberListener::_nil());
+      if (CORBA::is_nil (sub.in ())) {
+        cerr << "Failed to create_subscriber." << endl;
+        exit(1);
+      }
+
+      // Attach the subscriber to the transport.
+      OpenDDS::DCPS::SubscriberImpl* sub_impl =
+      OpenDDS::DCPS::reference_to_servant<OpenDDS::DCPS::SubscriberImpl> (sub.in ());
+      if (0 == sub_impl) {
+        cerr << "Failed to obtain subscriber servant\n" << endl;
+        exit(1);
+      }
+
+      OpenDDS::DCPS::AttachStatus status = sub_impl->attach_transport(transport_impl.in());
+      if (status != OpenDDS::DCPS::ATTACH_OK) {
+        std::string status_str;
+        switch (status) {
+        case OpenDDS::DCPS::ATTACH_BAD_TRANSPORT:
+          status_str = "ATTACH_BAD_TRANSPORT";
+          break;
+        case OpenDDS::DCPS::ATTACH_ERROR:
+          status_str = "ATTACH_ERROR";
+          break;
+        case OpenDDS::DCPS::ATTACH_INCOMPATIBLE_QOS:
+          status_str = "ATTACH_INCOMPATIBLE_QOS";
+          break;
+        default:
+          status_str = "Unknown Status";
+          break;
+        }
+        cerr << "Failed to attach to the transport. Status == "
+          << status_str.c_str() << endl;
+        exit(1);
+      }
+
+      // activate the listener
+      DataReaderListenerImpl        listener_servant;
+      DDS::DataReaderListener_var listener = ::OpenDDS::DCPS::servant_to_reference(&listener_servant);
+
+      if (CORBA::is_nil (listener.in ())) {
+        cerr << "listener is nil." << endl;
+        exit(1);
+      }
+
+      // Create the Datareaders
+      DDS::DataReaderQos dr_qos;
+      sub->get_default_datareader_qos (dr_qos);
+      DDS::DataReader_var dr = sub->create_datareader(topic.in (),
+                                                      dr_qos,
+                                                      listener.in ());
+      if (CORBA::is_nil (dr.in ())) {
+        cerr << "create_datareader failed." << endl;
+        exit(1);
+      }
+
+
+      int expected = 10;
+      while ( listener_servant.num_reads() < expected) {
+        ACE_OS::sleep (1);
+      }
+
+      if (!CORBA::is_nil (participant.in ())) {
+        participant->delete_contained_entities();
+      }
+      if (!CORBA::is_nil (dpf.in ())) {
+        dpf->delete_participant(participant.in ());
+      }
+      ACE_OS::sleep(2);
+
+      TheTransportFactory->release();
+      TheServiceParticipant->shutdown ();
+
+    }
+  catch (CORBA::Exception& e)
+    {
+      cerr << "SUB: Exception caught in main ():" << endl << e << endl;
+      return 1;
+    }
+
+  return 0;
+}
diff --git a/dds_io_sub/diasio.cpp b/dds_io_sub/diasio.cpp
new file mode 100644
index 0000000..9209fcb
--- /dev/null
+++ b/dds_io_sub/diasio.cpp
@@ -0,0 +1,122 @@
+/*
+ ============================================================================
+ Name        : diasio.cpp
+ Author      : Manuel Traut
+ Version     :
+ Copyright   : Your copyright notice
+ Description : DAIS IO Class
+ ============================================================================
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <fcntl.h>
+#include <sys/io.h>
+#include <sys/ioctl.h>
+#include <unistd.h>
+#include <pthread.h>
+#include <time.h>
+
+#include "diasio.h"
+
+unsigned int DIASIO::instance = 0;
+bool DIASIO::stop_wd = false;
+int DIASIO::m_Bereich1;
+int DIASIO::m_Bereich2;
+int DIASIO::m_Bereich3;
+
+static void* watchDogTriggern(void* arg) 
+{
+	struct timespec req;
+	unsigned int out = 0;
+	
+	req.tv_sec  = 0;
+	req.tv_nsec = 300000;
+	while(!DIASIO::stop_wd){
+		outw( out, DIASIO::m_Bereich2 + 0x0c );
+		nanosleep(&req, NULL);
+	}
+	return NULL;
+}
+
+
+DIASIO::DIASIO(){
+	if(instance == 0){
+		init();
+	}
+	instance++;
+}
+
+DIASIO::~DIASIO(){
+	instance--;
+	if(instance == 0){
+		stop_wd = true;
+		pthread_join(watchdog, NULL);
+		S_AdresseOut -= m_Bereich2;
+	}
+}
+
+void DIASIO::set(TyuInt16 value){
+	outw( value, S_AdresseOut );
+}
+
+TyuInt16 DIASIO::get(){
+	return inw( S_AdresseOut );
+}
+
+void DIASIO::init(){
+	S_AdresseOut += m_Bereich2;
+
+	char a_buffer[17];
+	
+	pthread_attr_t watchdog_attr;
+		
+	iopl( 3 );
+
+	sprintf( a_buffer, "/dev/diasio_card%i", 0 );
+	m_Deviceio = open( a_buffer, O_RDWR );
+
+	if( -1 == m_Deviceio ) {
+		fprintf(stderr, "Kein Zugriff auf IO-Karte %s", a_buffer);
+		fflush(stderr);
+		exit(0);
+	}
+   
+	//PCI-Kartenadressen holen
+	m_Bereich1 = 0;
+	if( 0 != ioctl( m_Deviceio, D_TCDIASIOC_IOADRESSELESEN, &m_Bereich1 ) )
+	{
+		fprintf(stderr, "couldn't get bereich1\n");
+		fflush(stderr);
+		close( m_Deviceio );
+		m_Deviceio = -1;
+		exit(0);
+	}
+
+	m_Bereich2 = 1;
+	if( 0 != ioctl( m_Deviceio, D_TCDIASIOC_IOADRESSELESEN, &m_Bereich2 ) )
+	{
+		fprintf(stderr, "couldn't get bereich2\n");
+		fflush(stderr);
+		close( m_Deviceio );
+		m_Deviceio = -1;
+		exit(0);
+	}
+
+	m_Bereich3 = 2;
+	if( 0 != ioctl( m_Deviceio, D_TCDIASIOC_IOADRESSELESEN, &m_Bereich3 ) )
+	{
+		fprintf(stderr, "couldn't get bereich3\n");
+		fflush(stderr);
+		close( m_Deviceio );
+		m_Deviceio = -1;
+		exit(0);
+	}
+
+	fprintf(stderr, "1: 0x%x, 2: 0x%x, 3: 0x%x\n", m_Bereich1, m_Bereich2, m_Bereich3);
+	fflush(stderr);
+
+	pthread_attr_init(&watchdog_attr);
+	if ( pthread_create(&watchdog, &watchdog_attr, watchDogTriggern, NULL) )
+		perror("watchdog thread creation failed");
+}
diff --git a/dds_io_sub/diasio.h b/dds_io_sub/diasio.h
new file mode 100644
index 0000000..ae27b50
--- /dev/null
+++ b/dds_io_sub/diasio.h
@@ -0,0 +1,78 @@
+//------------------------------------------------------------------------------
+//  All rights reserved to Trumpf GmbH + Co., Germany
+//------------------------------------------------------------------------------
+
+#ifndef TCDIASUSER_H
+#define TCDIASUSER_H
+
+// -- required headers ---------------------------------------------------------
+#include <linux/ioctl.h>
+#include "tctypdef.h"
+
+/*
+ * Ioctl definitions
+ */
+
+/* Use 'j' as magic number */
+#define D_TCDIAS_IOC_MAGIC  'j'
+
+#define D_TCDIASIOC_IOADRESSELESEN        _IOWR( D_TCDIAS_IOC_MAGIC, 0, TyuInt32 )
+#define D_TCDIASIOC_MEMLAENGE             _IOR( D_TCDIAS_IOC_MAGIC, 1, TysInt32 )
+#define D_TCDIASIOC_MEMOFFSET             _IOR( D_TCDIAS_IOC_MAGIC, 2, TyuInt32 )
+#define D_TCDIASIOC_AUTOSTART             _IOWR( D_TCDIAS_IOC_MAGIC, 3, TyuInt32 )
+#define D_TCDIASIOC_INTERRUPTBETRIEB      _IOWR( D_TCDIAS_IOC_MAGIC, 4, TyuInt32 )
+#define D_TCDIASIOC_BEENDEN               _IO( D_TCDIAS_IOC_MAGIC, 5 )
+#define D_TCDIASIOC_BEENDENAUFHEBEN       _IO( D_TCDIAS_IOC_MAGIC, 6 )
+#define D_TCDIAS_IOC_MAXNR 7
+
+/*
+static TyuInt32 S_AdresseLS7166 = 0;
+static TyuInt32 S_AdresseLS7166Status = 1;
+static TyuInt32 S_Adresse7Seg1 = 2;
+static TyuInt32 S_Adresse7Seg2 = 3;
+*/
+static TyuInt32 S_AdresseOut = 4;
+/*
+static TyuInt32 S_AdresseIn = 5;
+static TyuInt32 S_AdresseWatchdog = 0x0c;
+static TyuInt32 S_AdresseStatus = 6;
+static TyuInt32 S_AdresseADStart = 7;
+static TyuInt32 S_AdresseMultiplexer = 8;
+static TyuInt32 S_AdresseFreigabe = 9;
+static TyuInt32 S_AdresseRevisionLogik = 0x0e;
+static TyuInt32 S_AdresseRevisionKarte = 0x0f;
+*/
+//zweiter Adressblock
+/*
+static TyuInt32 S_AdresseFrequenzzaehlerLW = 0;
+static TyuInt32 S_AdresseFrequenzzaehlerHW = 2;
+static TyuInt32 S_AdresseIndexRevisionZaehler = 4;
+static TyuInt32 S_AdresseAD = 6;
+static TyuInt32 S_AdresseDA0 = 8;
+static TyuInt32 S_AdresseDA1 = 0x0a;
+static TyuInt32 S_AdresseDA2 = 0x0c;
+static TyuInt32 S_AdresseDA3 = 0x0e;
+*/
+// -- exported global variables - declarations (should be empty)----------------
+
+class DIASIO{
+	
+public:
+	DIASIO();
+	~DIASIO();
+	void set(TyuInt16 value);
+	TyuInt16 get();
+	static int m_Bereich1;
+	static int m_Bereich2;
+	static int m_Bereich3;
+	static bool stop_wd;
+	
+private:
+	int m_Deviceio;
+	static unsigned int instance;
+	pthread_t watchdog;
+	
+	void init();
+};
+
+#endif
diff --git a/dds_io_sub/sub.ini b/dds_io_sub/sub.ini
new file mode 100644
index 0000000..9dcfe13
--- /dev/null
+++ b/dds_io_sub/sub.ini
@@ -0,0 +1,93 @@
+# Note:
+#    1) The configuration defaults to not configure via file. The configuration file name
+#       should be specified via command line option -DCPSConfigFile.
+#    2) Use # or ; for comments
+#    3) The command line option can overwrite the configuration value specified in this
+#       file.
+#    4) Run application with -DCPSDebugLevel [>0] to help debugging dds configuration.
+
+# This "common" section configures the data in Service_Participant.
+[common]
+# DCPS specific debug level.
+DCPSDebugLevel=0
+# DCPS repository ior file name.
+DCPSInfoRepo=file:///home/manut/repo.ior
+# Number of chunks that the DataWriter's cached allocator can allocate when the resource
+# limits are infinite.
+DCPSChunks=20
+# maximum number of expected associations for publishers and subscribers.  This is used
+# to pre allocate enough memory and reduce heap allocations.
+DCPSChunkAssociationMutltiplier=10
+# The propagation delay factor.
+DCPSLivelinessFactor=80
+# The port number for the builtin topic.
+#DCPSBitTransportPort=
+# The timeout for lookup data from the builtin topic datareader (in milliseconds).
+#DCPSBitLookupDurationMsec=
+
+
+# Configuration for a specific TransportImpl object. The section name has the "transport_impl_"
+# as prefix and appeneds with the transport id which is an integer.
+[transport_impl_1]
+# This transport_type should match the "type" argument in the svc.conf or be the
+# SimpleTcp which is part of the DDSdcps lib.
+transport_type=SimpleTcp
+# The local endpoint.
+local_address=localhost:2222
+#transport configuration
+swap_bytes=
+# Number of pre-created link (list) objects per pool for the
+# "send queue" of each DataLink.  Each link references a sample
+# or framework control message.
+queue_messages_per_pool=
+# Initial number of pre-allocated pools of link (list) objects
+# for the "send queue" of each DataLink.
+queue_initial_pools=
+#Max size (in bytes) of a packet (packet header + sample(s))
+max_packet_size=
+# Max number of samples that should ever be in a single packet.
+max_samples_per_packet=
+# Optimum size (in bytes) of a packet (packet header + sample(s)).
+optimum_packet_size=
+# This is just for SimpleTcp transport.
+enable_nagle_algorithm=
+
+###=== Configurations for connector side during reconnecting===
+
+# The initial retry delay in milliseconds.
+# The first connection retry will be when the loss of connection
+# is detected.  The second try will be after this delay.
+# The default is 500 miliseconds.
+conn_retry_initial_delay=
+
+# The backoff multiplier for reconnection strategy.
+# The third and so on reconnect will be this value * the previous delay.
+# Hence with conn_retry_initial_delay=500 and conn_retry_backoff_multiplier=1.5
+# the second reconnect attempt will be at 0.5 seconds after first retry connect
+# fails; the third attempt will be 0.75 seconds after the second retry connect
+# fails; the fourth attempt will be 1.125 seconds after the third retry connect
+# fails.
+# The default value is 2.0.
+conn_retry_backoff_multiplier=
+
+# Number of attemps to reconnect before giving up and calling
+# on_publication_lost() and on_subscription_lost() callbacks.
+# The default is 3.
+conn_retry_attempts=
+
+# Maximum period (in milliseconds) of not being able to send queued
+# messages. If there are samples queued and no output for longer
+# than this period then the connection will be closed and on_*_lost()
+# callbacks will be called. If the value is zero, the default, then
+# this check will not be made.
+max_output_pause_period=
+
+###=== Configurations for acceptor side during reconnecting===
+
+# The time period in milliseconds for the acceptor side
+# of a connection to wait for the connection to be reconnected.
+# If not reconnected within this period then
+# on_publication_lost() and on_subscription_lost() callbacks
+# will be called.
+# The default is 2 seconds (2000 millseconds).
+passive_reconnect_duration=
\ No newline at end of file
diff --git a/dds_io_sub/sub_start.sh b/dds_io_sub/sub_start.sh
new file mode 100644
index 0000000..1f4bc35
--- /dev/null
+++ b/dds_io_sub/sub_start.sh
@@ -0,0 +1 @@
+./dds_io_sub -ORBSvcConf tcp.conf -DCPSInfoRepo corbaloc:iiop:192.168.0.98:4456/DCPSInfoRepo -DCPSConfigFile sub.ini
diff --git a/dds_io_sub/tcp.conf b/dds_io_sub/tcp.conf
new file mode 100644
index 0000000..7084cc8
--- /dev/null
+++ b/dds_io_sub/tcp.conf
@@ -0,0 +1 @@
+dynamic DCPS_SimpleTcpLoader Service_Object * SimpleTcp:_make_DCPS_SimpleTcpLoader() "-type SimpleTcp"
diff --git a/dds_io_sub/tctypdef.h b/dds_io_sub/tctypdef.h
new file mode 100644
index 0000000..614771d
--- /dev/null
+++ b/dds_io_sub/tctypdef.h
@@ -0,0 +1,75 @@
+// \HEADER\--------------------------------------------------------------------
+//
+//  $Archive:   //pvcs_tw/data/archives/SensorSystems/Linuxprojekte/DIAS-Linux/rtsystem/src/rtsystem/lrt/treiber/dias4io/tctypdef.h-arc  $
+//
+//  $Revision:   1.0  $
+//
+//  $Date:   Mar 05 2007 12:07:38  $
+//
+//  $Author:   kraussjo  $
+//
+//  CONTENTS      :
+//
+//  DESCRIPTION   :
+//
+//  RESTRICTIONS  :
+//
+//  REQUIRES      :
+//
+//------------------------------------------------------------------------------
+//  All rights reserved to Trumpf GmbH + Co., Germany
+//------------------------------------------------------------------------------
+
+#ifndef tctypdef_H
+#define tctypdef_H
+
+
+// -- required headers ---------------------------------------------------------
+
+// -- forward declarations -----------------------------------------------------
+
+// -- exported constants, types, classes ---------------------------------------
+
+// -- exported functions - declarations ----------------------------------------
+
+/**
+* Description of
+*
+* Design Pattern:
+*
+* @author  krauss
+* @version  $Revision:   1.0  $
+*/
+#if defined DIASLINUX || WIN32
+typedef char     TysChar;
+typedef unsigned char   TyuChar;
+typedef signed short    TysInt16;
+typedef unsigned short  TyuInt16;
+typedef signed int      TysInt32;
+typedef unsigned int    TyuInt32;
+typedef signed long     TysInt64;
+typedef unsigned long   TyuInt64;
+typedef float           TyReal32;
+typedef double          TyReal64;
+#else
+typedef char     TysChar;
+typedef unsigned char   TyuChar;
+typedef signed int      TysInt16;
+typedef unsigned int    TyuInt16;
+typedef signed long     TysInt32;
+typedef unsigned long   TyuInt32;
+typedef float           TyReal32;
+typedef double          TyReal64;
+/*
+#define TysChar char
+#define TyuChar unsigned char
+#define TysInt16 int
+#define TyuInt16 unsigned int
+#define TysInt32 long
+#define TyuInt32 unsigned long
+#define TyReal32 float
+#define TyReal64 double*/
+#endif
+// -- exported global variables - declarations (should be empty)----------------
+
+#endif