private String typeAccessor(DataSchema schema) { DataSchema.Type schemaType = schema.getType(); String swiftyType = swiftyTypeAccessors.get(schemaType); if (swiftyType == null) { throw new IllegalArgumentException("unrecognized type: " + schemaType); } return swiftyType; }
private String typeEnumSymbol(DataSchema schema) { DataSchema.Type schemaType = schema.getType(); String swiftyType = swiftyTypeEnumSymbols.get(schemaType); if (swiftyType == null) { throw new IllegalArgumentException("unrecognized type: " + schemaType); } return swiftyType; }
@Override public boolean evaluate(DataElement element) { DataSchema schema = element.getSchema(); return (schema != null && schema.getType() == _type); }
private static DataSchema dereferenceIfTyperef(DataSchema schema) { final DataSchema.Type type = schema.getType(); return type == DataSchema.Type.TYPEREF ? ((TyperefDataSchema) schema).getRef() : null; }
private static DataSchema dereferenceIfTyperef(DataSchema schema) { final DataSchema.Type type = schema.getType(); return type == DataSchema.Type.TYPEREF ? ((TyperefDataSchema) schema).getRef() : null; }
/** * Allow custom class to to bound to record or typeref of primitive types that are not enums. */ private static boolean allowCustomClass(DataSchema schema) { boolean result = false; final DataSchema.Type type = schema.getType(); if (type == DataSchema.Type.TYPEREF || type == DataSchema.Type.RECORD) { // allow custom class only if the dereferenced type is a record or a primitive types that are not enums final DataSchema dereferencedSchema = schema.getDereferencedDataSchema(); if (dereferencedSchema.getType() == DataSchema.Type.RECORD || (CodeUtil.isDirectType(dereferencedSchema) && dereferencedSchema.getType() != DataSchema.Type.ENUM)) { result = true; } } return result; }
private void checkPrimitive(DataSchema older, DataSchema newer) { DataSchema.Type newerType = newer.getType(); switch (newerType) { case LONG: checkAllowedOlderTypes(older.getType(), newerType, DataSchema.Type.INT); break; case FLOAT: checkAllowedOlderTypes(older.getType(), newerType, DataSchema.Type.INT, DataSchema.Type.LONG); break; case DOUBLE: checkAllowedOlderTypes(older.getType(), newerType, DataSchema.Type.INT, DataSchema.Type.LONG, DataSchema.Type.FLOAT); break; default: isSameType(older, newer); break; } }
@Override public Iterable<Map.Entry<String, Object>> orderMap(DataMap map) { if (_currentSchema != null && _currentSchema.getType() == DataSchema.Type.RECORD) { return orderMapEntries((RecordDataSchema) _currentSchema, map); } return Data.orderMapEntries(map); }
@Override public void index(int index) { DataSchema newSchema = null; if (_currentSchema != null && _currentSchema.getType() == DataSchema.Type.ARRAY) { ArrayDataSchema arraySchema = (ArrayDataSchema) _currentSchema; newSchema = arraySchema.getItems(); } _pendingSchema = newSchema; super.index(index); }
protected Object validatePrimitive(DataElement element, DataSchema schema, Object object) { Class<?> primitiveClass = _primitiveTypeToClassMap.get(schema.getType()); Object fixed = object; if (object.getClass() != primitiveClass) { if (_options.getCoercionMode() != CoercionMode.OFF) { fixed = fixupPrimitive(schema, object); if (fixed == object) { addMessage(element, "%1$s cannot be coerced to %2$s", String.valueOf(object), primitiveClass.getSimpleName()); } } else { addMessage(element, "%1$s is not backed by a %2$s", String.valueOf(object), primitiveClass.getSimpleName()); } } return fixed; }
/** * Returns the union member class name for the given {@link ClassTemplateSpec} as a Typescript * source code string. * * @return a typescript source code string identifying the union member. */ public String unionMemberTypeName() { DataSchema memberSchema = _memberSchema(); Type memberType = _memberSchema().getType(); if (memberSchema.isPrimitive() || memberType == Type.MAP || memberType == Type.ARRAY) { String unionMemberKey = _memberSchema().getUnionMemberKey(); String camelCasedName = Character.toUpperCase(unionMemberKey.charAt(0)) + unionMemberKey.substring(1); return camelCasedName + "Member"; // IntMember, DoubleMember, FixedMember etc } else if (memberSchema instanceof NamedDataSchema) { String className = ((NamedDataSchema) memberSchema).getName(); return className + "Member"; // e.g: FortuneCookieMember } else { throw new IllegalArgumentException("Don't know how to handle schema of type " + memberSchema.getType()); } }
private DataSchema currentSchema() { DataSchema schema = null; DataSchema listSchema = _element.getSchema(); if (listSchema != null) { DataSchema dereferencedListSchema = listSchema.getDereferencedDataSchema(); if (dereferencedListSchema.getType() == DataSchema.Type.ARRAY) { schema = ((ArrayDataSchema) dereferencedListSchema).getItems(); } } return schema; }
@Override public void callback(List<String> path, DataSchema schema) { if (schema.getType() != DataSchema.Type.RECORD) { return; } RecordDataSchema recordSchema = (RecordDataSchema) schema; for (RecordDataSchema.Field field : recordSchema.getFields()) { Object defaultData = field.getDefault(); if (defaultData != null) { path.add(DataSchemaConstants.DEFAULT_KEY); Object newDefault = translateField(pathList(path), defaultData, field); path.remove(path.size() - 1); field.setDefault(newDefault); } } }
private final void validateSchema(ValidatorContext context, DataSchema schema) { if (schema.getType() == DataSchema.Type.TYPEREF) { DataSchema refSchema = ((TyperefDataSchema) schema).getRef(); validateSchema(context, refSchema); getAndInvokeValidatorList(context, schema); } else { getAndInvokeValidatorList(context, schema); } }
@Override protected void encodeProperties(DataSchema schema) throws IOException { if (_options.getEmbeddedSchema() == EmbedSchemaMode.ROOT_ONLY) { DataSchema dereferencedSchema = _rootSchema.getDereferencedDataSchema(); if (schema == dereferencedSchema && schema.getType() != DataSchema.Type.UNION) { encodePropertiesWithEmbeddedSchema(schema); return; } } super.encodeProperties(schema); }
private ClassTemplateSpec determineDataClass(DataSchema schema, ClassTemplateSpec enclosingClass, String memberName) { final ClassTemplateSpec result; final DataSchema dereferencedSchema = schema.getDereferencedDataSchema(); if (dereferencedSchema.getType() == DataSchema.Type.ENUM) { result = PrimitiveTemplateSpec.getInstance(DataSchema.Type.STRING); } else if (CodeUtil.isDirectType(dereferencedSchema)) { result = getPrimitiveClassForSchema((PrimitiveDataSchema) dereferencedSchema, enclosingClass, memberName); } else { result = null; } return result; }
private String getParameterItems(ParameterSchema param, DataSchemaResolver resolver) { if (param.hasItems()) { _infoMap.addRestSpecInfo(CompatibilityInfo.Type.DEPRECATED, _infoPath, "The \"items\" field"); return param.getItems(GetMode.DEFAULT); } final DataSchema paramDataSchema = RestSpecCodec.textToSchema(param.getType(GetMode.DEFAULT), resolver); if (paramDataSchema instanceof ArrayDataSchema) { // Union member key works because previously only primitive types are allowed for items field return ((ArrayDataSchema) paramDataSchema).getItems().getUnionMemberKey(); } else { _infoMap.addRestSpecInfo("type", CompatibilityInfo.Type.TYPE_ERROR, _infoPath, "expect an array, got " + paramDataSchema.getType()); return null; } }
private Expr readTypeExpr(Expr expr, ClassTemplateSpec spec) { DataSchema.Type schemaType = spec.getSchema().getType(); Expr className = expr(spec.getClassName()); switch (schemaType) { case ENUM: return className.enumRead(expr); case RECORD: case UNION: return className.readJSON(expr); case MAP: CourierMapTemplateSpec mapSpec = (CourierMapTemplateSpec)spec; ClassTemplateSpec valueSpec = selectMapValueType(mapSpec); return expr.mapValues(readTypeExpr($0, valueSpec, mapSpec.getCustomInfo(), false)); case ARRAY: ArrayTemplateSpec arraySpec = (ArrayTemplateSpec)spec; ClassTemplateSpec itemSpec = selectArrayItemsType(arraySpec); return expr.map(readTypeExpr($0, itemSpec, arraySpec.getCustomInfo(), false)); default: throw new IllegalArgumentException("unrecognized type: " + schemaType); } }
private void addParams(ActionRequestBuilder<?, ?> request, DynamicRecordMetadata requestMetadata, ParameterSchemaArray parameters) { if (parameters != null) { for (ParameterSchema parameter : parameters) { FieldDef<?> fieldDef = requestMetadata.getFieldDef(parameter.getName()); Object value = generateFieldDefValue(fieldDef); // For custom types(TypeRefs) we generate the example values using the dereferenced type. Changing the field-def // to the dereferenced type so the example values can be set on the request without coercing. if (fieldDef.getDataSchema().getType() == Type.TYPEREF) { FieldDef<?> deRefFieldDef = new FieldDef<>(fieldDef.getName(), fieldDef.getDataClass(), fieldDef.getDataSchema().getDereferencedDataSchema()); deRefFieldDef.getField().setRecord(fieldDef.getField().getRecord()); fieldDef = deRefFieldDef; } request.setParam(fieldDef, value); } } }