private <T extends TypeBuilder & WithAnnotation> MetadataType withNewAnnotations(T builder) { Set<TypeAnnotation> all = getAllTypeAnnotations(); for (TypeAnnotation typeAnnotation : all) { builder.with(typeAnnotation); } return builder.build(); }
public MetadataType build() { return builder.orElseThrow(() -> new RuntimeException("No type was specified.")).build(); }
private FunctionParameter build() { MetadataType type = metadataType != null ? metadataType : builder.build(); return new FunctionParameter(name, type); } }
@Override public IntersectionType build() { if (types.isEmpty()) { throw new RuntimeException("Tuple needs at least one type"); } final List<MetadataType> types = this.types.stream() .map((builder) -> builder.build()) .collect(Collectors.toList()); return new DefaultIntersectionType(types, format, annotations); } }
@Override public TupleType build() { if (types.isEmpty()) { throw new RuntimeException("Tuple needs at least one type"); } final List<MetadataType> types = this.types.stream() .map((builder) -> builder.build()) .collect(toList()); return new DefaultTupleType(types, format, annotations); }
@Override public MessageMetadataType build() { return new DefaultMessageMetadataType( payloadType.map(b -> b.build()), o -> payloadAnnotations.forEach((aClass, typeAnnotation) -> o.with(typeAnnotation)), attributesType.map(b -> b.build()), o -> attributesAnnotations.forEach((aClass, typeAnnotation) -> o.with(typeAnnotation)), annotations); }
@Override public AttributeFieldType build() { if (!name.isPresent() && !pattern.isPresent()) { throw new RuntimeException("No name or pattern was specified."); } final TypeBuilder<?> typeBuilder = this.value.orElseThrow(() -> new RuntimeException("No value was specified.")); final MetadataType build = typeBuilder.build(); final DefaultAttributeKeyType key = new DefaultAttributeKeyType(name, pattern, format, Collections.emptyMap()); return new DefaultAttributeFieldType(key, build, required, format, annotations); }
@Override public ObjectFieldType build() { return result.get(() -> { final ObjectKeyType keyType = keyBuilder.orElseThrow(() -> new RuntimeException("No field key was specified for building the ObjectType.")).build(); final MetadataType value = typeValue != null ? typeValue : valueBuilder.orElseThrow(() -> new RuntimeException("No field value was specified for building the ObjectType.")) .build(); return new DefaultObjectFieldType(keyType, value, required, repeated, format, annotations); }); }
private <T extends TypeBuilder & WithAnnotation> MetadataType withNewAnnotations(T builder) { Set<TypeAnnotation> all = getAllTypeAnnotations(); for (TypeAnnotation typeAnnotation : all) { builder.with(typeAnnotation); } return builder.build(); }
private ArrayType buildArrayType(TypeBuilder<?> arrayBuilder) { ArrayType type; AtomicReference<MetadataType> metadataTypeHolder = new AtomicReference<>(); if (isRecursiveType(arrayBuilder) || result.isDefined()) { type = result.get(() -> new DefaultArrayType(metadataTypeHolder::get, format, annotations)); metadataTypeHolder.set(type); } else { metadataTypeHolder.set(arrayBuilder.build()); type = result.get(() -> new DefaultArrayType(metadataTypeHolder::get, format, annotations)); } return type; }
@Override public Optional<MetadataType> load(String typeIdentifier, String typeAlias) { try (Reader bufferedReader = buildReader()) { JsonElement root = new JsonParser().parse(bufferedReader); String content = root.toString(); ExampleAnnotation example = new ExampleAnnotation(StringEscapeUtils.escapeJson(content)); final TypeBuilder<?> typeBuilder = new HandlerManager().handle(root, new ParsingContext().withAnnotation(example)); addTypeAlias(typeBuilder, typeAlias); return Optional.of(typeBuilder.build()); } catch (IOException e) { throw new RuntimeException(e); } }
@Override public Optional<MetadataType> load(String identifier, String typeAlias) { final Schema jsonSchema = getJsonSchemaLoader().loadSchema(); final TypeBuilder<?> typeBuilder = new HandlerManager().handle(jsonSchema, new ParsingContext()); MetadataTypeUtils.addTypeAlias(typeBuilder, typeAlias); return Optional.of(typeBuilder.build()); }
@Override public TypeBuilder<?> handle(JsonElement jsonElement, BaseTypeBuilder root, HandlerManager handlerManager, ParsingContext parsingContext) { JsonArray array = (JsonArray) jsonElement; final ArrayTypeBuilder arrayMetadataBuilder = root.arrayType(); parsingContext.getAnnotations().forEach(arrayMetadataBuilder::with); final JsonElement arraySample = getFirstChild(array); if (arraySample != null) { List<MetadataType> uniqueTypes = new ArrayList<>(); Map<MetadataType, TypeBuilder<?>> builders = new LinkedHashMap<>(); for (Iterator<JsonElement> it = array.iterator(); it.hasNext();) { JsonElement item = it.next(); TypeBuilder<?> itemBuilder = handlerManager.handle(item, new ParsingContext()); MetadataType type = itemBuilder.build(); if (!builders.containsKey(type)) { builders.put(type, itemBuilder); } } // Create union or simple type if (builders.size() > 1) { UnionTypeBuilder unionTypeBuilder = arrayMetadataBuilder.of().unionType(); builders.values().forEach(unionTypeBuilder::of); } else { arrayMetadataBuilder.of(handlerManager.handle(arraySample, new ParsingContext())); } } else { arrayMetadataBuilder.of().anyType(); } return arrayMetadataBuilder; }
assertParameter(parameters, "candidateDoors", "", TYPE_BUILDER.objectType() .openWith((objectTypeBuilder(KnockeableDoor.class)).build()) .with(new ClassInformationAnnotation(Map.class, asList(String.class, KnockeableDoor.class))) .build(),