static Builder builder() { return new Builder(); }
@Override public Type resolve(ForeignReferenceType reference) { ConjureImports conjureImports = types.conjureImports().get(reference.namespace()); Preconditions.checkNotNull(conjureImports, "Import not found for namespace: %s", reference.namespace()); return resolveFromTypeName(reference.type(), conjureImports.conjure().types()); }
@Test public void testParser_refType() throws ParseException { assertThat(TypeParser.INSTANCE.parse("Foo")) .isEqualTo(LocalReferenceType.of(TypeName.of("Foo"))); }
@Test public void testParser_foreignRefType() throws ParseException { assertThat(TypeParser.INSTANCE.parse("bar.Foo")) .isEqualTo(ForeignReferenceType.of(Namespace.of("bar"), TypeName.of("Foo"))); }
/** * Replaces the (typically empty) ImportedTypes object for each namespace by an object with inlined/populated * {@link ConjureImports#conjure()} imported definitions}. */ private Map<Namespace, ConjureImports> parseImports( Map<Namespace, ConjureImports> declaredImports, Path baseDir) { return declaredImports.entrySet().stream().collect(Collectors.toMap(Map.Entry::getKey, entry -> { String importedFile = entry.getValue().file(); ConjureSourceFile importedConjure = parse(baseDir.resolve(importedFile).toFile()); return ConjureImports.withResolvedImports(importedFile, importedConjure); })); }
public static TypeDefinition parseAliasType( TypeName name, com.palantir.conjure.parser.types.reference.AliasTypeDefinition def, ConjureTypeParserVisitor.ReferenceTypeResolver typeResolver) { return TypeDefinition.alias(AliasDefinition.builder() .typeName(name) .alias(def.alias().visit(new ConjureTypeParserVisitor(typeResolver))) .docs(def.docs().map(Documentation::of)) .build()); }
@Test public void testConjureExternalImports() { ConjureSourceFile conjure = ConjureParser.parse(new File("src/test/resources/example-external-types.yml")); assertThat(conjure.types().imports().get(TypeName.of("ExampleAnyImport")).baseType()) .isEqualTo(PrimitiveType.fromString("any")); }
@Override public Type resolve(LocalReferenceType reference) { return resolveFromTypeName(reference.type(), types); }
private static Map<TypeName, TypeDefinition> parseImportObjects(Map<Namespace, ConjureImports> conjureImports) { Map<TypeName, TypeDefinition> allDefinitions = Maps.newHashMap(); conjureImports.values().forEach(conjureImport -> { ConjureSourceFile conjureDef = conjureImport.conjure(); ReferenceTypeResolver importTypeResolver = new ConjureTypeParserVisitor.ByParsedRepresentationTypeNameResolver(conjureDef.types()); allDefinitions.putAll(parseImportObjects(conjureDef.types().conjureImports())); allDefinitions.putAll(parseObjects(conjureDef.types(), importTypeResolver)); }); return allDefinitions; }
.types(TypesDefinition.builder() .putImports(TypeName.of("ResourceIdentifier"), ExternalTypeDefinition.javaType( "com.palantir.ri.ResourceIdentifier", PrimitiveType.STRING)) .definitions(NamedTypesDefinition.builder() FieldDefinition.of(PrimitiveType.STRING)) .build()) .putObjects(TypeName.of("StringAlias"), AliasTypeDefinition.builder() .alias(PrimitiveType.STRING) .build()) .build()) .build()) .args(ImmutableMap.of(ParameterName.of("foo"), ArgumentDefinition.builder() .paramType(ArgumentDefinition.ParamType.HEADER) .type(LocalReferenceType.of(TypeName.of("StringAlias"))) .build())) .build())
@Override public LocalReferenceType parse(ParserState input) throws ParseException { input.mark(); String typeReference = REF_PARSER.parse(input); if (typeReference == null) { input.rewind(); return null; } input.release(); ConjureMetrics.incrementCounter(LocalReferenceType.class); return LocalReferenceType.of(TypeName.of(typeReference)); } }
@Override public ForeignReferenceType parse(ParserState input) throws ParseException { String namespace = NAMESPACE_PARSER.parse(input); if (Parsers.nullOrUnexpected(Parsers.expect(".").parse(input))) { return null; } String ref = TypeReferenceParser.REF_PARSER.parse(input); ConjureMetrics.incrementCounter(ForeignReferenceType.class); return ForeignReferenceType.of(Namespace.of(namespace), TypeName.of(ref)); } }