diff --git a/src/forsyde.hpp b/src/forsyde.hpp
index f28d39e..7b79381 100644
--- a/src/forsyde.hpp
+++ b/src/forsyde.hpp
@@ -69,8 +69,10 @@
 // include the main SystemC library
 #include <systemc>
 
+// include type libraries
+#include "forsyde/type_helpers.hpp"
 #ifdef FORSYDE_INTROSPECTION
-#include "forsyde/types.hpp"
+#include "forsyde/type_introspect.hpp"
 #endif
 
 // include the abstract semantics
diff --git a/src/forsyde/abssemantics.hpp b/src/forsyde/abssemantics.hpp
index cc881b5..7e61982 100644
--- a/src/forsyde/abssemantics.hpp
+++ b/src/forsyde/abssemantics.hpp
@@ -14,6 +14,8 @@
 #ifndef ABSSEMANTICS_HPP
 #define ABSSEMANTICS_HPP
 
+#include "type_introspect.hpp"
+
 /*! \file abssemantics.hpp
  * \brief The common abstract semantics for all MoCs.
  * 
@@ -89,7 +91,7 @@ class signal: public sc_fifo<TokenType>
     //! Returns the name of the token type
     virtual const char* token_type() const
     {
-        return get_type_name<T>();
+        return IntrospectiveType::traverse<T>();
     }
     
     virtual std::string moc() const = 0;
@@ -149,7 +151,7 @@ class in_port: public sc_fifo_in<TokenType>
     //! Returns the plain name of the token type
     virtual const char* token_type() const
     {
-        return get_type_name<T>();
+        return IntrospectiveType::traverse<T>();
     }
 #endif
 };
@@ -189,7 +191,7 @@ class out_port: public sc_fifo_out<TokenType>
     //! Returns the name of the actual type (not abst_ext version)
     virtual const char* token_type() const
     {
-        return get_type_name<T>();
+        return IntrospectiveType::traverse<T>();
     }
 #endif
 };
diff --git a/src/forsyde/sdf_helpers.hpp b/src/forsyde/sdf_helpers.hpp
index bc90791..f2aa01e 100644
--- a/src/forsyde/sdf_helpers.hpp
+++ b/src/forsyde/sdf_helpers.hpp
@@ -345,7 +345,7 @@ template <class T1, template <class> class I1If,
 inline zip<T1,T2>* make_zip(std::string pName,
     unsigned int i1toks,
     unsigned int i2toks,
-    OIf<std::tuple<std::vector<T1>,std::vector<T2>>>& outS,
+    OIf<token_tuple<T1,T2>>& outS,
     I1If<T1>& inp1S,
     I2If<T2>& inp2S
     )
@@ -370,7 +370,7 @@ template <template <class> class IIf,
            class T1, template <class> class O1If,
            class T2, template <class> class O2If>
 inline unzip<T1,T2>* make_unzip(std::string pName,
-    IIf<std::tuple<std::vector<T1>,std::vector<T2>>>& inpS,
+    IIf<token_tuple<T1,T2>>& inpS,
     unsigned int o1toks,
     unsigned int o2toks,
     O1If<T1>& out1S,
diff --git a/src/forsyde/sdf_moc.hpp b/src/forsyde/sdf_moc.hpp
index 9ee4750..b428fc4 100644
--- a/src/forsyde/sdf_moc.hpp
+++ b/src/forsyde/sdf_moc.hpp
@@ -24,6 +24,7 @@
 #include <functional>
 #include <tuple>
 
+#include "token.hpp"
 #include "sdf_process.hpp"
 #include "sdf_process_constructors.hpp"
 #include "sdf_helpers.hpp"
diff --git a/src/forsyde/sdf_process_constructors.hpp b/src/forsyde/sdf_process_constructors.hpp
index 4cccb83..deef9a6 100644
--- a/src/forsyde/sdf_process_constructors.hpp
+++ b/src/forsyde/sdf_process_constructors.hpp
@@ -25,6 +25,8 @@
 #include <functional>
 #include <tuple>
 #include <vector>
+#include <initializer_list>
+
 
 #include "sdf_process.hpp"
 
@@ -1128,7 +1130,7 @@ class zip : public sdf_process
 public:
     SDF_in<T1> iport1;        ///< port for the input channel 1
     SDF_in<T2> iport2;        ///< port for the input channel 2
-    SDF_out<std::tuple<std::vector<T1>,std::vector<T2>>> oport1;///< port for the output channel
+    SDF_out<token_tuple<T1,T2>> oport1;///< port for the output channel
 
     //! The constructor requires the module name
     /*! It creates an SC_THREAD which reads data from its input ports,
@@ -1153,29 +1155,27 @@ class zip : public sdf_process
     unsigned i1toks;
     unsigned i2toks;
     
-    // intermediate values
-    std::vector<T1> ival1;
-    std::vector<T2> ival2;
+    token_tuple<T1,T2> ival;
+
     
     void init()
     {
-        ival1.resize(i1toks);
-        ival2.resize(i2toks);
+    	ival.resize({i1toks, i2toks});
     }
     
     void prep()
     {
         for (auto i=0; i<i1toks; i++)
-            ival1[i] = iport1.read();
+            ival.get<0>(i) = iport1.read();
         for (auto i=0; i<i2toks; i++)
-            ival2[i] = iport2.read();    
+        	ival.get<1>(i) = iport2.read();
     }
     
     void exec() {}
     
     void prod()
     {
-        WRITE_MULTIPORT(oport1,std::make_tuple(ival1,ival2))  // write to the output
+        WRITE_MULTIPORT(oport1,ival)  // write to the output
     }
     
     void clean() {}
@@ -1200,15 +1200,15 @@ class zipN : public sdf_process
 {
 public:
     std::tuple <SDF_in<Ts>...> iport;///< tuple of ports for the input channels
-    SDF_out<std::tuple<std::vector<Ts>...> > oport1;///< port for the output channel
+    SDF_out<token_tuple<Ts...> > oport1;///< port for the output channel
 
     //! The constructor requires the module name
     /*! It creates an SC_THREAD which reads data from its input port,
      * zips them together and writes the results using the output port
      */
     zipN(sc_module_name _name,
-         std::vector<unsigned> in_toks)
-          :sdf_process(_name), oport1("oport1"), in_toks(in_toks)
+		 std::initializer_list<unsigned> in_toks)
+          :sdf_process(_name), oport1("oport1"), in_toks(std::vector<unsigned>(in_toks))
     {
         if (in_toks.size()!=sizeof...(Ts))
             SC_REPORT_ERROR(name(),"Wrong number of production rates provided");
@@ -1224,16 +1224,16 @@ class zipN : public sdf_process
 private:
     std::vector<unsigned> in_toks;
     // intermediate values
-    std::tuple<std::vector<Ts>...>* in_val;
+    token_tuple<Ts...>* in_val;
     
     void init()
     {
-        in_val = new std::tuple<std::vector<Ts>...>;
+        in_val = new token_tuple<Ts...>;
     }
     
     void prep()
     {
-        *in_val = sc_fifo_tuple_read<Ts...>(iport, in_toks);
+        in_val->t = sc_fifo_tuple_read<Ts...>(iport, in_toks);
     }
     
     void exec() {}
@@ -1326,7 +1326,7 @@ template <class T1, class T2>
 class unzip : public sdf_process
 {
 public:
-    SDF_in<std::tuple<std::vector<T1>,std::vector<T2>>> iport1;///< port for the input channel
+    SDF_in<token_tuple<T1,T2>> iport1;///< port for the input channel
     SDF_out<T1> oport1;        ///< port for the output channel 1
     SDF_out<T2> oport2;        ///< port for the output channel 2
 
@@ -1363,7 +1363,7 @@ class unzip : public sdf_process
     
     void prep()
     {
-        *in_val = iport1.read();
+        *in_val = iport1.read().t;
     }
     
     void exec() {}
@@ -1399,7 +1399,7 @@ template <class... Ts>
 class unzipN : public sdf_process
 {
 public:
-    SDF_in<std::tuple<std::vector<Ts>...>> iport1;///< port for the input channel
+    SDF_in<token_tuple<Ts...>> iport1;///< port for the input channel
     std::tuple<SDF_out<Ts>...> oport;///< tuple of ports for the output channels
 
     //! The constructor requires the module name
@@ -1407,8 +1407,8 @@ class unzipN : public sdf_process
      * unzips it and writes the results using the output ports
      */
     unzipN(sc_module_name _name,
-            std::vector<unsigned> out_toks)
-          :sdf_process(_name), iport1("iport1"), out_toks(out_toks)
+            std::initializer_list<unsigned> out_toks)
+          :sdf_process(_name), iport1("iport1"), out_toks(std::vector<unsigned>(out_toks))
     {
         if (out_toks.size()!=sizeof...(Ts))
             SC_REPORT_ERROR(name(),"Wrong number of production rates provided");
@@ -1433,7 +1433,7 @@ class unzipN : public sdf_process
     
     void prep()
     {
-        *in_val = iport1.read();
+        *in_val = iport1.read().t;
     }
     
     void exec() {}
diff --git a/src/forsyde/token.hpp b/src/forsyde/token.hpp
new file mode 100644
index 0000000..df62596
--- /dev/null
+++ b/src/forsyde/token.hpp
@@ -0,0 +1,86 @@
+#ifndef TOKEN_TYPE_HPP
+#define TOKEN_TYPE_HPP
+
+/**********************************************************************           
+    * token.hpp -- Containers for tokens in UT MoCs                   *
+    *                                                                 *
+    * Author:  George Ungureanu (ugeorge@kth.se)                      *
+    *                                                                 *
+    * Purpose: Hides vector containers used for implementing multiple *
+    *          produced/consumed tokens, used in some MoCs (e.g. SDF) *
+    *                                                                 *
+    * Usage:   This file is included automatically                    *
+    *                                                                 *
+    * License: BSD3                                                   *
+    *******************************************************************/
+
+
+/*! \file token.hpp
+ * \brief Implements the token containers
+ */
+
+namespace ForSyDe
+{
+
+template<typename T>
+using tokens = std::vector<T>;
+
+template<typename... T>
+struct token_tuple {
+	typedef std::tuple<tokens<T>...> type;
+	type t;
+
+    token_tuple() {}
+    token_tuple(std::initializer_list<size_t> list) { traverse_tuple<sizeof...(T), type>::resize(list.end(), t); }
+	explicit token_tuple(const std::tuple<tokens<T>...> t_) : t(t_) {};
+	token_tuple(const token_tuple<T...> & t_) : t(t_.t){}
+
+    void resize(std::initializer_list<size_t> list) { traverse_tuple<sizeof...(T), type>::resize(list.end(), t); }
+	token_tuple<T...>& operator=(const token_tuple<T...>& rhs) { t = rhs.t; return *this;}
+	token_tuple<T...>& operator=(const std::tuple<tokens<T>...>& rhs) { t = rhs; return *this;}
+
+private:
+
+	// Default template for traversing a tuple
+	template <size_t N, typename Tup>
+	struct traverse_tuple {};
+
+	// Template specialization for traversing a tuple with multiple elements
+	template <size_t N, typename TT, typename... Tail>
+	struct traverse_tuple<N, std::tuple<tokens<TT>, Tail...>>{
+		static inline void resize(std::initializer_list<size_t>::iterator size, std::tuple<tokens<TT>, Tail...>& tv) {
+			--size;
+			std::get<N-1>(tv).resize(*size);
+			traverse_tuple<N-1, std::tuple<tokens<TT>, Tail...>>::resize(size, tv);
+		}
+	};
+
+	// Template specialization for traversing a tuple with one element
+	template <typename TT, typename... Tail>
+	struct traverse_tuple<1, std::tuple<tokens<TT>, Tail...>>{
+		static inline void resize(std::initializer_list<size_t>::iterator size, std::tuple<tokens<TT>, Tail...>& tv) {
+			std::get<0>(tv).resize(*size);
+		}
+	};
+};
+
+template<typename... T>
+std::ostream& operator <<(std::ostream &os, const token_tuple<T...> &obj) {
+	return os;
+}
+
+
+// TODO: make an initializer traversal
+template<typename T>
+tokens<T> init(size_t n){
+	return tokens<T>(n);
+}
+
+template<typename... T>
+tokens<token_tuple<T...>> init(size_t n, std::initializer_list<size_t> list){
+	return tokens<token_tuple<T...>>(n, token_tuple<T...>(list));
+}
+
+}
+
+#endif
diff --git a/src/forsyde/type_helpers.hpp b/src/forsyde/type_helpers.hpp
new file mode 100644
index 0000000..bc9864f
--- /dev/null
+++ b/src/forsyde/type_helpers.hpp
@@ -0,0 +1,208 @@
+/**********************************************************************           
+    * type_helpers.hpp -- provides functions for accessing C types    *
+    *                                                                 *
+    * Author: George Ungureanu (ugeorge@kth.se)                       *
+    *                                                                 *
+    * Purpose: Provide facilities to access C types inside ForSyDe    *
+    *          signal structures.                                     *
+    *                                                                 *
+    * Usage:   This file is included automatically                    *
+    *                                                                 *
+    * License:                                                        *
+    *******************************************************************/
+
+#ifndef FORSYDE_TYPE_HELPERS_HPP
+#define FORSYDE_TYPE_HELPERS_HPP
+
+#include <tuple>
+#include "abst_ext.hpp"
+#include "token.hpp"
+
+/*! \file types.hpp
+ *  \brief Provides facilities for addressing C types inside complex containers.
+ */
+
+namespace ForSyDe
+{
+
+
+//! Class containing methods for returning references to C types inside channel structures
+/*! This class is used as a namespace for the getter helpers which return a
+ *  reference to a C type inside a channel structure implemented with template 
+ *  classes such as STL types, by addressing them using an index pack.
+ */
+class TypeGetter {
+public:
+        template<size_t N, typename T, size_t... Ixs> struct base;
+	template<size_t N, typename T, size_t... Ixs>
+	struct traverse {
+		static inline const void get (T&) {
+			throw std::out_of_range( "Too many indexes for the input type!" );
+		}
+	};
+
+	// Once the index pack has been consumed, return a reference to this C
+	//primitive type
+	template <typename T> struct base_t { typedef T type; };
+	template <typename T> struct base_val {
+		static inline const T& get (const T& t) { return t; }
+		static inline       T& get (T& t)       { return t; }
+	};
+
+	// Once the index pack has been consumed, return a reference to the C array
+	// associated with this std::vector
+	template <typename T> struct base_t<std::vector<T>> { typedef T type; };
+	template <typename T> struct base_val<std::vector<T>> {
+		static inline const T& get (const std::vector<T>& t) { return t[0]; }
+		static inline       T& get (std::vector<T>& t)       { return t[0]; }
+	};
+
+	// Once the index pack has been consumed, return a reference to the C array
+	// associated with this std::array
+	template <typename T, size_t S> struct base_t<std::array<T,S>> { typedef T type; };
+	template <typename T, size_t S> struct base_val<std::array<T,S>> {
+		static inline const T& get (const std::array<T,S>& t) { return t.data()[0]; }
+		static inline       T& get (std::array<T,S>& t)       { return t.data()[0]; }
+	};
+
+	// This is where the index pack is consumed. Once this point has been reached
+        // get the base C type addressed by the index pack
+	template<typename T, size_t... Ixs>
+	struct base<0, T, Ixs...> { typedef typename base_t<T>::type type; };
+	template<typename T, size_t... Ixs>
+	struct traverse<0, T, Ixs...> {
+		static inline const typename base_t<T>::type& get (const T& t) { return base_val<T>::get(t); }
+		static inline typename       base_t<T>::type& get (T& t)       { return base_val<T>::get(t); }
+	};
+
+	// traversal through a vector
+	template<size_t N, typename T, size_t Ix, size_t... Ixs>
+	struct base<N, std::vector<T>, Ix, Ixs...> { typedef typename base<N-1, T, Ixs...>::type type; };
+	template<size_t N, typename T, size_t Ix, size_t... Ixs>
+	struct traverse<N, std::vector<T>, Ix, Ixs...> {
+		static inline const typename base<N, std::vector<T>, Ix, Ixs...>::type& get (const std::vector<T>& t) {
+			return traverse<N-1, T, Ixs...>::get(t.at(Ix));
+		}
+		static inline typename       base<N, std::vector<T>, Ix, Ixs...>::type& get (std::vector<T>& t) {
+			return traverse<N-1, T, Ixs...>::get(t.at(Ix));
+		}
+	};
+
+	// traversal through an array
+	template<size_t N, typename T, size_t S, size_t Ix, size_t... Ixs>
+	struct base<N, std::array<T,S>, Ix, Ixs...> { typedef typename base<N-1, T, Ixs...>::type type; };
+	template<size_t N, typename T, size_t S, size_t Ix, size_t... Ixs>
+	struct traverse<N, std::array<T,S>, Ix, Ixs...> {
+		static inline const typename base<N, std::array<T,S>, Ix, Ixs...>::type& get (const std::array<T,S>& t) {
+			return traverse<N-1, T, Ixs...>::get(t.at(Ix));
+		}
+		static inline typename      base<N, std::array<T,S>, Ix, Ixs...>::type& get (std::array<T,S>& t) {
+			return traverse<N-1, T, Ixs...>::get(t.at(Ix));
+		}
+	};
+
+	// traversal through a tuple
+	template<size_t N, typename... T, size_t Ix, size_t... Ixs>
+	struct base<N, std::tuple<T...>, Ix, Ixs...> {
+		typedef typename base<N-1, typename std::tuple_element<Ix, std::tuple<T...> >::type, Ixs...>::type type;
+	};
+	template<size_t N, typename... T, size_t Ix, size_t... Ixs>
+	struct traverse<N, std::tuple<T...>, Ix, Ixs...> {
+		static inline const typename base<N, std::tuple<T...>, Ix, Ixs...>::type& get (const std::tuple<T...>& t) {
+			return traverse<N-1, typename std::tuple_element<Ix, std::tuple<T...> >::type, Ixs...> ::get(std::get<Ix>(t));
+		}
+		static inline typename       base<N, std::tuple<T...>, Ix, Ixs...>::type& get (std::tuple<T...>& t) {
+			return traverse<N-1, typename std::tuple_element<Ix, std::tuple<T...> >::type, Ixs...> ::get(std::get<Ix>(t));
+		}
+	};
+
+	// traversal through a token_tuple
+	template<size_t N, typename... T, size_t Ix, size_t... Ixs>
+	struct base<N, token_tuple<T...>, Ix, Ixs...> {
+		typedef typename base<N-1, typename std::tuple_element<Ix, std::tuple<std::vector<T>...> >::type, Ixs...>::type type;
+	};
+	template<size_t N, typename... T, size_t Ix, size_t... Ixs>
+	struct traverse<N, token_tuple<T...>, Ix, Ixs...> {
+		static inline const typename base<N, token_tuple<T...>, Ix, Ixs...>::type& get (const token_tuple<T...>& t) {
+			return traverse<N-1, typename std::tuple_element<Ix, std::tuple<std::vector<T>...> >::type, Ixs...> ::get(std::get<Ix>(t.t));
+		}
+		static inline typename       base<N, token_tuple<T...>, Ix, Ixs...>::type& get (token_tuple<T...>& t) {
+			return traverse<N-1, typename std::tuple_element<Ix, std::tuple<std::vector<T>...> >::type, Ixs...> ::get(std::get<Ix>(t.t));
+		}
+	};
+};
+
+
+/*! Get a reference to the first-level element in a complex template structure 
+\code{.cpp}
+std::vector<int> a = {1,2,3,4};
+int b = ForSyDe::get<1>(a);    // b = 2
+\endcode
+ */
+template<size_t I1, typename Ti>
+inline typename TypeGetter::base<1, Ti, I1>::type&
+get(Ti& v){ return TypeGetter::traverse<1, Ti, I1>::get(v); }
+
+/*! Get a reference to the second-level element in a complex template structure 
+\code{.cpp}
+std::tuple<std::vector<int>,char> a = std::make_tuple(std::vector({1,2,3,4,5}), 'b');
+int b = ForSyDe::get<0,2>(a);    // b = 3
+\endcode
+ */
+template<size_t I1, size_t I2, typename Ti>
+inline typename TypeGetter::base<2, Ti, I1, I2>::type&
+get(Ti& v){ return TypeGetter::traverse<2, Ti, I1, I2>::get(v); }
+
+
+/*! Get a reference to a third-level element in a complex template structure 
+\code{.cpp}
+std::tuple<std::vector<int>,char> a1 = std::make_tuple(std::vector({1,2,3}), 'a1');
+std::tuple<std::vector<int>,char> a2 = std::make_tuple(std::vector({4,5,6}), 'a2');
+std::vector<std::tuple<std::vector<int>,char>> a = {a1, a2};
+int b = ForSyDe::get<1,0,2>(a)    // b = 6
+\endcode
+ */
+template<size_t I1, size_t I2, size_t I3, typename Ti>
+inline typename TypeGetter::base<3, Ti, I1, I2, I3>::type&
+get(Ti& v){ return TypeGetter::traverse<3, Ti, I1, I2, I3>::get(v); }
+
+/*! Get a reference to a fourth-level element in a complex template structure 
+ */
+template<size_t I1, size_t I2, size_t I3, size_t I4, typename Ti>
+inline typename TypeGetter::base<4, Ti, I1, I2, I3, I4>::type&
+get(Ti& v){ return TypeGetter::traverse<4, Ti, I1, I2, I3, I4>::get(v); }
+
+/*! Get a reference to a fifth-level element in a complex template structure 
+ */
+template<size_t I1, size_t I2, size_t I3, size_t I4, size_t I5, typename Ti>
+inline typename TypeGetter::base<5, Ti, I1, I2, I3, I4, I5>::type&
+get(Ti& v){ return TypeGetter::traverse<5, Ti, I1, I2, I3, I4, I5>::get(v); }
+
+
+
+
+template<size_t I1, typename Ti>
+inline const typename TypeGetter::base<1, Ti, I1>::type&
+get(const Ti& v){ return TypeGetter::traverse<1, Ti, I1>::get(v); }
+
+template<size_t I1, size_t I2, typename Ti>
+inline const typename TypeGetter::base<2, Ti, I1, I2>::type&
+get(const Ti& v){ return TypeGetter::traverse<2, Ti, I1, I2>::get(v); }
+
+template<size_t I1, size_t I2, size_t I3, typename Ti>
+inline const typename TypeGetter::base<3, Ti, I1, I2, I3>::type&
+get(const Ti& v){ return TypeGetter::traverse<3, Ti, I1, I2, I3>::get(v); }
+
+template<size_t I1, size_t I2, size_t I3, size_t I4, typename Ti>
+inline const typename TypeGetter::base<4, Ti, I1, I2, I3, I4>::type&
+get(const Ti& v){ return TypeGetter::traverse<4, Ti, I1, I2, I3, I4>::get(v); }
+
+template<size_t I1, size_t I2, size_t I3, size_t I4, size_t I5, typename Ti>
+inline const typename TypeGetter::base<5, Ti, I1, I2, I3, I4, I5>::type&
+get(const Ti& v){ return TypeGetter::traverse<5, Ti, I1, I2, I3, I4, I5>::get(v); }
+
+
+}
+
+#endif
+
diff --git a/src/forsyde/type_introspect.hpp b/src/forsyde/type_introspect.hpp
new file mode 100644
index 0000000..a9f1613
--- /dev/null
+++ b/src/forsyde/type_introspect.hpp
@@ -0,0 +1,373 @@
+/**********************************************************************           
+    * types.hpp -- provides a type reflection mechanism.              *
+    *                                                                 *
+    * Authors: Hosein Attarzadeh (shan2@kth.se)                       *
+    *          George Ungureanu (ugeorge@kth.se)                      *
+    *                                                                 *
+    * based on: http://stackoverflow.com/questions/1055452/c-get-name-of-type-in-template *
+    *                                                                 *
+    * Purpose: Provide facilities to store the type information, used *
+    *          in introspection.                                      *
+    *                                                                 *
+    * Usage:   This file is included automatically                    *
+    *                                                                 *
+    * License:                                                        *
+    *******************************************************************/
+
+#ifndef FORSYDE_TYPE_INTROSPECT_HPP
+#define FORSYDE_TYPE_INTROSPECT_HPP
+
+/*! \file types.hpp
+ * \brief Provides facilities for type introspection
+ * 
+ *  This file includes
+ *    - a set of basic facilities for registering names or non-POD
+ *      C/C++ types to be reflected in the XML output of the
+ *      introspection stage.
+ *    - a set of basic facilities for declaring and registering custom
+ *      types, such as struct
+ *    - a set of methods for recursive parsing and introspection of
+ *      template data types.
+ *    - a singleton container for storing all type structures found
+ *      during the introspection phase
+ */
+
+
+#include <iostream>
+#include <sstream>
+#include <tuple>
+
+#include "abst_ext.hpp"
+#include "token.hpp"
+#include "rapidxml_print.hpp"
+
+using namespace rapidxml;
+
+// The general case uses RTTI (if the type is not registered explicitly)
+#pragma once
+template<typename T> const char* get_type_name() {
+	return typeid(T).name();
+}
+
+// helper macros
+#define FIRST_ARG___(N, ...) N
+#define FARG_NAME___(N, ...) #N
+#define REST_ARGS___(N, ...) __VA_ARGS__
+#define FIRST_ARG__(args) FIRST_ARG___ args
+#define FARG_NAME__(args) FARG_NAME___ args
+#define REST_ARGS__(args) REST_ARGS___ args
+
+
+// Specialization for each type
+#define DEFINE_TYPE(...) \
+    template<>const char* get_type_name<__VA_ARGS__>(){return #__VA_ARGS__;}
+
+#define DEFINE_TYPE_NAME(...) \
+	template<>const char* get_type_name<REST_ARGS__((__VA_ARGS__))>(){return FIRST_ARG__((__VA_ARGS__);}
+
+
+// Defines also the streaming operator for user defined types. Must be followed by a function definition. {}
+#define DEFINE_TYPE_STREAM(...) \
+		DEFINE_TYPE(__VA_ARGS__); \
+		void getCustomTypeDefinition(std::ostream &os, const __VA_ARGS__ &obj); \
+		std::ostream& operator <<(std::ostream &os, const __VA_ARGS__ &obj) \
+		{ \
+			getCustomTypeDefinition(os, obj); \
+			return os;\
+		} \
+		void getCustomTypeDefinition(std::ostream &os, const __VA_ARGS__ &obj)
+
+
+#define TYPEDEF(...)\
+    typedef REST_ARGS__((__VA_ARGS__)) FIRST_ARG__((__VA_ARGS__));\
+    DEFINE_TYPE_STREAM(FIRST_ARG__((__VA_ARGS__)))
+
+
+// Helper macro for creating structures. Must be followed by a definition between {}
+#define STRUCT(...)\
+	typedef struct FIRST_ARG__((__VA_ARGS__)) { \
+			REST_ARGS__((__VA_ARGS__)) \
+	} FIRST_ARG__((__VA_ARGS__)); \
+	DEFINE_TYPE_STREAM(FIRST_ARG__((__VA_ARGS__)))
+
+
+// Helper macro for creating unions. Must be followed by a definition between {}
+#define UNION(...)\
+	typedef union FIRST_ARG__((__VA_ARGS__)) { \
+			REST_ARGS__((__VA_ARGS__)) \
+	} FIRST_ARG__((__VA_ARGS__)); \
+	DEFINE_TYPE_STREAM(FIRST_ARG__((__VA_ARGS__)))
+
+
+
+// Primitive type name definition
+DEFINE_TYPE(char);
+DEFINE_TYPE(short int);
+DEFINE_TYPE(unsigned short int);
+DEFINE_TYPE(int);
+DEFINE_TYPE(unsigned int);
+DEFINE_TYPE(long int);
+DEFINE_TYPE(unsigned long int);
+DEFINE_TYPE(long long int);
+DEFINE_TYPE(unsigned long long int);
+DEFINE_TYPE(bool);
+DEFINE_TYPE(float);
+DEFINE_TYPE(double);
+DEFINE_TYPE(long double);
+DEFINE_TYPE(wchar_t);
+
+namespace ForSyDe
+{
+
+#ifdef FORSYDE_TYPE_INTROSPECTION
+
+// Identifiers for primitive types
+template<class T> struct isPrimitive { enum { val = 0 }; };
+template<> struct isPrimitive<char>                   { enum { val = 1 }; };
+template<> struct isPrimitive<short int>              { enum { val = 1 }; };
+template<> struct isPrimitive<unsigned short int>     { enum { val = 1 }; };
+template<> struct isPrimitive<int>                    { enum { val = 1 }; };
+template<> struct isPrimitive<unsigned int>           { enum { val = 1 }; };
+template<> struct isPrimitive<long int>               { enum { val = 1 }; };
+template<> struct isPrimitive<unsigned long int>      { enum { val = 1 }; };
+template<> struct isPrimitive<long long int>          { enum { val = 1 }; };
+template<> struct isPrimitive<unsigned long long int> { enum { val = 1 }; };
+template<> struct isPrimitive<bool>                   { enum { val = 1 }; };
+template<> struct isPrimitive<float>                  { enum { val = 1 }; };
+template<> struct isPrimitive<double>                 { enum { val = 1 }; };
+template<> struct isPrimitive<long double>            { enum { val = 1 }; };
+template<> struct isPrimitive<wchar_t>                { enum { val = 1 }; };
+
+// xml label names
+static char* const_name = (char*)"name";
+static char* const_data_type = (char*)"type";
+static char* const_primitive = (char*)"primitive";
+static char* const_custom = (char*)"custom";
+static char* const_vector = (char*)"vector";
+static char* const_array = (char*)"array";
+static char* const_tuple = (char*)"tuple";
+static char* const_size = (char*)"size";
+static char* const_length = (char*)"length";
+static char* const_root_type = (char*)"forsyde_types";
+
+
+//! Singleton container for storing type structures during introspection
+/*! This class is used to store type structures during the introspection phase
+ *  as XML DOM document. It identifies types from the ForSyDe-IR by their
+ *  name given by the RTTI and stores them only once.
+ */
+class TypeContainer {
+public:
+    //! The instance getter.
+	static TypeContainer& get() {
+		static TypeContainer instance;
+		return instance;
+	}
+
+    //! Returns the root node of the XML DOM
+	xml_node<>* root() { return root_node; }
+
+    //! Allocates and appends a node to the XML documents, and returns its pointer.
+    xml_node<>* add_node(xml_node<>* parent, const char* name) {
+        xml_node<>* node = xml_doc.allocate_node(node_element, name);
+        parent->append_node(node);
+        return node;
+    }
+
+    //! Allocates and appends an attribute to an XML node, and returns its pointer.
+    void add_attribute(xml_node<>* node, const char* attr_name, const char* attr_val) {
+        xml_attribute<>* attr = xml_doc.allocate_attribute(attr_name, attr_val);
+        node->append_attribute(attr);
+    }
+
+    //! The print method writes the XML file to the output.
+    /*! The XML structure is already generated, so this command only
+     * checks for the availability of the output file and dumps the XML
+     * to it.
+     */
+    void printXML(std::string fileName)
+    {
+        std::ofstream outFile(fileName);
+        if (!outFile.is_open())
+            SC_REPORT_ERROR(fileName.c_str(), "file could not be opened to write the introspection output. Does the path exists?");
+        outFile << "<?xml version=\"1.0\" ?>" << std::endl;
+        outFile << "<!-- Automatically generated by ForSyDe -->" << std::endl;
+        outFile << "<!DOCTYPE forsyde_types SYSTEM \"forsyde_types.dtd\" >"  << std::endl;
+        outFile << xml_doc;
+
+    }
+
+private:
+    //! The (hidden) default constructor.
+	TypeContainer() {
+		root_node = xml_doc.allocate_node(node_element, const_root_type);
+		xml_doc.append_node(root_node);
+	};
+
+	~TypeContainer() {
+		xml_doc.clear();
+	};
+
+	// these are needed to ensure singleton pattern
+	TypeContainer(TypeContainer const&);
+	void operator=(TypeContainer const&);
+
+    //! The RapidXML DOM
+	xml_document<> xml_doc;
+
+	//! The root node
+	xml_node<>* root_node;
+
+};
+
+#endif // FORSYDE_TYPE_INTROSPECTION
+
+//! Class containing methods for recursive type introspection
+/*! This class is used as a namespace for all template functions used for
+ *  recursive type introspection. During the traversal of a type, its structure
+ *  is being stored in a TypeContainer singleton.
+ */
+class IntrospectiveType {
+public:
+	//! Main (and only) function for parsing a data type
+	/*! This function is the only one called during the introspection phase to
+	 *  traverse a type.
+	 *
+	 *  If the FORSYDE_TYPE_INTROSPECTION compiler flag is enabled then it
+	 *  updates the TypeContainer with the XML structure extracted. Otherwise
+	 *  it just returns its identifier (RTTI or given name).
+	 */
+	template <typename T>
+	static inline const char* traverse() {
+		const char* type_name = get_type_name<T>();
+
+#ifdef FORSYDE_TYPE_INTROSPECTION
+		xml_node<>* root = TypeContainer::get().root();
+		for (auto child = root->first_node(); child; child = child->next_sibling()) {
+			if (child->first_attribute(const_name)->value() == type_name ) return type_name;
+		}
+
+		xml_node<> *type_node = TypeContainer::get().add_node(root, const_data_type);
+		TypeContainer::get().add_attribute(type_node, const_name, type_name);
+		add_type_node<T>::get(type_node);
+#endif
+		return type_name;
+	};
+
+#ifdef FORSYDE_TYPE_INTROSPECTION
+
+	// Default template for getting the information of a node, in case no other structure is identified
+	template <typename T>
+	struct add_type_node {
+		static inline void get (xml_node<>* parent) {
+			char* node_type = (isPrimitive<T>::val) ? const_primitive : const_custom;
+			xml_node<> *primitive_node = TypeContainer::get().add_node(parent, node_type);
+			TypeContainer::get().add_attribute(primitive_node, const_name, get_type_name<T>());
+			TypeContainer::get().add_attribute(primitive_node, const_size, size_to_char(sizeof(T)));
+		}
+	};
+
+	// Template specialization for parsing vectors
+	template <typename T>
+	struct add_type_node<std::vector<T>> {
+		static inline void  get (xml_node<>* parent) {
+			xml_node<> *vector_node = TypeContainer::get().add_node(parent, const_vector);
+
+			add_type_node<T>::get(vector_node);
+		}
+	};
+
+	// Template specialization for parsing fixed size (std::)arrays
+	template <typename T, size_t S>
+	struct add_type_node<std::array<T,S>> {
+		static inline void  get (xml_node<>* parent) {
+			xml_node<> *vector_node = TypeContainer::get().add_node(parent, const_array);
+			TypeContainer::get().add_attribute(vector_node, const_length, size_to_char(S));
+
+			add_type_node<T>::get(vector_node);
+		}
+	};
+
+	// Template specialization for parsing tuples
+	template <typename... T>
+	struct add_type_node<std::tuple<T...>> {
+		static inline void get (xml_node<>* parent) {
+			xml_node<> *tuple_node = TypeContainer::get().add_node(parent, const_tuple);
+			TypeContainer::get().add_attribute(tuple_node, const_length, size_to_char(sizeof...(T)));
+			traverse_tuple<sizeof...(T), std::tuple<T...>>::get(tuple_node);
+		}
+	};
+
+	// Template specialization for parsing tuples
+	template <typename... T>
+	struct add_type_node<token_tuple<T...>> {
+		static inline void get (xml_node<>* parent) {
+			xml_node<> *tuple_node = TypeContainer::get().add_node(parent, const_tuple);
+			TypeContainer::get().add_attribute(tuple_node, const_length, size_to_char(sizeof...(T)));
+			traverse_tuple<sizeof...(T), token_tuple<T...>>::get(tuple_node);
+		}
+	};
+
+	// Default template for traversing a tuple
+	template <size_t N, typename Tup>
+	struct traverse_tuple {};
+
+	// Template specialization for traversing a tuple with multiple elements
+	template <size_t N, typename Head, typename... Tail>
+	struct traverse_tuple<N, std::tuple<Head, Tail...>>{
+		static inline void get (xml_node<>* parent) {
+			add_type_node<Head>::get(parent);
+			traverse_tuple<N-1, std::tuple<Tail...>>::get(parent);
+		}
+	};
+
+	// Template specialization for traversing a tuple with one element
+	template <typename Head, typename... Tail>
+	struct traverse_tuple<1, std::tuple<Head, Tail...>> {
+		static inline void get (xml_node<>* parent) {
+			add_type_node<Head>::get(parent);
+		}
+	};
+
+	// Template specialization for traversing a tuple with multiple elements
+	template <size_t N, typename Head, typename... Tail>
+	struct traverse_tuple<N, token_tuple<Head, Tail...>>{
+		static inline void get (xml_node<>* parent) {
+			add_type_node<Head>::get(parent);
+			traverse_tuple<N-1, token_tuple<Tail...>>::get(parent);
+		}
+	};
+
+	// Template specialization for traversing a tuple with one element
+	template <typename Head, typename... Tail>
+	struct traverse_tuple<1, token_tuple<Head, Tail...>> {
+		static inline void get (xml_node<>* parent) {
+			add_type_node<Head>::get(parent);
+		}
+	};
+
+
+
+	// Utility function : size_t to char array
+    static inline const char* size_to_char(size_t size){
+    	std::string str = std::to_string(size);
+    	char * writable = new char[str.size() + 1];
+    	std::copy(str.begin(), str.end(), writable);
+    	writable[str.size()] = '\0';
+    	return writable;
+    }
+
+	// Utility function : char array size_t
+    static inline size_t char_to_size(const char* char_size){
+    	std::istringstream iss(char_size);
+    	size_t size;
+    	iss >> size;
+    	return size;
+    }
+
+#endif  // FORSYDE_TYPE_INTROSPECTION
+};
+
+}
+
+#endif
diff --git a/src/forsyde/types.hpp b/src/forsyde/types.hpp
deleted file mode 100644
index 94bd0ba..0000000
--- a/src/forsyde/types.hpp
+++ /dev/null
@@ -1,59 +0,0 @@
-/**********************************************************************           
-    * types.hpp -- provides a simple type reflection mechanism.       *
-    *                                                                 *
-    * Author:  Hosein Attarzadeh (shan2@kth.se) based on:             *
-    * http://stackoverflow.com/questions/1055452/c-get-name-of-type-in-template *
-    *                                                                 *
-    * Purpose: Provide facilities to store the type names, used in    *
-    *          introspection.                                         *
-    * Usage:   This file is included automatically                    *
-    *                                                                 *
-    * License:                                                        *
-    *******************************************************************/
-
-#ifndef TYPES_HPP
-#define TYPES_HPP
-
-/*! \file types.hpp
- * \brief Provides facilities for basic type introspection
- * 
- *  This file includes a a set of basic facilities for registering names
- * for non-POD C/C++ types to be reflected in the XML output of the
- * interospection stage.
- */
-
-//~ namespace ForSyDe
-//~ {
-
-// The general case uses RTTI (if the type is not registered explicitly)
-#pragma once
-template<typename T> const char* get_type_name() {return typeid(T).name();}
-
-// Specialization for each type
-#define DEFINE_TYPE(X) \
-    template<>const char* get_type_name<X>(){return #X;}
-// Another version where we explicitly provide the type name (for complex types)
-#define DEFINE_TYPE_NAME(X,N) \
-    template<>const char* get_type_name<X>(){return N;}
-
-// Specialization for base types
-
-DEFINE_TYPE(char);
-DEFINE_TYPE(short int);
-DEFINE_TYPE(unsigned short int);
-DEFINE_TYPE(int);
-DEFINE_TYPE(unsigned int);
-DEFINE_TYPE(long int);
-DEFINE_TYPE(unsigned long int);
-DEFINE_TYPE(long long int);
-DEFINE_TYPE(unsigned long long int);
-DEFINE_TYPE(bool);
-DEFINE_TYPE(float);
-DEFINE_TYPE(double);
-DEFINE_TYPE(long double);
-DEFINE_TYPE(wchar_t);
-
-
-//~ }
-
-#endif
diff --git a/src/forsyde/xml.hpp b/src/forsyde/xml.hpp
index 9a7a7ac..815893a 100644
--- a/src/forsyde/xml.hpp
+++ b/src/forsyde/xml.hpp
@@ -23,6 +23,7 @@
  */
 
 #include <algorithm>
+#include <fstream>
 #include "rapidxml_print.hpp"
 
 #include "abssemantics.hpp"
@@ -42,6 +43,7 @@ void get_moc_and_pc(const std::string& kind, std::string& moc, std::string& pc)
     pc = kind.substr(kind.rfind(':')+1, kind.length());
 }
 
+
 //! Abstract class used to Export a system as an XML file
 /*! This class provides basic facilities to export a ForSyDe-SystemC
  * process network as an XML file.
@@ -94,11 +96,12 @@ class XMLExport
     /*! It initiates the translation job which is a recursive traversal
      * of the process network.
      */
+
     void traverse(sc_module* top)
     {
         // Initiate the XML file for this level of hierarchy
         xml_node<>* pn_node = init(top);
-        
+
         // Get the list of module children (ports and other processes)
         std::vector<sc_object*> children = top->get_child_objects();
         
@@ -145,7 +148,8 @@ class XMLExport
         printXML(path + name_str + std::string(".xml"));
         
     }
-    
+
+private:
     //! The init member initiates the XML DOM and performs initial settings.
     /*! 
      */
@@ -164,7 +168,7 @@ class XMLExport
         
         return pn_node;
     }
-    
+
     //! The print method writes the XML file to the output.
     /*! The XML structure is already generated, so this command only
      * checks for the availability of the output file and dumps the XML
@@ -332,6 +336,7 @@ class XMLExport
     
     //! The RapidXML DOM
     xml_document<> xml_doc;
+
     
     //! Some global constant names
     char *const_name, *const_leaf_process, *const_composite_process, 
@@ -341,7 +346,7 @@ class XMLExport
          *const_port_dir, *const_direction, *const_in, *const_out,
          *const_signal, *const_component_name, *const_argument, *const_value,
          *const_source, *const_source_port, *const_target, *const_target_port,
-         *const_bound_process, *const_bound_port;
+         *const_bound_process, *const_bound_port, *const_data_type;
     
     inline xml_node<>* allocate_append_node(xml_node<>* top, const char* name)
     {