import io.swagger.models.properties.DoubleProperty; //导入依赖的package包/类
private static void initPropertyMap() {
  PROPERTY_MAP.put(BooleanProperty.class, SimpleType.constructUnsafe(Boolean.class));

  PROPERTY_MAP.put(FloatProperty.class, SimpleType.constructUnsafe(Float.class));
  PROPERTY_MAP.put(DoubleProperty.class, SimpleType.constructUnsafe(Double.class));
  PROPERTY_MAP.put(DecimalProperty.class, SimpleType.constructUnsafe(BigDecimal.class));

  PROPERTY_MAP.put(ByteProperty.class, SimpleType.constructUnsafe(Byte.class));
  PROPERTY_MAP.put(ShortProperty.class, SimpleType.constructUnsafe(Short.class));
  PROPERTY_MAP.put(IntegerProperty.class, SimpleType.constructUnsafe(Integer.class));
  PROPERTY_MAP.put(BaseIntegerProperty.class, SimpleType.constructUnsafe(Integer.class));
  PROPERTY_MAP.put(LongProperty.class, SimpleType.constructUnsafe(Long.class));

  // stringProperty包含了enum的场景，并不一定是转化为string
  // 但是，如果统一走StringPropertyConverter则可以处理enum的场景
  PROPERTY_MAP.put(StringProperty.class, SimpleType.constructUnsafe(String.class));

  PROPERTY_MAP.put(DateProperty.class, SimpleType.constructUnsafe(LocalDate.class));
  PROPERTY_MAP.put(DateTimeProperty.class, SimpleType.constructUnsafe(Date.class));

  PROPERTY_MAP.put(ByteArrayProperty.class, SimpleType.constructUnsafe(byte[].class));

  PROPERTY_MAP.put(FileProperty.class, SimpleType.constructUnsafe(Part.class));
}
 

import io.swagger.models.properties.DoubleProperty; //导入依赖的package包/类
private static Property getSwaggerArrayProperty(TypeToken<?> typeToken) {
  Class<?> type = typeToken.getRawType();
  if (type == String.class) {
    return new StringProperty();
  } else if (type == Boolean.class || type == Boolean.TYPE) {
    return new BooleanProperty();
  } else if (type == Integer.class || type == Integer.TYPE) {
    return new IntegerProperty();
  } else if (type == Long.class || type == Long.TYPE) {
    return new LongProperty();
  } else if (type == Float.class || type == Float.TYPE) {
    return new FloatProperty();
  } else if (type == Double.class || type == Double.TYPE) {
    return new DoubleProperty();
  } else if (type == byte[].class) {
    return new ByteArrayProperty();
  } else if (type.isEnum()) {
    return new StringProperty();
  }
  throw new IllegalArgumentException("invalid property type");
}
 

import io.swagger.models.properties.DoubleProperty; //导入依赖的package包/类
private Property makeProperty(PropertyDescription pd) {
    switch (pd.typeName) {
    case BOOLEAN:
        return new BooleanProperty();
    case BYTES:
        return new BinaryProperty();
    case COLLECTION:
        return new ArrayProperty(makeProperty(pd.elementDescription));
    case DATE:
        return new DateTimeProperty();
    case DOUBLE:
        return new DoubleProperty();
    case ENUM:
        StringProperty prop = new StringProperty();
        if (pd.enumValues != null) {
            prop._enum(Arrays.asList(pd.enumValues));
        }
        return prop;
    case InternetAddressV4:
        return new StringProperty();
    case InternetAddressV6:
        return new StringProperty();
    case LONG:
        return new LongProperty();
    case MAP:
        return new MapProperty(new StringProperty());
    case PODO:
        return refProperty(pd);
    case STRING:
        return new StringProperty();
    case URI:
        return new StringProperty(Format.URI);
    default:
        throw new IllegalStateException("unknown type " + pd.typeName);
    }
}
 

import io.swagger.models.properties.DoubleProperty; //导入依赖的package包/类
private void setResponseType(Response response, String type) {
    try {
        Class<?> clazz;
        switch (type) {
        case "int":
        case "long":
        case "short":
        case "byte":
        case "double":
        case "float":
            clazz = Double.class;
            break;
        case "char":
            clazz = Character.class;
            break;
        case "boolean":
            clazz = Boolean.class;
            break;
        default:
            clazz = Class.forName(type);
        }

        if (clazz == Object.class || clazz == JsonObject.class) {
            // a generic JSON
            response.setSchema(new ObjectProperty());
        } else if (Number.class.isAssignableFrom(clazz)) {
            response.setSchema(new DoubleProperty());
        } else if (clazz == Boolean.class) {
            response.setSchema(new BooleanProperty());
        } else if (clazz == String.class || clazz == Character.class) {
            response.setSchema(new StringProperty());
        } else if (clazz != Void.class) {
            response.setSchema(refProperty(modelForPodo(clazz)));
        }
    } catch (ClassNotFoundException ex) {
        Logger.getLogger(SwaggerAssembler.class.getName()).log(Level.SEVERE, null, ex);
    }
}
 

import io.swagger.models.properties.DoubleProperty; //导入依赖的package包/类
public static Property getItems(DataType dataType) {
	if (DataType.String.equals(dataType))
		return new StringProperty();
	else if (DataType.Integer.equals(dataType))
		return new IntegerProperty();
	else if (DataType.Boolean.equals(dataType))
		return new BooleanProperty();
	else if (DataType.Number.equals(dataType))
		return new DoubleProperty();
	return null;
}
 

import io.swagger.models.properties.DoubleProperty; //导入依赖的package包/类
@Test
public void map_ReturnsEmptyMap_ForNonArraySchema() {
  // Assert
  TupleEntity entity = new TupleEntity(
      ImmutableMap.of(MediaType.APPLICATION_JSON_TYPE, new DoubleProperty()), result);

  // Act
  Object mappedEntity = tupleEntityMapper.map(entity, MediaType.APPLICATION_JSON_TYPE);

  // Assert
  assertThat(mappedEntity, equalTo(ImmutableMap.of()));
}
 

import io.swagger.models.properties.DoubleProperty; //导入依赖的package包/类
@Before
public void setUp() {
  schemaMapper = new DoubleSchemaMapper();
  property = new DoubleProperty();

  when(entityBuilderContext.getLdPathExecutor()).thenReturn(ldPathExecutor);
  schemaMapperAdapter = new SchemaMapperAdapter(Arrays.asList(schemaMapper));
}
 

import io.swagger.models.properties.DoubleProperty; //导入依赖的package包/类
public static String getDefaultValue(Property property){
    Validate.notNull(property, "property must not be null!");
    String defaultValue = "";
    if(property instanceof BooleanProperty){
        BooleanProperty booleanProperty = (BooleanProperty)property;
        defaultValue = Objects.toString(booleanProperty.getDefault(), "");
    }else if(property instanceof StringProperty){
        StringProperty stringProperty = (StringProperty)property;
        defaultValue = Objects.toString(stringProperty.getDefault(), "");
    }else if(property instanceof DoubleProperty){
        DoubleProperty doubleProperty = (DoubleProperty)property;
        defaultValue = Objects.toString(doubleProperty.getDefault(), "");
    }else if(property instanceof FloatProperty){
        FloatProperty floatProperty = (FloatProperty)property;
        defaultValue = Objects.toString(floatProperty.getDefault(), "");
    }else if(property instanceof IntegerProperty){
        IntegerProperty integerProperty = (IntegerProperty)property;
        defaultValue = Objects.toString(integerProperty.getDefault(), "");
    }
    else if(property instanceof LongProperty){
        LongProperty longProperty = (LongProperty)property;
        defaultValue = Objects.toString(longProperty.getDefault(), "");
    }
    else if(property instanceof UUIDProperty){
        UUIDProperty uuidProperty = (UUIDProperty)property;
        defaultValue = Objects.toString(uuidProperty.getDefault(), "");
    }
    return defaultValue;
}
 

import io.swagger.models.properties.DoubleProperty; //导入依赖的package包/类
@Override
public Double mapTupleValue(@NonNull DoubleProperty schema, @NonNull ValueContext valueContext) {
  return SchemaMapperUtils.castLiteralValue(valueContext.getValue()).doubleValue();
}
 

import io.swagger.models.properties.DoubleProperty; //导入依赖的package包/类
@Override
public boolean supports(@NonNull Property schema) {
  return schema instanceof DoubleProperty;
}