From a1c178f7eb76a3ca5fd4fa21fe83f296e10600d9 Mon Sep 17 00:00:00 2001
From: Jueun Park <s5616012@mailbox.tu-dresden.de>
Date: Tue, 1 Mar 2022 15:43:03 +0900
Subject: [PATCH] fix

---
 src/main/jastadd/Parser.jrag        | 934 ++++++++++++++++++++++++++
 src/main/jastadd/ReverseParser.jrag | 976 ++++++++++++++++++++++++++++
 2 files changed, 1910 insertions(+)
 create mode 100644 src/main/jastadd/Parser.jrag
 create mode 100644 src/main/jastadd/ReverseParser.jrag

diff --git a/src/main/jastadd/Parser.jrag b/src/main/jastadd/Parser.jrag
new file mode 100644
index 00000000..c74c6564
--- /dev/null
+++ b/src/main/jastadd/Parser.jrag
@@ -0,0 +1,934 @@
+import io.swagger.models.*;
+import io.swagger.v3.oas.models.OpenAPI;
+import io.swagger.v3.oas.models.*;
+import io.swagger.v3.oas.models.callbacks.*;
+import io.swagger.v3.oas.models.examples.*;
+import io.swagger.v3.oas.models.headers.*;
+import io.swagger.v3.oas.models.info.*;
+import io.swagger.v3.oas.models.links.*;
+import io.swagger.v3.oas.models.media.*;
+import io.swagger.v3.oas.models.parameters.*;
+import io.swagger.v3.oas.models.responses.*;
+import io.swagger.v3.oas.models.security.*;
+import io.swagger.v3.oas.models.servers.*;
+import io.swagger.v3.oas.models.tags.*;
+
+
+aspect Parser {
+
+public static OpenAPIObject OpenAPIObject.parseOpenAPI(OpenAPI api) {
+        OpenAPIObject openapi = new OpenAPIObject();
+
+        if (api.getOpenapi() != null)
+        openapi.setOpenAPI(api.getOpenapi());
+        if (api.getInfo() != null)
+        openapi.set_impl_i(InfoObject.parseInfo(api.getInfo()));
+        if (api.getPaths() != null) {
+        for (String key : api.getPaths().keySet())
+        openapi.addP(new PathsObject(key, PathItemObject.parsePath(api.getPaths().get(key))));
+        }
+        if (api.getServers() != null) {
+        for (io.swagger.v3.oas.models.servers.Server s : api.getServers())
+        openapi.addS(ServerObject.parseServer(s));
+        }
+        if (api.getComponents() != null)
+        openapi.set_impl_c(ComponentsObject.parseComponents(api.getComponents()));
+        if (api.getSecurity() != null) {
+        for (io.swagger.v3.oas.models.security.SecurityRequirement s : api.getSecurity())
+        openapi.addSr(SecurityRequirementObject.parseSecurityRequirement(s));
+        }
+        if (api.getTags() != null) {
+        for (io.swagger.v3.oas.models.tags.Tag t : api.getTags())
+        openapi.addT(TagObject.parseTag(t));
+        }
+        if (api.getExternalDocs() != null)
+        openapi.set_impl_e(ExternalDocObject.parseExternalDocs(api.getExternalDocs()));
+        if (api.getExtensions().size() != 0) {
+        for (String key : api.getExtensions().keySet())
+        openapi.addEx(new Extension(key, api.getExtensions().get(key)));
+        }
+    /* 3.1.0 features
+    if (api.getWebhook != null) ...
+    if (api.getJsonSchemaDialect != null) ...
+     */
+
+        return openapi;
+        }
+
+public static InfoObject InfoObject.parseInfo(io.swagger.v3.oas.models.info.Info info) {
+        InfoObject infoObject = new InfoObject();
+
+        if (info.getTitle() != null)
+        infoObject.setTitle(info.getTitle());
+        if (info.getVersion() != null)
+        infoObject.setVersion(info.getVersion());
+        if (info.getDescription() != null)
+        infoObject.setDescription(info.getDescription());
+        if (info.getTermsOfService() != null)
+        infoObject.setTermsOfService(info.getTermsOfService());
+        if (info.getContact() != null)
+        infoObject.set_impl_c(ContactObject.parseContact(info.getContact()));
+        if (info.getLicense() != null)
+        infoObject.set_impl_l(LicenseObject.parseLicense(info.getLicense()));
+        if (info.getExtensions().size() != 0) {
+        for (String key : info.getExtensions().keySet())
+        infoObject.addEx(new Extension(key, info.getExtensions().get(key)));
+        }
+
+        /* 3.1.0 features
+        if (info.getSummary != null) ...
+        */
+
+        return infoObject;
+        }
+
+public static ContactObject ContactObject.parseContact(io.swagger.v3.oas.models.info.Contact contact){
+        ContactObject contactObject = new ContactObject();
+
+        if (contact.getName() != null)
+        contactObject.setName(contact.getName());
+        if (contact.getUrl() != null)
+        contactObject.setUrl(contact.getUrl());
+        if (contact.getEmail() != null)
+        contactObject.setEmail(contact.getEmail());
+        if (contact.getExtensions().size() != 0) {
+        for (String key : contact.getExtensions().keySet())
+        contactObject.addEx(new Extension(key, contact.getExtensions().get(key)));
+        }
+
+        return contactObject;
+        }
+
+public static LicenseObject LicenseObject.parseLicense(io.swagger.v3.oas.models.info.License license){
+        LicenseObject licenseObject = new LicenseObject();
+
+        if (license.getName() != null)
+        licenseObject.setName(license.getName());
+        if (license.getUrl() != null)
+        licenseObject.setUrl(license.getUrl());
+        if (license.getExtensions().size() != 0) {
+        for (String key : license.getExtensions().keySet())
+        licenseObject.addEx(new Extension(key, license.getExtensions().get(key)));
+        }
+
+        /* 3.1.0 features
+        if (license.getIdentifier() != null) ...
+         */
+
+        return licenseObject;
+        }
+
+public static ServerObject ServerObject.parseServer(Server server){
+        ServerObject serverObject = new ServerObject();
+
+        if (server.getUrl() != null)
+        serverObject.setUrl(server.getUrl());
+        if (server.getDescription() != null)
+        serverObject.setDescription(server.getDescription());
+        if (server.getVariables() != null) {
+        for (String key : server.getVariables().keySet())
+        serverObject.addSt(new ServerVariablesTuple(key, ServerVariableObject.parseServerVariable(server.getVariables().get(key))));
+        }
+        if (server.getExtensions().size() != 0) {
+        for (String key : server.getExtensions().keySet())
+        serverObject.addEx(new Extension(key, server.getExtensions().get(key)));
+        }
+
+        return serverObject;
+        }
+
+public static ServerVariableObject ServerVariableObject.parseServerVariable(ServerVariable serverVariable){
+        ServerVariableObject serverVariableObject = new ServerVariableObject();
+
+        if (serverVariable.getDefault() != null)
+        serverVariableObject.setDefault(serverVariable.getDefault());
+        if (serverVariable.getDescription() != null)
+        serverVariableObject.setDescription(serverVariable.getDescription());
+        if (serverVariable.getEnum().size() != 0) {
+        for (String e : serverVariable.getEnum())
+        serverVariableObject.addE(new Enum(e));
+        }
+        if (serverVariable.getExtensions().size() != 0) {
+        for (String key : serverVariable.getExtensions().keySet())
+        serverVariableObject.addEx(new Extension(key, serverVariable.getExtensions().get(key)));
+        }
+
+        return serverVariableObject;
+        }
+
+public static ComponentsObject ComponentsObject.parseComponents(Components components) {
+        ComponentsObject componentsObject = new ComponentsObject();
+
+        if (components.getSchemas() != null) {
+        for (String key : components.getSchemas().keySet())
+        componentsObject.addS(new SchemaTuple(key, SchemaOb.parseSchema(components.getSchemas().get(key))));
+        }
+        if (components.getResponses() != null) {
+        for (String key : components.getResponses().keySet())
+        componentsObject.addR(new ResponseTuple(key, ResponseOb.parseResponse(components.getResponses().get(key))));
+        }
+        if (components.getParameters() != null) {
+        for (String key : components.getParameters().keySet())
+        componentsObject.addP(new ParameterTuple(key, ParameterOb.parseParameter(components.getParameters().get(key))));
+        }
+        if (components.getExamples() != null) {
+        for (String key : components.getExamples().keySet())
+        componentsObject.addE(new ExampleTuple(key, ExampleObject.parseExample(components.getExamples().get(key))));
+        }
+        if (components.getRequestBodies() != null) {
+        for (String key : components.getRequestBodies().keySet())
+        componentsObject.addRb(new RequestBodyTuple(key, RequestBodyOb.parseRequestBody(components.getRequestBodies().get(key))));
+        }
+        if (components.getHeaders() != null) {
+        for (String key : components.getHeaders().keySet())
+        componentsObject.addH(new HeaderTuple(key, HeaderOb.parseHeader(components.getHeaders().get(key))));
+        }
+        if (components.getSecuritySchemes() != null) {
+        for (String key : components.getSecuritySchemes().keySet())
+        componentsObject.addSc(new SecuritySchemeTuple(key, SecuritySchemeOb.parseSecurityScheme(components.getSecuritySchemes().get(key))));
+        }
+        if (components.getLinks() != null) {
+        for (String key : components.getLinks().keySet())
+        componentsObject.addL(new LinkTuple(key, LinkOb.parseLink(components.getLinks().get(key))));
+        }
+        if (components.getCallbacks() != null) {
+        for (String key : components.getCallbacks().keySet())
+        componentsObject.addC(new CallbackTuple(key, CallbackOb.parseCallback(components.getCallbacks().get(key))));
+        }
+        if (components.getExtensions().size() != 0) {
+        for (String key : components.getExtensions().keySet())
+        componentsObject.addEx(new Extension(key, components.getExtensions().get(key)));
+        }
+
+        /* 3.1.0 features
+        if (components.getPathItems() != null) ...
+         */
+
+        return componentsObject;
+        }
+
+public static PathItemOb PathItemOb.parsePath(PathItem path) {
+        PathItemObject pathItem = new PathItemObject();
+
+        if(path.get$ref() != null){
+        PathItemReference r = new PathItemReference();
+        r.setRef(path.get$ref());
+
+      /* 3.1.0 features
+      if (path.getSummary() != null) ...
+      if (path.getDescription() != null) ...
+      if (path.getPathItem() != null) ...
+       */
+
+        return r;
+        } else
+
+        if (path.getSummary() != null)
+        pathItem.setSummary(path.getSummary());
+        if (path.getDescription() != null)
+        pathItem.setDescription(path.getDescription());
+        if (path.getGet() != null) {
+        Get get = new Get();
+        get.set_impl_o(OperationObject.parseOperation(path.getGet()));
+        pathItem.setG(get);
+        }
+        if (path.getPut() != null) {
+        Put put = new Put();
+        put.set_impl_o(OperationObject.parseOperation(path.getPut()));
+        pathItem.setPut(put);
+        }
+        if (path.getPost() != null) {
+        Post post = new Post();
+        post.set_impl_o(OperationObject.parseOperation(path.getPost()));
+        pathItem.setPost(post);
+        }
+        if (path.getDelete() != null) {
+        Delete delete = new Delete();
+        delete.set_impl_o(OperationObject.parseOperation(path.getDelete()));
+        pathItem.set_impl_d(delete);
+        }
+        if (path.getOptions() != null) {
+        Options options = new Options();
+        options.set_impl_o(OperationObject.parseOperation(path.getOptions()));
+        pathItem.set_impl_o(options);
+        }
+        if (path.getHead() != null) {
+        Head head = new Head();
+        head.set_impl_o(OperationObject.parseOperation(path.getHead()));
+        pathItem.setH(head);
+        }
+        if (path.getPatch() != null) {
+        Patch patch = new Patch();
+        patch.set_impl_o(OperationObject.parseOperation(path.getPatch()));
+        pathItem.setP(patch);
+        }
+        if (path.getTrace() != null) {
+        Trace trace = new Trace();
+        trace.set_impl_o(OperationObject.parseOperation(path.getTrace()));
+        pathItem.setT(trace);
+        }
+        if (path.getServers() != null) {
+        for (Server s : path.getServers())
+        pathItem.addS(ServerObject.parseServer(s));
+        }
+        if (path.getParameters() != null) {
+        for (Parameter p : path.getParameters())
+        pathItem.addPo(ParameterOb.parseParameter(p));
+        }
+        if (path.getExtensions().size() != 0) {
+        for (String key : path.getExtensions().keySet())
+        pathItem.addEx(new Extension(key, path.getExtensions().get(key)));
+        }
+
+        return pathItem;
+        }
+
+public static OperationObject OperationObject.parseOperation(io.swagger.v3.oas.models.Operation operation) {
+        OperationObject operationObject = new OperationObject();
+
+        if (operation.getDeprecated() != null)
+        operationObject.setDeprecatedBoolean(operation.getDeprecated());
+        if (operation.getTags() != null) {
+        for (String t : operation.getTags()) {
+        de.tudresden.inf.st.openapi.ast.Tag tag = new de.tudresden.inf.st.openapi.ast.Tag();
+        tag.setTag(t);
+        operationObject.addT(tag);
+        }
+        }
+        if (operation.getSummary() != null)
+        operationObject.setSummary(operation.getSummary());
+        if (operation.getDescription() != null)
+        operationObject.setDescription(operation.getDescription());
+        if (operation.getExternalDocs() != null)
+        operationObject.set_impl_ed(ExternalDocObject.parseExternalDocs(operation.getExternalDocs()));
+        if (operation.getOperationId() != null)
+        operationObject.setOperationID(operation.getOperationId());
+        if (operation.getParameters() != null) {
+        for (Parameter p : operation.getParameters())
+        operationObject.addP(ParameterOb.parseParameter(p));
+        }
+        if (operation.getRequestBody() != null)
+        operationObject.set_impl_rb(RequestBodyOb.parseRequestBody(operation.getRequestBody()));
+        if (operation.getResponses().size() != 0) {
+        ResponsesObject r = new ResponsesObject();
+        for (String key : operation.getResponses().keySet())
+        r.addR(new ResponseTuple(key, ResponseObject.parseResponse(operation.getResponses().get(key))));
+        operationObject.set_impl_r(r);
+        }
+        if (operation.getCallbacks().size() != 0) {
+        for (String key : operation.getCallbacks().keySet())
+        operationObject.addC(new CallbackTuple(key, CallbackObject.parseCallback(operation.getCallbacks().get(key))));
+        }
+        if (operation.getSecurity().size() != 0) {
+        for (io.swagger.v3.oas.models.security.SecurityRequirement s : operation.getSecurity())
+        operationObject.addSr(SecurityRequirementObject.parseSecurityRequirement(s));
+        }
+        if (operation.getServers() != null) {
+        for (Server s : operation.getServers())
+        operationObject.addS(ServerObject.parseServer(s));
+        }
+        if (operation.getExtensions().size() != 0) {
+        for (String key : operation.getExtensions().keySet())
+        operationObject.addEx(new Extension(key, operation.getExtensions().get(key)));
+        }
+
+        return operationObject;
+        }
+
+public static ExternalDocObject ExternalDocObject.parseExternalDocs(ExternalDocumentation externalDocs){
+        ExternalDocObject externalDocObject = new ExternalDocObject();
+
+        if (externalDocs.getDescription() != null)
+        externalDocObject.setDescription(externalDocs.getDescription());
+        if (externalDocs.getUrl() != null)
+        externalDocObject.setUrl(externalDocs.getUrl());
+        if (externalDocs.getExtensions() != null) {
+        for (String key : externalDocs.getExtensions().keySet())
+        externalDocObject.addEx(new Extension(key, externalDocs.getExtensions().get(key)));
+        }
+
+        return externalDocObject;
+        }
+
+public static ParameterOb ParameterOb.parseParameter(Parameter parameter) {
+        ParameterObject parameterObject = new ParameterObject();
+
+        if (parameter.get$ref() != null) {
+        ParameterReference p = new ParameterReference();
+        p.setRef(parameter.get$ref());
+
+      /* 3.1.0 features
+      if (parameter.getSummary() != null) ...
+      if (parameter.getDescription() != null) ...
+      if (parameter.getParameter() != null) ...
+       */
+
+        return p;
+        } else {
+        if (parameter.getName() != null)
+        parameterObject.setName(parameter.getName());
+        if (parameter.getIn() != null)
+        parameterObject.setIn(parameter.getIn());
+        if (parameter.getDescription() != null)
+        parameterObject.setDescription(parameter.getDescription());
+        if (parameter.getDeprecated() != null)
+        parameterObject.setDeprecatedBoolean(parameter.getDeprecated());
+        if (parameter.getStyle() != null)
+        parameterObject.setStyle(parameter.getStyle().toString());
+        if (parameter.getExplode() != null)
+        parameterObject.setExplode(parameter.getExplode());
+        if (parameter.getAllowReserved() != null)
+        parameterObject.setAllowReserved(parameter.getAllowReserved());
+        if (parameter.getSchema() != null)
+        parameterObject.set_impl_s(SchemaOb.parseSchema(parameter.getSchema()));
+        if (parameter.getExample() != null)
+        parameterObject.setExample(parameter.getExample());
+        if (parameter.getExamples() != null) {
+        for (String key : parameter.getExamples().keySet())
+        parameterObject.addE(new ExampleTuple(key, ExampleObject.parseExample(parameter.getExamples().get(key))));
+        }
+        if (parameter.getContent() != null) {
+        for (String key : parameter.getContent().keySet())
+        parameterObject.addC(new ContentTuple(key, MediaTypeObject.parseMediaType(parameter.getContent().get(key))));
+        }
+        if (parameter.getRequired() != null)
+        parameterObject.setRequired(parameter.getRequired());
+        if (parameter.getExtensions().size() != 0) {
+        for (String key : parameter.getExtensions().keySet())
+        parameterObject.addEx(new Extension(key, parameter.getExtensions().get(key)));
+        }
+        }
+
+        return parameterObject;
+        }
+
+public static RequestBodyOb RequestBodyOb.parseRequestBody(RequestBody requestBody) {
+        RequestBodyObject requestBodyObject = new RequestBodyObject();
+
+        if (requestBody.get$ref() != null) {
+        RequestBodyReference r = new RequestBodyReference();
+        r.setRef(requestBody.get$ref());
+
+      /* 3.1.0 features
+      if (requestBody.getSummary() != null) ...
+      if (requestBody.getDescription() != null) ...
+       */
+
+        return r;
+        } else {
+        if (requestBody.getContent() != null) {
+        for (String key : requestBody.getContent().keySet())
+        requestBodyObject.addC(new ContentTuple(key, MediaTypeObject.parseMediaType(requestBody.getContent().get(key))));
+        }
+        if (requestBody.getDescription() != null)
+        requestBodyObject.setDescription(requestBody.getDescription());
+        if (requestBody.getRequired() != null)
+        requestBodyObject.setRequired(requestBody.getRequired());
+        if (requestBody.getExtensions().size() != 0) {
+        for (String key : requestBody.getExtensions().keySet())
+        requestBodyObject.addEx(new Extension(key, requestBody.getExtensions().get(key)));
+        }
+        }
+
+        return requestBodyObject;
+        }
+
+public static MediaTypeObject MediaTypeObject.parseMediaType(MediaType mediaType) {
+        MediaTypeObject mediaTypeObject = new MediaTypeObject();
+
+        if (mediaType.getSchema() != null)
+        mediaTypeObject.set_impl_s(SchemaObject.parseSchema(mediaType.getSchema()));
+        if (mediaType.getExample() != null)
+        mediaTypeObject.setExample(mediaType.getExample());
+        if (mediaType.getExamples().size() != 0) {
+        for (String key : mediaType.getExamples().keySet())
+        mediaTypeObject.addE(new ExampleTuple(key, ExampleObject.parseExample(mediaType.getExamples().get(key))));
+        }
+        if (mediaType.getEncoding().size() != 0) {
+        for (String key : mediaType.getEncoding().keySet())
+        mediaTypeObject.addEn(new EncodingTuple(key, EncodingObject.parseEncoding(mediaType.getEncoding().get(key))));
+        }
+        if (mediaType.getExtensions().size() != 0) {
+        for (String key : mediaType.getExtensions().keySet())
+        mediaTypeObject.addEx(new Extension(key, mediaType.getExtensions().get(key)));
+        }
+
+        return mediaTypeObject;
+        }
+
+public static EncodingObject EncodingObject.parseEncoding(Encoding encodingProperty) {
+        EncodingObject encodingObject = new EncodingObject();
+
+        if (encodingProperty.getContentType() != null)
+        encodingObject.setContentType(encodingProperty.getContentType());
+        if (encodingProperty.getHeaders() != null) {
+        for (String key : encodingProperty.getHeaders().keySet())
+        encodingObject.addH(new HeaderTuple(key, HeaderObject.parseHeader(encodingProperty.getHeaders().get(key))));
+        }
+        if (encodingProperty.getStyle() != null)
+        encodingObject.setStyle(encodingProperty.getStyle().toString());
+        if (encodingProperty.getExplode() != null)
+        encodingObject.setExplode(encodingProperty.getExplode());
+        if (encodingProperty.getAllowReserved() != null)
+        encodingObject.setAllowReserved(encodingProperty.getAllowReserved());
+        if (encodingProperty.getExtensions() != null) {
+        for (String key : encodingProperty.getExtensions().keySet())
+        encodingObject.addEx(new Extension(key, encodingProperty.getExtensions().get(key)));
+        }
+
+        return encodingObject;
+        }
+
+public static ResponseOb ResponseOb.parseResponse(ApiResponse response) {
+        ResponseObject responseObject = new ResponseObject();
+
+        if (response.get$ref() != null) {
+        ResponseReference r = new ResponseReference();
+        r.setRef(response.get$ref());
+
+      /* 3.1.0 features
+      if (response.getSummary() != null) ...
+      if (response.getDescription() != null) ...
+       */
+
+        return r;
+        } else {
+        if (response.getDescription() != null)
+        responseObject.setDescription(response.getDescription());
+        if (response.getHeaders().size() != 0) {
+        for (String key : response.getHeaders().keySet())
+        responseObject.addH(new HeaderTuple(key, HeaderObject.parseHeader(response.getHeaders().get(key))));
+        }
+        if (response.getContent().size() != 0) {
+        for (String key : response.getContent().keySet())
+        responseObject.addC(new ContentTuple(key, MediaTypeObject.parseMediaType(response.getContent().get(key))));
+        }
+        if (response.getLinks().size() != 0) {
+        for (String key : response.getLinks().keySet())
+        responseObject.addL(new LinkTuple(key, LinkOb.parseLink(response.getLinks().get(key))));
+        }
+        if (response.getExtensions().size() != 0) {
+        for (String key : response.getExtensions().keySet())
+        responseObject.addEx(new Extension(key, response.getExtensions().get(key)));
+        }
+        }
+
+        return responseObject;
+        }
+
+public static CallbackOb CallbackOb.parseCallback(Callback callback) {
+        CallbackObject callbackObject = new CallbackObject();
+
+        if (callback.get$ref() != null) {
+        CallbackReference c = new CallbackReference();
+        c.setRef(callback.get$ref());
+
+      /* 3.1.0 features
+      if (callback.getSummary() != null) ...
+      if (callback.getDescription() != null) ...
+       */
+
+        return c;
+        } else {
+        if (callback.size() != 0) {
+        for (String key : callback.keySet())
+        callbackObject.addE(new Expression(key, PathItemObject.parsePath(callback.get(key))));
+        }
+        if (callback.getExtensions().size() != 0) {
+        for (String key : callback.getExtensions().keySet())
+        callbackObject.addEx(new Extension(key, callback.getExtensions().get(key)));
+        }
+        }
+
+        return callbackObject;
+        }
+
+public static ExampleObject ExampleObject.parseExample(Example example){
+        ExampleObject exampleObject = new ExampleObject();
+
+        if (example.getSummary() != null)
+        exampleObject.setSummary(example.getSummary());
+        if (example.getDescription() != null)
+        exampleObject.setDescription(example.getDescription());
+        if (example.getValue() != null)
+        exampleObject.setValue(example.getValue());
+        if (example.getExternalValue() != null)
+        exampleObject.setExternalValue(example.getExternalValue());
+        if (example.getExtensions().size() != 0) {
+        for (String key : example.getExtensions().keySet())
+        exampleObject.addEx(new Extension(key, example.getExtensions().get(key)));
+        }
+
+        return exampleObject;
+        }
+
+public static LinkOb LinkOb.parseLink(Link link) {
+        LinkObject linkObject = new LinkObject();
+
+        if (link.get$ref() != null) {
+        LinkReference l = new LinkReference();
+        l.setRef(link.get$ref());
+
+      /* 3.1.0 features
+      if (link.getSummary() != null) ...
+      if (link.getDescription() != null) ...
+       */
+
+        return l;
+        } else {
+        if (link.getOperationRef() != null)
+        linkObject.setOperationRef(link.getOperationRef());
+        if (link.getOperationId() != null)
+        linkObject.setOperationID(link.getOperationId());
+        if (link.getParameters().size() != 0) {
+        for (String key : link.getParameters().keySet())
+        linkObject.addL(new LinkParameterTuple(key, link.getParameters().get(key)));
+        }
+        if (link.getDescription() != null)
+        linkObject.setDescription(link.getDescription());
+        if (link.getServer() != null)
+        linkObject.set_impl_s(ServerObject.parseServer(link.getServer()));
+        if (link.getExtensions().size() != 0) {
+        for (String key : link.getExtensions().keySet())
+        linkObject.addEx(new Extension(key, link.getExtensions().get(key)));
+        }
+        }
+
+        return linkObject;
+        }
+
+public static HeaderOb HeaderOb.parseHeader(Header header) {
+        HeaderObject headerObject = new HeaderObject();
+
+        if (header.get$ref() != null) {
+        HeaderReference h = new HeaderReference();
+        h.setRef(header.get$ref());
+
+      /* 3.1.0 features
+      if (header.getSummary() != null) ...
+      if (header.getDescription() != null) ...
+       */
+
+        return h;
+        } else {
+        if (header.getRequired() != null)
+        headerObject.setRequired(header.getRequired());
+        if (header.getDescription() != null)
+        headerObject.setDescription(header.getDescription());
+        if (header.getDeprecated() != null)
+        headerObject.setDeprecatedBoolean(header.getDeprecated());
+        if (header.getStyle() != null)
+        headerObject.setStyle(header.getStyle().toString());
+        if (header.getExplode() != null)
+        headerObject.setExplode(header.getExplode());
+        if (header.getExample() != null)
+        headerObject.setExample(header.getExample());
+        if (header.getExamples().size() != 0) {
+        for (String key : header.getExamples().keySet())
+        headerObject.addE(new ExampleTuple(key, ExampleObject.parseExample(header.getExamples().get(key))));
+        }
+        if (header.getContent().size() != 0) {
+        for (String key : header.getContent().keySet())
+        headerObject.addC(new ContentTuple(key, MediaTypeObject.parseMediaType(header.getContent().get(key))));
+        }
+        if (header.getSchema() != null)
+        headerObject.set_impl_s(SchemaOb.parseSchema(header.getSchema()));
+        if (header.getExtensions() != null) {
+        for (String key : header.getExtensions().keySet())
+        headerObject.addEx(new Extension(key, header.getExtensions().get(key)));
+        }
+        }
+
+        return headerObject;
+        }
+
+public static TagObject TagObject.parseTag(io.swagger.v3.oas.models.tags.Tag tag){
+        TagObject tagObject = new TagObject();
+
+        tagObject.setName(tag.getName());
+
+        if (tag.getDescription() != null)
+        tagObject.setDescription(tag.getDescription());
+        if (tag.getExternalDocs() != null)
+        tagObject.set_impl_e(ExternalDocObject.parseExternalDocs(tag.getExternalDocs()));
+        if (tag.getExtensions().size() != 0) {
+        for (String key : tag.getExtensions().keySet())
+        tagObject.addEx(new Extension(key, tag.getExtensions().get(key)));
+        }
+
+        return tagObject;
+        }
+
+public static SchemaOb SchemaOb.parseSchema (Schema<?> schema) {
+        SchemaObject schemaObject = new SchemaObject();
+
+        if (schema.get$ref() != null) {
+        SchemaReference s = new SchemaReference();
+        s.setRef(schema.get$ref());
+
+      /* 3.1.0 features
+      if (schema.getSummary() != null) ...
+      if (schema.getDescription() != null) ...
+       */
+
+        return s;
+        } else {
+        if (schema.getAdditionalProperties() != null)
+        schemaObject.setAdditionalProperties(schema.getAdditionalProperties());
+        if (schema.getDefault() != null)
+        schemaObject.setDefaultValue(schema.getDefault());
+        if (schema.getDescription() != null)
+        schemaObject.setDescription(schema.getDescription());
+        if (schema.getDeprecated() != null)
+        schemaObject.setDeprecatedBoolean(schema.getDeprecated());
+        if (schema.getDiscriminator() != null)
+        schemaObject.setD(DiscriminatorObject.parseDiscriminator(schema.getDiscriminator()));
+        if (schema.getEnum() != null) {
+        for (Object o : schema.getEnum()) {
+        EnumObj enumObj = new EnumObj();
+        enumObj.setEnumOb(o);
+        schemaObject.addE(enumObj);
+        }
+        }
+        // in 3.1.0, there are multiple examples
+        if (schema.getExample() != null)
+        schemaObject.addEl(new ExampleElement(schema.getExample()));
+      /* in 3.1.0, types are Number instead of Boolean
+      if (schema.getExclusiveMaximum() != null)
+        schemaObject.setExclusiveMaximum(schema.getExclusiveMaximum());
+      if (schema.getExclusiveMinimum() != null)
+        schemaObject.setExclusiveMinimum(schema.getExclusiveMinimum());
+       */
+        if (schema.getExternalDocs() != null)
+        schemaObject.setExt(ExternalDocObject.parseExternalDocs(schema.getExternalDocs()));
+        if (schema.getFormat() != null)
+        schemaObject.setFormat(schema.getFormat());
+        if (schema.getMaximum() != null)
+        schemaObject.setMaximum(schema.getMaximum());
+        if (schema.getMinimum() != null)
+        schemaObject.setMinimum(schema.getMinimum());
+        if (schema.getMaxItems() != null)
+        schemaObject.setMaxItems(schema.getMaxItems());
+        if (schema.getMinItems() != null)
+        schemaObject.setMinItems(schema.getMinItems());
+        if (schema.getMaxLength() != null)
+        schemaObject.setMaxLength(schema.getMaxLength());
+        if (schema.getMinLength() != null)
+        schemaObject.setMinLength(schema.getMinLength());
+        if (schema.getMaxProperties() != null)
+        schemaObject.setMaxProperties(schema.getMaxProperties());
+        if (schema.getMinProperties() != null)
+        schemaObject.setMinProperties(schema.getMinProperties());
+        if (schema.getMultipleOf() != null)
+        schemaObject.setMultipleOf(schema.getMultipleOf());
+        if (schema.getNot() != null) {
+        NotSchema notSchema = new NotSchema();
+        notSchema.set_impl_s(parseSchema(schema.getNot()));
+        schemaObject.set_impl_n(notSchema);
+        }
+        if (schema.getPattern() != null)
+        schemaObject.setPattern(schema.getPattern());
+        if (schema.getProperties().size() != 0) {
+        for (String key : schema.getProperties().keySet()) {
+        PropertyItem propertyItem = new PropertyItem();
+        schemaObject.addP(new PropertyItem(key, parseSchema(schema.getProperties().get(key))));
+        }
+        }
+        if (schema.getRequired().size() != 0) {
+        for (String s : schema.getRequired()) {
+        RequiredField requiredField = new RequiredField();
+        requiredField.setValue(s);
+        schemaObject.addR(requiredField);
+        }
+        }
+      /* Schemas not supported (maybe supported in 3.1.0)
+      if (schema.getItemsSchema() != null) {
+        ItemsSchema itemsSchema = new ItemsSchema();
+        itemsSchema.setSchemaOb(parseSchema(schema.getItemsSchema(), context, map));
+        schemaObject.setItemsSchema(itemsSchema);
+      }
+      if (schema.getAllOfSchemas() != null) {
+        for (org.openapi4j.parser.model.v3.Schema schemaItem : schema.getAllOfSchemas()) {
+          AllOfSchema allOfSchema = new AllOfSchema();
+          allOfSchema.setSchemaOb(parseSchema(schemaItem, context, map));
+          schemaObject.addAllOfSchema(allOfSchema);
+        }
+      }
+      if (schema.getAnyOfSchemas() != null) {
+        for (org.openapi4j.parser.model.v3.Schema schemaItem : schema.getAnyOfSchemas()) {
+          AnyOfSchema anyOfSchema = new AnyOfSchema();
+          anyOfSchema.setSchemaOb(parseSchema(schemaItem, context, map));
+          schemaObject.addAnyOfSchema(anyOfSchema);
+        }
+      }
+      if (schema.getOneOfSchemas() != null) {
+        for (org.openapi4j.parser.model.v3.Schema schemaItem : schema.getOneOfSchemas()) {
+          OneOfSchema oneOfSchema = new OneOfSchema();
+          oneOfSchema.setSchemaOb(parseSchema(schemaItem, context, map));
+          schemaObject.addOneOfSchema(oneOfSchema);
+        }
+      }
+       */
+        if (schema.getReadOnly() != null)
+        schemaObject.setReadOnly(schema.getReadOnly());
+        if (schema.getWriteOnly() != null)
+        schemaObject.setWriteOnly(schema.getWriteOnly());
+        if (schema.getType() != null)
+        schemaObject.setType(schema.getType());
+        if (schema.getTitle() != null)
+        schemaObject.setTitle(schema.getTitle());
+        if (schema.getUniqueItems() != null)
+        schemaObject.setUniqueItems(schema.getUniqueItems());
+        if (schema.getXml() != null)
+        schemaObject.setX(XmlObject.parseXml(schema.getXml()));
+        if (schema.getExtensions().size() != 0) {
+        for (String key : schema.getExtensions().keySet())
+        schemaObject.addEx(new Extension(key, schema.getExtensions().get(key)));
+        }
+        }
+
+        return schemaObject;
+        }
+
+public static DiscriminatorObject DiscriminatorObject.parseDiscriminator (Discriminator discriminator) {
+        DiscriminatorObject discriminatorObject = new DiscriminatorObject();
+
+        if (discriminator.getPropertyName() != null)
+        discriminatorObject.setPropertyName(discriminator.getPropertyName());
+        if (discriminator.getMapping() != null) {
+        MappingTuple mapping = new MappingTuple();
+        for (String key : discriminator.getMapping().keySet()) {
+        mapping.setKey(key);
+        mapping.setValue(discriminator.getMapping().get(key));
+        discriminatorObject.addM(mapping);
+        }
+        }
+
+        return discriminatorObject;
+        }
+
+public static XmlObject XmlObject.parseXml (XML xml) {
+        XmlObject xmlObject = new XmlObject();
+
+        if (xml.getName() != null)
+        xmlObject.setName(xml.getName());
+        if (xml.getNamespace() != null)
+        xmlObject.setNamespace(xml.getNamespace());
+        if (xml.getPrefix() != null)
+        xmlObject.setPrefix(xml.getPrefix());
+        if (xml.getAttribute() != null)
+        xmlObject.setAttribute(xml.getAttribute());
+        if (xml.getWrapped() != null)
+        xmlObject.setWrapped(xml.getWrapped());
+        if (xml.getExtensions() != null) {
+        for (String key : xml.getExtensions().keySet())
+        xmlObject.addEx(new Extension(key, xml.getExtensions().get(key)));
+        }
+
+        return xmlObject;
+        }
+
+public static SecuritySchemeOb SecuritySchemeOb.parseSecurityScheme(SecurityScheme securityScheme){
+        SecuritySchemeObject securitySchemeObject = new SecuritySchemeObject();
+
+        if(securityScheme.get$ref() != null){
+        SecuritySchemeReference r = new SecuritySchemeReference();
+        r.setRef(securityScheme.get$ref());
+
+      /* 3.1.0 features
+      if (securityScheme.getSummary() != null) ...
+      if (securityScheme.getDescription() != null) ...
+       */
+
+        return r;
+        } else {
+        if (securityScheme.getType() != null)
+        securitySchemeObject.setType(securityScheme.getType().toString());
+        if (securityScheme.getName() != null)
+        securitySchemeObject.setName(securityScheme.getName());
+        if (securityScheme.getIn() != null)
+        securitySchemeObject.setIn(securityScheme.getIn().toString());
+        if (securityScheme.getScheme() != null)
+        securitySchemeObject.setScheme(securityScheme.getScheme());
+        if (securityScheme.getOpenIdConnectUrl() != null)
+        securitySchemeObject.setOpenIdConnectUrl(securityScheme.getOpenIdConnectUrl());
+        if (securityScheme.getFlows() != null)
+        securitySchemeObject.setO(OAuthFlowsObject.parseOAuthFlows(securityScheme.getFlows()));
+        if (securityScheme.getDescription() != null)
+        securitySchemeObject.setDescription(securityScheme.getDescription());
+        if (securityScheme.getBearerFormat() != null)
+        securitySchemeObject.setBearerFormat(securityScheme.getBearerFormat());
+        if (securityScheme.getExtensions() != null) {
+        for (String key : securityScheme.getExtensions().keySet())
+        securitySchemeObject.addEx(new Extension(key, securityScheme.getExtensions().get(key)));
+        }
+        }
+
+        return securitySchemeObject;
+        }
+
+public static OAuthFlowsObject OAuthFlowsObject.parseOAuthFlows(OAuthFlows oAuthFlows){
+        OAuthFlowsObject oAuthFlowsObject = new OAuthFlowsObject();
+        Implicit implicit = new Implicit();
+        Password password = new Password();
+        ClientCredentials clientCredentials = new ClientCredentials();
+        AuthorizationCode authorizationCode = new AuthorizationCode();
+
+        if (oAuthFlows.getImplicit() != null) {
+        implicit.set_impl_o(OAuthFlowObject.parseOAuthFlow(oAuthFlows.getImplicit()));
+        oAuthFlowsObject.set_impl_i(implicit);
+        }
+        if (oAuthFlows.getPassword() != null) {
+        password.set_impl_o(OAuthFlowObject.parseOAuthFlow(oAuthFlows.getPassword()));
+        oAuthFlowsObject.set_impl_p(password);
+        }
+        if (oAuthFlows.getClientCredentials() != null) {
+        clientCredentials.set_impl_o(OAuthFlowObject.parseOAuthFlow(oAuthFlows.getClientCredentials()));
+        oAuthFlowsObject.set_impl_c(clientCredentials);
+        }
+        if (oAuthFlows.getAuthorizationCode() != null) {
+        authorizationCode.set_impl_o(OAuthFlowObject.parseOAuthFlow(oAuthFlows.getAuthorizationCode()));
+        oAuthFlowsObject.set_impl_a(authorizationCode);
+        }
+        if (oAuthFlows.getExtensions() != null) {
+        for (String key : oAuthFlows.getExtensions().keySet())
+        oAuthFlowsObject.addEx(new Extension(key, oAuthFlows.getExtensions().get(key)));
+        }
+
+        return oAuthFlowsObject;
+        }
+
+public static OAuthFlowObject OAuthFlowObject.parseOAuthFlow(OAuthFlow oAuthFlow){
+        OAuthFlowObject oAuthFlowObject = new OAuthFlowObject();
+
+        if (oAuthFlow.getAuthorizationUrl() != null)
+        oAuthFlowObject.setAuthorizationUrl(oAuthFlow.getAuthorizationUrl());
+        if (oAuthFlow.getTokenUrl() != null)
+        oAuthFlowObject.setTokenUrl(oAuthFlow.getTokenUrl());
+        for (String key : oAuthFlow.getScopes().keySet())
+        oAuthFlowObject.addS(new ScopesTuple(key, oAuthFlow.getScopes().get(key)));
+        if (oAuthFlow.getRefreshUrl() != null)
+        oAuthFlowObject.setRefreshUrl(oAuthFlow.getRefreshUrl());
+        if (oAuthFlow.getExtensions() != null) {
+        for (String key : oAuthFlow.getExtensions().keySet())
+        oAuthFlowObject.addEx(new Extension(key, oAuthFlow.getExtensions().get(key)));
+        }
+
+        return oAuthFlowObject;
+        }
+
+public static SecurityRequirementObject SecurityRequirementObject.parseSecurityRequirement(io.swagger.v3.oas.models.security.SecurityRequirement securityRequirement){
+        SecurityRequirementObject securityRequirementObject = new SecurityRequirementObject();
+
+        if (securityRequirement != null) {
+        for (String key : securityRequirement.keySet()) {
+        List<SecurityRequirementValue> values = new ArrayList<>();
+        for (String v : securityRequirement.get(key))
+        values.add(new SecurityRequirementValue(v));
+        securityRequirementObject.addT(new SecurityRequirementTuple(key, values));
+        }
+        }
+
+        return securityRequirementObject;
+        }
+        }
diff --git a/src/main/jastadd/ReverseParser.jrag b/src/main/jastadd/ReverseParser.jrag
new file mode 100644
index 00000000..a70fc669
--- /dev/null
+++ b/src/main/jastadd/ReverseParser.jrag
@@ -0,0 +1,976 @@
+import java.util.*;
+aspect ReverseParser {
+
+public static OpenAPI OpenAPIObject.reverseOpenAPI (OpenAPIObject openapi){
+        OpenAPI api = new OpenAPI();
+
+        if (!openapi.getOpenAPI().isEmpty())
+        api.setOpenapi(openapi.getOpenAPI());
+        if (openapi.hasI())
+        api.setInfo(InfoObject.reverseInfo(openapi.get_impl_i()));
+        if (openapi.get_impl_s().size() != 0) {
+        List<Server> servers = new ArrayList<>();
+        for (ServerObject s : openapi.get_impl_s())
+        servers.add(ServerObject.reverseServer(s));
+        api.setServers(servers);
+        }
+        if (openapi.get_impl_p().size() != 0) {
+        Paths paths = new Paths();
+        for (PathsObject p : openapi.getPList()){
+        //if (p.get_impl_p() instanceof PathItemObject)
+        //paths.addPathItem(p.getRef(), PathIte)
+        }
+        api.setPaths(paths);
+        }
+        if (openapi.hasC())
+        api.setComponents(ComponentsObject.reverseComponents(openapi.get_impl_c()));
+        if (openapi.getSrList().size() != 0) {
+        List<io.swagger.v3.oas.models.security.SecurityRequirement> securityRequirements = new ArrayList<>();
+        for (SecurityRequirementObject s : openapi.getSrList())
+        securityRequirements.add(SecurityRequirementObject.reverseSecurityRequirement(s));
+        api.setSecurity(securityRequirements);
+        }
+        if (openapi.getTList().size() != 0) {
+        List<io.swagger.v3.oas.models.tags.Tag> tags = new ArrayList<>();
+        for (TagObject t : openapi.getTList())
+        tags.add(TagObject.reverseTag(t));
+        api.setTags(tags);
+        }
+        if (openapi.hasE())
+        api.setExternalDocs(ExternalDocObject.reverseExternalDocs(openapi.getE()));
+        if (openapi.getExList().size() != 0) {
+        Map<String, Object> extensionMap = new HashMap<>();
+        for (Extension e : openapi.getExList())
+        extensionMap.put(e.getKey(), e.getValue());
+        api.setExtensions(extensionMap);
+        }
+
+        /* 3.1.0 features
+    if (openapi.getWebhook != null) ...
+    if (openapi.getJsonSchemaDialect != null) ...
+     */
+
+        return api;
+        }
+
+public static io.swagger.v3.oas.models.info.Info InfoObject.reverseInfo (InfoObject infoObject){
+        io.swagger.v3.oas.models.info.Info info = new io.swagger.v3.oas.models.info.Info();
+
+        if (!infoObject.getTitle().isEmpty())
+        info.setTitle(infoObject.getTitle());
+        if (!infoObject.getVersion().isEmpty())
+        info.setVersion(infoObject.getVersion());
+        if (!infoObject.getDescription().isEmpty())
+        info.setDescription(infoObject.getDescription());
+        if (!infoObject.getTermsOfService().isEmpty())
+        info.setTermsOfService(infoObject.getTermsOfService());
+        if (infoObject.hasC())
+        info.setContact(ContactObject.reverseContact(infoObject.get_impl_c()));
+        if (infoObject.hasL())
+        info.setLicense(LicenseObject.reverseLicense(infoObject.get_impl_l()));
+        if (infoObject.getExList().size() != 0) {
+        Map<String, Object> extension = new HashMap<>();
+        for (Extension e : infoObject.getExList())
+        extension.put(e.getKey(), e.getValue());
+        info.setExtensions(extension);
+        }
+
+        return info;
+        }
+
+public static io.swagger.v3.oas.models.info.Contact ContactObject.reverseContact (ContactObject contactObject){
+        io.swagger.v3.oas.models.info.Contact contact = new io.swagger.v3.oas.models.info.Contact();
+
+        if (!contactObject.getName().isEmpty())
+        contact.setName(contactObject.getName());
+        if (!contactObject.getUrl().isEmpty())
+        contact.setUrl(contactObject.getUrl());
+        if (!contactObject.getEmail().isEmpty())
+        contact.setEmail(contactObject.getEmail());
+        if (contactObject.getExList().size() != 0) {
+        Map<String, Object> extensions = new HashMap<>();
+        for (Extension e : contactObject.getExList())
+        extensions.put(e.getKey(), e.getValue());
+        contact.setExtensions(extensions);
+        }
+
+        return contact;
+        }
+
+public static io.swagger.v3.oas.models.info.License LicenseObject.reverseLicense (LicenseObject licenseObject){
+        io.swagger.v3.oas.models.info.License license = new io.swagger.v3.oas.models.info.License();
+
+        if (!licenseObject.getName().isEmpty())
+        license.setName(licenseObject.getName());
+        if (!licenseObject.getUrl().isEmpty())
+        license.setUrl(licenseObject.getUrl());
+        if (licenseObject.getExList().size() != 0) {
+        Map<String, Object> extensions = new HashMap<>();
+        for (Extension e : licenseObject.getExList())
+        extensions.put(e.getKey(), e.getValue());
+        license.setExtensions(extensions);
+        }
+
+        return license;
+        }
+
+public static Server ServerObject.reverseServer (ServerObject serverObject){
+        Server server = new Server();
+
+        if (!serverObject.getUrl().isEmpty())
+        server.setUrl(serverObject.getUrl());
+        if (!serverObject.getDescription().isEmpty())
+        server.setDescription(serverObject.getDescription());
+        if (serverObject.get_impl_st().size() != 0) {
+        ServerVariables serverVariables = new ServerVariables();
+        for (ServerVariablesTuple s : serverObject.get_impl_st())
+        serverVariables.addServerVariable(s.getName(), ServerVariableObject.reverseServerVariable(s.get_impl_s()));
+        server.setVariables(serverVariables);
+        }
+        if (serverObject.getExList().size() != 0) {
+        Map<String, Object> extensions = new HashMap<>();
+        for (Extension e : serverObject.getExList())
+        extensions.put(e.getKey(), e.getValue());
+        server.setExtensions(extensions);
+        }
+
+        return server;
+        }
+
+public static ServerVariable ServerVariableObject.reverseServerVariable (ServerVariableObject serverVariableObject){
+        ServerVariable serverVariable = new ServerVariable();
+
+        if (!serverVariableObject.getDefault().isEmpty())
+        serverVariable.setDefault(serverVariableObject.getDefault());
+        if (!serverVariableObject.getDescription().isEmpty())
+        serverVariable.setDescription(serverVariableObject.getDescription());
+        if (serverVariableObject.get_impl_e().size() != 0) {
+        List<String> enums = new ArrayList<>();
+        for (Enum e : serverVariableObject.getEList())
+        enums.add(e.getEnumValue());
+        serverVariable.setEnum(enums);
+        }
+        if (serverVariableObject.getEList().size() != 0) {
+        Map<String, Object> extensions = new HashMap<>();
+        for (Extension e : serverVariableObject.getExList())
+        extensions.put(e.getKey(), e.getValue());
+        serverVariable.setExtensions(extensions);
+        }
+
+        return serverVariable;
+        }
+
+public static Components ComponentsObject.reverseComponents (ComponentsObject componentsObject){
+        Components components = new Components();
+
+        if (componentsObject.getSList().size() != 0) {
+        Map<String, io.swagger.v3.oas.models.media.Schema> schemaMap = new HashMap<>();
+        SchemaOb s;
+        for (SchemaTuple t : componentsObject.getSList()) {
+        s = t.get_impl_o();
+        if (s instanceof SchemaObject)
+        schemaMap.put(t.getKey(), ((SchemaObject) s).reverseSchema(s));
+        else
+        schemaMap.put(t.getKey(), ((SchemaReference) s).reverseSchema(s));
+        }
+        components.setSchemas(schemaMap);
+        }
+        if (componentsObject.getRList().size() != 0) {
+        Map<String, ApiResponse> responseMap = new HashMap<>();
+        ResponseOb r;
+        for (ResponseTuple t : componentsObject.getRList()) {
+        r = t.get_impl_o();
+        responseMap.put(t.getKey(), r.reverseResponse(r));
+        }
+        components.setResponses(responseMap);
+        }
+        if (componentsObject.getPList().size() != 0) {
+        Map<String, Parameter> parameterMap = new HashMap<>();
+        ParameterOb p;
+        for (ParameterTuple t : componentsObject.getPList()) {
+        p = t.get_impl_o();
+        parameterMap.put(t.getKey(), p.reverseParameter(p));
+        }
+        components.setParameters(parameterMap);
+        }
+        if (componentsObject.getEList().size() != 0) {
+        Map<String, Example> exampleMap = new HashMap<>();
+        for (ExampleTuple t : componentsObject.getEList())
+        exampleMap.put(t.getKey(), ExampleObject.reverseExample(t.get_impl_o()));
+        components.setExamples(exampleMap);
+        }
+        if (componentsObject.getRbList().size() != 0) {
+        Map<String, RequestBody> requestBodyMap = new HashMap<>();
+        RequestBodyOb r;
+        for (RequestBodyTuple t : componentsObject.getRbList()) {
+        r = t.get_impl_o();
+        requestBodyMap.put(t.getKey(), r.reverseRequestBody(r));
+        }
+        components.setRequestBodies(requestBodyMap);
+        }
+        if (componentsObject.getHList().size() != 0) {
+        Map<String, Header> headerMap = new HashMap<>();
+        HeaderOb h;
+        for (HeaderTuple t : componentsObject.getHList()) {
+        h = t.get_impl_o();
+        headerMap.put(t.getKey(), h.reverseHeader(h));
+        }
+        components.setHeaders(headerMap);
+        }
+        if (componentsObject.getScList().size() != 0) {
+        Map<String, SecurityScheme> securitySchemeMap = new HashMap<>();
+        SecuritySchemeOb s;
+        for (SecuritySchemeTuple t : componentsObject.getScList()) {
+        s = t.get_impl_o();
+        securitySchemeMap.put(t.getKey(), s.reverseSecurityScheme(s));
+        }
+        components.setSecuritySchemes(securitySchemeMap);
+        }
+        if (componentsObject.getLList().size() != 0) {
+        Map<String, Link> linkMap = new HashMap<>();
+        LinkOb l;
+        for (LinkTuple t : componentsObject.getLList()) {
+        l = t.get_impl_o();
+        linkMap.put(t.getKey(), l.reverseLink(l));
+        }
+        components.setLinks(linkMap);
+        }
+        if (componentsObject.getCList().size() != 0) {
+        Map<String, Callback> callbackMap = new HashMap<>();
+        CallbackOb c;
+        for (CallbackTuple t : componentsObject.getCList()) {
+        c = t.get_impl_o();
+        callbackMap.put(t.getKey(), c.reverseCallback(c));
+        }
+        components.setCallbacks(callbackMap);
+        }
+        if (componentsObject.getExList().size() != 0) {
+        Map<String, Object> extensions = new HashMap<>();
+        for (Extension e : componentsObject.getExList())
+        extensions.put(e.getKey(), e.getValue());
+        components.setExtensions(extensions);
+        }
+
+        return components;
+        }
+
+        syn PathItem PathItemOb.reversePath (PathItemOb pathItemOb);
+        eq PathItemReference.reversePath (PathItemOb pathItemOb) {
+        PathItem pathItem = new PathItem();
+        PathItemReference p = (PathItemReference) pathItemOb;
+
+        /* implement after reference implementation
+        if (!p.getRef().isEmpty()) {
+        try {
+        parameter.setReference(new org.openapi4j.core.model.v3.OAI3Context(new URL("")), new URL(""), p.getRef());
+        } catch (Exception e) {
+        e.printStackTrace();
+        }
+        }
+         */
+
+        return pathItem;
+        }
+        eq PathItemObject.reversePath (PathItemOb pathItemOb) {
+        PathItem path = new PathItem();
+        PathItemObject p = (PathItemObject) pathItemOb;
+
+        if (!p.getSummary().isEmpty())
+        path.setSummary(p.getSummary());
+        if (!p.getDescription().isEmpty())
+        path.setDescription(p.getDescription());
+        if (p.hasG())
+        path.setGet(OperationObject.reverseOperation(p.getG().get_impl_o()));
+        if (p.hasPut())
+        path.setPut(OperationObject.reverseOperation(p.getPut().get_impl_o()));
+        if (p.hasPost())
+        path.setPost(OperationObject.reverseOperation(p.getPost().get_impl_o()));
+        if (p.hasD())
+        path.setDelete(OperationObject.reverseOperation(p.getD().get_impl_o()));
+        if (p.hasO())
+        path.setOptions(OperationObject.reverseOperation(p.getO().get_impl_o()));
+        if (p.hasH())
+        path.setHead(OperationObject.reverseOperation(p.getH().get_impl_o()));
+        if (p.hasP())
+        path.setPatch(OperationObject.reverseOperation(p.getP().get_impl_o()));
+        if (p.getSList().size() != 0) {
+        for (ServerObject s : p.getSList())
+        path.addServersItem(ServerObject.reverseServer(s));
+        }
+        if (p.getPoList().size() != 0) {
+        for (ParameterOb e : p.getPoList())
+        path.addParametersItem(e.reverseParameter(e));
+        }
+        if (p.getExList().size() != 0) {
+        Map<String, Object> extensionMap = new HashMap<>();
+        for (Extension e : p.getExList())
+        extensionMap.put(e.getKey(), e.getValue());
+        path.setExtensions(extensionMap);
+        }
+
+        return path;
+        }
+
+public static io.swagger.v3.oas.models.Operation OperationObject.reverseOperation (OperationObject operationObject){
+        io.swagger.v3.oas.models.Operation operation = new io.swagger.v3.oas.models.Operation();
+
+        if (operationObject.getTList().size() != 0) {
+        for (de.tudresden.inf.st.openapi.ast.Tag t : operationObject.getTList())
+        operation.addTagsItem(t.getTag());
+        }
+        if (!operationObject.getSummary().isEmpty())
+        operation.setSummary(operationObject.getSummary());
+        if (!operationObject.getDescription().isEmpty())
+        operation.setDescription(operationObject.getDescription());
+        if (operationObject.hasEd())
+        operation.setExternalDocs(ExternalDocObject.reverseExternalDocs(operationObject.get_impl_ed()));
+        if (!operationObject.getOperationID().isEmpty())
+        operation.setOperationId(operationObject.getOperationID());
+        if (operationObject.getPList().size() != 0) {
+        for (ParameterOb p : operationObject.getPList())
+        operation.addParametersItem(p.reverseParameter(p));
+        }
+        if (operationObject.hasRb())
+        operation.setRequestBody(operationObject.get_impl_rb().reverseRequestBody(operationObject.get_impl_rb()));
+        if (operationObject.getR().getRList().size() != 0) {
+        ApiResponses responses = new ApiResponses();
+        for (ResponseTuple t : operationObject.getR().getRList())
+        responses.put(t.getKey(), t.get_impl_o().reverseResponse(t.get_impl_o()));
+        operation.setResponses(responses);
+        }
+        if (operationObject.getCList().size() != 0) {
+        Map<String, Callback> callbacks = new HashMap<>();
+        for (CallbackTuple t : operationObject.getCList())
+        callbacks.put(t.getKey(), t.get_impl_o().reverseCallback(t.get_impl_o()));
+        operation.setCallbacks(callbacks);
+        }
+        if (operationObject.getDeprecatedBoolean() != null)
+        operation.setDeprecated(operationObject.getDeprecatedBoolean());
+        if (operationObject.getSrList().size() != 0) {
+        for (SecurityRequirementObject s : operationObject.getSrList())
+        operation.addSecurityItem(SecurityRequirementObject.reverseSecurityRequirement(s));
+        }
+        if (operationObject.getSList().size() != 0) {
+        for (ServerObject s : operationObject.getSList())
+        operation.addServersItem(ServerObject.reverseServer(s));
+        }
+        if (operationObject.getExList().size() != 0) {
+        Map<String, Object> extensionMap = new HashMap<>();
+        for (Extension e : operationObject.getExList())
+        extensionMap.put(e.getKey(), e.getValue());
+        operation.setExtensions(extensionMap);
+        }
+
+        return operation;
+        }
+
+public static io.swagger.v3.oas.models.ExternalDocumentation ExternalDocObject.reverseExternalDocs (ExternalDocObject externalDocObject){
+        ExternalDocumentation externalDocs = new ExternalDocumentation();
+
+        if (!externalDocObject.getDescription().isEmpty())
+        externalDocs.setDescription(externalDocObject.getDescription());
+        if (!externalDocObject.getUrl().isEmpty())
+        externalDocs.setUrl(externalDocObject.getUrl());
+        if (externalDocObject.getExList().size() != 0) {
+        Map<String, Object> extensionMap = new HashMap<>();
+        for (Extension e : externalDocObject.getExList())
+        extensionMap.put(e.getKey(), e.getValue());
+        externalDocs.setExtensions(extensionMap);
+        }
+
+        return externalDocs;
+        }
+
+        syn io.swagger.v3.oas.models.parameters.Parameter ParameterOb.reverseParameter (ParameterOb parameterOb);
+        eq ParameterReference.reverseParameter (ParameterOb parameterOb) {
+        io.swagger.v3.oas.models.parameters.Parameter parameter = new io.swagger.v3.oas.models.parameters.Parameter();
+        ParameterReference p = (ParameterReference) parameterOb;
+
+        if (!p.getRef().isEmpty()) {
+        parameter.set$ref(p.getRef());
+        }
+
+        return parameter;
+        }
+        eq ParameterObject.reverseParameter (ParameterOb parameterOb) {
+        io.swagger.v3.oas.models.parameters.Parameter parameter = new io.swagger.v3.oas.models.parameters.Parameter();
+        ParameterObject p = (ParameterObject) parameterOb;
+
+        if (!p.getName().isEmpty())
+        parameter.setName(p.getName());
+        if (!p.getIn().isEmpty())
+        parameter.setIn(p.getIn());
+        if (p.getRequired() != null)
+        parameter.setRequired(p.getRequired());
+        if (!p.getDescription().isEmpty())
+        parameter.setDescription(p.getDescription());
+        if (p.getDeprecatedBoolean() != null)
+        parameter.setDeprecated(p.getDeprecatedBoolean());
+        if (!p.getStyle().isEmpty())
+        parameter.setStyle(Parameter.StyleEnum.valueOf(p.getStyle()));
+        if (p.getAllowReserved() != null)
+        parameter.setAllowReserved(p.getAllowReserved());
+        if (p.getExplode() != null)
+        parameter.setExplode(p.getExplode());
+        if (p.getS() != null)
+        parameter.setSchema(p.get_impl_s().reverseSchema(p.get_impl_s()));
+        if (p.getExample() != null)
+        parameter.setExample(p.getExample());
+        if (p.getEList().size() != 0) {
+        Map<String, Example> exampleMap = new HashMap<>();
+        for (ExampleTuple t : p.getEList())
+        exampleMap.put(t.getKey(), ExampleObject.reverseExample(t.get_impl_o()));
+        parameter.setExamples(exampleMap);
+        }
+        if (p.getCList().size() != 0) {
+        io.swagger.v3.oas.models.media.Content content = new Content();
+        for (ContentTuple t : p.getCList())
+        content.put(t.getKey(), MediaTypeObject.reverseMediaType(t.get_impl_m()));
+        parameter.setContent(content);
+        }
+        if (p.getRequired() != null)
+        parameter.setRequired(p.getRequired());
+        if (p.getExList().size() != 0) {
+        Map<String, Object> extensionMap = new HashMap<>();
+        for (Extension e : p.getExList())
+        extensionMap.put(e.getKey(), e.getValue());
+        parameter.setExtensions(extensionMap);
+        }
+
+        return parameter;
+        }
+
+        syn RequestBody RequestBodyOb.reverseRequestBody (RequestBodyOb requestBodyOb);
+        eq RequestBodyReference.reverseRequestBody (RequestBodyOb requestBodyOb) {
+        RequestBody requestBody = new RequestBody();
+        RequestBodyReference r = (RequestBodyReference) requestBodyOb;
+
+        if (!r.getRef().isEmpty()) {
+        requestBody.set$ref(r.getRef());
+        }
+
+        return requestBody;
+        }
+        eq RequestBodyObject.reverseRequestBody (RequestBodyOb requestBodyOb) {
+        RequestBody requestBody = new RequestBody();
+        RequestBodyObject r = (RequestBodyObject) requestBodyOb;
+
+        if (r.getCList().size() != 0) {
+        io.swagger.v3.oas.models.media.Content contents = new Content();
+        for (ContentTuple t : r.getCList())
+        contents.put(t.getKey(), MediaTypeObject.reverseMediaType(t.get_impl_m()));
+        requestBody.setContent(contents);
+        }
+        if (!r.getDescription().isEmpty())
+        requestBody.setDescription(r.getDescription());
+        if (r.getRequired() != null)
+        requestBody.setRequired(r.getRequired());
+
+        return requestBody;
+        }
+
+public static io.swagger.v3.oas.models.media.MediaType MediaTypeObject.reverseMediaType (MediaTypeObject mediaTypeObject){
+        MediaType mediaType = new MediaType();
+        SchemaOb s;
+
+        if (mediaTypeObject.get_impl_s() != null) {
+        s = mediaTypeObject.get_impl_s();
+        mediaType.setSchema(s.reverseSchema(s));
+        }
+        if (mediaTypeObject.getExample() != null)
+        mediaType.setExample(mediaTypeObject.getExample());
+        if (mediaTypeObject.getEList().size() != 0) {
+        Map<String, Example> exampleMap = new HashMap<>();
+        for (ExampleTuple t : mediaTypeObject.getEList())
+        exampleMap.put(t.getKey(), ExampleObject.reverseExample(t.get_impl_o()));
+        mediaType.setExamples(exampleMap);
+        }
+        if (mediaTypeObject.getEnList().size() != 0) {
+        Map<String, io.swagger.v3.oas.models.media.Encoding> encodingMap = new HashMap<>();
+        for (EncodingTuple t : mediaTypeObject.getEnList())
+        encodingMap.put(t.getKey(), EncodingObject.reverseEncoding(t.get_impl_e()));
+        mediaType.setEncoding(encodingMap);
+        }
+
+        return mediaType;
+        }
+
+public static io.swagger.v3.oas.models.media.Encoding EncodingObject.reverseEncoding (EncodingObject encodingObject){
+        io.swagger.v3.oas.models.media.Encoding encodingProperty = new io.swagger.v3.oas.models.media.Encoding();
+        HeaderOb h;
+
+        if (!encodingObject.getContentType().isEmpty())
+        encodingProperty.setContentType(encodingObject.getContentType());
+        if (encodingObject.get_impl_h().size() != 0) {
+        Map<String, Header> headers = new HashMap<>();
+        for (HeaderTuple t : encodingObject.get_impl_h()) {
+        h = t.get_impl_o();
+        headers.put(t.getKey(), h.reverseHeader(h));
+        }
+        encodingProperty.setHeaders(headers);
+        }
+        //if (!encodingObject.getStyle().isEmpty())
+        //  encodingProperty.setStyle(Encoding.StyleEnum.valueOf());
+        if (encodingObject.getExplode() != null)
+        encodingProperty.setExplode(encodingObject.getExplode());
+        if (encodingObject.getExList().size() != 0) {
+        Map<String, Object> extensionMap = new HashMap<>();
+        for (Extension e : encodingObject.getExList())
+        extensionMap.put(e.getKey(), e.getValue());
+        encodingProperty.setExtensions(extensionMap);
+        }
+
+        return encodingProperty;
+        }
+
+        syn ApiResponse ResponseOb.reverseResponse (ResponseOb responseOb);
+        eq ResponseReference.reverseResponse (ResponseOb responseOb){
+        ApiResponse response = new ApiResponse();
+        ResponseReference r = (ResponseReference) responseOb;
+
+        if (!r.getRef().isEmpty()) {
+        response.set$ref(r.getRef());
+        }
+
+        return response;
+        }
+        eq ResponseObject.reverseResponse (ResponseOb responseOb){
+        ApiResponse response = new ApiResponse();
+        ResponseObject r = (ResponseObject) responseOb;
+
+        if (!r.getDescription().isEmpty())
+        response.setDescription(r.getDescription());
+        if (r.get_impl_h().size() != 0) {
+        Map<String, Header> headers = new HashMap<>();
+        for (HeaderTuple t : r.get_impl_h())
+        headers.put(t.getKey(), t.get_impl_o().reverseHeader(t.get_impl_o()));
+        response.setHeaders(headers);
+        }
+        if (r.getCList().size() != 0) {
+        io.swagger.v3.oas.models.media.Content contents = new io.swagger.v3.oas.models.media.Content();
+        for (ContentTuple t : r.getCList())
+        contents.put(t.getKey(), MediaTypeObject.reverseMediaType(t.get_impl_m()));
+        response.setContent(contents);
+        }
+        if (r.get_impl_l().size() != 0) {
+        Map<String, Link> links = new HashMap<>();
+        for (LinkTuple t : r.get_impl_l())
+        links.put(t.getKey(), t.get_impl_o().reverseLink(t.get_impl_o()));
+        response.setLinks(links);
+        }
+
+        return response;
+        }
+
+        syn io.swagger.v3.oas.models.callbacks.Callback CallbackOb.reverseCallback (CallbackOb callbackOb);
+        eq CallbackReference.reverseCallback (CallbackOb callbackOb) {
+        io.swagger.v3.oas.models.callbacks.Callback callback = new io.swagger.v3.oas.models.callbacks.Callback();
+        CallbackReference c = (CallbackReference) callbackOb;
+
+        if (!c.getRef().isEmpty()) {
+        callback.set$ref(c.getRef());
+        }
+
+        return callback;
+        }
+        eq CallbackObject.reverseCallback (CallbackOb callbackOb) {
+        io.swagger.v3.oas.models.callbacks.Callback callback = new io.swagger.v3.oas.models.callbacks.Callback();
+        CallbackObject c = (CallbackObject) callbackOb;
+
+        if (c.getEList().size() != 0) {
+        Map<String, Path> paths = new HashMap<>();
+        PathItemOb p;
+        for (Expression e : c.getEList())
+        callback.addPathItem(e.getName(), e.get_impl_p().reversePath(e.get_impl_p()));
+        }
+
+        return callback;
+        }
+
+public static Example ExampleObject.reverseExample (ExampleObject exampleObject){
+        Example example = new Example();
+
+        if (!exampleObject.getSummary().isEmpty())
+        example.setSummary(exampleObject.getSummary());
+        if (!exampleObject.getDescription().isEmpty())
+        example.setDescription(exampleObject.getDescription());
+        if (exampleObject.getValue() != null)
+        example.setValue(exampleObject.getValue());
+        if (!exampleObject.getExternalValue().isEmpty())
+        example.setExternalValue(exampleObject.getExternalValue());
+        if (exampleObject.getExList().size() != 0) {
+        Map<String, Object> extension = new HashMap<>();
+        for (Extension e : exampleObject.getExList())
+        extension.put(e.getKey(), e.getValue());
+        example.setExtensions(extension);
+        }
+
+        return example;
+        }
+
+        syn io.swagger.v3.oas.models.links.Link LinkOb.reverseLink (LinkOb linkOb);
+        eq LinkReference.reverseLink (LinkOb linkOb){
+        io.swagger.v3.oas.models.links.Link link = new io.swagger.v3.oas.models.links.Link();
+        LinkReference l = (LinkReference) linkOb;
+
+        if (!l.getRef().isEmpty())
+        link.set$ref(l.getRef());
+
+        return link;
+        }
+        eq LinkObject.reverseLink (LinkOb linkOb){
+        io.swagger.v3.oas.models.links.Link link = new io.swagger.v3.oas.models.links.Link();
+        LinkObject l = (LinkObject) linkOb;
+
+        if (!l.getOperationRef().isEmpty())
+        link.setOperationRef(l.getOperationRef());
+        if (!l.getOperationID().isEmpty())
+        link.setOperationId(l.getOperationID());
+        if (l.get_impl_l().size() != 0) {
+        Map<String, String> parameters = new HashMap<>();
+        for (LinkParameterTuple t : l.get_impl_l())
+        parameters.put(t.getKey(), t.getValue());
+        link.setParameters(parameters);
+        }
+        if (!l.getDescription().isEmpty())
+        link.setDescription(l.getDescription());
+        if (l.hasS())
+        link.setServer(ServerObject.reverseServer(l.get_impl_s()));
+        if (l.getExList().size() != 0){
+        for(Extension e : l.getExList())
+        link.addExtension(e.getKey(), e.getValue());
+        }
+
+        return link;
+        }
+
+        syn io.swagger.v3.oas.models.headers.Header HeaderOb.reverseHeader (HeaderOb headerOb);
+        eq HeaderReference.reverseHeader (HeaderOb headerOb) {
+        io.swagger.v3.oas.models.headers.Header header = new io.swagger.v3.oas.models.headers.Header();
+        HeaderReference h = new HeaderReference();
+
+        if (!h.getRef().isEmpty()) {
+        header.set$ref(h.getRef());
+        }
+
+        return header;
+        }
+        eq HeaderObject.reverseHeader (HeaderOb headerOb) {
+        io.swagger.v3.oas.models.headers.Header header = new io.swagger.v3.oas.models.headers.Header();
+        HeaderObject h = (HeaderObject) headerOb;
+
+        if (h.getRequired() != null)
+        header.setRequired(h.getRequired());
+        if (!h.getDescription().isEmpty())
+        header.setDescription(h.getDescription());
+        if (!h.getStyle().isEmpty())
+        header.setStyle(Header.StyleEnum.valueOf(h.getStyle()));
+        if (h.getExplode() != null)
+        header.setExplode(h.getExplode());
+        //if (h.getAllowReserved() != null)
+        //  header.setAllowReserved(h.getAllowReserved());
+        if (h.getExample() != null)
+        header.setExample(h.getExample());
+        if (h.getEList().size() != 0) {
+        Map<String, Example> examples = new HashMap<>();
+        for (ExampleTuple t : h.getEList())
+        examples.put(t.getKey(), ExampleObject.reverseExample(t.get_impl_o()));
+        header.setExample(examples);
+        }
+        if (h.getCList().size() != 0) {
+        io.swagger.v3.oas.models.media.Content contents = new io.swagger.v3.oas.models.media.Content();
+        for (ContentTuple t : h.getCList())
+        contents.put(t.getKey(), MediaTypeObject.reverseMediaType(t.get_impl_m()));
+        header.setContent(contents);
+        }
+        if (h.hasS())
+        header.setSchema(h.get_impl_s().reverseSchema(h.get_impl_s()));
+
+        return header;
+        }
+
+public static io.swagger.v3.oas.models.tags.Tag TagObject.reverseTag (TagObject tagObject){
+        io.swagger.v3.oas.models.tags.Tag tag = new io.swagger.v3.oas.models.tags.Tag();
+
+        tag.setName(tagObject.getName());
+
+        if (!tagObject.getDescription().isEmpty())
+        tag.setDescription(tagObject.getDescription());
+        if (tagObject.hasE())
+        tag.setExternalDocs(ExternalDocObject.reverseExternalDocs(tagObject.get_impl_e()));
+        if (tagObject.getExList().size() != 0) {
+        Map<String, Object> extensionMap = new HashMap<>();
+        for (Extension e : tagObject.getExList())
+        extensionMap.put(e.getKey(), e.getValue());
+        tag.setExtensions(extensionMap);
+        }
+
+        return tag;
+        }
+
+  /*
+  syn org.openapi4j.parser.model.v3.Schema SchemaOb.reverseSchema (SchemaOb schemaOb);
+  eq SchemaReference.reverseSchema (SchemaOb schemaOb){
+    org.openapi4j.parser.model.v3.Schema schema = new org.openapi4j.parser.model.v3.Schema();
+    SchemaReference s = (SchemaReference) schemaOb;
+
+    if (!s.getRef().isEmpty()) {
+      try {
+        schema.setReference(new org.openapi4j.core.model.v3.OAI3Context(new URL("")), new URL(""), s.getRef());
+      } catch (Exception e) {
+        e.printStackTrace();
+      }
+    }
+
+    return schema;
+  }
+  eq SchemaObject.reverseSchema (SchemaOb schemaOb){
+    org.openapi4j.parser.model.v3.Schema schema = new org.openapi4j.parser.model.v3.Schema();
+    SchemaObject s = (SchemaObject) schemaOb;
+
+    if (s.hasAdditionalProperties()) {
+      SchemaOb o = s.getAdditionalProperties().getSchemaOb();
+      if (o instanceof SchemaObject)
+        schema.setAdditionalProperties(((SchemaObject) o).reverseSchema(o, map));
+      else
+        schema.setAdditionalProperties(((SchemaReference) o).reverseSchema(o, map));
+    }
+    if (s.getAdditionalPropertiesAllowed() != null)
+      schema.setAdditionalPropertiesAllowed(s.getAdditionalPropertiesAllowed());
+    if (s.getDefaultValue() != null)
+      schema.setDefault(s.getDefaultValue());
+    if (!s.getDescription().isEmpty())
+      schema.setDescription(s.getDescription());
+    if (s.getDeprecatedBoolean() != null)
+      schema.setDeprecated(s.getDeprecatedBoolean());
+    if (s.hasDiscriminatorObject())
+      schema.setDiscriminator(DiscriminatorObject.reverseDiscriminator(s.getDiscriminatorObject(), map));
+    if (s.getNumEnumObj() != 0) {
+      for (EnumObj e : s.getEnumObjs())
+        schema.addEnum(e.getEnumOb());
+    }
+
+    if (s.getExample() != null)
+      schema.setExample(s.getExample());
+    if (s.getExclusiveMaximum() != null)
+      schema.setExclusiveMaximum(s.getExclusiveMaximum());
+    if (s.getExclusiveMinimum() != null)
+      schema.setExclusiveMinimum(s.getExclusiveMinimum());
+    if (s.hasExternalDocObject())
+      schema.setExternalDocs(ExternalDocObject.reverseExternalDocs(s.getExternalDocObject(), map));
+    if (!s.getFormat().isEmpty())
+      schema.setFormat(s.getFormat());
+    if (s.hasItemsSchema()) {
+      if (s.getItemsSchema().getSchemaOb() instanceof SchemaObject)
+        schema.setItemsSchema(((SchemaObject) s.getItemsSchema().getSchemaOb()).reverseSchema(s.getItemsSchema().getSchemaOb(), map));
+      else
+        schema.setItemsSchema(((SchemaReference) s.getItemsSchema().getSchemaOb()).reverseSchema(s.getItemsSchema().getSchemaOb(), map));
+    }
+    if (s.getMaximum() != null)
+      schema.setMaximum(s.getMaximum());
+    if (s.getMinimum() != null)
+      schema.setMinimum(s.getMinimum());
+    if (s.getMaxItems() != null)
+      schema.setMaxItems(s.getMaxItems());
+    if (s.getMinItems() != null)
+      schema.setMinItems(s.getMinItems());
+    if (s.getMaxLength() != null)
+      schema.setMaxLength(s.getMaxLength());
+    if (s.getMinLength() != null)
+      schema.setMinLength(s.getMinLength());
+    if (s.getMaxProperties() != null)
+      schema.setMaxProperties(s.getMaxProperties());
+    if (s.getMinProperties() != null)
+      schema.setMinProperties(s.getMinProperties());
+    if (s.getMultipleOf() != null)
+      schema.setMultipleOf(s.getMultipleOf());
+    if (s.hasNotSchema()) {
+      if (s.getNotSchema().getSchemaOb() instanceof SchemaObject)
+        schema.setNotSchema(((SchemaObject) s.getNotSchema().getSchemaOb()).reverseSchema(s.getNotSchema().getSchemaOb(), map));
+      else
+        schema.setNotSchema(((SchemaReference) s.getNotSchema().getSchemaOb()).reverseSchema(s.getNotSchema().getSchemaOb(), map));
+    }
+    if (s.getNullable() != null)
+      schema.setNullable(s.getNullable());
+    if (!s.getPattern().isEmpty())
+      schema.setPattern(s.getPattern());
+    if (s.getNumPropertyItem() != 0) {
+      Map<String, org.openapi4j.parser.model.v3.Schema> properties = new HashMap<>();
+      for (PropertyItem p : s.getPropertyItemList()) {
+        if (p.getSchemaOb() instanceof SchemaObject)
+          properties.put(p.getName(), ((SchemaObject) p.getSchemaOb()).reverseSchema(p.getSchemaOb(), map));
+        else
+          properties.put(p.getName(), ((SchemaReference) p.getSchemaOb()).reverseSchema(p.getSchemaOb(), map));
+      }
+      schema.setProperties(properties);
+    }
+    if (s.getNumRequiredField() != 0) {
+      for (RequiredField r : s.getRequiredFields())
+        schema.addRequiredField(r.getValue());
+    }
+    if (s.getNumAllOfSchema() != 0) {
+      for (AllOfSchema a : s.getAllOfSchemas()) {
+        if (a.getSchemaOb() instanceof SchemaObject)
+          schema.addAllOfSchema(((SchemaObject) a.getSchemaOb()).reverseSchema(a.getSchemaOb(), map));
+        else
+          schema.addAllOfSchema(((SchemaReference) a.getSchemaOb()).reverseSchema(a.getSchemaOb(), map));
+      }
+    }
+    if (s.getNumAnyOfSchema() != 0) {
+      for (AnyOfSchema a : s.getAnyOfSchemas()) {
+        if (a.getSchemaOb() instanceof SchemaObject)
+          schema.addAnyOfSchema(((SchemaObject) a.getSchemaOb()).reverseSchema(a.getSchemaOb(), map));
+        else
+          schema.addAnyOfSchema(((SchemaReference) a.getSchemaOb()).reverseSchema(a.getSchemaOb(), map));
+      }
+    }
+    if (s.getNumOneOfSchema() != 0) {
+      for (OneOfSchema o : s.getOneOfSchemas()) {
+        if (o.getSchemaOb() instanceof SchemaObject)
+          schema.addOneOfSchema(((SchemaObject) o.getSchemaOb()).reverseSchema(o.getSchemaOb(), map));
+        else
+          schema.addOneOfSchema(((SchemaReference) o.getSchemaOb()).reverseSchema(o.getSchemaOb(), map));
+      }
+    }
+    if (s.getReadOnly() != null)
+      schema.setReadOnly(s.getReadOnly());
+    if (s.getWriteOnly() != null)
+      schema.setWriteOnly(s.getWriteOnly());
+    if (!s.getType().isEmpty())
+      schema.setType(s.getType());
+    if (!s.getTitle().isEmpty())
+      schema.setTitle(s.getTitle());
+    if (s.getUniqueItems() != null)
+      schema.setUniqueItems(s.getUniqueItems());
+    if (s.hasXmlObject())
+      schema.setXml(XmlObject.reverseXml(s.getXmlObject(), map));
+    if (s.getNumExtension() != 0) {
+      Map<String, Object> extensionMap = new HashMap<>();
+      for (Extension e : s.getExtensions())
+        extensionMap.put(e.getKey(), e.getValue());
+      schema.setExtensions(extensionMap);
+    }
+
+    return schema;
+  }
+   */
+
+public static io.swagger.v3.oas.models.media.Discriminator DiscriminatorObject.reverseDiscriminator (DiscriminatorObject discriminatorObject) {
+        io.swagger.v3.oas.models.media.Discriminator discriminator = new io.swagger.v3.oas.models.media.Discriminator();
+
+        if (!discriminatorObject.getPropertyName().isEmpty())
+        discriminator.setPropertyName(discriminatorObject.getPropertyName());
+        if (discriminatorObject.get_impl_m().size() != 0) {
+        Map<String, String> mapping = new HashMap<>();
+        for (MappingTuple m : discriminatorObject.get_impl_m())
+        mapping.put(m.getKey(), m.getValue());
+        discriminator.setMapping(mapping);
+        }
+
+        return discriminator;
+        }
+
+public static io.swagger.v3.oas.models.media.XML XmlObject.reverseXml (XmlObject xmlObject) {
+        io.swagger.v3.oas.models.media.XML xml = new io.swagger.v3.oas.models.media.XML();
+
+        if (!xmlObject.getName().isEmpty())
+        xml.setName(xmlObject.getName());
+        if (!xmlObject.getNamespace().isEmpty())
+        xml.setNamespace(xmlObject.getNamespace());
+        if (!xmlObject.getPrefix().isEmpty())
+        xml.setPrefix(xmlObject.getPrefix());
+        if (xmlObject.getAttribute() != null)
+        xml.setAttribute(xmlObject.getAttribute());
+        if (xmlObject.getWrapped() != null)
+        xml.setWrapped(xmlObject.getWrapped());
+
+        return xml;
+        }
+
+        syn io.swagger.v3.oas.models.security.SecurityScheme SecuritySchemeOb.reverseSecurityScheme (SecuritySchemeOb securitySchemeOb);
+        eq SecuritySchemeReference.reverseSecurityScheme (SecuritySchemeOb securitySchemeOb){
+        io.swagger.v3.oas.models.security.SecurityScheme securityScheme = new io.swagger.v3.oas.models.security.SecurityScheme();
+        SecuritySchemeReference s = (SecuritySchemeReference) securitySchemeOb;
+
+        if (!s.getRef().isEmpty()) {securityScheme.set$ref(s.getRef());
+        }
+
+        return securityScheme;
+        }
+        eq SecuritySchemeObject.reverseSecurityScheme (SecuritySchemeOb securitySchemeOb){
+        io.swagger.v3.oas.models.security.SecurityScheme securityScheme = new io.swagger.v3.oas.models.security.SecurityScheme();
+        SecuritySchemeObject s = (SecuritySchemeObject) securitySchemeOb;
+
+        if (!s.getType().isEmpty())
+        securityScheme.setType(SecurityScheme.Type.valueOf(s.getType()));
+        if (!s.getName().isEmpty())
+        securityScheme.setName(s.getName());
+        if (!s.getIn().isEmpty())
+        securityScheme.setIn(SecurityScheme.In.valueOf(s.getIn()));
+        if (!s.getScheme().isEmpty())
+        securityScheme.setScheme(s.getScheme());
+        if (!s.getOpenIdConnectUrl().isEmpty())
+        securityScheme.setOpenIdConnectUrl(s.getOpenIdConnectUrl());
+        if (s.get_impl_o() != null)
+        securityScheme.setFlows(OAuthFlowsObject.reverseOAuthFlows(s.get_impl_o()));
+        if (!s.getDescription().isEmpty())
+        securityScheme.setDescription(s.getDescription());
+        if (!s.getBearerFormat().isEmpty())
+        securityScheme.setBearerFormat(s.getBearerFormat());
+        if (s.getExList().size() != 0) {
+        Map<String, Object> extensionMap = new HashMap<>();
+        for (Extension e : s.getExList())
+        extensionMap.put(e.getKey(), e.getValue());
+        securityScheme.setExtensions(extensionMap);
+        }
+
+        return securityScheme;
+        }
+
+public static io.swagger.v3.oas.models.security.OAuthFlows OAuthFlowsObject.reverseOAuthFlows (OAuthFlowsObject oAuthFlowsObject){
+        io.swagger.v3.oas.models.security.OAuthFlows oAuthFlows = new io.swagger.v3.oas.models.security.OAuthFlows();
+
+        if (oAuthFlowsObject.hasI())
+        oAuthFlows.setImplicit(OAuthFlowObject.reverseOAuthFlow(oAuthFlowsObject.get_impl_i().get_impl_o()));
+        if (oAuthFlowsObject.hasP())
+        oAuthFlows.setPassword(OAuthFlowObject.reverseOAuthFlow(oAuthFlowsObject.get_impl_p().get_impl_o()));
+        if (oAuthFlowsObject.hasC())
+        oAuthFlows.setClientCredentials(OAuthFlowObject.reverseOAuthFlow(oAuthFlowsObject.get_impl_c().get_impl_o()));
+        if (oAuthFlowsObject.hasA())
+        oAuthFlows.setAuthorizationCode(OAuthFlowObject.reverseOAuthFlow(oAuthFlowsObject.get_impl_a().get_impl_o()));
+
+        return oAuthFlows;
+        }
+
+public static io.swagger.v3.oas.models.security.OAuthFlow OAuthFlowObject.reverseOAuthFlow (OAuthFlowObject oAuthFlowObject){
+        io.swagger.v3.oas.models.security.OAuthFlow oAuthFlow = new io.swagger.v3.oas.models.security.OAuthFlow();
+        Scopes scopes = new Scopes();
+
+        if (oAuthFlowObject.getAuthorizationUrl() != null)
+        oAuthFlow.setAuthorizationUrl(oAuthFlowObject.getAuthorizationUrl());
+        if (oAuthFlowObject.getTokenUrl() != null)
+        oAuthFlow.setTokenUrl(oAuthFlowObject.getTokenUrl());
+        for (ScopesTuple t : oAuthFlowObject.getSList())
+        scopes.put(t.getScopesKey(), t.getScopesValue());
+        oAuthFlow.setScopes(scopes);
+        if (oAuthFlowObject.getRefreshUrl() != null)
+        oAuthFlow.setRefreshUrl(oAuthFlowObject.getRefreshUrl());
+
+        return oAuthFlow;
+        }
+
+public static io.swagger.v3.oas.models.security.SecurityRequirement SecurityRequirementObject.reverseSecurityRequirement (SecurityRequirementObject securityRequirementObject){
+        io.swagger.v3.oas.models.security.SecurityRequirement securityRequirement = new io.swagger.v3.oas.models.security.SecurityRequirement();
+
+        if (securityRequirementObject.get_impl_t().size() != 0) {
+        Map<String, List<String>> requirements = new HashMap<>();
+        for (SecurityRequirementTuple t : securityRequirementObject.get_impl_t()) {
+        List<String> values = new ArrayList<>();
+        for (SecurityRequirementValue v : t.get_impl_v())
+        values.add(v.getValue());
+        securityRequirement.addList(t.getName(), values);
+        }
+        }
+
+        return securityRequirement;
+        }
-- 
GitLab