Frames

QUIC/.cproject

@@ -0,0 +1,81 @@
+<?xml version="1.0" encoding="UTF-8" standalone="no"?>
+<?fileVersion 4.0.0?><cproject storage_type_id="org.eclipse.cdt.core.XmlProjectDescriptionStorage">
+	<storageModule moduleId="org.eclipse.cdt.core.settings">
+		<cconfiguration id="org.omnetpp.cdt.gnu.config.debug.214598754">
+			<storageModule buildSystemId="org.eclipse.cdt.managedbuilder.core.configurationDataProvider" id="org.omnetpp.cdt.gnu.config.debug.214598754" moduleId="org.eclipse.cdt.core.settings" name="debug">
+				<externalSettings/>
+				<extensions>
+					<extension id="org.eclipse.cdt.core.MachO64" point="org.eclipse.cdt.core.BinaryParser"/>
+					<extension id="org.eclipse.cdt.core.PE" point="org.eclipse.cdt.core.BinaryParser"/>
+					<extension id="org.eclipse.cdt.core.ELF" point="org.eclipse.cdt.core.BinaryParser"/>
+					<extension id="org.eclipse.cdt.core.GASErrorParser" point="org.eclipse.cdt.core.ErrorParser"/>
+					<extension id="org.eclipse.cdt.core.GmakeErrorParser" point="org.eclipse.cdt.core.ErrorParser"/>
+					<extension id="org.eclipse.cdt.core.GLDErrorParser" point="org.eclipse.cdt.core.ErrorParser"/>
+					<extension id="org.eclipse.cdt.core.CWDLocator" point="org.eclipse.cdt.core.ErrorParser"/>
+					<extension id="org.eclipse.cdt.core.GCCErrorParser" point="org.eclipse.cdt.core.ErrorParser"/>
+				</extensions>
+			</storageModule>
+			<storageModule moduleId="cdtBuildSystem" version="4.0.0">
+				<configuration artifactName="${ProjName}" buildProperties="" description="" id="org.omnetpp.cdt.gnu.config.debug.214598754" name="debug" parent="org.omnetpp.cdt.gnu.config.debug">
+					<folderInfo id="org.omnetpp.cdt.gnu.config.debug.214598754." name="/" resourcePath="">
+						<toolChain id="org.omnetpp.cdt.gnu.toolchain.debug.2030249339" name="C++ Toolchain for OMNeT++" superClass="org.omnetpp.cdt.gnu.toolchain.debug">
+							<targetPlatform binaryParser="org.eclipse.cdt.core.ELF;org.eclipse.cdt.core.MachO64;org.eclipse.cdt.core.PE" id="org.omnetpp.cdt.targetPlatform.808402859" isAbstract="false" name="Windows, Linux, Mac" osList="win32,linux,macosx" superClass="org.omnetpp.cdt.targetPlatform"/>
+							<builder id="org.omnetpp.cdt.gnu.builder.debug.737370877" managedBuildOn="true" name="OMNeT++ Make Builder (opp_makemake).debug" superClass="org.omnetpp.cdt.gnu.builder.debug"/>
+							<tool id="cdt.managedbuild.tool.gnu.archiver.base.922381525" name="GCC Archiver" superClass="cdt.managedbuild.tool.gnu.archiver.base"/>
+							<tool id="cdt.managedbuild.tool.gnu.cpp.compiler.base.1382400468" name="GCC C++ Compiler" superClass="cdt.managedbuild.tool.gnu.cpp.compiler.base"/>
+							<tool id="cdt.managedbuild.tool.gnu.c.compiler.base.1940858744" name="GCC C Compiler" superClass="cdt.managedbuild.tool.gnu.c.compiler.base"/>
+							<tool id="cdt.managedbuild.tool.gnu.c.linker.base.2045591854" name="GCC C Linker" superClass="cdt.managedbuild.tool.gnu.c.linker.base"/>
+							<tool id="cdt.managedbuild.tool.gnu.cpp.linker.base.1355518783" name="GCC C++ Linker" superClass="cdt.managedbuild.tool.gnu.cpp.linker.base"/>
+							<tool id="cdt.managedbuild.tool.gnu.assembler.base.525485360" name="GCC Assembler" superClass="cdt.managedbuild.tool.gnu.assembler.base"/>
+						</toolChain>
+					</folderInfo>
+				</configuration>
+			</storageModule>
+			<storageModule moduleId="org.eclipse.cdt.core.externalSettings"/>
+		</cconfiguration>
+		<cconfiguration id="org.omnetpp.cdt.gnu.config.release.890759287">
+			<storageModule buildSystemId="org.eclipse.cdt.managedbuilder.core.configurationDataProvider" id="org.omnetpp.cdt.gnu.config.release.890759287" moduleId="org.eclipse.cdt.core.settings" name="release">
+				<externalSettings/>
+				<extensions>
+					<extension id="org.eclipse.cdt.core.MachO64" point="org.eclipse.cdt.core.BinaryParser"/>
+					<extension id="org.eclipse.cdt.core.PE" point="org.eclipse.cdt.core.BinaryParser"/>
+					<extension id="org.eclipse.cdt.core.ELF" point="org.eclipse.cdt.core.BinaryParser"/>
+					<extension id="org.eclipse.cdt.core.GASErrorParser" point="org.eclipse.cdt.core.ErrorParser"/>
+					<extension id="org.eclipse.cdt.core.GmakeErrorParser" point="org.eclipse.cdt.core.ErrorParser"/>
+					<extension id="org.eclipse.cdt.core.GLDErrorParser" point="org.eclipse.cdt.core.ErrorParser"/>
+					<extension id="org.eclipse.cdt.core.CWDLocator" point="org.eclipse.cdt.core.ErrorParser"/>
+					<extension id="org.eclipse.cdt.core.GCCErrorParser" point="org.eclipse.cdt.core.ErrorParser"/>
+				</extensions>
+			</storageModule>
+			<storageModule moduleId="cdtBuildSystem" version="4.0.0">
+				<configuration artifactName="${ProjName}" buildProperties="" description="" id="org.omnetpp.cdt.gnu.config.release.890759287" name="release" parent="org.omnetpp.cdt.gnu.config.release">
+					<folderInfo id="org.omnetpp.cdt.gnu.config.release.890759287." name="/" resourcePath="">
+						<toolChain id="org.omnetpp.cdt.gnu.toolchain.release.2099107698" name="C++ Toolchain for OMNeT++" superClass="org.omnetpp.cdt.gnu.toolchain.release">
+							<targetPlatform binaryParser="org.eclipse.cdt.core.ELF;org.eclipse.cdt.core.MachO64;org.eclipse.cdt.core.PE" id="org.omnetpp.cdt.targetPlatform.268183508" isAbstract="false" name="Windows, Linux, Mac" osList="win32,linux,macosx" superClass="org.omnetpp.cdt.targetPlatform"/>
+							<builder id="org.omnetpp.cdt.gnu.builder.release.319479071" managedBuildOn="true" name="OMNeT++ Make Builder (opp_makemake).release" superClass="org.omnetpp.cdt.gnu.builder.release"/>
+							<tool id="cdt.managedbuild.tool.gnu.archiver.base.534395341" name="GCC Archiver" superClass="cdt.managedbuild.tool.gnu.archiver.base"/>
+							<tool id="cdt.managedbuild.tool.gnu.cpp.compiler.base.1330717157" name="GCC C++ Compiler" superClass="cdt.managedbuild.tool.gnu.cpp.compiler.base"/>
+							<tool id="cdt.managedbuild.tool.gnu.c.compiler.base.557001848" name="GCC C Compiler" superClass="cdt.managedbuild.tool.gnu.c.compiler.base"/>
+							<tool id="cdt.managedbuild.tool.gnu.c.linker.base.256993055" name="GCC C Linker" superClass="cdt.managedbuild.tool.gnu.c.linker.base"/>
+							<tool id="cdt.managedbuild.tool.gnu.cpp.linker.base.1400173853" name="GCC C++ Linker" superClass="cdt.managedbuild.tool.gnu.cpp.linker.base"/>
+							<tool id="cdt.managedbuild.tool.gnu.assembler.base.1849493846" name="GCC Assembler" superClass="cdt.managedbuild.tool.gnu.assembler.base"/>
+						</toolChain>
+					</folderInfo>
+				</configuration>
+			</storageModule>
+		</cconfiguration>
+	</storageModule>
+	<storageModule moduleId="cdtBuildSystem" version="4.0.0">
+		<project id="QUIC.org.omnetpp.cdt.omnetppProjectType.1991495107" name="OMNeT++ Simulation" projectType="org.omnetpp.cdt.omnetppProjectType"/>
+	</storageModule>
+	<storageModule moduleId="scannerConfiguration">
+		<autodiscovery enabled="true" problemReportingEnabled="true" selectedProfileId=""/>
+		<scannerConfigBuildInfo instanceId="org.omnetpp.cdt.gnu.config.release.890759287">
+			<autodiscovery enabled="true" problemReportingEnabled="true" selectedProfileId="org.omnetpp.cdt.OmnetppGCCPerProjectProfile"/>
+		</scannerConfigBuildInfo>
+		<scannerConfigBuildInfo instanceId="org.omnetpp.cdt.gnu.config.debug.214598754">
+			<autodiscovery enabled="true" problemReportingEnabled="true" selectedProfileId="org.omnetpp.cdt.OmnetppGCCPerProjectProfile"/>
+		</scannerConfigBuildInfo>
+	</storageModule>
+	<storageModule moduleId="org.eclipse.cdt.core.LanguageSettingsProviders"/>
+</cproject>

QUIC/.oppbuildspec

@@ -0,0 +1,4 @@
+<?xml version="1.0" encoding="UTF-8" standalone="no"?>
+<buildspec version="4.0">
+    <dir makemake-options="--deep -O out -I. --meta:recurse --meta:export-include-path --meta:use-exported-include-paths --meta:export-library --meta:use-exported-libs --meta:feature-cflags --meta:feature-ldflags" path="." type="makemake"/>
+</buildspec>

QUIC/.project

@@ -0,0 +1,39 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<projectDescription>
+	<name>QUIC</name>
+	<comment></comment>
+	<projects>
+		<project>inet</project>
+	</projects>
+	<buildSpec>
+		<buildCommand>
+			<name>org.omnetpp.cdt.MakefileBuilder</name>
+			<arguments>
+			</arguments>
+		</buildCommand>
+		<buildCommand>
+			<name>org.omnetpp.scave.builder.vectorfileindexer</name>
+			<arguments>
+			</arguments>
+		</buildCommand>
+		<buildCommand>
+			<name>org.eclipse.cdt.managedbuilder.core.genmakebuilder</name>
+			<triggers>clean,full,incremental,</triggers>
+			<arguments>
+			</arguments>
+		</buildCommand>
+		<buildCommand>
+			<name>org.eclipse.cdt.managedbuilder.core.ScannerConfigBuilder</name>
+			<triggers>full,incremental,</triggers>
+			<arguments>
+			</arguments>
+		</buildCommand>
+	</buildSpec>
+	<natures>
+		<nature>org.eclipse.cdt.core.cnature</nature>
+		<nature>org.eclipse.cdt.core.ccnature</nature>
+		<nature>org.eclipse.cdt.managedbuilder.core.managedBuildNature</nature>
+		<nature>org.eclipse.cdt.managedbuilder.core.ScannerConfigNature</nature>
+		<nature>org.omnetpp.main.omnetppnature</nature>
+	</natures>
+</projectDescription>

QUIC/.settings/language.settings.xml

@@ -0,0 +1,25 @@
+<?xml version="1.0" encoding="UTF-8" standalone="no"?>
+<project>
+	<configuration id="org.omnetpp.cdt.gnu.config.debug.214598754" name="debug">
+		<extension point="org.eclipse.cdt.core.LanguageSettingsProvider">
+			<provider copy-of="extension" id="org.eclipse.cdt.ui.UserLanguageSettingsProvider"/>
+			<provider-reference id="org.eclipse.cdt.core.ReferencedProjectsLanguageSettingsProvider" ref="shared-provider"/>
+			<provider-reference id="org.eclipse.cdt.managedbuilder.core.MBSLanguageSettingsProvider" ref="shared-provider"/>
+			<provider class="org.eclipse.cdt.managedbuilder.language.settings.providers.GCCBuiltinSpecsDetector" console="false" env-hash="1125886900994185115" id="org.eclipse.cdt.managedbuilder.core.GCCBuiltinSpecsDetector" keep-relative-paths="false" name="CDT GCC Built-in Compiler Settings" parameter="${COMMAND} ${FLAGS} -E -P -v -dD &quot;${INPUTS}&quot;" prefer-non-shared="true">
+				<language-scope id="org.eclipse.cdt.core.gcc"/>
+				<language-scope id="org.eclipse.cdt.core.g++"/>
+			</provider>
+		</extension>
+	</configuration>
+	<configuration id="org.omnetpp.cdt.gnu.config.release.890759287" name="release">
+		<extension point="org.eclipse.cdt.core.LanguageSettingsProvider">
+			<provider copy-of="extension" id="org.eclipse.cdt.ui.UserLanguageSettingsProvider"/>
+			<provider-reference id="org.eclipse.cdt.core.ReferencedProjectsLanguageSettingsProvider" ref="shared-provider"/>
+			<provider-reference id="org.eclipse.cdt.managedbuilder.core.MBSLanguageSettingsProvider" ref="shared-provider"/>
+			<provider class="org.eclipse.cdt.managedbuilder.language.settings.providers.GCCBuiltinSpecsDetector" console="false" env-hash="1125886900994185115" id="org.eclipse.cdt.managedbuilder.core.GCCBuiltinSpecsDetector" keep-relative-paths="false" name="CDT GCC Built-in Compiler Settings" parameter="${COMMAND} ${FLAGS} -E -P -v -dD &quot;${INPUTS}&quot;" prefer-non-shared="true">
+				<language-scope id="org.eclipse.cdt.core.gcc"/>
+				<language-scope id="org.eclipse.cdt.core.g++"/>
+			</provider>
+		</extension>
+	</configuration>
+</project>

QUIC/Connection/connection.h

@@ -0,0 +1,36 @@
+/*
+ * connection_Setup.h
+ *
+ *  Created on: Nov 17, 2017
+ *      Author: anay
+ */
+
+#ifndef CONNECTION_CONNECTION_H_
+#define CONNECTION_CONNECTION_H_
+
+#include "Headers/application_Error_Code.h"
+#include "Headers/transport_Error_Codes.h"
+#include "Headers/long_Header_m.h"
+#include "Headers/short_Header_m.h"
+#include "Frames/ack_m.h"
+#include "Frames/application_Close_m.h"
+#include "Frames/blocked_m.h"
+#include "Frames/connection_close_m.h"
+#include "Frames/max_Data_m.h"
+#include "Frames/max_Stream_Data_m.h"
+#include "Frames/new_Connection_Id_m.h"
+#include "Frames/padding_m.h"
+#include "Frames/ping_m.h"
+#include "Frames/rst_stream_m.h"
+#include "Frames/stop_Sending_m.h"
+#include "Frames/stream_Blocked_m.h"
+#include "Frames/stream_m.h"
+#include "Packets/0_RTT_Protected_m.h"
+#include "Packets/client_Cleartext_m.h"
+#include "Packets/client_Initial_m.h"
+#include "Packets/server_Cleartext_m.h"
+#include "Packets/server_Stateless_Retry_m.h"
+#include "Packets/version_Negotiation_m.h"
+
+
+#endif /* CONNECTION_CONNECTION_H_ */

QUIC/Connection/connection_Setup.cpp

@@ -0,0 +1,19 @@
+/*
+ * connection_Setup.cpp
+ *
+ *  Created on: Nov 27, 2017
+ *      Author: anay
+ */
+#include <omnetpp.h>
+#include "connection_Setup.h"
+
+void connection_Setup::initialize(int stage)
+{
+
+}
+void connection_Setup::sendVersionNegotiation()
+{
+    Version_Negotiation *msg;
+    msg->str("0x01, 0x02");
+}
+

QUIC/Connection/connection_Setup.h

@@ -0,0 +1,33 @@
+/*
+ * connection_Setup.h
+ *
+ *  Created on: Nov 27, 2017
+ *      Author: anay
+ */
+
+#ifndef CONNECTION_CONNECTION_SETUP_H_
+#define CONNECTION_CONNECTION_SETUP_H_
+
+#include <stdlib.h>
+#include <stdint.h>
+#include <string.h>
+#include <omnetpp.h>
+#include "Connection/connection.h"
+
+class connection_Setup {
+
+    void sendVersionNegotiation();
+    void receiveVersionNegotiation(Version_Negotiation *msg);
+    void sendClientInitial();
+    void receiveClientInitial(Client_Initial *msg);
+    void sendClientCleartext();
+    void receiveClientCleartext(Client_Cleartext *msg);
+    void sendServerStatelessRetry();
+    void receiveServerStatelessRetry(Server_Stateless_Retry *msg);
+    void sendServerCleartext();
+    void receiveServerCleartext(Server_Cleartext *msg);
+
+};
+
+
+#endif /* CONNECTION_CONNECTION_SETUP_H_ */

QUIC/Connection/sockets.cpp

@@ -0,0 +1,20 @@
+/*
+ * socket.c
+ *
+ *  Created on: Nov 27, 2017
+ *      Author: anay
+ */
+
+#include "Connection/sockets.h"
+#include <sockets.h>
+#include "inet/src/inet/transportlayer/contract/udp/UDPSocket.h"
+
+using namespace inet;
+
+define_Socket::define_Socket(int port)
+{
+    UDPSocket udpsocket;
+    udpsocket.bind(port);
+}
+
+

QUIC/Connection/sockets.h

@@ -0,0 +1,19 @@
+/*
+ * sockets.h
+ *
+ *  Created on: Nov 27, 2017
+ *      Author: anay
+ */
+
+#ifndef CONNECTION_SOCKETS_H_
+#define CONNECTION_SOCKETS_H_
+
+#include <netinet/in.h>
+#include "inet/src/inet/transportlayer/contract/udp/UDPSocket.h"
+
+class define_Socket {
+
+    define_Socket(int port);
+};
+
+#endif /* CONNECTION_SOCKETS_H_ */

QUIC/Frames/ack.msg

@@ -0,0 +1,25 @@
+//
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Lesser General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+// 
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU Lesser General Public License for more details.
+// 
+// You should have received a copy of the GNU Lesser General Public License
+// along with this program.  If not, see http://www.gnu.org/licenses/.
+// 
+
+//
+// TODO generated message class
+//
+class Ack {
+    uint8_t type;
+    uint8_t num_Blocks;
+    uint64_t largest_Acknowledged;
+    uint16_t ack_Delay;
+    string ack_Block_Section;
+}

QUIC/Frames/ack_m.cc

@@ -0,0 +1,537 @@
+//
+// Generated file, do not edit! Created by nedtool 5.2 from Frames/ack.msg.
+//
+
+// Disable warnings about unused variables, empty switch stmts, etc:
+#ifdef _MSC_VER
+#  pragma warning(disable:4101)
+#  pragma warning(disable:4065)
+#endif
+
+#if defined(__clang__)
+#  pragma clang diagnostic ignored "-Wshadow"
+#  pragma clang diagnostic ignored "-Wconversion"
+#  pragma clang diagnostic ignored "-Wunused-parameter"
+#  pragma clang diagnostic ignored "-Wc++98-compat"
+#  pragma clang diagnostic ignored "-Wunreachable-code-break"
+#  pragma clang diagnostic ignored "-Wold-style-cast"
+#elif defined(__GNUC__)
+#  pragma GCC diagnostic ignored "-Wshadow"
+#  pragma GCC diagnostic ignored "-Wconversion"
+#  pragma GCC diagnostic ignored "-Wunused-parameter"
+#  pragma GCC diagnostic ignored "-Wold-style-cast"
+#  pragma GCC diagnostic ignored "-Wsuggest-attribute=noreturn"
+#  pragma GCC diagnostic ignored "-Wfloat-conversion"
+#endif
+
+#include <iostream>
+#include <sstream>
+#include "ack_m.h"
+
+namespace omnetpp {
+
+// Template pack/unpack rules. They are declared *after* a1l type-specific pack functions for multiple reasons.
+// They are in the omnetpp namespace, to allow them to be found by argument-dependent lookup via the cCommBuffer argument
+
+// Packing/unpacking an std::vector
+template<typename T, typename A>
+void doParsimPacking(omnetpp::cCommBuffer *buffer, const std::vector<T,A>& v)
+{
+    int n = v.size();
+    doParsimPacking(buffer, n);
+    for (int i = 0; i < n; i++)
+        doParsimPacking(buffer, v[i]);
+}
+
+template<typename T, typename A>
+void doParsimUnpacking(omnetpp::cCommBuffer *buffer, std::vector<T,A>& v)
+{
+    int n;
+    doParsimUnpacking(buffer, n);
+    v.resize(n);
+    for (int i = 0; i < n; i++)
+        doParsimUnpacking(buffer, v[i]);
+}
+
+// Packing/unpacking an std::list
+template<typename T, typename A>
+void doParsimPacking(omnetpp::cCommBuffer *buffer, const std::list<T,A>& l)
+{
+    doParsimPacking(buffer, (int)l.size());
+    for (typename std::list<T,A>::const_iterator it = l.begin(); it != l.end(); ++it)
+        doParsimPacking(buffer, (T&)*it);
+}
+
+template<typename T, typename A>
+void doParsimUnpacking(omnetpp::cCommBuffer *buffer, std::list<T,A>& l)
+{
+    int n;
+    doParsimUnpacking(buffer, n);
+    for (int i=0; i<n; i++) {
+        l.push_back(T());
+        doParsimUnpacking(buffer, l.back());
+    }
+}
+
+// Packing/unpacking an std::set
+template<typename T, typename Tr, typename A>
+void doParsimPacking(omnetpp::cCommBuffer *buffer, const std::set<T,Tr,A>& s)
+{
+    doParsimPacking(buffer, (int)s.size());
+    for (typename std::set<T,Tr,A>::const_iterator it = s.begin(); it != s.end(); ++it)
+        doParsimPacking(buffer, *it);
+}
+
+template<typename T, typename Tr, typename A>
+void doParsimUnpacking(omnetpp::cCommBuffer *buffer, std::set<T,Tr,A>& s)
+{
+    int n;
+    doParsimUnpacking(buffer, n);
+    for (int i=0; i<n; i++) {
+        T x;
+        doParsimUnpacking(buffer, x);
+        s.insert(x);
+    }
+}
+
+// Packing/unpacking an std::map
+template<typename K, typename V, typename Tr, typename A>
+void doParsimPacking(omnetpp::cCommBuffer *buffer, const std::map<K,V,Tr,A>& m)
+{
+    doParsimPacking(buffer, (int)m.size());
+    for (typename std::map<K,V,Tr,A>::const_iterator it = m.begin(); it != m.end(); ++it) {
+        doParsimPacking(buffer, it->first);
+        doParsimPacking(buffer, it->second);
+    }
+}
+
+template<typename K, typename V, typename Tr, typename A>
+void doParsimUnpacking(omnetpp::cCommBuffer *buffer, std::map<K,V,Tr,A>& m)
+{
+    int n;
+    doParsimUnpacking(buffer, n);
+    for (int i=0; i<n; i++) {
+        K k; V v;
+        doParsimUnpacking(buffer, k);
+        doParsimUnpacking(buffer, v);
+        m[k] = v;
+    }
+}
+
+// Default pack/unpack function for arrays
+template<typename T>
+void doParsimArrayPacking(omnetpp::cCommBuffer *b, const T *t, int n)
+{
+    for (int i = 0; i < n; i++)
+        doParsimPacking(b, t[i]);
+}
+
+template<typename T>
+void doParsimArrayUnpacking(omnetpp::cCommBuffer *b, T *t, int n)
+{
+    for (int i = 0; i < n; i++)
+        doParsimUnpacking(b, t[i]);
+}
+
+// Default rule to prevent compiler from choosing base class' doParsimPacking() function
+template<typename T>
+void doParsimPacking(omnetpp::cCommBuffer *, const T& t)
+{
+    throw omnetpp::cRuntimeError("Parsim error: No doParsimPacking() function for type %s", omnetpp::opp_typename(typeid(t)));
+}
+
+template<typename T>
+void doParsimUnpacking(omnetpp::cCommBuffer *, T& t)
+{
+    throw omnetpp::cRuntimeError("Parsim error: No doParsimUnpacking() function for type %s", omnetpp::opp_typename(typeid(t)));
+}
+
+}  // namespace omnetpp
+
+
+// forward
+template<typename T, typename A>
+std::ostream& operator<<(std::ostream& out, const std::vector<T,A>& vec);
+
+// Template rule which fires if a struct or class doesn't have operator<<
+template<typename T>
+inline std::ostream& operator<<(std::ostream& out,const T&) {return out;}
+
+// operator<< for std::vector<T>
+template<typename T, typename A>
+inline std::ostream& operator<<(std::ostream& out, const std::vector<T,A>& vec)
+{
+    out.put('{');
+    for(typename std::vector<T,A>::const_iterator it = vec.begin(); it != vec.end(); ++it)
+    {
+        if (it != vec.begin()) {
+            out.put(','); out.put(' ');
+        }
+        out << *it;
+    }
+    out.put('}');
+    
+    char buf[32];
+    sprintf(buf, " (size=%u)", (unsigned int)vec.size());
+    out.write(buf, strlen(buf));
+    return out;
+}
+
+Register_Class(Ack)
+
+Ack::Ack() : ::omnetpp::cObject()
+{
+    this->type = 0;
+    this->num_Blocks = 0;
+    this->largest_Acknowledged = 0;
+    this->ack_Delay = 0;
+}
+
+Ack::Ack(const Ack& other) : ::omnetpp::cObject(other)
+{
+    copy(other);
+}
+
+Ack::~Ack()
+{
+}
+
+Ack& Ack::operator=(const Ack& other)
+{
+    if (this==&other) return *this;
+    ::omnetpp::cObject::operator=(other);
+    copy(other);
+    return *this;
+}
+
+void Ack::copy(const Ack& other)
+{
+    this->type = other.type;
+    this->num_Blocks = other.num_Blocks;
+    this->largest_Acknowledged = other.largest_Acknowledged;
+    this->ack_Delay = other.ack_Delay;
+    this->ack_Block_Section = other.ack_Block_Section;
+}
+
+void Ack::parsimPack(omnetpp::cCommBuffer *b) const
+{
+    doParsimPacking(b,this->type);
+    doParsimPacking(b,this->num_Blocks);
+    doParsimPacking(b,this->largest_Acknowledged);
+    doParsimPacking(b,this->ack_Delay);
+    doParsimPacking(b,this->ack_Block_Section);
+}
+
+void Ack::parsimUnpack(omnetpp::cCommBuffer *b)
+{
+    doParsimUnpacking(b,this->type);
+    doParsimUnpacking(b,this->num_Blocks);
+    doParsimUnpacking(b,this->largest_Acknowledged);
+    doParsimUnpacking(b,this->ack_Delay);
+    doParsimUnpacking(b,this->ack_Block_Section);
+}
+
+uint8_t Ack::getType() const
+{
+    return this->type;
+}
+
+void Ack::setType(uint8_t type)
+{
+    this->type = type;
+}
+
+uint8_t Ack::getNum_Blocks() const
+{
+    return this->num_Blocks;
+}
+
+void Ack::setNum_Blocks(uint8_t num_Blocks)
+{
+    this->num_Blocks = num_Blocks;
+}
+
+uint64_t Ack::getLargest_Acknowledged() const
+{
+    return this->largest_Acknowledged;
+}
+
+void Ack::setLargest_Acknowledged(uint64_t largest_Acknowledged)
+{
+    this->largest_Acknowledged = largest_Acknowledged;
+}
+
+uint16_t Ack::getAck_Delay() const
+{
+    return this->ack_Delay;
+}
+
+void Ack::setAck_Delay(uint16_t ack_Delay)
+{
+    this->ack_Delay = ack_Delay;
+}
+
+const char * Ack::getAck_Block_Section() const
+{
+    return this->ack_Block_Section.c_str();
+}
+
+void Ack::setAck_Block_Section(const char * ack_Block_Section)
+{
+    this->ack_Block_Section = ack_Block_Section;
+}
+
+class AckDescriptor : public omnetpp::cClassDescriptor
+{
+  private:
+    mutable const char **propertynames;
+  public:
+    AckDescriptor();
+    virtual ~AckDescriptor();
+
+    virtual bool doesSupport(omnetpp::cObject *obj) const override;
+    virtual const char **getPropertyNames() const override;
+    virtual const char *getProperty(const char *propertyname) const override;
+    virtual int getFieldCount() const override;
+    virtual const char *getFieldName(int field) const override;
+    virtual int findField(const char *fieldName) const override;
+    virtual unsigned int getFieldTypeFlags(int field) const override;
+    virtual const char *getFieldTypeString(int field) const override;
+    virtual const char **getFieldPropertyNames(int field) const override;
+    virtual const char *getFieldProperty(int field, const char *propertyname) const override;
+    virtual int getFieldArraySize(void *object, int field) const override;
+
+    virtual const char *getFieldDynamicTypeString(void *object, int field, int i) const override;
+    virtual std::string getFieldValueAsString(void *object, int field, int i) const override;
+    virtual bool setFieldValueAsString(void *object, int field, int i, const char *value) const override;
+
+    virtual const char *getFieldStructName(int field) const override;
+    virtual void *getFieldStructValuePointer(void *object, int field, int i) const override;
+};
+
+Register_ClassDescriptor(AckDescriptor)
+
+AckDescriptor::AckDescriptor() : omnetpp::cClassDescriptor("Ack", "omnetpp::cObject")
+{
+    propertynames = nullptr;
+}
+
+AckDescriptor::~AckDescriptor()
+{
+    delete[] propertynames;
+}
+
+bool AckDescriptor::doesSupport(omnetpp::cObject *obj) const
+{
+    return dynamic_cast<Ack *>(obj)!=nullptr;
+}
+
+const char **AckDescriptor::getPropertyNames() const
+{
+    if (!propertynames) {
+        static const char *names[] = {  nullptr };
+        omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
+        const char **basenames = basedesc ? basedesc->getPropertyNames() : nullptr;
+        propertynames = mergeLists(basenames, names);
+    }
+    return propertynames;
+}
+
+const char *AckDescriptor::getProperty(const char *propertyname) const
+{
+    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
+    return basedesc ? basedesc->getProperty(propertyname) : nullptr;
+}
+
+int AckDescriptor::getFieldCount() const
+{
+    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
+    return basedesc ? 5+basedesc->getFieldCount() : 5;
+}
+
+unsigned int AckDescriptor::getFieldTypeFlags(int field) const
+{
+    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
+    if (basedesc) {
+        if (field < basedesc->getFieldCount())
+            return basedesc->getFieldTypeFlags(field);
+        field -= basedesc->getFieldCount();
+    }
+    static unsigned int fieldTypeFlags[] = {
+        FD_ISEDITABLE,
+        FD_ISEDITABLE,
+        FD_ISEDITABLE,
+        FD_ISEDITABLE,
+        FD_ISEDITABLE,
+    };
+    return (field>=0 && field<5) ? fieldTypeFlags[field] : 0;
+}
+
+const char *AckDescriptor::getFieldName(int field) const
+{
+    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
+    if (basedesc) {
+        if (field < basedesc->getFieldCount())
+            return basedesc->getFieldName(field);
+        field -= basedesc->getFieldCount();
+    }
+    static const char *fieldNames[] = {
+        "type",
+        "num_Blocks",
+        "largest_Acknowledged",
+        "ack_Delay",
+        "ack_Block_Section",
+    };
+    return (field>=0 && field<5) ? fieldNames[field] : nullptr;
+}
+
+int AckDescriptor::findField(const char *fieldName) const
+{
+    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
+    int base = basedesc ? basedesc->getFieldCount() : 0;
+    if (fieldName[0]=='t' && strcmp(fieldName, "type")==0) return base+0;
+    if (fieldName[0]=='n' && strcmp(fieldName, "num_Blocks")==0) return base+1;
+    if (fieldName[0]=='l' && strcmp(fieldName, "largest_Acknowledged")==0) return base+2;
+    if (fieldName[0]=='a' && strcmp(fieldName, "ack_Delay")==0) return base+3;
+    if (fieldName[0]=='a' && strcmp(fieldName, "ack_Block_Section")==0) return base+4;
+    return basedesc ? basedesc->findField(fieldName) : -1;
+}
+
+const char *AckDescriptor::getFieldTypeString(int field) const
+{
+    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
+    if (basedesc) {
+        if (field < basedesc->getFieldCount())
+            return basedesc->getFieldTypeString(field);
+        field -= basedesc->getFieldCount();
+    }
+    static const char *fieldTypeStrings[] = {
+        "uint8_t",
+        "uint8_t",
+        "uint64_t",
+        "uint16_t",
+        "string",
+    };
+    return (field>=0 && field<5) ? fieldTypeStrings[field] : nullptr;
+}
+
+const char **AckDescriptor::getFieldPropertyNames(int field) const
+{
+    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
+    if (basedesc) {
+        if (field < basedesc->getFieldCount())
+            return basedesc->getFieldPropertyNames(field);
+        field -= basedesc->getFieldCount();
+    }
+    switch (field) {
+        default: return nullptr;
+    }
+}
+
+const char *AckDescriptor::getFieldProperty(int field, const char *propertyname) const
+{
+    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
+    if (basedesc) {
+        if (field < basedesc->getFieldCount())
+            return basedesc->getFieldProperty(field, propertyname);
+        field -= basedesc->getFieldCount();
+    }
+    switch (field) {
+        default: return nullptr;
+    }
+}
+
+int AckDescriptor::getFieldArraySize(void *object, int field) const
+{
+    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
+    if (basedesc) {
+        if (field < basedesc->getFieldCount())
+            return basedesc->getFieldArraySize(object, field);
+        field -= basedesc->getFieldCount();
+    }
+    Ack *pp = (Ack *)object; (void)pp;
+    switch (field) {
+        default: return 0;
+    }
+}
+
+const char *AckDescriptor::getFieldDynamicTypeString(void *object, int field, int i) const
+{
+    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
+    if (basedesc) {
+        if (field < basedesc->getFieldCount())
+            return basedesc->getFieldDynamicTypeString(object,field,i);
+        field -= basedesc->getFieldCount();
+    }
+    Ack *pp = (Ack *)object; (void)pp;
+    switch (field) {
+        default: return nullptr;
+    }
+}
+
+std::string AckDescriptor::getFieldValueAsString(void *object, int field, int i) const
+{
+    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
+    if (basedesc) {
+        if (field < basedesc->getFieldCount())
+            return basedesc->getFieldValueAsString(object,field,i);
+        field -= basedesc->getFieldCount();
+    }
+    Ack *pp = (Ack *)object; (void)pp;
+    switch (field) {
+        case 0: return ulong2string(pp->getType());
+        case 1: return ulong2string(pp->getNum_Blocks());
+        case 2: return uint642string(pp->getLargest_Acknowledged());
+        case 3: return ulong2string(pp->getAck_Delay());
+        case 4: return oppstring2string(pp->getAck_Block_Section());
+        default: return "";
+    }
+}
+
+bool AckDescriptor::setFieldValueAsString(void *object, int field, int i, const char *value) const
+{
+    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
+    if (basedesc) {
+        if (field < basedesc->getFieldCount())
+            return basedesc->setFieldValueAsString(object,field,i,value);
+        field -= basedesc->getFieldCount();
+    }
+    Ack *pp = (Ack *)object; (void)pp;
+    switch (field) {
+        case 0: pp->setType(string2ulong(value)); return true;
+        case 1: pp->setNum_Blocks(string2ulong(value)); return true;
+        case 2: pp->setLargest_Acknowledged(string2uint64(value)); return true;
+        case 3: pp->setAck_Delay(string2ulong(value)); return true;
+        case 4: pp->setAck_Block_Section((value)); return true;
+        default: return false;
+    }
+}
+
+const char *AckDescriptor::getFieldStructName(int field) const
+{
+    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
+    if (basedesc) {
+        if (field < basedesc->getFieldCount())
+            return basedesc->getFieldStructName(field);
+        field -= basedesc->getFieldCount();
+    }
+    switch (field) {
+        default: return nullptr;
+    };
+}
+
+void *AckDescriptor::getFieldStructValuePointer(void *object, int field, int i) const
+{
+    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
+    if (basedesc) {
+        if (field < basedesc->getFieldCount())
+            return basedesc->getFieldStructValuePointer(object, field, i);
+        field -= basedesc->getFieldCount();
+    }
+    Ack *pp = (Ack *)object; (void)pp;
+    switch (field) {
+        default: return nullptr;
+    }
+}
+
+

QUIC/Frames/ack_m.h

@@ -0,0 +1,80 @@
+//
+// Generated file, do not edit! Created by nedtool 5.2 from Frames/ack.msg.
+//
+
+#if defined(__clang__)
+#  pragma clang diagnostic ignored "-Wreserved-id-macro"
+#endif
+#ifndef __ACK_M_H
+#define __ACK_M_H
+
+#include <omnetpp.h>
+
+// nedtool version check
+#define MSGC_VERSION 0x0502
+#if (MSGC_VERSION!=OMNETPP_VERSION)
+#    error Version mismatch! Probably this file was generated by an earlier version of nedtool: 'make clean' should help.
+#endif
+
+
+
+/**
+ * Class generated from <tt>Frames/ack.msg:19</tt> by nedtool.
+ * <pre>
+ * //
+ * // TODO generated message class
+ * //
+ * class Ack
+ * {
+ *     uint8_t type;
+ *     uint8_t num_Blocks;
+ *     uint64_t largest_Acknowledged;
+ *     uint16_t ack_Delay;
+ *     string ack_Block_Section;
+ * }
+ * </pre>
+ */
+class Ack : public ::omnetpp::cObject
+{
+  protected:
+    uint8_t type;
+    uint8_t num_Blocks;
+    uint64_t largest_Acknowledged;
+    uint16_t ack_Delay;
+    ::omnetpp::opp_string ack_Block_Section;
+
+  private:
+    void copy(const Ack& other);
+
+  protected:
+    // protected and unimplemented operator==(), to prevent accidental usage
+    bool operator==(const Ack&);
+
+  public:
+    Ack();
+    Ack(const Ack& other);
+    virtual ~Ack();
+    Ack& operator=(const Ack& other);
+    virtual Ack *dup() const override {return new Ack(*this);}
+    virtual void parsimPack(omnetpp::cCommBuffer *b) const override;
+    virtual void parsimUnpack(omnetpp::cCommBuffer *b) override;
+
+    // field getter/setter methods
+    virtual uint8_t getType() const;
+    virtual void setType(uint8_t type);
+    virtual uint8_t getNum_Blocks() const;
+    virtual void setNum_Blocks(uint8_t num_Blocks);
+    virtual uint64_t getLargest_Acknowledged() const;
+    virtual void setLargest_Acknowledged(uint64_t largest_Acknowledged);
+    virtual uint16_t getAck_Delay() const;
+    virtual void setAck_Delay(uint16_t ack_Delay);
+    virtual const char * getAck_Block_Section() const;
+    virtual void setAck_Block_Section(const char * ack_Block_Section);
+};
+
+inline void doParsimPacking(omnetpp::cCommBuffer *b, const Ack& obj) {obj.parsimPack(b);}
+inline void doParsimUnpacking(omnetpp::cCommBuffer *b, Ack& obj) {obj.parsimUnpack(b);}
+
+
+#endif // ifndef __ACK_M_H
+

QUIC/Frames/application_Close.msg

@@ -0,0 +1,24 @@
+//
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Lesser General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+// 
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU Lesser General Public License for more details.
+// 
+// You should have received a copy of the GNU Lesser General Public License
+// along with this program.  If not, see http://www.gnu.org/licenses/.
+// 
+
+//
+// TODO generated message class
+//
+class Application_Close {
+    uint8_t type = 3;
+    uint16_t error_Code;
+    uint16_t reason_Phrase_Length;
+    string reason_Phrase;
+}

QUIC/Frames/application_Close_m.cc

@@ -0,0 +1,517 @@
+//
+// Generated file, do not edit! Created by nedtool 5.2 from Frames/application_Close.msg.
+//
+
+// Disable warnings about unused variables, empty switch stmts, etc:
+#ifdef _MSC_VER
+#  pragma warning(disable:4101)
+#  pragma warning(disable:4065)
+#endif
+
+#if defined(__clang__)
+#  pragma clang diagnostic ignored "-Wshadow"
+#  pragma clang diagnostic ignored "-Wconversion"
+#  pragma clang diagnostic ignored "-Wunused-parameter"
+#  pragma clang diagnostic ignored "-Wc++98-compat"
+#  pragma clang diagnostic ignored "-Wunreachable-code-break"
+#  pragma clang diagnostic ignored "-Wold-style-cast"
+#elif defined(__GNUC__)
+#  pragma GCC diagnostic ignored "-Wshadow"
+#  pragma GCC diagnostic ignored "-Wconversion"
+#  pragma GCC diagnostic ignored "-Wunused-parameter"
+#  pragma GCC diagnostic ignored "-Wold-style-cast"
+#  pragma GCC diagnostic ignored "-Wsuggest-attribute=noreturn"
+#  pragma GCC diagnostic ignored "-Wfloat-conversion"
+#endif
+
+#include <iostream>
+#include <sstream>
+#include "application_Close_m.h"
+
+namespace omnetpp {
+
+// Template pack/unpack rules. They are declared *after* a1l type-specific pack functions for multiple reasons.
+// They are in the omnetpp namespace, to allow them to be found by argument-dependent lookup via the cCommBuffer argument
+
+// Packing/unpacking an std::vector
+template<typename T, typename A>
+void doParsimPacking(omnetpp::cCommBuffer *buffer, const std::vector<T,A>& v)
+{
+    int n = v.size();
+    doParsimPacking(buffer, n);
+    for (int i = 0; i < n; i++)
+        doParsimPacking(buffer, v[i]);
+}
+
+template<typename T, typename A>
+void doParsimUnpacking(omnetpp::cCommBuffer *buffer, std::vector<T,A>& v)
+{
+    int n;
+    doParsimUnpacking(buffer, n);
+    v.resize(n);
+    for (int i = 0; i < n; i++)
+        doParsimUnpacking(buffer, v[i]);
+}
+
+// Packing/unpacking an std::list
+template<typename T, typename A>
+void doParsimPacking(omnetpp::cCommBuffer *buffer, const std::list<T,A>& l)
+{
+    doParsimPacking(buffer, (int)l.size());
+    for (typename std::list<T,A>::const_iterator it = l.begin(); it != l.end(); ++it)
+        doParsimPacking(buffer, (T&)*it);
+}
+
+template<typename T, typename A>
+void doParsimUnpacking(omnetpp::cCommBuffer *buffer, std::list<T,A>& l)
+{
+    int n;
+    doParsimUnpacking(buffer, n);
+    for (int i=0; i<n; i++) {
+        l.push_back(T());
+        doParsimUnpacking(buffer, l.back());
+    }
+}
+
+// Packing/unpacking an std::set
+template<typename T, typename Tr, typename A>
+void doParsimPacking(omnetpp::cCommBuffer *buffer, const std::set<T,Tr,A>& s)
+{
+    doParsimPacking(buffer, (int)s.size());
+    for (typename std::set<T,Tr,A>::const_iterator it = s.begin(); it != s.end(); ++it)
+        doParsimPacking(buffer, *it);
+}
+
+template<typename T, typename Tr, typename A>
+void doParsimUnpacking(omnetpp::cCommBuffer *buffer, std::set<T,Tr,A>& s)
+{
+    int n;
+    doParsimUnpacking(buffer, n);
+    for (int i=0; i<n; i++) {
+        T x;
+        doParsimUnpacking(buffer, x);
+        s.insert(x);
+    }
+}
+
+// Packing/unpacking an std::map
+template<typename K, typename V, typename Tr, typename A>
+void doParsimPacking(omnetpp::cCommBuffer *buffer, const std::map<K,V,Tr,A>& m)
+{
+    doParsimPacking(buffer, (int)m.size());
+    for (typename std::map<K,V,Tr,A>::const_iterator it = m.begin(); it != m.end(); ++it) {
+        doParsimPacking(buffer, it->first);
+        doParsimPacking(buffer, it->second);
+    }
+}
+
+template<typename K, typename V, typename Tr, typename A>
+void doParsimUnpacking(omnetpp::cCommBuffer *buffer, std::map<K,V,Tr,A>& m)
+{
+    int n;
+    doParsimUnpacking(buffer, n);
+    for (int i=0; i<n; i++) {
+        K k; V v;
+        doParsimUnpacking(buffer, k);
+        doParsimUnpacking(buffer, v);
+        m[k] = v;
+    }
+}
+
+// Default pack/unpack function for arrays
+template<typename T>
+void doParsimArrayPacking(omnetpp::cCommBuffer *b, const T *t, int n)
+{
+    for (int i = 0; i < n; i++)
+        doParsimPacking(b, t[i]);
+}
+
+template<typename T>
+void doParsimArrayUnpacking(omnetpp::cCommBuffer *b, T *t, int n)
+{
+    for (int i = 0; i < n; i++)
+        doParsimUnpacking(b, t[i]);
+}
+
+// Default rule to prevent compiler from choosing base class' doParsimPacking() function
+template<typename T>
+void doParsimPacking(omnetpp::cCommBuffer *, const T& t)
+{
+    throw omnetpp::cRuntimeError("Parsim error: No doParsimPacking() function for type %s", omnetpp::opp_typename(typeid(t)));
+}
+
+template<typename T>
+void doParsimUnpacking(omnetpp::cCommBuffer *, T& t)
+{
+    throw omnetpp::cRuntimeError("Parsim error: No doParsimUnpacking() function for type %s", omnetpp::opp_typename(typeid(t)));
+}
+
+}  // namespace omnetpp
+
+
+// forward
+template<typename T, typename A>
+std::ostream& operator<<(std::ostream& out, const std::vector<T,A>& vec);
+
+// Template rule which fires if a struct or class doesn't have operator<<
+template<typename T>
+inline std::ostream& operator<<(std::ostream& out,const T&) {return out;}
+
+// operator<< for std::vector<T>
+template<typename T, typename A>
+inline std::ostream& operator<<(std::ostream& out, const std::vector<T,A>& vec)
+{
+    out.put('{');
+    for(typename std::vector<T,A>::const_iterator it = vec.begin(); it != vec.end(); ++it)
+    {
+        if (it != vec.begin()) {
+            out.put(','); out.put(' ');
+        }
+        out << *it;
+    }
+    out.put('}');
+    
+    char buf[32];
+    sprintf(buf, " (size=%u)", (unsigned int)vec.size());
+    out.write(buf, strlen(buf));
+    return out;
+}
+
+Register_Class(Application_Close)
+
+Application_Close::Application_Close() : ::omnetpp::cObject()
+{
+    this->type = 3;
+    this->error_Code = 0;
+    this->reason_Phrase_Length = 0;
+}
+
+Application_Close::Application_Close(const Application_Close& other) : ::omnetpp::cObject(other)
+{
+    copy(other);
+}
+
+Application_Close::~Application_Close()
+{
+}
+
+Application_Close& Application_Close::operator=(const Application_Close& other)
+{
+    if (this==&other) return *this;
+    ::omnetpp::cObject::operator=(other);
+    copy(other);
+    return *this;
+}
+
+void Application_Close::copy(const Application_Close& other)
+{
+    this->type = other.type;
+    this->error_Code = other.error_Code;
+    this->reason_Phrase_Length = other.reason_Phrase_Length;
+    this->reason_Phrase = other.reason_Phrase;
+}
+
+void Application_Close::parsimPack(omnetpp::cCommBuffer *b) const
+{
+    doParsimPacking(b,this->type);
+    doParsimPacking(b,this->error_Code);
+    doParsimPacking(b,this->reason_Phrase_Length);
+    doParsimPacking(b,this->reason_Phrase);
+}
+
+void Application_Close::parsimUnpack(omnetpp::cCommBuffer *b)
+{
+    doParsimUnpacking(b,this->type);
+    doParsimUnpacking(b,this->error_Code);
+    doParsimUnpacking(b,this->reason_Phrase_Length);
+    doParsimUnpacking(b,this->reason_Phrase);
+}
+
+uint8_t Application_Close::getType() const
+{
+    return this->type;
+}
+
+void Application_Close::setType(uint8_t type)
+{
+    this->type = type;
+}
+
+uint16_t Application_Close::getError_Code() const
+{
+    return this->error_Code;
+}
+
+void Application_Close::setError_Code(uint16_t error_Code)
+{
+    this->error_Code = error_Code;
+}
+
+uint16_t Application_Close::getReason_Phrase_Length() const
+{
+    return this->reason_Phrase_Length;
+}
+
+void Application_Close::setReason_Phrase_Length(uint16_t reason_Phrase_Length)
+{
+    this->reason_Phrase_Length = reason_Phrase_Length;
+}
+
+const char * Application_Close::getReason_Phrase() const
+{
+    return this->reason_Phrase.c_str();
+}
+
+void Application_Close::setReason_Phrase(const char * reason_Phrase)
+{
+    this->reason_Phrase = reason_Phrase;
+}
+
+class Application_CloseDescriptor : public omnetpp::cClassDescriptor
+{
+  private:
+    mutable const char **propertynames;
+  public:
+    Application_CloseDescriptor();
+    virtual ~Application_CloseDescriptor();
+
+    virtual bool doesSupport(omnetpp::cObject *obj) const override;
+    virtual const char **getPropertyNames() const override;
+    virtual const char *getProperty(const char *propertyname) const override;
+    virtual int getFieldCount() const override;
+    virtual const char *getFieldName(int field) const override;
+    virtual int findField(const char *fieldName) const override;
+    virtual unsigned int getFieldTypeFlags(int field) const override;
+    virtual const char *getFieldTypeString(int field) const override;
+    virtual const char **getFieldPropertyNames(int field) const override;
+    virtual const char *getFieldProperty(int field, const char *propertyname) const override;
+    virtual int getFieldArraySize(void *object, int field) const override;
+
+    virtual const char *getFieldDynamicTypeString(void *object, int field, int i) const override;
+    virtual std::string getFieldValueAsString(void *object, int field, int i) const override;
+    virtual bool setFieldValueAsString(void *object, int field, int i, const char *value) const override;
+
+    virtual const char *getFieldStructName(int field) const override;
+    virtual void *getFieldStructValuePointer(void *object, int field, int i) const override;
+};
+
+Register_ClassDescriptor(Application_CloseDescriptor)
+
+Application_CloseDescriptor::Application_CloseDescriptor() : omnetpp::cClassDescriptor("Application_Close", "omnetpp::cObject")
+{
+    propertynames = nullptr;
+}
+
+Application_CloseDescriptor::~Application_CloseDescriptor()
+{
+    delete[] propertynames;
+}
+
+bool Application_CloseDescriptor::doesSupport(omnetpp::cObject *obj) const
+{
+    return dynamic_cast<Application_Close *>(obj)!=nullptr;
+}
+
+const char **Application_CloseDescriptor::getPropertyNames() const
+{
+    if (!propertynames) {
+        static const char *names[] = {  nullptr };
+        omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
+        const char **basenames = basedesc ? basedesc->getPropertyNames() : nullptr;
+        propertynames = mergeLists(basenames, names);
+    }
+    return propertynames;
+}
+
+const char *Application_CloseDescriptor::getProperty(const char *propertyname) const
+{
+    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
+    return basedesc ? basedesc->getProperty(propertyname) : nullptr;
+}
+
+int Application_CloseDescriptor::getFieldCount() const
+{
+    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
+    return basedesc ? 4+basedesc->getFieldCount() : 4;
+}
+
+unsigned int Application_CloseDescriptor::getFieldTypeFlags(int field) const
+{
+    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
+    if (basedesc) {
+        if (field < basedesc->getFieldCount())
+            return basedesc->getFieldTypeFlags(field);
+        field -= basedesc->getFieldCount();
+    }
+    static unsigned int fieldTypeFlags[] = {
+        FD_ISEDITABLE,
+        FD_ISEDITABLE,
+        FD_ISEDITABLE,
+        FD_ISEDITABLE,
+    };
+    return (field>=0 && field<4) ? fieldTypeFlags[field] : 0;
+}
+
+const char *Application_CloseDescriptor::getFieldName(int field) const
+{
+    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
+    if (basedesc) {
+        if (field < basedesc->getFieldCount())
+            return basedesc->getFieldName(field);
+        field -= basedesc->getFieldCount();
+    }
+    static const char *fieldNames[] = {
+        "type",
+        "error_Code",
+        "reason_Phrase_Length",
+        "reason_Phrase",
+    };
+    return (field>=0 && field<4) ? fieldNames[field] : nullptr;
+}
+
+int Application_CloseDescriptor::findField(const char *fieldName) const
+{
+    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
+    int base = basedesc ? basedesc->getFieldCount() : 0;
+    if (fieldName[0]=='t' && strcmp(fieldName, "type")==0) return base+0;
+    if (fieldName[0]=='e' && strcmp(fieldName, "error_Code")==0) return base+1;
+    if (fieldName[0]=='r' && strcmp(fieldName, "reason_Phrase_Length")==0) return base+2;
+    if (fieldName[0]=='r' && strcmp(fieldName, "reason_Phrase")==0) return base+3;
+    return basedesc ? basedesc->findField(fieldName) : -1;
+}
+
+const char *Application_CloseDescriptor::getFieldTypeString(int field) const
+{
+    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
+    if (basedesc) {
+        if (field < basedesc->getFieldCount())
+            return basedesc->getFieldTypeString(field);
+        field -= basedesc->getFieldCount();
+    }
+    static const char *fieldTypeStrings[] = {
+        "uint8_t",
+        "uint16_t",
+        "uint16_t",
+        "string",
+    };
+    return (field>=0 && field<4) ? fieldTypeStrings[field] : nullptr;
+}
+
+const char **Application_CloseDescriptor::getFieldPropertyNames(int field) const
+{
+    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
+    if (basedesc) {
+        if (field < basedesc->getFieldCount())
+            return basedesc->getFieldPropertyNames(field);
+        field -= basedesc->getFieldCount();
+    }
+    switch (field) {
+        default: return nullptr;
+    }
+}
+
+const char *Application_CloseDescriptor::getFieldProperty(int field, const char *propertyname) const
+{
+    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
+    if (basedesc) {
+        if (field < basedesc->getFieldCount())
+            return basedesc->getFieldProperty(field, propertyname);
+        field -= basedesc->getFieldCount();
+    }
+    switch (field) {
+        default: return nullptr;
+    }
+}
+
+int Application_CloseDescriptor::getFieldArraySize(void *object, int field) const
+{
+    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
+    if (basedesc) {
+        if (field < basedesc->getFieldCount())
+            return basedesc->getFieldArraySize(object, field);
+        field -= basedesc->getFieldCount();
+    }
+    Application_Close *pp = (Application_Close *)object; (void)pp;
+    switch (field) {
+        default: return 0;
+    }
+}
+
+const char *Application_CloseDescriptor::getFieldDynamicTypeString(void *object, int field, int i) const
+{
+    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
+    if (basedesc) {
+        if (field < basedesc->getFieldCount())
+            return basedesc->getFieldDynamicTypeString(object,field,i);
+        field -= basedesc->getFieldCount();
+    }
+    Application_Close *pp = (Application_Close *)object; (void)pp;
+    switch (field) {
+        default: return nullptr;
+    }
+}
+
+std::string Application_CloseDescriptor::getFieldValueAsString(void *object, int field, int i) const
+{
+    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
+    if (basedesc) {
+        if (field < basedesc->getFieldCount())
+            return basedesc->getFieldValueAsString(object,field,i);
+        field -= basedesc->getFieldCount();
+    }
+    Application_Close *pp = (Application_Close *)object; (void)pp;
+    switch (field) {
+        case 0: return ulong2string(pp->getType());
+        case 1: return ulong2string(pp->getError_Code());
+        case 2: return ulong2string(pp->getReason_Phrase_Length());
+        case 3: return oppstring2string(pp->getReason_Phrase());
+        default: return "";
+    }
+}
+
+bool Application_CloseDescriptor::setFieldValueAsString(void *object, int field, int i, const char *value) const
+{
+    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
+    if (basedesc) {
+        if (field < basedesc->getFieldCount())
+            return basedesc->setFieldValueAsString(object,field,i,value);
+        field -= basedesc->getFieldCount();
+    }
+    Application_Close *pp = (Application_Close *)object; (void)pp;
+    switch (field) {
+        case 0: pp->setType(string2ulong(value)); return true;
+        case 1: pp->setError_Code(string2ulong(value)); return true;
+        case 2: pp->setReason_Phrase_Length(string2ulong(value)); return true;
+        case 3: pp->setReason_Phrase((value)); return true;
+        default: return false;
+    }
+}
+
+const char *Application_CloseDescriptor::getFieldStructName(int field) const
+{
+    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
+    if (basedesc) {
+        if (field < basedesc->getFieldCount())
+            return basedesc->getFieldStructName(field);
+        field -= basedesc->getFieldCount();
+    }
+    switch (field) {
+        default: return nullptr;
+    };
+}
+
+void *Application_CloseDescriptor::getFieldStructValuePointer(void *object, int field, int i) const
+{
+    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
+    if (basedesc) {
+        if (field < basedesc->getFieldCount())
+            return basedesc->getFieldStructValuePointer(object, field, i);
+        field -= basedesc->getFieldCount();
+    }
+    Application_Close *pp = (Application_Close *)object; (void)pp;
+    switch (field) {
+        default: return nullptr;
+    }
+}
+
+

QUIC/Frames/application_Close_m.h

@@ -0,0 +1,76 @@
+//
+// Generated file, do not edit! Created by nedtool 5.2 from Frames/application_Close.msg.
+//
+
+#if defined(__clang__)
+#  pragma clang diagnostic ignored "-Wreserved-id-macro"
+#endif
+#ifndef __APPLICATION_CLOSE_M_H
+#define __APPLICATION_CLOSE_M_H
+
+#include <omnetpp.h>
+
+// nedtool version check
+#define MSGC_VERSION 0x0502
+#if (MSGC_VERSION!=OMNETPP_VERSION)
+#    error Version mismatch! Probably this file was generated by an earlier version of nedtool: 'make clean' should help.
+#endif
+
+
+
+/**
+ * Class generated from <tt>Frames/application_Close.msg:19</tt> by nedtool.
+ * <pre>
+ * //
+ * // TODO generated message class
+ * //
+ * class Application_Close
+ * {
+ *     uint8_t type = 3;
+ *     uint16_t error_Code;
+ *     uint16_t reason_Phrase_Length;
+ *     string reason_Phrase;
+ * }
+ * </pre>
+ */
+class Application_Close : public ::omnetpp::cObject
+{
+  protected:
+    uint8_t type;
+    uint16_t error_Code;
+    uint16_t reason_Phrase_Length;
+    ::omnetpp::opp_string reason_Phrase;
+
+  private:
+    void copy(const Application_Close& other);
+
+  protected:
+    // protected and unimplemented operator==(), to prevent accidental usage
+    bool operator==(const Application_Close&);
+
+  public:
+    Application_Close();
+    Application_Close(const Application_Close& other);
+    virtual ~Application_Close();
+    Application_Close& operator=(const Application_Close& other);
+    virtual Application_Close *dup() const override {return new Application_Close(*this);}
+    virtual void parsimPack(omnetpp::cCommBuffer *b) const override;
+    virtual void parsimUnpack(omnetpp::cCommBuffer *b) override;
+
+    // field getter/setter methods
+    virtual uint8_t getType() const;
+    virtual void setType(uint8_t type);
+    virtual uint16_t getError_Code() const;
+    virtual void setError_Code(uint16_t error_Code);
+    virtual uint16_t getReason_Phrase_Length() const;
+    virtual void setReason_Phrase_Length(uint16_t reason_Phrase_Length);
+    virtual const char * getReason_Phrase() const;
+    virtual void setReason_Phrase(const char * reason_Phrase);
+};
+
+inline void doParsimPacking(omnetpp::cCommBuffer *b, const Application_Close& obj) {obj.parsimPack(b);}
+inline void doParsimUnpacking(omnetpp::cCommBuffer *b, Application_Close& obj) {obj.parsimUnpack(b);}
+
+
+#endif // ifndef __APPLICATION_CLOSE_M_H
+

QUIC/Frames/blocked.msg

@@ -0,0 +1,22 @@
+//
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Lesser General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+// 
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU Lesser General Public License for more details.
+// 
+// You should have received a copy of the GNU Lesser General Public License
+// along with this program.  If not, see http://www.gnu.org/licenses/.
+// 
+
+//
+// TODO generated message class
+//
+class Blocked {
+	uint8_t type = 8;
+}
+	

QUIC/Frames/blocked_m.cc

@@ -0,0 +1,458 @@
+//
+// Generated file, do not edit! Created by nedtool 5.2 from Frames/blocked.msg.
+//
+
+// Disable warnings about unused variables, empty switch stmts, etc:
+#ifdef _MSC_VER
+#  pragma warning(disable:4101)
+#  pragma warning(disable:4065)
+#endif
+
+#if defined(__clang__)
+#  pragma clang diagnostic ignored "-Wshadow"
+#  pragma clang diagnostic ignored "-Wconversion"
+#  pragma clang diagnostic ignored "-Wunused-parameter"
+#  pragma clang diagnostic ignored "-Wc++98-compat"
+#  pragma clang diagnostic ignored "-Wunreachable-code-break"
+#  pragma clang diagnostic ignored "-Wold-style-cast"
+#elif defined(__GNUC__)
+#  pragma GCC diagnostic ignored "-Wshadow"
+#  pragma GCC diagnostic ignored "-Wconversion"
+#  pragma GCC diagnostic ignored "-Wunused-parameter"
+#  pragma GCC diagnostic ignored "-Wold-style-cast"
+#  pragma GCC diagnostic ignored "-Wsuggest-attribute=noreturn"
+#  pragma GCC diagnostic ignored "-Wfloat-conversion"
+#endif
+
+#include <iostream>
+#include <sstream>
+#include "blocked_m.h"
+
+namespace omnetpp {
+
+// Template pack/unpack rules. They are declared *after* a1l type-specific pack functions for multiple reasons.
+// They are in the omnetpp namespace, to allow them to be found by argument-dependent lookup via the cCommBuffer argument
+
+// Packing/unpacking an std::vector
+template<typename T, typename A>
+void doParsimPacking(omnetpp::cCommBuffer *buffer, const std::vector<T,A>& v)
+{
+    int n = v.size();
+    doParsimPacking(buffer, n);
+    for (int i = 0; i < n; i++)
+        doParsimPacking(buffer, v[i]);
+}
+
+template<typename T, typename A>
+void doParsimUnpacking(omnetpp::cCommBuffer *buffer, std::vector<T,A>& v)
+{
+    int n;
+    doParsimUnpacking(buffer, n);
+    v.resize(n);
+    for (int i = 0; i < n; i++)
+        doParsimUnpacking(buffer, v[i]);
+}
+
+// Packing/unpacking an std::list
+template<typename T, typename A>
+void doParsimPacking(omnetpp::cCommBuffer *buffer, const std::list<T,A>& l)
+{
+    doParsimPacking(buffer, (int)l.size());
+    for (typename std::list<T,A>::const_iterator it = l.begin(); it != l.end(); ++it)
+        doParsimPacking(buffer, (T&)*it);
+}
+
+template<typename T, typename A>
+void doParsimUnpacking(omnetpp::cCommBuffer *buffer, std::list<T,A>& l)
+{
+    int n;
+    doParsimUnpacking(buffer, n);
+    for (int i=0; i<n; i++) {
+        l.push_back(T());
+        doParsimUnpacking(buffer, l.back());
+    }
+}
+
+// Packing/unpacking an std::set
+template<typename T, typename Tr, typename A>
+void doParsimPacking(omnetpp::cCommBuffer *buffer, const std::set<T,Tr,A>& s)
+{
+    doParsimPacking(buffer, (int)s.size());
+    for (typename std::set<T,Tr,A>::const_iterator it = s.begin(); it != s.end(); ++it)
+        doParsimPacking(buffer, *it);
+}
+
+template<typename T, typename Tr, typename A>
+void doParsimUnpacking(omnetpp::cCommBuffer *buffer, std::set<T,Tr,A>& s)
+{
+    int n;
+    doParsimUnpacking(buffer, n);
+    for (int i=0; i<n; i++) {
+        T x;
+        doParsimUnpacking(buffer, x);
+        s.insert(x);
+    }
+}
+
+// Packing/unpacking an std::map
+template<typename K, typename V, typename Tr, typename A>
+void doParsimPacking(omnetpp::cCommBuffer *buffer, const std::map<K,V,Tr,A>& m)
+{
+    doParsimPacking(buffer, (int)m.size());
+    for (typename std::map<K,V,Tr,A>::const_iterator it = m.begin(); it != m.end(); ++it) {
+        doParsimPacking(buffer, it->first);
+        doParsimPacking(buffer, it->second);
+    }
+}
+
+template<typename K, typename V, typename Tr, typename A>
+void doParsimUnpacking(omnetpp::cCommBuffer *buffer, std::map<K,V,Tr,A>& m)
+{
+    int n;
+    doParsimUnpacking(buffer, n);
+    for (int i=0; i<n; i++) {
+        K k; V v;
+        doParsimUnpacking(buffer, k);
+        doParsimUnpacking(buffer, v);
+        m[k] = v;
+    }
+}
+
+// Default pack/unpack function for arrays
+template<typename T>
+void doParsimArrayPacking(omnetpp::cCommBuffer *b, const T *t, int n)
+{
+    for (int i = 0; i < n; i++)
+        doParsimPacking(b, t[i]);
+}
+
+template<typename T>
+void doParsimArrayUnpacking(omnetpp::cCommBuffer *b, T *t, int n)
+{
+    for (int i = 0; i < n; i++)
+        doParsimUnpacking(b, t[i]);
+}
+
+// Default rule to prevent compiler from choosing base class' doParsimPacking() function
+template<typename T>
+void doParsimPacking(omnetpp::cCommBuffer *, const T& t)
+{
+    throw omnetpp::cRuntimeError("Parsim error: No doParsimPacking() function for type %s", omnetpp::opp_typename(typeid(t)));
+}
+
+template<typename T>
+void doParsimUnpacking(omnetpp::cCommBuffer *, T& t)
+{
+    throw omnetpp::cRuntimeError("Parsim error: No doParsimUnpacking() function for type %s", omnetpp::opp_typename(typeid(t)));
+}
+
+}  // namespace omnetpp
+
+
+// forward
+template<typename T, typename A>
+std::ostream& operator<<(std::ostream& out, const std::vector<T,A>& vec);
+
+// Template rule which fires if a struct or class doesn't have operator<<
+template<typename T>
+inline std::ostream& operator<<(std::ostream& out,const T&) {return out;}
+
+// operator<< for std::vector<T>
+template<typename T, typename A>
+inline std::ostream& operator<<(std::ostream& out, const std::vector<T,A>& vec)
+{
+    out.put('{');
+    for(typename std::vector<T,A>::const_iterator it = vec.begin(); it != vec.end(); ++it)
+    {
+        if (it != vec.begin()) {
+            out.put(','); out.put(' ');
+        }
+        out << *it;
+    }
+    out.put('}');
+    
+    char buf[32];
+    sprintf(buf, " (size=%u)", (unsigned int)vec.size());
+    out.write(buf, strlen(buf));
+    return out;
+}
+
+Register_Class(Blocked)
+
+Blocked::Blocked() : ::omnetpp::cObject()
+{
+    this->type = 8;
+}
+
+Blocked::Blocked(const Blocked& other) : ::omnetpp::cObject(other)
+{
+    copy(other);
+}
+
+Blocked::~Blocked()
+{
+}
+
+Blocked& Blocked::operator=(const Blocked& other)
+{
+    if (this==&other) return *this;
+    ::omnetpp::cObject::operator=(other);
+    copy(other);
+    return *this;
+}
+
+void Blocked::copy(const Blocked& other)
+{
+    this->type = other.type;
+}
+
+void Blocked::parsimPack(omnetpp::cCommBuffer *b) const
+{
+    doParsimPacking(b,this->type);
+}
+
+void Blocked::parsimUnpack(omnetpp::cCommBuffer *b)
+{
+    doParsimUnpacking(b,this->type);
+}
+
+uint8_t Blocked::getType() const
+{
+    return this->type;
+}
+
+void Blocked::setType(uint8_t type)
+{
+    this->type = type;
+}
+
+class BlockedDescriptor : public omnetpp::cClassDescriptor
+{
+  private:
+    mutable const char **propertynames;
+  public:
+    BlockedDescriptor();
+    virtual ~BlockedDescriptor();
+
+    virtual bool doesSupport(omnetpp::cObject *obj) const override;
+    virtual const char **getPropertyNames() const override;
+    virtual const char *getProperty(const char *propertyname) const override;
+    virtual int getFieldCount() const override;
+    virtual const char *getFieldName(int field) const override;
+    virtual int findField(const char *fieldName) const override;
+    virtual unsigned int getFieldTypeFlags(int field) const override;
+    virtual const char *getFieldTypeString(int field) const override;
+    virtual const char **getFieldPropertyNames(int field) const override;
+    virtual const char *getFieldProperty(int field, const char *propertyname) const override;
+    virtual int getFieldArraySize(void *object, int field) const override;
+
+    virtual const char *getFieldDynamicTypeString(void *object, int field, int i) const override;
+    virtual std::string getFieldValueAsString(void *object, int field, int i) const override;
+    virtual bool setFieldValueAsString(void *object, int field, int i, const char *value) const override;
+
+    virtual const char *getFieldStructName(int field) const override;
+    virtual void *getFieldStructValuePointer(void *object, int field, int i) const override;
+};
+
+Register_ClassDescriptor(BlockedDescriptor)
+
+BlockedDescriptor::BlockedDescriptor() : omnetpp::cClassDescriptor("Blocked", "omnetpp::cObject")
+{
+    propertynames = nullptr;
+}
+
+BlockedDescriptor::~BlockedDescriptor()
+{
+    delete[] propertynames;
+}
+
+bool BlockedDescriptor::doesSupport(omnetpp::cObject *obj) const
+{
+    return dynamic_cast<Blocked *>(obj)!=nullptr;
+}
+
+const char **BlockedDescriptor::getPropertyNames() const
+{
+    if (!propertynames) {
+        static const char *names[] = {  nullptr };
+        omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
+        const char **basenames = basedesc ? basedesc->getPropertyNames() : nullptr;
+        propertynames = mergeLists(basenames, names);
+    }
+    return propertynames;
+}
+
+const char *BlockedDescriptor::getProperty(const char *propertyname) const
+{
+    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
+    return basedesc ? basedesc->getProperty(propertyname) : nullptr;
+}
+
+int BlockedDescriptor::getFieldCount() const
+{
+    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
+    return basedesc ? 1+basedesc->getFieldCount() : 1;
+}
+
+unsigned int BlockedDescriptor::getFieldTypeFlags(int field) const
+{
+    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
+    if (basedesc) {
+        if (field < basedesc->getFieldCount())
+            return basedesc->getFieldTypeFlags(field);
+        field -= basedesc->getFieldCount();
+    }
+    static unsigned int fieldTypeFlags[] = {
+        FD_ISEDITABLE,
+    };
+    return (field>=0 && field<1) ? fieldTypeFlags[field] : 0;
+}
+
+const char *BlockedDescriptor::getFieldName(int field) const
+{
+    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
+    if (basedesc) {
+        if (field < basedesc->getFieldCount())
+            return basedesc->getFieldName(field);
+        field -= basedesc->getFieldCount();
+    }
+    static const char *fieldNames[] = {
+        "type",
+    };
+    return (field>=0 && field<1) ? fieldNames[field] : nullptr;
+}
+
+int BlockedDescriptor::findField(const char *fieldName) const
+{
+    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
+    int base = basedesc ? basedesc->getFieldCount() : 0;
+    if (fieldName[0]=='t' && strcmp(fieldName, "type")==0) return base+0;
+    return basedesc ? basedesc->findField(fieldName) : -1;
+}
+
+const char *BlockedDescriptor::getFieldTypeString(int field) const
+{
+    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
+    if (basedesc) {
+        if (field < basedesc->getFieldCount())
+            return basedesc->getFieldTypeString(field);
+        field -= basedesc->getFieldCount();
+    }
+    static const char *fieldTypeStrings[] = {
+        "uint8_t",
+    };
+    return (field>=0 && field<1) ? fieldTypeStrings[field] : nullptr;
+}
+
+const char **BlockedDescriptor::getFieldPropertyNames(int field) const
+{
+    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
+    if (basedesc) {
+        if (field < basedesc->getFieldCount())
+            return basedesc->getFieldPropertyNames(field);
+        field -= basedesc->getFieldCount();
+    }
+    switch (field) {
+        default: return nullptr;
+    }
+}
+
+const char *BlockedDescriptor::getFieldProperty(int field, const char *propertyname) const
+{
+    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
+    if (basedesc) {
+        if (field < basedesc->getFieldCount())
+            return basedesc->getFieldProperty(field, propertyname);
+        field -= basedesc->getFieldCount();
+    }
+    switch (field) {
+        default: return nullptr;
+    }
+}
+
+int BlockedDescriptor::getFieldArraySize(void *object, int field) const
+{
+    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
+    if (basedesc) {
+        if (field < basedesc->getFieldCount())
+            return basedesc->getFieldArraySize(object, field);
+        field -= basedesc->getFieldCount();
+    }
+    Blocked *pp = (Blocked *)object; (void)pp;
+    switch (field) {
+        default: return 0;
+    }
+}
+
+const char *BlockedDescriptor::getFieldDynamicTypeString(void *object, int field, int i) const
+{
+    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
+    if (basedesc) {
+        if (field < basedesc->getFieldCount())
+            return basedesc->getFieldDynamicTypeString(object,field,i);
+        field -= basedesc->getFieldCount();
+    }
+    Blocked *pp = (Blocked *)object; (void)pp;
+    switch (field) {
+        default: return nullptr;
+    }
+}
+
+std::string BlockedDescriptor::getFieldValueAsString(void *object, int field, int i) const
+{
+    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
+    if (basedesc) {
+        if (field < basedesc->getFieldCount())
+            return basedesc->getFieldValueAsString(object,field,i);
+        field -= basedesc->getFieldCount();
+    }
+    Blocked *pp = (Blocked *)object; (void)pp;
+    switch (field) {
+        case 0: return ulong2string(pp->getType());
+        default: return "";
+    }
+}
+
+bool BlockedDescriptor::setFieldValueAsString(void *object, int field, int i, const char *value) const
+{
+    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
+    if (basedesc) {
+        if (field < basedesc->getFieldCount())
+            return basedesc->setFieldValueAsString(object,field,i,value);
+        field -= basedesc->getFieldCount();
+    }
+    Blocked *pp = (Blocked *)object; (void)pp;
+    switch (field) {
+        case 0: pp->setType(string2ulong(value)); return true;
+        default: return false;
+    }
+}
+
+const char *BlockedDescriptor::getFieldStructName(int field) const
+{
+    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
+    if (basedesc) {
+        if (field < basedesc->getFieldCount())
+            return basedesc->getFieldStructName(field);
+        field -= basedesc->getFieldCount();
+    }
+    switch (field) {
+        default: return nullptr;
+    };
+}
+
+void *BlockedDescriptor::getFieldStructValuePointer(void *object, int field, int i) const
+{
+    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
+    if (basedesc) {
+        if (field < basedesc->getFieldCount())
+            return basedesc->getFieldStructValuePointer(object, field, i);
+        field -= basedesc->getFieldCount();
+    }
+    Blocked *pp = (Blocked *)object; (void)pp;
+    switch (field) {
+        default: return nullptr;
+    }
+}
+
+

QUIC/Frames/blocked_m.h

@@ -0,0 +1,64 @@
+//
+// Generated file, do not edit! Created by nedtool 5.2 from Frames/blocked.msg.
+//
+
+#if defined(__clang__)
+#  pragma clang diagnostic ignored "-Wreserved-id-macro"
+#endif
+#ifndef __BLOCKED_M_H
+#define __BLOCKED_M_H
+
+#include <omnetpp.h>
+
+// nedtool version check
+#define MSGC_VERSION 0x0502
+#if (MSGC_VERSION!=OMNETPP_VERSION)
+#    error Version mismatch! Probably this file was generated by an earlier version of nedtool: 'make clean' should help.
+#endif
+
+
+
+/**
+ * Class generated from <tt>Frames/blocked.msg:19</tt> by nedtool.
+ * <pre>
+ * //
+ * // TODO generated message class
+ * //
+ * class Blocked
+ * {
+ *     uint8_t type = 8;
+ * }
+ * </pre>
+ */
+class Blocked : public ::omnetpp::cObject
+{
+  protected:
+    uint8_t type;
+
+  private:
+    void copy(const Blocked& other);
+
+  protected:
+    // protected and unimplemented operator==(), to prevent accidental usage
+    bool operator==(const Blocked&);
+
+  public:
+    Blocked();
+    Blocked(const Blocked& other);
+    virtual ~Blocked();
+    Blocked& operator=(const Blocked& other);
+    virtual Blocked *dup() const override {return new Blocked(*this);}
+    virtual void parsimPack(omnetpp::cCommBuffer *b) const override;
+    virtual void parsimUnpack(omnetpp::cCommBuffer *b) override;
+
+    // field getter/setter methods
+    virtual uint8_t getType() const;
+    virtual void setType(uint8_t type);
+};
+
+inline void doParsimPacking(omnetpp::cCommBuffer *b, const Blocked& obj) {obj.parsimPack(b);}
+inline void doParsimUnpacking(omnetpp::cCommBuffer *b, Blocked& obj) {obj.parsimUnpack(b);}
+
+
+#endif // ifndef __BLOCKED_M_H
+

QUIC/Frames/connection_close.msg

@@ -0,0 +1,24 @@
+//
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Lesser General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+// 
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU Lesser General Public License for more details.
+// 
+// You should have received a copy of the GNU Lesser General Public License
+// along with this program.  If not, see http://www.gnu.org/licenses/.
+// 
+
+//
+// TODO generated message class
+//
+class Connection_close {
+    uint8_t type = 2;
+    uint16_t error_Code;
+    uint16_t reason_Phrase_Length;
+    string reason_Phrase;
+}

QUIC/Frames/connection_close_m.cc

@@ -0,0 +1,517 @@
+//
+// Generated file, do not edit! Created by nedtool 5.2 from Frames/connection_close.msg.
+//
+
+// Disable warnings about unused variables, empty switch stmts, etc:
+#ifdef _MSC_VER
+#  pragma warning(disable:4101)
+#  pragma warning(disable:4065)
+#endif
+
+#if defined(__clang__)
+#  pragma clang diagnostic ignored "-Wshadow"
+#  pragma clang diagnostic ignored "-Wconversion"
+#  pragma clang diagnostic ignored "-Wunused-parameter"
+#  pragma clang diagnostic ignored "-Wc++98-compat"
+#  pragma clang diagnostic ignored "-Wunreachable-code-break"
+#  pragma clang diagnostic ignored "-Wold-style-cast"
+#elif defined(__GNUC__)
+#  pragma GCC diagnostic ignored "-Wshadow"
+#  pragma GCC diagnostic ignored "-Wconversion"
+#  pragma GCC diagnostic ignored "-Wunused-parameter"
+#  pragma GCC diagnostic ignored "-Wold-style-cast"
+#  pragma GCC diagnostic ignored "-Wsuggest-attribute=noreturn"
+#  pragma GCC diagnostic ignored "-Wfloat-conversion"
+#endif
+
+#include <iostream>
+#include <sstream>
+#include "connection_close_m.h"
+
+namespace omnetpp {
+
+// Template pack/unpack rules. They are declared *after* a1l type-specific pack functions for multiple reasons.
+// They are in the omnetpp namespace, to allow them to be found by argument-dependent lookup via the cCommBuffer argument
+
+// Packing/unpacking an std::vector
+template<typename T, typename A>
+void doParsimPacking(omnetpp::cCommBuffer *buffer, const std::vector<T,A>& v)
+{
+    int n = v.size();
+    doParsimPacking(buffer, n);
+    for (int i = 0; i < n; i++)
+        doParsimPacking(buffer, v[i]);
+}
+
+template<typename T, typename A>
+void doParsimUnpacking(omnetpp::cCommBuffer *buffer, std::vector<T,A>& v)
+{
+    int n;
+    doParsimUnpacking(buffer, n);
+    v.resize(n);
+    for (int i = 0; i < n; i++)
+        doParsimUnpacking(buffer, v[i]);
+}
+
+// Packing/unpacking an std::list
+template<typename T, typename A>
+void doParsimPacking(omnetpp::cCommBuffer *buffer, const std::list<T,A>& l)
+{
+    doParsimPacking(buffer, (int)l.size());
+    for (typename std::list<T,A>::const_iterator it = l.begin(); it != l.end(); ++it)
+        doParsimPacking(buffer, (T&)*it);
+}
+
+template<typename T, typename A>
+void doParsimUnpacking(omnetpp::cCommBuffer *buffer, std::list<T,A>& l)
+{
+    int n;
+    doParsimUnpacking(buffer, n);
+    for (int i=0; i<n; i++) {
+        l.push_back(T());
+        doParsimUnpacking(buffer, l.back());
+    }
+}
+
+// Packing/unpacking an std::set
+template<typename T, typename Tr, typename A>
+void doParsimPacking(omnetpp::cCommBuffer *buffer, const std::set<T,Tr,A>& s)
+{
+    doParsimPacking(buffer, (int)s.size());
+    for (typename std::set<T,Tr,A>::const_iterator it = s.begin(); it != s.end(); ++it)
+        doParsimPacking(buffer, *it);
+}
+
+template<typename T, typename Tr, typename A>
+void doParsimUnpacking(omnetpp::cCommBuffer *buffer, std::set<T,Tr,A>& s)
+{
+    int n;
+    doParsimUnpacking(buffer, n);
+    for (int i=0; i<n; i++) {
+        T x;
+        doParsimUnpacking(buffer, x);
+        s.insert(x);
+    }
+}
+
+// Packing/unpacking an std::map
+template<typename K, typename V, typename Tr, typename A>
+void doParsimPacking(omnetpp::cCommBuffer *buffer, const std::map<K,V,Tr,A>& m)
+{
+    doParsimPacking(buffer, (int)m.size());
+    for (typename std::map<K,V,Tr,A>::const_iterator it = m.begin(); it != m.end(); ++it) {
+        doParsimPacking(buffer, it->first);
+        doParsimPacking(buffer, it->second);
+    }
+}
+
+template<typename K, typename V, typename Tr, typename A>
+void doParsimUnpacking(omnetpp::cCommBuffer *buffer, std::map<K,V,Tr,A>& m)
+{
+    int n;
+    doParsimUnpacking(buffer, n);
+    for (int i=0; i<n; i++) {
+        K k; V v;
+        doParsimUnpacking(buffer, k);
+        doParsimUnpacking(buffer, v);
+        m[k] = v;
+    }
+}
+
+// Default pack/unpack function for arrays
+template<typename T>
+void doParsimArrayPacking(omnetpp::cCommBuffer *b, const T *t, int n)
+{
+    for (int i = 0; i < n; i++)
+        doParsimPacking(b, t[i]);
+}
+
+template<typename T>
+void doParsimArrayUnpacking(omnetpp::cCommBuffer *b, T *t, int n)
+{
+    for (int i = 0; i < n; i++)
+        doParsimUnpacking(b, t[i]);
+}
+
+// Default rule to prevent compiler from choosing base class' doParsimPacking() function
+template<typename T>
+void doParsimPacking(omnetpp::cCommBuffer *, const T& t)
+{
+    throw omnetpp::cRuntimeError("Parsim error: No doParsimPacking() function for type %s", omnetpp::opp_typename(typeid(t)));
+}
+
+template<typename T>
+void doParsimUnpacking(omnetpp::cCommBuffer *, T& t)
+{
+    throw omnetpp::cRuntimeError("Parsim error: No doParsimUnpacking() function for type %s", omnetpp::opp_typename(typeid(t)));
+}
+
+}  // namespace omnetpp
+
+
+// forward
+template<typename T, typename A>
+std::ostream& operator<<(std::ostream& out, const std::vector<T,A>& vec);
+
+// Template rule which fires if a struct or class doesn't have operator<<
+template<typename T>
+inline std::ostream& operator<<(std::ostream& out,const T&) {return out;}
+
+// operator<< for std::vector<T>
+template<typename T, typename A>
+inline std::ostream& operator<<(std::ostream& out, const std::vector<T,A>& vec)
+{
+    out.put('{');
+    for(typename std::vector<T,A>::const_iterator it = vec.begin(); it != vec.end(); ++it)
+    {
+        if (it != vec.begin()) {
+            out.put(','); out.put(' ');
+        }
+        out << *it;
+    }
+    out.put('}');
+    
+    char buf[32];
+    sprintf(buf, " (size=%u)", (unsigned int)vec.size());
+    out.write(buf, strlen(buf));
+    return out;
+}
+
+Register_Class(Connection_close)
+
+Connection_close::Connection_close() : ::omnetpp::cObject()
+{
+    this->type = 2;
+    this->error_Code = 0;
+    this->reason_Phrase_Length = 0;
+}
+
+Connection_close::Connection_close(const Connection_close& other) : ::omnetpp::cObject(other)
+{
+    copy(other);
+}
+
+Connection_close::~Connection_close()
+{
+}
+
+Connection_close& Connection_close::operator=(const Connection_close& other)
+{
+    if (this==&other) return *this;
+    ::omnetpp::cObject::operator=(other);
+    copy(other);
+    return *this;
+}
+
+void Connection_close::copy(const Connection_close& other)
+{
+    this->type = other.type;
+    this->error_Code = other.error_Code;
+    this->reason_Phrase_Length = other.reason_Phrase_Length;
+    this->reason_Phrase = other.reason_Phrase;
+}
+
+void Connection_close::parsimPack(omnetpp::cCommBuffer *b) const
+{
+    doParsimPacking(b,this->type);
+    doParsimPacking(b,this->error_Code);
+    doParsimPacking(b,this->reason_Phrase_Length);
+    doParsimPacking(b,this->reason_Phrase);
+}
+
+void Connection_close::parsimUnpack(omnetpp::cCommBuffer *b)
+{
+    doParsimUnpacking(b,this->type);
+    doParsimUnpacking(b,this->error_Code);
+    doParsimUnpacking(b,this->reason_Phrase_Length);
+    doParsimUnpacking(b,this->reason_Phrase);
+}
+
+uint8_t Connection_close::getType() const
+{
+    return this->type;
+}
+
+void Connection_close::setType(uint8_t type)
+{
+    this->type = type;
+}
+
+uint16_t Connection_close::getError_Code() const
+{
+    return this->error_Code;
+}
+
+void Connection_close::setError_Code(uint16_t error_Code)
+{
+    this->error_Code = error_Code;
+}
+
+uint16_t Connection_close::getReason_Phrase_Length() const
+{
+    return this->reason_Phrase_Length;
+}
+
+void Connection_close::setReason_Phrase_Length(uint16_t reason_Phrase_Length)
+{
+    this->reason_Phrase_Length = reason_Phrase_Length;
+}
+
+const char * Connection_close::getReason_Phrase() const
+{
+    return this->reason_Phrase.c_str();
+}
+
+void Connection_close::setReason_Phrase(const char * reason_Phrase)
+{
+    this->reason_Phrase = reason_Phrase;
+}
+
+class Connection_closeDescriptor : public omnetpp::cClassDescriptor
+{
+  private:
+    mutable const char **propertynames;
+  public:
+    Connection_closeDescriptor();
+    virtual ~Connection_closeDescriptor();
+
+    virtual bool doesSupport(omnetpp::cObject *obj) const override;
+    virtual const char **getPropertyNames() const override;
+    virtual const char *getProperty(const char *propertyname) const override;
+    virtual int getFieldCount() const override;
+    virtual const char *getFieldName(int field) const override;
+    virtual int findField(const char *fieldName) const override;
+    virtual unsigned int getFieldTypeFlags(int field) const override;
+    virtual const char *getFieldTypeString(int field) const override;
+    virtual const char **getFieldPropertyNames(int field) const override;
+    virtual const char *getFieldProperty(int field, const char *propertyname) const override;
+    virtual int getFieldArraySize(void *object, int field) const override;
+
+    virtual const char *getFieldDynamicTypeString(void *object, int field, int i) const override;
+    virtual std::string getFieldValueAsString(void *object, int field, int i) const override;
+    virtual bool setFieldValueAsString(void *object, int field, int i, const char *value) const override;
+
+    virtual const char *getFieldStructName(int field) const override;
+    virtual void *getFieldStructValuePointer(void *object, int field, int i) const override;
+};
+
+Register_ClassDescriptor(Connection_closeDescriptor)
+
+Connection_closeDescriptor::Connection_closeDescriptor() : omnetpp::cClassDescriptor("Connection_close", "omnetpp::cObject")
+{
+    propertynames = nullptr;
+}
+
+Connection_closeDescriptor::~Connection_closeDescriptor()
+{
+    delete[] propertynames;
+}
+
+bool Connection_closeDescriptor::doesSupport(omnetpp::cObject *obj) const
+{
+    return dynamic_cast<Connection_close *>(obj)!=nullptr;
+}
+
+const char **Connection_closeDescriptor::getPropertyNames() const
+{
+    if (!propertynames) {
+        static const char *names[] = {  nullptr };
+        omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
+        const char **basenames = basedesc ? basedesc->getPropertyNames() : nullptr;
+        propertynames = mergeLists(basenames, names);
+    }
+    return propertynames;
+}
+
+const char *Connection_closeDescriptor::getProperty(const char *propertyname) const
+{
+    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
+    return basedesc ? basedesc->getProperty(propertyname) : nullptr;
+}
+
+int Connection_closeDescriptor::getFieldCount() const
+{
+    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
+    return basedesc ? 4+basedesc->getFieldCount() : 4;
+}
+
+unsigned int Connection_closeDescriptor::getFieldTypeFlags(int field) const
+{
+    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
+    if (basedesc) {
+        if (field < basedesc->getFieldCount())
+            return basedesc->getFieldTypeFlags(field);
+        field -= basedesc->getFieldCount();
+    }
+    static unsigned int fieldTypeFlags[] = {
+        FD_ISEDITABLE,
+        FD_ISEDITABLE,
+        FD_ISEDITABLE,
+        FD_ISEDITABLE,
+    };
+    return (field>=0 && field<4) ? fieldTypeFlags[field] : 0;
+}
+
+const char *Connection_closeDescriptor::getFieldName(int field) const
+{
+    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
+    if (basedesc) {
+        if (field < basedesc->getFieldCount())
+            return basedesc->getFieldName(field);
+        field -= basedesc->getFieldCount();
+    }
+    static const char *fieldNames[] = {
+        "type",
+        "error_Code",
+        "reason_Phrase_Length",
+        "reason_Phrase",
+    };
+    return (field>=0 && field<4) ? fieldNames[field] : nullptr;
+}
+
+int Connection_closeDescriptor::findField(const char *fieldName) const
+{
+    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
+    int base = basedesc ? basedesc->getFieldCount() : 0;
+    if (fieldName[0]=='t' && strcmp(fieldName, "type")==0) return base+0;
+    if (fieldName[0]=='e' && strcmp(fieldName, "error_Code")==0) return base+1;
+    if (fieldName[0]=='r' && strcmp(fieldName, "reason_Phrase_Length")==0) return base+2;
+    if (fieldName[0]=='r' && strcmp(fieldName, "reason_Phrase")==0) return base+3;
+    return basedesc ? basedesc->findField(fieldName) : -1;
+}
+
+const char *Connection_closeDescriptor::getFieldTypeString(int field) const
+{
+    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
+    if (basedesc) {
+        if (field < basedesc->getFieldCount())
+            return basedesc->getFieldTypeString(field);
+        field -= basedesc->getFieldCount();
+    }
+    static const char *fieldTypeStrings[] = {
+        "uint8_t",
+        "uint16_t",
+        "uint16_t",
+        "string",
+    };
+    return (field>=0 && field<4) ? fieldTypeStrings[field] : nullptr;
+}
+
+const char **Connection_closeDescriptor::getFieldPropertyNames(int field) const
+{
+    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
+    if (basedesc) {
+        if (field < basedesc->getFieldCount())
+            return basedesc->getFieldPropertyNames(field);
+        field -= basedesc->getFieldCount();
+    }
+    switch (field) {
+        default: return nullptr;
+    }
+}
+
+const char *Connection_closeDescriptor::getFieldProperty(int field, const char *propertyname) const
+{
+    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
+    if (basedesc) {
+        if (field < basedesc->getFieldCount())
+            return basedesc->getFieldProperty(field, propertyname);
+        field -= basedesc->getFieldCount();
+    }
+    switch (field) {
+        default: return nullptr;
+    }
+}
+
+int Connection_closeDescriptor::getFieldArraySize(void *object, int field) const
+{
+    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
+    if (basedesc) {
+        if (field < basedesc->getFieldCount())
+            return basedesc->getFieldArraySize(object, field);
+        field -= basedesc->getFieldCount();
+    }
+    Connection_close *pp = (Connection_close *)object; (void)pp;
+    switch (field) {
+        default: return 0;
+    }
+}
+
+const char *Connection_closeDescriptor::getFieldDynamicTypeString(void *object, int field, int i) const
+{
+    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
+    if (basedesc) {
+        if (field < basedesc->getFieldCount())
+            return basedesc->getFieldDynamicTypeString(object,field,i);
+        field -= basedesc->getFieldCount();
+    }
+    Connection_close *pp = (Connection_close *)object; (void)pp;
+    switch (field) {
+        default: return nullptr;
+    }
+}
+
+std::string Connection_closeDescriptor::getFieldValueAsString(void *object, int field, int i) const
+{
+    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
+    if (basedesc) {
+        if (field < basedesc->getFieldCount())
+            return basedesc->getFieldValueAsString(object,field,i);
+        field -= basedesc->getFieldCount();
+    }
+    Connection_close *pp = (Connection_close *)object; (void)pp;
+    switch (field) {
+        case 0: return ulong2string(pp->getType());
+        case 1: return ulong2string(pp->getError_Code());
+        case 2: return ulong2string(pp->getReason_Phrase_Length());
+        case 3: return oppstring2string(pp->getReason_Phrase());
+        default: return "";
+    }
+}
+
+bool Connection_closeDescriptor::setFieldValueAsString(void *object, int field, int i, const char *value) const
+{
+    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
+    if (basedesc) {
+        if (field < basedesc->getFieldCount())
+            return basedesc->setFieldValueAsString(object,field,i,value);
+        field -= basedesc->getFieldCount();
+    }
+    Connection_close *pp = (Connection_close *)object; (void)pp;
+    switch (field) {
+        case 0: pp->setType(string2ulong(value)); return true;
+        case 1: pp->setError_Code(string2ulong(value)); return true;
+        case 2: pp->setReason_Phrase_Length(string2ulong(value)); return true;
+        case 3: pp->setReason_Phrase((value)); return true;
+        default: return false;
+    }
+}
+
+const char *Connection_closeDescriptor::getFieldStructName(int field) const
+{
+    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
+    if (basedesc) {
+        if (field < basedesc->getFieldCount())
+            return basedesc->getFieldStructName(field);
+        field -= basedesc->getFieldCount();
+    }
+    switch (field) {
+        default: return nullptr;
+    };
+}
+
+void *Connection_closeDescriptor::getFieldStructValuePointer(void *object, int field, int i) const
+{
+    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
+    if (basedesc) {
+        if (field < basedesc->getFieldCount())
+            return basedesc->getFieldStructValuePointer(object, field, i);
+        field -= basedesc->getFieldCount();
+    }
+    Connection_close *pp = (Connection_close *)object; (void)pp;
+    switch (field) {
+        default: return nullptr;
+    }
+}
+
+

QUIC/Frames/connection_close_m.h

@@ -0,0 +1,76 @@
+//
+// Generated file, do not edit! Created by nedtool 5.2 from Frames/connection_close.msg.
+//
+
+#if defined(__clang__)
+#  pragma clang diagnostic ignored "-Wreserved-id-macro"
+#endif
+#ifndef __CONNECTION_CLOSE_M_H
+#define __CONNECTION_CLOSE_M_H
+
+#include <omnetpp.h>
+
+// nedtool version check
+#define MSGC_VERSION 0x0502
+#if (MSGC_VERSION!=OMNETPP_VERSION)
+#    error Version mismatch! Probably this file was generated by an earlier version of nedtool: 'make clean' should help.
+#endif
+
+
+
+/**
+ * Class generated from <tt>Frames/connection_close.msg:19</tt> by nedtool.
+ * <pre>
+ * //
+ * // TODO generated message class
+ * //
+ * class Connection_close
+ * {
+ *     uint8_t type = 2;
+ *     uint16_t error_Code;
+ *     uint16_t reason_Phrase_Length;
+ *     string reason_Phrase;
+ * }
+ * </pre>
+ */
+class Connection_close : public ::omnetpp::cObject
+{
+  protected:
+    uint8_t type;
+    uint16_t error_Code;
+    uint16_t reason_Phrase_Length;
+    ::omnetpp::opp_string reason_Phrase;
+
+  private:
+    void copy(const Connection_close& other);
+
+  protected:
+    // protected and unimplemented operator==(), to prevent accidental usage
+    bool operator==(const Connection_close&);
+
+  public:
+    Connection_close();
+    Connection_close(const Connection_close& other);
+    virtual ~Connection_close();
+    Connection_close& operator=(const Connection_close& other);
+    virtual Connection_close *dup() const override {return new Connection_close(*this);}
+    virtual void parsimPack(omnetpp::cCommBuffer *b) const override;
+    virtual void parsimUnpack(omnetpp::cCommBuffer *b) override;
+
+    // field getter/setter methods
+    virtual uint8_t getType() const;
+    virtual void setType(uint8_t type);
+    virtual uint16_t getError_Code() const;
+    virtual void setError_Code(uint16_t error_Code);
+    virtual uint16_t getReason_Phrase_Length() const;
+    virtual void setReason_Phrase_Length(uint16_t reason_Phrase_Length);
+    virtual const char * getReason_Phrase() const;
+    virtual void setReason_Phrase(const char * reason_Phrase);
+};
+
+inline void doParsimPacking(omnetpp::cCommBuffer *b, const Connection_close& obj) {obj.parsimPack(b);}
+inline void doParsimUnpacking(omnetpp::cCommBuffer *b, Connection_close& obj) {obj.parsimUnpack(b);}
+
+
+#endif // ifndef __CONNECTION_CLOSE_M_H
+

QUIC/Frames/max_Data.msg

@@ -0,0 +1,22 @@
+//
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Lesser General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+// 
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU Lesser General Public License for more details.
+// 
+// You should have received a copy of the GNU Lesser General Public License
+// along with this program.  If not, see http://www.gnu.org/licenses/.
+// 
+
+//
+// TODO generated message class
+//
+class Max_Data {
+    uint8_t type = 4;
+    uint64_t maximum_Data;
+}

QUIC/Frames/max_Data_m.cc

@@ -0,0 +1,478 @@
+//
+// Generated file, do not edit! Created by nedtool 5.2 from Frames/max_Data.msg.
+//
+
+// Disable warnings about unused variables, empty switch stmts, etc:
+#ifdef _MSC_VER
+#  pragma warning(disable:4101)
+#  pragma warning(disable:4065)
+#endif
+
+#if defined(__clang__)
+#  pragma clang diagnostic ignored "-Wshadow"
+#  pragma clang diagnostic ignored "-Wconversion"
+#  pragma clang diagnostic ignored "-Wunused-parameter"
+#  pragma clang diagnostic ignored "-Wc++98-compat"
+#  pragma clang diagnostic ignored "-Wunreachable-code-break"
+#  pragma clang diagnostic ignored "-Wold-style-cast"
+#elif defined(__GNUC__)
+#  pragma GCC diagnostic ignored "-Wshadow"
+#  pragma GCC diagnostic ignored "-Wconversion"
+#  pragma GCC diagnostic ignored "-Wunused-parameter"
+#  pragma GCC diagnostic ignored "-Wold-style-cast"
+#  pragma GCC diagnostic ignored "-Wsuggest-attribute=noreturn"
+#  pragma GCC diagnostic ignored "-Wfloat-conversion"
+#endif
+
+#include <iostream>
+#include <sstream>
+#include "max_Data_m.h"
+
+namespace omnetpp {
+
+// Template pack/unpack rules. They are declared *after* a1l type-specific pack functions for multiple reasons.
+// They are in the omnetpp namespace, to allow them to be found by argument-dependent lookup via the cCommBuffer argument
+
+// Packing/unpacking an std::vector
+template<typename T, typename A>
+void doParsimPacking(omnetpp::cCommBuffer *buffer, const std::vector<T,A>& v)
+{
+    int n = v.size();
+    doParsimPacking(buffer, n);
+    for (int i = 0; i < n; i++)
+        doParsimPacking(buffer, v[i]);
+}
+
+template<typename T, typename A>
+void doParsimUnpacking(omnetpp::cCommBuffer *buffer, std::vector<T,A>& v)
+{
+    int n;
+    doParsimUnpacking(buffer, n);
+    v.resize(n);
+    for (int i = 0; i < n; i++)
+        doParsimUnpacking(buffer, v[i]);
+}
+
+// Packing/unpacking an std::list
+template<typename T, typename A>
+void doParsimPacking(omnetpp::cCommBuffer *buffer, const std::list<T,A>& l)
+{
+    doParsimPacking(buffer, (int)l.size());
+    for (typename std::list<T,A>::const_iterator it = l.begin(); it != l.end(); ++it)
+        doParsimPacking(buffer, (T&)*it);
+}
+
+template<typename T, typename A>
+void doParsimUnpacking(omnetpp::cCommBuffer *buffer, std::list<T,A>& l)
+{
+    int n;
+    doParsimUnpacking(buffer, n);
+    for (int i=0; i<n; i++) {
+        l.push_back(T());
+        doParsimUnpacking(buffer, l.back());
+    }
+}
+
+// Packing/unpacking an std::set
+template<typename T, typename Tr, typename A>
+void doParsimPacking(omnetpp::cCommBuffer *buffer, const std::set<T,Tr,A>& s)
+{
+    doParsimPacking(buffer, (int)s.size());
+    for (typename std::set<T,Tr,A>::const_iterator it = s.begin(); it != s.end(); ++it)
+        doParsimPacking(buffer, *it);
+}
+
+template<typename T, typename Tr, typename A>
+void doParsimUnpacking(omnetpp::cCommBuffer *buffer, std::set<T,Tr,A>& s)
+{
+    int n;
+    doParsimUnpacking(buffer, n);
+    for (int i=0; i<n; i++) {
+        T x;
+        doParsimUnpacking(buffer, x);
+        s.insert(x);
+    }
+}
+
+// Packing/unpacking an std::map
+template<typename K, typename V, typename Tr, typename A>
+void doParsimPacking(omnetpp::cCommBuffer *buffer, const std::map<K,V,Tr,A>& m)
+{
+    doParsimPacking(buffer, (int)m.size());
+    for (typename std::map<K,V,Tr,A>::const_iterator it = m.begin(); it != m.end(); ++it) {
+        doParsimPacking(buffer, it->first);
+        doParsimPacking(buffer, it->second);
+    }
+}
+
+template<typename K, typename V, typename Tr, typename A>
+void doParsimUnpacking(omnetpp::cCommBuffer *buffer, std::map<K,V,Tr,A>& m)
+{
+    int n;
+    doParsimUnpacking(buffer, n);
+    for (int i=0; i<n; i++) {
+        K k; V v;
+        doParsimUnpacking(buffer, k);
+        doParsimUnpacking(buffer, v);
+        m[k] = v;
+    }
+}
+
+// Default pack/unpack function for arrays
+template<typename T>
+void doParsimArrayPacking(omnetpp::cCommBuffer *b, const T *t, int n)
+{
+    for (int i = 0; i < n; i++)
+        doParsimPacking(b, t[i]);
+}
+
+template<typename T>
+void doParsimArrayUnpacking(omnetpp::cCommBuffer *b, T *t, int n)
+{
+    for (int i = 0; i < n; i++)
+        doParsimUnpacking(b, t[i]);
+}
+
+// Default rule to prevent compiler from choosing base class' doParsimPacking() function
+template<typename T>
+void doParsimPacking(omnetpp::cCommBuffer *, const T& t)
+{
+    throw omnetpp::cRuntimeError("Parsim error: No doParsimPacking() function for type %s", omnetpp::opp_typename(typeid(t)));
+}
+
+template<typename T>
+void doParsimUnpacking(omnetpp::cCommBuffer *, T& t)
+{
+    throw omnetpp::cRuntimeError("Parsim error: No doParsimUnpacking() function for type %s", omnetpp::opp_typename(typeid(t)));
+}
+
+}  // namespace omnetpp
+
+
+// forward
+template<typename T, typename A>
+std::ostream& operator<<(std::ostream& out, const std::vector<T,A>& vec);
+
+// Template rule which fires if a struct or class doesn't have operator<<
+template<typename T>
+inline std::ostream& operator<<(std::ostream& out,const T&) {return out;}
+
+// operator<< for std::vector<T>
+template<typename T, typename A>
+inline std::ostream& operator<<(std::ostream& out, const std::vector<T,A>& vec)
+{
+    out.put('{');
+    for(typename std::vector<T,A>::const_iterator it = vec.begin(); it != vec.end(); ++it)
+    {
+        if (it != vec.begin()) {
+            out.put(','); out.put(' ');
+        }
+        out << *it;
+    }
+    out.put('}');
+    
+    char buf[32];
+    sprintf(buf, " (size=%u)", (unsigned int)vec.size());
+    out.write(buf, strlen(buf));
+    return out;
+}
+
+Register_Class(Max_Data)
+
+Max_Data::Max_Data() : ::omnetpp::cObject()
+{
+    this->type = 4;
+    this->maximum_Data = 0;
+}
+
+Max_Data::Max_Data(const Max_Data& other) : ::omnetpp::cObject(other)
+{
+    copy(other);
+}
+
+Max_Data::~Max_Data()
+{
+}
+
+Max_Data& Max_Data::operator=(const Max_Data& other)
+{
+    if (this==&other) return *this;
+    ::omnetpp::cObject::operator=(other);
+    copy(other);
+    return *this;
+}
+
+void Max_Data::copy(const Max_Data& other)
+{
+    this->type = other.type;
+    this->maximum_Data = other.maximum_Data;
+}
+
+void Max_Data::parsimPack(omnetpp::cCommBuffer *b) const
+{
+    doParsimPacking(b,this->type);
+    doParsimPacking(b,this->maximum_Data);
+}
+
+void Max_Data::parsimUnpack(omnetpp::cCommBuffer *b)
+{
+    doParsimUnpacking(b,this->type);
+    doParsimUnpacking(b,this->maximum_Data);
+}
+
+uint8_t Max_Data::getType() const
+{
+    return this->type;
+}
+
+void Max_Data::setType(uint8_t type)
+{
+    this->type = type;
+}
+
+uint64_t Max_Data::getMaximum_Data() const
+{
+    return this->maximum_Data;
+}
+
+void Max_Data::setMaximum_Data(uint64_t maximum_Data)
+{
+    this->maximum_Data = maximum_Data;
+}
+
+class Max_DataDescriptor : public omnetpp::cClassDescriptor
+{
+  private:
+    mutable const char **propertynames;
+  public:
+    Max_DataDescriptor();
+    virtual ~Max_DataDescriptor();
+
+    virtual bool doesSupport(omnetpp::cObject *obj) const override;
+    virtual const char **getPropertyNames() const override;
+    virtual const char *getProperty(const char *propertyname) const override;
+    virtual int getFieldCount() const override;
+    virtual const char *getFieldName(int field) const override;
+    virtual int findField(const char *fieldName) const override;
+    virtual unsigned int getFieldTypeFlags(int field) const override;
+    virtual const char *getFieldTypeString(int field) const override;
+    virtual const char **getFieldPropertyNames(int field) const override;
+    virtual const char *getFieldProperty(int field, const char *propertyname) const override;
+    virtual int getFieldArraySize(void *object, int field) const override;
+
+    virtual const char *getFieldDynamicTypeString(void *object, int field, int i) const override;
+    virtual std::string getFieldValueAsString(void *object, int field, int i) const override;
+    virtual bool setFieldValueAsString(void *object, int field, int i, const char *value) const override;
+
+    virtual const char *getFieldStructName(int field) const override;
+    virtual void *getFieldStructValuePointer(void *object, int field, int i) const override;
+};
+
+Register_ClassDescriptor(Max_DataDescriptor)
+
+Max_DataDescriptor::Max_DataDescriptor() : omnetpp::cClassDescriptor("Max_Data", "omnetpp::cObject")
+{
+    propertynames = nullptr;
+}
+
+Max_DataDescriptor::~Max_DataDescriptor()
+{
+    delete[] propertynames;
+}
+
+bool Max_DataDescriptor::doesSupport(omnetpp::cObject *obj) const
+{
+    return dynamic_cast<Max_Data *>(obj)!=nullptr;
+}
+
+const char **Max_DataDescriptor::getPropertyNames() const
+{
+    if (!propertynames) {
+        static const char *names[] = {  nullptr };
+        omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
+        const char **basenames = basedesc ? basedesc->getPropertyNames() : nullptr;
+        propertynames = mergeLists(basenames, names);
+    }
+    return propertynames;
+}
+
+const char *Max_DataDescriptor::getProperty(const char *propertyname) const
+{
+    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
+    return basedesc ? basedesc->getProperty(propertyname) : nullptr;
+}
+
+int Max_DataDescriptor::getFieldCount() const
+{
+    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
+    return basedesc ? 2+basedesc->getFieldCount() : 2;
+}
+
+unsigned int Max_DataDescriptor::getFieldTypeFlags(int field) const
+{
+    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
+    if (basedesc) {
+        if (field < basedesc->getFieldCount())
+            return basedesc->getFieldTypeFlags(field);
+        field -= basedesc->getFieldCount();
+    }
+    static unsigned int fieldTypeFlags[] = {
+        FD_ISEDITABLE,
+        FD_ISEDITABLE,
+    };
+    return (field>=0 && field<2) ? fieldTypeFlags[field] : 0;
+}
+
+const char *Max_DataDescriptor::getFieldName(int field) const
+{
+    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
+    if (basedesc) {
+        if (field < basedesc->getFieldCount())
+            return basedesc->getFieldName(field);
+        field -= basedesc->getFieldCount();
+    }
+    static const char *fieldNames[] = {
+        "type",
+        "maximum_Data",
+    };
+    return (field>=0 && field<2) ? fieldNames[field] : nullptr;
+}
+
+int Max_DataDescriptor::findField(const char *fieldName) const
+{
+    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
+    int base = basedesc ? basedesc->getFieldCount() : 0;
+    if (fieldName[0]=='t' && strcmp(fieldName, "type")==0) return base+0;
+    if (fieldName[0]=='m' && strcmp(fieldName, "maximum_Data")==0) return base+1;
+    return basedesc ? basedesc->findField(fieldName) : -1;
+}
+
+const char *Max_DataDescriptor::getFieldTypeString(int field) const
+{
+    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
+    if (basedesc) {
+        if (field < basedesc->getFieldCount())
+            return basedesc->getFieldTypeString(field);
+        field -= basedesc->getFieldCount();
+    }
+    static const char *fieldTypeStrings[] = {
+        "uint8_t",
+        "uint64_t",
+    };
+    return (field>=0 && field<2) ? fieldTypeStrings[field] : nullptr;
+}
+
+const char **Max_DataDescriptor::getFieldPropertyNames(int field) const
+{
+    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
+    if (basedesc) {
+        if (field < basedesc->getFieldCount())
+            return basedesc->getFieldPropertyNames(field);
+        field -= basedesc->getFieldCount();
+    }
+    switch (field) {
+        default: return nullptr;
+    }
+}
+
+const char *Max_DataDescriptor::getFieldProperty(int field, const char *propertyname) const
+{
+    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
+    if (basedesc) {
+        if (field < basedesc->getFieldCount())
+            return basedesc->getFieldProperty(field, propertyname);
+        field -= basedesc->getFieldCount();
+    }
+    switch (field) {
+        default: return nullptr;
+    }
+}
+
+int Max_DataDescriptor::getFieldArraySize(void *object, int field) const
+{
+    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
+    if (basedesc) {
+        if (field < basedesc->getFieldCount())
+            return basedesc->getFieldArraySize(object, field);
+        field -= basedesc->getFieldCount();
+    }
+    Max_Data *pp = (Max_Data *)object; (void)pp;
+    switch (field) {
+        default: return 0;
+    }
+}
+
+const char *Max_DataDescriptor::getFieldDynamicTypeString(void *object, int field, int i) const
+{
+    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
+    if (basedesc) {
+        if (field < basedesc->getFieldCount())
+            return basedesc->getFieldDynamicTypeString(object,field,i);
+        field -= basedesc->getFieldCount();
+    }
+    Max_Data *pp = (Max_Data *)object; (void)pp;
+    switch (field) {
+        default: return nullptr;
+    }
+}
+
+std::string Max_DataDescriptor::getFieldValueAsString(void *object, int field, int i) const
+{
+    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
+    if (basedesc) {
+        if (field < basedesc->getFieldCount())
+            return basedesc->getFieldValueAsString(object,field,i);
+        field -= basedesc->getFieldCount();
+    }
+    Max_Data *pp = (Max_Data *)object; (void)pp;
+    switch (field) {
+        case 0: return ulong2string(pp->getType());
+        case 1: return uint642string(pp->getMaximum_Data());
+        default: return "";
+    }
+}
+
+bool Max_DataDescriptor::setFieldValueAsString(void *object, int field, int i, const char *value) const
+{
+    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
+    if (basedesc) {
+        if (field < basedesc->getFieldCount())
+            return basedesc->setFieldValueAsString(object,field,i,value);
+        field -= basedesc->getFieldCount();
+    }
+    Max_Data *pp = (Max_Data *)object; (void)pp;
+    switch (field) {
+        case 0: pp->setType(string2ulong(value)); return true;
+        case 1: pp->setMaximum_Data(string2uint64(value)); return true;
+        default: return false;
+    }
+}
+
+const char *Max_DataDescriptor::getFieldStructName(int field) const
+{
+    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
+    if (basedesc) {
+        if (field < basedesc->getFieldCount())
+            return basedesc->getFieldStructName(field);
+        field -= basedesc->getFieldCount();
+    }
+    switch (field) {
+        default: return nullptr;
+    };
+}
+
+void *Max_DataDescriptor::getFieldStructValuePointer(void *object, int field, int i) const
+{
+    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
+    if (basedesc) {
+        if (field < basedesc->getFieldCount())
+            return basedesc->getFieldStructValuePointer(object, field, i);
+        field -= basedesc->getFieldCount();
+    }
+    Max_Data *pp = (Max_Data *)object; (void)pp;
+    switch (field) {
+        default: return nullptr;
+    }
+}
+
+

QUIC/Frames/max_Data_m.h

@@ -0,0 +1,68 @@
+//
+// Generated file, do not edit! Created by nedtool 5.2 from Frames/max_Data.msg.
+//
+
+#if defined(__clang__)
+#  pragma clang diagnostic ignored "-Wreserved-id-macro"
+#endif
+#ifndef __MAX_DATA_M_H
+#define __MAX_DATA_M_H
+
+#include <omnetpp.h>
+
+// nedtool version check
+#define MSGC_VERSION 0x0502
+#if (MSGC_VERSION!=OMNETPP_VERSION)
+#    error Version mismatch! Probably this file was generated by an earlier version of nedtool: 'make clean' should help.
+#endif
+
+
+
+/**
+ * Class generated from <tt>Frames/max_Data.msg:19</tt> by nedtool.
+ * <pre>
+ * //
+ * // TODO generated message class
+ * //
+ * class Max_Data
+ * {
+ *     uint8_t type = 4;
+ *     uint64_t maximum_Data;
+ * }
+ * </pre>
+ */
+class Max_Data : public ::omnetpp::cObject
+{
+  protected:
+    uint8_t type;
+    uint64_t maximum_Data;
+
+  private:
+    void copy(const Max_Data& other);
+
+  protected:
+    // protected and unimplemented operator==(), to prevent accidental usage
+    bool operator==(const Max_Data&);
+
+  public:
+    Max_Data();
+    Max_Data(const Max_Data& other);
+    virtual ~Max_Data();
+    Max_Data& operator=(const Max_Data& other);
+    virtual Max_Data *dup() const override {return new Max_Data(*this);}
+    virtual void parsimPack(omnetpp::cCommBuffer *b) const override;
+    virtual void parsimUnpack(omnetpp::cCommBuffer *b) override;
+
+    // field getter/setter methods
+    virtual uint8_t getType() const;
+    virtual void setType(uint8_t type);
+    virtual uint64_t getMaximum_Data() const;
+    virtual void setMaximum_Data(uint64_t maximum_Data);
+};
+
+inline void doParsimPacking(omnetpp::cCommBuffer *b, const Max_Data& obj) {obj.parsimPack(b);}
+inline void doParsimUnpacking(omnetpp::cCommBuffer *b, Max_Data& obj) {obj.parsimUnpack(b);}
+
+
+#endif // ifndef __MAX_DATA_M_H
+

QUIC/Frames/max_Stream_Data.msg

@@ -0,0 +1,23 @@
+//
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Lesser General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+// 
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU Lesser General Public License for more details.
+// 
+// You should have received a copy of the GNU Lesser General Public License
+// along with this program.  If not, see http://www.gnu.org/licenses/.
+// 
+
+//
+// TODO generated message class
+//
+class Max_Stream_Data {
+    uint8_t type = 5;
+    uint32_t stream_Id;
+    uint64_t maximum_Stream_Data;
+}

QUIC/Frames/max_Stream_Data_m.cc

@@ -0,0 +1,498 @@
+//
+// Generated file, do not edit! Created by nedtool 5.2 from Frames/max_Stream_Data.msg.
+//
+
+// Disable warnings about unused variables, empty switch stmts, etc:
+#ifdef _MSC_VER
+#  pragma warning(disable:4101)
+#  pragma warning(disable:4065)
+#endif
+
+#if defined(__clang__)
+#  pragma clang diagnostic ignored "-Wshadow"
+#  pragma clang diagnostic ignored "-Wconversion"
+#  pragma clang diagnostic ignored "-Wunused-parameter"
+#  pragma clang diagnostic ignored "-Wc++98-compat"
+#  pragma clang diagnostic ignored "-Wunreachable-code-break"
+#  pragma clang diagnostic ignored "-Wold-style-cast"
+#elif defined(__GNUC__)
+#  pragma GCC diagnostic ignored "-Wshadow"
+#  pragma GCC diagnostic ignored "-Wconversion"
+#  pragma GCC diagnostic ignored "-Wunused-parameter"
+#  pragma GCC diagnostic ignored "-Wold-style-cast"
+#  pragma GCC diagnostic ignored "-Wsuggest-attribute=noreturn"
+#  pragma GCC diagnostic ignored "-Wfloat-conversion"
+#endif
+
+#include <iostream>
+#include <sstream>
+#include "max_Stream_Data_m.h"
+
+namespace omnetpp {
+
+// Template pack/unpack rules. They are declared *after* a1l type-specific pack functions for multiple reasons.
+// They are in the omnetpp namespace, to allow them to be found by argument-dependent lookup via the cCommBuffer argument
+
+// Packing/unpacking an std::vector
+template<typename T, typename A>
+void doParsimPacking(omnetpp::cCommBuffer *buffer, const std::vector<T,A>& v)
+{
+    int n = v.size();
+    doParsimPacking(buffer, n);
+    for (int i = 0; i < n; i++)
+        doParsimPacking(buffer, v[i]);
+}
+
+template<typename T, typename A>
+void doParsimUnpacking(omnetpp::cCommBuffer *buffer, std::vector<T,A>& v)
+{
+    int n;
+    doParsimUnpacking(buffer, n);
+    v.resize(n);
+    for (int i = 0; i < n; i++)
+        doParsimUnpacking(buffer, v[i]);
+}
+
+// Packing/unpacking an std::list
+template<typename T, typename A>
+void doParsimPacking(omnetpp::cCommBuffer *buffer, const std::list<T,A>& l)
+{
+    doParsimPacking(buffer, (int)l.size());
+    for (typename std::list<T,A>::const_iterator it = l.begin(); it != l.end(); ++it)
+        doParsimPacking(buffer, (T&)*it);
+}
+
+template<typename T, typename A>
+void doParsimUnpacking(omnetpp::cCommBuffer *buffer, std::list<T,A>& l)
+{
+    int n;
+    doParsimUnpacking(buffer, n);
+    for (int i=0; i<n; i++) {
+        l.push_back(T());
+        doParsimUnpacking(buffer, l.back());
+    }
+}
+
+// Packing/unpacking an std::set
+template<typename T, typename Tr, typename A>
+void doParsimPacking(omnetpp::cCommBuffer *buffer, const std::set<T,Tr,A>& s)
+{
+    doParsimPacking(buffer, (int)s.size());
+    for (typename std::set<T,Tr,A>::const_iterator it = s.begin(); it != s.end(); ++it)
+        doParsimPacking(buffer, *it);
+}
+
+template<typename T, typename Tr, typename A>
+void doParsimUnpacking(omnetpp::cCommBuffer *buffer, std::set<T,Tr,A>& s)
+{
+    int n;
+    doParsimUnpacking(buffer, n);
+    for (int i=0; i<n; i++) {
+        T x;
+        doParsimUnpacking(buffer, x);
+        s.insert(x);
+    }
+}
+
+// Packing/unpacking an std::map
+template<typename K, typename V, typename Tr, typename A>
+void doParsimPacking(omnetpp::cCommBuffer *buffer, const std::map<K,V,Tr,A>& m)
+{
+    doParsimPacking(buffer, (int)m.size());
+    for (typename std::map<K,V,Tr,A>::const_iterator it = m.begin(); it != m.end(); ++it) {
+        doParsimPacking(buffer, it->first);
+        doParsimPacking(buffer, it->second);
+    }
+}
+
+template<typename K, typename V, typename Tr, typename A>
+void doParsimUnpacking(omnetpp::cCommBuffer *buffer, std::map<K,V,Tr,A>& m)
+{
+    int n;
+    doParsimUnpacking(buffer, n);
+    for (int i=0; i<n; i++) {
+        K k; V v;
+        doParsimUnpacking(buffer, k);
+        doParsimUnpacking(buffer, v);
+        m[k] = v;
+    }
+}
+
+// Default pack/unpack function for arrays
+template<typename T>
+void doParsimArrayPacking(omnetpp::cCommBuffer *b, const T *t, int n)
+{
+    for (int i = 0; i < n; i++)
+        doParsimPacking(b, t[i]);
+}
+
+template<typename T>
+void doParsimArrayUnpacking(omnetpp::cCommBuffer *b, T *t, int n)
+{
+    for (int i = 0; i < n; i++)
+        doParsimUnpacking(b, t[i]);
+}
+
+// Default rule to prevent compiler from choosing base class' doParsimPacking() function
+template<typename T>
+void doParsimPacking(omnetpp::cCommBuffer *, const T& t)
+{
+    throw omnetpp::cRuntimeError("Parsim error: No doParsimPacking() function for type %s", omnetpp::opp_typename(typeid(t)));
+}
+
+template<typename T>
+void doParsimUnpacking(omnetpp::cCommBuffer *, T& t)
+{
+    throw omnetpp::cRuntimeError("Parsim error: No doParsimUnpacking() function for type %s", omnetpp::opp_typename(typeid(t)));
+}
+
+}  // namespace omnetpp
+
+
+// forward
+template<typename T, typename A>
+std::ostream& operator<<(std::ostream& out, const std::vector<T,A>& vec);
+
+// Template rule which fires if a struct or class doesn't have operator<<
+template<typename T>
+inline std::ostream& operator<<(std::ostream& out,const T&) {return out;}
+
+// operator<< for std::vector<T>
+template<typename T, typename A>
+inline std::ostream& operator<<(std::ostream& out, const std::vector<T,A>& vec)
+{
+    out.put('{');
+    for(typename std::vector<T,A>::const_iterator it = vec.begin(); it != vec.end(); ++it)
+    {
+        if (it != vec.begin()) {
+            out.put(','); out.put(' ');
+        }
+        out << *it;
+    }
+    out.put('}');
+    
+    char buf[32];
+    sprintf(buf, " (size=%u)", (unsigned int)vec.size());
+    out.write(buf, strlen(buf));
+    return out;
+}
+
+Register_Class(Max_Stream_Data)
+
+Max_Stream_Data::Max_Stream_Data() : ::omnetpp::cObject()
+{
+    this->type = 5;
+    this->stream_Id = 0;
+    this->maximum_Stream_Data = 0;
+}
+
+Max_Stream_Data::Max_Stream_Data(const Max_Stream_Data& other) : ::omnetpp::cObject(other)
+{
+    copy(other);
+}
+
+Max_Stream_Data::~Max_Stream_Data()
+{
+}
+
+Max_Stream_Data& Max_Stream_Data::operator=(const Max_Stream_Data& other)
+{
+    if (this==&other) return *this;
+    ::omnetpp::cObject::operator=(other);
+    copy(other);
+    return *this;
+}
+
+void Max_Stream_Data::copy(const Max_Stream_Data& other)
+{
+    this->type = other.type;
+    this->stream_Id = other.stream_Id;
+    this->maximum_Stream_Data = other.maximum_Stream_Data;
+}
+
+void Max_Stream_Data::parsimPack(omnetpp::cCommBuffer *b) const
+{
+    doParsimPacking(b,this->type);
+    doParsimPacking(b,this->stream_Id);
+    doParsimPacking(b,this->maximum_Stream_Data);
+}
+
+void Max_Stream_Data::parsimUnpack(omnetpp::cCommBuffer *b)
+{
+    doParsimUnpacking(b,this->type);
+    doParsimUnpacking(b,this->stream_Id);
+    doParsimUnpacking(b,this->maximum_Stream_Data);
+}
+
+uint8_t Max_Stream_Data::getType() const
+{
+    return this->type;
+}
+
+void Max_Stream_Data::setType(uint8_t type)
+{
+    this->type = type;
+}
+
+uint32_t Max_Stream_Data::getStream_Id() const
+{
+    return this->stream_Id;
+}
+
+void Max_Stream_Data::setStream_Id(uint32_t stream_Id)
+{
+    this->stream_Id = stream_Id;
+}
+
+uint64_t Max_Stream_Data::getMaximum_Stream_Data() const
+{
+    return this->maximum_Stream_Data;
+}
+
+void Max_Stream_Data::setMaximum_Stream_Data(uint64_t maximum_Stream_Data)
+{
+    this->maximum_Stream_Data = maximum_Stream_Data;
+}
+
+class Max_Stream_DataDescriptor : public omnetpp::cClassDescriptor
+{
+  private:
+    mutable const char **propertynames;
+  public:
+    Max_Stream_DataDescriptor();
+    virtual ~Max_Stream_DataDescriptor();
+
+    virtual bool doesSupport(omnetpp::cObject *obj) const override;
+    virtual const char **getPropertyNames() const override;
+    virtual const char *getProperty(const char *propertyname) const override;
+    virtual int getFieldCount() const override;
+    virtual const char *getFieldName(int field) const override;
+    virtual int findField(const char *fieldName) const override;
+    virtual unsigned int getFieldTypeFlags(int field) const override;
+    virtual const char *getFieldTypeString(int field) const override;
+    virtual const char **getFieldPropertyNames(int field) const override;
+    virtual const char *getFieldProperty(int field, const char *propertyname) const override;
+    virtual int getFieldArraySize(void *object, int field) const override;
+
+    virtual const char *getFieldDynamicTypeString(void *object, int field, int i) const override;
+    virtual std::string getFieldValueAsString(void *object, int field, int i) const override;
+    virtual bool setFieldValueAsString(void *object, int field, int i, const char *value) const override;
+
+    virtual const char *getFieldStructName(int field) const override;
+    virtual void *getFieldStructValuePointer(void *object, int field, int i) const override;
+};
+
+Register_ClassDescriptor(Max_Stream_DataDescriptor)
+
+Max_Stream_DataDescriptor::Max_Stream_DataDescriptor() : omnetpp::cClassDescriptor("Max_Stream_Data", "omnetpp::cObject")
+{
+    propertynames = nullptr;
+}
+
+Max_Stream_DataDescriptor::~Max_Stream_DataDescriptor()
+{
+    delete[] propertynames;
+}
+
+bool Max_Stream_DataDescriptor::doesSupport(omnetpp::cObject *obj) const
+{
+    return dynamic_cast<Max_Stream_Data *>(obj)!=nullptr;
+}
+
+const char **Max_Stream_DataDescriptor::getPropertyNames() const
+{
+    if (!propertynames) {
+        static const char *names[] = {  nullptr };
+        omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
+        const char **basenames = basedesc ? basedesc->getPropertyNames() : nullptr;
+        propertynames = mergeLists(basenames, names);
+    }
+    return propertynames;
+}
+
+const char *Max_Stream_DataDescriptor::getProperty(const char *propertyname) const
+{
+    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
+    return basedesc ? basedesc->getProperty(propertyname) : nullptr;
+}
+
+int Max_Stream_DataDescriptor::getFieldCount() const
+{
+    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
+    return basedesc ? 3+basedesc->getFieldCount() : 3;
+}
+
+unsigned int Max_Stream_DataDescriptor::getFieldTypeFlags(int field) const
+{
+    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
+    if (basedesc) {
+        if (field < basedesc->getFieldCount())
+            return basedesc->getFieldTypeFlags(field);
+        field -= basedesc->getFieldCount();
+    }
+    static unsigned int fieldTypeFlags[] = {
+        FD_ISEDITABLE,
+        FD_ISEDITABLE,
+        FD_ISEDITABLE,
+    };
+    return (field>=0 && field<3) ? fieldTypeFlags[field] : 0;
+}
+
+const char *Max_Stream_DataDescriptor::getFieldName(int field) const
+{
+    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
+    if (basedesc) {
+        if (field < basedesc->getFieldCount())
+            return basedesc->getFieldName(field);
+        field -= basedesc->getFieldCount();
+    }
+    static const char *fieldNames[] = {
+        "type",
+        "stream_Id",
+        "maximum_Stream_Data",
+    };
+    return (field>=0 && field<3) ? fieldNames[field] : nullptr;
+}
+
+int Max_Stream_DataDescriptor::findField(const char *fieldName) const
+{
+    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
+    int base = basedesc ? basedesc->getFieldCount() : 0;
+    if (fieldName[0]=='t' && strcmp(fieldName, "type")==0) return base+0;
+    if (fieldName[0]=='s' && strcmp(fieldName, "stream_Id")==0) return base+1;
+    if (fieldName[0]=='m' && strcmp(fieldName, "maximum_Stream_Data")==0) return base+2;
+    return basedesc ? basedesc->findField(fieldName) : -1;
+}
+
+const char *Max_Stream_DataDescriptor::getFieldTypeString(int field) const
+{
+    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
+    if (basedesc) {
+        if (field < basedesc->getFieldCount())
+            return basedesc->getFieldTypeString(field);
+        field -= basedesc->getFieldCount();
+    }
+    static const char *fieldTypeStrings[] = {
+        "uint8_t",
+        "uint32_t",
+        "uint64_t",
+    };
+    return (field>=0 && field<3) ? fieldTypeStrings[field] : nullptr;
+}
+
+const char **Max_Stream_DataDescriptor::getFieldPropertyNames(int field) const
+{
+    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
+    if (basedesc) {
+        if (field < basedesc->getFieldCount())
+            return basedesc->getFieldPropertyNames(field);
+        field -= basedesc->getFieldCount();
+    }
+    switch (field) {
+        default: return nullptr;
+    }
+}
+
+const char *Max_Stream_DataDescriptor::getFieldProperty(int field, const char *propertyname) const
+{
+    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
+    if (basedesc) {
+        if (field < basedesc->getFieldCount())
+            return basedesc->getFieldProperty(field, propertyname);
+        field -= basedesc->getFieldCount();
+    }
+    switch (field) {
+        default: return nullptr;
+    }
+}
+
+int Max_Stream_DataDescriptor::getFieldArraySize(void *object, int field) const
+{
+    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
+    if (basedesc) {
+        if (field < basedesc->getFieldCount())
+            return basedesc->getFieldArraySize(object, field);
+        field -= basedesc->getFieldCount();
+    }
+    Max_Stream_Data *pp = (Max_Stream_Data *)object; (void)pp;
+    switch (field) {
+        default: return 0;
+    }
+}
+
+const char *Max_Stream_DataDescriptor::getFieldDynamicTypeString(void *object, int field, int i) const
+{
+    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
+    if (basedesc) {
+        if (field < basedesc->getFieldCount())
+            return basedesc->getFieldDynamicTypeString(object,field,i);
+        field -= basedesc->getFieldCount();
+    }
+    Max_Stream_Data *pp = (Max_Stream_Data *)object; (void)pp;
+    switch (field) {
+        default: return nullptr;
+    }
+}
+
+std::string Max_Stream_DataDescriptor::getFieldValueAsString(void *object, int field, int i) const
+{
+    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
+    if (basedesc) {
+        if (field < basedesc->getFieldCount())
+            return basedesc->getFieldValueAsString(object,field,i);
+        field -= basedesc->getFieldCount();
+    }
+    Max_Stream_Data *pp = (Max_Stream_Data *)object; (void)pp;
+    switch (field) {
+        case 0: return ulong2string(pp->getType());
+        case 1: return ulong2string(pp->getStream_Id());
+        case 2: return uint642string(pp->getMaximum_Stream_Data());
+        default: return "";
+    }
+}
+
+bool Max_Stream_DataDescriptor::setFieldValueAsString(void *object, int field, int i, const char *value) const
+{
+    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
+    if (basedesc) {
+        if (field < basedesc->getFieldCount())
+            return basedesc->setFieldValueAsString(object,field,i,value);
+        field -= basedesc->getFieldCount();
+    }
+    Max_Stream_Data *pp = (Max_Stream_Data *)object; (void)pp;
+    switch (field) {
+        case 0: pp->setType(string2ulong(value)); return true;
+        case 1: pp->setStream_Id(string2ulong(value)); return true;
+        case 2: pp->setMaximum_Stream_Data(string2uint64(value)); return true;
+        default: return false;
+    }
+}
+
+const char *Max_Stream_DataDescriptor::getFieldStructName(int field) const
+{
+    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
+    if (basedesc) {
+        if (field < basedesc->getFieldCount())
+            return basedesc->getFieldStructName(field);
+        field -= basedesc->getFieldCount();
+    }
+    switch (field) {
+        default: return nullptr;
+    };
+}
+
+void *Max_Stream_DataDescriptor::getFieldStructValuePointer(void *object, int field, int i) const
+{
+    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
+    if (basedesc) {
+        if (field < basedesc->getFieldCount())
+            return basedesc->getFieldStructValuePointer(object, field, i);
+        field -= basedesc->getFieldCount();
+    }
+    Max_Stream_Data *pp = (Max_Stream_Data *)object; (void)pp;
+    switch (field) {
+        default: return nullptr;
+    }
+}
+
+

QUIC/Frames/max_Stream_Data_m.h

@@ -0,0 +1,72 @@
+//
+// Generated file, do not edit! Created by nedtool 5.2 from Frames/max_Stream_Data.msg.
+//
+
+#if defined(__clang__)
+#  pragma clang diagnostic ignored "-Wreserved-id-macro"
+#endif
+#ifndef __MAX_STREAM_DATA_M_H
+#define __MAX_STREAM_DATA_M_H
+
+#include <omnetpp.h>
+
+// nedtool version check
+#define MSGC_VERSION 0x0502
+#if (MSGC_VERSION!=OMNETPP_VERSION)
+#    error Version mismatch! Probably this file was generated by an earlier version of nedtool: 'make clean' should help.
+#endif
+
+
+
+/**
+ * Class generated from <tt>Frames/max_Stream_Data.msg:19</tt> by nedtool.
+ * <pre>
+ * //
+ * // TODO generated message class
+ * //
+ * class Max_Stream_Data
+ * {
+ *     uint8_t type = 5;
+ *     uint32_t stream_Id;
+ *     uint64_t maximum_Stream_Data;
+ * }
+ * </pre>
+ */
+class Max_Stream_Data : public ::omnetpp::cObject
+{
+  protected:
+    uint8_t type;
+    uint32_t stream_Id;
+    uint64_t maximum_Stream_Data;
+
+  private:
+    void copy(const Max_Stream_Data& other);
+
+  protected:
+    // protected and unimplemented operator==(), to prevent accidental usage
+    bool operator==(const Max_Stream_Data&);
+
+  public:
+    Max_Stream_Data();
+    Max_Stream_Data(const Max_Stream_Data& other);
+    virtual ~Max_Stream_Data();
+    Max_Stream_Data& operator=(const Max_Stream_Data& other);
+    virtual Max_Stream_Data *dup() const override {return new Max_Stream_Data(*this);}
+    virtual void parsimPack(omnetpp::cCommBuffer *b) const override;
+    virtual void parsimUnpack(omnetpp::cCommBuffer *b) override;
+
+    // field getter/setter methods
+    virtual uint8_t getType() const;
+    virtual void setType(uint8_t type);
+    virtual uint32_t getStream_Id() const;
+    virtual void setStream_Id(uint32_t stream_Id);
+    virtual uint64_t getMaximum_Stream_Data() const;
+    virtual void setMaximum_Stream_Data(uint64_t maximum_Stream_Data);
+};
+
+inline void doParsimPacking(omnetpp::cCommBuffer *b, const Max_Stream_Data& obj) {obj.parsimPack(b);}
+inline void doParsimUnpacking(omnetpp::cCommBuffer *b, Max_Stream_Data& obj) {obj.parsimUnpack(b);}
+
+
+#endif // ifndef __MAX_STREAM_DATA_M_H
+

QUIC/Frames/max_Stream_Id.msg

@@ -0,0 +1,22 @@
+//
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Lesser General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+// 
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU Lesser General Public License for more details.
+// 
+// You should have received a copy of the GNU Lesser General Public License
+// along with this program.  If not, see http://www.gnu.org/licenses/.
+// 
+
+//
+// TODO generated message class
+//
+class Max_Stream_Id {
+    uint8_t type = 6;
+    uint32_t maximum_Stream_Id;
+}

QUIC/Frames/max_Stream_Id_m.cc

@@ -0,0 +1,478 @@
+//
+// Generated file, do not edit! Created by nedtool 5.2 from Frames/max_Stream_Id.msg.
+//
+
+// Disable warnings about unused variables, empty switch stmts, etc:
+#ifdef _MSC_VER
+#  pragma warning(disable:4101)
+#  pragma warning(disable:4065)
+#endif
+
+#if defined(__clang__)
+#  pragma clang diagnostic ignored "-Wshadow"
+#  pragma clang diagnostic ignored "-Wconversion"
+#  pragma clang diagnostic ignored "-Wunused-parameter"
+#  pragma clang diagnostic ignored "-Wc++98-compat"
+#  pragma clang diagnostic ignored "-Wunreachable-code-break"
+#  pragma clang diagnostic ignored "-Wold-style-cast"
+#elif defined(__GNUC__)
+#  pragma GCC diagnostic ignored "-Wshadow"
+#  pragma GCC diagnostic ignored "-Wconversion"
+#  pragma GCC diagnostic ignored "-Wunused-parameter"
+#  pragma GCC diagnostic ignored "-Wold-style-cast"
+#  pragma GCC diagnostic ignored "-Wsuggest-attribute=noreturn"
+#  pragma GCC diagnostic ignored "-Wfloat-conversion"
+#endif
+
+#include <iostream>
+#include <sstream>
+#include "max_Stream_Id_m.h"
+
+namespace omnetpp {
+
+// Template pack/unpack rules. They are declared *after* a1l type-specific pack functions for multiple reasons.
+// They are in the omnetpp namespace, to allow them to be found by argument-dependent lookup via the cCommBuffer argument
+
+// Packing/unpacking an std::vector
+template<typename T, typename A>
+void doParsimPacking(omnetpp::cCommBuffer *buffer, const std::vector<T,A>& v)
+{
+    int n = v.size();
+    doParsimPacking(buffer, n);
+    for (int i = 0; i < n; i++)
+        doParsimPacking(buffer, v[i]);
+}
+
+template<typename T, typename A>
+void doParsimUnpacking(omnetpp::cCommBuffer *buffer, std::vector<T,A>& v)
+{
+    int n;
+    doParsimUnpacking(buffer, n);
+    v.resize(n);
+    for (int i = 0; i < n; i++)
+        doParsimUnpacking(buffer, v[i]);
+}
+
+// Packing/unpacking an std::list
+template<typename T, typename A>
+void doParsimPacking(omnetpp::cCommBuffer *buffer, const std::list<T,A>& l)
+{
+    doParsimPacking(buffer, (int)l.size());
+    for (typename std::list<T,A>::const_iterator it = l.begin(); it != l.end(); ++it)
+        doParsimPacking(buffer, (T&)*it);
+}
+
+template<typename T, typename A>
+void doParsimUnpacking(omnetpp::cCommBuffer *buffer, std::list<T,A>& l)
+{
+    int n;
+    doParsimUnpacking(buffer, n);
+    for (int i=0; i<n; i++) {
+        l.push_back(T());
+        doParsimUnpacking(buffer, l.back());
+    }
+}
+
+// Packing/unpacking an std::set
+template<typename T, typename Tr, typename A>
+void doParsimPacking(omnetpp::cCommBuffer *buffer, const std::set<T,Tr,A>& s)
+{
+    doParsimPacking(buffer, (int)s.size());
+    for (typename std::set<T,Tr,A>::const_iterator it = s.begin(); it != s.end(); ++it)
+        doParsimPacking(buffer, *it);
+}
+
+template<typename T, typename Tr, typename A>
+void doParsimUnpacking(omnetpp::cCommBuffer *buffer, std::set<T,Tr,A>& s)
+{
+    int n;
+    doParsimUnpacking(buffer, n);
+    for (int i=0; i<n; i++) {
+        T x;
+        doParsimUnpacking(buffer, x);
+        s.insert(x);
+    }
+}
+
+// Packing/unpacking an std::map
+template<typename K, typename V, typename Tr, typename A>
+void doParsimPacking(omnetpp::cCommBuffer *buffer, const std::map<K,V,Tr,A>& m)
+{
+    doParsimPacking(buffer, (int)m.size());
+    for (typename std::map<K,V,Tr,A>::const_iterator it = m.begin(); it != m.end(); ++it) {
+        doParsimPacking(buffer, it->first);
+        doParsimPacking(buffer, it->second);
+    }
+}
+
+template<typename K, typename V, typename Tr, typename A>
+void doParsimUnpacking(omnetpp::cCommBuffer *buffer, std::map<K,V,Tr,A>& m)
+{
+    int n;
+    doParsimUnpacking(buffer, n);
+    for (int i=0; i<n; i++) {
+        K k; V v;
+        doParsimUnpacking(buffer, k);
+        doParsimUnpacking(buffer, v);
+        m[k] = v;
+    }
+}
+
+// Default pack/unpack function for arrays
+template<typename T>
+void doParsimArrayPacking(omnetpp::cCommBuffer *b, const T *t, int n)
+{
+    for (int i = 0; i < n; i++)
+        doParsimPacking(b, t[i]);
+}
+
+template<typename T>
+void doParsimArrayUnpacking(omnetpp::cCommBuffer *b, T *t, int n)
+{
+    for (int i = 0; i < n; i++)
+        doParsimUnpacking(b, t[i]);
+}
+
+// Default rule to prevent compiler from choosing base class' doParsimPacking() function
+template<typename T>
+void doParsimPacking(omnetpp::cCommBuffer *, const T& t)
+{
+    throw omnetpp::cRuntimeError("Parsim error: No doParsimPacking() function for type %s", omnetpp::opp_typename(typeid(t)));
+}
+
+template<typename T>
+void doParsimUnpacking(omnetpp::cCommBuffer *, T& t)
+{
+    throw omnetpp::cRuntimeError("Parsim error: No doParsimUnpacking() function for type %s", omnetpp::opp_typename(typeid(t)));
+}
+
+}  // namespace omnetpp
+
+
+// forward
+template<typename T, typename A>
+std::ostream& operator<<(std::ostream& out, const std::vector<T,A>& vec);
+
+// Template rule which fires if a struct or class doesn't have operator<<
+template<typename T>
+inline std::ostream& operator<<(std::ostream& out,const T&) {return out;}
+
+// operator<< for std::vector<T>
+template<typename T, typename A>
+inline std::ostream& operator<<(std::ostream& out, const std::vector<T,A>& vec)
+{
+    out.put('{');
+    for(typename std::vector<T,A>::const_iterator it = vec.begin(); it != vec.end(); ++it)
+    {
+        if (it != vec.begin()) {
+            out.put(','); out.put(' ');
+        }
+        out << *it;
+    }
+    out.put('}');
+    
+    char buf[32];
+    sprintf(buf, " (size=%u)", (unsigned int)vec.size());
+    out.write(buf, strlen(buf));
+    return out;
+}
+
+Register_Class(Max_Stream_Id)
+
+Max_Stream_Id::Max_Stream_Id() : ::omnetpp::cObject()
+{
+    this->type = 6;
+    this->maximum_Stream_Id = 0;
+}
+
+Max_Stream_Id::Max_Stream_Id(const Max_Stream_Id& other) : ::omnetpp::cObject(other)
+{
+    copy(other);
+}
+
+Max_Stream_Id::~Max_Stream_Id()
+{
+}
+
+Max_Stream_Id& Max_Stream_Id::operator=(const Max_Stream_Id& other)
+{
+    if (this==&other) return *this;
+    ::omnetpp::cObject::operator=(other);
+    copy(other);
+    return *this;
+}
+
+void Max_Stream_Id::copy(const Max_Stream_Id& other)
+{
+    this->type = other.type;
+    this->maximum_Stream_Id = other.maximum_Stream_Id;
+}
+
+void Max_Stream_Id::parsimPack(omnetpp::cCommBuffer *b) const
+{
+    doParsimPacking(b,this->type);
+    doParsimPacking(b,this->maximum_Stream_Id);
+}
+
+void Max_Stream_Id::parsimUnpack(omnetpp::cCommBuffer *b)
+{
+    doParsimUnpacking(b,this->type);
+    doParsimUnpacking(b,this->maximum_Stream_Id);
+}
+
+uint8_t Max_Stream_Id::getType() const
+{
+    return this->type;
+}
+
+void Max_Stream_Id::setType(uint8_t type)
+{
+    this->type = type;
+}
+
+uint32_t Max_Stream_Id::getMaximum_Stream_Id() const
+{
+    return this->maximum_Stream_Id;
+}
+
+void Max_Stream_Id::setMaximum_Stream_Id(uint32_t maximum_Stream_Id)
+{
+    this->maximum_Stream_Id = maximum_Stream_Id;
+}
+
+class Max_Stream_IdDescriptor : public omnetpp::cClassDescriptor
+{
+  private:
+    mutable const char **propertynames;
+  public:
+    Max_Stream_IdDescriptor();
+    virtual ~Max_Stream_IdDescriptor();
+
+    virtual bool doesSupport(omnetpp::cObject *obj) const override;
+    virtual const char **getPropertyNames() const override;
+    virtual const char *getProperty(const char *propertyname) const override;
+    virtual int getFieldCount() const override;
+    virtual const char *getFieldName(int field) const override;
+    virtual int findField(const char *fieldName) const override;
+    virtual unsigned int getFieldTypeFlags(int field) const override;
+    virtual const char *getFieldTypeString(int field) const override;
+    virtual const char **getFieldPropertyNames(int field) const override;
+    virtual const char *getFieldProperty(int field, const char *propertyname) const override;
+    virtual int getFieldArraySize(void *object, int field) const override;
+
+    virtual const char *getFieldDynamicTypeString(void *object, int field, int i) const override;
+    virtual std::string getFieldValueAsString(void *object, int field, int i) const override;
+    virtual bool setFieldValueAsString(void *object, int field, int i, const char *value) const override;
+
+    virtual const char *getFieldStructName(int field) const override;
+    virtual void *getFieldStructValuePointer(void *object, int field, int i) const override;
+};
+
+Register_ClassDescriptor(Max_Stream_IdDescriptor)
+
+Max_Stream_IdDescriptor::Max_Stream_IdDescriptor() : omnetpp::cClassDescriptor("Max_Stream_Id", "omnetpp::cObject")
+{
+    propertynames = nullptr;
+}
+
+Max_Stream_IdDescriptor::~Max_Stream_IdDescriptor()
+{
+    delete[] propertynames;
+}
+
+bool Max_Stream_IdDescriptor::doesSupport(omnetpp::cObject *obj) const
+{
+    return dynamic_cast<Max_Stream_Id *>(obj)!=nullptr;
+}
+
+const char **Max_Stream_IdDescriptor::getPropertyNames() const
+{
+    if (!propertynames) {
+        static const char *names[] = {  nullptr };
+        omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
+        const char **basenames = basedesc ? basedesc->getPropertyNames() : nullptr;
+        propertynames = mergeLists(basenames, names);
+    }
+    return propertynames;
+}
+
+const char *Max_Stream_IdDescriptor::getProperty(const char *propertyname) const
+{
+    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
+    return basedesc ? basedesc->getProperty(propertyname) : nullptr;
+}
+
+int Max_Stream_IdDescriptor::getFieldCount() const
+{
+    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
+    return basedesc ? 2+basedesc->getFieldCount() : 2;
+}
+
+unsigned int Max_Stream_IdDescriptor::getFieldTypeFlags(int field) const
+{
+    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
+    if (basedesc) {
+        if (field < basedesc->getFieldCount())
+            return basedesc->getFieldTypeFlags(field);
+        field -= basedesc->getFieldCount();
+    }
+    static unsigned int fieldTypeFlags[] = {
+        FD_ISEDITABLE,
+        FD_ISEDITABLE,
+    };
+    return (field>=0 && field<2) ? fieldTypeFlags[field] : 0;
+}
+
+const char *Max_Stream_IdDescriptor::getFieldName(int field) const
+{
+    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
+    if (basedesc) {
+        if (field < basedesc->getFieldCount())
+            return basedesc->getFieldName(field);
+        field -= basedesc->getFieldCount();
+    }
+    static const char *fieldNames[] = {
+        "type",
+        "maximum_Stream_Id",
+    };
+    return (field>=0 && field<2) ? fieldNames[field] : nullptr;
+}
+
+int Max_Stream_IdDescriptor::findField(const char *fieldName) const
+{
+    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
+    int base = basedesc ? basedesc->getFieldCount() : 0;
+    if (fieldName[0]=='t' && strcmp(fieldName, "type")==0) return base+0;
+    if (fieldName[0]=='m' && strcmp(fieldName, "maximum_Stream_Id")==0) return base+1;
+    return basedesc ? basedesc->findField(fieldName) : -1;
+}
+
+const char *Max_Stream_IdDescriptor::getFieldTypeString(int field) const
+{
+    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
+    if (basedesc) {
+        if (field < basedesc->getFieldCount())
+            return basedesc->getFieldTypeString(field);
+        field -= basedesc->getFieldCount();
+    }
+    static const char *fieldTypeStrings[] = {
+        "uint8_t",
+        "uint32_t",
+    };
+    return (field>=0 && field<2) ? fieldTypeStrings[field] : nullptr;
+}
+
+const char **Max_Stream_IdDescriptor::getFieldPropertyNames(int field) const
+{
+    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
+    if (basedesc) {
+        if (field < basedesc->getFieldCount())
+            return basedesc->getFieldPropertyNames(field);
+        field -= basedesc->getFieldCount();
+    }
+    switch (field) {
+        default: return nullptr;
+    }
+}
+
+const char *Max_Stream_IdDescriptor::getFieldProperty(int field, const char *propertyname) const
+{
+    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
+    if (basedesc) {
+        if (field < basedesc->getFieldCount())
+            return basedesc->getFieldProperty(field, propertyname);
+        field -= basedesc->getFieldCount();
+    }
+    switch (field) {
+        default: return nullptr;
+    }
+}
+
+int Max_Stream_IdDescriptor::getFieldArraySize(void *object, int field) const
+{
+    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
+    if (basedesc) {
+        if (field < basedesc->getFieldCount())
+            return basedesc->getFieldArraySize(object, field);
+        field -= basedesc->getFieldCount();
+    }
+    Max_Stream_Id *pp = (Max_Stream_Id *)object; (void)pp;
+    switch (field) {
+        default: return 0;
+    }
+}
+
+const char *Max_Stream_IdDescriptor::getFieldDynamicTypeString(void *object, int field, int i) const
+{
+    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
+    if (basedesc) {
+        if (field < basedesc->getFieldCount())
+            return basedesc->getFieldDynamicTypeString(object,field,i);
+        field -= basedesc->getFieldCount();
+    }
+    Max_Stream_Id *pp = (Max_Stream_Id *)object; (void)pp;
+    switch (field) {
+        default: return nullptr;
+    }
+}
+
+std::string Max_Stream_IdDescriptor::getFieldValueAsString(void *object, int field, int i) const
+{
+    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
+    if (basedesc) {
+        if (field < basedesc->getFieldCount())
+            return basedesc->getFieldValueAsString(object,field,i);
+        field -= basedesc->getFieldCount();
+    }
+    Max_Stream_Id *pp = (Max_Stream_Id *)object; (void)pp;
+    switch (field) {
+        case 0: return ulong2string(pp->getType());
+        case 1: return ulong2string(pp->getMaximum_Stream_Id());
+        default: return "";
+    }
+}
+
+bool Max_Stream_IdDescriptor::setFieldValueAsString(void *object, int field, int i, const char *value) const
+{
+    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
+    if (basedesc) {
+        if (field < basedesc->getFieldCount())
+            return basedesc->setFieldValueAsString(object,field,i,value);
+        field -= basedesc->getFieldCount();
+    }
+    Max_Stream_Id *pp = (Max_Stream_Id *)object; (void)pp;
+    switch (field) {
+        case 0: pp->setType(string2ulong(value)); return true;
+        case 1: pp->setMaximum_Stream_Id(string2ulong(value)); return true;
+        default: return false;
+    }
+}
+
+const char *Max_Stream_IdDescriptor::getFieldStructName(int field) const
+{
+    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
+    if (basedesc) {
+        if (field < basedesc->getFieldCount())
+            return basedesc->getFieldStructName(field);
+        field -= basedesc->getFieldCount();
+    }
+    switch (field) {
+        default: return nullptr;
+    };
+}
+
+void *Max_Stream_IdDescriptor::getFieldStructValuePointer(void *object, int field, int i) const
+{
+    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
+    if (basedesc) {
+        if (field < basedesc->getFieldCount())
+            return basedesc->getFieldStructValuePointer(object, field, i);
+        field -= basedesc->getFieldCount();
+    }
+    Max_Stream_Id *pp = (Max_Stream_Id *)object; (void)pp;
+    switch (field) {
+        default: return nullptr;
+    }
+}
+
+

QUIC/Frames/max_Stream_Id_m.h

@@ -0,0 +1,68 @@
+//
+// Generated file, do not edit! Created by nedtool 5.2 from Frames/max_Stream_Id.msg.
+//
+
+#if defined(__clang__)
+#  pragma clang diagnostic ignored "-Wreserved-id-macro"
+#endif
+#ifndef __MAX_STREAM_ID_M_H
+#define __MAX_STREAM_ID_M_H
+
+#include <omnetpp.h>
+
+// nedtool version check
+#define MSGC_VERSION 0x0502
+#if (MSGC_VERSION!=OMNETPP_VERSION)
+#    error Version mismatch! Probably this file was generated by an earlier version of nedtool: 'make clean' should help.
+#endif
+
+
+
+/**
+ * Class generated from <tt>Frames/max_Stream_Id.msg:19</tt> by nedtool.
+ * <pre>
+ * //
+ * // TODO generated message class
+ * //
+ * class Max_Stream_Id
+ * {
+ *     uint8_t type = 6;
+ *     uint32_t maximum_Stream_Id;
+ * }
+ * </pre>
+ */
+class Max_Stream_Id : public ::omnetpp::cObject
+{
+  protected:
+    uint8_t type;
+    uint32_t maximum_Stream_Id;
+
+  private:
+    void copy(const Max_Stream_Id& other);
+
+  protected:
+    // protected and unimplemented operator==(), to prevent accidental usage
+    bool operator==(const Max_Stream_Id&);
+
+  public:
+    Max_Stream_Id();
+    Max_Stream_Id(const Max_Stream_Id& other);
+    virtual ~Max_Stream_Id();
+    Max_Stream_Id& operator=(const Max_Stream_Id& other);
+    virtual Max_Stream_Id *dup() const override {return new Max_Stream_Id(*this);}
+    virtual void parsimPack(omnetpp::cCommBuffer *b) const override;
+    virtual void parsimUnpack(omnetpp::cCommBuffer *b) override;
+
+    // field getter/setter methods
+    virtual uint8_t getType() const;
+    virtual void setType(uint8_t type);
+    virtual uint32_t getMaximum_Stream_Id() const;
+    virtual void setMaximum_Stream_Id(uint32_t maximum_Stream_Id);
+};
+
+inline void doParsimPacking(omnetpp::cCommBuffer *b, const Max_Stream_Id& obj) {obj.parsimPack(b);}
+inline void doParsimUnpacking(omnetpp::cCommBuffer *b, Max_Stream_Id& obj) {obj.parsimUnpack(b);}
+
+
+#endif // ifndef __MAX_STREAM_ID_M_H
+

QUIC/Frames/new_Connection_Id.msg

@@ -0,0 +1,31 @@
+//
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Lesser General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+// 
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU Lesser General Public License for more details.
+// 
+// You should have received a copy of the GNU Lesser General Public License
+// along with this program.  If not, see http://www.gnu.org/licenses/.
+// 
+
+//
+// TODO generated message class
+//
+cplusplus{{
+  	#include <vector>
+  	typedef std::vector<uint64_t> SRT;	
+}};
+
+class noncobject SRT;
+
+class New_Connection_Id {
+	uint8_t type = 11;
+	uint16_t sequence;
+	uint64_t connection_Id;
+	SRT stateless_Reset_Token;	
+}

QUIC/Frames/new_Connection_Id_m.cc

@@ -0,0 +1,518 @@
+//
+// Generated file, do not edit! Created by nedtool 5.2 from Frames/new_Connection_Id.msg.
+//
+
+// Disable warnings about unused variables, empty switch stmts, etc:
+#ifdef _MSC_VER
+#  pragma warning(disable:4101)
+#  pragma warning(disable:4065)
+#endif
+
+#if defined(__clang__)
+#  pragma clang diagnostic ignored "-Wshadow"
+#  pragma clang diagnostic ignored "-Wconversion"
+#  pragma clang diagnostic ignored "-Wunused-parameter"
+#  pragma clang diagnostic ignored "-Wc++98-compat"
+#  pragma clang diagnostic ignored "-Wunreachable-code-break"
+#  pragma clang diagnostic ignored "-Wold-style-cast"
+#elif defined(__GNUC__)
+#  pragma GCC diagnostic ignored "-Wshadow"
+#  pragma GCC diagnostic ignored "-Wconversion"
+#  pragma GCC diagnostic ignored "-Wunused-parameter"
+#  pragma GCC diagnostic ignored "-Wold-style-cast"
+#  pragma GCC diagnostic ignored "-Wsuggest-attribute=noreturn"
+#  pragma GCC diagnostic ignored "-Wfloat-conversion"
+#endif
+
+#include <iostream>
+#include <sstream>
+#include "new_Connection_Id_m.h"
+
+namespace omnetpp {
+
+// Template pack/unpack rules. They are declared *after* a1l type-specific pack functions for multiple reasons.
+// They are in the omnetpp namespace, to allow them to be found by argument-dependent lookup via the cCommBuffer argument
+
+// Packing/unpacking an std::vector
+template<typename T, typename A>
+void doParsimPacking(omnetpp::cCommBuffer *buffer, const std::vector<T,A>& v)
+{
+    int n = v.size();
+    doParsimPacking(buffer, n);
+    for (int i = 0; i < n; i++)
+        doParsimPacking(buffer, v[i]);
+}
+
+template<typename T, typename A>
+void doParsimUnpacking(omnetpp::cCommBuffer *buffer, std::vector<T,A>& v)
+{
+    int n;
+    doParsimUnpacking(buffer, n);
+    v.resize(n);
+    for (int i = 0; i < n; i++)
+        doParsimUnpacking(buffer, v[i]);
+}
+
+// Packing/unpacking an std::list
+template<typename T, typename A>
+void doParsimPacking(omnetpp::cCommBuffer *buffer, const std::list<T,A>& l)
+{
+    doParsimPacking(buffer, (int)l.size());
+    for (typename std::list<T,A>::const_iterator it = l.begin(); it != l.end(); ++it)
+        doParsimPacking(buffer, (T&)*it);
+}
+
+template<typename T, typename A>
+void doParsimUnpacking(omnetpp::cCommBuffer *buffer, std::list<T,A>& l)
+{
+    int n;
+    doParsimUnpacking(buffer, n);
+    for (int i=0; i<n; i++) {
+        l.push_back(T());
+        doParsimUnpacking(buffer, l.back());
+    }
+}
+
+// Packing/unpacking an std::set
+template<typename T, typename Tr, typename A>
+void doParsimPacking(omnetpp::cCommBuffer *buffer, const std::set<T,Tr,A>& s)
+{
+    doParsimPacking(buffer, (int)s.size());
+    for (typename std::set<T,Tr,A>::const_iterator it = s.begin(); it != s.end(); ++it)
+        doParsimPacking(buffer, *it);
+}
+
+template<typename T, typename Tr, typename A>
+void doParsimUnpacking(omnetpp::cCommBuffer *buffer, std::set<T,Tr,A>& s)
+{
+    int n;
+    doParsimUnpacking(buffer, n);
+    for (int i=0; i<n; i++) {
+        T x;
+        doParsimUnpacking(buffer, x);
+        s.insert(x);
+    }
+}
+
+// Packing/unpacking an std::map
+template<typename K, typename V, typename Tr, typename A>
+void doParsimPacking(omnetpp::cCommBuffer *buffer, const std::map<K,V,Tr,A>& m)
+{
+    doParsimPacking(buffer, (int)m.size());
+    for (typename std::map<K,V,Tr,A>::const_iterator it = m.begin(); it != m.end(); ++it) {
+        doParsimPacking(buffer, it->first);
+        doParsimPacking(buffer, it->second);
+    }
+}
+
+template<typename K, typename V, typename Tr, typename A>
+void doParsimUnpacking(omnetpp::cCommBuffer *buffer, std::map<K,V,Tr,A>& m)
+{
+    int n;
+    doParsimUnpacking(buffer, n);
+    for (int i=0; i<n; i++) {
+        K k; V v;
+        doParsimUnpacking(buffer, k);
+        doParsimUnpacking(buffer, v);
+        m[k] = v;
+    }
+}
+
+// Default pack/unpack function for arrays
+template<typename T>
+void doParsimArrayPacking(omnetpp::cCommBuffer *b, const T *t, int n)
+{
+    for (int i = 0; i < n; i++)
+        doParsimPacking(b, t[i]);
+}
+
+template<typename T>
+void doParsimArrayUnpacking(omnetpp::cCommBuffer *b, T *t, int n)
+{
+    for (int i = 0; i < n; i++)
+        doParsimUnpacking(b, t[i]);
+}
+
+// Default rule to prevent compiler from choosing base class' doParsimPacking() function
+template<typename T>
+void doParsimPacking(omnetpp::cCommBuffer *, const T& t)
+{
+    throw omnetpp::cRuntimeError("Parsim error: No doParsimPacking() function for type %s", omnetpp::opp_typename(typeid(t)));
+}
+
+template<typename T>
+void doParsimUnpacking(omnetpp::cCommBuffer *, T& t)
+{
+    throw omnetpp::cRuntimeError("Parsim error: No doParsimUnpacking() function for type %s", omnetpp::opp_typename(typeid(t)));
+}
+
+}  // namespace omnetpp
+
+
+// forward
+template<typename T, typename A>
+std::ostream& operator<<(std::ostream& out, const std::vector<T,A>& vec);
+
+// Template rule which fires if a struct or class doesn't have operator<<
+template<typename T>
+inline std::ostream& operator<<(std::ostream& out,const T&) {return out;}
+
+// operator<< for std::vector<T>
+template<typename T, typename A>
+inline std::ostream& operator<<(std::ostream& out, const std::vector<T,A>& vec)
+{
+    out.put('{');
+    for(typename std::vector<T,A>::const_iterator it = vec.begin(); it != vec.end(); ++it)
+    {
+        if (it != vec.begin()) {
+            out.put(','); out.put(' ');
+        }
+        out << *it;
+    }
+    out.put('}');
+    
+    char buf[32];
+    sprintf(buf, " (size=%u)", (unsigned int)vec.size());
+    out.write(buf, strlen(buf));
+    return out;
+}
+
+Register_Class(New_Connection_Id)
+
+New_Connection_Id::New_Connection_Id() : ::omnetpp::cObject()
+{
+    this->type = 11;
+    this->sequence = 0;
+    this->connection_Id = 0;
+}
+
+New_Connection_Id::New_Connection_Id(const New_Connection_Id& other) : ::omnetpp::cObject(other)
+{
+    copy(other);
+}
+
+New_Connection_Id::~New_Connection_Id()
+{
+}
+
+New_Connection_Id& New_Connection_Id::operator=(const New_Connection_Id& other)
+{
+    if (this==&other) return *this;
+    ::omnetpp::cObject::operator=(other);
+    copy(other);
+    return *this;
+}
+
+void New_Connection_Id::copy(const New_Connection_Id& other)
+{
+    this->type = other.type;
+    this->sequence = other.sequence;
+    this->connection_Id = other.connection_Id;
+    this->stateless_Reset_Token = other.stateless_Reset_Token;
+}
+
+void New_Connection_Id::parsimPack(omnetpp::cCommBuffer *b) const
+{
+    doParsimPacking(b,this->type);
+    doParsimPacking(b,this->sequence);
+    doParsimPacking(b,this->connection_Id);
+    doParsimPacking(b,this->stateless_Reset_Token);
+}
+
+void New_Connection_Id::parsimUnpack(omnetpp::cCommBuffer *b)
+{
+    doParsimUnpacking(b,this->type);
+    doParsimUnpacking(b,this->sequence);
+    doParsimUnpacking(b,this->connection_Id);
+    doParsimUnpacking(b,this->stateless_Reset_Token);
+}
+
+uint8_t New_Connection_Id::getType() const
+{
+    return this->type;
+}
+
+void New_Connection_Id::setType(uint8_t type)
+{
+    this->type = type;
+}
+
+uint16_t New_Connection_Id::getSequence() const
+{
+    return this->sequence;
+}
+
+void New_Connection_Id::setSequence(uint16_t sequence)
+{
+    this->sequence = sequence;
+}
+
+uint64_t New_Connection_Id::getConnection_Id() const
+{
+    return this->connection_Id;
+}
+
+void New_Connection_Id::setConnection_Id(uint64_t connection_Id)
+{
+    this->connection_Id = connection_Id;
+}
+
+SRT& New_Connection_Id::getStateless_Reset_Token()
+{
+    return this->stateless_Reset_Token;
+}
+
+void New_Connection_Id::setStateless_Reset_Token(const SRT& stateless_Reset_Token)
+{
+    this->stateless_Reset_Token = stateless_Reset_Token;
+}
+
+class New_Connection_IdDescriptor : public omnetpp::cClassDescriptor
+{
+  private:
+    mutable const char **propertynames;
+  public:
+    New_Connection_IdDescriptor();
+    virtual ~New_Connection_IdDescriptor();
+
+    virtual bool doesSupport(omnetpp::cObject *obj) const override;
+    virtual const char **getPropertyNames() const override;
+    virtual const char *getProperty(const char *propertyname) const override;
+    virtual int getFieldCount() const override;
+    virtual const char *getFieldName(int field) const override;
+    virtual int findField(const char *fieldName) const override;
+    virtual unsigned int getFieldTypeFlags(int field) const override;
+    virtual const char *getFieldTypeString(int field) const override;
+    virtual const char **getFieldPropertyNames(int field) const override;
+    virtual const char *getFieldProperty(int field, const char *propertyname) const override;
+    virtual int getFieldArraySize(void *object, int field) const override;
+
+    virtual const char *getFieldDynamicTypeString(void *object, int field, int i) const override;
+    virtual std::string getFieldValueAsString(void *object, int field, int i) const override;
+    virtual bool setFieldValueAsString(void *object, int field, int i, const char *value) const override;
+
+    virtual const char *getFieldStructName(int field) const override;
+    virtual void *getFieldStructValuePointer(void *object, int field, int i) const override;
+};
+
+Register_ClassDescriptor(New_Connection_IdDescriptor)
+
+New_Connection_IdDescriptor::New_Connection_IdDescriptor() : omnetpp::cClassDescriptor("New_Connection_Id", "omnetpp::cObject")
+{
+    propertynames = nullptr;
+}
+
+New_Connection_IdDescriptor::~New_Connection_IdDescriptor()
+{
+    delete[] propertynames;
+}
+
+bool New_Connection_IdDescriptor::doesSupport(omnetpp::cObject *obj) const
+{
+    return dynamic_cast<New_Connection_Id *>(obj)!=nullptr;
+}
+
+const char **New_Connection_IdDescriptor::getPropertyNames() const
+{
+    if (!propertynames) {
+        static const char *names[] = {  nullptr };
+        omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
+        const char **basenames = basedesc ? basedesc->getPropertyNames() : nullptr;
+        propertynames = mergeLists(basenames, names);
+    }
+    return propertynames;
+}
+
+const char *New_Connection_IdDescriptor::getProperty(const char *propertyname) const
+{
+    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
+    return basedesc ? basedesc->getProperty(propertyname) : nullptr;
+}
+
+int New_Connection_IdDescriptor::getFieldCount() const
+{
+    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
+    return basedesc ? 4+basedesc->getFieldCount() : 4;
+}
+
+unsigned int New_Connection_IdDescriptor::getFieldTypeFlags(int field) const
+{
+    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
+    if (basedesc) {
+        if (field < basedesc->getFieldCount())
+            return basedesc->getFieldTypeFlags(field);
+        field -= basedesc->getFieldCount();
+    }
+    static unsigned int fieldTypeFlags[] = {
+        FD_ISEDITABLE,
+        FD_ISEDITABLE,
+        FD_ISEDITABLE,
+        FD_ISCOMPOUND,
+    };
+    return (field>=0 && field<4) ? fieldTypeFlags[field] : 0;
+}
+
+const char *New_Connection_IdDescriptor::getFieldName(int field) const
+{
+    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
+    if (basedesc) {
+        if (field < basedesc->getFieldCount())
+            return basedesc->getFieldName(field);
+        field -= basedesc->getFieldCount();
+    }
+    static const char *fieldNames[] = {
+        "type",
+        "sequence",
+        "connection_Id",
+        "stateless_Reset_Token",
+    };
+    return (field>=0 && field<4) ? fieldNames[field] : nullptr;
+}
+
+int New_Connection_IdDescriptor::findField(const char *fieldName) const
+{
+    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
+    int base = basedesc ? basedesc->getFieldCount() : 0;
+    if (fieldName[0]=='t' && strcmp(fieldName, "type")==0) return base+0;
+    if (fieldName[0]=='s' && strcmp(fieldName, "sequence")==0) return base+1;
+    if (fieldName[0]=='c' && strcmp(fieldName, "connection_Id")==0) return base+2;
+    if (fieldName[0]=='s' && strcmp(fieldName, "stateless_Reset_Token")==0) return base+3;
+    return basedesc ? basedesc->findField(fieldName) : -1;
+}
+
+const char *New_Connection_IdDescriptor::getFieldTypeString(int field) const
+{
+    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
+    if (basedesc) {
+        if (field < basedesc->getFieldCount())
+            return basedesc->getFieldTypeString(field);
+        field -= basedesc->getFieldCount();
+    }
+    static const char *fieldTypeStrings[] = {
+        "uint8_t",
+        "uint16_t",
+        "uint64_t",
+        "SRT",
+    };
+    return (field>=0 && field<4) ? fieldTypeStrings[field] : nullptr;
+}
+
+const char **New_Connection_IdDescriptor::getFieldPropertyNames(int field) const
+{
+    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
+    if (basedesc) {
+        if (field < basedesc->getFieldCount())
+            return basedesc->getFieldPropertyNames(field);
+        field -= basedesc->getFieldCount();
+    }
+    switch (field) {
+        default: return nullptr;
+    }
+}
+
+const char *New_Connection_IdDescriptor::getFieldProperty(int field, const char *propertyname) const
+{
+    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
+    if (basedesc) {
+        if (field < basedesc->getFieldCount())
+            return basedesc->getFieldProperty(field, propertyname);
+        field -= basedesc->getFieldCount();
+    }
+    switch (field) {
+        default: return nullptr;
+    }
+}
+
+int New_Connection_IdDescriptor::getFieldArraySize(void *object, int field) const
+{
+    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
+    if (basedesc) {
+        if (field < basedesc->getFieldCount())
+            return basedesc->getFieldArraySize(object, field);
+        field -= basedesc->getFieldCount();
+    }
+    New_Connection_Id *pp = (New_Connection_Id *)object; (void)pp;
+    switch (field) {
+        default: return 0;
+    }
+}
+
+const char *New_Connection_IdDescriptor::getFieldDynamicTypeString(void *object, int field, int i) const
+{
+    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
+    if (basedesc) {
+        if (field < basedesc->getFieldCount())
+            return basedesc->getFieldDynamicTypeString(object,field,i);
+        field -= basedesc->getFieldCount();
+    }
+    New_Connection_Id *pp = (New_Connection_Id *)object; (void)pp;
+    switch (field) {
+        default: return nullptr;
+    }
+}
+
+std::string New_Connection_IdDescriptor::getFieldValueAsString(void *object, int field, int i) const
+{
+    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
+    if (basedesc) {
+        if (field < basedesc->getFieldCount())
+            return basedesc->getFieldValueAsString(object,field,i);
+        field -= basedesc->getFieldCount();
+    }
+    New_Connection_Id *pp = (New_Connection_Id *)object; (void)pp;
+    switch (field) {
+        case 0: return ulong2string(pp->getType());
+        case 1: return ulong2string(pp->getSequence());
+        case 2: return uint642string(pp->getConnection_Id());
+        case 3: {std::stringstream out; out << pp->getStateless_Reset_Token(); return out.str();}
+        default: return "";
+    }
+}
+
+bool New_Connection_IdDescriptor::setFieldValueAsString(void *object, int field, int i, const char *value) const
+{
+    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
+    if (basedesc) {
+        if (field < basedesc->getFieldCount())
+            return basedesc->setFieldValueAsString(object,field,i,value);
+        field -= basedesc->getFieldCount();
+    }
+    New_Connection_Id *pp = (New_Connection_Id *)object; (void)pp;
+    switch (field) {
+        case 0: pp->setType(string2ulong(value)); return true;
+        case 1: pp->setSequence(string2ulong(value)); return true;
+        case 2: pp->setConnection_Id(string2uint64(value)); return true;
+        default: return false;
+    }
+}
+
+const char *New_Connection_IdDescriptor::getFieldStructName(int field) const
+{
+    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
+    if (basedesc) {
+        if (field < basedesc->getFieldCount())
+            return basedesc->getFieldStructName(field);
+        field -= basedesc->getFieldCount();
+    }
+    switch (field) {
+        case 3: return omnetpp::opp_typename(typeid(SRT));
+        default: return nullptr;
+    };
+}
+
+void *New_Connection_IdDescriptor::getFieldStructValuePointer(void *object, int field, int i) const
+{
+    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
+    if (basedesc) {
+        if (field < basedesc->getFieldCount())
+            return basedesc->getFieldStructValuePointer(object, field, i);
+        field -= basedesc->getFieldCount();
+    }
+    New_Connection_Id *pp = (New_Connection_Id *)object; (void)pp;
+    switch (field) {
+        case 3: return (void *)(&pp->getStateless_Reset_Token()); break;
+        default: return nullptr;
+    }
+}
+
+

QUIC/Frames/new_Connection_Id_m.h

@@ -0,0 +1,79 @@
+//
+// Generated file, do not edit! Created by nedtool 5.2 from Frames/new_Connection_Id.msg.
+//
+
+#if defined(__clang__)
+#  pragma clang diagnostic ignored "-Wreserved-id-macro"
+#endif
+#ifndef __NEW_CONNECTION_ID_M_H
+#define __NEW_CONNECTION_ID_M_H
+
+#include <omnetpp.h>
+
+// nedtool version check
+#define MSGC_VERSION 0x0502
+#if (MSGC_VERSION!=OMNETPP_VERSION)
+#    error Version mismatch! Probably this file was generated by an earlier version of nedtool: 'make clean' should help.
+#endif
+
+
+
+// cplusplus {{
+  	#include <vector>
+  	typedef std::vector<uint64_t> SRT;	
+// }}
+
+/**
+ * Class generated from <tt>Frames/new_Connection_Id.msg:26</tt> by nedtool.
+ * <pre>
+ * class New_Connection_Id
+ * {
+ *     uint8_t type = 11;
+ *     uint16_t sequence;
+ *     uint64_t connection_Id;
+ *     SRT stateless_Reset_Token;
+ * }
+ * </pre>
+ */
+class New_Connection_Id : public ::omnetpp::cObject
+{
+  protected:
+    uint8_t type;
+    uint16_t sequence;
+    uint64_t connection_Id;
+    SRT stateless_Reset_Token;
+
+  private:
+    void copy(const New_Connection_Id& other);
+
+  protected:
+    // protected and unimplemented operator==(), to prevent accidental usage
+    bool operator==(const New_Connection_Id&);
+
+  public:
+    New_Connection_Id();
+    New_Connection_Id(const New_Connection_Id& other);
+    virtual ~New_Connection_Id();
+    New_Connection_Id& operator=(const New_Connection_Id& other);
+    virtual New_Connection_Id *dup() const override {return new New_Connection_Id(*this);}
+    virtual void parsimPack(omnetpp::cCommBuffer *b) const override;
+    virtual void parsimUnpack(omnetpp::cCommBuffer *b) override;
+
+    // field getter/setter methods
+    virtual uint8_t getType() const;
+    virtual void setType(uint8_t type);
+    virtual uint16_t getSequence() const;
+    virtual void setSequence(uint16_t sequence);
+    virtual uint64_t getConnection_Id() const;
+    virtual void setConnection_Id(uint64_t connection_Id);
+    virtual SRT& getStateless_Reset_Token();
+    virtual const SRT& getStateless_Reset_Token() const {return const_cast<New_Connection_Id*>(this)->getStateless_Reset_Token();}
+    virtual void setStateless_Reset_Token(const SRT& stateless_Reset_Token);
+};
+
+inline void doParsimPacking(omnetpp::cCommBuffer *b, const New_Connection_Id& obj) {obj.parsimPack(b);}
+inline void doParsimUnpacking(omnetpp::cCommBuffer *b, New_Connection_Id& obj) {obj.parsimUnpack(b);}
+
+
+#endif // ifndef __NEW_CONNECTION_ID_M_H
+

QUIC/Frames/padding.msg

@@ -0,0 +1,23 @@
+//
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Lesser General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+// 
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU Lesser General Public License for more details.
+// 
+// You should have received a copy of the GNU Lesser General Public License
+// along with this program.  If not, see http://www.gnu.org/licenses/.
+// 
+
+//
+// TODO generated message class
+//
+
+
+class Padding {
+    uint8_t type = 0;
+    }

QUIC/Frames/padding_m.cc

@@ -0,0 +1,458 @@
+//
+// Generated file, do not edit! Created by nedtool 5.2 from Frames/padding.msg.
+//
+
+// Disable warnings about unused variables, empty switch stmts, etc:
+#ifdef _MSC_VER
+#  pragma warning(disable:4101)
+#  pragma warning(disable:4065)
+#endif
+
+#if defined(__clang__)
+#  pragma clang diagnostic ignored "-Wshadow"
+#  pragma clang diagnostic ignored "-Wconversion"
+#  pragma clang diagnostic ignored "-Wunused-parameter"
+#  pragma clang diagnostic ignored "-Wc++98-compat"
+#  pragma clang diagnostic ignored "-Wunreachable-code-break"
+#  pragma clang diagnostic ignored "-Wold-style-cast"
+#elif defined(__GNUC__)
+#  pragma GCC diagnostic ignored "-Wshadow"
+#  pragma GCC diagnostic ignored "-Wconversion"
+#  pragma GCC diagnostic ignored "-Wunused-parameter"
+#  pragma GCC diagnostic ignored "-Wold-style-cast"
+#  pragma GCC diagnostic ignored "-Wsuggest-attribute=noreturn"
+#  pragma GCC diagnostic ignored "-Wfloat-conversion"
+#endif
+
+#include <iostream>
+#include <sstream>
+#include "padding_m.h"
+
+namespace omnetpp {
+
+// Template pack/unpack rules. They are declared *after* a1l type-specific pack functions for multiple reasons.
+// They are in the omnetpp namespace, to allow them to be found by argument-dependent lookup via the cCommBuffer argument
+
+// Packing/unpacking an std::vector
+template<typename T, typename A>
+void doParsimPacking(omnetpp::cCommBuffer *buffer, const std::vector<T,A>& v)
+{
+    int n = v.size();
+    doParsimPacking(buffer, n);
+    for (int i = 0; i < n; i++)
+        doParsimPacking(buffer, v[i]);
+}
+
+template<typename T, typename A>
+void doParsimUnpacking(omnetpp::cCommBuffer *buffer, std::vector<T,A>& v)
+{
+    int n;
+    doParsimUnpacking(buffer, n);
+    v.resize(n);
+    for (int i = 0; i < n; i++)
+        doParsimUnpacking(buffer, v[i]);
+}
+
+// Packing/unpacking an std::list
+template<typename T, typename A>
+void doParsimPacking(omnetpp::cCommBuffer *buffer, const std::list<T,A>& l)
+{
+    doParsimPacking(buffer, (int)l.size());
+    for (typename std::list<T,A>::const_iterator it = l.begin(); it != l.end(); ++it)
+        doParsimPacking(buffer, (T&)*it);
+}
+
+template<typename T, typename A>
+void doParsimUnpacking(omnetpp::cCommBuffer *buffer, std::list<T,A>& l)
+{
+    int n;
+    doParsimUnpacking(buffer, n);
+    for (int i=0; i<n; i++) {
+        l.push_back(T());
+        doParsimUnpacking(buffer, l.back());
+    }
+}
+
+// Packing/unpacking an std::set
+template<typename T, typename Tr, typename A>
+void doParsimPacking(omnetpp::cCommBuffer *buffer, const std::set<T,Tr,A>& s)
+{
+    doParsimPacking(buffer, (int)s.size());
+    for (typename std::set<T,Tr,A>::const_iterator it = s.begin(); it != s.end(); ++it)
+        doParsimPacking(buffer, *it);
+}
+
+template<typename T, typename Tr, typename A>
+void doParsimUnpacking(omnetpp::cCommBuffer *buffer, std::set<T,Tr,A>& s)
+{
+    int n;
+    doParsimUnpacking(buffer, n);
+    for (int i=0; i<n; i++) {
+        T x;
+        doParsimUnpacking(buffer, x);
+        s.insert(x);
+    }
+}
+
+// Packing/unpacking an std::map
+template<typename K, typename V, typename Tr, typename A>
+void doParsimPacking(omnetpp::cCommBuffer *buffer, const std::map<K,V,Tr,A>& m)
+{
+    doParsimPacking(buffer, (int)m.size());
+    for (typename std::map<K,V,Tr,A>::const_iterator it = m.begin(); it != m.end(); ++it) {
+        doParsimPacking(buffer, it->first);
+        doParsimPacking(buffer, it->second);
+    }
+}
+
+template<typename K, typename V, typename Tr, typename A>
+void doParsimUnpacking(omnetpp::cCommBuffer *buffer, std::map<K,V,Tr,A>& m)
+{
+    int n;
+    doParsimUnpacking(buffer, n);
+    for (int i=0; i<n; i++) {
+        K k; V v;
+        doParsimUnpacking(buffer, k);
+        doParsimUnpacking(buffer, v);
+        m[k] = v;
+    }
+}
+
+// Default pack/unpack function for arrays
+template<typename T>
+void doParsimArrayPacking(omnetpp::cCommBuffer *b, const T *t, int n)
+{
+    for (int i = 0; i < n; i++)
+        doParsimPacking(b, t[i]);
+}
+
+template<typename T>
+void doParsimArrayUnpacking(omnetpp::cCommBuffer *b, T *t, int n)
+{
+    for (int i = 0; i < n; i++)
+        doParsimUnpacking(b, t[i]);
+}
+
+// Default rule to prevent compiler from choosing base class' doParsimPacking() function
+template<typename T>
+void doParsimPacking(omnetpp::cCommBuffer *, const T& t)
+{
+    throw omnetpp::cRuntimeError("Parsim error: No doParsimPacking() function for type %s", omnetpp::opp_typename(typeid(t)));
+}
+
+template<typename T>
+void doParsimUnpacking(omnetpp::cCommBuffer *, T& t)
+{
+    throw omnetpp::cRuntimeError("Parsim error: No doParsimUnpacking() function for type %s", omnetpp::opp_typename(typeid(t)));
+}
+
+}  // namespace omnetpp
+
+
+// forward
+template<typename T, typename A>
+std::ostream& operator<<(std::ostream& out, const std::vector<T,A>& vec);
+
+// Template rule which fires if a struct or class doesn't have operator<<
+template<typename T>
+inline std::ostream& operator<<(std::ostream& out,const T&) {return out;}
+
+// operator<< for std::vector<T>
+template<typename T, typename A>
+inline std::ostream& operator<<(std::ostream& out, const std::vector<T,A>& vec)
+{
+    out.put('{');
+    for(typename std::vector<T,A>::const_iterator it = vec.begin(); it != vec.end(); ++it)
+    {
+        if (it != vec.begin()) {
+            out.put(','); out.put(' ');
+        }
+        out << *it;
+    }
+    out.put('}');
+    
+    char buf[32];
+    sprintf(buf, " (size=%u)", (unsigned int)vec.size());
+    out.write(buf, strlen(buf));
+    return out;
+}
+
+Register_Class(Padding)
+
+Padding::Padding() : ::omnetpp::cObject()
+{
+    this->type = 0;
+}
+
+Padding::Padding(const Padding& other) : ::omnetpp::cObject(other)
+{
+    copy(other);
+}
+
+Padding::~Padding()
+{
+}
+
+Padding& Padding::operator=(const Padding& other)
+{
+    if (this==&other) return *this;
+    ::omnetpp::cObject::operator=(other);
+    copy(other);
+    return *this;
+}
+
+void Padding::copy(const Padding& other)
+{
+    this->type = other.type;
+}
+
+void Padding::parsimPack(omnetpp::cCommBuffer *b) const
+{
+    doParsimPacking(b,this->type);
+}
+
+void Padding::parsimUnpack(omnetpp::cCommBuffer *b)
+{
+    doParsimUnpacking(b,this->type);
+}
+
+uint8_t Padding::getType() const
+{
+    return this->type;
+}
+
+void Padding::setType(uint8_t type)
+{
+    this->type = type;
+}
+
+class PaddingDescriptor : public omnetpp::cClassDescriptor
+{
+  private:
+    mutable const char **propertynames;
+  public:
+    PaddingDescriptor();
+    virtual ~PaddingDescriptor();
+
+    virtual bool doesSupport(omnetpp::cObject *obj) const override;
+    virtual const char **getPropertyNames() const override;
+    virtual const char *getProperty(const char *propertyname) const override;
+    virtual int getFieldCount() const override;
+    virtual const char *getFieldName(int field) const override;
+    virtual int findField(const char *fieldName) const override;
+    virtual unsigned int getFieldTypeFlags(int field) const override;
+    virtual const char *getFieldTypeString(int field) const override;
+    virtual const char **getFieldPropertyNames(int field) const override;
+    virtual const char *getFieldProperty(int field, const char *propertyname) const override;
+    virtual int getFieldArraySize(void *object, int field) const override;
+
+    virtual const char *getFieldDynamicTypeString(void *object, int field, int i) const override;
+    virtual std::string getFieldValueAsString(void *object, int field, int i) const override;
+    virtual bool setFieldValueAsString(void *object, int field, int i, const char *value) const override;
+
+    virtual const char *getFieldStructName(int field) const override;
+    virtual void *getFieldStructValuePointer(void *object, int field, int i) const override;
+};
+
+Register_ClassDescriptor(PaddingDescriptor)
+
+PaddingDescriptor::PaddingDescriptor() : omnetpp::cClassDescriptor("Padding", "omnetpp::cObject")
+{
+    propertynames = nullptr;
+}
+
+PaddingDescriptor::~PaddingDescriptor()
+{
+    delete[] propertynames;
+}
+
+bool PaddingDescriptor::doesSupport(omnetpp::cObject *obj) const
+{
+    return dynamic_cast<Padding *>(obj)!=nullptr;
+}
+
+const char **PaddingDescriptor::getPropertyNames() const
+{
+    if (!propertynames) {
+        static const char *names[] = {  nullptr };
+        omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
+        const char **basenames = basedesc ? basedesc->getPropertyNames() : nullptr;
+        propertynames = mergeLists(basenames, names);
+    }
+    return propertynames;
+}
+
+const char *PaddingDescriptor::getProperty(const char *propertyname) const
+{
+    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
+    return basedesc ? basedesc->getProperty(propertyname) : nullptr;
+}
+
+int PaddingDescriptor::getFieldCount() const
+{
+    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
+    return basedesc ? 1+basedesc->getFieldCount() : 1;
+}
+
+unsigned int PaddingDescriptor::getFieldTypeFlags(int field) const
+{
+    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
+    if (basedesc) {
+        if (field < basedesc->getFieldCount())
+            return basedesc->getFieldTypeFlags(field);
+        field -= basedesc->getFieldCount();
+    }
+    static unsigned int fieldTypeFlags[] = {
+        FD_ISEDITABLE,
+    };
+    return (field>=0 && field<1) ? fieldTypeFlags[field] : 0;
+}
+
+const char *PaddingDescriptor::getFieldName(int field) const
+{
+    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
+    if (basedesc) {
+        if (field < basedesc->getFieldCount())
+            return basedesc->getFieldName(field);
+        field -= basedesc->getFieldCount();
+    }
+    static const char *fieldNames[] = {
+        "type",
+    };
+    return (field>=0 && field<1) ? fieldNames[field] : nullptr;
+}
+
+int PaddingDescriptor::findField(const char *fieldName) const
+{
+    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
+    int base = basedesc ? basedesc->getFieldCount() : 0;
+    if (fieldName[0]=='t' && strcmp(fieldName, "type")==0) return base+0;
+    return basedesc ? basedesc->findField(fieldName) : -1;
+}
+
+const char *PaddingDescriptor::getFieldTypeString(int field) const
+{
+    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
+    if (basedesc) {
+        if (field < basedesc->getFieldCount())
+            return basedesc->getFieldTypeString(field);
+        field -= basedesc->getFieldCount();
+    }
+    static const char *fieldTypeStrings[] = {
+        "uint8_t",
+    };
+    return (field>=0 && field<1) ? fieldTypeStrings[field] : nullptr;
+}
+
+const char **PaddingDescriptor::getFieldPropertyNames(int field) const
+{
+    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
+    if (basedesc) {
+        if (field < basedesc->getFieldCount())
+            return basedesc->getFieldPropertyNames(field);
+        field -= basedesc->getFieldCount();
+    }
+    switch (field) {
+        default: return nullptr;
+    }
+}
+
+const char *PaddingDescriptor::getFieldProperty(int field, const char *propertyname) const
+{
+    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
+    if (basedesc) {
+        if (field < basedesc->getFieldCount())
+            return basedesc->getFieldProperty(field, propertyname);
+        field -= basedesc->getFieldCount();
+    }
+    switch (field) {
+        default: return nullptr;
+    }
+}
+
+int PaddingDescriptor::getFieldArraySize(void *object, int field) const
+{
+    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
+    if (basedesc) {
+        if (field < basedesc->getFieldCount())
+            return basedesc->getFieldArraySize(object, field);
+        field -= basedesc->getFieldCount();
+    }
+    Padding *pp = (Padding *)object; (void)pp;
+    switch (field) {
+        default: return 0;
+    }
+}
+
+const char *PaddingDescriptor::getFieldDynamicTypeString(void *object, int field, int i) const
+{
+    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
+    if (basedesc) {
+        if (field < basedesc->getFieldCount())
+            return basedesc->getFieldDynamicTypeString(object,field,i);
+        field -= basedesc->getFieldCount();
+    }
+    Padding *pp = (Padding *)object; (void)pp;
+    switch (field) {
+        default: return nullptr;
+    }
+}
+
+std::string PaddingDescriptor::getFieldValueAsString(void *object, int field, int i) const
+{
+    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
+    if (basedesc) {
+        if (field < basedesc->getFieldCount())
+            return basedesc->getFieldValueAsString(object,field,i);
+        field -= basedesc->getFieldCount();
+    }
+    Padding *pp = (Padding *)object; (void)pp;
+    switch (field) {
+        case 0: return ulong2string(pp->getType());
+        default: return "";
+    }
+}
+
+bool PaddingDescriptor::setFieldValueAsString(void *object, int field, int i, const char *value) const
+{
+    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
+    if (basedesc) {
+        if (field < basedesc->getFieldCount())
+            return basedesc->setFieldValueAsString(object,field,i,value);
+        field -= basedesc->getFieldCount();
+    }
+    Padding *pp = (Padding *)object; (void)pp;
+    switch (field) {
+        case 0: pp->setType(string2ulong(value)); return true;
+        default: return false;
+    }
+}
+
+const char *PaddingDescriptor::getFieldStructName(int field) const
+{
+    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
+    if (basedesc) {
+        if (field < basedesc->getFieldCount())
+            return basedesc->getFieldStructName(field);
+        field -= basedesc->getFieldCount();
+    }
+    switch (field) {
+        default: return nullptr;
+    };
+}
+
+void *PaddingDescriptor::getFieldStructValuePointer(void *object, int field, int i) const
+{
+    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
+    if (basedesc) {
+        if (field < basedesc->getFieldCount())
+            return basedesc->getFieldStructValuePointer(object, field, i);
+        field -= basedesc->getFieldCount();
+    }
+    Padding *pp = (Padding *)object; (void)pp;
+    switch (field) {
+        default: return nullptr;
+    }
+}
+
+

QUIC/Frames/padding_m.h

@@ -0,0 +1,61 @@
+//
+// Generated file, do not edit! Created by nedtool 5.2 from Frames/padding.msg.
+//
+
+#if defined(__clang__)
+#  pragma clang diagnostic ignored "-Wreserved-id-macro"
+#endif
+#ifndef __PADDING_M_H
+#define __PADDING_M_H
+
+#include <omnetpp.h>
+
+// nedtool version check
+#define MSGC_VERSION 0x0502
+#if (MSGC_VERSION!=OMNETPP_VERSION)
+#    error Version mismatch! Probably this file was generated by an earlier version of nedtool: 'make clean' should help.
+#endif
+
+
+
+/**
+ * Class generated from <tt>Frames/padding.msg:21</tt> by nedtool.
+ * <pre>
+ * class Padding
+ * {
+ *     uint8_t type = 0;
+ * }
+ * </pre>
+ */
+class Padding : public ::omnetpp::cObject
+{
+  protected:
+    uint8_t type;
+
+  private:
+    void copy(const Padding& other);
+
+  protected:
+    // protected and unimplemented operator==(), to prevent accidental usage
+    bool operator==(const Padding&);
+
+  public:
+    Padding();
+    Padding(const Padding& other);
+    virtual ~Padding();
+    Padding& operator=(const Padding& other);
+    virtual Padding *dup() const override {return new Padding(*this);}
+    virtual void parsimPack(omnetpp::cCommBuffer *b) const override;
+    virtual void parsimUnpack(omnetpp::cCommBuffer *b) override;
+
+    // field getter/setter methods
+    virtual uint8_t getType() const;
+    virtual void setType(uint8_t type);
+};
+
+inline void doParsimPacking(omnetpp::cCommBuffer *b, const Padding& obj) {obj.parsimPack(b);}
+inline void doParsimUnpacking(omnetpp::cCommBuffer *b, Padding& obj) {obj.parsimUnpack(b);}
+
+
+#endif // ifndef __PADDING_M_H
+

QUIC/Frames/ping.msg

@@ -0,0 +1,21 @@
+//
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Lesser General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+// 
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU Lesser General Public License for more details.
+// 
+// You should have received a copy of the GNU Lesser General Public License
+// along with this program.  If not, see http://www.gnu.org/licenses/.
+// 
+
+//
+// TODO generated message class
+//
+class Ping {
+    uint8_t type = 7;
+}

QUIC/Frames/ping_m.cc

@@ -0,0 +1,458 @@
+//
+// Generated file, do not edit! Created by nedtool 5.2 from Frames/ping.msg.
+//
+
+// Disable warnings about unused variables, empty switch stmts, etc:
+#ifdef _MSC_VER
+#  pragma warning(disable:4101)
+#  pragma warning(disable:4065)
+#endif
+
+#if defined(__clang__)
+#  pragma clang diagnostic ignored "-Wshadow"
+#  pragma clang diagnostic ignored "-Wconversion"
+#  pragma clang diagnostic ignored "-Wunused-parameter"
+#  pragma clang diagnostic ignored "-Wc++98-compat"
+#  pragma clang diagnostic ignored "-Wunreachable-code-break"
+#  pragma clang diagnostic ignored "-Wold-style-cast"
+#elif defined(__GNUC__)
+#  pragma GCC diagnostic ignored "-Wshadow"
+#  pragma GCC diagnostic ignored "-Wconversion"
+#  pragma GCC diagnostic ignored "-Wunused-parameter"
+#  pragma GCC diagnostic ignored "-Wold-style-cast"
+#  pragma GCC diagnostic ignored "-Wsuggest-attribute=noreturn"
+#  pragma GCC diagnostic ignored "-Wfloat-conversion"
+#endif
+
+#include <iostream>
+#include <sstream>
+#include "ping_m.h"
+
+namespace omnetpp {
+
+// Template pack/unpack rules. They are declared *after* a1l type-specific pack functions for multiple reasons.
+// They are in the omnetpp namespace, to allow them to be found by argument-dependent lookup via the cCommBuffer argument
+
+// Packing/unpacking an std::vector
+template<typename T, typename A>
+void doParsimPacking(omnetpp::cCommBuffer *buffer, const std::vector<T,A>& v)
+{
+    int n = v.size();
+    doParsimPacking(buffer, n);
+    for (int i = 0; i < n; i++)
+        doParsimPacking(buffer, v[i]);
+}
+
+template<typename T, typename A>
+void doParsimUnpacking(omnetpp::cCommBuffer *buffer, std::vector<T,A>& v)
+{
+    int n;
+    doParsimUnpacking(buffer, n);
+    v.resize(n);
+    for (int i = 0; i < n; i++)
+        doParsimUnpacking(buffer, v[i]);
+}
+
+// Packing/unpacking an std::list
+template<typename T, typename A>
+void doParsimPacking(omnetpp::cCommBuffer *buffer, const std::list<T,A>& l)
+{
+    doParsimPacking(buffer, (int)l.size());
+    for (typename std::list<T,A>::const_iterator it = l.begin(); it != l.end(); ++it)
+        doParsimPacking(buffer, (T&)*it);
+}
+
+template<typename T, typename A>
+void doParsimUnpacking(omnetpp::cCommBuffer *buffer, std::list<T,A>& l)
+{
+    int n;
+    doParsimUnpacking(buffer, n);
+    for (int i=0; i<n; i++) {
+        l.push_back(T());
+        doParsimUnpacking(buffer, l.back());
+    }
+}
+
+// Packing/unpacking an std::set
+template<typename T, typename Tr, typename A>
+void doParsimPacking(omnetpp::cCommBuffer *buffer, const std::set<T,Tr,A>& s)
+{
+    doParsimPacking(buffer, (int)s.size());
+    for (typename std::set<T,Tr,A>::const_iterator it = s.begin(); it != s.end(); ++it)
+        doParsimPacking(buffer, *it);
+}
+
+template<typename T, typename Tr, typename A>
+void doParsimUnpacking(omnetpp::cCommBuffer *buffer, std::set<T,Tr,A>& s)
+{
+    int n;
+    doParsimUnpacking(buffer, n);
+    for (int i=0; i<n; i++) {
+        T x;
+        doParsimUnpacking(buffer, x);
+        s.insert(x);
+    }
+}
+
+// Packing/unpacking an std::map
+template<typename K, typename V, typename Tr, typename A>
+void doParsimPacking(omnetpp::cCommBuffer *buffer, const std::map<K,V,Tr,A>& m)
+{
+    doParsimPacking(buffer, (int)m.size());
+    for (typename std::map<K,V,Tr,A>::const_iterator it = m.begin(); it != m.end(); ++it) {
+        doParsimPacking(buffer, it->first);
+        doParsimPacking(buffer, it->second);
+    }
+}
+
+template<typename K, typename V, typename Tr, typename A>
+void doParsimUnpacking(omnetpp::cCommBuffer *buffer, std::map<K,V,Tr,A>& m)
+{
+    int n;
+    doParsimUnpacking(buffer, n);
+    for (int i=0; i<n; i++) {
+        K k; V v;
+        doParsimUnpacking(buffer, k);
+        doParsimUnpacking(buffer, v);
+        m[k] = v;
+    }
+}
+
+// Default pack/unpack function for arrays
+template<typename T>
+void doParsimArrayPacking(omnetpp::cCommBuffer *b, const T *t, int n)
+{
+    for (int i = 0; i < n; i++)
+        doParsimPacking(b, t[i]);
+}
+
+template<typename T>
+void doParsimArrayUnpacking(omnetpp::cCommBuffer *b, T *t, int n)
+{
+    for (int i = 0; i < n; i++)
+        doParsimUnpacking(b, t[i]);
+}
+
+// Default rule to prevent compiler from choosing base class' doParsimPacking() function
+template<typename T>
+void doParsimPacking(omnetpp::cCommBuffer *, const T& t)
+{
+    throw omnetpp::cRuntimeError("Parsim error: No doParsimPacking() function for type %s", omnetpp::opp_typename(typeid(t)));
+}
+
+template<typename T>
+void doParsimUnpacking(omnetpp::cCommBuffer *, T& t)
+{
+    throw omnetpp::cRuntimeError("Parsim error: No doParsimUnpacking() function for type %s", omnetpp::opp_typename(typeid(t)));
+}
+
+}  // namespace omnetpp
+
+
+// forward
+template<typename T, typename A>
+std::ostream& operator<<(std::ostream& out, const std::vector<T,A>& vec);
+
+// Template rule which fires if a struct or class doesn't have operator<<
+template<typename T>
+inline std::ostream& operator<<(std::ostream& out,const T&) {return out;}
+
+// operator<< for std::vector<T>
+template<typename T, typename A>
+inline std::ostream& operator<<(std::ostream& out, const std::vector<T,A>& vec)
+{
+    out.put('{');
+    for(typename std::vector<T,A>::const_iterator it = vec.begin(); it != vec.end(); ++it)
+    {
+        if (it != vec.begin()) {
+            out.put(','); out.put(' ');
+        }
+        out << *it;
+    }
+    out.put('}');
+    
+    char buf[32];
+    sprintf(buf, " (size=%u)", (unsigned int)vec.size());
+    out.write(buf, strlen(buf));
+    return out;
+}
+
+Register_Class(Ping)
+
+Ping::Ping() : ::omnetpp::cObject()
+{
+    this->type = 7;
+}
+
+Ping::Ping(const Ping& other) : ::omnetpp::cObject(other)
+{
+    copy(other);
+}
+
+Ping::~Ping()
+{
+}
+
+Ping& Ping::operator=(const Ping& other)
+{
+    if (this==&other) return *this;
+    ::omnetpp::cObject::operator=(other);
+    copy(other);
+    return *this;
+}
+
+void Ping::copy(const Ping& other)
+{
+    this->type = other.type;
+}
+
+void Ping::parsimPack(omnetpp::cCommBuffer *b) const
+{
+    doParsimPacking(b,this->type);
+}
+
+void Ping::parsimUnpack(omnetpp::cCommBuffer *b)
+{
+    doParsimUnpacking(b,this->type);
+}
+
+uint8_t Ping::getType() const
+{
+    return this->type;
+}
+
+void Ping::setType(uint8_t type)
+{
+    this->type = type;
+}
+
+class PingDescriptor : public omnetpp::cClassDescriptor
+{
+  private:
+    mutable const char **propertynames;
+  public:
+    PingDescriptor();
+    virtual ~PingDescriptor();
+
+    virtual bool doesSupport(omnetpp::cObject *obj) const override;
+    virtual const char **getPropertyNames() const override;
+    virtual const char *getProperty(const char *propertyname) const override;
+    virtual int getFieldCount() const override;
+    virtual const char *getFieldName(int field) const override;
+    virtual int findField(const char *fieldName) const override;
+    virtual unsigned int getFieldTypeFlags(int field) const override;
+    virtual const char *getFieldTypeString(int field) const override;
+    virtual const char **getFieldPropertyNames(int field) const override;
+    virtual const char *getFieldProperty(int field, const char *propertyname) const override;
+    virtual int getFieldArraySize(void *object, int field) const override;
+
+    virtual const char *getFieldDynamicTypeString(void *object, int field, int i) const override;
+    virtual std::string getFieldValueAsString(void *object, int field, int i) const override;
+    virtual bool setFieldValueAsString(void *object, int field, int i, const char *value) const override;
+
+    virtual const char *getFieldStructName(int field) const override;
+    virtual void *getFieldStructValuePointer(void *object, int field, int i) const override;
+};
+
+Register_ClassDescriptor(PingDescriptor)
+
+PingDescriptor::PingDescriptor() : omnetpp::cClassDescriptor("Ping", "omnetpp::cObject")
+{
+    propertynames = nullptr;
+}
+
+PingDescriptor::~PingDescriptor()
+{
+    delete[] propertynames;
+}
+
+bool PingDescriptor::doesSupport(omnetpp::cObject *obj) const
+{
+    return dynamic_cast<Ping *>(obj)!=nullptr;
+}
+
+const char **PingDescriptor::getPropertyNames() const
+{
+    if (!propertynames) {
+        static const char *names[] = {  nullptr };
+        omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
+        const char **basenames = basedesc ? basedesc->getPropertyNames() : nullptr;
+        propertynames = mergeLists(basenames, names);
+    }
+    return propertynames;
+}
+
+const char *PingDescriptor::getProperty(const char *propertyname) const
+{
+    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
+    return basedesc ? basedesc->getProperty(propertyname) : nullptr;
+}
+
+int PingDescriptor::getFieldCount() const
+{
+    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
+    return basedesc ? 1+basedesc->getFieldCount() : 1;
+}
+
+unsigned int PingDescriptor::getFieldTypeFlags(int field) const
+{
+    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
+    if (basedesc) {
+        if (field < basedesc->getFieldCount())
+            return basedesc->getFieldTypeFlags(field);
+        field -= basedesc->getFieldCount();
+    }
+    static unsigned int fieldTypeFlags[] = {
+        FD_ISEDITABLE,
+    };
+    return (field>=0 && field<1) ? fieldTypeFlags[field] : 0;
+}
+
+const char *PingDescriptor::getFieldName(int field) const
+{
+    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
+    if (basedesc) {
+        if (field < basedesc->getFieldCount())
+            return basedesc->getFieldName(field);
+        field -= basedesc->getFieldCount();
+    }
+    static const char *fieldNames[] = {
+        "type",
+    };
+    return (field>=0 && field<1) ? fieldNames[field] : nullptr;
+}
+
+int PingDescriptor::findField(const char *fieldName) const
+{
+    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
+    int base = basedesc ? basedesc->getFieldCount() : 0;
+    if (fieldName[0]=='t' && strcmp(fieldName, "type")==0) return base+0;
+    return basedesc ? basedesc->findField(fieldName) : -1;
+}
+
+const char *PingDescriptor::getFieldTypeString(int field) const
+{
+    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
+    if (basedesc) {
+        if (field < basedesc->getFieldCount())
+            return basedesc->getFieldTypeString(field);
+        field -= basedesc->getFieldCount();
+    }
+    static const char *fieldTypeStrings[] = {
+        "uint8_t",
+    };
+    return (field>=0 && field<1) ? fieldTypeStrings[field] : nullptr;
+}
+
+const char **PingDescriptor::getFieldPropertyNames(int field) const
+{
+    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
+    if (basedesc) {
+        if (field < basedesc->getFieldCount())
+            return basedesc->getFieldPropertyNames(field);
+        field -= basedesc->getFieldCount();
+    }
+    switch (field) {
+        default: return nullptr;
+    }
+}
+
+const char *PingDescriptor::getFieldProperty(int field, const char *propertyname) const
+{
+    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
+    if (basedesc) {
+        if (field < basedesc->getFieldCount())
+            return basedesc->getFieldProperty(field, propertyname);
+        field -= basedesc->getFieldCount();
+    }
+    switch (field) {
+        default: return nullptr;
+    }
+}
+
+int PingDescriptor::getFieldArraySize(void *object, int field) const
+{
+    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
+    if (basedesc) {
+        if (field < basedesc->getFieldCount())
+            return basedesc->getFieldArraySize(object, field);
+        field -= basedesc->getFieldCount();
+    }
+    Ping *pp = (Ping *)object; (void)pp;
+    switch (field) {
+        default: return 0;
+    }
+}
+
+const char *PingDescriptor::getFieldDynamicTypeString(void *object, int field, int i) const
+{
+    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
+    if (basedesc) {
+        if (field < basedesc->getFieldCount())
+            return basedesc->getFieldDynamicTypeString(object,field,i);
+        field -= basedesc->getFieldCount();
+    }
+    Ping *pp = (Ping *)object; (void)pp;
+    switch (field) {
+        default: return nullptr;
+    }
+}
+
+std::string PingDescriptor::getFieldValueAsString(void *object, int field, int i) const
+{
+    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
+    if (basedesc) {
+        if (field < basedesc->getFieldCount())
+            return basedesc->getFieldValueAsString(object,field,i);
+        field -= basedesc->getFieldCount();
+    }
+    Ping *pp = (Ping *)object; (void)pp;
+    switch (field) {
+        case 0: return ulong2string(pp->getType());
+        default: return "";
+    }
+}
+
+bool PingDescriptor::setFieldValueAsString(void *object, int field, int i, const char *value) const
+{
+    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
+    if (basedesc) {
+        if (field < basedesc->getFieldCount())
+            return basedesc->setFieldValueAsString(object,field,i,value);
+        field -= basedesc->getFieldCount();
+    }
+    Ping *pp = (Ping *)object; (void)pp;
+    switch (field) {
+        case 0: pp->setType(string2ulong(value)); return true;
+        default: return false;
+    }
+}
+
+const char *PingDescriptor::getFieldStructName(int field) const
+{
+    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
+    if (basedesc) {
+        if (field < basedesc->getFieldCount())
+            return basedesc->getFieldStructName(field);
+        field -= basedesc->getFieldCount();
+    }
+    switch (field) {
+        default: return nullptr;
+    };
+}
+
+void *PingDescriptor::getFieldStructValuePointer(void *object, int field, int i) const
+{
+    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
+    if (basedesc) {
+        if (field < basedesc->getFieldCount())
+            return basedesc->getFieldStructValuePointer(object, field, i);
+        field -= basedesc->getFieldCount();
+    }
+    Ping *pp = (Ping *)object; (void)pp;
+    switch (field) {
+        default: return nullptr;
+    }
+}
+
+

QUIC/Frames/ping_m.h

@@ -0,0 +1,64 @@
+//
+// Generated file, do not edit! Created by nedtool 5.2 from Frames/ping.msg.
+//
+
+#if defined(__clang__)
+#  pragma clang diagnostic ignored "-Wreserved-id-macro"
+#endif
+#ifndef __PING_M_H
+#define __PING_M_H
+
+#include <omnetpp.h>
+
+// nedtool version check
+#define MSGC_VERSION 0x0502
+#if (MSGC_VERSION!=OMNETPP_VERSION)
+#    error Version mismatch! Probably this file was generated by an earlier version of nedtool: 'make clean' should help.
+#endif
+
+
+
+/**
+ * Class generated from <tt>Frames/ping.msg:19</tt> by nedtool.
+ * <pre>
+ * //
+ * // TODO generated message class
+ * //
+ * class Ping
+ * {
+ *     uint8_t type = 7;
+ * }
+ * </pre>
+ */
+class Ping : public ::omnetpp::cObject
+{
+  protected:
+    uint8_t type;
+
+  private:
+    void copy(const Ping& other);
+
+  protected:
+    // protected and unimplemented operator==(), to prevent accidental usage
+    bool operator==(const Ping&);
+
+  public:
+    Ping();
+    Ping(const Ping& other);
+    virtual ~Ping();
+    Ping& operator=(const Ping& other);
+    virtual Ping *dup() const override {return new Ping(*this);}
+    virtual void parsimPack(omnetpp::cCommBuffer *b) const override;
+    virtual void parsimUnpack(omnetpp::cCommBuffer *b) override;
+
+    // field getter/setter methods
+    virtual uint8_t getType() const;
+    virtual void setType(uint8_t type);
+};
+
+inline void doParsimPacking(omnetpp::cCommBuffer *b, const Ping& obj) {obj.parsimPack(b);}
+inline void doParsimUnpacking(omnetpp::cCommBuffer *b, Ping& obj) {obj.parsimUnpack(b);}
+
+
+#endif // ifndef __PING_M_H
+

QUIC/Frames/rst_stream.msg

@@ -0,0 +1,24 @@
+//
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Lesser General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+// 
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU Lesser General Public License for more details.
+// 
+// You should have received a copy of the GNU Lesser General Public License
+// along with this program.  If not, see http://www.gnu.org/licenses/.
+// 
+
+//
+// TODO generated message class
+//
+class Rst_stream {
+    uint8_t type = 1;
+    uint32_t stream_Id;
+    uint16_t application_Error_Code;
+    double final_Offset;
+}

QUIC/Frames/rst_stream_m.cc

@@ -0,0 +1,518 @@
+//
+// Generated file, do not edit! Created by nedtool 5.2 from Frames/rst_stream.msg.
+//
+
+// Disable warnings about unused variables, empty switch stmts, etc:
+#ifdef _MSC_VER
+#  pragma warning(disable:4101)
+#  pragma warning(disable:4065)
+#endif
+
+#if defined(__clang__)
+#  pragma clang diagnostic ignored "-Wshadow"
+#  pragma clang diagnostic ignored "-Wconversion"
+#  pragma clang diagnostic ignored "-Wunused-parameter"
+#  pragma clang diagnostic ignored "-Wc++98-compat"
+#  pragma clang diagnostic ignored "-Wunreachable-code-break"
+#  pragma clang diagnostic ignored "-Wold-style-cast"
+#elif defined(__GNUC__)
+#  pragma GCC diagnostic ignored "-Wshadow"
+#  pragma GCC diagnostic ignored "-Wconversion"
+#  pragma GCC diagnostic ignored "-Wunused-parameter"
+#  pragma GCC diagnostic ignored "-Wold-style-cast"
+#  pragma GCC diagnostic ignored "-Wsuggest-attribute=noreturn"
+#  pragma GCC diagnostic ignored "-Wfloat-conversion"
+#endif
+
+#include <iostream>
+#include <sstream>
+#include "rst_stream_m.h"
+
+namespace omnetpp {
+
+// Template pack/unpack rules. They are declared *after* a1l type-specific pack functions for multiple reasons.
+// They are in the omnetpp namespace, to allow them to be found by argument-dependent lookup via the cCommBuffer argument
+
+// Packing/unpacking an std::vector
+template<typename T, typename A>
+void doParsimPacking(omnetpp::cCommBuffer *buffer, const std::vector<T,A>& v)
+{
+    int n = v.size();
+    doParsimPacking(buffer, n);
+    for (int i = 0; i < n; i++)
+        doParsimPacking(buffer, v[i]);
+}
+
+template<typename T, typename A>
+void doParsimUnpacking(omnetpp::cCommBuffer *buffer, std::vector<T,A>& v)
+{
+    int n;
+    doParsimUnpacking(buffer, n);
+    v.resize(n);
+    for (int i = 0; i < n; i++)
+        doParsimUnpacking(buffer, v[i]);
+}
+
+// Packing/unpacking an std::list
+template<typename T, typename A>
+void doParsimPacking(omnetpp::cCommBuffer *buffer, const std::list<T,A>& l)
+{
+    doParsimPacking(buffer, (int)l.size());
+    for (typename std::list<T,A>::const_iterator it = l.begin(); it != l.end(); ++it)
+        doParsimPacking(buffer, (T&)*it);
+}
+
+template<typename T, typename A>
+void doParsimUnpacking(omnetpp::cCommBuffer *buffer, std::list<T,A>& l)
+{
+    int n;
+    doParsimUnpacking(buffer, n);
+    for (int i=0; i<n; i++) {
+        l.push_back(T());
+        doParsimUnpacking(buffer, l.back());
+    }
+}
+
+// Packing/unpacking an std::set
+template<typename T, typename Tr, typename A>
+void doParsimPacking(omnetpp::cCommBuffer *buffer, const std::set<T,Tr,A>& s)
+{
+    doParsimPacking(buffer, (int)s.size());
+    for (typename std::set<T,Tr,A>::const_iterator it = s.begin(); it != s.end(); ++it)
+        doParsimPacking(buffer, *it);
+}
+
+template<typename T, typename Tr, typename A>
+void doParsimUnpacking(omnetpp::cCommBuffer *buffer, std::set<T,Tr,A>& s)
+{
+    int n;
+    doParsimUnpacking(buffer, n);
+    for (int i=0; i<n; i++) {
+        T x;
+        doParsimUnpacking(buffer, x);
+        s.insert(x);
+    }
+}
+
+// Packing/unpacking an std::map
+template<typename K, typename V, typename Tr, typename A>
+void doParsimPacking(omnetpp::cCommBuffer *buffer, const std::map<K,V,Tr,A>& m)
+{
+    doParsimPacking(buffer, (int)m.size());
+    for (typename std::map<K,V,Tr,A>::const_iterator it = m.begin(); it != m.end(); ++it) {
+        doParsimPacking(buffer, it->first);
+        doParsimPacking(buffer, it->second);
+    }
+}
+
+template<typename K, typename V, typename Tr, typename A>
+void doParsimUnpacking(omnetpp::cCommBuffer *buffer, std::map<K,V,Tr,A>& m)
+{
+    int n;
+    doParsimUnpacking(buffer, n);
+    for (int i=0; i<n; i++) {
+        K k; V v;
+        doParsimUnpacking(buffer, k);
+        doParsimUnpacking(buffer, v);
+        m[k] = v;
+    }
+}
+
+// Default pack/unpack function for arrays
+template<typename T>
+void doParsimArrayPacking(omnetpp::cCommBuffer *b, const T *t, int n)
+{
+    for (int i = 0; i < n; i++)
+        doParsimPacking(b, t[i]);
+}
+
+template<typename T>
+void doParsimArrayUnpacking(omnetpp::cCommBuffer *b, T *t, int n)
+{
+    for (int i = 0; i < n; i++)
+        doParsimUnpacking(b, t[i]);
+}
+
+// Default rule to prevent compiler from choosing base class' doParsimPacking() function
+template<typename T>
+void doParsimPacking(omnetpp::cCommBuffer *, const T& t)
+{
+    throw omnetpp::cRuntimeError("Parsim error: No doParsimPacking() function for type %s", omnetpp::opp_typename(typeid(t)));
+}
+
+template<typename T>
+void doParsimUnpacking(omnetpp::cCommBuffer *, T& t)
+{
+    throw omnetpp::cRuntimeError("Parsim error: No doParsimUnpacking() function for type %s", omnetpp::opp_typename(typeid(t)));
+}
+
+}  // namespace omnetpp
+
+
+// forward
+template<typename T, typename A>
+std::ostream& operator<<(std::ostream& out, const std::vector<T,A>& vec);
+
+// Template rule which fires if a struct or class doesn't have operator<<
+template<typename T>
+inline std::ostream& operator<<(std::ostream& out,const T&) {return out;}
+
+// operator<< for std::vector<T>
+template<typename T, typename A>
+inline std::ostream& operator<<(std::ostream& out, const std::vector<T,A>& vec)
+{
+    out.put('{');
+    for(typename std::vector<T,A>::const_iterator it = vec.begin(); it != vec.end(); ++it)
+    {
+        if (it != vec.begin()) {
+            out.put(','); out.put(' ');
+        }
+        out << *it;
+    }
+    out.put('}');
+    
+    char buf[32];
+    sprintf(buf, " (size=%u)", (unsigned int)vec.size());
+    out.write(buf, strlen(buf));
+    return out;
+}
+
+Register_Class(Rst_stream)
+
+Rst_stream::Rst_stream() : ::omnetpp::cObject()
+{
+    this->type = 1;
+    this->stream_Id = 0;
+    this->application_Error_Code = 0;
+    this->final_Offset = 0;
+}
+
+Rst_stream::Rst_stream(const Rst_stream& other) : ::omnetpp::cObject(other)
+{
+    copy(other);
+}
+
+Rst_stream::~Rst_stream()
+{
+}
+
+Rst_stream& Rst_stream::operator=(const Rst_stream& other)
+{
+    if (this==&other) return *this;
+    ::omnetpp::cObject::operator=(other);
+    copy(other);
+    return *this;
+}
+
+void Rst_stream::copy(const Rst_stream& other)
+{
+    this->type = other.type;
+    this->stream_Id = other.stream_Id;
+    this->application_Error_Code = other.application_Error_Code;
+    this->final_Offset = other.final_Offset;
+}
+
+void Rst_stream::parsimPack(omnetpp::cCommBuffer *b) const
+{
+    doParsimPacking(b,this->type);
+    doParsimPacking(b,this->stream_Id);
+    doParsimPacking(b,this->application_Error_Code);
+    doParsimPacking(b,this->final_Offset);
+}
+
+void Rst_stream::parsimUnpack(omnetpp::cCommBuffer *b)
+{
+    doParsimUnpacking(b,this->type);
+    doParsimUnpacking(b,this->stream_Id);
+    doParsimUnpacking(b,this->application_Error_Code);
+    doParsimUnpacking(b,this->final_Offset);
+}
+
+uint8_t Rst_stream::getType() const
+{
+    return this->type;
+}
+
+void Rst_stream::setType(uint8_t type)
+{
+    this->type = type;
+}
+
+uint32_t Rst_stream::getStream_Id() const
+{
+    return this->stream_Id;
+}
+
+void Rst_stream::setStream_Id(uint32_t stream_Id)
+{
+    this->stream_Id = stream_Id;
+}
+
+uint16_t Rst_stream::getApplication_Error_Code() const
+{
+    return this->application_Error_Code;
+}
+
+void Rst_stream::setApplication_Error_Code(uint16_t application_Error_Code)
+{
+    this->application_Error_Code = application_Error_Code;
+}
+
+double Rst_stream::getFinal_Offset() const
+{
+    return this->final_Offset;
+}
+
+void Rst_stream::setFinal_Offset(double final_Offset)
+{
+    this->final_Offset = final_Offset;
+}
+
+class Rst_streamDescriptor : public omnetpp::cClassDescriptor
+{
+  private:
+    mutable const char **propertynames;
+  public:
+    Rst_streamDescriptor();
+    virtual ~Rst_streamDescriptor();
+
+    virtual bool doesSupport(omnetpp::cObject *obj) const override;
+    virtual const char **getPropertyNames() const override;
+    virtual const char *getProperty(const char *propertyname) const override;
+    virtual int getFieldCount() const override;
+    virtual const char *getFieldName(int field) const override;
+    virtual int findField(const char *fieldName) const override;
+    virtual unsigned int getFieldTypeFlags(int field) const override;
+    virtual const char *getFieldTypeString(int field) const override;
+    virtual const char **getFieldPropertyNames(int field) const override;
+    virtual const char *getFieldProperty(int field, const char *propertyname) const override;
+    virtual int getFieldArraySize(void *object, int field) const override;
+
+    virtual const char *getFieldDynamicTypeString(void *object, int field, int i) const override;
+    virtual std::string getFieldValueAsString(void *object, int field, int i) const override;
+    virtual bool setFieldValueAsString(void *object, int field, int i, const char *value) const override;
+
+    virtual const char *getFieldStructName(int field) const override;
+    virtual void *getFieldStructValuePointer(void *object, int field, int i) const override;
+};
+
+Register_ClassDescriptor(Rst_streamDescriptor)
+
+Rst_streamDescriptor::Rst_streamDescriptor() : omnetpp::cClassDescriptor("Rst_stream", "omnetpp::cObject")
+{
+    propertynames = nullptr;
+}
+
+Rst_streamDescriptor::~Rst_streamDescriptor()
+{
+    delete[] propertynames;
+}
+
+bool Rst_streamDescriptor::doesSupport(omnetpp::cObject *obj) const
+{
+    return dynamic_cast<Rst_stream *>(obj)!=nullptr;
+}
+
+const char **Rst_streamDescriptor::getPropertyNames() const
+{
+    if (!propertynames) {
+        static const char *names[] = {  nullptr };
+        omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
+        const char **basenames = basedesc ? basedesc->getPropertyNames() : nullptr;
+        propertynames = mergeLists(basenames, names);
+    }
+    return propertynames;
+}
+
+const char *Rst_streamDescriptor::getProperty(const char *propertyname) const
+{
+    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
+    return basedesc ? basedesc->getProperty(propertyname) : nullptr;
+}
+
+int Rst_streamDescriptor::getFieldCount() const
+{
+    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
+    return basedesc ? 4+basedesc->getFieldCount() : 4;
+}
+
+unsigned int Rst_streamDescriptor::getFieldTypeFlags(int field) const
+{
+    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
+    if (basedesc) {
+        if (field < basedesc->getFieldCount())
+            return basedesc->getFieldTypeFlags(field);
+        field -= basedesc->getFieldCount();
+    }
+    static unsigned int fieldTypeFlags[] = {
+        FD_ISEDITABLE,
+        FD_ISEDITABLE,
+        FD_ISEDITABLE,
+        FD_ISEDITABLE,
+    };
+    return (field>=0 && field<4) ? fieldTypeFlags[field] : 0;
+}
+
+const char *Rst_streamDescriptor::getFieldName(int field) const
+{
+    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
+    if (basedesc) {
+        if (field < basedesc->getFieldCount())
+            return basedesc->getFieldName(field);
+        field -= basedesc->getFieldCount();
+    }
+    static const char *fieldNames[] = {
+        "type",
+        "stream_Id",
+        "application_Error_Code",
+        "final_Offset",
+    };
+    return (field>=0 && field<4) ? fieldNames[field] : nullptr;
+}
+
+int Rst_streamDescriptor::findField(const char *fieldName) const
+{
+    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
+    int base = basedesc ? basedesc->getFieldCount() : 0;
+    if (fieldName[0]=='t' && strcmp(fieldName, "type")==0) return base+0;
+    if (fieldName[0]=='s' && strcmp(fieldName, "stream_Id")==0) return base+1;
+    if (fieldName[0]=='a' && strcmp(fieldName, "application_Error_Code")==0) return base+2;
+    if (fieldName[0]=='f' && strcmp(fieldName, "final_Offset")==0) return base+3;
+    return basedesc ? basedesc->findField(fieldName) : -1;
+}
+
+const char *Rst_streamDescriptor::getFieldTypeString(int field) const
+{
+    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
+    if (basedesc) {
+        if (field < basedesc->getFieldCount())
+            return basedesc->getFieldTypeString(field);
+        field -= basedesc->getFieldCount();
+    }
+    static const char *fieldTypeStrings[] = {
+        "uint8_t",
+        "uint32_t",
+        "uint16_t",
+        "double",
+    };
+    return (field>=0 && field<4) ? fieldTypeStrings[field] : nullptr;
+}
+
+const char **Rst_streamDescriptor::getFieldPropertyNames(int field) const
+{
+    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
+    if (basedesc) {
+        if (field < basedesc->getFieldCount())
+            return basedesc->getFieldPropertyNames(field);
+        field -= basedesc->getFieldCount();
+    }
+    switch (field) {
+        default: return nullptr;
+    }
+}
+
+const char *Rst_streamDescriptor::getFieldProperty(int field, const char *propertyname) const
+{
+    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
+    if (basedesc) {
+        if (field < basedesc->getFieldCount())
+            return basedesc->getFieldProperty(field, propertyname);
+        field -= basedesc->getFieldCount();
+    }
+    switch (field) {
+        default: return nullptr;
+    }
+}
+
+int Rst_streamDescriptor::getFieldArraySize(void *object, int field) const
+{
+    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
+    if (basedesc) {
+        if (field < basedesc->getFieldCount())
+            return basedesc->getFieldArraySize(object, field);
+        field -= basedesc->getFieldCount();
+    }
+    Rst_stream *pp = (Rst_stream *)object; (void)pp;
+    switch (field) {
+        default: return 0;
+    }
+}
+
+const char *Rst_streamDescriptor::getFieldDynamicTypeString(void *object, int field, int i) const
+{
+    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
+    if (basedesc) {
+        if (field < basedesc->getFieldCount())
+            return basedesc->getFieldDynamicTypeString(object,field,i);
+        field -= basedesc->getFieldCount();
+    }
+    Rst_stream *pp = (Rst_stream *)object; (void)pp;
+    switch (field) {
+        default: return nullptr;
+    }
+}
+
+std::string Rst_streamDescriptor::getFieldValueAsString(void *object, int field, int i) const
+{
+    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
+    if (basedesc) {
+        if (field < basedesc->getFieldCount())
+            return basedesc->getFieldValueAsString(object,field,i);
+        field -= basedesc->getFieldCount();
+    }
+    Rst_stream *pp = (Rst_stream *)object; (void)pp;
+    switch (field) {
+        case 0: return ulong2string(pp->getType());
+        case 1: return ulong2string(pp->getStream_Id());
+        case 2: return ulong2string(pp->getApplication_Error_Code());
+        case 3: return double2string(pp->getFinal_Offset());
+        default: return "";
+    }
+}
+
+bool Rst_streamDescriptor::setFieldValueAsString(void *object, int field, int i, const char *value) const
+{
+    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
+    if (basedesc) {
+        if (field < basedesc->getFieldCount())
+            return basedesc->setFieldValueAsString(object,field,i,value);
+        field -= basedesc->getFieldCount();
+    }
+    Rst_stream *pp = (Rst_stream *)object; (void)pp;
+    switch (field) {
+        case 0: pp->setType(string2ulong(value)); return true;
+        case 1: pp->setStream_Id(string2ulong(value)); return true;
+        case 2: pp->setApplication_Error_Code(string2ulong(value)); return true;
+        case 3: pp->setFinal_Offset(string2double(value)); return true;
+        default: return false;
+    }
+}
+
+const char *Rst_streamDescriptor::getFieldStructName(int field) const
+{
+    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
+    if (basedesc) {
+        if (field < basedesc->getFieldCount())
+            return basedesc->getFieldStructName(field);
+        field -= basedesc->getFieldCount();
+    }
+    switch (field) {
+        default: return nullptr;
+    };
+}
+
+void *Rst_streamDescriptor::getFieldStructValuePointer(void *object, int field, int i) const
+{
+    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
+    if (basedesc) {
+        if (field < basedesc->getFieldCount())
+            return basedesc->getFieldStructValuePointer(object, field, i);
+        field -= basedesc->getFieldCount();
+    }
+    Rst_stream *pp = (Rst_stream *)object; (void)pp;
+    switch (field) {
+        default: return nullptr;
+    }
+}
+
+

QUIC/Frames/rst_stream_m.h

@@ -0,0 +1,76 @@
+//
+// Generated file, do not edit! Created by nedtool 5.2 from Frames/rst_stream.msg.
+//
+
+#if defined(__clang__)
+#  pragma clang diagnostic ignored "-Wreserved-id-macro"
+#endif
+#ifndef __RST_STREAM_M_H
+#define __RST_STREAM_M_H
+
+#include <omnetpp.h>
+
+// nedtool version check
+#define MSGC_VERSION 0x0502
+#if (MSGC_VERSION!=OMNETPP_VERSION)
+#    error Version mismatch! Probably this file was generated by an earlier version of nedtool: 'make clean' should help.
+#endif
+
+
+
+/**
+ * Class generated from <tt>Frames/rst_stream.msg:19</tt> by nedtool.
+ * <pre>
+ * //
+ * // TODO generated message class
+ * //
+ * class Rst_stream
+ * {
+ *     uint8_t type = 1;
+ *     uint32_t stream_Id;
+ *     uint16_t application_Error_Code;
+ *     double final_Offset;
+ * }
+ * </pre>
+ */
+class Rst_stream : public ::omnetpp::cObject
+{
+  protected:
+    uint8_t type;
+    uint32_t stream_Id;
+    uint16_t application_Error_Code;
+    double final_Offset;
+
+  private:
+    void copy(const Rst_stream& other);
+
+  protected:
+    // protected and unimplemented operator==(), to prevent accidental usage
+    bool operator==(const Rst_stream&);
+
+  public:
+    Rst_stream();
+    Rst_stream(const Rst_stream& other);
+    virtual ~Rst_stream();
+    Rst_stream& operator=(const Rst_stream& other);
+    virtual Rst_stream *dup() const override {return new Rst_stream(*this);}
+    virtual void parsimPack(omnetpp::cCommBuffer *b) const override;
+    virtual void parsimUnpack(omnetpp::cCommBuffer *b) override;
+
+    // field getter/setter methods
+    virtual uint8_t getType() const;
+    virtual void setType(uint8_t type);
+    virtual uint32_t getStream_Id() const;
+    virtual void setStream_Id(uint32_t stream_Id);
+    virtual uint16_t getApplication_Error_Code() const;
+    virtual void setApplication_Error_Code(uint16_t application_Error_Code);
+    virtual double getFinal_Offset() const;
+    virtual void setFinal_Offset(double final_Offset);
+};
+
+inline void doParsimPacking(omnetpp::cCommBuffer *b, const Rst_stream& obj) {obj.parsimPack(b);}
+inline void doParsimUnpacking(omnetpp::cCommBuffer *b, Rst_stream& obj) {obj.parsimUnpack(b);}
+
+
+#endif // ifndef __RST_STREAM_M_H
+

QUIC/Frames/stop_Sending.msg

@@ -0,0 +1,23 @@
+//
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Lesser General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+// 
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU Lesser General Public License for more details.
+// 
+// You should have received a copy of the GNU Lesser General Public License
+// along with this program.  If not, see http://www.gnu.org/licenses/.
+// 
+
+//
+// TODO generated message class
+//
+class Stop_Sending {
+    uint8_t type = 12;
+    uint32_t stream_Id;
+    uint16_t application_Error_Code;
+}

QUIC/Frames/stop_Sending_m.cc

@@ -0,0 +1,498 @@
+//
+// Generated file, do not edit! Created by nedtool 5.2 from Frames/stop_Sending.msg.
+//
+
+// Disable warnings about unused variables, empty switch stmts, etc:
+#ifdef _MSC_VER
+#  pragma warning(disable:4101)
+#  pragma warning(disable:4065)
+#endif
+
+#if defined(__clang__)
+#  pragma clang diagnostic ignored "-Wshadow"
+#  pragma clang diagnostic ignored "-Wconversion"
+#  pragma clang diagnostic ignored "-Wunused-parameter"
+#  pragma clang diagnostic ignored "-Wc++98-compat"
+#  pragma clang diagnostic ignored "-Wunreachable-code-break"
+#  pragma clang diagnostic ignored "-Wold-style-cast"
+#elif defined(__GNUC__)
+#  pragma GCC diagnostic ignored "-Wshadow"
+#  pragma GCC diagnostic ignored "-Wconversion"
+#  pragma GCC diagnostic ignored "-Wunused-parameter"
+#  pragma GCC diagnostic ignored "-Wold-style-cast"
+#  pragma GCC diagnostic ignored "-Wsuggest-attribute=noreturn"
+#  pragma GCC diagnostic ignored "-Wfloat-conversion"
+#endif
+
+#include <iostream>
+#include <sstream>
+#include "stop_Sending_m.h"
+
+namespace omnetpp {
+
+// Template pack/unpack rules. They are declared *after* a1l type-specific pack functions for multiple reasons.
+// They are in the omnetpp namespace, to allow them to be found by argument-dependent lookup via the cCommBuffer argument
+
+// Packing/unpacking an std::vector
+template<typename T, typename A>
+void doParsimPacking(omnetpp::cCommBuffer *buffer, const std::vector<T,A>& v)
+{
+    int n = v.size();
+    doParsimPacking(buffer, n);
+    for (int i = 0; i < n; i++)
+        doParsimPacking(buffer, v[i]);
+}
+
+template<typename T, typename A>
+void doParsimUnpacking(omnetpp::cCommBuffer *buffer, std::vector<T,A>& v)
+{
+    int n;
+    doParsimUnpacking(buffer, n);
+    v.resize(n);
+    for (int i = 0; i < n; i++)
+        doParsimUnpacking(buffer, v[i]);
+}
+
+// Packing/unpacking an std::list
+template<typename T, typename A>
+void doParsimPacking(omnetpp::cCommBuffer *buffer, const std::list<T,A>& l)
+{
+    doParsimPacking(buffer, (int)l.size());
+    for (typename std::list<T,A>::const_iterator it = l.begin(); it != l.end(); ++it)
+        doParsimPacking(buffer, (T&)*it);
+}
+
+template<typename T, typename A>
+void doParsimUnpacking(omnetpp::cCommBuffer *buffer, std::list<T,A>& l)
+{
+    int n;
+    doParsimUnpacking(buffer, n);
+    for (int i=0; i<n; i++) {
+        l.push_back(T());
+        doParsimUnpacking(buffer, l.back());
+    }
+}
+
+// Packing/unpacking an std::set
+template<typename T, typename Tr, typename A>
+void doParsimPacking(omnetpp::cCommBuffer *buffer, const std::set<T,Tr,A>& s)
+{
+    doParsimPacking(buffer, (int)s.size());
+    for (typename std::set<T,Tr,A>::const_iterator it = s.begin(); it != s.end(); ++it)
+        doParsimPacking(buffer, *it);
+}
+
+template<typename T, typename Tr, typename A>
+void doParsimUnpacking(omnetpp::cCommBuffer *buffer, std::set<T,Tr,A>& s)
+{
+    int n;
+    doParsimUnpacking(buffer, n);
+    for (int i=0; i<n; i++) {
+        T x;
+        doParsimUnpacking(buffer, x);
+        s.insert(x);
+    }
+}
+
+// Packing/unpacking an std::map
+template<typename K, typename V, typename Tr, typename A>
+void doParsimPacking(omnetpp::cCommBuffer *buffer, const std::map<K,V,Tr,A>& m)
+{
+    doParsimPacking(buffer, (int)m.size());
+    for (typename std::map<K,V,Tr,A>::const_iterator it = m.begin(); it != m.end(); ++it) {
+        doParsimPacking(buffer, it->first);
+        doParsimPacking(buffer, it->second);
+    }
+}
+
+template<typename K, typename V, typename Tr, typename A>
+void doParsimUnpacking(omnetpp::cCommBuffer *buffer, std::map<K,V,Tr,A>& m)
+{
+    int n;
+    doParsimUnpacking(buffer, n);
+    for (int i=0; i<n; i++) {
+        K k; V v;
+        doParsimUnpacking(buffer, k);
+        doParsimUnpacking(buffer, v);
+        m[k] = v;
+    }
+}
+
+// Default pack/unpack function for arrays
+template<typename T>
+void doParsimArrayPacking(omnetpp::cCommBuffer *b, const T *t, int n)
+{
+    for (int i = 0; i < n; i++)
+        doParsimPacking(b, t[i]);
+}
+
+template<typename T>
+void doParsimArrayUnpacking(omnetpp::cCommBuffer *b, T *t, int n)
+{
+    for (int i = 0; i < n; i++)
+        doParsimUnpacking(b, t[i]);
+}
+
+// Default rule to prevent compiler from choosing base class' doParsimPacking() function
+template<typename T>
+void doParsimPacking(omnetpp::cCommBuffer *, const T& t)
+{
+    throw omnetpp::cRuntimeError("Parsim error: No doParsimPacking() function for type %s", omnetpp::opp_typename(typeid(t)));
+}
+
+template<typename T>
+void doParsimUnpacking(omnetpp::cCommBuffer *, T& t)
+{
+    throw omnetpp::cRuntimeError("Parsim error: No doParsimUnpacking() function for type %s", omnetpp::opp_typename(typeid(t)));
+}
+
+}  // namespace omnetpp
+
+
+// forward
+template<typename T, typename A>
+std::ostream& operator<<(std::ostream& out, const std::vector<T,A>& vec);
+
+// Template rule which fires if a struct or class doesn't have operator<<
+template<typename T>
+inline std::ostream& operator<<(std::ostream& out,const T&) {return out;}
+
+// operator<< for std::vector<T>
+template<typename T, typename A>
+inline std::ostream& operator<<(std::ostream& out, const std::vector<T,A>& vec)
+{
+    out.put('{');
+    for(typename std::vector<T,A>::const_iterator it = vec.begin(); it != vec.end(); ++it)
+    {
+        if (it != vec.begin()) {
+            out.put(','); out.put(' ');
+        }
+        out << *it;
+    }
+    out.put('}');
+    
+    char buf[32];
+    sprintf(buf, " (size=%u)", (unsigned int)vec.size());
+    out.write(buf, strlen(buf));
+    return out;
+}
+
+Register_Class(Stop_Sending)
+
+Stop_Sending::Stop_Sending() : ::omnetpp::cObject()
+{
+    this->type = 12;
+    this->stream_Id = 0;
+    this->application_Error_Code = 0;
+}
+
+Stop_Sending::Stop_Sending(const Stop_Sending& other) : ::omnetpp::cObject(other)
+{
+    copy(other);
+}
+
+Stop_Sending::~Stop_Sending()
+{
+}
+
+Stop_Sending& Stop_Sending::operator=(const Stop_Sending& other)
+{
+    if (this==&other) return *this;
+    ::omnetpp::cObject::operator=(other);
+    copy(other);
+    return *this;
+}
+
+void Stop_Sending::copy(const Stop_Sending& other)
+{
+    this->type = other.type;
+    this->stream_Id = other.stream_Id;
+    this->application_Error_Code = other.application_Error_Code;
+}
+
+void Stop_Sending::parsimPack(omnetpp::cCommBuffer *b) const
+{
+    doParsimPacking(b,this->type);
+    doParsimPacking(b,this->stream_Id);
+    doParsimPacking(b,this->application_Error_Code);
+}
+
+void Stop_Sending::parsimUnpack(omnetpp::cCommBuffer *b)
+{
+    doParsimUnpacking(b,this->type);
+    doParsimUnpacking(b,this->stream_Id);
+    doParsimUnpacking(b,this->application_Error_Code);
+}
+
+uint8_t Stop_Sending::getType() const
+{
+    return this->type;
+}
+
+void Stop_Sending::setType(uint8_t type)
+{
+    this->type = type;
+}
+
+uint32_t Stop_Sending::getStream_Id() const
+{
+    return this->stream_Id;
+}
+
+void Stop_Sending::setStream_Id(uint32_t stream_Id)
+{
+    this->stream_Id = stream_Id;
+}
+
+uint16_t Stop_Sending::getApplication_Error_Code() const
+{
+    return this->application_Error_Code;
+}
+
+void Stop_Sending::setApplication_Error_Code(uint16_t application_Error_Code)
+{
+    this->application_Error_Code = application_Error_Code;
+}
+
+class Stop_SendingDescriptor : public omnetpp::cClassDescriptor
+{
+  private:
+    mutable const char **propertynames;
+  public:
+    Stop_SendingDescriptor();
+    virtual ~Stop_SendingDescriptor();
+
+    virtual bool doesSupport(omnetpp::cObject *obj) const override;
+    virtual const char **getPropertyNames() const override;
+    virtual const char *getProperty(const char *propertyname) const override;
+    virtual int getFieldCount() const override;
+    virtual const char *getFieldName(int field) const override;
+    virtual int findField(const char *fieldName) const override;
+    virtual unsigned int getFieldTypeFlags(int field) const override;
+    virtual const char *getFieldTypeString(int field) const override;
+    virtual const char **getFieldPropertyNames(int field) const override;
+    virtual const char *getFieldProperty(int field, const char *propertyname) const override;
+    virtual int getFieldArraySize(void *object, int field) const override;
+
+    virtual const char *getFieldDynamicTypeString(void *object, int field, int i) const override;
+    virtual std::string getFieldValueAsString(void *object, int field, int i) const override;
+    virtual bool setFieldValueAsString(void *object, int field, int i, const char *value) const override;
+
+    virtual const char *getFieldStructName(int field) const override;
+    virtual void *getFieldStructValuePointer(void *object, int field, int i) const override;
+};
+
+Register_ClassDescriptor(Stop_SendingDescriptor)
+
+Stop_SendingDescriptor::Stop_SendingDescriptor() : omnetpp::cClassDescriptor("Stop_Sending", "omnetpp::cObject")
+{
+    propertynames = nullptr;
+}
+
+Stop_SendingDescriptor::~Stop_SendingDescriptor()
+{
+    delete[] propertynames;
+}
+
+bool Stop_SendingDescriptor::doesSupport(omnetpp::cObject *obj) const
+{
+    return dynamic_cast<Stop_Sending *>(obj)!=nullptr;
+}
+
+const char **Stop_SendingDescriptor::getPropertyNames() const
+{
+    if (!propertynames) {
+        static const char *names[] = {  nullptr };
+        omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
+        const char **basenames = basedesc ? basedesc->getPropertyNames() : nullptr;
+        propertynames = mergeLists(basenames, names);
+    }
+    return propertynames;
+}
+
+const char *Stop_SendingDescriptor::getProperty(const char *propertyname) const
+{
+    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
+    return basedesc ? basedesc->getProperty(propertyname) : nullptr;
+}
+
+int Stop_SendingDescriptor::getFieldCount() const
+{
+    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
+    return basedesc ? 3+basedesc->getFieldCount() : 3;
+}
+
+unsigned int Stop_SendingDescriptor::getFieldTypeFlags(int field) const
+{
+    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
+    if (basedesc) {
+        if (field < basedesc->getFieldCount())
+            return basedesc->getFieldTypeFlags(field);
+        field -= basedesc->getFieldCount();
+    }
+    static unsigned int fieldTypeFlags[] = {
+        FD_ISEDITABLE,
+        FD_ISEDITABLE,
+        FD_ISEDITABLE,
+    };
+    return (field>=0 && field<3) ? fieldTypeFlags[field] : 0;
+}
+
+const char *Stop_SendingDescriptor::getFieldName(int field) const
+{
+    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
+    if (basedesc) {
+        if (field < basedesc->getFieldCount())
+            return basedesc->getFieldName(field);
+        field -= basedesc->getFieldCount();
+    }
+    static const char *fieldNames[] = {
+        "type",
+        "stream_Id",
+        "application_Error_Code",
+    };
+    return (field>=0 && field<3) ? fieldNames[field] : nullptr;
+}
+
+int Stop_SendingDescriptor::findField(const char *fieldName) const
+{
+    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
+    int base = basedesc ? basedesc->getFieldCount() : 0;
+    if (fieldName[0]=='t' && strcmp(fieldName, "type")==0) return base+0;
+    if (fieldName[0]=='s' && strcmp(fieldName, "stream_Id")==0) return base+1;
+    if (fieldName[0]=='a' && strcmp(fieldName, "application_Error_Code")==0) return base+2;
+    return basedesc ? basedesc->findField(fieldName) : -1;
+}
+
+const char *Stop_SendingDescriptor::getFieldTypeString(int field) const
+{
+    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
+    if (basedesc) {
+        if (field < basedesc->getFieldCount())
+            return basedesc->getFieldTypeString(field);
+        field -= basedesc->getFieldCount();
+    }
+    static const char *fieldTypeStrings[] = {
+        "uint8_t",
+        "uint32_t",
+        "uint16_t",
+    };
+    return (field>=0 && field<3) ? fieldTypeStrings[field] : nullptr;
+}
+
+const char **Stop_SendingDescriptor::getFieldPropertyNames(int field) const
+{
+    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
+    if (basedesc) {
+        if (field < basedesc->getFieldCount())
+            return basedesc->getFieldPropertyNames(field);
+        field -= basedesc->getFieldCount();
+    }
+    switch (field) {
+        default: return nullptr;
+    }
+}
+
+const char *Stop_SendingDescriptor::getFieldProperty(int field, const char *propertyname) const
+{
+    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
+    if (basedesc) {
+        if (field < basedesc->getFieldCount())
+            return basedesc->getFieldProperty(field, propertyname);
+        field -= basedesc->getFieldCount();
+    }
+    switch (field) {
+        default: return nullptr;
+    }
+}
+
+int Stop_SendingDescriptor::getFieldArraySize(void *object, int field) const
+{
+    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
+    if (basedesc) {
+        if (field < basedesc->getFieldCount())
+            return basedesc->getFieldArraySize(object, field);
+        field -= basedesc->getFieldCount();
+    }
+    Stop_Sending *pp = (Stop_Sending *)object; (void)pp;
+    switch (field) {
+        default: return 0;
+    }
+}
+
+const char *Stop_SendingDescriptor::getFieldDynamicTypeString(void *object, int field, int i) const
+{
+    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
+    if (basedesc) {
+        if (field < basedesc->getFieldCount())
+            return basedesc->getFieldDynamicTypeString(object,field,i);
+        field -= basedesc->getFieldCount();
+    }
+    Stop_Sending *pp = (Stop_Sending *)object; (void)pp;
+    switch (field) {
+        default: return nullptr;
+    }
+}
+
+std::string Stop_SendingDescriptor::getFieldValueAsString(void *object, int field, int i) const
+{
+    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
+    if (basedesc) {
+        if (field < basedesc->getFieldCount())
+            return basedesc->getFieldValueAsString(object,field,i);
+        field -= basedesc->getFieldCount();
+    }
+    Stop_Sending *pp = (Stop_Sending *)object; (void)pp;
+    switch (field) {
+        case 0: return ulong2string(pp->getType());
+        case 1: return ulong2string(pp->getStream_Id());
+        case 2: return ulong2string(pp->getApplication_Error_Code());
+        default: return "";
+    }
+}
+
+bool Stop_SendingDescriptor::setFieldValueAsString(void *object, int field, int i, const char *value) const
+{
+    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
+    if (basedesc) {
+        if (field < basedesc->getFieldCount())
+            return basedesc->setFieldValueAsString(object,field,i,value);
+        field -= basedesc->getFieldCount();
+    }
+    Stop_Sending *pp = (Stop_Sending *)object; (void)pp;
+    switch (field) {
+        case 0: pp->setType(string2ulong(value)); return true;
+        case 1: pp->setStream_Id(string2ulong(value)); return true;
+        case 2: pp->setApplication_Error_Code(string2ulong(value)); return true;
+        default: return false;
+    }
+}
+
+const char *Stop_SendingDescriptor::getFieldStructName(int field) const
+{
+    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
+    if (basedesc) {
+        if (field < basedesc->getFieldCount())
+            return basedesc->getFieldStructName(field);
+        field -= basedesc->getFieldCount();
+    }
+    switch (field) {
+        default: return nullptr;
+    };
+}
+
+void *Stop_SendingDescriptor::getFieldStructValuePointer(void *object, int field, int i) const
+{
+    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
+    if (basedesc) {
+        if (field < basedesc->getFieldCount())
+            return basedesc->getFieldStructValuePointer(object, field, i);
+        field -= basedesc->getFieldCount();
+    }
+    Stop_Sending *pp = (Stop_Sending *)object; (void)pp;
+    switch (field) {
+        default: return nullptr;
+    }
+}
+
+

QUIC/Frames/stop_Sending_m.h

@@ -0,0 +1,72 @@
+//
+// Generated file, do not edit! Created by nedtool 5.2 from Frames/stop_Sending.msg.
+//
+
+#if defined(__clang__)
+#  pragma clang diagnostic ignored "-Wreserved-id-macro"
+#endif
+#ifndef __STOP_SENDING_M_H
+#define __STOP_SENDING_M_H
+
+#include <omnetpp.h>
+
+// nedtool version check
+#define MSGC_VERSION 0x0502
+#if (MSGC_VERSION!=OMNETPP_VERSION)
+#    error Version mismatch! Probably this file was generated by an earlier version of nedtool: 'make clean' should help.
+#endif
+
+
+
+/**
+ * Class generated from <tt>Frames/stop_Sending.msg:19</tt> by nedtool.
+ * <pre>
+ * //
+ * // TODO generated message class
+ * //
+ * class Stop_Sending
+ * {
+ *     uint8_t type = 12;
+ *     uint32_t stream_Id;
+ *     uint16_t application_Error_Code;
+ * }
+ * </pre>
+ */
+class Stop_Sending : public ::omnetpp::cObject
+{
+  protected:
+    uint8_t type;
+    uint32_t stream_Id;
+    uint16_t application_Error_Code;
+
+  private:
+    void copy(const Stop_Sending& other);
+
+  protected:
+    // protected and unimplemented operator==(), to prevent accidental usage
+    bool operator==(const Stop_Sending&);
+
+  public:
+    Stop_Sending();
+    Stop_Sending(const Stop_Sending& other);
+    virtual ~Stop_Sending();
+    Stop_Sending& operator=(const Stop_Sending& other);
+    virtual Stop_Sending *dup() const override {return new Stop_Sending(*this);}
+    virtual void parsimPack(omnetpp::cCommBuffer *b) const override;
+    virtual void parsimUnpack(omnetpp::cCommBuffer *b) override;
+
+    // field getter/setter methods
+    virtual uint8_t getType() const;
+    virtual void setType(uint8_t type);
+    virtual uint32_t getStream_Id() const;
+    virtual void setStream_Id(uint32_t stream_Id);
+    virtual uint16_t getApplication_Error_Code() const;
+    virtual void setApplication_Error_Code(uint16_t application_Error_Code);
+};
+
+inline void doParsimPacking(omnetpp::cCommBuffer *b, const Stop_Sending& obj) {obj.parsimPack(b);}
+inline void doParsimUnpacking(omnetpp::cCommBuffer *b, Stop_Sending& obj) {obj.parsimUnpack(b);}
+
+
+#endif // ifndef __STOP_SENDING_M_H
+

QUIC/Frames/stream.msg

@@ -0,0 +1,25 @@
+//
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Lesser General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+// 
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU Lesser General Public License for more details.
+// 
+// You should have received a copy of the GNU Lesser General Public License
+// along with this program.  If not, see http://www.gnu.org/licenses/.
+// 
+
+//
+// TODO generated message class
+//
+class Stream {
+    uint8_t type;
+    uint32_t stream_Id;
+    uint64_t offset;
+    uint16_t data_Length;
+    string stream_Data;
+}

QUIC/Frames/stream_Blocked.msg

@@ -0,0 +1,22 @@
+//
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Lesser General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+// 
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU Lesser General Public License for more details.
+// 
+// You should have received a copy of the GNU Lesser General Public License
+// along with this program.  If not, see http://www.gnu.org/licenses/.
+// 
+
+//
+// TODO generated message class
+//
+class Stream_Blocked {
+    uint8_t type = 9;
+    uint32_t stream_Id;
+}

QUIC/Frames/stream_Blocked_m.cc

@@ -0,0 +1,478 @@
+//
+// Generated file, do not edit! Created by nedtool 5.2 from Frames/stream_Blocked.msg.
+//
+
+// Disable warnings about unused variables, empty switch stmts, etc:
+#ifdef _MSC_VER
+#  pragma warning(disable:4101)
+#  pragma warning(disable:4065)
+#endif
+
+#if defined(__clang__)
+#  pragma clang diagnostic ignored "-Wshadow"
+#  pragma clang diagnostic ignored "-Wconversion"
+#  pragma clang diagnostic ignored "-Wunused-parameter"
+#  pragma clang diagnostic ignored "-Wc++98-compat"
+#  pragma clang diagnostic ignored "-Wunreachable-code-break"
+#  pragma clang diagnostic ignored "-Wold-style-cast"
+#elif defined(__GNUC__)
+#  pragma GCC diagnostic ignored "-Wshadow"
+#  pragma GCC diagnostic ignored "-Wconversion"
+#  pragma GCC diagnostic ignored "-Wunused-parameter"
+#  pragma GCC diagnostic ignored "-Wold-style-cast"
+#  pragma GCC diagnostic ignored "-Wsuggest-attribute=noreturn"
+#  pragma GCC diagnostic ignored "-Wfloat-conversion"
+#endif
+
+#include <iostream>
+#include <sstream>
+#include "stream_Blocked_m.h"
+
+namespace omnetpp {
+
+// Template pack/unpack rules. They are declared *after* a1l type-specific pack functions for multiple reasons.
+// They are in the omnetpp namespace, to allow them to be found by argument-dependent lookup via the cCommBuffer argument
+
+// Packing/unpacking an std::vector
+template<typename T, typename A>
+void doParsimPacking(omnetpp::cCommBuffer *buffer, const std::vector<T,A>& v)
+{
+    int n = v.size();
+    doParsimPacking(buffer, n);
+    for (int i = 0; i < n; i++)
+        doParsimPacking(buffer, v[i]);
+}
+
+template<typename T, typename A>
+void doParsimUnpacking(omnetpp::cCommBuffer *buffer, std::vector<T,A>& v)
+{
+    int n;
+    doParsimUnpacking(buffer, n);
+    v.resize(n);
+    for (int i = 0; i < n; i++)
+        doParsimUnpacking(buffer, v[i]);
+}
+
+// Packing/unpacking an std::list
+template<typename T, typename A>
+void doParsimPacking(omnetpp::cCommBuffer *buffer, const std::list<T,A>& l)
+{
+    doParsimPacking(buffer, (int)l.size());
+    for (typename std::list<T,A>::const_iterator it = l.begin(); it != l.end(); ++it)
+        doParsimPacking(buffer, (T&)*it);
+}
+
+template<typename T, typename A>
+void doParsimUnpacking(omnetpp::cCommBuffer *buffer, std::list<T,A>& l)
+{
+    int n;
+    doParsimUnpacking(buffer, n);
+    for (int i=0; i<n; i++) {
+        l.push_back(T());
+        doParsimUnpacking(buffer, l.back());
+    }
+}
+
+// Packing/unpacking an std::set
+template<typename T, typename Tr, typename A>
+void doParsimPacking(omnetpp::cCommBuffer *buffer, const std::set<T,Tr,A>& s)
+{
+    doParsimPacking(buffer, (int)s.size());
+    for (typename std::set<T,Tr,A>::const_iterator it = s.begin(); it != s.end(); ++it)
+        doParsimPacking(buffer, *it);
+}
+
+template<typename T, typename Tr, typename A>
+void doParsimUnpacking(omnetpp::cCommBuffer *buffer, std::set<T,Tr,A>& s)
+{
+    int n;
+    doParsimUnpacking(buffer, n);
+    for (int i=0; i<n; i++) {
+        T x;
+        doParsimUnpacking(buffer, x);
+        s.insert(x);
+    }
+}
+
+// Packing/unpacking an std::map
+template<typename K, typename V, typename Tr, typename A>
+void doParsimPacking(omnetpp::cCommBuffer *buffer, const std::map<K,V,Tr,A>& m)
+{
+    doParsimPacking(buffer, (int)m.size());
+    for (typename std::map<K,V,Tr,A>::const_iterator it = m.begin(); it != m.end(); ++it) {
+        doParsimPacking(buffer, it->first);
+        doParsimPacking(buffer, it->second);
+    }
+}
+
+template<typename K, typename V, typename Tr, typename A>
+void doParsimUnpacking(omnetpp::cCommBuffer *buffer, std::map<K,V,Tr,A>& m)
+{
+    int n;
+    doParsimUnpacking(buffer, n);
+    for (int i=0; i<n; i++) {
+        K k; V v;
+        doParsimUnpacking(buffer, k);
+        doParsimUnpacking(buffer, v);
+        m[k] = v;
+    }
+}
+
+// Default pack/unpack function for arrays
+template<typename T>
+void doParsimArrayPacking(omnetpp::cCommBuffer *b, const T *t, int n)
+{
+    for (int i = 0; i < n; i++)
+        doParsimPacking(b, t[i]);
+}
+
+template<typename T>
+void doParsimArrayUnpacking(omnetpp::cCommBuffer *b, T *t, int n)
+{
+    for (int i = 0; i < n; i++)
+        doParsimUnpacking(b, t[i]);
+}
+
+// Default rule to prevent compiler from choosing base class' doParsimPacking() function
+template<typename T>
+void doParsimPacking(omnetpp::cCommBuffer *, const T& t)
+{
+    throw omnetpp::cRuntimeError("Parsim error: No doParsimPacking() function for type %s", omnetpp::opp_typename(typeid(t)));
+}
+
+template<typename T>
+void doParsimUnpacking(omnetpp::cCommBuffer *, T& t)
+{
+    throw omnetpp::cRuntimeError("Parsim error: No doParsimUnpacking() function for type %s", omnetpp::opp_typename(typeid(t)));
+}
+
+}  // namespace omnetpp
+
+
+// forward
+template<typename T, typename A>
+std::ostream& operator<<(std::ostream& out, const std::vector<T,A>& vec);
+
+// Template rule which fires if a struct or class doesn't have operator<<
+template<typename T>
+inline std::ostream& operator<<(std::ostream& out,const T&) {return out;}
+
+// operator<< for std::vector<T>
+template<typename T, typename A>
+inline std::ostream& operator<<(std::ostream& out, const std::vector<T,A>& vec)
+{
+    out.put('{');
+    for(typename std::vector<T,A>::const_iterator it = vec.begin(); it != vec.end(); ++it)
+    {
+        if (it != vec.begin()) {
+            out.put(','); out.put(' ');
+        }
+        out << *it;
+    }
+    out.put('}');
+    
+    char buf[32];
+    sprintf(buf, " (size=%u)", (unsigned int)vec.size());
+    out.write(buf, strlen(buf));
+    return out;
+}
+
+Register_Class(Stream_Blocked)
+
+Stream_Blocked::Stream_Blocked() : ::omnetpp::cObject()
+{
+    this->type = 9;
+    this->stream_Id = 0;
+}
+
+Stream_Blocked::Stream_Blocked(const Stream_Blocked& other) : ::omnetpp::cObject(other)
+{
+    copy(other);
+}
+
+Stream_Blocked::~Stream_Blocked()
+{
+}
+
+Stream_Blocked& Stream_Blocked::operator=(const Stream_Blocked& other)
+{
+    if (this==&other) return *this;
+    ::omnetpp::cObject::operator=(other);
+    copy(other);
+    return *this;
+}
+
+void Stream_Blocked::copy(const Stream_Blocked& other)
+{
+    this->type = other.type;
+    this->stream_Id = other.stream_Id;
+}
+
+void Stream_Blocked::parsimPack(omnetpp::cCommBuffer *b) const
+{
+    doParsimPacking(b,this->type);
+    doParsimPacking(b,this->stream_Id);
+}
+
+void Stream_Blocked::parsimUnpack(omnetpp::cCommBuffer *b)
+{
+    doParsimUnpacking(b,this->type);
+    doParsimUnpacking(b,this->stream_Id);
+}
+
+uint8_t Stream_Blocked::getType() const
+{
+    return this->type;
+}
+
+void Stream_Blocked::setType(uint8_t type)
+{
+    this->type = type;
+}
+
+uint32_t Stream_Blocked::getStream_Id() const
+{
+    return this->stream_Id;
+}
+
+void Stream_Blocked::setStream_Id(uint32_t stream_Id)
+{
+    this->stream_Id = stream_Id;
+}
+
+class Stream_BlockedDescriptor : public omnetpp::cClassDescriptor
+{
+  private:
+    mutable const char **propertynames;
+  public:
+    Stream_BlockedDescriptor();
+    virtual ~Stream_BlockedDescriptor();
+
+    virtual bool doesSupport(omnetpp::cObject *obj) const override;
+    virtual const char **getPropertyNames() const override;
+    virtual const char *getProperty(const char *propertyname) const override;
+    virtual int getFieldCount() const override;
+    virtual const char *getFieldName(int field) const override;
+    virtual int findField(const char *fieldName) const override;
+    virtual unsigned int getFieldTypeFlags(int field) const override;
+    virtual const char *getFieldTypeString(int field) const override;
+    virtual const char **getFieldPropertyNames(int field) const override;
+    virtual const char *getFieldProperty(int field, const char *propertyname) const override;
+    virtual int getFieldArraySize(void *object, int field) const override;
+
+    virtual const char *getFieldDynamicTypeString(void *object, int field, int i) const override;
+    virtual std::string getFieldValueAsString(void *object, int field, int i) const override;
+    virtual bool setFieldValueAsString(void *object, int field, int i, const char *value) const override;
+
+    virtual const char *getFieldStructName(int field) const override;
+    virtual void *getFieldStructValuePointer(void *object, int field, int i) const override;
+};
+
+Register_ClassDescriptor(Stream_BlockedDescriptor)
+
+Stream_BlockedDescriptor::Stream_BlockedDescriptor() : omnetpp::cClassDescriptor("Stream_Blocked", "omnetpp::cObject")
+{
+    propertynames = nullptr;
+}
+
+Stream_BlockedDescriptor::~Stream_BlockedDescriptor()
+{
+    delete[] propertynames;
+}
+
+bool Stream_BlockedDescriptor::doesSupport(omnetpp::cObject *obj) const
+{
+    return dynamic_cast<Stream_Blocked *>(obj)!=nullptr;
+}
+
+const char **Stream_BlockedDescriptor::getPropertyNames() const
+{
+    if (!propertynames) {
+        static const char *names[] = {  nullptr };
+        omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
+        const char **basenames = basedesc ? basedesc->getPropertyNames() : nullptr;
+        propertynames = mergeLists(basenames, names);
+    }
+    return propertynames;
+}
+
+const char *Stream_BlockedDescriptor::getProperty(const char *propertyname) const
+{
+    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
+    return basedesc ? basedesc->getProperty(propertyname) : nullptr;
+}
+
+int Stream_BlockedDescriptor::getFieldCount() const
+{
+    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
+    return basedesc ? 2+basedesc->getFieldCount() : 2;
+}
+
+unsigned int Stream_BlockedDescriptor::getFieldTypeFlags(int field) const
+{
+    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
+    if (basedesc) {
+        if (field < basedesc->getFieldCount())
+            return basedesc->getFieldTypeFlags(field);
+        field -= basedesc->getFieldCount();
+    }
+    static unsigned int fieldTypeFlags[] = {
+        FD_ISEDITABLE,
+        FD_ISEDITABLE,
+    };
+    return (field>=0 && field<2) ? fieldTypeFlags[field] : 0;
+}
+
+const char *Stream_BlockedDescriptor::getFieldName(int field) const
+{
+    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
+    if (basedesc) {
+        if (field < basedesc->getFieldCount())
+            return basedesc->getFieldName(field);
+        field -= basedesc->getFieldCount();
+    }
+    static const char *fieldNames[] = {
+        "type",
+        "stream_Id",
+    };
+    return (field>=0 && field<2) ? fieldNames[field] : nullptr;
+}
+
+int Stream_BlockedDescriptor::findField(const char *fieldName) const
+{
+    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
+    int base = basedesc ? basedesc->getFieldCount() : 0;
+    if (fieldName[0]=='t' && strcmp(fieldName, "type")==0) return base+0;
+    if (fieldName[0]=='s' && strcmp(fieldName, "stream_Id")==0) return base+1;
+    return basedesc ? basedesc->findField(fieldName) : -1;
+}
+
+const char *Stream_BlockedDescriptor::getFieldTypeString(int field) const
+{
+    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
+    if (basedesc) {
+        if (field < basedesc->getFieldCount())
+            return basedesc->getFieldTypeString(field);
+        field -= basedesc->getFieldCount();
+    }
+    static const char *fieldTypeStrings[] = {
+        "uint8_t",
+        "uint32_t",
+    };
+    return (field>=0 && field<2) ? fieldTypeStrings[field] : nullptr;
+}
+
+const char **Stream_BlockedDescriptor::getFieldPropertyNames(int field) const
+{
+    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
+    if (basedesc) {
+        if (field < basedesc->getFieldCount())
+            return basedesc->getFieldPropertyNames(field);
+        field -= basedesc->getFieldCount();
+    }
+    switch (field) {
+        default: return nullptr;
+    }
+}
+
+const char *Stream_BlockedDescriptor::getFieldProperty(int field, const char *propertyname) const
+{
+    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
+    if (basedesc) {
+        if (field < basedesc->getFieldCount())
+            return basedesc->getFieldProperty(field, propertyname);
+        field -= basedesc->getFieldCount();
+    }
+    switch (field) {
+        default: return nullptr;
+    }
+}
+
+int Stream_BlockedDescriptor::getFieldArraySize(void *object, int field) const
+{
+    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
+    if (basedesc) {
+        if (field < basedesc->getFieldCount())
+            return basedesc->getFieldArraySize(object, field);
+        field -= basedesc->getFieldCount();
+    }
+    Stream_Blocked *pp = (Stream_Blocked *)object; (void)pp;
+    switch (field) {
+        default: return 0;
+    }
+}
+
+const char *Stream_BlockedDescriptor::getFieldDynamicTypeString(void *object, int field, int i) const
+{
+    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
+    if (basedesc) {
+        if (field < basedesc->getFieldCount())
+            return basedesc->getFieldDynamicTypeString(object,field,i);
+        field -= basedesc->getFieldCount();
+    }
+    Stream_Blocked *pp = (Stream_Blocked *)object; (void)pp;
+    switch (field) {
+        default: return nullptr;
+    }
+}
+
+std::string Stream_BlockedDescriptor::getFieldValueAsString(void *object, int field, int i) const
+{
+    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
+    if (basedesc) {
+        if (field < basedesc->getFieldCount())
+            return basedesc->getFieldValueAsString(object,field,i);
+        field -= basedesc->getFieldCount();
+    }
+    Stream_Blocked *pp = (Stream_Blocked *)object; (void)pp;
+    switch (field) {
+        case 0: return ulong2string(pp->getType());
+        case 1: return ulong2string(pp->getStream_Id());
+        default: return "";
+    }
+}
+
+bool Stream_BlockedDescriptor::setFieldValueAsString(void *object, int field, int i, const char *value) const
+{
+    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
+    if (basedesc) {
+        if (field < basedesc->getFieldCount())
+            return basedesc->setFieldValueAsString(object,field,i,value);
+        field -= basedesc->getFieldCount();
+    }
+    Stream_Blocked *pp = (Stream_Blocked *)object; (void)pp;
+    switch (field) {
+        case 0: pp->setType(string2ulong(value)); return true;
+        case 1: pp->setStream_Id(string2ulong(value)); return true;
+        default: return false;
+    }
+}
+
+const char *Stream_BlockedDescriptor::getFieldStructName(int field) const
+{
+    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
+    if (basedesc) {
+        if (field < basedesc->getFieldCount())
+            return basedesc->getFieldStructName(field);
+        field -= basedesc->getFieldCount();
+    }
+    switch (field) {
+        default: return nullptr;
+    };
+}
+
+void *Stream_BlockedDescriptor::getFieldStructValuePointer(void *object, int field, int i) const
+{
+    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
+    if (basedesc) {
+        if (field < basedesc->getFieldCount())
+            return basedesc->getFieldStructValuePointer(object, field, i);
+        field -= basedesc->getFieldCount();
+    }
+    Stream_Blocked *pp = (Stream_Blocked *)object; (void)pp;
+    switch (field) {
+        default: return nullptr;
+    }
+}
+
+

QUIC/Frames/stream_Blocked_m.h

@@ -0,0 +1,68 @@
+//
+// Generated file, do not edit! Created by nedtool 5.2 from Frames/stream_Blocked.msg.
+//
+
+#if defined(__clang__)
+#  pragma clang diagnostic ignored "-Wreserved-id-macro"
+#endif
+#ifndef __STREAM_BLOCKED_M_H
+#define __STREAM_BLOCKED_M_H
+
+#include <omnetpp.h>
+
+// nedtool version check
+#define MSGC_VERSION 0x0502
+#if (MSGC_VERSION!=OMNETPP_VERSION)
+#    error Version mismatch! Probably this file was generated by an earlier version of nedtool: 'make clean' should help.
+#endif
+
+
+
+/**
+ * Class generated from <tt>Frames/stream_Blocked.msg:19</tt> by nedtool.
+ * <pre>
+ * //
+ * // TODO generated message class
+ * //
+ * class Stream_Blocked
+ * {
+ *     uint8_t type = 9;
+ *     uint32_t stream_Id;
+ * }
+ * </pre>
+ */
+class Stream_Blocked : public ::omnetpp::cObject
+{
+  protected:
+    uint8_t type;
+    uint32_t stream_Id;
+
+  private:
+    void copy(const Stream_Blocked& other);
+
+  protected:
+    // protected and unimplemented operator==(), to prevent accidental usage
+    bool operator==(const Stream_Blocked&);
+
+  public:
+    Stream_Blocked();
+    Stream_Blocked(const Stream_Blocked& other);
+    virtual ~Stream_Blocked();
+    Stream_Blocked& operator=(const Stream_Blocked& other);
+    virtual Stream_Blocked *dup() const override {return new Stream_Blocked(*this);}
+    virtual void parsimPack(omnetpp::cCommBuffer *b) const override;
+    virtual void parsimUnpack(omnetpp::cCommBuffer *b) override;
+
+    // field getter/setter methods
+    virtual uint8_t getType() const;
+    virtual void setType(uint8_t type);
+    virtual uint32_t getStream_Id() const;
+    virtual void setStream_Id(uint32_t stream_Id);
+};
+
+inline void doParsimPacking(omnetpp::cCommBuffer *b, const Stream_Blocked& obj) {obj.parsimPack(b);}
+inline void doParsimUnpacking(omnetpp::cCommBuffer *b, Stream_Blocked& obj) {obj.parsimUnpack(b);}
+
+
+#endif // ifndef __STREAM_BLOCKED_M_H
+

QUIC/Frames/stream_Id_Blocked.msg

@@ -0,0 +1,21 @@
+//
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Lesser General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+// 
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU Lesser General Public License for more details.
+// 
+// You should have received a copy of the GNU Lesser General Public License
+// along with this program.  If not, see http://www.gnu.org/licenses/.
+// 
+
+//
+// TODO generated message class
+//
+class Stream_Id_Blocked {
+    uint8_t type = 10;
+}

QUIC/Frames/stream_Id_Blocked_m.cc

@@ -0,0 +1,458 @@
+//
+// Generated file, do not edit! Created by nedtool 5.2 from Frames/stream_Id_Blocked.msg.
+//
+
+// Disable warnings about unused variables, empty switch stmts, etc:
+#ifdef _MSC_VER
+#  pragma warning(disable:4101)
+#  pragma warning(disable:4065)
+#endif
+
+#if defined(__clang__)
+#  pragma clang diagnostic ignored "-Wshadow"
+#  pragma clang diagnostic ignored "-Wconversion"
+#  pragma clang diagnostic ignored "-Wunused-parameter"
+#  pragma clang diagnostic ignored "-Wc++98-compat"
+#  pragma clang diagnostic ignored "-Wunreachable-code-break"
+#  pragma clang diagnostic ignored "-Wold-style-cast"
+#elif defined(__GNUC__)
+#  pragma GCC diagnostic ignored "-Wshadow"
+#  pragma GCC diagnostic ignored "-Wconversion"
+#  pragma GCC diagnostic ignored "-Wunused-parameter"
+#  pragma GCC diagnostic ignored "-Wold-style-cast"
+#  pragma GCC diagnostic ignored "-Wsuggest-attribute=noreturn"
+#  pragma GCC diagnostic ignored "-Wfloat-conversion"
+#endif
+
+#include <iostream>
+#include <sstream>
+#include "stream_Id_Blocked_m.h"
+
+namespace omnetpp {
+
+// Template pack/unpack rules. They are declared *after* a1l type-specific pack functions for multiple reasons.
+// They are in the omnetpp namespace, to allow them to be found by argument-dependent lookup via the cCommBuffer argument
+
+// Packing/unpacking an std::vector
+template<typename T, typename A>
+void doParsimPacking(omnetpp::cCommBuffer *buffer, const std::vector<T,A>& v)
+{
+    int n = v.size();
+    doParsimPacking(buffer, n);
+    for (int i = 0; i < n; i++)
+        doParsimPacking(buffer, v[i]);
+}
+
+template<typename T, typename A>
+void doParsimUnpacking(omnetpp::cCommBuffer *buffer, std::vector<T,A>& v)
+{
+    int n;
+    doParsimUnpacking(buffer, n);
+    v.resize(n);
+    for (int i = 0; i < n; i++)
+        doParsimUnpacking(buffer, v[i]);
+}
+
+// Packing/unpacking an std::list
+template<typename T, typename A>
+void doParsimPacking(omnetpp::cCommBuffer *buffer, const std::list<T,A>& l)
+{
+    doParsimPacking(buffer, (int)l.size());
+    for (typename std::list<T,A>::const_iterator it = l.begin(); it != l.end(); ++it)
+        doParsimPacking(buffer, (T&)*it);
+}
+
+template<typename T, typename A>
+void doParsimUnpacking(omnetpp::cCommBuffer *buffer, std::list<T,A>& l)
+{
+    int n;
+    doParsimUnpacking(buffer, n);
+    for (int i=0; i<n; i++) {
+        l.push_back(T());
+        doParsimUnpacking(buffer, l.back());
+    }
+}
+
+// Packing/unpacking an std::set
+template<typename T, typename Tr, typename A>
+void doParsimPacking(omnetpp::cCommBuffer *buffer, const std::set<T,Tr,A>& s)
+{
+    doParsimPacking(buffer, (int)s.size());
+    for (typename std::set<T,Tr,A>::const_iterator it = s.begin(); it != s.end(); ++it)
+        doParsimPacking(buffer, *it);
+}
+
+template<typename T, typename Tr, typename A>
+void doParsimUnpacking(omnetpp::cCommBuffer *buffer, std::set<T,Tr,A>& s)
+{
+    int n;
+    doParsimUnpacking(buffer, n);
+    for (int i=0; i<n; i++) {
+        T x;
+        doParsimUnpacking(buffer, x);
+        s.insert(x);
+    }
+}
+
+// Packing/unpacking an std::map
+template<typename K, typename V, typename Tr, typename A>
+void doParsimPacking(omnetpp::cCommBuffer *buffer, const std::map<K,V,Tr,A>& m)
+{
+    doParsimPacking(buffer, (int)m.size());
+    for (typename std::map<K,V,Tr,A>::const_iterator it = m.begin(); it != m.end(); ++it) {
+        doParsimPacking(buffer, it->first);
+        doParsimPacking(buffer, it->second);
+    }
+}
+
+template<typename K, typename V, typename Tr, typename A>
+void doParsimUnpacking(omnetpp::cCommBuffer *buffer, std::map<K,V,Tr,A>& m)
+{
+    int n;
+    doParsimUnpacking(buffer, n);
+    for (int i=0; i<n; i++) {
+        K k; V v;
+        doParsimUnpacking(buffer, k);
+        doParsimUnpacking(buffer, v);
+        m[k] = v;
+    }
+}
+
+// Default pack/unpack function for arrays
+template<typename T>
+void doParsimArrayPacking(omnetpp::cCommBuffer *b, const T *t, int n)
+{
+    for (int i = 0; i < n; i++)
+        doParsimPacking(b, t[i]);
+}
+
+template<typename T>
+void doParsimArrayUnpacking(omnetpp::cCommBuffer *b, T *t, int n)
+{
+    for (int i = 0; i < n; i++)
+        doParsimUnpacking(b, t[i]);
+}
+
+// Default rule to prevent compiler from choosing base class' doParsimPacking() function
+template<typename T>
+void doParsimPacking(omnetpp::cCommBuffer *, const T& t)
+{
+    throw omnetpp::cRuntimeError("Parsim error: No doParsimPacking() function for type %s", omnetpp::opp_typename(typeid(t)));
+}
+
+template<typename T>
+void doParsimUnpacking(omnetpp::cCommBuffer *, T& t)
+{
+    throw omnetpp::cRuntimeError("Parsim error: No doParsimUnpacking() function for type %s", omnetpp::opp_typename(typeid(t)));
+}
+
+}  // namespace omnetpp
+
+
+// forward
+template<typename T, typename A>
+std::ostream& operator<<(std::ostream& out, const std::vector<T,A>& vec);
+
+// Template rule which fires if a struct or class doesn't have operator<<
+template<typename T>
+inline std::ostream& operator<<(std::ostream& out,const T&) {return out;}
+
+// operator<< for std::vector<T>
+template<typename T, typename A>
+inline std::ostream& operator<<(std::ostream& out, const std::vector<T,A>& vec)
+{
+    out.put('{');
+    for(typename std::vector<T,A>::const_iterator it = vec.begin(); it != vec.end(); ++it)
+    {
+        if (it != vec.begin()) {
+            out.put(','); out.put(' ');
+        }
+        out << *it;
+    }
+    out.put('}');
+    
+    char buf[32];
+    sprintf(buf, " (size=%u)", (unsigned int)vec.size());
+    out.write(buf, strlen(buf));
+    return out;
+}
+
+Register_Class(Stream_Id_Blocked)
+
+Stream_Id_Blocked::Stream_Id_Blocked() : ::omnetpp::cObject()
+{
+    this->type = 10;
+}
+
+Stream_Id_Blocked::Stream_Id_Blocked(const Stream_Id_Blocked& other) : ::omnetpp::cObject(other)
+{
+    copy(other);
+}
+
+Stream_Id_Blocked::~Stream_Id_Blocked()
+{
+}
+
+Stream_Id_Blocked& Stream_Id_Blocked::operator=(const Stream_Id_Blocked& other)
+{
+    if (this==&other) return *this;
+    ::omnetpp::cObject::operator=(other);
+    copy(other);
+    return *this;
+}
+
+void Stream_Id_Blocked::copy(const Stream_Id_Blocked& other)
+{
+    this->type = other.type;
+}
+
+void Stream_Id_Blocked::parsimPack(omnetpp::cCommBuffer *b) const
+{
+    doParsimPacking(b,this->type);
+}
+
+void Stream_Id_Blocked::parsimUnpack(omnetpp::cCommBuffer *b)
+{
+    doParsimUnpacking(b,this->type);
+}
+
+uint8_t Stream_Id_Blocked::getType() const
+{
+    return this->type;
+}
+
+void Stream_Id_Blocked::setType(uint8_t type)
+{
+    this->type = type;
+}
+
+class Stream_Id_BlockedDescriptor : public omnetpp::cClassDescriptor
+{
+  private:
+    mutable const char **propertynames;
+  public:
+    Stream_Id_BlockedDescriptor();
+    virtual ~Stream_Id_BlockedDescriptor();
+
+    virtual bool doesSupport(omnetpp::cObject *obj) const override;
+    virtual const char **getPropertyNames() const override;
+    virtual const char *getProperty(const char *propertyname) const override;
+    virtual int getFieldCount() const override;
+    virtual const char *getFieldName(int field) const override;
+    virtual int findField(const char *fieldName) const override;
+    virtual unsigned int getFieldTypeFlags(int field) const override;
+    virtual const char *getFieldTypeString(int field) const override;
+    virtual const char **getFieldPropertyNames(int field) const override;
+    virtual const char *getFieldProperty(int field, const char *propertyname) const override;
+    virtual int getFieldArraySize(void *object, int field) const override;
+
+    virtual const char *getFieldDynamicTypeString(void *object, int field, int i) const override;
+    virtual std::string getFieldValueAsString(void *object, int field, int i) const override;
+    virtual bool setFieldValueAsString(void *object, int field, int i, const char *value) const override;
+
+    virtual const char *getFieldStructName(int field) const override;
+    virtual void *getFieldStructValuePointer(void *object, int field, int i) const override;
+};
+
+Register_ClassDescriptor(Stream_Id_BlockedDescriptor)
+
+Stream_Id_BlockedDescriptor::Stream_Id_BlockedDescriptor() : omnetpp::cClassDescriptor("Stream_Id_Blocked", "omnetpp::cObject")
+{
+    propertynames = nullptr;
+}
+
+Stream_Id_BlockedDescriptor::~Stream_Id_BlockedDescriptor()
+{
+    delete[] propertynames;
+}
+
+bool Stream_Id_BlockedDescriptor::doesSupport(omnetpp::cObject *obj) const
+{
+    return dynamic_cast<Stream_Id_Blocked *>(obj)!=nullptr;
+}
+
+const char **Stream_Id_BlockedDescriptor::getPropertyNames() const
+{
+    if (!propertynames) {
+        static const char *names[] = {  nullptr };
+        omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
+        const char **basenames = basedesc ? basedesc->getPropertyNames() : nullptr;
+        propertynames = mergeLists(basenames, names);
+    }
+    return propertynames;
+}
+
+const char *Stream_Id_BlockedDescriptor::getProperty(const char *propertyname) const
+{
+    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
+    return basedesc ? basedesc->getProperty(propertyname) : nullptr;
+}
+
+int Stream_Id_BlockedDescriptor::getFieldCount() const
+{
+    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
+    return basedesc ? 1+basedesc->getFieldCount() : 1;
+}
+
+unsigned int Stream_Id_BlockedDescriptor::getFieldTypeFlags(int field) const
+{
+    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
+    if (basedesc) {
+        if (field < basedesc->getFieldCount())
+            return basedesc->getFieldTypeFlags(field);
+        field -= basedesc->getFieldCount();
+    }
+    static unsigned int fieldTypeFlags[] = {
+        FD_ISEDITABLE,
+    };
+    return (field>=0 && field<1) ? fieldTypeFlags[field] : 0;
+}
+
+const char *Stream_Id_BlockedDescriptor::getFieldName(int field) const
+{
+    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
+    if (basedesc) {
+        if (field < basedesc->getFieldCount())
+            return basedesc->getFieldName(field);
+        field -= basedesc->getFieldCount();
+    }
+    static const char *fieldNames[] = {
+        "type",
+    };
+    return (field>=0 && field<1) ? fieldNames[field] : nullptr;
+}
+
+int Stream_Id_BlockedDescriptor::findField(const char *fieldName) const
+{
+    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
+    int base = basedesc ? basedesc->getFieldCount() : 0;
+    if (fieldName[0]=='t' && strcmp(fieldName, "type")==0) return base+0;
+    return basedesc ? basedesc->findField(fieldName) : -1;
+}
+
+const char *Stream_Id_BlockedDescriptor::getFieldTypeString(int field) const
+{
+    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
+    if (basedesc) {
+        if (field < basedesc->getFieldCount())
+            return basedesc->getFieldTypeString(field);
+        field -= basedesc->getFieldCount();
+    }
+    static const char *fieldTypeStrings[] = {
+        "uint8_t",
+    };
+    return (field>=0 && field<1) ? fieldTypeStrings[field] : nullptr;
+}
+
+const char **Stream_Id_BlockedDescriptor::getFieldPropertyNames(int field) const
+{
+    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
+    if (basedesc) {
+        if (field < basedesc->getFieldCount())
+            return basedesc->getFieldPropertyNames(field);
+        field -= basedesc->getFieldCount();
+    }
+    switch (field) {
+        default: return nullptr;
+    }
+}
+
+const char *Stream_Id_BlockedDescriptor::getFieldProperty(int field, const char *propertyname) const
+{
+    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
+    if (basedesc) {
+        if (field < basedesc->getFieldCount())
+            return basedesc->getFieldProperty(field, propertyname);
+        field -= basedesc->getFieldCount();
+    }
+    switch (field) {
+        default: return nullptr;
+    }
+}
+
+int Stream_Id_BlockedDescriptor::getFieldArraySize(void *object, int field) const
+{
+    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
+    if (basedesc) {
+        if (field < basedesc->getFieldCount())
+            return basedesc->getFieldArraySize(object, field);
+        field -= basedesc->getFieldCount();
+    }
+    Stream_Id_Blocked *pp = (Stream_Id_Blocked *)object; (void)pp;
+    switch (field) {
+        default: return 0;
+    }
+}
+
+const char *Stream_Id_BlockedDescriptor::getFieldDynamicTypeString(void *object, int field, int i) const
+{
+    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
+    if (basedesc) {
+        if (field < basedesc->getFieldCount())
+            return basedesc->getFieldDynamicTypeString(object,field,i);
+        field -= basedesc->getFieldCount();
+    }
+    Stream_Id_Blocked *pp = (Stream_Id_Blocked *)object; (void)pp;
+    switch (field) {
+        default: return nullptr;
+    }
+}
+
+std::string Stream_Id_BlockedDescriptor::getFieldValueAsString(void *object, int field, int i) const
+{
+    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
+    if (basedesc) {
+        if (field < basedesc->getFieldCount())
+            return basedesc->getFieldValueAsString(object,field,i);
+        field -= basedesc->getFieldCount();
+    }
+    Stream_Id_Blocked *pp = (Stream_Id_Blocked *)object; (void)pp;
+    switch (field) {
+        case 0: return ulong2string(pp->getType());
+        default: return "";
+    }
+}
+
+bool Stream_Id_BlockedDescriptor::setFieldValueAsString(void *object, int field, int i, const char *value) const
+{
+    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
+    if (basedesc) {
+        if (field < basedesc->getFieldCount())
+            return basedesc->setFieldValueAsString(object,field,i,value);
+        field -= basedesc->getFieldCount();
+    }
+    Stream_Id_Blocked *pp = (Stream_Id_Blocked *)object; (void)pp;
+    switch (field) {
+        case 0: pp->setType(string2ulong(value)); return true;
+        default: return false;
+    }
+}
+
+const char *Stream_Id_BlockedDescriptor::getFieldStructName(int field) const
+{
+    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
+    if (basedesc) {
+        if (field < basedesc->getFieldCount())
+            return basedesc->getFieldStructName(field);
+        field -= basedesc->getFieldCount();
+    }
+    switch (field) {
+        default: return nullptr;
+    };
+}
+
+void *Stream_Id_BlockedDescriptor::getFieldStructValuePointer(void *object, int field, int i) const
+{
+    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
+    if (basedesc) {
+        if (field < basedesc->getFieldCount())
+            return basedesc->getFieldStructValuePointer(object, field, i);
+        field -= basedesc->getFieldCount();
+    }
+    Stream_Id_Blocked *pp = (Stream_Id_Blocked *)object; (void)pp;
+    switch (field) {
+        default: return nullptr;
+    }
+}
+
+

QUIC/Frames/stream_Id_Blocked_m.h

@@ -0,0 +1,64 @@
+//
+// Generated file, do not edit! Created by nedtool 5.2 from Frames/stream_Id_Blocked.msg.
+//
+
+#if defined(__clang__)
+#  pragma clang diagnostic ignored "-Wreserved-id-macro"
+#endif
+#ifndef __STREAM_ID_BLOCKED_M_H
+#define __STREAM_ID_BLOCKED_M_H
+
+#include <omnetpp.h>
+
+// nedtool version check
+#define MSGC_VERSION 0x0502
+#if (MSGC_VERSION!=OMNETPP_VERSION)
+#    error Version mismatch! Probably this file was generated by an earlier version of nedtool: 'make clean' should help.
+#endif
+
+
+
+/**
+ * Class generated from <tt>Frames/stream_Id_Blocked.msg:19</tt> by nedtool.
+ * <pre>
+ * //
+ * // TODO generated message class
+ * //
+ * class Stream_Id_Blocked
+ * {
+ *     uint8_t type = 10;
+ * }
+ * </pre>
+ */
+class Stream_Id_Blocked : public ::omnetpp::cObject
+{
+  protected:
+    uint8_t type;
+
+  private:
+    void copy(const Stream_Id_Blocked& other);
+
+  protected:
+    // protected and unimplemented operator==(), to prevent accidental usage
+    bool operator==(const Stream_Id_Blocked&);
+
+  public:
+    Stream_Id_Blocked();
+    Stream_Id_Blocked(const Stream_Id_Blocked& other);
+    virtual ~Stream_Id_Blocked();
+    Stream_Id_Blocked& operator=(const Stream_Id_Blocked& other);
+    virtual Stream_Id_Blocked *dup() const override {return new Stream_Id_Blocked(*this);}
+    virtual void parsimPack(omnetpp::cCommBuffer *b) const override;
+    virtual void parsimUnpack(omnetpp::cCommBuffer *b) override;
+
+    // field getter/setter methods
+    virtual uint8_t getType() const;
+    virtual void setType(uint8_t type);
+};
+
+inline void doParsimPacking(omnetpp::cCommBuffer *b, const Stream_Id_Blocked& obj) {obj.parsimPack(b);}
+inline void doParsimUnpacking(omnetpp::cCommBuffer *b, Stream_Id_Blocked& obj) {obj.parsimUnpack(b);}
+
+
+#endif // ifndef __STREAM_ID_BLOCKED_M_H
+

QUIC/Frames/stream_m.cc

@@ -0,0 +1,537 @@
+//
+// Generated file, do not edit! Created by nedtool 5.2 from Frames/stream.msg.
+//
+
+// Disable warnings about unused variables, empty switch stmts, etc:
+#ifdef _MSC_VER
+#  pragma warning(disable:4101)
+#  pragma warning(disable:4065)
+#endif
+
+#if defined(__clang__)
+#  pragma clang diagnostic ignored "-Wshadow"
+#  pragma clang diagnostic ignored "-Wconversion"
+#  pragma clang diagnostic ignored "-Wunused-parameter"
+#  pragma clang diagnostic ignored "-Wc++98-compat"
+#  pragma clang diagnostic ignored "-Wunreachable-code-break"
+#  pragma clang diagnostic ignored "-Wold-style-cast"
+#elif defined(__GNUC__)
+#  pragma GCC diagnostic ignored "-Wshadow"
+#  pragma GCC diagnostic ignored "-Wconversion"
+#  pragma GCC diagnostic ignored "-Wunused-parameter"
+#  pragma GCC diagnostic ignored "-Wold-style-cast"
+#  pragma GCC diagnostic ignored "-Wsuggest-attribute=noreturn"
+#  pragma GCC diagnostic ignored "-Wfloat-conversion"
+#endif
+
+#include <iostream>
+#include <sstream>
+#include "stream_m.h"
+
+namespace omnetpp {
+
+// Template pack/unpack rules. They are declared *after* a1l type-specific pack functions for multiple reasons.
+// They are in the omnetpp namespace, to allow them to be found by argument-dependent lookup via the cCommBuffer argument
+
+// Packing/unpacking an std::vector
+template<typename T, typename A>
+void doParsimPacking(omnetpp::cCommBuffer *buffer, const std::vector<T,A>& v)
+{
+    int n = v.size();
+    doParsimPacking(buffer, n);
+    for (int i = 0; i < n; i++)
+        doParsimPacking(buffer, v[i]);
+}
+
+template<typename T, typename A>
+void doParsimUnpacking(omnetpp::cCommBuffer *buffer, std::vector<T,A>& v)
+{
+    int n;
+    doParsimUnpacking(buffer, n);
+    v.resize(n);
+    for (int i = 0; i < n; i++)
+        doParsimUnpacking(buffer, v[i]);
+}
+
+// Packing/unpacking an std::list
+template<typename T, typename A>
+void doParsimPacking(omnetpp::cCommBuffer *buffer, const std::list<T,A>& l)
+{
+    doParsimPacking(buffer, (int)l.size());
+    for (typename std::list<T,A>::const_iterator it = l.begin(); it != l.end(); ++it)
+        doParsimPacking(buffer, (T&)*it);
+}
+
+template<typename T, typename A>
+void doParsimUnpacking(omnetpp::cCommBuffer *buffer, std::list<T,A>& l)
+{
+    int n;
+    doParsimUnpacking(buffer, n);
+    for (int i=0; i<n; i++) {
+        l.push_back(T());
+        doParsimUnpacking(buffer, l.back());
+    }
+}
+
+// Packing/unpacking an std::set
+template<typename T, typename Tr, typename A>
+void doParsimPacking(omnetpp::cCommBuffer *buffer, const std::set<T,Tr,A>& s)
+{
+    doParsimPacking(buffer, (int)s.size());
+    for (typename std::set<T,Tr,A>::const_iterator it = s.begin(); it != s.end(); ++it)
+        doParsimPacking(buffer, *it);
+}
+
+template<typename T, typename Tr, typename A>
+void doParsimUnpacking(omnetpp::cCommBuffer *buffer, std::set<T,Tr,A>& s)
+{
+    int n;
+    doParsimUnpacking(buffer, n);
+    for (int i=0; i<n; i++) {
+        T x;
+        doParsimUnpacking(buffer, x);
+        s.insert(x);
+    }
+}
+
+// Packing/unpacking an std::map
+template<typename K, typename V, typename Tr, typename A>
+void doParsimPacking(omnetpp::cCommBuffer *buffer, const std::map<K,V,Tr,A>& m)
+{
+    doParsimPacking(buffer, (int)m.size());
+    for (typename std::map<K,V,Tr,A>::const_iterator it = m.begin(); it != m.end(); ++it) {
+        doParsimPacking(buffer, it->first);
+        doParsimPacking(buffer, it->second);
+    }
+}
+
+template<typename K, typename V, typename Tr, typename A>
+void doParsimUnpacking(omnetpp::cCommBuffer *buffer, std::map<K,V,Tr,A>& m)
+{
+    int n;
+    doParsimUnpacking(buffer, n);
+    for (int i=0; i<n; i++) {
+        K k; V v;
+        doParsimUnpacking(buffer, k);
+        doParsimUnpacking(buffer, v);
+        m[k] = v;
+    }
+}
+
+// Default pack/unpack function for arrays
+template<typename T>
+void doParsimArrayPacking(omnetpp::cCommBuffer *b, const T *t, int n)
+{
+    for (int i = 0; i < n; i++)
+        doParsimPacking(b, t[i]);
+}
+
+template<typename T>
+void doParsimArrayUnpacking(omnetpp::cCommBuffer *b, T *t, int n)
+{
+    for (int i = 0; i < n; i++)
+        doParsimUnpacking(b, t[i]);
+}
+
+// Default rule to prevent compiler from choosing base class' doParsimPacking() function
+template<typename T>
+void doParsimPacking(omnetpp::cCommBuffer *, const T& t)
+{
+    throw omnetpp::cRuntimeError("Parsim error: No doParsimPacking() function for type %s", omnetpp::opp_typename(typeid(t)));
+}
+
+template<typename T>
+void doParsimUnpacking(omnetpp::cCommBuffer *, T& t)
+{
+    throw omnetpp::cRuntimeError("Parsim error: No doParsimUnpacking() function for type %s", omnetpp::opp_typename(typeid(t)));
+}
+
+}  // namespace omnetpp
+
+
+// forward
+template<typename T, typename A>
+std::ostream& operator<<(std::ostream& out, const std::vector<T,A>& vec);
+
+// Template rule which fires if a struct or class doesn't have operator<<
+template<typename T>
+inline std::ostream& operator<<(std::ostream& out,const T&) {return out;}
+
+// operator<< for std::vector<T>
+template<typename T, typename A>
+inline std::ostream& operator<<(std::ostream& out, const std::vector<T,A>& vec)
+{
+    out.put('{');
+    for(typename std::vector<T,A>::const_iterator it = vec.begin(); it != vec.end(); ++it)
+    {
+        if (it != vec.begin()) {
+            out.put(','); out.put(' ');
+        }
+        out << *it;
+    }
+    out.put('}');
+    
+    char buf[32];
+    sprintf(buf, " (size=%u)", (unsigned int)vec.size());
+    out.write(buf, strlen(buf));
+    return out;
+}
+
+Register_Class(Stream)
+
+Stream::Stream() : ::omnetpp::cObject()
+{
+    this->type = 0;
+    this->stream_Id = 0;
+    this->offset = 0;
+    this->data_Length = 0;
+}
+
+Stream::Stream(const Stream& other) : ::omnetpp::cObject(other)
+{
+    copy(other);
+}
+
+Stream::~Stream()
+{
+}
+
+Stream& Stream::operator=(const Stream& other)
+{
+    if (this==&other) return *this;
+    ::omnetpp::cObject::operator=(other);
+    copy(other);
+    return *this;
+}
+
+void Stream::copy(const Stream& other)
+{
+    this->type = other.type;
+    this->stream_Id = other.stream_Id;
+    this->offset = other.offset;
+    this->data_Length = other.data_Length;
+    this->stream_Data = other.stream_Data;
+}
+
+void Stream::parsimPack(omnetpp::cCommBuffer *b) const
+{
+    doParsimPacking(b,this->type);
+    doParsimPacking(b,this->stream_Id);
+    doParsimPacking(b,this->offset);
+    doParsimPacking(b,this->data_Length);
+    doParsimPacking(b,this->stream_Data);
+}
+
+void Stream::parsimUnpack(omnetpp::cCommBuffer *b)
+{
+    doParsimUnpacking(b,this->type);
+    doParsimUnpacking(b,this->stream_Id);
+    doParsimUnpacking(b,this->offset);
+    doParsimUnpacking(b,this->data_Length);
+    doParsimUnpacking(b,this->stream_Data);
+}
+
+uint8_t Stream::getType() const
+{
+    return this->type;
+}
+
+void Stream::setType(uint8_t type)
+{
+    this->type = type;
+}
+
+uint32_t Stream::getStream_Id() const
+{
+    return this->stream_Id;
+}
+
+void Stream::setStream_Id(uint32_t stream_Id)
+{
+    this->stream_Id = stream_Id;
+}
+
+uint64_t Stream::getOffset() const
+{
+    return this->offset;
+}
+
+void Stream::setOffset(uint64_t offset)
+{
+    this->offset = offset;
+}
+
+uint16_t Stream::getData_Length() const
+{
+    return this->data_Length;
+}
+
+void Stream::setData_Length(uint16_t data_Length)
+{
+    this->data_Length = data_Length;
+}
+
+const char * Stream::getStream_Data() const
+{
+    return this->stream_Data.c_str();
+}
+
+void Stream::setStream_Data(const char * stream_Data)
+{
+    this->stream_Data = stream_Data;
+}
+
+class StreamDescriptor : public omnetpp::cClassDescriptor
+{
+  private:
+    mutable const char **propertynames;
+  public:
+    StreamDescriptor();
+    virtual ~StreamDescriptor();
+
+    virtual bool doesSupport(omnetpp::cObject *obj) const override;
+    virtual const char **getPropertyNames() const override;
+    virtual const char *getProperty(const char *propertyname) const override;
+    virtual int getFieldCount() const override;
+    virtual const char *getFieldName(int field) const override;
+    virtual int findField(const char *fieldName) const override;
+    virtual unsigned int getFieldTypeFlags(int field) const override;
+    virtual const char *getFieldTypeString(int field) const override;
+    virtual const char **getFieldPropertyNames(int field) const override;
+    virtual const char *getFieldProperty(int field, const char *propertyname) const override;
+    virtual int getFieldArraySize(void *object, int field) const override;
+
+    virtual const char *getFieldDynamicTypeString(void *object, int field, int i) const override;
+    virtual std::string getFieldValueAsString(void *object, int field, int i) const override;
+    virtual bool setFieldValueAsString(void *object, int field, int i, const char *value) const override;
+
+    virtual const char *getFieldStructName(int field) const override;
+    virtual void *getFieldStructValuePointer(void *object, int field, int i) const override;
+};
+
+Register_ClassDescriptor(StreamDescriptor)
+
+StreamDescriptor::StreamDescriptor() : omnetpp::cClassDescriptor("Stream", "omnetpp::cObject")
+{
+    propertynames = nullptr;
+}
+
+StreamDescriptor::~StreamDescriptor()
+{
+    delete[] propertynames;
+}
+
+bool StreamDescriptor::doesSupport(omnetpp::cObject *obj) const
+{
+    return dynamic_cast<Stream *>(obj)!=nullptr;
+}
+
+const char **StreamDescriptor::getPropertyNames() const
+{
+    if (!propertynames) {
+        static const char *names[] = {  nullptr };
+        omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
+        const char **basenames = basedesc ? basedesc->getPropertyNames() : nullptr;
+        propertynames = mergeLists(basenames, names);
+    }
+    return propertynames;
+}
+
+const char *StreamDescriptor::getProperty(const char *propertyname) const
+{
+    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
+    return basedesc ? basedesc->getProperty(propertyname) : nullptr;
+}
+
+int StreamDescriptor::getFieldCount() const
+{
+    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
+    return basedesc ? 5+basedesc->getFieldCount() : 5;
+}
+
+unsigned int StreamDescriptor::getFieldTypeFlags(int field) const
+{
+    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
+    if (basedesc) {
+        if (field < basedesc->getFieldCount())
+            return basedesc->getFieldTypeFlags(field);
+        field -= basedesc->getFieldCount();
+    }
+    static unsigned int fieldTypeFlags[] = {
+        FD_ISEDITABLE,
+        FD_ISEDITABLE,
+        FD_ISEDITABLE,
+        FD_ISEDITABLE,
+        FD_ISEDITABLE,
+    };
+    return (field>=0 && field<5) ? fieldTypeFlags[field] : 0;
+}
+
+const char *StreamDescriptor::getFieldName(int field) const
+{
+    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
+    if (basedesc) {
+        if (field < basedesc->getFieldCount())
+            return basedesc->getFieldName(field);
+        field -= basedesc->getFieldCount();
+    }
+    static const char *fieldNames[] = {
+        "type",
+        "stream_Id",
+        "offset",
+        "data_Length",
+        "stream_Data",
+    };
+    return (field>=0 && field<5) ? fieldNames[field] : nullptr;
+}
+
+int StreamDescriptor::findField(const char *fieldName) const
+{
+    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
+    int base = basedesc ? basedesc->getFieldCount() : 0;
+    if (fieldName[0]=='t' && strcmp(fieldName, "type")==0) return base+0;
+    if (fieldName[0]=='s' && strcmp(fieldName, "stream_Id")==0) return base+1;
+    if (fieldName[0]=='o' && strcmp(fieldName, "offset")==0) return base+2;
+    if (fieldName[0]=='d' && strcmp(fieldName, "data_Length")==0) return base+3;
+    if (fieldName[0]=='s' && strcmp(fieldName, "stream_Data")==0) return base+4;
+    return basedesc ? basedesc->findField(fieldName) : -1;
+}
+
+const char *StreamDescriptor::getFieldTypeString(int field) const
+{
+    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
+    if (basedesc) {
+        if (field < basedesc->getFieldCount())
+            return basedesc->getFieldTypeString(field);
+        field -= basedesc->getFieldCount();
+    }
+    static const char *fieldTypeStrings[] = {
+        "uint8_t",
+        "uint32_t",
+        "uint64_t",
+        "uint16_t",
+        "string",
+    };
+    return (field>=0 && field<5) ? fieldTypeStrings[field] : nullptr;
+}
+
+const char **StreamDescriptor::getFieldPropertyNames(int field) const
+{
+    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
+    if (basedesc) {
+        if (field < basedesc->getFieldCount())
+            return basedesc->getFieldPropertyNames(field);
+        field -= basedesc->getFieldCount();
+    }
+    switch (field) {
+        default: return nullptr;
+    }
+}
+
+const char *StreamDescriptor::getFieldProperty(int field, const char *propertyname) const
+{
+    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
+    if (basedesc) {
+        if (field < basedesc->getFieldCount())
+            return basedesc->getFieldProperty(field, propertyname);
+        field -= basedesc->getFieldCount();
+    }
+    switch (field) {
+        default: return nullptr;
+    }
+}
+
+int StreamDescriptor::getFieldArraySize(void *object, int field) const
+{
+    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
+    if (basedesc) {
+        if (field < basedesc->getFieldCount())
+            return basedesc->getFieldArraySize(object, field);
+        field -= basedesc->getFieldCount();
+    }
+    Stream *pp = (Stream *)object; (void)pp;
+    switch (field) {
+        default: return 0;
+    }
+}
+
+const char *StreamDescriptor::getFieldDynamicTypeString(void *object, int field, int i) const
+{
+    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
+    if (basedesc) {
+        if (field < basedesc->getFieldCount())
+            return basedesc->getFieldDynamicTypeString(object,field,i);
+        field -= basedesc->getFieldCount();
+    }
+    Stream *pp = (Stream *)object; (void)pp;
+    switch (field) {
+        default: return nullptr;
+    }
+}
+
+std::string StreamDescriptor::getFieldValueAsString(void *object, int field, int i) const
+{
+    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
+    if (basedesc) {
+        if (field < basedesc->getFieldCount())
+            return basedesc->getFieldValueAsString(object,field,i);
+        field -= basedesc->getFieldCount();
+    }
+    Stream *pp = (Stream *)object; (void)pp;
+    switch (field) {
+        case 0: return ulong2string(pp->getType());
+        case 1: return ulong2string(pp->getStream_Id());
+        case 2: return uint642string(pp->getOffset());
+        case 3: return ulong2string(pp->getData_Length());
+        case 4: return oppstring2string(pp->getStream_Data());
+        default: return "";
+    }
+}
+
+bool StreamDescriptor::setFieldValueAsString(void *object, int field, int i, const char *value) const
+{
+    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
+    if (basedesc) {
+        if (field < basedesc->getFieldCount())
+            return basedesc->setFieldValueAsString(object,field,i,value);
+        field -= basedesc->getFieldCount();
+    }
+    Stream *pp = (Stream *)object; (void)pp;
+    switch (field) {
+        case 0: pp->setType(string2ulong(value)); return true;
+        case 1: pp->setStream_Id(string2ulong(value)); return true;
+        case 2: pp->setOffset(string2uint64(value)); return true;
+        case 3: pp->setData_Length(string2ulong(value)); return true;
+        case 4: pp->setStream_Data((value)); return true;
+        default: return false;
+    }
+}
+
+const char *StreamDescriptor::getFieldStructName(int field) const
+{
+    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
+    if (basedesc) {
+        if (field < basedesc->getFieldCount())
+            return basedesc->getFieldStructName(field);
+        field -= basedesc->getFieldCount();
+    }
+    switch (field) {
+        default: return nullptr;
+    };
+}
+
+void *StreamDescriptor::getFieldStructValuePointer(void *object, int field, int i) const
+{
+    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
+    if (basedesc) {
+        if (field < basedesc->getFieldCount())
+            return basedesc->getFieldStructValuePointer(object, field, i);
+        field -= basedesc->getFieldCount();
+    }
+    Stream *pp = (Stream *)object; (void)pp;
+    switch (field) {
+        default: return nullptr;
+    }
+}
+
+

QUIC/Frames/stream_m.h

@@ -0,0 +1,80 @@
+//
+// Generated file, do not edit! Created by nedtool 5.2 from Frames/stream.msg.
+//
+
+#if defined(__clang__)
+#  pragma clang diagnostic ignored "-Wreserved-id-macro"
+#endif
+#ifndef __STREAM_M_H
+#define __STREAM_M_H
+
+#include <omnetpp.h>
+
+// nedtool version check
+#define MSGC_VERSION 0x0502
+#if (MSGC_VERSION!=OMNETPP_VERSION)
+#    error Version mismatch! Probably this file was generated by an earlier version of nedtool: 'make clean' should help.
+#endif
+
+
+
+/**
+ * Class generated from <tt>Frames/stream.msg:19</tt> by nedtool.
+ * <pre>
+ * //
+ * // TODO generated message class
+ * //
+ * class Stream
+ * {
+ *     uint8_t type;
+ *     uint32_t stream_Id;
+ *     uint64_t offset;
+ *     uint16_t data_Length;
+ *     string stream_Data;
+ * }
+ * </pre>
+ */
+class Stream : public ::omnetpp::cObject
+{
+  protected:
+    uint8_t type;
+    uint32_t stream_Id;
+    uint64_t offset;
+    uint16_t data_Length;
+    ::omnetpp::opp_string stream_Data;
+
+  private:
+    void copy(const Stream& other);
+
+  protected:
+    // protected and unimplemented operator==(), to prevent accidental usage
+    bool operator==(const Stream&);
+
+  public:
+    Stream();
+    Stream(const Stream& other);
+    virtual ~Stream();
+    Stream& operator=(const Stream& other);
+    virtual Stream *dup() const override {return new Stream(*this);}
+    virtual void parsimPack(omnetpp::cCommBuffer *b) const override;
+    virtual void parsimUnpack(omnetpp::cCommBuffer *b) override;
+
+    // field getter/setter methods
+    virtual uint8_t getType() const;
+    virtual void setType(uint8_t type);
+    virtual uint32_t getStream_Id() const;
+    virtual void setStream_Id(uint32_t stream_Id);
+    virtual uint64_t getOffset() const;
+    virtual void setOffset(uint64_t offset);
+    virtual uint16_t getData_Length() const;
+    virtual void setData_Length(uint16_t data_Length);
+    virtual const char * getStream_Data() const;
+    virtual void setStream_Data(const char * stream_Data);
+};
+
+inline void doParsimPacking(omnetpp::cCommBuffer *b, const Stream& obj) {obj.parsimPack(b);}
+inline void doParsimUnpacking(omnetpp::cCommBuffer *b, Stream& obj) {obj.parsimUnpack(b);}
+
+
+#endif // ifndef __STREAM_M_H
+

QUIC/Headers/application_Error_Code.h

@@ -0,0 +1,15 @@
+/*
+ * application_Error_Code.h
+ *
+ *  Created on: Nov 27, 2017
+ *      Author: anay
+ */
+
+#ifndef HEADERS_APPLICATION_ERROR_CODE_H_
+#define HEADERS_APPLICATION_ERROR_CODE_H_
+
+
+
+
+
+#endif /* HEADERS_APPLICATION_ERROR_CODE_H_ */

QUIC/Headers/long_Header.msg

@@ -0,0 +1,24 @@
+//
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Lesser General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+// 
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU Lesser General Public License for more details.
+// 
+// You should have received a copy of the GNU Lesser General Public License
+// along with this program.  If not, see http://www.gnu.org/licenses/.
+// 
+
+//
+// TODO generated message class
+//
+packet Long_Header{
+    uint8_t type;
+    uint64_t CID;
+    uint32_t PN;
+    uint32_t version;
+}

QUIC/Headers/long_Header_m.cc

@@ -0,0 +1,520 @@
+//
+// Generated file, do not edit! Created by nedtool 5.2 from Headers/long_Header.msg.
+//
+
+// Disable warnings about unused variables, empty switch stmts, etc:
+#ifdef _MSC_VER
+#  pragma warning(disable:4101)
+#  pragma warning(disable:4065)
+#endif
+
+#if defined(__clang__)
+#  pragma clang diagnostic ignored "-Wshadow"
+#  pragma clang diagnostic ignored "-Wconversion"
+#  pragma clang diagnostic ignored "-Wunused-parameter"
+#  pragma clang diagnostic ignored "-Wc++98-compat"
+#  pragma clang diagnostic ignored "-Wunreachable-code-break"
+#  pragma clang diagnostic ignored "-Wold-style-cast"
+#elif defined(__GNUC__)
+#  pragma GCC diagnostic ignored "-Wshadow"
+#  pragma GCC diagnostic ignored "-Wconversion"
+#  pragma GCC diagnostic ignored "-Wunused-parameter"
+#  pragma GCC diagnostic ignored "-Wold-style-cast"
+#  pragma GCC diagnostic ignored "-Wsuggest-attribute=noreturn"
+#  pragma GCC diagnostic ignored "-Wfloat-conversion"
+#endif
+
+#include <iostream>
+#include <sstream>
+#include "long_Header_m.h"
+
+namespace omnetpp {
+
+// Template pack/unpack rules. They are declared *after* a1l type-specific pack functions for multiple reasons.
+// They are in the omnetpp namespace, to allow them to be found by argument-dependent lookup via the cCommBuffer argument
+
+// Packing/unpacking an std::vector
+template<typename T, typename A>
+void doParsimPacking(omnetpp::cCommBuffer *buffer, const std::vector<T,A>& v)
+{
+    int n = v.size();
+    doParsimPacking(buffer, n);
+    for (int i = 0; i < n; i++)
+        doParsimPacking(buffer, v[i]);
+}
+
+template<typename T, typename A>
+void doParsimUnpacking(omnetpp::cCommBuffer *buffer, std::vector<T,A>& v)
+{
+    int n;
+    doParsimUnpacking(buffer, n);
+    v.resize(n);
+    for (int i = 0; i < n; i++)
+        doParsimUnpacking(buffer, v[i]);
+}
+
+// Packing/unpacking an std::list
+template<typename T, typename A>
+void doParsimPacking(omnetpp::cCommBuffer *buffer, const std::list<T,A>& l)
+{
+    doParsimPacking(buffer, (int)l.size());
+    for (typename std::list<T,A>::const_iterator it = l.begin(); it != l.end(); ++it)
+        doParsimPacking(buffer, (T&)*it);
+}
+
+template<typename T, typename A>
+void doParsimUnpacking(omnetpp::cCommBuffer *buffer, std::list<T,A>& l)
+{
+    int n;
+    doParsimUnpacking(buffer, n);
+    for (int i=0; i<n; i++) {
+        l.push_back(T());
+        doParsimUnpacking(buffer, l.back());
+    }
+}
+
+// Packing/unpacking an std::set
+template<typename T, typename Tr, typename A>
+void doParsimPacking(omnetpp::cCommBuffer *buffer, const std::set<T,Tr,A>& s)
+{
+    doParsimPacking(buffer, (int)s.size());
+    for (typename std::set<T,Tr,A>::const_iterator it = s.begin(); it != s.end(); ++it)
+        doParsimPacking(buffer, *it);
+}
+
+template<typename T, typename Tr, typename A>
+void doParsimUnpacking(omnetpp::cCommBuffer *buffer, std::set<T,Tr,A>& s)
+{
+    int n;
+    doParsimUnpacking(buffer, n);
+    for (int i=0; i<n; i++) {
+        T x;
+        doParsimUnpacking(buffer, x);
+        s.insert(x);
+    }
+}
+
+// Packing/unpacking an std::map
+template<typename K, typename V, typename Tr, typename A>
+void doParsimPacking(omnetpp::cCommBuffer *buffer, const std::map<K,V,Tr,A>& m)
+{
+    doParsimPacking(buffer, (int)m.size());
+    for (typename std::map<K,V,Tr,A>::const_iterator it = m.begin(); it != m.end(); ++it) {
+        doParsimPacking(buffer, it->first);
+        doParsimPacking(buffer, it->second);
+    }
+}
+
+template<typename K, typename V, typename Tr, typename A>
+void doParsimUnpacking(omnetpp::cCommBuffer *buffer, std::map<K,V,Tr,A>& m)
+{
+    int n;
+    doParsimUnpacking(buffer, n);
+    for (int i=0; i<n; i++) {
+        K k; V v;
+        doParsimUnpacking(buffer, k);
+        doParsimUnpacking(buffer, v);
+        m[k] = v;
+    }
+}
+
+// Default pack/unpack function for arrays
+template<typename T>
+void doParsimArrayPacking(omnetpp::cCommBuffer *b, const T *t, int n)
+{
+    for (int i = 0; i < n; i++)
+        doParsimPacking(b, t[i]);
+}
+
+template<typename T>
+void doParsimArrayUnpacking(omnetpp::cCommBuffer *b, T *t, int n)
+{
+    for (int i = 0; i < n; i++)
+        doParsimUnpacking(b, t[i]);
+}
+
+// Default rule to prevent compiler from choosing base class' doParsimPacking() function
+template<typename T>
+void doParsimPacking(omnetpp::cCommBuffer *, const T& t)
+{
+    throw omnetpp::cRuntimeError("Parsim error: No doParsimPacking() function for type %s", omnetpp::opp_typename(typeid(t)));
+}
+
+template<typename T>
+void doParsimUnpacking(omnetpp::cCommBuffer *, T& t)
+{
+    throw omnetpp::cRuntimeError("Parsim error: No doParsimUnpacking() function for type %s", omnetpp::opp_typename(typeid(t)));
+}
+
+}  // namespace omnetpp
+
+
+// forward
+template<typename T, typename A>
+std::ostream& operator<<(std::ostream& out, const std::vector<T,A>& vec);
+
+// Template rule which fires if a struct or class doesn't have operator<<
+template<typename T>
+inline std::ostream& operator<<(std::ostream& out,const T&) {return out;}
+
+// operator<< for std::vector<T>
+template<typename T, typename A>
+inline std::ostream& operator<<(std::ostream& out, const std::vector<T,A>& vec)
+{
+    out.put('{');
+    for(typename std::vector<T,A>::const_iterator it = vec.begin(); it != vec.end(); ++it)
+    {
+        if (it != vec.begin()) {
+            out.put(','); out.put(' ');
+        }
+        out << *it;
+    }
+    out.put('}');
+    
+    char buf[32];
+    sprintf(buf, " (size=%u)", (unsigned int)vec.size());
+    out.write(buf, strlen(buf));
+    return out;
+}
+
+Register_Class(Long_Header)
+
+Long_Header::Long_Header(const char *name, short kind) : ::omnetpp::cPacket(name,kind)
+{
+    this->type = 0;
+    this->CID = 0;
+    this->PN = 0;
+    this->version = 0;
+}
+
+Long_Header::Long_Header(const Long_Header& other) : ::omnetpp::cPacket(other)
+{
+    copy(other);
+}
+
+Long_Header::~Long_Header()
+{
+}
+
+Long_Header& Long_Header::operator=(const Long_Header& other)
+{
+    if (this==&other) return *this;
+    ::omnetpp::cPacket::operator=(other);
+    copy(other);
+    return *this;
+}
+
+void Long_Header::copy(const Long_Header& other)
+{
+    this->type = other.type;
+    this->CID = other.CID;
+    this->PN = other.PN;
+    this->version = other.version;
+}
+
+void Long_Header::parsimPack(omnetpp::cCommBuffer *b) const
+{
+    ::omnetpp::cPacket::parsimPack(b);
+    doParsimPacking(b,this->type);
+    doParsimPacking(b,this->CID);
+    doParsimPacking(b,this->PN);
+    doParsimPacking(b,this->version);
+}
+
+void Long_Header::parsimUnpack(omnetpp::cCommBuffer *b)
+{
+    ::omnetpp::cPacket::parsimUnpack(b);
+    doParsimUnpacking(b,this->type);
+    doParsimUnpacking(b,this->CID);
+    doParsimUnpacking(b,this->PN);
+    doParsimUnpacking(b,this->version);
+}
+
+uint8_t Long_Header::getType() const
+{
+    return this->type;
+}
+
+void Long_Header::setType(uint8_t type)
+{
+    this->type = type;
+}
+
+uint64_t Long_Header::getCID() const
+{
+    return this->CID;
+}
+
+void Long_Header::setCID(uint64_t CID)
+{
+    this->CID = CID;
+}
+
+uint32_t Long_Header::getPN() const
+{
+    return this->PN;
+}
+
+void Long_Header::setPN(uint32_t PN)
+{
+    this->PN = PN;
+}
+
+uint32_t Long_Header::getVersion() const
+{
+    return this->version;
+}
+
+void Long_Header::setVersion(uint32_t version)
+{
+    this->version = version;
+}
+
+class Long_HeaderDescriptor : public omnetpp::cClassDescriptor
+{
+  private:
+    mutable const char **propertynames;
+  public:
+    Long_HeaderDescriptor();
+    virtual ~Long_HeaderDescriptor();
+
+    virtual bool doesSupport(omnetpp::cObject *obj) const override;
+    virtual const char **getPropertyNames() const override;
+    virtual const char *getProperty(const char *propertyname) const override;
+    virtual int getFieldCount() const override;
+    virtual const char *getFieldName(int field) const override;
+    virtual int findField(const char *fieldName) const override;
+    virtual unsigned int getFieldTypeFlags(int field) const override;
+    virtual const char *getFieldTypeString(int field) const override;
+    virtual const char **getFieldPropertyNames(int field) const override;
+    virtual const char *getFieldProperty(int field, const char *propertyname) const override;
+    virtual int getFieldArraySize(void *object, int field) const override;
+
+    virtual const char *getFieldDynamicTypeString(void *object, int field, int i) const override;
+    virtual std::string getFieldValueAsString(void *object, int field, int i) const override;
+    virtual bool setFieldValueAsString(void *object, int field, int i, const char *value) const override;
+
+    virtual const char *getFieldStructName(int field) const override;
+    virtual void *getFieldStructValuePointer(void *object, int field, int i) const override;
+};
+
+Register_ClassDescriptor(Long_HeaderDescriptor)
+
+Long_HeaderDescriptor::Long_HeaderDescriptor() : omnetpp::cClassDescriptor("Long_Header", "omnetpp::cPacket")
+{
+    propertynames = nullptr;
+}
+
+Long_HeaderDescriptor::~Long_HeaderDescriptor()
+{
+    delete[] propertynames;
+}
+
+bool Long_HeaderDescriptor::doesSupport(omnetpp::cObject *obj) const
+{
+    return dynamic_cast<Long_Header *>(obj)!=nullptr;
+}
+
+const char **Long_HeaderDescriptor::getPropertyNames() const
+{
+    if (!propertynames) {
+        static const char *names[] = {  nullptr };
+        omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
+        const char **basenames = basedesc ? basedesc->getPropertyNames() : nullptr;
+        propertynames = mergeLists(basenames, names);
+    }
+    return propertynames;
+}
+
+const char *Long_HeaderDescriptor::getProperty(const char *propertyname) const
+{
+    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
+    return basedesc ? basedesc->getProperty(propertyname) : nullptr;
+}
+
+int Long_HeaderDescriptor::getFieldCount() const
+{
+    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
+    return basedesc ? 4+basedesc->getFieldCount() : 4;
+}
+
+unsigned int Long_HeaderDescriptor::getFieldTypeFlags(int field) const
+{
+    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
+    if (basedesc) {
+        if (field < basedesc->getFieldCount())
+            return basedesc->getFieldTypeFlags(field);
+        field -= basedesc->getFieldCount();
+    }
+    static unsigned int fieldTypeFlags[] = {
+        FD_ISEDITABLE,
+        FD_ISEDITABLE,
+        FD_ISEDITABLE,
+        FD_ISEDITABLE,
+    };
+    return (field>=0 && field<4) ? fieldTypeFlags[field] : 0;
+}
+
+const char *Long_HeaderDescriptor::getFieldName(int field) const
+{
+    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
+    if (basedesc) {
+        if (field < basedesc->getFieldCount())
+            return basedesc->getFieldName(field);
+        field -= basedesc->getFieldCount();
+    }
+    static const char *fieldNames[] = {
+        "type",
+        "CID",
+        "PN",
+        "version",
+    };
+    return (field>=0 && field<4) ? fieldNames[field] : nullptr;
+}
+
+int Long_HeaderDescriptor::findField(const char *fieldName) const
+{
+    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
+    int base = basedesc ? basedesc->getFieldCount() : 0;
+    if (fieldName[0]=='t' && strcmp(fieldName, "type")==0) return base+0;
+    if (fieldName[0]=='C' && strcmp(fieldName, "CID")==0) return base+1;
+    if (fieldName[0]=='P' && strcmp(fieldName, "PN")==0) return base+2;
+    if (fieldName[0]=='v' && strcmp(fieldName, "version")==0) return base+3;
+    return basedesc ? basedesc->findField(fieldName) : -1;
+}
+
+const char *Long_HeaderDescriptor::getFieldTypeString(int field) const
+{
+    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
+    if (basedesc) {
+        if (field < basedesc->getFieldCount())
+            return basedesc->getFieldTypeString(field);
+        field -= basedesc->getFieldCount();
+    }
+    static const char *fieldTypeStrings[] = {
+        "uint8_t",
+        "uint64_t",
+        "uint32_t",
+        "uint32_t",
+    };
+    return (field>=0 && field<4) ? fieldTypeStrings[field] : nullptr;
+}
+
+const char **Long_HeaderDescriptor::getFieldPropertyNames(int field) const
+{
+    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
+    if (basedesc) {
+        if (field < basedesc->getFieldCount())
+            return basedesc->getFieldPropertyNames(field);
+        field -= basedesc->getFieldCount();
+    }
+    switch (field) {
+        default: return nullptr;
+    }
+}
+
+const char *Long_HeaderDescriptor::getFieldProperty(int field, const char *propertyname) const
+{
+    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
+    if (basedesc) {
+        if (field < basedesc->getFieldCount())
+            return basedesc->getFieldProperty(field, propertyname);
+        field -= basedesc->getFieldCount();
+    }
+    switch (field) {
+        default: return nullptr;
+    }
+}
+
+int Long_HeaderDescriptor::getFieldArraySize(void *object, int field) const
+{
+    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
+    if (basedesc) {
+        if (field < basedesc->getFieldCount())
+            return basedesc->getFieldArraySize(object, field);
+        field -= basedesc->getFieldCount();
+    }
+    Long_Header *pp = (Long_Header *)object; (void)pp;
+    switch (field) {
+        default: return 0;
+    }
+}
+
+const char *Long_HeaderDescriptor::getFieldDynamicTypeString(void *object, int field, int i) const
+{
+    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
+    if (basedesc) {
+        if (field < basedesc->getFieldCount())
+            return basedesc->getFieldDynamicTypeString(object,field,i);
+        field -= basedesc->getFieldCount();
+    }
+    Long_Header *pp = (Long_Header *)object; (void)pp;
+    switch (field) {
+        default: return nullptr;
+    }
+}
+
+std::string Long_HeaderDescriptor::getFieldValueAsString(void *object, int field, int i) const
+{
+    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
+    if (basedesc) {
+        if (field < basedesc->getFieldCount())
+            return basedesc->getFieldValueAsString(object,field,i);
+        field -= basedesc->getFieldCount();
+    }
+    Long_Header *pp = (Long_Header *)object; (void)pp;
+    switch (field) {
+        case 0: return ulong2string(pp->getType());
+        case 1: return uint642string(pp->getCID());
+        case 2: return ulong2string(pp->getPN());
+        case 3: return ulong2string(pp->getVersion());
+        default: return "";
+    }
+}
+
+bool Long_HeaderDescriptor::setFieldValueAsString(void *object, int field, int i, const char *value) const
+{
+    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
+    if (basedesc) {
+        if (field < basedesc->getFieldCount())
+            return basedesc->setFieldValueAsString(object,field,i,value);
+        field -= basedesc->getFieldCount();
+    }
+    Long_Header *pp = (Long_Header *)object; (void)pp;
+    switch (field) {
+        case 0: pp->setType(string2ulong(value)); return true;
+        case 1: pp->setCID(string2uint64(value)); return true;
+        case 2: pp->setPN(string2ulong(value)); return true;
+        case 3: pp->setVersion(string2ulong(value)); return true;
+        default: return false;
+    }
+}
+
+const char *Long_HeaderDescriptor::getFieldStructName(int field) const
+{
+    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
+    if (basedesc) {
+        if (field < basedesc->getFieldCount())
+            return basedesc->getFieldStructName(field);
+        field -= basedesc->getFieldCount();
+    }
+    switch (field) {
+        default: return nullptr;
+    };
+}
+
+void *Long_HeaderDescriptor::getFieldStructValuePointer(void *object, int field, int i) const
+{
+    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
+    if (basedesc) {
+        if (field < basedesc->getFieldCount())
+            return basedesc->getFieldStructValuePointer(object, field, i);
+        field -= basedesc->getFieldCount();
+    }
+    Long_Header *pp = (Long_Header *)object; (void)pp;
+    switch (field) {
+        default: return nullptr;
+    }
+}
+
+

QUIC/Headers/long_Header_m.h

@@ -0,0 +1,76 @@
+//
+// Generated file, do not edit! Created by nedtool 5.2 from Headers/long_Header.msg.
+//
+
+#if defined(__clang__)
+#  pragma clang diagnostic ignored "-Wreserved-id-macro"
+#endif
+#ifndef __LONG_HEADER_M_H
+#define __LONG_HEADER_M_H
+
+#include <omnetpp.h>
+
+// nedtool version check
+#define MSGC_VERSION 0x0502
+#if (MSGC_VERSION!=OMNETPP_VERSION)
+#    error Version mismatch! Probably this file was generated by an earlier version of nedtool: 'make clean' should help.
+#endif
+
+
+
+/**
+ * Class generated from <tt>Headers/long_Header.msg:19</tt> by nedtool.
+ * <pre>
+ * //
+ * // TODO generated message class
+ * //
+ * packet Long_Header
+ * {
+ *     uint8_t type;
+ *     uint64_t CID;
+ *     uint32_t PN;
+ *     uint32_t version;
+ * }
+ * </pre>
+ */
+class Long_Header : public ::omnetpp::cPacket
+{
+  protected:
+    uint8_t type;
+    uint64_t CID;
+    uint32_t PN;
+    uint32_t version;
+
+  private:
+    void copy(const Long_Header& other);
+
+  protected:
+    // protected and unimplemented operator==(), to prevent accidental usage
+    bool operator==(const Long_Header&);
+
+  public:
+    Long_Header(const char *name=nullptr, short kind=0);
+    Long_Header(const Long_Header& other);
+    virtual ~Long_Header();
+    Long_Header& operator=(const Long_Header& other);
+    virtual Long_Header *dup() const override {return new Long_Header(*this);}
+    virtual void parsimPack(omnetpp::cCommBuffer *b) const override;
+    virtual void parsimUnpack(omnetpp::cCommBuffer *b) override;
+
+    // field getter/setter methods
+    virtual uint8_t getType() const;
+    virtual void setType(uint8_t type);
+    virtual uint64_t getCID() const;
+    virtual void setCID(uint64_t CID);
+    virtual uint32_t getPN() const;
+    virtual void setPN(uint32_t PN);
+    virtual uint32_t getVersion() const;
+    virtual void setVersion(uint32_t version);
+};
+
+inline void doParsimPacking(omnetpp::cCommBuffer *b, const Long_Header& obj) {obj.parsimPack(b);}
+inline void doParsimUnpacking(omnetpp::cCommBuffer *b, Long_Header& obj) {obj.parsimUnpack(b);}
+
+
+#endif // ifndef __LONG_HEADER_M_H
+

QUIC/Headers/short_Header.msg

@@ -0,0 +1,24 @@
+//
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Lesser General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+// 
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU Lesser General Public License for more details.
+// 
+// You should have received a copy of the GNU Lesser General Public License
+// along with this program.  If not, see http://www.gnu.org/licenses/.
+// 
+
+
+//
+// TODO generated message class
+//
+packet Short_Header {
+    uint8_t type;
+    uint64_t CID;
+    uint32_t PN;
+}

QUIC/Headers/short_Header_m.cc

@@ -0,0 +1,500 @@
+//
+// Generated file, do not edit! Created by nedtool 5.2 from Headers/short_Header.msg.
+//
+
+// Disable warnings about unused variables, empty switch stmts, etc:
+#ifdef _MSC_VER
+#  pragma warning(disable:4101)
+#  pragma warning(disable:4065)
+#endif
+
+#if defined(__clang__)
+#  pragma clang diagnostic ignored "-Wshadow"
+#  pragma clang diagnostic ignored "-Wconversion"
+#  pragma clang diagnostic ignored "-Wunused-parameter"
+#  pragma clang diagnostic ignored "-Wc++98-compat"
+#  pragma clang diagnostic ignored "-Wunreachable-code-break"
+#  pragma clang diagnostic ignored "-Wold-style-cast"
+#elif defined(__GNUC__)
+#  pragma GCC diagnostic ignored "-Wshadow"
+#  pragma GCC diagnostic ignored "-Wconversion"
+#  pragma GCC diagnostic ignored "-Wunused-parameter"
+#  pragma GCC diagnostic ignored "-Wold-style-cast"
+#  pragma GCC diagnostic ignored "-Wsuggest-attribute=noreturn"
+#  pragma GCC diagnostic ignored "-Wfloat-conversion"
+#endif
+
+#include <iostream>
+#include <sstream>
+#include "short_Header_m.h"
+
+namespace omnetpp {
+
+// Template pack/unpack rules. They are declared *after* a1l type-specific pack functions for multiple reasons.
+// They are in the omnetpp namespace, to allow them to be found by argument-dependent lookup via the cCommBuffer argument
+
+// Packing/unpacking an std::vector
+template<typename T, typename A>
+void doParsimPacking(omnetpp::cCommBuffer *buffer, const std::vector<T,A>& v)
+{
+    int n = v.size();
+    doParsimPacking(buffer, n);
+    for (int i = 0; i < n; i++)
+        doParsimPacking(buffer, v[i]);
+}
+
+template<typename T, typename A>
+void doParsimUnpacking(omnetpp::cCommBuffer *buffer, std::vector<T,A>& v)
+{
+    int n;
+    doParsimUnpacking(buffer, n);
+    v.resize(n);
+    for (int i = 0; i < n; i++)
+        doParsimUnpacking(buffer, v[i]);
+}
+
+// Packing/unpacking an std::list
+template<typename T, typename A>
+void doParsimPacking(omnetpp::cCommBuffer *buffer, const std::list<T,A>& l)
+{
+    doParsimPacking(buffer, (int)l.size());
+    for (typename std::list<T,A>::const_iterator it = l.begin(); it != l.end(); ++it)
+        doParsimPacking(buffer, (T&)*it);
+}
+
+template<typename T, typename A>
+void doParsimUnpacking(omnetpp::cCommBuffer *buffer, std::list<T,A>& l)
+{
+    int n;
+    doParsimUnpacking(buffer, n);
+    for (int i=0; i<n; i++) {
+        l.push_back(T());
+        doParsimUnpacking(buffer, l.back());
+    }
+}
+
+// Packing/unpacking an std::set
+template<typename T, typename Tr, typename A>
+void doParsimPacking(omnetpp::cCommBuffer *buffer, const std::set<T,Tr,A>& s)
+{
+    doParsimPacking(buffer, (int)s.size());
+    for (typename std::set<T,Tr,A>::const_iterator it = s.begin(); it != s.end(); ++it)
+        doParsimPacking(buffer, *it);
+}
+
+template<typename T, typename Tr, typename A>
+void doParsimUnpacking(omnetpp::cCommBuffer *buffer, std::set<T,Tr,A>& s)
+{
+    int n;
+    doParsimUnpacking(buffer, n);
+    for (int i=0; i<n; i++) {
+        T x;
+        doParsimUnpacking(buffer, x);
+        s.insert(x);
+    }
+}
+
+// Packing/unpacking an std::map
+template<typename K, typename V, typename Tr, typename A>
+void doParsimPacking(omnetpp::cCommBuffer *buffer, const std::map<K,V,Tr,A>& m)
+{
+    doParsimPacking(buffer, (int)m.size());
+    for (typename std::map<K,V,Tr,A>::const_iterator it = m.begin(); it != m.end(); ++it) {
+        doParsimPacking(buffer, it->first);
+        doParsimPacking(buffer, it->second);
+    }
+}
+
+template<typename K, typename V, typename Tr, typename A>
+void doParsimUnpacking(omnetpp::cCommBuffer *buffer, std::map<K,V,Tr,A>& m)
+{
+    int n;
+    doParsimUnpacking(buffer, n);
+    for (int i=0; i<n; i++) {
+        K k; V v;
+        doParsimUnpacking(buffer, k);
+        doParsimUnpacking(buffer, v);
+        m[k] = v;
+    }
+}
+
+// Default pack/unpack function for arrays
+template<typename T>
+void doParsimArrayPacking(omnetpp::cCommBuffer *b, const T *t, int n)
+{
+    for (int i = 0; i < n; i++)
+        doParsimPacking(b, t[i]);
+}
+
+template<typename T>
+void doParsimArrayUnpacking(omnetpp::cCommBuffer *b, T *t, int n)
+{
+    for (int i = 0; i < n; i++)
+        doParsimUnpacking(b, t[i]);
+}
+
+// Default rule to prevent compiler from choosing base class' doParsimPacking() function
+template<typename T>
+void doParsimPacking(omnetpp::cCommBuffer *, const T& t)
+{
+    throw omnetpp::cRuntimeError("Parsim error: No doParsimPacking() function for type %s", omnetpp::opp_typename(typeid(t)));
+}
+
+template<typename T>
+void doParsimUnpacking(omnetpp::cCommBuffer *, T& t)
+{
+    throw omnetpp::cRuntimeError("Parsim error: No doParsimUnpacking() function for type %s", omnetpp::opp_typename(typeid(t)));
+}
+
+}  // namespace omnetpp
+
+
+// forward
+template<typename T, typename A>
+std::ostream& operator<<(std::ostream& out, const std::vector<T,A>& vec);
+
+// Template rule which fires if a struct or class doesn't have operator<<
+template<typename T>
+inline std::ostream& operator<<(std::ostream& out,const T&) {return out;}
+
+// operator<< for std::vector<T>
+template<typename T, typename A>
+inline std::ostream& operator<<(std::ostream& out, const std::vector<T,A>& vec)
+{
+    out.put('{');
+    for(typename std::vector<T,A>::const_iterator it = vec.begin(); it != vec.end(); ++it)
+    {
+        if (it != vec.begin()) {
+            out.put(','); out.put(' ');
+        }
+        out << *it;
+    }
+    out.put('}');
+    
+    char buf[32];
+    sprintf(buf, " (size=%u)", (unsigned int)vec.size());
+    out.write(buf, strlen(buf));
+    return out;
+}
+
+Register_Class(Short_Header)
+
+Short_Header::Short_Header(const char *name, short kind) : ::omnetpp::cPacket(name,kind)
+{
+    this->type = 0;
+    this->CID = 0;
+    this->PN = 0;
+}
+
+Short_Header::Short_Header(const Short_Header& other) : ::omnetpp::cPacket(other)
+{
+    copy(other);
+}
+
+Short_Header::~Short_Header()
+{
+}
+
+Short_Header& Short_Header::operator=(const Short_Header& other)
+{
+    if (this==&other) return *this;
+    ::omnetpp::cPacket::operator=(other);
+    copy(other);
+    return *this;
+}
+
+void Short_Header::copy(const Short_Header& other)
+{
+    this->type = other.type;
+    this->CID = other.CID;
+    this->PN = other.PN;
+}
+
+void Short_Header::parsimPack(omnetpp::cCommBuffer *b) const
+{
+    ::omnetpp::cPacket::parsimPack(b);
+    doParsimPacking(b,this->type);
+    doParsimPacking(b,this->CID);
+    doParsimPacking(b,this->PN);
+}
+
+void Short_Header::parsimUnpack(omnetpp::cCommBuffer *b)
+{
+    ::omnetpp::cPacket::parsimUnpack(b);
+    doParsimUnpacking(b,this->type);
+    doParsimUnpacking(b,this->CID);
+    doParsimUnpacking(b,this->PN);
+}
+
+uint8_t Short_Header::getType() const
+{
+    return this->type;
+}
+
+void Short_Header::setType(uint8_t type)
+{
+    this->type = type;
+}
+
+uint64_t Short_Header::getCID() const
+{
+    return this->CID;
+}
+
+void Short_Header::setCID(uint64_t CID)
+{
+    this->CID = CID;
+}
+
+uint32_t Short_Header::getPN() const
+{
+    return this->PN;
+}
+
+void Short_Header::setPN(uint32_t PN)
+{
+    this->PN = PN;
+}
+
+class Short_HeaderDescriptor : public omnetpp::cClassDescriptor
+{
+  private:
+    mutable const char **propertynames;
+  public:
+    Short_HeaderDescriptor();
+    virtual ~Short_HeaderDescriptor();
+
+    virtual bool doesSupport(omnetpp::cObject *obj) const override;
+    virtual const char **getPropertyNames() const override;
+    virtual const char *getProperty(const char *propertyname) const override;
+    virtual int getFieldCount() const override;
+    virtual const char *getFieldName(int field) const override;
+    virtual int findField(const char *fieldName) const override;
+    virtual unsigned int getFieldTypeFlags(int field) const override;
+    virtual const char *getFieldTypeString(int field) const override;
+    virtual const char **getFieldPropertyNames(int field) const override;
+    virtual const char *getFieldProperty(int field, const char *propertyname) const override;
+    virtual int getFieldArraySize(void *object, int field) const override;
+
+    virtual const char *getFieldDynamicTypeString(void *object, int field, int i) const override;
+    virtual std::string getFieldValueAsString(void *object, int field, int i) const override;
+    virtual bool setFieldValueAsString(void *object, int field, int i, const char *value) const override;
+
+    virtual const char *getFieldStructName(int field) const override;
+    virtual void *getFieldStructValuePointer(void *object, int field, int i) const override;
+};
+
+Register_ClassDescriptor(Short_HeaderDescriptor)
+
+Short_HeaderDescriptor::Short_HeaderDescriptor() : omnetpp::cClassDescriptor("Short_Header", "omnetpp::cPacket")
+{
+    propertynames = nullptr;
+}
+
+Short_HeaderDescriptor::~Short_HeaderDescriptor()
+{
+    delete[] propertynames;
+}
+
+bool Short_HeaderDescriptor::doesSupport(omnetpp::cObject *obj) const
+{
+    return dynamic_cast<Short_Header *>(obj)!=nullptr;
+}
+
+const char **Short_HeaderDescriptor::getPropertyNames() const
+{
+    if (!propertynames) {
+        static const char *names[] = {  nullptr };
+        omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
+        const char **basenames = basedesc ? basedesc->getPropertyNames() : nullptr;
+        propertynames = mergeLists(basenames, names);
+    }
+    return propertynames;
+}
+
+const char *Short_HeaderDescriptor::getProperty(const char *propertyname) const
+{
+    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
+    return basedesc ? basedesc->getProperty(propertyname) : nullptr;
+}
+
+int Short_HeaderDescriptor::getFieldCount() const
+{
+    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
+    return basedesc ? 3+basedesc->getFieldCount() : 3;
+}
+
+unsigned int Short_HeaderDescriptor::getFieldTypeFlags(int field) const
+{
+    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
+    if (basedesc) {
+        if (field < basedesc->getFieldCount())
+            return basedesc->getFieldTypeFlags(field);
+        field -= basedesc->getFieldCount();
+    }
+    static unsigned int fieldTypeFlags[] = {
+        FD_ISEDITABLE,
+        FD_ISEDITABLE,
+        FD_ISEDITABLE,
+    };
+    return (field>=0 && field<3) ? fieldTypeFlags[field] : 0;
+}
+
+const char *Short_HeaderDescriptor::getFieldName(int field) const
+{
+    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
+    if (basedesc) {
+        if (field < basedesc->getFieldCount())
+            return basedesc->getFieldName(field);
+        field -= basedesc->getFieldCount();
+    }
+    static const char *fieldNames[] = {
+        "type",
+        "CID",
+        "PN",
+    };
+    return (field>=0 && field<3) ? fieldNames[field] : nullptr;
+}
+
+int Short_HeaderDescriptor::findField(const char *fieldName) const
+{
+    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
+    int base = basedesc ? basedesc->getFieldCount() : 0;
+    if (fieldName[0]=='t' && strcmp(fieldName, "type")==0) return base+0;
+    if (fieldName[0]=='C' && strcmp(fieldName, "CID")==0) return base+1;
+    if (fieldName[0]=='P' && strcmp(fieldName, "PN")==0) return base+2;
+    return basedesc ? basedesc->findField(fieldName) : -1;
+}
+
+const char *Short_HeaderDescriptor::getFieldTypeString(int field) const
+{
+    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
+    if (basedesc) {
+        if (field < basedesc->getFieldCount())
+            return basedesc->getFieldTypeString(field);
+        field -= basedesc->getFieldCount();
+    }
+    static const char *fieldTypeStrings[] = {
+        "uint8_t",
+        "uint64_t",
+        "uint32_t",
+    };
+    return (field>=0 && field<3) ? fieldTypeStrings[field] : nullptr;
+}
+
+const char **Short_HeaderDescriptor::getFieldPropertyNames(int field) const
+{
+    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
+    if (basedesc) {
+        if (field < basedesc->getFieldCount())
+            return basedesc->getFieldPropertyNames(field);
+        field -= basedesc->getFieldCount();
+    }
+    switch (field) {
+        default: return nullptr;
+    }
+}
+
+const char *Short_HeaderDescriptor::getFieldProperty(int field, const char *propertyname) const
+{
+    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
+    if (basedesc) {
+        if (field < basedesc->getFieldCount())
+            return basedesc->getFieldProperty(field, propertyname);
+        field -= basedesc->getFieldCount();
+    }
+    switch (field) {
+        default: return nullptr;
+    }
+}
+
+int Short_HeaderDescriptor::getFieldArraySize(void *object, int field) const
+{
+    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
+    if (basedesc) {
+        if (field < basedesc->getFieldCount())
+            return basedesc->getFieldArraySize(object, field);
+        field -= basedesc->getFieldCount();
+    }
+    Short_Header *pp = (Short_Header *)object; (void)pp;
+    switch (field) {
+        default: return 0;
+    }
+}
+
+const char *Short_HeaderDescriptor::getFieldDynamicTypeString(void *object, int field, int i) const
+{
+    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
+    if (basedesc) {
+        if (field < basedesc->getFieldCount())
+            return basedesc->getFieldDynamicTypeString(object,field,i);
+        field -= basedesc->getFieldCount();
+    }
+    Short_Header *pp = (Short_Header *)object; (void)pp;
+    switch (field) {
+        default: return nullptr;
+    }
+}
+
+std::string Short_HeaderDescriptor::getFieldValueAsString(void *object, int field, int i) const
+{
+    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
+    if (basedesc) {
+        if (field < basedesc->getFieldCount())
+            return basedesc->getFieldValueAsString(object,field,i);
+        field -= basedesc->getFieldCount();
+    }
+    Short_Header *pp = (Short_Header *)object; (void)pp;
+    switch (field) {
+        case 0: return ulong2string(pp->getType());
+        case 1: return uint642string(pp->getCID());
+        case 2: return ulong2string(pp->getPN());
+        default: return "";
+    }
+}
+
+bool Short_HeaderDescriptor::setFieldValueAsString(void *object, int field, int i, const char *value) const
+{
+    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
+    if (basedesc) {
+        if (field < basedesc->getFieldCount())
+            return basedesc->setFieldValueAsString(object,field,i,value);
+        field -= basedesc->getFieldCount();
+    }
+    Short_Header *pp = (Short_Header *)object; (void)pp;
+    switch (field) {
+        case 0: pp->setType(string2ulong(value)); return true;
+        case 1: pp->setCID(string2uint64(value)); return true;
+        case 2: pp->setPN(string2ulong(value)); return true;
+        default: return false;
+    }
+}
+
+const char *Short_HeaderDescriptor::getFieldStructName(int field) const
+{
+    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
+    if (basedesc) {
+        if (field < basedesc->getFieldCount())
+            return basedesc->getFieldStructName(field);
+        field -= basedesc->getFieldCount();
+    }
+    switch (field) {
+        default: return nullptr;
+    };
+}
+
+void *Short_HeaderDescriptor::getFieldStructValuePointer(void *object, int field, int i) const
+{
+    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
+    if (basedesc) {
+        if (field < basedesc->getFieldCount())
+            return basedesc->getFieldStructValuePointer(object, field, i);
+        field -= basedesc->getFieldCount();
+    }
+    Short_Header *pp = (Short_Header *)object; (void)pp;
+    switch (field) {
+        default: return nullptr;
+    }
+}
+
+

QUIC/Headers/short_Header_m.h

@@ -0,0 +1,72 @@
+//
+// Generated file, do not edit! Created by nedtool 5.2 from Headers/short_Header.msg.
+//
+
+#if defined(__clang__)
+#  pragma clang diagnostic ignored "-Wreserved-id-macro"
+#endif
+#ifndef __SHORT_HEADER_M_H
+#define __SHORT_HEADER_M_H
+
+#include <omnetpp.h>
+
+// nedtool version check
+#define MSGC_VERSION 0x0502
+#if (MSGC_VERSION!=OMNETPP_VERSION)
+#    error Version mismatch! Probably this file was generated by an earlier version of nedtool: 'make clean' should help.
+#endif
+
+
+
+/**
+ * Class generated from <tt>Headers/short_Header.msg:20</tt> by nedtool.
+ * <pre>
+ * //
+ * // TODO generated message class
+ * //
+ * packet Short_Header
+ * {
+ *     uint8_t type;
+ *     uint64_t CID;
+ *     uint32_t PN;
+ * }
+ * </pre>
+ */
+class Short_Header : public ::omnetpp::cPacket
+{
+  protected:
+    uint8_t type;
+    uint64_t CID;
+    uint32_t PN;
+
+  private:
+    void copy(const Short_Header& other);
+
+  protected:
+    // protected and unimplemented operator==(), to prevent accidental usage
+    bool operator==(const Short_Header&);
+
+  public:
+    Short_Header(const char *name=nullptr, short kind=0);
+    Short_Header(const Short_Header& other);
+    virtual ~Short_Header();
+    Short_Header& operator=(const Short_Header& other);
+    virtual Short_Header *dup() const override {return new Short_Header(*this);}
+    virtual void parsimPack(omnetpp::cCommBuffer *b) const override;
+    virtual void parsimUnpack(omnetpp::cCommBuffer *b) override;
+
+    // field getter/setter methods
+    virtual uint8_t getType() const;
+    virtual void setType(uint8_t type);
+    virtual uint64_t getCID() const;
+    virtual void setCID(uint64_t CID);
+    virtual uint32_t getPN() const;
+    virtual void setPN(uint32_t PN);
+};
+
+inline void doParsimPacking(omnetpp::cCommBuffer *b, const Short_Header& obj) {obj.parsimPack(b);}
+inline void doParsimUnpacking(omnetpp::cCommBuffer *b, Short_Header& obj) {obj.parsimUnpack(b);}
+
+
+#endif // ifndef __SHORT_HEADER_M_H
+

QUIC/Headers/transport_Error_Codes.h

@@ -0,0 +1,36 @@
+/*
+ * error_Codes.h
+ *
+ *  Created on: Nov 27, 2017
+ *      Author: anay
+ */
+
+#ifndef HEADERS_TRANSPORT_ERROR_CODES_H_
+#define HEADERS_TRANSPORT_ERROR_CODES_H_
+
+#define NO_ERROR 0x00
+#define INTERNAL_ERROR 0x01
+#define FLOW_CONTROL_ERROR 0x03
+#define STREAM_ID_ERROR 0x04
+#define STREAM_STATE_ERROR 0x05
+#define STREAM_STATE_ERROR 0x06
+#define FRAME_FORMAT_ERROR 0x07
+#define TRANSPORT_PARAMETER_ERROR 0x08
+#define VERSION_NEGOTIATION_ERROR 0x09
+#define PROTOCOL_VIOLATION 0x0A
+#define PADDING_FRAME_ERROR 0x100
+#define RST_STREAM_ERROR 0x101
+#define CONNECTION_CLOSE_FRAME_ERROR 0x102
+#define APPLICATION_CLOSE_FRAME_ERROR 0x103
+#define MAX_DATA_FRAME_ERROR 0x104
+#define MAX_STREAM_DATA_FRAME_ERROR 0x105
+#define MAX_STREAM_ID_FRAME_ERROR 0x106
+#define PING_FRAME_ERROR 0x107
+#define BLOCKED_FRAME_ERROR 0x108
+#define STREAM_BLOCKED_FRAME_ERROR 0x109
+#define STREAM_ID_BLOCKED_FRAME_ERROR 0x10A
+#define NEW_CONNECTION_ID_FRAME_ERROR 0x10B
+#define STOP_SENDING_FRAME_ERROR 0x10C
+
+
+#endif /* HEADERS_TRANSPORT_ERROR_CODES_H_ */

QUIC/Makefile

@@ -0,0 +1,177 @@
+#
+# OMNeT++/OMNEST Makefile for QUIC
+#
+# This file was generated with the command:
+#  opp_makemake -f --deep -O out -I.
+#
+
+# Name of target to be created (-o option)
+TARGET = QUIC$(D)$(EXE_SUFFIX)
+TARGET_DIR = .
+
+# User interface (uncomment one) (-u option)
+USERIF_LIBS = $(ALL_ENV_LIBS) # that is, $(TKENV_LIBS) $(QTENV_LIBS) $(CMDENV_LIBS)
+#USERIF_LIBS = $(CMDENV_LIBS)
+#USERIF_LIBS = $(TKENV_LIBS)
+#USERIF_LIBS = $(QTENV_LIBS)
+
+# C++ include paths (with -I)
+INCLUDE_PATH = -I.
+
+# Additional object and library files to link with
+EXTRA_OBJS =
+
+# Additional libraries (-L, -l options)
+LIBS =
+
+# Output directory
+PROJECT_OUTPUT_DIR = out
+PROJECTRELATIVE_PATH =
+O = $(PROJECT_OUTPUT_DIR)/$(CONFIGNAME)/$(PROJECTRELATIVE_PATH)
+
+# Object files for local .cc, .msg and .sm files
+OBJS = \
+    $O/Frames/ack_m.o \
+    $O/Frames/application_Close_m.o \
+    $O/Frames/blocked_m.o \
+    $O/Frames/connection_close_m.o \
+    $O/Frames/max_Data_m.o \
+    $O/Frames/max_Stream_Data_m.o \
+    $O/Frames/max_Stream_Id_m.o \
+    $O/Frames/new_Connection_Id_m.o \
+    $O/Frames/padding_m.o \
+    $O/Frames/ping_m.o \
+    $O/Frames/rst_stream_m.o \
+    $O/Frames/stop_Sending_m.o \
+    $O/Frames/stream_m.o \
+    $O/Frames/stream_Blocked_m.o \
+    $O/Frames/stream_Id_Blocked_m.o \
+    $O/Headers/long_Header_m.o \
+    $O/Headers/short_Header_m.o \
+    $O/Packets/0_RTT_Protected_m.o \
+    $O/Packets/client_Cleartext_m.o \
+    $O/Packets/client_Initial_m.o \
+    $O/Packets/server_Cleartext_m.o \
+    $O/Packets/server_Stateless_Retry_m.o \
+    $O/Packets/version_Negotiation_m.o
+
+# Message files
+MSGFILES = \
+    Frames/ack.msg \
+    Frames/application_Close.msg \
+    Frames/blocked.msg \
+    Frames/connection_close.msg \
+    Frames/max_Data.msg \
+    Frames/max_Stream_Data.msg \
+    Frames/max_Stream_Id.msg \
+    Frames/new_Connection_Id.msg \
+    Frames/padding.msg \
+    Frames/ping.msg \
+    Frames/rst_stream.msg \
+    Frames/stop_Sending.msg \
+    Frames/stream.msg \
+    Frames/stream_Blocked.msg \
+    Frames/stream_Id_Blocked.msg \
+    Headers/long_Header.msg \
+    Headers/short_Header.msg \
+    Packets/0_RTT_Protected.msg \
+    Packets/client_Cleartext.msg \
+    Packets/client_Initial.msg \
+    Packets/server_Cleartext.msg \
+    Packets/server_Stateless_Retry.msg \
+    Packets/version_Negotiation.msg
+
+# SM files
+SMFILES =
+
+#------------------------------------------------------------------------------
+
+# Pull in OMNeT++ configuration (Makefile.inc)
+
+ifneq ("$(OMNETPP_CONFIGFILE)","")
+CONFIGFILE = $(OMNETPP_CONFIGFILE)
+else
+ifneq ("$(OMNETPP_ROOT)","")
+CONFIGFILE = $(OMNETPP_ROOT)/Makefile.inc
+else
+CONFIGFILE = $(shell opp_configfilepath)
+endif
+endif
+
+ifeq ("$(wildcard $(CONFIGFILE))","")
+$(error Config file '$(CONFIGFILE)' does not exist -- add the OMNeT++ bin directory to the path so that opp_configfilepath can be found, or set the OMNETPP_CONFIGFILE variable to point to Makefile.inc)
+endif
+
+include $(CONFIGFILE)
+
+# Simulation kernel and user interface libraries
+OMNETPP_LIBS = $(OPPMAIN_LIB) $(USERIF_LIBS) $(KERNEL_LIBS) $(SYS_LIBS)
+
+COPTS = $(CFLAGS) $(IMPORT_DEFINES)  $(INCLUDE_PATH) -I$(OMNETPP_INCL_DIR)
+MSGCOPTS = $(INCLUDE_PATH)
+SMCOPTS =
+
+# we want to recompile everything if COPTS changes,
+# so we store COPTS into $COPTS_FILE and have object
+# files depend on it (except when "make depend" was called)
+COPTS_FILE = $O/.last-copts
+ifneq ("$(COPTS)","$(shell cat $(COPTS_FILE) 2>/dev/null || echo '')")
+$(shell $(MKPATH) "$O" && echo "$(COPTS)" >$(COPTS_FILE))
+endif
+
+#------------------------------------------------------------------------------
+# User-supplied makefile fragment(s)
+# >>>
+# <<<
+#------------------------------------------------------------------------------
+
+# Main target
+all: $(TARGET_DIR)/$(TARGET)
+
+$(TARGET_DIR)/% :: $O/%
+	@mkdir -p $(TARGET_DIR)
+	$(Q)$(LN) $< $@
+ifeq ($(TOOLCHAIN_NAME),clangc2)
+	$(Q)-$(LN) $(<:%.dll=%.lib) $(@:%.dll=%.lib)
+endif
+
+$O/$(TARGET): $(OBJS)  $(wildcard $(EXTRA_OBJS)) Makefile $(CONFIGFILE)
+	@$(MKPATH) $O
+	@echo Creating executable: $@
+	$(Q)$(CXX) $(LDFLAGS) -o $O/$(TARGET) $(OBJS) $(EXTRA_OBJS) $(AS_NEEDED_OFF) $(WHOLE_ARCHIVE_ON) $(LIBS) $(WHOLE_ARCHIVE_OFF) $(OMNETPP_LIBS)
+
+.PHONY: all clean cleanall depend msgheaders smheaders
+
+.SUFFIXES: .cc
+
+$O/%.o: %.cc $(COPTS_FILE) | msgheaders smheaders
+	@$(MKPATH) $(dir $@)
+	$(qecho) "$<"
+	$(Q)$(CXX) -c $(CXXFLAGS) $(COPTS) -o $@ $<
+
+%_m.cc %_m.h: %.msg
+	$(qecho) MSGC: $<
+	$(Q)$(MSGC) -s _m.cc $(MSGCOPTS) $?
+
+%_sm.cc %_sm.h: %.sm
+	$(qecho) SMC: $<
+	$(Q)$(SMC) -c++ -suffix cc $(SMCOPTS) $?
+
+msgheaders: $(MSGFILES:.msg=_m.h)
+
+smheaders: $(SMFILES:.sm=_sm.h)
+
+clean:
+	$(qecho) Cleaning $(TARGET)
+	$(Q)-rm -rf $O
+	$(Q)-rm -f $(TARGET_DIR)/$(TARGET)
+	$(Q)-rm -f $(TARGET_DIR)/$(TARGET:%.dll=%.lib)
+	$(Q)-rm -f $(call opp_rwildcard, . , *_m.cc *_m.h *_sm.cc *_sm.h)
+
+cleanall:
+	$(Q)$(MAKE) -s clean MODE=release
+	$(Q)$(MAKE) -s clean MODE=debug
+	$(Q)-rm -rf $(PROJECT_OUTPUT_DIR)
+
+# include all dependencies
+-include $(OBJS:%.o=%.d)

QUIC/Packets/0_RTT_Protected.msg

@@ -0,0 +1,21 @@
+//
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Lesser General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+// 
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU Lesser General Public License for more details.
+// 
+// You should have received a copy of the GNU Lesser General Public License
+// along with this program.  If not, see http://www.gnu.org/licenses/.
+// 
+
+//
+// TODO generated message class
+//
+packet _0_RTT_Protected {
+    int someField;
+}

QUIC/Packets/0_RTT_Protected_m.cc

@@ -0,0 +1,460 @@
+//
+// Generated file, do not edit! Created by nedtool 5.2 from Packets/0_RTT_Protected.msg.
+//
+
+// Disable warnings about unused variables, empty switch stmts, etc:
+#ifdef _MSC_VER
+#  pragma warning(disable:4101)
+#  pragma warning(disable:4065)
+#endif
+
+#if defined(__clang__)
+#  pragma clang diagnostic ignored "-Wshadow"
+#  pragma clang diagnostic ignored "-Wconversion"
+#  pragma clang diagnostic ignored "-Wunused-parameter"
+#  pragma clang diagnostic ignored "-Wc++98-compat"
+#  pragma clang diagnostic ignored "-Wunreachable-code-break"
+#  pragma clang diagnostic ignored "-Wold-style-cast"
+#elif defined(__GNUC__)
+#  pragma GCC diagnostic ignored "-Wshadow"
+#  pragma GCC diagnostic ignored "-Wconversion"
+#  pragma GCC diagnostic ignored "-Wunused-parameter"
+#  pragma GCC diagnostic ignored "-Wold-style-cast"
+#  pragma GCC diagnostic ignored "-Wsuggest-attribute=noreturn"
+#  pragma GCC diagnostic ignored "-Wfloat-conversion"
+#endif
+
+#include <iostream>
+#include <sstream>
+#include "0_RTT_Protected_m.h"
+
+namespace omnetpp {
+
+// Template pack/unpack rules. They are declared *after* a1l type-specific pack functions for multiple reasons.
+// They are in the omnetpp namespace, to allow them to be found by argument-dependent lookup via the cCommBuffer argument
+
+// Packing/unpacking an std::vector
+template<typename T, typename A>
+void doParsimPacking(omnetpp::cCommBuffer *buffer, const std::vector<T,A>& v)
+{
+    int n = v.size();
+    doParsimPacking(buffer, n);
+    for (int i = 0; i < n; i++)
+        doParsimPacking(buffer, v[i]);
+}
+
+template<typename T, typename A>
+void doParsimUnpacking(omnetpp::cCommBuffer *buffer, std::vector<T,A>& v)
+{
+    int n;
+    doParsimUnpacking(buffer, n);
+    v.resize(n);
+    for (int i = 0; i < n; i++)
+        doParsimUnpacking(buffer, v[i]);
+}
+
+// Packing/unpacking an std::list
+template<typename T, typename A>
+void doParsimPacking(omnetpp::cCommBuffer *buffer, const std::list<T,A>& l)
+{
+    doParsimPacking(buffer, (int)l.size());
+    for (typename std::list<T,A>::const_iterator it = l.begin(); it != l.end(); ++it)
+        doParsimPacking(buffer, (T&)*it);
+}
+
+template<typename T, typename A>
+void doParsimUnpacking(omnetpp::cCommBuffer *buffer, std::list<T,A>& l)
+{
+    int n;
+    doParsimUnpacking(buffer, n);
+    for (int i=0; i<n; i++) {
+        l.push_back(T());
+        doParsimUnpacking(buffer, l.back());
+    }
+}
+
+// Packing/unpacking an std::set
+template<typename T, typename Tr, typename A>
+void doParsimPacking(omnetpp::cCommBuffer *buffer, const std::set<T,Tr,A>& s)
+{
+    doParsimPacking(buffer, (int)s.size());
+    for (typename std::set<T,Tr,A>::const_iterator it = s.begin(); it != s.end(); ++it)
+        doParsimPacking(buffer, *it);
+}
+
+template<typename T, typename Tr, typename A>
+void doParsimUnpacking(omnetpp::cCommBuffer *buffer, std::set<T,Tr,A>& s)
+{
+    int n;
+    doParsimUnpacking(buffer, n);
+    for (int i=0; i<n; i++) {
+        T x;
+        doParsimUnpacking(buffer, x);
+        s.insert(x);
+    }
+}
+
+// Packing/unpacking an std::map
+template<typename K, typename V, typename Tr, typename A>
+void doParsimPacking(omnetpp::cCommBuffer *buffer, const std::map<K,V,Tr,A>& m)
+{
+    doParsimPacking(buffer, (int)m.size());
+    for (typename std::map<K,V,Tr,A>::const_iterator it = m.begin(); it != m.end(); ++it) {
+        doParsimPacking(buffer, it->first);
+        doParsimPacking(buffer, it->second);
+    }
+}
+
+template<typename K, typename V, typename Tr, typename A>
+void doParsimUnpacking(omnetpp::cCommBuffer *buffer, std::map<K,V,Tr,A>& m)
+{
+    int n;
+    doParsimUnpacking(buffer, n);
+    for (int i=0; i<n; i++) {
+        K k; V v;
+        doParsimUnpacking(buffer, k);
+        doParsimUnpacking(buffer, v);
+        m[k] = v;
+    }
+}
+
+// Default pack/unpack function for arrays
+template<typename T>
+void doParsimArrayPacking(omnetpp::cCommBuffer *b, const T *t, int n)
+{
+    for (int i = 0; i < n; i++)
+        doParsimPacking(b, t[i]);
+}
+
+template<typename T>
+void doParsimArrayUnpacking(omnetpp::cCommBuffer *b, T *t, int n)
+{
+    for (int i = 0; i < n; i++)
+        doParsimUnpacking(b, t[i]);
+}
+
+// Default rule to prevent compiler from choosing base class' doParsimPacking() function
+template<typename T>
+void doParsimPacking(omnetpp::cCommBuffer *, const T& t)
+{
+    throw omnetpp::cRuntimeError("Parsim error: No doParsimPacking() function for type %s", omnetpp::opp_typename(typeid(t)));
+}
+
+template<typename T>
+void doParsimUnpacking(omnetpp::cCommBuffer *, T& t)
+{
+    throw omnetpp::cRuntimeError("Parsim error: No doParsimUnpacking() function for type %s", omnetpp::opp_typename(typeid(t)));
+}
+
+}  // namespace omnetpp
+
+
+// forward
+template<typename T, typename A>
+std::ostream& operator<<(std::ostream& out, const std::vector<T,A>& vec);
+
+// Template rule which fires if a struct or class doesn't have operator<<
+template<typename T>
+inline std::ostream& operator<<(std::ostream& out,const T&) {return out;}
+
+// operator<< for std::vector<T>
+template<typename T, typename A>
+inline std::ostream& operator<<(std::ostream& out, const std::vector<T,A>& vec)
+{
+    out.put('{');
+    for(typename std::vector<T,A>::const_iterator it = vec.begin(); it != vec.end(); ++it)
+    {
+        if (it != vec.begin()) {
+            out.put(','); out.put(' ');
+        }
+        out << *it;
+    }
+    out.put('}');
+    
+    char buf[32];
+    sprintf(buf, " (size=%u)", (unsigned int)vec.size());
+    out.write(buf, strlen(buf));
+    return out;
+}
+
+Register_Class(_0_RTT_Protected)
+
+_0_RTT_Protected::_0_RTT_Protected(const char *name, short kind) : ::omnetpp::cPacket(name,kind)
+{
+    this->someField = 0;
+}
+
+_0_RTT_Protected::_0_RTT_Protected(const _0_RTT_Protected& other) : ::omnetpp::cPacket(other)
+{
+    copy(other);
+}
+
+_0_RTT_Protected::~_0_RTT_Protected()
+{
+}
+
+_0_RTT_Protected& _0_RTT_Protected::operator=(const _0_RTT_Protected& other)
+{
+    if (this==&other) return *this;
+    ::omnetpp::cPacket::operator=(other);
+    copy(other);
+    return *this;
+}
+
+void _0_RTT_Protected::copy(const _0_RTT_Protected& other)
+{
+    this->someField = other.someField;
+}
+
+void _0_RTT_Protected::parsimPack(omnetpp::cCommBuffer *b) const
+{
+    ::omnetpp::cPacket::parsimPack(b);
+    doParsimPacking(b,this->someField);
+}
+
+void _0_RTT_Protected::parsimUnpack(omnetpp::cCommBuffer *b)
+{
+    ::omnetpp::cPacket::parsimUnpack(b);
+    doParsimUnpacking(b,this->someField);
+}
+
+int _0_RTT_Protected::getSomeField() const
+{
+    return this->someField;
+}
+
+void _0_RTT_Protected::setSomeField(int someField)
+{
+    this->someField = someField;
+}
+
+class _0_RTT_ProtectedDescriptor : public omnetpp::cClassDescriptor
+{
+  private:
+    mutable const char **propertynames;
+  public:
+    _0_RTT_ProtectedDescriptor();
+    virtual ~_0_RTT_ProtectedDescriptor();
+
+    virtual bool doesSupport(omnetpp::cObject *obj) const override;
+    virtual const char **getPropertyNames() const override;
+    virtual const char *getProperty(const char *propertyname) const override;
+    virtual int getFieldCount() const override;
+    virtual const char *getFieldName(int field) const override;
+    virtual int findField(const char *fieldName) const override;
+    virtual unsigned int getFieldTypeFlags(int field) const override;
+    virtual const char *getFieldTypeString(int field) const override;
+    virtual const char **getFieldPropertyNames(int field) const override;
+    virtual const char *getFieldProperty(int field, const char *propertyname) const override;
+    virtual int getFieldArraySize(void *object, int field) const override;
+
+    virtual const char *getFieldDynamicTypeString(void *object, int field, int i) const override;
+    virtual std::string getFieldValueAsString(void *object, int field, int i) const override;
+    virtual bool setFieldValueAsString(void *object, int field, int i, const char *value) const override;
+
+    virtual const char *getFieldStructName(int field) const override;
+    virtual void *getFieldStructValuePointer(void *object, int field, int i) const override;
+};
+
+Register_ClassDescriptor(_0_RTT_ProtectedDescriptor)
+
+_0_RTT_ProtectedDescriptor::_0_RTT_ProtectedDescriptor() : omnetpp::cClassDescriptor("_0_RTT_Protected", "omnetpp::cPacket")
+{
+    propertynames = nullptr;
+}
+
+_0_RTT_ProtectedDescriptor::~_0_RTT_ProtectedDescriptor()
+{
+    delete[] propertynames;
+}
+
+bool _0_RTT_ProtectedDescriptor::doesSupport(omnetpp::cObject *obj) const
+{
+    return dynamic_cast<_0_RTT_Protected *>(obj)!=nullptr;
+}
+
+const char **_0_RTT_ProtectedDescriptor::getPropertyNames() const
+{
+    if (!propertynames) {
+        static const char *names[] = {  nullptr };
+        omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
+        const char **basenames = basedesc ? basedesc->getPropertyNames() : nullptr;
+        propertynames = mergeLists(basenames, names);
+    }
+    return propertynames;
+}
+
+const char *_0_RTT_ProtectedDescriptor::getProperty(const char *propertyname) const
+{
+    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
+    return basedesc ? basedesc->getProperty(propertyname) : nullptr;
+}
+
+int _0_RTT_ProtectedDescriptor::getFieldCount() const
+{
+    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
+    return basedesc ? 1+basedesc->getFieldCount() : 1;
+}
+
+unsigned int _0_RTT_ProtectedDescriptor::getFieldTypeFlags(int field) const
+{
+    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
+    if (basedesc) {
+        if (field < basedesc->getFieldCount())
+            return basedesc->getFieldTypeFlags(field);
+        field -= basedesc->getFieldCount();
+    }
+    static unsigned int fieldTypeFlags[] = {
+        FD_ISEDITABLE,
+    };
+    return (field>=0 && field<1) ? fieldTypeFlags[field] : 0;
+}
+
+const char *_0_RTT_ProtectedDescriptor::getFieldName(int field) const
+{
+    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
+    if (basedesc) {
+        if (field < basedesc->getFieldCount())
+            return basedesc->getFieldName(field);
+        field -= basedesc->getFieldCount();
+    }
+    static const char *fieldNames[] = {
+        "someField",
+    };
+    return (field>=0 && field<1) ? fieldNames[field] : nullptr;
+}
+
+int _0_RTT_ProtectedDescriptor::findField(const char *fieldName) const
+{
+    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
+    int base = basedesc ? basedesc->getFieldCount() : 0;
+    if (fieldName[0]=='s' && strcmp(fieldName, "someField")==0) return base+0;
+    return basedesc ? basedesc->findField(fieldName) : -1;
+}
+
+const char *_0_RTT_ProtectedDescriptor::getFieldTypeString(int field) const
+{
+    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
+    if (basedesc) {
+        if (field < basedesc->getFieldCount())
+            return basedesc->getFieldTypeString(field);
+        field -= basedesc->getFieldCount();
+    }
+    static const char *fieldTypeStrings[] = {
+        "int",
+    };
+    return (field>=0 && field<1) ? fieldTypeStrings[field] : nullptr;
+}
+
+const char **_0_RTT_ProtectedDescriptor::getFieldPropertyNames(int field) const
+{
+    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
+    if (basedesc) {
+        if (field < basedesc->getFieldCount())
+            return basedesc->getFieldPropertyNames(field);
+        field -= basedesc->getFieldCount();
+    }
+    switch (field) {
+        default: return nullptr;
+    }
+}
+
+const char *_0_RTT_ProtectedDescriptor::getFieldProperty(int field, const char *propertyname) const
+{
+    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
+    if (basedesc) {
+        if (field < basedesc->getFieldCount())
+            return basedesc->getFieldProperty(field, propertyname);
+        field -= basedesc->getFieldCount();
+    }
+    switch (field) {
+        default: return nullptr;
+    }
+}
+
+int _0_RTT_ProtectedDescriptor::getFieldArraySize(void *object, int field) const
+{
+    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
+    if (basedesc) {
+        if (field < basedesc->getFieldCount())
+            return basedesc->getFieldArraySize(object, field);
+        field -= basedesc->getFieldCount();
+    }
+    _0_RTT_Protected *pp = (_0_RTT_Protected *)object; (void)pp;
+    switch (field) {
+        default: return 0;
+    }
+}
+
+const char *_0_RTT_ProtectedDescriptor::getFieldDynamicTypeString(void *object, int field, int i) const
+{
+    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
+    if (basedesc) {
+        if (field < basedesc->getFieldCount())
+            return basedesc->getFieldDynamicTypeString(object,field,i);
+        field -= basedesc->getFieldCount();
+    }
+    _0_RTT_Protected *pp = (_0_RTT_Protected *)object; (void)pp;
+    switch (field) {
+        default: return nullptr;
+    }
+}
+
+std::string _0_RTT_ProtectedDescriptor::getFieldValueAsString(void *object, int field, int i) const
+{
+    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
+    if (basedesc) {
+        if (field < basedesc->getFieldCount())
+            return basedesc->getFieldValueAsString(object,field,i);
+        field -= basedesc->getFieldCount();
+    }
+    _0_RTT_Protected *pp = (_0_RTT_Protected *)object; (void)pp;
+    switch (field) {
+        case 0: return long2string(pp->getSomeField());
+        default: return "";
+    }
+}
+
+bool _0_RTT_ProtectedDescriptor::setFieldValueAsString(void *object, int field, int i, const char *value) const
+{
+    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
+    if (basedesc) {
+        if (field < basedesc->getFieldCount())
+            return basedesc->setFieldValueAsString(object,field,i,value);
+        field -= basedesc->getFieldCount();
+    }
+    _0_RTT_Protected *pp = (_0_RTT_Protected *)object; (void)pp;
+    switch (field) {
+        case 0: pp->setSomeField(string2long(value)); return true;
+        default: return false;
+    }
+}
+
+const char *_0_RTT_ProtectedDescriptor::getFieldStructName(int field) const
+{
+    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
+    if (basedesc) {
+        if (field < basedesc->getFieldCount())
+            return basedesc->getFieldStructName(field);
+        field -= basedesc->getFieldCount();
+    }
+    switch (field) {
+        default: return nullptr;
+    };
+}
+
+void *_0_RTT_ProtectedDescriptor::getFieldStructValuePointer(void *object, int field, int i) const
+{
+    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
+    if (basedesc) {
+        if (field < basedesc->getFieldCount())
+            return basedesc->getFieldStructValuePointer(object, field, i);
+        field -= basedesc->getFieldCount();
+    }
+    _0_RTT_Protected *pp = (_0_RTT_Protected *)object; (void)pp;
+    switch (field) {
+        default: return nullptr;
+    }
+}
+
+

QUIC/Packets/0_RTT_Protected_m.h

@@ -0,0 +1,64 @@
+//
+// Generated file, do not edit! Created by nedtool 5.2 from Packets/0_RTT_Protected.msg.
+//
+
+#if defined(__clang__)
+#  pragma clang diagnostic ignored "-Wreserved-id-macro"
+#endif
+#ifndef __0_RTT_PROTECTED_M_H
+#define __0_RTT_PROTECTED_M_H
+
+#include <omnetpp.h>
+
+// nedtool version check
+#define MSGC_VERSION 0x0502
+#if (MSGC_VERSION!=OMNETPP_VERSION)
+#    error Version mismatch! Probably this file was generated by an earlier version of nedtool: 'make clean' should help.
+#endif
+
+
+
+/**
+ * Class generated from <tt>Packets/0_RTT_Protected.msg:19</tt> by nedtool.
+ * <pre>
+ * //
+ * // TODO generated message class
+ * //
+ * packet _0_RTT_Protected
+ * {
+ *     int someField;
+ * }
+ * </pre>
+ */
+class _0_RTT_Protected : public ::omnetpp::cPacket
+{
+  protected:
+    int someField;
+
+  private:
+    void copy(const _0_RTT_Protected& other);
+
+  protected:
+    // protected and unimplemented operator==(), to prevent accidental usage
+    bool operator==(const _0_RTT_Protected&);
+
+  public:
+    _0_RTT_Protected(const char *name=nullptr, short kind=0);
+    _0_RTT_Protected(const _0_RTT_Protected& other);
+    virtual ~_0_RTT_Protected();
+    _0_RTT_Protected& operator=(const _0_RTT_Protected& other);
+    virtual _0_RTT_Protected *dup() const override {return new _0_RTT_Protected(*this);}
+    virtual void parsimPack(omnetpp::cCommBuffer *b) const override;
+    virtual void parsimUnpack(omnetpp::cCommBuffer *b) override;
+
+    // field getter/setter methods
+    virtual int getSomeField() const;
+    virtual void setSomeField(int someField);
+};
+
+inline void doParsimPacking(omnetpp::cCommBuffer *b, const _0_RTT_Protected& obj) {obj.parsimPack(b);}
+inline void doParsimUnpacking(omnetpp::cCommBuffer *b, _0_RTT_Protected& obj) {obj.parsimUnpack(b);}
+
+
+#endif // ifndef __0_RTT_PROTECTED_M_H
+

QUIC/Packets/client_Cleartext.msg

@@ -0,0 +1,32 @@
+//
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Lesser General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+// 
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU Lesser General Public License for more details.
+// 
+// You should have received a copy of the GNU Lesser General Public License
+// along with this program.  If not, see http://www.gnu.org/licenses/.
+// 
+
+cplusplus {{
+#include "Frames/stream_m.h"
+#include "Frames/ack_m.h"
+#include "Frames/padding_m.h"
+}}
+class noncobject Stream;
+class noncobject Ack;
+class noncobject Padding;
+
+//
+// TODO generated message class
+//
+packet Client_Cleartext {
+	Stream stream_0;
+	Ack ack_0;
+	Padding padding_0;
+}

QUIC/Packets/client_Cleartext_m.cc

@@ -0,0 +1,500 @@
+//
+// Generated file, do not edit! Created by nedtool 5.2 from Packets/client_Cleartext.msg.
+//
+
+// Disable warnings about unused variables, empty switch stmts, etc:
+#ifdef _MSC_VER
+#  pragma warning(disable:4101)
+#  pragma warning(disable:4065)
+#endif
+
+#if defined(__clang__)
+#  pragma clang diagnostic ignored "-Wshadow"
+#  pragma clang diagnostic ignored "-Wconversion"
+#  pragma clang diagnostic ignored "-Wunused-parameter"
+#  pragma clang diagnostic ignored "-Wc++98-compat"
+#  pragma clang diagnostic ignored "-Wunreachable-code-break"
+#  pragma clang diagnostic ignored "-Wold-style-cast"
+#elif defined(__GNUC__)
+#  pragma GCC diagnostic ignored "-Wshadow"
+#  pragma GCC diagnostic ignored "-Wconversion"
+#  pragma GCC diagnostic ignored "-Wunused-parameter"
+#  pragma GCC diagnostic ignored "-Wold-style-cast"
+#  pragma GCC diagnostic ignored "-Wsuggest-attribute=noreturn"
+#  pragma GCC diagnostic ignored "-Wfloat-conversion"
+#endif
+
+#include <iostream>
+#include <sstream>
+#include "client_Cleartext_m.h"
+
+namespace omnetpp {
+
+// Template pack/unpack rules. They are declared *after* a1l type-specific pack functions for multiple reasons.
+// They are in the omnetpp namespace, to allow them to be found by argument-dependent lookup via the cCommBuffer argument
+
+// Packing/unpacking an std::vector
+template<typename T, typename A>
+void doParsimPacking(omnetpp::cCommBuffer *buffer, const std::vector<T,A>& v)
+{
+    int n = v.size();
+    doParsimPacking(buffer, n);
+    for (int i = 0; i < n; i++)
+        doParsimPacking(buffer, v[i]);
+}
+
+template<typename T, typename A>
+void doParsimUnpacking(omnetpp::cCommBuffer *buffer, std::vector<T,A>& v)
+{
+    int n;
+    doParsimUnpacking(buffer, n);
+    v.resize(n);
+    for (int i = 0; i < n; i++)
+        doParsimUnpacking(buffer, v[i]);
+}
+
+// Packing/unpacking an std::list
+template<typename T, typename A>
+void doParsimPacking(omnetpp::cCommBuffer *buffer, const std::list<T,A>& l)
+{
+    doParsimPacking(buffer, (int)l.size());
+    for (typename std::list<T,A>::const_iterator it = l.begin(); it != l.end(); ++it)
+        doParsimPacking(buffer, (T&)*it);
+}
+
+template<typename T, typename A>
+void doParsimUnpacking(omnetpp::cCommBuffer *buffer, std::list<T,A>& l)
+{
+    int n;
+    doParsimUnpacking(buffer, n);
+    for (int i=0; i<n; i++) {
+        l.push_back(T());
+        doParsimUnpacking(buffer, l.back());
+    }
+}
+
+// Packing/unpacking an std::set
+template<typename T, typename Tr, typename A>
+void doParsimPacking(omnetpp::cCommBuffer *buffer, const std::set<T,Tr,A>& s)
+{
+    doParsimPacking(buffer, (int)s.size());
+    for (typename std::set<T,Tr,A>::const_iterator it = s.begin(); it != s.end(); ++it)
+        doParsimPacking(buffer, *it);
+}
+
+template<typename T, typename Tr, typename A>
+void doParsimUnpacking(omnetpp::cCommBuffer *buffer, std::set<T,Tr,A>& s)
+{
+    int n;
+    doParsimUnpacking(buffer, n);
+    for (int i=0; i<n; i++) {
+        T x;
+        doParsimUnpacking(buffer, x);
+        s.insert(x);
+    }
+}
+
+// Packing/unpacking an std::map
+template<typename K, typename V, typename Tr, typename A>
+void doParsimPacking(omnetpp::cCommBuffer *buffer, const std::map<K,V,Tr,A>& m)
+{
+    doParsimPacking(buffer, (int)m.size());
+    for (typename std::map<K,V,Tr,A>::const_iterator it = m.begin(); it != m.end(); ++it) {
+        doParsimPacking(buffer, it->first);
+        doParsimPacking(buffer, it->second);
+    }
+}
+
+template<typename K, typename V, typename Tr, typename A>
+void doParsimUnpacking(omnetpp::cCommBuffer *buffer, std::map<K,V,Tr,A>& m)
+{
+    int n;
+    doParsimUnpacking(buffer, n);
+    for (int i=0; i<n; i++) {
+        K k; V v;
+        doParsimUnpacking(buffer, k);
+        doParsimUnpacking(buffer, v);
+        m[k] = v;
+    }
+}
+
+// Default pack/unpack function for arrays
+template<typename T>
+void doParsimArrayPacking(omnetpp::cCommBuffer *b, const T *t, int n)
+{
+    for (int i = 0; i < n; i++)
+        doParsimPacking(b, t[i]);
+}
+
+template<typename T>
+void doParsimArrayUnpacking(omnetpp::cCommBuffer *b, T *t, int n)
+{
+    for (int i = 0; i < n; i++)
+        doParsimUnpacking(b, t[i]);
+}
+
+// Default rule to prevent compiler from choosing base class' doParsimPacking() function
+template<typename T>
+void doParsimPacking(omnetpp::cCommBuffer *, const T& t)
+{
+    throw omnetpp::cRuntimeError("Parsim error: No doParsimPacking() function for type %s", omnetpp::opp_typename(typeid(t)));
+}
+
+template<typename T>
+void doParsimUnpacking(omnetpp::cCommBuffer *, T& t)
+{
+    throw omnetpp::cRuntimeError("Parsim error: No doParsimUnpacking() function for type %s", omnetpp::opp_typename(typeid(t)));
+}
+
+}  // namespace omnetpp
+
+
+// forward
+template<typename T, typename A>
+std::ostream& operator<<(std::ostream& out, const std::vector<T,A>& vec);
+
+// Template rule which fires if a struct or class doesn't have operator<<
+template<typename T>
+inline std::ostream& operator<<(std::ostream& out,const T&) {return out;}
+
+// operator<< for std::vector<T>
+template<typename T, typename A>
+inline std::ostream& operator<<(std::ostream& out, const std::vector<T,A>& vec)
+{
+    out.put('{');
+    for(typename std::vector<T,A>::const_iterator it = vec.begin(); it != vec.end(); ++it)
+    {
+        if (it != vec.begin()) {
+            out.put(','); out.put(' ');
+        }
+        out << *it;
+    }
+    out.put('}');
+    
+    char buf[32];
+    sprintf(buf, " (size=%u)", (unsigned int)vec.size());
+    out.write(buf, strlen(buf));
+    return out;
+}
+
+Register_Class(Client_Cleartext)
+
+Client_Cleartext::Client_Cleartext(const char *name, short kind) : ::omnetpp::cPacket(name,kind)
+{
+}
+
+Client_Cleartext::Client_Cleartext(const Client_Cleartext& other) : ::omnetpp::cPacket(other)
+{
+    copy(other);
+}
+
+Client_Cleartext::~Client_Cleartext()
+{
+}
+
+Client_Cleartext& Client_Cleartext::operator=(const Client_Cleartext& other)
+{
+    if (this==&other) return *this;
+    ::omnetpp::cPacket::operator=(other);
+    copy(other);
+    return *this;
+}
+
+void Client_Cleartext::copy(const Client_Cleartext& other)
+{
+    this->stream_0 = other.stream_0;
+    this->ack_0 = other.ack_0;
+    this->padding_0 = other.padding_0;
+}
+
+void Client_Cleartext::parsimPack(omnetpp::cCommBuffer *b) const
+{
+    ::omnetpp::cPacket::parsimPack(b);
+    doParsimPacking(b,this->stream_0);
+    doParsimPacking(b,this->ack_0);
+    doParsimPacking(b,this->padding_0);
+}
+
+void Client_Cleartext::parsimUnpack(omnetpp::cCommBuffer *b)
+{
+    ::omnetpp::cPacket::parsimUnpack(b);
+    doParsimUnpacking(b,this->stream_0);
+    doParsimUnpacking(b,this->ack_0);
+    doParsimUnpacking(b,this->padding_0);
+}
+
+Stream& Client_Cleartext::getStream_0()
+{
+    return this->stream_0;
+}
+
+void Client_Cleartext::setStream_0(const Stream& stream_0)
+{
+    this->stream_0 = stream_0;
+}
+
+Ack& Client_Cleartext::getAck_0()
+{
+    return this->ack_0;
+}
+
+void Client_Cleartext::setAck_0(const Ack& ack_0)
+{
+    this->ack_0 = ack_0;
+}
+
+Padding& Client_Cleartext::getPadding_0()
+{
+    return this->padding_0;
+}
+
+void Client_Cleartext::setPadding_0(const Padding& padding_0)
+{
+    this->padding_0 = padding_0;
+}
+
+class Client_CleartextDescriptor : public omnetpp::cClassDescriptor
+{
+  private:
+    mutable const char **propertynames;
+  public:
+    Client_CleartextDescriptor();
+    virtual ~Client_CleartextDescriptor();
+
+    virtual bool doesSupport(omnetpp::cObject *obj) const override;
+    virtual const char **getPropertyNames() const override;
+    virtual const char *getProperty(const char *propertyname) const override;
+    virtual int getFieldCount() const override;
+    virtual const char *getFieldName(int field) const override;
+    virtual int findField(const char *fieldName) const override;
+    virtual unsigned int getFieldTypeFlags(int field) const override;
+    virtual const char *getFieldTypeString(int field) const override;
+    virtual const char **getFieldPropertyNames(int field) const override;
+    virtual const char *getFieldProperty(int field, const char *propertyname) const override;
+    virtual int getFieldArraySize(void *object, int field) const override;
+
+    virtual const char *getFieldDynamicTypeString(void *object, int field, int i) const override;
+    virtual std::string getFieldValueAsString(void *object, int field, int i) const override;
+    virtual bool setFieldValueAsString(void *object, int field, int i, const char *value) const override;
+
+    virtual const char *getFieldStructName(int field) const override;
+    virtual void *getFieldStructValuePointer(void *object, int field, int i) const override;
+};
+
+Register_ClassDescriptor(Client_CleartextDescriptor)
+
+Client_CleartextDescriptor::Client_CleartextDescriptor() : omnetpp::cClassDescriptor("Client_Cleartext", "omnetpp::cPacket")
+{
+    propertynames = nullptr;
+}
+
+Client_CleartextDescriptor::~Client_CleartextDescriptor()
+{
+    delete[] propertynames;
+}
+
+bool Client_CleartextDescriptor::doesSupport(omnetpp::cObject *obj) const
+{
+    return dynamic_cast<Client_Cleartext *>(obj)!=nullptr;
+}
+
+const char **Client_CleartextDescriptor::getPropertyNames() const
+{
+    if (!propertynames) {
+        static const char *names[] = {  nullptr };
+        omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
+        const char **basenames = basedesc ? basedesc->getPropertyNames() : nullptr;
+        propertynames = mergeLists(basenames, names);
+    }
+    return propertynames;
+}
+
+const char *Client_CleartextDescriptor::getProperty(const char *propertyname) const
+{
+    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
+    return basedesc ? basedesc->getProperty(propertyname) : nullptr;
+}
+
+int Client_CleartextDescriptor::getFieldCount() const
+{
+    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
+    return basedesc ? 3+basedesc->getFieldCount() : 3;
+}
+
+unsigned int Client_CleartextDescriptor::getFieldTypeFlags(int field) const
+{
+    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
+    if (basedesc) {
+        if (field < basedesc->getFieldCount())
+            return basedesc->getFieldTypeFlags(field);
+        field -= basedesc->getFieldCount();
+    }
+    static unsigned int fieldTypeFlags[] = {
+        FD_ISCOMPOUND,
+        FD_ISCOMPOUND,
+        FD_ISCOMPOUND,
+    };
+    return (field>=0 && field<3) ? fieldTypeFlags[field] : 0;
+}
+
+const char *Client_CleartextDescriptor::getFieldName(int field) const
+{
+    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
+    if (basedesc) {
+        if (field < basedesc->getFieldCount())
+            return basedesc->getFieldName(field);
+        field -= basedesc->getFieldCount();
+    }
+    static const char *fieldNames[] = {
+        "stream_0",
+        "ack_0",
+        "padding_0",
+    };
+    return (field>=0 && field<3) ? fieldNames[field] : nullptr;
+}
+
+int Client_CleartextDescriptor::findField(const char *fieldName) const
+{
+    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
+    int base = basedesc ? basedesc->getFieldCount() : 0;
+    if (fieldName[0]=='s' && strcmp(fieldName, "stream_0")==0) return base+0;
+    if (fieldName[0]=='a' && strcmp(fieldName, "ack_0")==0) return base+1;
+    if (fieldName[0]=='p' && strcmp(fieldName, "padding_0")==0) return base+2;
+    return basedesc ? basedesc->findField(fieldName) : -1;
+}
+
+const char *Client_CleartextDescriptor::getFieldTypeString(int field) const
+{
+    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
+    if (basedesc) {
+        if (field < basedesc->getFieldCount())
+            return basedesc->getFieldTypeString(field);
+        field -= basedesc->getFieldCount();
+    }
+    static const char *fieldTypeStrings[] = {
+        "Stream",
+        "Ack",
+        "Padding",
+    };
+    return (field>=0 && field<3) ? fieldTypeStrings[field] : nullptr;
+}
+
+const char **Client_CleartextDescriptor::getFieldPropertyNames(int field) const
+{
+    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
+    if (basedesc) {
+        if (field < basedesc->getFieldCount())
+            return basedesc->getFieldPropertyNames(field);
+        field -= basedesc->getFieldCount();
+    }
+    switch (field) {
+        default: return nullptr;
+    }
+}
+
+const char *Client_CleartextDescriptor::getFieldProperty(int field, const char *propertyname) const
+{
+    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
+    if (basedesc) {
+        if (field < basedesc->getFieldCount())
+            return basedesc->getFieldProperty(field, propertyname);
+        field -= basedesc->getFieldCount();
+    }
+    switch (field) {
+        default: return nullptr;
+    }
+}
+
+int Client_CleartextDescriptor::getFieldArraySize(void *object, int field) const
+{
+    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
+    if (basedesc) {
+        if (field < basedesc->getFieldCount())
+            return basedesc->getFieldArraySize(object, field);
+        field -= basedesc->getFieldCount();
+    }
+    Client_Cleartext *pp = (Client_Cleartext *)object; (void)pp;
+    switch (field) {
+        default: return 0;
+    }
+}
+
+const char *Client_CleartextDescriptor::getFieldDynamicTypeString(void *object, int field, int i) const
+{
+    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
+    if (basedesc) {
+        if (field < basedesc->getFieldCount())
+            return basedesc->getFieldDynamicTypeString(object,field,i);
+        field -= basedesc->getFieldCount();
+    }
+    Client_Cleartext *pp = (Client_Cleartext *)object; (void)pp;
+    switch (field) {
+        default: return nullptr;
+    }
+}
+
+std::string Client_CleartextDescriptor::getFieldValueAsString(void *object, int field, int i) const
+{
+    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
+    if (basedesc) {
+        if (field < basedesc->getFieldCount())
+            return basedesc->getFieldValueAsString(object,field,i);
+        field -= basedesc->getFieldCount();
+    }
+    Client_Cleartext *pp = (Client_Cleartext *)object; (void)pp;
+    switch (field) {
+        case 0: {std::stringstream out; out << pp->getStream_0(); return out.str();}
+        case 1: {std::stringstream out; out << pp->getAck_0(); return out.str();}
+        case 2: {std::stringstream out; out << pp->getPadding_0(); return out.str();}
+        default: return "";
+    }
+}
+
+bool Client_CleartextDescriptor::setFieldValueAsString(void *object, int field, int i, const char *value) const
+{
+    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
+    if (basedesc) {
+        if (field < basedesc->getFieldCount())
+            return basedesc->setFieldValueAsString(object,field,i,value);
+        field -= basedesc->getFieldCount();
+    }
+    Client_Cleartext *pp = (Client_Cleartext *)object; (void)pp;
+    switch (field) {
+        default: return false;
+    }
+}
+
+const char *Client_CleartextDescriptor::getFieldStructName(int field) const
+{
+    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
+    if (basedesc) {
+        if (field < basedesc->getFieldCount())
+            return basedesc->getFieldStructName(field);
+        field -= basedesc->getFieldCount();
+    }
+    switch (field) {
+        case 0: return omnetpp::opp_typename(typeid(Stream));
+        case 1: return omnetpp::opp_typename(typeid(Ack));
+        case 2: return omnetpp::opp_typename(typeid(Padding));
+        default: return nullptr;
+    };
+}
+
+void *Client_CleartextDescriptor::getFieldStructValuePointer(void *object, int field, int i) const
+{
+    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
+    if (basedesc) {
+        if (field < basedesc->getFieldCount())
+            return basedesc->getFieldStructValuePointer(object, field, i);
+        field -= basedesc->getFieldCount();
+    }
+    Client_Cleartext *pp = (Client_Cleartext *)object; (void)pp;
+    switch (field) {
+        case 0: return (void *)(&pp->getStream_0()); break;
+        case 1: return (void *)(&pp->getAck_0()); break;
+        case 2: return (void *)(&pp->getPadding_0()); break;
+        default: return nullptr;
+    }
+}
+
+

QUIC/Packets/client_Cleartext_m.h

@@ -0,0 +1,81 @@
+//
+// Generated file, do not edit! Created by nedtool 5.2 from Packets/client_Cleartext.msg.
+//
+
+#if defined(__clang__)
+#  pragma clang diagnostic ignored "-Wreserved-id-macro"
+#endif
+#ifndef __CLIENT_CLEARTEXT_M_H
+#define __CLIENT_CLEARTEXT_M_H
+
+#include <omnetpp.h>
+
+// nedtool version check
+#define MSGC_VERSION 0x0502
+#if (MSGC_VERSION!=OMNETPP_VERSION)
+#    error Version mismatch! Probably this file was generated by an earlier version of nedtool: 'make clean' should help.
+#endif
+
+
+
+// cplusplus {{
+#include "Frames/stream_m.h"
+#include "Frames/ack_m.h"
+#include "Frames/padding_m.h"
+// }}
+
+/**
+ * Class generated from <tt>Packets/client_Cleartext.msg:28</tt> by nedtool.
+ * <pre>
+ * //
+ * // TODO generated message class
+ * //
+ * packet Client_Cleartext
+ * {
+ *     Stream stream_0;
+ *     Ack ack_0;
+ *     Padding padding_0;
+ * }
+ * </pre>
+ */
+class Client_Cleartext : public ::omnetpp::cPacket
+{
+  protected:
+    Stream stream_0;
+    Ack ack_0;
+    Padding padding_0;
+
+  private:
+    void copy(const Client_Cleartext& other);
+
+  protected:
+    // protected and unimplemented operator==(), to prevent accidental usage
+    bool operator==(const Client_Cleartext&);
+
+  public:
+    Client_Cleartext(const char *name=nullptr, short kind=0);
+    Client_Cleartext(const Client_Cleartext& other);
+    virtual ~Client_Cleartext();
+    Client_Cleartext& operator=(const Client_Cleartext& other);
+    virtual Client_Cleartext *dup() const override {return new Client_Cleartext(*this);}
+    virtual void parsimPack(omnetpp::cCommBuffer *b) const override;
+    virtual void parsimUnpack(omnetpp::cCommBuffer *b) override;
+
+    // field getter/setter methods
+    virtual Stream& getStream_0();
+    virtual const Stream& getStream_0() const {return const_cast<Client_Cleartext*>(this)->getStream_0();}
+    virtual void setStream_0(const Stream& stream_0);
+    virtual Ack& getAck_0();
+    virtual const Ack& getAck_0() const {return const_cast<Client_Cleartext*>(this)->getAck_0();}
+    virtual void setAck_0(const Ack& ack_0);
+    virtual Padding& getPadding_0();
+    virtual const Padding& getPadding_0() const {return const_cast<Client_Cleartext*>(this)->getPadding_0();}
+    virtual void setPadding_0(const Padding& padding_0);
+};
+
+inline void doParsimPacking(omnetpp::cCommBuffer *b, const Client_Cleartext& obj) {obj.parsimPack(b);}
+inline void doParsimUnpacking(omnetpp::cCommBuffer *b, Client_Cleartext& obj) {obj.parsimUnpack(b);}
+
+
+#endif // ifndef __CLIENT_CLEARTEXT_M_H
+

QUIC/Packets/client_Initial.msg

@@ -0,0 +1,26 @@
+//
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Lesser General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+// 
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU Lesser General Public License for more details.
+// 
+// You should have received a copy of the GNU Lesser General Public License
+// along with this program.  If not, see http://www.gnu.org/licenses/.
+// 
+
+cplusplus {{
+#include "Frames/stream_m.h"
+}}
+class noncobject Stream;
+
+//
+// TODO generated message class
+//
+packet Client_Initial {
+    Stream stream_0;
+}

QUIC/Packets/client_Initial_m.cc

@@ -0,0 +1,460 @@
+//
+// Generated file, do not edit! Created by nedtool 5.2 from Packets/client_Initial.msg.
+//
+
+// Disable warnings about unused variables, empty switch stmts, etc:
+#ifdef _MSC_VER
+#  pragma warning(disable:4101)
+#  pragma warning(disable:4065)
+#endif
+
+#if defined(__clang__)
+#  pragma clang diagnostic ignored "-Wshadow"
+#  pragma clang diagnostic ignored "-Wconversion"
+#  pragma clang diagnostic ignored "-Wunused-parameter"
+#  pragma clang diagnostic ignored "-Wc++98-compat"
+#  pragma clang diagnostic ignored "-Wunreachable-code-break"
+#  pragma clang diagnostic ignored "-Wold-style-cast"
+#elif defined(__GNUC__)
+#  pragma GCC diagnostic ignored "-Wshadow"
+#  pragma GCC diagnostic ignored "-Wconversion"
+#  pragma GCC diagnostic ignored "-Wunused-parameter"
+#  pragma GCC diagnostic ignored "-Wold-style-cast"
+#  pragma GCC diagnostic ignored "-Wsuggest-attribute=noreturn"
+#  pragma GCC diagnostic ignored "-Wfloat-conversion"
+#endif
+
+#include <iostream>
+#include <sstream>
+#include "client_Initial_m.h"
+
+namespace omnetpp {
+
+// Template pack/unpack rules. They are declared *after* a1l type-specific pack functions for multiple reasons.
+// They are in the omnetpp namespace, to allow them to be found by argument-dependent lookup via the cCommBuffer argument
+
+// Packing/unpacking an std::vector
+template<typename T, typename A>
+void doParsimPacking(omnetpp::cCommBuffer *buffer, const std::vector<T,A>& v)
+{
+    int n = v.size();
+    doParsimPacking(buffer, n);
+    for (int i = 0; i < n; i++)
+        doParsimPacking(buffer, v[i]);
+}
+
+template<typename T, typename A>
+void doParsimUnpacking(omnetpp::cCommBuffer *buffer, std::vector<T,A>& v)
+{
+    int n;
+    doParsimUnpacking(buffer, n);
+    v.resize(n);
+    for (int i = 0; i < n; i++)
+        doParsimUnpacking(buffer, v[i]);
+}
+
+// Packing/unpacking an std::list
+template<typename T, typename A>
+void doParsimPacking(omnetpp::cCommBuffer *buffer, const std::list<T,A>& l)
+{
+    doParsimPacking(buffer, (int)l.size());
+    for (typename std::list<T,A>::const_iterator it = l.begin(); it != l.end(); ++it)
+        doParsimPacking(buffer, (T&)*it);
+}
+
+template<typename T, typename A>
+void doParsimUnpacking(omnetpp::cCommBuffer *buffer, std::list<T,A>& l)
+{
+    int n;
+    doParsimUnpacking(buffer, n);
+    for (int i=0; i<n; i++) {
+        l.push_back(T());
+        doParsimUnpacking(buffer, l.back());
+    }
+}
+
+// Packing/unpacking an std::set
+template<typename T, typename Tr, typename A>
+void doParsimPacking(omnetpp::cCommBuffer *buffer, const std::set<T,Tr,A>& s)
+{
+    doParsimPacking(buffer, (int)s.size());
+    for (typename std::set<T,Tr,A>::const_iterator it = s.begin(); it != s.end(); ++it)
+        doParsimPacking(buffer, *it);
+}
+
+template<typename T, typename Tr, typename A>
+void doParsimUnpacking(omnetpp::cCommBuffer *buffer, std::set<T,Tr,A>& s)
+{
+    int n;
+    doParsimUnpacking(buffer, n);
+    for (int i=0; i<n; i++) {
+        T x;
+        doParsimUnpacking(buffer, x);
+        s.insert(x);
+    }
+}
+
+// Packing/unpacking an std::map
+template<typename K, typename V, typename Tr, typename A>
+void doParsimPacking(omnetpp::cCommBuffer *buffer, const std::map<K,V,Tr,A>& m)
+{
+    doParsimPacking(buffer, (int)m.size());
+    for (typename std::map<K,V,Tr,A>::const_iterator it = m.begin(); it != m.end(); ++it) {
+        doParsimPacking(buffer, it->first);
+        doParsimPacking(buffer, it->second);
+    }
+}
+
+template<typename K, typename V, typename Tr, typename A>
+void doParsimUnpacking(omnetpp::cCommBuffer *buffer, std::map<K,V,Tr,A>& m)
+{
+    int n;
+    doParsimUnpacking(buffer, n);
+    for (int i=0; i<n; i++) {
+        K k; V v;
+        doParsimUnpacking(buffer, k);
+        doParsimUnpacking(buffer, v);
+        m[k] = v;
+    }
+}
+
+// Default pack/unpack function for arrays
+template<typename T>
+void doParsimArrayPacking(omnetpp::cCommBuffer *b, const T *t, int n)
+{
+    for (int i = 0; i < n; i++)
+        doParsimPacking(b, t[i]);
+}
+
+template<typename T>
+void doParsimArrayUnpacking(omnetpp::cCommBuffer *b, T *t, int n)
+{
+    for (int i = 0; i < n; i++)
+        doParsimUnpacking(b, t[i]);
+}
+
+// Default rule to prevent compiler from choosing base class' doParsimPacking() function
+template<typename T>
+void doParsimPacking(omnetpp::cCommBuffer *, const T& t)
+{
+    throw omnetpp::cRuntimeError("Parsim error: No doParsimPacking() function for type %s", omnetpp::opp_typename(typeid(t)));
+}
+
+template<typename T>
+void doParsimUnpacking(omnetpp::cCommBuffer *, T& t)
+{
+    throw omnetpp::cRuntimeError("Parsim error: No doParsimUnpacking() function for type %s", omnetpp::opp_typename(typeid(t)));
+}
+
+}  // namespace omnetpp
+
+
+// forward
+template<typename T, typename A>
+std::ostream& operator<<(std::ostream& out, const std::vector<T,A>& vec);
+
+// Template rule which fires if a struct or class doesn't have operator<<
+template<typename T>
+inline std::ostream& operator<<(std::ostream& out,const T&) {return out;}
+
+// operator<< for std::vector<T>
+template<typename T, typename A>
+inline std::ostream& operator<<(std::ostream& out, const std::vector<T,A>& vec)
+{
+    out.put('{');
+    for(typename std::vector<T,A>::const_iterator it = vec.begin(); it != vec.end(); ++it)
+    {
+        if (it != vec.begin()) {
+            out.put(','); out.put(' ');
+        }
+        out << *it;
+    }
+    out.put('}');
+    
+    char buf[32];
+    sprintf(buf, " (size=%u)", (unsigned int)vec.size());
+    out.write(buf, strlen(buf));
+    return out;
+}
+
+Register_Class(Client_Initial)
+
+Client_Initial::Client_Initial(const char *name, short kind) : ::omnetpp::cPacket(name,kind)
+{
+}
+
+Client_Initial::Client_Initial(const Client_Initial& other) : ::omnetpp::cPacket(other)
+{
+    copy(other);
+}
+
+Client_Initial::~Client_Initial()
+{
+}
+
+Client_Initial& Client_Initial::operator=(const Client_Initial& other)
+{
+    if (this==&other) return *this;
+    ::omnetpp::cPacket::operator=(other);
+    copy(other);
+    return *this;
+}
+
+void Client_Initial::copy(const Client_Initial& other)
+{
+    this->stream_0 = other.stream_0;
+}
+
+void Client_Initial::parsimPack(omnetpp::cCommBuffer *b) const
+{
+    ::omnetpp::cPacket::parsimPack(b);
+    doParsimPacking(b,this->stream_0);
+}
+
+void Client_Initial::parsimUnpack(omnetpp::cCommBuffer *b)
+{
+    ::omnetpp::cPacket::parsimUnpack(b);
+    doParsimUnpacking(b,this->stream_0);
+}
+
+Stream& Client_Initial::getStream_0()
+{
+    return this->stream_0;
+}
+
+void Client_Initial::setStream_0(const Stream& stream_0)
+{
+    this->stream_0 = stream_0;
+}
+
+class Client_InitialDescriptor : public omnetpp::cClassDescriptor
+{
+  private:
+    mutable const char **propertynames;
+  public:
+    Client_InitialDescriptor();
+    virtual ~Client_InitialDescriptor();
+
+    virtual bool doesSupport(omnetpp::cObject *obj) const override;
+    virtual const char **getPropertyNames() const override;
+    virtual const char *getProperty(const char *propertyname) const override;
+    virtual int getFieldCount() const override;
+    virtual const char *getFieldName(int field) const override;
+    virtual int findField(const char *fieldName) const override;
+    virtual unsigned int getFieldTypeFlags(int field) const override;
+    virtual const char *getFieldTypeString(int field) const override;
+    virtual const char **getFieldPropertyNames(int field) const override;
+    virtual const char *getFieldProperty(int field, const char *propertyname) const override;
+    virtual int getFieldArraySize(void *object, int field) const override;
+
+    virtual const char *getFieldDynamicTypeString(void *object, int field, int i) const override;
+    virtual std::string getFieldValueAsString(void *object, int field, int i) const override;
+    virtual bool setFieldValueAsString(void *object, int field, int i, const char *value) const override;
+
+    virtual const char *getFieldStructName(int field) const override;
+    virtual void *getFieldStructValuePointer(void *object, int field, int i) const override;
+};
+
+Register_ClassDescriptor(Client_InitialDescriptor)
+
+Client_InitialDescriptor::Client_InitialDescriptor() : omnetpp::cClassDescriptor("Client_Initial", "omnetpp::cPacket")
+{
+    propertynames = nullptr;
+}
+
+Client_InitialDescriptor::~Client_InitialDescriptor()
+{
+    delete[] propertynames;
+}
+
+bool Client_InitialDescriptor::doesSupport(omnetpp::cObject *obj) const
+{
+    return dynamic_cast<Client_Initial *>(obj)!=nullptr;
+}
+
+const char **Client_InitialDescriptor::getPropertyNames() const
+{
+    if (!propertynames) {
+        static const char *names[] = {  nullptr };
+        omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
+        const char **basenames = basedesc ? basedesc->getPropertyNames() : nullptr;
+        propertynames = mergeLists(basenames, names);
+    }
+    return propertynames;
+}
+
+const char *Client_InitialDescriptor::getProperty(const char *propertyname) const
+{
+    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
+    return basedesc ? basedesc->getProperty(propertyname) : nullptr;
+}
+
+int Client_InitialDescriptor::getFieldCount() const
+{
+    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
+    return basedesc ? 1+basedesc->getFieldCount() : 1;
+}
+
+unsigned int Client_InitialDescriptor::getFieldTypeFlags(int field) const
+{
+    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
+    if (basedesc) {
+        if (field < basedesc->getFieldCount())
+            return basedesc->getFieldTypeFlags(field);
+        field -= basedesc->getFieldCount();
+    }
+    static unsigned int fieldTypeFlags[] = {
+        FD_ISCOMPOUND,
+    };
+    return (field>=0 && field<1) ? fieldTypeFlags[field] : 0;
+}
+
+const char *Client_InitialDescriptor::getFieldName(int field) const
+{
+    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
+    if (basedesc) {
+        if (field < basedesc->getFieldCount())
+            return basedesc->getFieldName(field);
+        field -= basedesc->getFieldCount();
+    }
+    static const char *fieldNames[] = {
+        "stream_0",
+    };
+    return (field>=0 && field<1) ? fieldNames[field] : nullptr;
+}
+
+int Client_InitialDescriptor::findField(const char *fieldName) const
+{
+    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
+    int base = basedesc ? basedesc->getFieldCount() : 0;
+    if (fieldName[0]=='s' && strcmp(fieldName, "stream_0")==0) return base+0;
+    return basedesc ? basedesc->findField(fieldName) : -1;
+}
+
+const char *Client_InitialDescriptor::getFieldTypeString(int field) const
+{
+    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
+    if (basedesc) {
+        if (field < basedesc->getFieldCount())
+            return basedesc->getFieldTypeString(field);
+        field -= basedesc->getFieldCount();
+    }
+    static const char *fieldTypeStrings[] = {
+        "Stream",
+    };
+    return (field>=0 && field<1) ? fieldTypeStrings[field] : nullptr;
+}
+
+const char **Client_InitialDescriptor::getFieldPropertyNames(int field) const
+{
+    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
+    if (basedesc) {
+        if (field < basedesc->getFieldCount())
+            return basedesc->getFieldPropertyNames(field);
+        field -= basedesc->getFieldCount();
+    }
+    switch (field) {
+        default: return nullptr;
+    }
+}
+
+const char *Client_InitialDescriptor::getFieldProperty(int field, const char *propertyname) const
+{
+    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
+    if (basedesc) {
+        if (field < basedesc->getFieldCount())
+            return basedesc->getFieldProperty(field, propertyname);
+        field -= basedesc->getFieldCount();
+    }
+    switch (field) {
+        default: return nullptr;
+    }
+}
+
+int Client_InitialDescriptor::getFieldArraySize(void *object, int field) const
+{
+    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
+    if (basedesc) {
+        if (field < basedesc->getFieldCount())
+            return basedesc->getFieldArraySize(object, field);
+        field -= basedesc->getFieldCount();
+    }
+    Client_Initial *pp = (Client_Initial *)object; (void)pp;
+    switch (field) {
+        default: return 0;
+    }
+}
+
+const char *Client_InitialDescriptor::getFieldDynamicTypeString(void *object, int field, int i) const
+{
+    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
+    if (basedesc) {
+        if (field < basedesc->getFieldCount())
+            return basedesc->getFieldDynamicTypeString(object,field,i);
+        field -= basedesc->getFieldCount();
+    }
+    Client_Initial *pp = (Client_Initial *)object; (void)pp;
+    switch (field) {
+        default: return nullptr;
+    }
+}
+
+std::string Client_InitialDescriptor::getFieldValueAsString(void *object, int field, int i) const
+{
+    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
+    if (basedesc) {
+        if (field < basedesc->getFieldCount())
+            return basedesc->getFieldValueAsString(object,field,i);
+        field -= basedesc->getFieldCount();
+    }
+    Client_Initial *pp = (Client_Initial *)object; (void)pp;
+    switch (field) {
+        case 0: {std::stringstream out; out << pp->getStream_0(); return out.str();}
+        default: return "";
+    }
+}
+
+bool Client_InitialDescriptor::setFieldValueAsString(void *object, int field, int i, const char *value) const
+{
+    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
+    if (basedesc) {
+        if (field < basedesc->getFieldCount())
+            return basedesc->setFieldValueAsString(object,field,i,value);
+        field -= basedesc->getFieldCount();
+    }
+    Client_Initial *pp = (Client_Initial *)object; (void)pp;
+    switch (field) {
+        default: return false;
+    }
+}
+
+const char *Client_InitialDescriptor::getFieldStructName(int field) const
+{
+    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
+    if (basedesc) {
+        if (field < basedesc->getFieldCount())
+            return basedesc->getFieldStructName(field);
+        field -= basedesc->getFieldCount();
+    }
+    switch (field) {
+        case 0: return omnetpp::opp_typename(typeid(Stream));
+        default: return nullptr;
+    };
+}
+
+void *Client_InitialDescriptor::getFieldStructValuePointer(void *object, int field, int i) const
+{
+    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
+    if (basedesc) {
+        if (field < basedesc->getFieldCount())
+            return basedesc->getFieldStructValuePointer(object, field, i);
+        field -= basedesc->getFieldCount();
+    }
+    Client_Initial *pp = (Client_Initial *)object; (void)pp;
+    switch (field) {
+        case 0: return (void *)(&pp->getStream_0()); break;
+        default: return nullptr;
+    }
+}
+
+

QUIC/Packets/client_Initial_m.h

@@ -0,0 +1,69 @@
+//
+// Generated file, do not edit! Created by nedtool 5.2 from Packets/client_Initial.msg.
+//
+
+#if defined(__clang__)
+#  pragma clang diagnostic ignored "-Wreserved-id-macro"
+#endif
+#ifndef __CLIENT_INITIAL_M_H
+#define __CLIENT_INITIAL_M_H
+
+#include <omnetpp.h>
+
+// nedtool version check
+#define MSGC_VERSION 0x0502
+#if (MSGC_VERSION!=OMNETPP_VERSION)
+#    error Version mismatch! Probably this file was generated by an earlier version of nedtool: 'make clean' should help.
+#endif
+
+
+
+// cplusplus {{
+#include "Frames/stream_m.h"
+// }}
+
+/**
+ * Class generated from <tt>Packets/client_Initial.msg:24</tt> by nedtool.
+ * <pre>
+ * //
+ * // TODO generated message class
+ * //
+ * packet Client_Initial
+ * {
+ *     Stream stream_0;
+ * }
+ * </pre>
+ */
+class Client_Initial : public ::omnetpp::cPacket
+{
+  protected:
+    Stream stream_0;
+
+  private:
+    void copy(const Client_Initial& other);
+
+  protected:
+    // protected and unimplemented operator==(), to prevent accidental usage
+    bool operator==(const Client_Initial&);
+
+  public:
+    Client_Initial(const char *name=nullptr, short kind=0);
+    Client_Initial(const Client_Initial& other);
+    virtual ~Client_Initial();
+    Client_Initial& operator=(const Client_Initial& other);
+    virtual Client_Initial *dup() const override {return new Client_Initial(*this);}
+    virtual void parsimPack(omnetpp::cCommBuffer *b) const override;
+    virtual void parsimUnpack(omnetpp::cCommBuffer *b) override;
+
+    // field getter/setter methods
+    virtual Stream& getStream_0();
+    virtual const Stream& getStream_0() const {return const_cast<Client_Initial*>(this)->getStream_0();}
+    virtual void setStream_0(const Stream& stream_0);
+};
+
+inline void doParsimPacking(omnetpp::cCommBuffer *b, const Client_Initial& obj) {obj.parsimPack(b);}
+inline void doParsimUnpacking(omnetpp::cCommBuffer *b, Client_Initial& obj) {obj.parsimUnpack(b);}
+
+
+#endif // ifndef __CLIENT_INITIAL_M_H
+

QUIC/Packets/server_Cleartext.msg

@@ -0,0 +1,32 @@
+//
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Lesser General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+// 
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU Lesser General Public License for more details.
+// 
+// You should have received a copy of the GNU Lesser General Public License
+// along with this program.  If not, see http://www.gnu.org/licenses/.
+// 
+
+cplusplus {{
+#include "Frames/stream_m.h"
+#include "Frames/ack_m.h"
+#include "Frames/padding_m.h"
+}}
+class noncobject Stream;
+class noncobject Ack;
+class noncobject Padding;
+
+//
+// TODO generated message class
+//
+packet Server_Cleartext {
+	Stream stream_0;
+	Ack ack_0;
+	Padding padding_0;
+}

QUIC/Packets/server_Cleartext_m.cc

@@ -0,0 +1,500 @@
+//
+// Generated file, do not edit! Created by nedtool 5.2 from Packets/server_Cleartext.msg.
+//
+
+// Disable warnings about unused variables, empty switch stmts, etc:
+#ifdef _MSC_VER
+#  pragma warning(disable:4101)
+#  pragma warning(disable:4065)
+#endif
+
+#if defined(__clang__)
+#  pragma clang diagnostic ignored "-Wshadow"
+#  pragma clang diagnostic ignored "-Wconversion"
+#  pragma clang diagnostic ignored "-Wunused-parameter"
+#  pragma clang diagnostic ignored "-Wc++98-compat"
+#  pragma clang diagnostic ignored "-Wunreachable-code-break"
+#  pragma clang diagnostic ignored "-Wold-style-cast"
+#elif defined(__GNUC__)
+#  pragma GCC diagnostic ignored "-Wshadow"
+#  pragma GCC diagnostic ignored "-Wconversion"
+#  pragma GCC diagnostic ignored "-Wunused-parameter"
+#  pragma GCC diagnostic ignored "-Wold-style-cast"
+#  pragma GCC diagnostic ignored "-Wsuggest-attribute=noreturn"
+#  pragma GCC diagnostic ignored "-Wfloat-conversion"
+#endif
+
+#include <iostream>
+#include <sstream>
+#include "server_Cleartext_m.h"
+
+namespace omnetpp {
+
+// Template pack/unpack rules. They are declared *after* a1l type-specific pack functions for multiple reasons.
+// They are in the omnetpp namespace, to allow them to be found by argument-dependent lookup via the cCommBuffer argument
+
+// Packing/unpacking an std::vector
+template<typename T, typename A>
+void doParsimPacking(omnetpp::cCommBuffer *buffer, const std::vector<T,A>& v)
+{
+    int n = v.size();
+    doParsimPacking(buffer, n);
+    for (int i = 0; i < n; i++)
+        doParsimPacking(buffer, v[i]);
+}
+
+template<typename T, typename A>
+void doParsimUnpacking(omnetpp::cCommBuffer *buffer, std::vector<T,A>& v)
+{
+    int n;
+    doParsimUnpacking(buffer, n);
+    v.resize(n);
+    for (int i = 0; i < n; i++)
+        doParsimUnpacking(buffer, v[i]);
+}
+
+// Packing/unpacking an std::list
+template<typename T, typename A>
+void doParsimPacking(omnetpp::cCommBuffer *buffer, const std::list<T,A>& l)
+{
+    doParsimPacking(buffer, (int)l.size());
+    for (typename std::list<T,A>::const_iterator it = l.begin(); it != l.end(); ++it)
+        doParsimPacking(buffer, (T&)*it);
+}
+
+template<typename T, typename A>
+void doParsimUnpacking(omnetpp::cCommBuffer *buffer, std::list<T,A>& l)
+{
+    int n;
+    doParsimUnpacking(buffer, n);
+    for (int i=0; i<n; i++) {
+        l.push_back(T());
+        doParsimUnpacking(buffer, l.back());
+    }
+}
+
+// Packing/unpacking an std::set
+template<typename T, typename Tr, typename A>
+void doParsimPacking(omnetpp::cCommBuffer *buffer, const std::set<T,Tr,A>& s)
+{
+    doParsimPacking(buffer, (int)s.size());
+    for (typename std::set<T,Tr,A>::const_iterator it = s.begin(); it != s.end(); ++it)
+        doParsimPacking(buffer, *it);
+}
+
+template<typename T, typename Tr, typename A>
+void doParsimUnpacking(omnetpp::cCommBuffer *buffer, std::set<T,Tr,A>& s)
+{
+    int n;
+    doParsimUnpacking(buffer, n);
+    for (int i=0; i<n; i++) {
+        T x;
+        doParsimUnpacking(buffer, x);
+        s.insert(x);
+    }
+}
+
+// Packing/unpacking an std::map
+template<typename K, typename V, typename Tr, typename A>
+void doParsimPacking(omnetpp::cCommBuffer *buffer, const std::map<K,V,Tr,A>& m)
+{
+    doParsimPacking(buffer, (int)m.size());
+    for (typename std::map<K,V,Tr,A>::const_iterator it = m.begin(); it != m.end(); ++it) {
+        doParsimPacking(buffer, it->first);
+        doParsimPacking(buffer, it->second);
+    }
+}
+
+template<typename K, typename V, typename Tr, typename A>
+void doParsimUnpacking(omnetpp::cCommBuffer *buffer, std::map<K,V,Tr,A>& m)
+{
+    int n;
+    doParsimUnpacking(buffer, n);
+    for (int i=0; i<n; i++) {
+        K k; V v;
+        doParsimUnpacking(buffer, k);
+        doParsimUnpacking(buffer, v);
+        m[k] = v;
+    }
+}
+
+// Default pack/unpack function for arrays
+template<typename T>
+void doParsimArrayPacking(omnetpp::cCommBuffer *b, const T *t, int n)
+{
+    for (int i = 0; i < n; i++)
+        doParsimPacking(b, t[i]);
+}
+
+template<typename T>
+void doParsimArrayUnpacking(omnetpp::cCommBuffer *b, T *t, int n)
+{
+    for (int i = 0; i < n; i++)
+        doParsimUnpacking(b, t[i]);
+}
+
+// Default rule to prevent compiler from choosing base class' doParsimPacking() function
+template<typename T>
+void doParsimPacking(omnetpp::cCommBuffer *, const T& t)
+{
+    throw omnetpp::cRuntimeError("Parsim error: No doParsimPacking() function for type %s", omnetpp::opp_typename(typeid(t)));
+}
+
+template<typename T>
+void doParsimUnpacking(omnetpp::cCommBuffer *, T& t)
+{
+    throw omnetpp::cRuntimeError("Parsim error: No doParsimUnpacking() function for type %s", omnetpp::opp_typename(typeid(t)));
+}
+
+}  // namespace omnetpp
+
+
+// forward
+template<typename T, typename A>
+std::ostream& operator<<(std::ostream& out, const std::vector<T,A>& vec);
+
+// Template rule which fires if a struct or class doesn't have operator<<
+template<typename T>
+inline std::ostream& operator<<(std::ostream& out,const T&) {return out;}
+
+// operator<< for std::vector<T>
+template<typename T, typename A>
+inline std::ostream& operator<<(std::ostream& out, const std::vector<T,A>& vec)
+{
+    out.put('{');
+    for(typename std::vector<T,A>::const_iterator it = vec.begin(); it != vec.end(); ++it)
+    {
+        if (it != vec.begin()) {
+            out.put(','); out.put(' ');
+        }
+        out << *it;
+    }
+    out.put('}');
+    
+    char buf[32];
+    sprintf(buf, " (size=%u)", (unsigned int)vec.size());
+    out.write(buf, strlen(buf));
+    return out;
+}
+
+Register_Class(Server_Cleartext)
+
+Server_Cleartext::Server_Cleartext(const char *name, short kind) : ::omnetpp::cPacket(name,kind)
+{
+}
+
+Server_Cleartext::Server_Cleartext(const Server_Cleartext& other) : ::omnetpp::cPacket(other)
+{
+    copy(other);
+}
+
+Server_Cleartext::~Server_Cleartext()
+{
+}
+
+Server_Cleartext& Server_Cleartext::operator=(const Server_Cleartext& other)
+{
+    if (this==&other) return *this;
+    ::omnetpp::cPacket::operator=(other);
+    copy(other);
+    return *this;
+}
+
+void Server_Cleartext::copy(const Server_Cleartext& other)
+{
+    this->stream_0 = other.stream_0;
+    this->ack_0 = other.ack_0;
+    this->padding_0 = other.padding_0;
+}
+
+void Server_Cleartext::parsimPack(omnetpp::cCommBuffer *b) const
+{
+    ::omnetpp::cPacket::parsimPack(b);
+    doParsimPacking(b,this->stream_0);
+    doParsimPacking(b,this->ack_0);
+    doParsimPacking(b,this->padding_0);
+}
+
+void Server_Cleartext::parsimUnpack(omnetpp::cCommBuffer *b)
+{
+    ::omnetpp::cPacket::parsimUnpack(b);
+    doParsimUnpacking(b,this->stream_0);
+    doParsimUnpacking(b,this->ack_0);
+    doParsimUnpacking(b,this->padding_0);
+}
+
+Stream& Server_Cleartext::getStream_0()
+{
+    return this->stream_0;
+}
+
+void Server_Cleartext::setStream_0(const Stream& stream_0)
+{
+    this->stream_0 = stream_0;
+}
+
+Ack& Server_Cleartext::getAck_0()
+{
+    return this->ack_0;
+}
+
+void Server_Cleartext::setAck_0(const Ack& ack_0)
+{
+    this->ack_0 = ack_0;
+}
+
+Padding& Server_Cleartext::getPadding_0()
+{
+    return this->padding_0;
+}
+
+void Server_Cleartext::setPadding_0(const Padding& padding_0)
+{
+    this->padding_0 = padding_0;
+}
+
+class Server_CleartextDescriptor : public omnetpp::cClassDescriptor
+{
+  private:
+    mutable const char **propertynames;
+  public:
+    Server_CleartextDescriptor();
+    virtual ~Server_CleartextDescriptor();
+
+    virtual bool doesSupport(omnetpp::cObject *obj) const override;
+    virtual const char **getPropertyNames() const override;
+    virtual const char *getProperty(const char *propertyname) const override;
+    virtual int getFieldCount() const override;
+    virtual const char *getFieldName(int field) const override;
+    virtual int findField(const char *fieldName) const override;
+    virtual unsigned int getFieldTypeFlags(int field) const override;
+    virtual const char *getFieldTypeString(int field) const override;
+    virtual const char **getFieldPropertyNames(int field) const override;
+    virtual const char *getFieldProperty(int field, const char *propertyname) const override;
+    virtual int getFieldArraySize(void *object, int field) const override;
+
+    virtual const char *getFieldDynamicTypeString(void *object, int field, int i) const override;
+    virtual std::string getFieldValueAsString(void *object, int field, int i) const override;
+    virtual bool setFieldValueAsString(void *object, int field, int i, const char *value) const override;
+
+    virtual const char *getFieldStructName(int field) const override;
+    virtual void *getFieldStructValuePointer(void *object, int field, int i) const override;
+};
+
+Register_ClassDescriptor(Server_CleartextDescriptor)
+
+Server_CleartextDescriptor::Server_CleartextDescriptor() : omnetpp::cClassDescriptor("Server_Cleartext", "omnetpp::cPacket")
+{
+    propertynames = nullptr;
+}
+
+Server_CleartextDescriptor::~Server_CleartextDescriptor()
+{
+    delete[] propertynames;
+}
+
+bool Server_CleartextDescriptor::doesSupport(omnetpp::cObject *obj) const
+{
+    return dynamic_cast<Server_Cleartext *>(obj)!=nullptr;
+}
+
+const char **Server_CleartextDescriptor::getPropertyNames() const
+{
+    if (!propertynames) {
+        static const char *names[] = {  nullptr };
+        omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
+        const char **basenames = basedesc ? basedesc->getPropertyNames() : nullptr;
+        propertynames = mergeLists(basenames, names);
+    }
+    return propertynames;
+}
+
+const char *Server_CleartextDescriptor::getProperty(const char *propertyname) const
+{
+    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
+    return basedesc ? basedesc->getProperty(propertyname) : nullptr;
+}
+
+int Server_CleartextDescriptor::getFieldCount() const
+{
+    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
+    return basedesc ? 3+basedesc->getFieldCount() : 3;
+}
+
+unsigned int Server_CleartextDescriptor::getFieldTypeFlags(int field) const
+{
+    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
+    if (basedesc) {
+        if (field < basedesc->getFieldCount())
+            return basedesc->getFieldTypeFlags(field);
+        field -= basedesc->getFieldCount();
+    }
+    static unsigned int fieldTypeFlags[] = {
+        FD_ISCOMPOUND,
+        FD_ISCOMPOUND,
+        FD_ISCOMPOUND,
+    };
+    return (field>=0 && field<3) ? fieldTypeFlags[field] : 0;
+}
+
+const char *Server_CleartextDescriptor::getFieldName(int field) const
+{
+    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
+    if (basedesc) {
+        if (field < basedesc->getFieldCount())
+            return basedesc->getFieldName(field);
+        field -= basedesc->getFieldCount();
+    }
+    static const char *fieldNames[] = {
+        "stream_0",
+        "ack_0",
+        "padding_0",
+    };
+    return (field>=0 && field<3) ? fieldNames[field] : nullptr;
+}
+
+int Server_CleartextDescriptor::findField(const char *fieldName) const
+{
+    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
+    int base = basedesc ? basedesc->getFieldCount() : 0;
+    if (fieldName[0]=='s' && strcmp(fieldName, "stream_0")==0) return base+0;
+    if (fieldName[0]=='a' && strcmp(fieldName, "ack_0")==0) return base+1;
+    if (fieldName[0]=='p' && strcmp(fieldName, "padding_0")==0) return base+2;
+    return basedesc ? basedesc->findField(fieldName) : -1;
+}
+
+const char *Server_CleartextDescriptor::getFieldTypeString(int field) const
+{
+    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
+    if (basedesc) {
+        if (field < basedesc->getFieldCount())
+            return basedesc->getFieldTypeString(field);
+        field -= basedesc->getFieldCount();
+    }
+    static const char *fieldTypeStrings[] = {
+        "Stream",
+        "Ack",
+        "Padding",
+    };
+    return (field>=0 && field<3) ? fieldTypeStrings[field] : nullptr;
+}
+
+const char **Server_CleartextDescriptor::getFieldPropertyNames(int field) const
+{
+    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
+    if (basedesc) {
+        if (field < basedesc->getFieldCount())
+            return basedesc->getFieldPropertyNames(field);
+        field -= basedesc->getFieldCount();
+    }
+    switch (field) {
+        default: return nullptr;
+    }
+}
+
+const char *Server_CleartextDescriptor::getFieldProperty(int field, const char *propertyname) const
+{
+    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
+    if (basedesc) {
+        if (field < basedesc->getFieldCount())
+            return basedesc->getFieldProperty(field, propertyname);
+        field -= basedesc->getFieldCount();
+    }
+    switch (field) {
+        default: return nullptr;
+    }
+}
+
+int Server_CleartextDescriptor::getFieldArraySize(void *object, int field) const
+{
+    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
+    if (basedesc) {
+        if (field < basedesc->getFieldCount())
+            return basedesc->getFieldArraySize(object, field);
+        field -= basedesc->getFieldCount();
+    }
+    Server_Cleartext *pp = (Server_Cleartext *)object; (void)pp;
+    switch (field) {
+        default: return 0;
+    }
+}
+
+const char *Server_CleartextDescriptor::getFieldDynamicTypeString(void *object, int field, int i) const
+{
+    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
+    if (basedesc) {
+        if (field < basedesc->getFieldCount())
+            return basedesc->getFieldDynamicTypeString(object,field,i);
+        field -= basedesc->getFieldCount();
+    }
+    Server_Cleartext *pp = (Server_Cleartext *)object; (void)pp;
+    switch (field) {
+        default: return nullptr;
+    }
+}
+
+std::string Server_CleartextDescriptor::getFieldValueAsString(void *object, int field, int i) const
+{
+    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
+    if (basedesc) {
+        if (field < basedesc->getFieldCount())
+            return basedesc->getFieldValueAsString(object,field,i);
+        field -= basedesc->getFieldCount();
+    }
+    Server_Cleartext *pp = (Server_Cleartext *)object; (void)pp;
+    switch (field) {
+        case 0: {std::stringstream out; out << pp->getStream_0(); return out.str();}
+        case 1: {std::stringstream out; out << pp->getAck_0(); return out.str();}
+        case 2: {std::stringstream out; out << pp->getPadding_0(); return out.str();}
+        default: return "";
+    }
+}
+
+bool Server_CleartextDescriptor::setFieldValueAsString(void *object, int field, int i, const char *value) const
+{
+    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
+    if (basedesc) {
+        if (field < basedesc->getFieldCount())
+            return basedesc->setFieldValueAsString(object,field,i,value);
+        field -= basedesc->getFieldCount();
+    }
+    Server_Cleartext *pp = (Server_Cleartext *)object; (void)pp;
+    switch (field) {
+        default: return false;
+    }
+}
+
+const char *Server_CleartextDescriptor::getFieldStructName(int field) const
+{
+    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
+    if (basedesc) {
+        if (field < basedesc->getFieldCount())
+            return basedesc->getFieldStructName(field);
+        field -= basedesc->getFieldCount();
+    }
+    switch (field) {
+        case 0: return omnetpp::opp_typename(typeid(Stream));
+        case 1: return omnetpp::opp_typename(typeid(Ack));
+        case 2: return omnetpp::opp_typename(typeid(Padding));
+        default: return nullptr;
+    };
+}
+
+void *Server_CleartextDescriptor::getFieldStructValuePointer(void *object, int field, int i) const
+{
+    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
+    if (basedesc) {
+        if (field < basedesc->getFieldCount())
+            return basedesc->getFieldStructValuePointer(object, field, i);
+        field -= basedesc->getFieldCount();
+    }
+    Server_Cleartext *pp = (Server_Cleartext *)object; (void)pp;
+    switch (field) {
+        case 0: return (void *)(&pp->getStream_0()); break;
+        case 1: return (void *)(&pp->getAck_0()); break;
+        case 2: return (void *)(&pp->getPadding_0()); break;
+        default: return nullptr;
+    }
+}
+
+

QUIC/Packets/server_Cleartext_m.h

@@ -0,0 +1,81 @@
+//
+// Generated file, do not edit! Created by nedtool 5.2 from Packets/server_Cleartext.msg.
+//
+
+#if defined(__clang__)
+#  pragma clang diagnostic ignored "-Wreserved-id-macro"
+#endif
+#ifndef __SERVER_CLEARTEXT_M_H
+#define __SERVER_CLEARTEXT_M_H
+
+#include <omnetpp.h>
+
+// nedtool version check
+#define MSGC_VERSION 0x0502
+#if (MSGC_VERSION!=OMNETPP_VERSION)
+#    error Version mismatch! Probably this file was generated by an earlier version of nedtool: 'make clean' should help.
+#endif
+
+
+
+// cplusplus {{
+#include "Frames/stream_m.h"
+#include "Frames/ack_m.h"
+#include "Frames/padding_m.h"
+// }}
+
+/**
+ * Class generated from <tt>Packets/server_Cleartext.msg:28</tt> by nedtool.
+ * <pre>
+ * //
+ * // TODO generated message class
+ * //
+ * packet Server_Cleartext
+ * {
+ *     Stream stream_0;
+ *     Ack ack_0;
+ *     Padding padding_0;
+ * }
+ * </pre>
+ */
+class Server_Cleartext : public ::omnetpp::cPacket
+{
+  protected:
+    Stream stream_0;
+    Ack ack_0;
+    Padding padding_0;
+
+  private:
+    void copy(const Server_Cleartext& other);
+
+  protected:
+    // protected and unimplemented operator==(), to prevent accidental usage
+    bool operator==(const Server_Cleartext&);
+
+  public:
+    Server_Cleartext(const char *name=nullptr, short kind=0);
+    Server_Cleartext(const Server_Cleartext& other);
+    virtual ~Server_Cleartext();
+    Server_Cleartext& operator=(const Server_Cleartext& other);
+    virtual Server_Cleartext *dup() const override {return new Server_Cleartext(*this);}
+    virtual void parsimPack(omnetpp::cCommBuffer *b) const override;
+    virtual void parsimUnpack(omnetpp::cCommBuffer *b) override;
+
+    // field getter/setter methods
+    virtual Stream& getStream_0();
+    virtual const Stream& getStream_0() const {return const_cast<Server_Cleartext*>(this)->getStream_0();}
+    virtual void setStream_0(const Stream& stream_0);
+    virtual Ack& getAck_0();
+    virtual const Ack& getAck_0() const {return const_cast<Server_Cleartext*>(this)->getAck_0();}
+    virtual void setAck_0(const Ack& ack_0);
+    virtual Padding& getPadding_0();
+    virtual const Padding& getPadding_0() const {return const_cast<Server_Cleartext*>(this)->getPadding_0();}
+    virtual void setPadding_0(const Padding& padding_0);
+};
+
+inline void doParsimPacking(omnetpp::cCommBuffer *b, const Server_Cleartext& obj) {obj.parsimPack(b);}
+inline void doParsimUnpacking(omnetpp::cCommBuffer *b, Server_Cleartext& obj) {obj.parsimUnpack(b);}
+
+
+#endif // ifndef __SERVER_CLEARTEXT_M_H
+

QUIC/Packets/server_Stateless_Retry.msg

@@ -0,0 +1,26 @@
+//
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Lesser General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+// 
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU Lesser General Public License for more details.
+// 
+// You should have received a copy of the GNU Lesser General Public License
+// along with this program.  If not, see http://www.gnu.org/licenses/.
+// 
+
+cplusplus {{
+#include "Frames/stream_m.h"
+}}
+class noncobject Stream;
+
+//
+// TODO generated message class
+//
+packet Server_Stateless_Retry{
+	Stream stream_0;
+}

QUIC/Packets/server_Stateless_Retry_m.cc

@@ -0,0 +1,460 @@
+//
+// Generated file, do not edit! Created by nedtool 5.2 from Packets/server_Stateless_Retry.msg.
+//
+
+// Disable warnings about unused variables, empty switch stmts, etc:
+#ifdef _MSC_VER
+#  pragma warning(disable:4101)
+#  pragma warning(disable:4065)
+#endif
+
+#if defined(__clang__)
+#  pragma clang diagnostic ignored "-Wshadow"
+#  pragma clang diagnostic ignored "-Wconversion"
+#  pragma clang diagnostic ignored "-Wunused-parameter"
+#  pragma clang diagnostic ignored "-Wc++98-compat"
+#  pragma clang diagnostic ignored "-Wunreachable-code-break"
+#  pragma clang diagnostic ignored "-Wold-style-cast"
+#elif defined(__GNUC__)
+#  pragma GCC diagnostic ignored "-Wshadow"
+#  pragma GCC diagnostic ignored "-Wconversion"
+#  pragma GCC diagnostic ignored "-Wunused-parameter"
+#  pragma GCC diagnostic ignored "-Wold-style-cast"
+#  pragma GCC diagnostic ignored "-Wsuggest-attribute=noreturn"
+#  pragma GCC diagnostic ignored "-Wfloat-conversion"
+#endif
+
+#include <iostream>
+#include <sstream>
+#include "server_Stateless_Retry_m.h"
+
+namespace omnetpp {
+
+// Template pack/unpack rules. They are declared *after* a1l type-specific pack functions for multiple reasons.
+// They are in the omnetpp namespace, to allow them to be found by argument-dependent lookup via the cCommBuffer argument
+
+// Packing/unpacking an std::vector
+template<typename T, typename A>
+void doParsimPacking(omnetpp::cCommBuffer *buffer, const std::vector<T,A>& v)
+{
+    int n = v.size();
+    doParsimPacking(buffer, n);
+    for (int i = 0; i < n; i++)
+        doParsimPacking(buffer, v[i]);
+}
+
+template<typename T, typename A>
+void doParsimUnpacking(omnetpp::cCommBuffer *buffer, std::vector<T,A>& v)
+{
+    int n;
+    doParsimUnpacking(buffer, n);
+    v.resize(n);
+    for (int i = 0; i < n; i++)
+        doParsimUnpacking(buffer, v[i]);
+}
+
+// Packing/unpacking an std::list
+template<typename T, typename A>
+void doParsimPacking(omnetpp::cCommBuffer *buffer, const std::list<T,A>& l)
+{
+    doParsimPacking(buffer, (int)l.size());
+    for (typename std::list<T,A>::const_iterator it = l.begin(); it != l.end(); ++it)
+        doParsimPacking(buffer, (T&)*it);
+}
+
+template<typename T, typename A>
+void doParsimUnpacking(omnetpp::cCommBuffer *buffer, std::list<T,A>& l)
+{
+    int n;
+    doParsimUnpacking(buffer, n);
+    for (int i=0; i<n; i++) {
+        l.push_back(T());
+        doParsimUnpacking(buffer, l.back());
+    }
+}
+
+// Packing/unpacking an std::set
+template<typename T, typename Tr, typename A>
+void doParsimPacking(omnetpp::cCommBuffer *buffer, const std::set<T,Tr,A>& s)
+{
+    doParsimPacking(buffer, (int)s.size());
+    for (typename std::set<T,Tr,A>::const_iterator it = s.begin(); it != s.end(); ++it)
+        doParsimPacking(buffer, *it);
+}
+
+template<typename T, typename Tr, typename A>
+void doParsimUnpacking(omnetpp::cCommBuffer *buffer, std::set<T,Tr,A>& s)
+{
+    int n;
+    doParsimUnpacking(buffer, n);
+    for (int i=0; i<n; i++) {
+        T x;
+        doParsimUnpacking(buffer, x);
+        s.insert(x);
+    }
+}
+
+// Packing/unpacking an std::map
+template<typename K, typename V, typename Tr, typename A>
+void doParsimPacking(omnetpp::cCommBuffer *buffer, const std::map<K,V,Tr,A>& m)
+{
+    doParsimPacking(buffer, (int)m.size());
+    for (typename std::map<K,V,Tr,A>::const_iterator it = m.begin(); it != m.end(); ++it) {
+        doParsimPacking(buffer, it->first);
+        doParsimPacking(buffer, it->second);
+    }
+}
+
+template<typename K, typename V, typename Tr, typename A>
+void doParsimUnpacking(omnetpp::cCommBuffer *buffer, std::map<K,V,Tr,A>& m)
+{
+    int n;
+    doParsimUnpacking(buffer, n);
+    for (int i=0; i<n; i++) {
+        K k; V v;
+        doParsimUnpacking(buffer, k);
+        doParsimUnpacking(buffer, v);
+        m[k] = v;
+    }
+}
+
+// Default pack/unpack function for arrays
+template<typename T>
+void doParsimArrayPacking(omnetpp::cCommBuffer *b, const T *t, int n)
+{
+    for (int i = 0; i < n; i++)
+        doParsimPacking(b, t[i]);
+}
+
+template<typename T>
+void doParsimArrayUnpacking(omnetpp::cCommBuffer *b, T *t, int n)
+{
+    for (int i = 0; i < n; i++)
+        doParsimUnpacking(b, t[i]);
+}
+
+// Default rule to prevent compiler from choosing base class' doParsimPacking() function
+template<typename T>
+void doParsimPacking(omnetpp::cCommBuffer *, const T& t)
+{
+    throw omnetpp::cRuntimeError("Parsim error: No doParsimPacking() function for type %s", omnetpp::opp_typename(typeid(t)));
+}
+
+template<typename T>
+void doParsimUnpacking(omnetpp::cCommBuffer *, T& t)
+{
+    throw omnetpp::cRuntimeError("Parsim error: No doParsimUnpacking() function for type %s", omnetpp::opp_typename(typeid(t)));
+}
+
+}  // namespace omnetpp
+
+
+// forward
+template<typename T, typename A>
+std::ostream& operator<<(std::ostream& out, const std::vector<T,A>& vec);
+
+// Template rule which fires if a struct or class doesn't have operator<<
+template<typename T>
+inline std::ostream& operator<<(std::ostream& out,const T&) {return out;}
+
+// operator<< for std::vector<T>
+template<typename T, typename A>
+inline std::ostream& operator<<(std::ostream& out, const std::vector<T,A>& vec)
+{
+    out.put('{');
+    for(typename std::vector<T,A>::const_iterator it = vec.begin(); it != vec.end(); ++it)
+    {
+        if (it != vec.begin()) {
+            out.put(','); out.put(' ');
+        }
+        out << *it;
+    }
+    out.put('}');
+    
+    char buf[32];
+    sprintf(buf, " (size=%u)", (unsigned int)vec.size());
+    out.write(buf, strlen(buf));
+    return out;
+}
+
+Register_Class(Server_Stateless_Retry)
+
+Server_Stateless_Retry::Server_Stateless_Retry(const char *name, short kind) : ::omnetpp::cPacket(name,kind)
+{
+}
+
+Server_Stateless_Retry::Server_Stateless_Retry(const Server_Stateless_Retry& other) : ::omnetpp::cPacket(other)
+{
+    copy(other);
+}
+
+Server_Stateless_Retry::~Server_Stateless_Retry()
+{
+}
+
+Server_Stateless_Retry& Server_Stateless_Retry::operator=(const Server_Stateless_Retry& other)
+{
+    if (this==&other) return *this;
+    ::omnetpp::cPacket::operator=(other);
+    copy(other);
+    return *this;
+}
+
+void Server_Stateless_Retry::copy(const Server_Stateless_Retry& other)
+{
+    this->stream_0 = other.stream_0;
+}
+
+void Server_Stateless_Retry::parsimPack(omnetpp::cCommBuffer *b) const
+{
+    ::omnetpp::cPacket::parsimPack(b);
+    doParsimPacking(b,this->stream_0);
+}
+
+void Server_Stateless_Retry::parsimUnpack(omnetpp::cCommBuffer *b)
+{
+    ::omnetpp::cPacket::parsimUnpack(b);
+    doParsimUnpacking(b,this->stream_0);
+}
+
+Stream& Server_Stateless_Retry::getStream_0()
+{
+    return this->stream_0;
+}
+
+void Server_Stateless_Retry::setStream_0(const Stream& stream_0)
+{
+    this->stream_0 = stream_0;
+}
+
+class Server_Stateless_RetryDescriptor : public omnetpp::cClassDescriptor
+{
+  private:
+    mutable const char **propertynames;
+  public:
+    Server_Stateless_RetryDescriptor();
+    virtual ~Server_Stateless_RetryDescriptor();
+
+    virtual bool doesSupport(omnetpp::cObject *obj) const override;
+    virtual const char **getPropertyNames() const override;
+    virtual const char *getProperty(const char *propertyname) const override;
+    virtual int getFieldCount() const override;
+    virtual const char *getFieldName(int field) const override;
+    virtual int findField(const char *fieldName) const override;
+    virtual unsigned int getFieldTypeFlags(int field) const override;
+    virtual const char *getFieldTypeString(int field) const override;
+    virtual const char **getFieldPropertyNames(int field) const override;
+    virtual const char *getFieldProperty(int field, const char *propertyname) const override;
+    virtual int getFieldArraySize(void *object, int field) const override;
+
+    virtual const char *getFieldDynamicTypeString(void *object, int field, int i) const override;
+    virtual std::string getFieldValueAsString(void *object, int field, int i) const override;
+    virtual bool setFieldValueAsString(void *object, int field, int i, const char *value) const override;
+
+    virtual const char *getFieldStructName(int field) const override;
+    virtual void *getFieldStructValuePointer(void *object, int field, int i) const override;
+};
+
+Register_ClassDescriptor(Server_Stateless_RetryDescriptor)
+
+Server_Stateless_RetryDescriptor::Server_Stateless_RetryDescriptor() : omnetpp::cClassDescriptor("Server_Stateless_Retry", "omnetpp::cPacket")
+{
+    propertynames = nullptr;
+}
+
+Server_Stateless_RetryDescriptor::~Server_Stateless_RetryDescriptor()
+{
+    delete[] propertynames;
+}
+
+bool Server_Stateless_RetryDescriptor::doesSupport(omnetpp::cObject *obj) const
+{
+    return dynamic_cast<Server_Stateless_Retry *>(obj)!=nullptr;
+}
+
+const char **Server_Stateless_RetryDescriptor::getPropertyNames() const
+{
+    if (!propertynames) {
+        static const char *names[] = {  nullptr };
+        omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
+        const char **basenames = basedesc ? basedesc->getPropertyNames() : nullptr;
+        propertynames = mergeLists(basenames, names);
+    }
+    return propertynames;
+}
+
+const char *Server_Stateless_RetryDescriptor::getProperty(const char *propertyname) const
+{
+    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
+    return basedesc ? basedesc->getProperty(propertyname) : nullptr;
+}
+
+int Server_Stateless_RetryDescriptor::getFieldCount() const
+{
+    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
+    return basedesc ? 1+basedesc->getFieldCount() : 1;
+}
+
+unsigned int Server_Stateless_RetryDescriptor::getFieldTypeFlags(int field) const
+{
+    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
+    if (basedesc) {
+        if (field < basedesc->getFieldCount())
+            return basedesc->getFieldTypeFlags(field);
+        field -= basedesc->getFieldCount();
+    }
+    static unsigned int fieldTypeFlags[] = {
+        FD_ISCOMPOUND,
+    };
+    return (field>=0 && field<1) ? fieldTypeFlags[field] : 0;
+}
+
+const char *Server_Stateless_RetryDescriptor::getFieldName(int field) const
+{
+    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
+    if (basedesc) {
+        if (field < basedesc->getFieldCount())
+            return basedesc->getFieldName(field);
+        field -= basedesc->getFieldCount();
+    }
+    static const char *fieldNames[] = {
+        "stream_0",
+    };
+    return (field>=0 && field<1) ? fieldNames[field] : nullptr;
+}
+
+int Server_Stateless_RetryDescriptor::findField(const char *fieldName) const
+{
+    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
+    int base = basedesc ? basedesc->getFieldCount() : 0;
+    if (fieldName[0]=='s' && strcmp(fieldName, "stream_0")==0) return base+0;
+    return basedesc ? basedesc->findField(fieldName) : -1;
+}
+
+const char *Server_Stateless_RetryDescriptor::getFieldTypeString(int field) const
+{
+    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
+    if (basedesc) {
+        if (field < basedesc->getFieldCount())
+            return basedesc->getFieldTypeString(field);
+        field -= basedesc->getFieldCount();
+    }
+    static const char *fieldTypeStrings[] = {
+        "Stream",
+    };
+    return (field>=0 && field<1) ? fieldTypeStrings[field] : nullptr;
+}
+
+const char **Server_Stateless_RetryDescriptor::getFieldPropertyNames(int field) const
+{
+    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
+    if (basedesc) {
+        if (field < basedesc->getFieldCount())
+            return basedesc->getFieldPropertyNames(field);
+        field -= basedesc->getFieldCount();
+    }
+    switch (field) {
+        default: return nullptr;
+    }
+}
+
+const char *Server_Stateless_RetryDescriptor::getFieldProperty(int field, const char *propertyname) const
+{
+    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
+    if (basedesc) {
+        if (field < basedesc->getFieldCount())
+            return basedesc->getFieldProperty(field, propertyname);
+        field -= basedesc->getFieldCount();
+    }
+    switch (field) {
+        default: return nullptr;
+    }
+}
+
+int Server_Stateless_RetryDescriptor::getFieldArraySize(void *object, int field) const
+{
+    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
+    if (basedesc) {
+        if (field < basedesc->getFieldCount())
+            return basedesc->getFieldArraySize(object, field);
+        field -= basedesc->getFieldCount();
+    }
+    Server_Stateless_Retry *pp = (Server_Stateless_Retry *)object; (void)pp;
+    switch (field) {
+        default: return 0;
+    }
+}
+
+const char *Server_Stateless_RetryDescriptor::getFieldDynamicTypeString(void *object, int field, int i) const
+{
+    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
+    if (basedesc) {
+        if (field < basedesc->getFieldCount())
+            return basedesc->getFieldDynamicTypeString(object,field,i);
+        field -= basedesc->getFieldCount();
+    }
+    Server_Stateless_Retry *pp = (Server_Stateless_Retry *)object; (void)pp;
+    switch (field) {
+        default: return nullptr;
+    }
+}
+
+std::string Server_Stateless_RetryDescriptor::getFieldValueAsString(void *object, int field, int i) const
+{
+    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
+    if (basedesc) {
+        if (field < basedesc->getFieldCount())
+            return basedesc->getFieldValueAsString(object,field,i);
+        field -= basedesc->getFieldCount();
+    }
+    Server_Stateless_Retry *pp = (Server_Stateless_Retry *)object; (void)pp;
+    switch (field) {
+        case 0: {std::stringstream out; out << pp->getStream_0(); return out.str();}
+        default: return "";
+    }
+}
+
+bool Server_Stateless_RetryDescriptor::setFieldValueAsString(void *object, int field, int i, const char *value) const
+{
+    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
+    if (basedesc) {
+        if (field < basedesc->getFieldCount())
+            return basedesc->setFieldValueAsString(object,field,i,value);
+        field -= basedesc->getFieldCount();
+    }
+    Server_Stateless_Retry *pp = (Server_Stateless_Retry *)object; (void)pp;
+    switch (field) {
+        default: return false;
+    }
+}
+
+const char *Server_Stateless_RetryDescriptor::getFieldStructName(int field) const
+{
+    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
+    if (basedesc) {
+        if (field < basedesc->getFieldCount())
+            return basedesc->getFieldStructName(field);
+        field -= basedesc->getFieldCount();
+    }
+    switch (field) {
+        case 0: return omnetpp::opp_typename(typeid(Stream));
+        default: return nullptr;
+    };
+}
+
+void *Server_Stateless_RetryDescriptor::getFieldStructValuePointer(void *object, int field, int i) const
+{
+    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
+    if (basedesc) {
+        if (field < basedesc->getFieldCount())
+            return basedesc->getFieldStructValuePointer(object, field, i);
+        field -= basedesc->getFieldCount();
+    }
+    Server_Stateless_Retry *pp = (Server_Stateless_Retry *)object; (void)pp;
+    switch (field) {
+        case 0: return (void *)(&pp->getStream_0()); break;
+        default: return nullptr;
+    }
+}
+
+

QUIC/Packets/server_Stateless_Retry_m.h

@@ -0,0 +1,69 @@
+//
+// Generated file, do not edit! Created by nedtool 5.2 from Packets/server_Stateless_Retry.msg.
+//
+
+#if defined(__clang__)
+#  pragma clang diagnostic ignored "-Wreserved-id-macro"
+#endif
+#ifndef __SERVER_STATELESS_RETRY_M_H
+#define __SERVER_STATELESS_RETRY_M_H
+
+#include <omnetpp.h>
+
+// nedtool version check
+#define MSGC_VERSION 0x0502
+#if (MSGC_VERSION!=OMNETPP_VERSION)
+#    error Version mismatch! Probably this file was generated by an earlier version of nedtool: 'make clean' should help.
+#endif
+
+
+
+// cplusplus {{
+#include "Frames/stream_m.h"
+// }}
+
+/**
+ * Class generated from <tt>Packets/server_Stateless_Retry.msg:24</tt> by nedtool.
+ * <pre>
+ * //
+ * // TODO generated message class
+ * //
+ * packet Server_Stateless_Retry
+ * {
+ *     Stream stream_0;
+ * }
+ * </pre>
+ */
+class Server_Stateless_Retry : public ::omnetpp::cPacket
+{
+  protected:
+    Stream stream_0;
+
+  private:
+    void copy(const Server_Stateless_Retry& other);
+
+  protected:
+    // protected and unimplemented operator==(), to prevent accidental usage
+    bool operator==(const Server_Stateless_Retry&);
+
+  public:
+    Server_Stateless_Retry(const char *name=nullptr, short kind=0);
+    Server_Stateless_Retry(const Server_Stateless_Retry& other);
+    virtual ~Server_Stateless_Retry();
+    Server_Stateless_Retry& operator=(const Server_Stateless_Retry& other);
+    virtual Server_Stateless_Retry *dup() const override {return new Server_Stateless_Retry(*this);}
+    virtual void parsimPack(omnetpp::cCommBuffer *b) const override;
+    virtual void parsimUnpack(omnetpp::cCommBuffer *b) override;
+
+    // field getter/setter methods
+    virtual Stream& getStream_0();
+    virtual const Stream& getStream_0() const {return const_cast<Server_Stateless_Retry*>(this)->getStream_0();}
+    virtual void setStream_0(const Stream& stream_0);
+};
+
+inline void doParsimPacking(omnetpp::cCommBuffer *b, const Server_Stateless_Retry& obj) {obj.parsimPack(b);}
+inline void doParsimUnpacking(omnetpp::cCommBuffer *b, Server_Stateless_Retry& obj) {obj.parsimUnpack(b);}
+
+
+#endif // ifndef __SERVER_STATELESS_RETRY_M_H
+

QUIC/Packets/version_Negotiation.msg

@@ -0,0 +1,21 @@
+//
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Lesser General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+// 
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU Lesser General Public License for more details.
+// 
+// You should have received a copy of the GNU Lesser General Public License
+// along with this program.  If not, see http://www.gnu.org/licenses/.
+// 
+
+//
+// TODO generated message class
+//
+packet Version_Negotiation {
+    string versions;
+}

QUIC/Packets/version_Negotiation_m.cc

@@ -0,0 +1,459 @@
+//
+// Generated file, do not edit! Created by nedtool 5.2 from Packets/version_Negotiation.msg.
+//
+
+// Disable warnings about unused variables, empty switch stmts, etc:
+#ifdef _MSC_VER
+#  pragma warning(disable:4101)
+#  pragma warning(disable:4065)
+#endif
+
+#if defined(__clang__)
+#  pragma clang diagnostic ignored "-Wshadow"
+#  pragma clang diagnostic ignored "-Wconversion"
+#  pragma clang diagnostic ignored "-Wunused-parameter"
+#  pragma clang diagnostic ignored "-Wc++98-compat"
+#  pragma clang diagnostic ignored "-Wunreachable-code-break"
+#  pragma clang diagnostic ignored "-Wold-style-cast"
+#elif defined(__GNUC__)
+#  pragma GCC diagnostic ignored "-Wshadow"
+#  pragma GCC diagnostic ignored "-Wconversion"
+#  pragma GCC diagnostic ignored "-Wunused-parameter"
+#  pragma GCC diagnostic ignored "-Wold-style-cast"
+#  pragma GCC diagnostic ignored "-Wsuggest-attribute=noreturn"
+#  pragma GCC diagnostic ignored "-Wfloat-conversion"
+#endif
+
+#include <iostream>
+#include <sstream>
+#include "version_Negotiation_m.h"
+
+namespace omnetpp {
+
+// Template pack/unpack rules. They are declared *after* a1l type-specific pack functions for multiple reasons.
+// They are in the omnetpp namespace, to allow them to be found by argument-dependent lookup via the cCommBuffer argument
+
+// Packing/unpacking an std::vector
+template<typename T, typename A>
+void doParsimPacking(omnetpp::cCommBuffer *buffer, const std::vector<T,A>& v)
+{
+    int n = v.size();
+    doParsimPacking(buffer, n);
+    for (int i = 0; i < n; i++)
+        doParsimPacking(buffer, v[i]);
+}
+
+template<typename T, typename A>
+void doParsimUnpacking(omnetpp::cCommBuffer *buffer, std::vector<T,A>& v)
+{
+    int n;
+    doParsimUnpacking(buffer, n);
+    v.resize(n);
+    for (int i = 0; i < n; i++)
+        doParsimUnpacking(buffer, v[i]);
+}
+
+// Packing/unpacking an std::list
+template<typename T, typename A>
+void doParsimPacking(omnetpp::cCommBuffer *buffer, const std::list<T,A>& l)
+{
+    doParsimPacking(buffer, (int)l.size());
+    for (typename std::list<T,A>::const_iterator it = l.begin(); it != l.end(); ++it)
+        doParsimPacking(buffer, (T&)*it);
+}
+
+template<typename T, typename A>
+void doParsimUnpacking(omnetpp::cCommBuffer *buffer, std::list<T,A>& l)
+{
+    int n;
+    doParsimUnpacking(buffer, n);
+    for (int i=0; i<n; i++) {
+        l.push_back(T());
+        doParsimUnpacking(buffer, l.back());
+    }
+}
+
+// Packing/unpacking an std::set
+template<typename T, typename Tr, typename A>
+void doParsimPacking(omnetpp::cCommBuffer *buffer, const std::set<T,Tr,A>& s)
+{
+    doParsimPacking(buffer, (int)s.size());
+    for (typename std::set<T,Tr,A>::const_iterator it = s.begin(); it != s.end(); ++it)
+        doParsimPacking(buffer, *it);
+}
+
+template<typename T, typename Tr, typename A>
+void doParsimUnpacking(omnetpp::cCommBuffer *buffer, std::set<T,Tr,A>& s)
+{
+    int n;
+    doParsimUnpacking(buffer, n);
+    for (int i=0; i<n; i++) {
+        T x;
+        doParsimUnpacking(buffer, x);
+        s.insert(x);
+    }
+}
+
+// Packing/unpacking an std::map
+template<typename K, typename V, typename Tr, typename A>
+void doParsimPacking(omnetpp::cCommBuffer *buffer, const std::map<K,V,Tr,A>& m)
+{
+    doParsimPacking(buffer, (int)m.size());
+    for (typename std::map<K,V,Tr,A>::const_iterator it = m.begin(); it != m.end(); ++it) {
+        doParsimPacking(buffer, it->first);
+        doParsimPacking(buffer, it->second);
+    }
+}
+
+template<typename K, typename V, typename Tr, typename A>
+void doParsimUnpacking(omnetpp::cCommBuffer *buffer, std::map<K,V,Tr,A>& m)
+{
+    int n;
+    doParsimUnpacking(buffer, n);
+    for (int i=0; i<n; i++) {
+        K k; V v;
+        doParsimUnpacking(buffer, k);
+        doParsimUnpacking(buffer, v);
+        m[k] = v;
+    }
+}
+
+// Default pack/unpack function for arrays
+template<typename T>
+void doParsimArrayPacking(omnetpp::cCommBuffer *b, const T *t, int n)
+{
+    for (int i = 0; i < n; i++)
+        doParsimPacking(b, t[i]);
+}
+
+template<typename T>
+void doParsimArrayUnpacking(omnetpp::cCommBuffer *b, T *t, int n)
+{
+    for (int i = 0; i < n; i++)
+        doParsimUnpacking(b, t[i]);
+}
+
+// Default rule to prevent compiler from choosing base class' doParsimPacking() function
+template<typename T>
+void doParsimPacking(omnetpp::cCommBuffer *, const T& t)
+{
+    throw omnetpp::cRuntimeError("Parsim error: No doParsimPacking() function for type %s", omnetpp::opp_typename(typeid(t)));
+}
+
+template<typename T>
+void doParsimUnpacking(omnetpp::cCommBuffer *, T& t)
+{
+    throw omnetpp::cRuntimeError("Parsim error: No doParsimUnpacking() function for type %s", omnetpp::opp_typename(typeid(t)));
+}
+
+}  // namespace omnetpp
+
+
+// forward
+template<typename T, typename A>
+std::ostream& operator<<(std::ostream& out, const std::vector<T,A>& vec);
+
+// Template rule which fires if a struct or class doesn't have operator<<
+template<typename T>
+inline std::ostream& operator<<(std::ostream& out,const T&) {return out;}
+
+// operator<< for std::vector<T>
+template<typename T, typename A>
+inline std::ostream& operator<<(std::ostream& out, const std::vector<T,A>& vec)
+{
+    out.put('{');
+    for(typename std::vector<T,A>::const_iterator it = vec.begin(); it != vec.end(); ++it)
+    {
+        if (it != vec.begin()) {
+            out.put(','); out.put(' ');
+        }
+        out << *it;
+    }
+    out.put('}');
+    
+    char buf[32];
+    sprintf(buf, " (size=%u)", (unsigned int)vec.size());
+    out.write(buf, strlen(buf));
+    return out;
+}
+
+Register_Class(Version_Negotiation)
+
+Version_Negotiation::Version_Negotiation(const char *name, short kind) : ::omnetpp::cPacket(name,kind)
+{
+}
+
+Version_Negotiation::Version_Negotiation(const Version_Negotiation& other) : ::omnetpp::cPacket(other)
+{
+    copy(other);
+}
+
+Version_Negotiation::~Version_Negotiation()
+{
+}
+
+Version_Negotiation& Version_Negotiation::operator=(const Version_Negotiation& other)
+{
+    if (this==&other) return *this;
+    ::omnetpp::cPacket::operator=(other);
+    copy(other);
+    return *this;
+}
+
+void Version_Negotiation::copy(const Version_Negotiation& other)
+{
+    this->versions = other.versions;
+}
+
+void Version_Negotiation::parsimPack(omnetpp::cCommBuffer *b) const
+{
+    ::omnetpp::cPacket::parsimPack(b);
+    doParsimPacking(b,this->versions);
+}
+
+void Version_Negotiation::parsimUnpack(omnetpp::cCommBuffer *b)
+{
+    ::omnetpp::cPacket::parsimUnpack(b);
+    doParsimUnpacking(b,this->versions);
+}
+
+const char * Version_Negotiation::getVersions() const
+{
+    return this->versions.c_str();
+}
+
+void Version_Negotiation::setVersions(const char * versions)
+{
+    this->versions = versions;
+}
+
+class Version_NegotiationDescriptor : public omnetpp::cClassDescriptor
+{
+  private:
+    mutable const char **propertynames;
+  public:
+    Version_NegotiationDescriptor();
+    virtual ~Version_NegotiationDescriptor();
+
+    virtual bool doesSupport(omnetpp::cObject *obj) const override;
+    virtual const char **getPropertyNames() const override;
+    virtual const char *getProperty(const char *propertyname) const override;
+    virtual int getFieldCount() const override;
+    virtual const char *getFieldName(int field) const override;
+    virtual int findField(const char *fieldName) const override;
+    virtual unsigned int getFieldTypeFlags(int field) const override;
+    virtual const char *getFieldTypeString(int field) const override;
+    virtual const char **getFieldPropertyNames(int field) const override;
+    virtual const char *getFieldProperty(int field, const char *propertyname) const override;
+    virtual int getFieldArraySize(void *object, int field) const override;
+
+    virtual const char *getFieldDynamicTypeString(void *object, int field, int i) const override;
+    virtual std::string getFieldValueAsString(void *object, int field, int i) const override;
+    virtual bool setFieldValueAsString(void *object, int field, int i, const char *value) const override;
+
+    virtual const char *getFieldStructName(int field) const override;
+    virtual void *getFieldStructValuePointer(void *object, int field, int i) const override;
+};
+
+Register_ClassDescriptor(Version_NegotiationDescriptor)
+
+Version_NegotiationDescriptor::Version_NegotiationDescriptor() : omnetpp::cClassDescriptor("Version_Negotiation", "omnetpp::cPacket")
+{
+    propertynames = nullptr;
+}
+
+Version_NegotiationDescriptor::~Version_NegotiationDescriptor()
+{
+    delete[] propertynames;
+}
+
+bool Version_NegotiationDescriptor::doesSupport(omnetpp::cObject *obj) const
+{
+    return dynamic_cast<Version_Negotiation *>(obj)!=nullptr;
+}
+
+const char **Version_NegotiationDescriptor::getPropertyNames() const
+{
+    if (!propertynames) {
+        static const char *names[] = {  nullptr };
+        omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
+        const char **basenames = basedesc ? basedesc->getPropertyNames() : nullptr;
+        propertynames = mergeLists(basenames, names);
+    }
+    return propertynames;
+}
+
+const char *Version_NegotiationDescriptor::getProperty(const char *propertyname) const
+{
+    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
+    return basedesc ? basedesc->getProperty(propertyname) : nullptr;
+}
+
+int Version_NegotiationDescriptor::getFieldCount() const
+{
+    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
+    return basedesc ? 1+basedesc->getFieldCount() : 1;
+}
+
+unsigned int Version_NegotiationDescriptor::getFieldTypeFlags(int field) const
+{
+    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
+    if (basedesc) {
+        if (field < basedesc->getFieldCount())
+            return basedesc->getFieldTypeFlags(field);
+        field -= basedesc->getFieldCount();
+    }
+    static unsigned int fieldTypeFlags[] = {
+        FD_ISEDITABLE,
+    };
+    return (field>=0 && field<1) ? fieldTypeFlags[field] : 0;
+}
+
+const char *Version_NegotiationDescriptor::getFieldName(int field) const
+{
+    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
+    if (basedesc) {
+        if (field < basedesc->getFieldCount())
+            return basedesc->getFieldName(field);
+        field -= basedesc->getFieldCount();
+    }
+    static const char *fieldNames[] = {
+        "versions",
+    };
+    return (field>=0 && field<1) ? fieldNames[field] : nullptr;
+}
+
+int Version_NegotiationDescriptor::findField(const char *fieldName) const
+{
+    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
+    int base = basedesc ? basedesc->getFieldCount() : 0;
+    if (fieldName[0]=='v' && strcmp(fieldName, "versions")==0) return base+0;
+    return basedesc ? basedesc->findField(fieldName) : -1;
+}
+
+const char *Version_NegotiationDescriptor::getFieldTypeString(int field) const
+{
+    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
+    if (basedesc) {
+        if (field < basedesc->getFieldCount())
+            return basedesc->getFieldTypeString(field);
+        field -= basedesc->getFieldCount();
+    }
+    static const char *fieldTypeStrings[] = {
+        "string",
+    };
+    return (field>=0 && field<1) ? fieldTypeStrings[field] : nullptr;
+}
+
+const char **Version_NegotiationDescriptor::getFieldPropertyNames(int field) const
+{
+    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
+    if (basedesc) {
+        if (field < basedesc->getFieldCount())
+            return basedesc->getFieldPropertyNames(field);
+        field -= basedesc->getFieldCount();
+    }
+    switch (field) {
+        default: return nullptr;
+    }
+}
+
+const char *Version_NegotiationDescriptor::getFieldProperty(int field, const char *propertyname) const
+{
+    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
+    if (basedesc) {
+        if (field < basedesc->getFieldCount())
+            return basedesc->getFieldProperty(field, propertyname);
+        field -= basedesc->getFieldCount();
+    }
+    switch (field) {
+        default: return nullptr;
+    }
+}
+
+int Version_NegotiationDescriptor::getFieldArraySize(void *object, int field) const
+{
+    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
+    if (basedesc) {
+        if (field < basedesc->getFieldCount())
+            return basedesc->getFieldArraySize(object, field);
+        field -= basedesc->getFieldCount();
+    }
+    Version_Negotiation *pp = (Version_Negotiation *)object; (void)pp;
+    switch (field) {
+        default: return 0;
+    }
+}
+
+const char *Version_NegotiationDescriptor::getFieldDynamicTypeString(void *object, int field, int i) const
+{
+    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
+    if (basedesc) {
+        if (field < basedesc->getFieldCount())
+            return basedesc->getFieldDynamicTypeString(object,field,i);
+        field -= basedesc->getFieldCount();
+    }
+    Version_Negotiation *pp = (Version_Negotiation *)object; (void)pp;
+    switch (field) {
+        default: return nullptr;
+    }
+}
+
+std::string Version_NegotiationDescriptor::getFieldValueAsString(void *object, int field, int i) const
+{
+    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
+    if (basedesc) {
+        if (field < basedesc->getFieldCount())
+            return basedesc->getFieldValueAsString(object,field,i);
+        field -= basedesc->getFieldCount();
+    }
+    Version_Negotiation *pp = (Version_Negotiation *)object; (void)pp;
+    switch (field) {
+        case 0: return oppstring2string(pp->getVersions());
+        default: return "";
+    }
+}
+
+bool Version_NegotiationDescriptor::setFieldValueAsString(void *object, int field, int i, const char *value) const
+{
+    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
+    if (basedesc) {
+        if (field < basedesc->getFieldCount())
+            return basedesc->setFieldValueAsString(object,field,i,value);
+        field -= basedesc->getFieldCount();
+    }
+    Version_Negotiation *pp = (Version_Negotiation *)object; (void)pp;
+    switch (field) {
+        case 0: pp->setVersions((value)); return true;
+        default: return false;
+    }
+}
+
+const char *Version_NegotiationDescriptor::getFieldStructName(int field) const
+{
+    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
+    if (basedesc) {
+        if (field < basedesc->getFieldCount())
+            return basedesc->getFieldStructName(field);
+        field -= basedesc->getFieldCount();
+    }
+    switch (field) {
+        default: return nullptr;
+    };
+}
+
+void *Version_NegotiationDescriptor::getFieldStructValuePointer(void *object, int field, int i) const
+{
+    omnetpp::cClassDescriptor *basedesc = getBaseClassDescriptor();
+    if (basedesc) {
+        if (field < basedesc->getFieldCount())
+            return basedesc->getFieldStructValuePointer(object, field, i);
+        field -= basedesc->getFieldCount();
+    }
+    Version_Negotiation *pp = (Version_Negotiation *)object; (void)pp;
+    switch (field) {
+        default: return nullptr;
+    }
+}
+
+

QUIC/Packets/version_Negotiation_m.h

@@ -0,0 +1,64 @@
+//
+// Generated file, do not edit! Created by nedtool 5.2 from Packets/version_Negotiation.msg.
+//
+
+#if defined(__clang__)
+#  pragma clang diagnostic ignored "-Wreserved-id-macro"
+#endif
+#ifndef __VERSION_NEGOTIATION_M_H
+#define __VERSION_NEGOTIATION_M_H
+
+#include <omnetpp.h>
+
+// nedtool version check
+#define MSGC_VERSION 0x0502
+#if (MSGC_VERSION!=OMNETPP_VERSION)
+#    error Version mismatch! Probably this file was generated by an earlier version of nedtool: 'make clean' should help.
+#endif
+
+
+
+/**
+ * Class generated from <tt>Packets/version_Negotiation.msg:19</tt> by nedtool.
+ * <pre>
+ * //
+ * // TODO generated message class
+ * //
+ * packet Version_Negotiation
+ * {
+ *     string versions;
+ * }
+ * </pre>
+ */
+class Version_Negotiation : public ::omnetpp::cPacket
+{
+  protected:
+    ::omnetpp::opp_string versions;
+
+  private:
+    void copy(const Version_Negotiation& other);
+
+  protected:
+    // protected and unimplemented operator==(), to prevent accidental usage
+    bool operator==(const Version_Negotiation&);
+
+  public:
+    Version_Negotiation(const char *name=nullptr, short kind=0);
+    Version_Negotiation(const Version_Negotiation& other);
+    virtual ~Version_Negotiation();
+    Version_Negotiation& operator=(const Version_Negotiation& other);
+    virtual Version_Negotiation *dup() const override {return new Version_Negotiation(*this);}
+    virtual void parsimPack(omnetpp::cCommBuffer *b) const override;
+    virtual void parsimUnpack(omnetpp::cCommBuffer *b) override;
+
+    // field getter/setter methods
+    virtual const char * getVersions() const;
+    virtual void setVersions(const char * versions);
+};
+
+inline void doParsimPacking(omnetpp::cCommBuffer *b, const Version_Negotiation& obj) {obj.parsimPack(b);}
+inline void doParsimUnpacking(omnetpp::cCommBuffer *b, Version_Negotiation& obj) {obj.parsimUnpack(b);}
+
+
+#endif // ifndef __VERSION_NEGOTIATION_M_H
+

QUIC/out/clang-debug/.last-copts

@@ -0,0 +1 @@
+-g -Wall -MMD -MP -MF .d  -fPIC  -Wno-deprecated-register -Wno-unused-function -fno-stack-protector -DHAVE_SWAPCONTEXT -DXMLPARSER=none -DPREFER_QTENV -DWITH_QTENV -DWITH_PARSIM -DWITH_NETBUILDER   -I. -I/home/anay/Documents/omnetpp-5.2/include

QUIC/out/clang-debug/Frames/ack_m.d

@@ -0,0 +1,6 @@
+out/clang-debug//Frames/ack_m.o: Frames/ack_m.cc Frames/ack_m.h \
+  /home/anay/Documents/omnetpp-5.2/include/omnetpp.h
+
+Frames/ack_m.h:
+
+/home/anay/Documents/omnetpp-5.2/include/omnetpp.h:

QUIC/out/clang-debug/Frames/application_Close_m.d

@@ -0,0 +1,7 @@
+out/clang-debug//Frames/application_Close_m.o: \
+  Frames/application_Close_m.cc Frames/application_Close_m.h \
+  /home/anay/Documents/omnetpp-5.2/include/omnetpp.h
+
+Frames/application_Close_m.h:
+
+/home/anay/Documents/omnetpp-5.2/include/omnetpp.h:

QUIC/out/clang-debug/Frames/blocked_m.d

@@ -0,0 +1,6 @@
+out/clang-debug//Frames/blocked_m.o: Frames/blocked_m.cc \
+  Frames/blocked_m.h /home/anay/Documents/omnetpp-5.2/include/omnetpp.h
+
+Frames/blocked_m.h:
+
+/home/anay/Documents/omnetpp-5.2/include/omnetpp.h:

QUIC/out/clang-debug/Frames/connection_close_m.d

@@ -0,0 +1,7 @@
+out/clang-debug//Frames/connection_close_m.o: \
+  Frames/connection_close_m.cc Frames/connection_close_m.h \
+  /home/anay/Documents/omnetpp-5.2/include/omnetpp.h
+
+Frames/connection_close_m.h:
+
+/home/anay/Documents/omnetpp-5.2/include/omnetpp.h:

QUIC/out/clang-debug/Frames/max_Data_m.d

@@ -0,0 +1,6 @@
+out/clang-debug//Frames/max_Data_m.o: Frames/max_Data_m.cc \
+  Frames/max_Data_m.h /home/anay/Documents/omnetpp-5.2/include/omnetpp.h
+
+Frames/max_Data_m.h:
+
+/home/anay/Documents/omnetpp-5.2/include/omnetpp.h:

QUIC/out/clang-debug/Frames/max_Stream_Data_m.d

@@ -0,0 +1,7 @@
+out/clang-debug//Frames/max_Stream_Data_m.o: Frames/max_Stream_Data_m.cc \
+  Frames/max_Stream_Data_m.h \
+  /home/anay/Documents/omnetpp-5.2/include/omnetpp.h
+
+Frames/max_Stream_Data_m.h:
+
+/home/anay/Documents/omnetpp-5.2/include/omnetpp.h:

QUIC/out/clang-debug/Frames/max_Stream_Id_m.d

@@ -0,0 +1,7 @@
+out/clang-debug//Frames/max_Stream_Id_m.o: Frames/max_Stream_Id_m.cc \
+  Frames/max_Stream_Id_m.h \
+  /home/anay/Documents/omnetpp-5.2/include/omnetpp.h
+
+Frames/max_Stream_Id_m.h:
+
+/home/anay/Documents/omnetpp-5.2/include/omnetpp.h:

QUIC/out/clang-debug/Frames/new_Connection_Id_m.d

@@ -0,0 +1,7 @@
+out/clang-debug//Frames/new_Connection_Id_m.o: \
+  Frames/new_Connection_Id_m.cc Frames/new_Connection_Id_m.h \
+  /home/anay/Documents/omnetpp-5.2/include/omnetpp.h
+
+Frames/new_Connection_Id_m.h:
+
+/home/anay/Documents/omnetpp-5.2/include/omnetpp.h:

QUIC/out/clang-debug/Frames/padding_m.d

@@ -0,0 +1,6 @@
+out/clang-debug//Frames/padding_m.o: Frames/padding_m.cc \
+  Frames/padding_m.h /home/anay/Documents/omnetpp-5.2/include/omnetpp.h
+
+Frames/padding_m.h:
+
+/home/anay/Documents/omnetpp-5.2/include/omnetpp.h: