com.reprezen.genflow.swagger.doc.RefHelper Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of swagger-doc Show documentation
The newest version!
package com.reprezen.genflow.swagger.doc;

import com.reprezen.genflow.swagger.doc.BadReferenceException;
import com.reprezen.genflow.swagger.doc.Helper;
import com.reprezen.genflow.swagger.doc.HelperHelper;
import io.swagger.models.Model;
import io.swagger.models.RefModel;
import io.swagger.models.RefResponse;
import io.swagger.models.Response;
import io.swagger.models.Swagger;
import io.swagger.models.parameters.Parameter;
import io.swagger.models.parameters.RefParameter;
import io.swagger.models.properties.Property;
import io.swagger.models.properties.RefProperty;
import io.swagger.models.refs.RefFormat;
import io.swagger.models.refs.RefType;
import java.util.Arrays;
import org.eclipse.xtext.xbase.lib.Exceptions;

@SuppressWarnings("all")
public class RefHelper implements Helper {
  private Swagger swagger;
  
  @Override
  public void init() {
    this.swagger = HelperHelper.getSwagger();
  }
  
  protected Object _resolve(final Object obj) {
    Object _switchResult = null;
    boolean _matched = false;
    if (obj instanceof RefParameter) {
      _matched=true;
      _switchResult = this.resolve(obj);
    }
    if (!_matched) {
      if (obj instanceof RefModel) {
        _matched=true;
        _switchResult = this.resolve(obj);
      }
    }
    if (!_matched) {
      if (obj instanceof RefProperty) {
        _matched=true;
        _switchResult = this.resolve(obj);
      }
    }
    if (!_matched) {
      if (obj instanceof RefResponse) {
        _matched=true;
        _switchResult = this.resolve(obj);
      }
    }
    if (!_matched) {
      _switchResult = obj;
    }
    return _switchResult;
  }
  
  protected Object _safeResolve(final Object obj) {
    Object _xtrycatchfinallyexpression = null;
    try {
      _xtrycatchfinallyexpression = this.resolve(obj);
    } catch (final Throwable _t) {
      if (_t instanceof BadReferenceException) {
        _xtrycatchfinallyexpression = obj;
      } else {
        throw Exceptions.sneakyThrow(_t);
      }
    }
    return _xtrycatchfinallyexpression;
  }
  
  protected Object _resolve(final Parameter param) {
    return param;
  }
  
  protected Object _safeResolve(final Parameter param) {
    return param;
  }
  
  protected Object _resolve(final RefParameter ref) {
    return this.resolve(ref.get$ref(), RefType.PARAMETER, ref.getSimpleRef(), ref.getRefFormat());
  }
  
  protected Object _safeResolve(final RefParameter ref) {
    return this.safeResolve(ref, ref.get$ref(), RefType.PARAMETER, ref.getSimpleRef(), ref.getRefFormat());
  }
  
  protected Object _resolve(final Model model) {
    return model;
  }
  
  protected Object _safeResolve(final Model model) {
    return model;
  }
  
  protected Object _resolve(final RefModel ref) {
    return this.resolve(ref.get$ref(), RefType.DEFINITION, ref.getSimpleRef(), ref.getRefFormat());
  }
  
  protected Object _safeResolve(final RefModel ref) {
    return this.safeResolve(ref, ref.get$ref(), RefType.DEFINITION, ref.getSimpleRef(), ref.getRefFormat());
  }
  
  protected Object _resolve(final Property prop) {
    return prop;
  }
  
  protected Object _safeResolve(final Property prop) {
    return prop;
  }
  
  protected Object _resolve(final RefProperty ref) {
    return this.resolve(ref.get$ref(), RefType.DEFINITION, ref.getSimpleRef(), ref.getRefFormat());
  }
  
  protected Object _safeResolve(final RefProperty ref) {
    return this.safeResolve(ref, ref.get$ref(), RefType.DEFINITION, ref.getSimpleRef(), ref.getRefFormat());
  }
  
  protected Object _resolve(final Response response) {
    return response;
  }
  
  protected Object _safeResolve(final Response response) {
    return response;
  }
  
  protected Object _resolve(final RefResponse ref) {
    return this.resolve(ref.get$ref(), RefType.RESPONSE, ref.getSimpleRef(), ref.getRefFormat());
  }
  
  protected Object _safeResolve(final RefResponse ref) {
    return this.safeResolve(ref, ref.get$ref(), RefType.RESPONSE, ref.getSimpleRef(), ref.getRefFormat());
  }
  
  private Object resolve(final String refString, final RefType refType, final String simpleRef, final RefFormat refFormat) {
    Object _xblockexpression = null;
    {
      Object _switchResult = null;
      if (refFormat != null) {
        switch (refFormat) {
          case INTERNAL:
            Object _switchResult_1 = null;
            if (refType != null) {
              switch (refType) {
                case PARAMETER:
                  _switchResult_1 = this.swagger.getParameters().get(simpleRef);
                  break;
                case DEFINITION:
                  _switchResult_1 = this.swagger.getDefinitions().get(simpleRef);
                  break;
                case RESPONSE:
                  _switchResult_1 = this.swagger.getResponses().get(simpleRef);
                  break;
                default:
                  _switchResult_1 = null;
                  break;
              }
            } else {
              _switchResult_1 = null;
            }
            _switchResult = _switchResult_1;
            break;
          default:
            _switchResult = null;
            break;
        }
      } else {
        _switchResult = null;
      }
      final Object value = _switchResult;
      Object _elvis = null;
      if (value != null) {
        _elvis = value;
      } else {
        Object _badRef = this.badRef(refString);
        _elvis = _badRef;
      }
      _xblockexpression = _elvis;
    }
    return _xblockexpression;
  }
  
  private Object safeResolve(final Object refObj, final String refString, final RefType refType, final String simpleRef, final RefFormat refFormat) {
    Object _xtrycatchfinallyexpression = null;
    try {
      _xtrycatchfinallyexpression = this.resolve(refString, refType, simpleRef, refFormat);
    } catch (final Throwable _t) {
      if (_t instanceof BadReferenceException) {
        _xtrycatchfinallyexpression = refObj;
      } else {
        throw Exceptions.sneakyThrow(_t);
      }
    }
    return _xtrycatchfinallyexpression;
  }
  
  public Object badRef(final String refString) {
    try {
      throw new BadReferenceException(refString);
    } catch (Throwable _e) {
      throw Exceptions.sneakyThrow(_e);
    }
  }
  
  public Object resolve(final Object ref) {
    if (ref instanceof RefProperty) {
      return _resolve((RefProperty)ref);
    } else if (ref instanceof RefModel) {
      return _resolve((RefModel)ref);
    } else if (ref instanceof RefResponse) {
      return _resolve((RefResponse)ref);
    } else if (ref instanceof RefParameter) {
      return _resolve((RefParameter)ref);
    } else if (ref instanceof Model) {
      return _resolve((Model)ref);
    } else if (ref instanceof Response) {
      return _resolve((Response)ref);
    } else if (ref instanceof Parameter) {
      return _resolve((Parameter)ref);
    } else if (ref instanceof Property) {
      return _resolve((Property)ref);
    } else if (ref != null) {
      return _resolve(ref);
    } else {
      throw new IllegalArgumentException("Unhandled parameter types: " +
        Arrays.