import io.swagger.models.parameters.RefParameter; //导入依赖的package包/类
/**
 * Ensures the parameters are all resolved and return just the list of parameters that are fully
 * resolved by the swagger core parser.
 */
private static ImmutableList<Parameter> getResolvedParameters(
    final DiagCollector diagCollector,
    ImmutableList<Parameter> parameters,
    final Location location) {
  ImmutableList<Parameter> resolvedParameters =
      FluentIterable.from(parameters)
          .filter(
              new Predicate<Parameter>() {
                @Override
                public boolean apply(Parameter parameter) {
                  if (parameter instanceof RefParameter) {
                    /*
                     * This is an invalid state. Reference parameters should automatically get
                     * resolved into parameter objects by the swagger core parser, because only
                     * references that are allowed are to parameters that are defined at the
                     * Swagger Object's parameters which are in the same file. If we reach here
                     * it would mean the reference cannot be resolved and nothing this converter
                     * can do.
                     */
                    diagCollector.addDiag(
                        Diag.warning(
                            location,
                            "Reference %s cannot be resolved",
                            ((RefParameter) parameter).get$ref()));
                    return false;
                  } else {
                    return true;
                  }
                }
              })
          .toList();
  return resolvedParameters;
}
 

import io.swagger.models.parameters.RefParameter; //导入依赖的package包/类
static Optional<ConfigurationProperty> createPropertyFromParameter(final Parameter parameter) {
    if (parameter instanceof RefParameter || parameter instanceof BodyParameter) {
        // Reference parameters are not supported, body parameters are
        // handled in createShape* methods

        return Optional.empty();
    }

    if (!(parameter instanceof SerializableParameter)) {
        throw new IllegalStateException(
            "Unexpected parameter type received, neither ref, body nor serializable: " + parameter);
    }

    final String name = parameter.getName();
    final String description = parameter.getDescription();
    final boolean required = parameter.getRequired();

    final ConfigurationProperty.Builder propertyBuilder = new ConfigurationProperty.Builder()//
        .kind("property")//
        .displayName(name)//
        .description(description)//
        .group("producer")//
        .required(required)//
        .componentProperty(false)//
        .deprecated(false)//
        .secret(false);

    final SerializableParameter serializableParameter = (SerializableParameter) parameter;

    final String type = serializableParameter.getType();
    propertyBuilder.type(type).javaType(JsonSchemaHelper.javaTypeFor(serializableParameter));

    final List<String> enums = serializableParameter.getEnum();
    if (enums != null) {
        propertyBuilder.addAllEnum(createEnums(enums));
    }

    return Optional.of(propertyBuilder.build());
}
 

import io.swagger.models.parameters.RefParameter; //导入依赖的package包/类
/**
 * Retrieves the type of a parameter, or otherwise null
 *
 * @param definitionDocumentResolver the definition document resolver
 * @return the type of the parameter, or otherwise null
 */
private Type getType(Map<String, Model> definitions, DocumentResolver definitionDocumentResolver) {
    Validate.notNull(parameter, "parameter must not be null!");
    Type type = null;

    if (parameter instanceof BodyParameter) {
        BodyParameter bodyParameter = (BodyParameter) parameter;
        Model model = bodyParameter.getSchema();

        if (model != null) {
            type = ModelUtils.getType(model, definitions, definitionDocumentResolver);
        } else {
            type = new BasicType("string", bodyParameter.getName());
        }

    } else if (parameter instanceof AbstractSerializableParameter) {
        AbstractSerializableParameter serializableParameter = (AbstractSerializableParameter) parameter;
        @SuppressWarnings("unchecked")
        List<String> enums = serializableParameter.getEnum();

        if (CollectionUtils.isNotEmpty(enums)) {
            type = new EnumType(serializableParameter.getName(), enums);
        } else {
            type = new BasicType(serializableParameter.getType(), serializableParameter.getName(), serializableParameter.getFormat());
        }
        if (serializableParameter.getType().equals("array")) {
            String collectionFormat = serializableParameter.getCollectionFormat();

            type = new ArrayType(serializableParameter.getName(), new PropertyAdapter(serializableParameter.getItems()).getType(definitionDocumentResolver), collectionFormat);
        }
    } else if (parameter instanceof RefParameter) {
        String refName = ((RefParameter) parameter).getSimpleRef();

        type = new RefType(definitionDocumentResolver.apply(refName), new ObjectType(refName, null /* FIXME, not used for now */));
    }
    return type;
}
 

import io.swagger.models.parameters.RefParameter; //导入依赖的package包/类
public static String getType(Parameter parameter, Set<String> definitions){
    Validate.notNull(parameter, "property must not be null!");
    String type = "NOT FOUND";
    if(parameter instanceof BodyParameter){
        BodyParameter bodyParameter = (BodyParameter)parameter;
        Model model = bodyParameter.getSchema();
        if(model != null){
            type = ModelUtils.getType(model);
        }else{
            type = "string";
        }

    }
    else if(parameter instanceof AbstractSerializableParameter){
        AbstractSerializableParameter serializableParameter = (AbstractSerializableParameter)parameter;
        List enums = serializableParameter.getEnum();
        if(enums != null && !enums.isEmpty()){
            type = "enum" + " (" + StringUtils.join(enums, ", ") + ")";
        }else{
            type = getTypeWithFormat(serializableParameter.getType(), serializableParameter.getFormat());
        }
        if(type.equals("array")){
            String collectionFormat = serializableParameter.getCollectionFormat();
            type = collectionFormat + " " + PropertyUtils.getType(serializableParameter.getItems()) + " " + type;
        }
    }
    else if(parameter instanceof RefParameter){
        RefParameter refParameter = (RefParameter)parameter;
        if(definitions != null) {
            definitions.add(refParameter.getSimpleRef());
        }
        return "["+refParameter.getSimpleRef()+"](#"+refParameter.getSimpleRef().toLowerCase(Locale.ENGLISH)+")";
    }
    return StringUtils.defaultString(type);
}
 

import io.swagger.models.parameters.RefParameter; //导入依赖的package包/类
static Optional<ConfigurationProperty> createPropertyFromParameter(final Parameter parameter) {
    if (parameter instanceof RefParameter || parameter instanceof BodyParameter) {
        // Reference parameters are not supported, body parameters are
        // handled in createShape* methods

        return Optional.empty();
    }

    if (!(parameter instanceof AbstractSerializableParameter<?>)) {
        throw new IllegalArgumentException("Unexpected parameter type received, neither ref, body nor serializable: " + parameter);
    }

    final String name = trimToNull(parameter.getName());
    final String description = trimToNull(parameter.getDescription());
    final boolean required = parameter.getRequired();

    final ConfigurationProperty.Builder propertyBuilder = new ConfigurationProperty.Builder()//
        .kind("property")//
        .displayName(name)//
        .description(description)//
        .group("producer")//
        .required(required)//
        .componentProperty(false)//
        .deprecated(false)//
        .secret(false);

    final AbstractSerializableParameter<?> serializableParameter = (AbstractSerializableParameter<?>) parameter;

    final Object defaultValue = serializableParameter.getDefaultValue();
    if (defaultValue != null) {
        propertyBuilder.defaultValue(String.valueOf(defaultValue));
    }

    final String type = serializableParameter.getType();
    propertyBuilder.type(type).javaType(JsonSchemaHelper.javaTypeFor(serializableParameter));

    final List<String> enums = serializableParameter.getEnum();
    if (enums != null) {
        propertyBuilder.addAllEnum(createEnums(enums));
    }

    return Optional.of(propertyBuilder.build());
}
 

import io.swagger.models.parameters.RefParameter; //导入依赖的package包/类
@SuppressWarnings({ "rawtypes", "unchecked" })
private AbstractType convertParameterToType(Parameter p) {
	if (p instanceof AbstractSerializableParameter<?>) {
		AbstractSerializableParameter<?> basicModel = (AbstractSerializableParameter<?>) p;
		String type = basicModel.getType();
		if (type == null && basicModel.getMinimum() != null) {
			type = "number";
		}
		if (type == null && basicModel.getMaximum() != null) {
			type = "number";
		}

		if (type == null && basicModel.getEnum() != null) {
			type = "string";
		}

		if (type != null && type.equals("array")) {
			if (basicModel.getEnum() != null) {
				type = "string";
			}
			// FIXME
		}
		if (type != null && type.equals("boolean")) {
			basicModel.setEnum(null);// FIXME
		}
		String format = basicModel.getFormat();
		FormatMapper mapFormat = FormatMapper.mapFormat(new FormatMapper(type, format));
		type = mapFormat.type;
		if (((AbstractSerializableParameter) p).getEnum() != null) {
			@SuppressWarnings("unchecked")
			LinkedHashSet<Object> linkedHashSet = new LinkedHashSet<>(
					((AbstractSerializableParameter) p).getEnum());
			linkedHashSet.remove(null);
			((AbstractSerializableParameter) p).setEnum(new ArrayList<>(linkedHashSet));
		}
		format = mapFormat.format;
		AbstractType st = base(type);
		AbstractType derive = TypeOps.derive("", st);
		transferTo(derive, Description.class, basicModel.getDescription());
		transferTo(derive, Example.class, basicModel.getExample());
		transferTo(derive, DisplayName.class, basicModel.getName());
		transferTo(derive, Default.class, basicModel.getDefaultValue());
		transferTo(derive, Enum.class, basicModel.getEnum());

		transferTo(derive, Format.class, format);
		transferTo(derive, MaxLength.class, basicModel.getMaxLength());
		transferTo(derive, MinLength.class, basicModel.getMinLength());
		transferTo(derive, Pattern.class, basicModel.getPattern());
		transferTo(derive, Enum.class, basicModel.getEnum());
		transferTo(derive, Minimum.class, basicModel.getMinimum());
		transferTo(derive, Maximum.class, basicModel.getMaximum());
		Property items = basicModel.getItems();
		if (items != null) {
			derive.addMeta(new ComponentShouldBeOfType(propertyToType(items)));
		}
		return derive;
	} else if (p instanceof RefParameter) {
		throw new IllegalStateException();
	} else if (p instanceof BodyParameter) {
		BodyParameter bp = (BodyParameter) p;
		Model schema = bp.getSchema();
		AbstractType convertType = convertType("", schema);
		transferTo(convertType, Description.class, bp.getDescription());
		transferTo(convertType, Example.class, bp.getExamples());
		return convertType;
	} else {
		throw new IllegalStateException();
	}
}