static List<ErrorDefinition> parseErrors( NamedTypesDefinition defs, ConjureTypeParserVisitor.ReferenceTypeResolver typeResolver) { Optional<String> defaultPackage = defs.defaultConjurePackage().map(p -> p.name()); ImmutableList.Builder<ErrorDefinition> errorsBuidler = ImmutableList.builder(); errorsBuidler.addAll(defs.errors().entrySet().stream().map(entry -> { TypeName typeName = TypeName.of( entry.getKey().name(), parsePackageOrElseThrow(entry.getValue().conjurePackage(), defaultPackage)); return parseErrorType(typeName, entry.getValue(), typeResolver); }).collect(Collectors.toList())); return errorsBuidler.build(); }
static Map<TypeName, TypeDefinition> parseObjects( com.palantir.conjure.parser.types.TypesDefinition parsed, ConjureTypeParserVisitor.ReferenceTypeResolver typeResolver) { Optional<String> defaultPackage = parsed.definitions().defaultConjurePackage().map(ConjurePackage::name); // no need to use validator here since TypeDefinitionParserVisitor calls each TypeDefinition parser that // validates its type. return parsed.definitions().objects().entrySet().stream() .map(entry -> entry.getValue().visit( new TypeDefinitionParserVisitor(entry.getKey().name(), defaultPackage, typeResolver))) .collect(Collectors.toMap(td -> td.accept(TypeDefinitionVisitor.TYPE_NAME), td -> td)); }
public static void recordMetrics(ConjureSourceFile definition) { Optional.ofNullable(SharedMetricRegistries.tryGetDefault()).ifPresent(metrics -> { metrics.counter(MetricRegistry.name(TypesDefinition.class, "conjure-imports")) .inc(definition.types().conjureImports().size()); metrics.counter(MetricRegistry.name(TypesDefinition.class, "imports")) .inc(definition.types().imports().size()); metrics.counter(MetricRegistry.name(NamedTypesDefinition.class, "services")) .inc(definition.services().size()); metrics.counter(MetricRegistry.name(NamedTypesDefinition.class, "types")) .inc(definition.types().definitions().objects().size()); metrics.counter(MetricRegistry.name(NamedTypesDefinition.class, "empty-default-conjure-package")) .inc(definition.types().definitions().defaultConjurePackage().isPresent() ? 0 : 1); metrics.counter(MetricRegistry.name(NamedTypesDefinition.class, "errors")) .inc(definition.types().definitions().errors().size()); }); } }
private static Type resolveFromTypeName( com.palantir.conjure.parser.types.names.TypeName name, TypesDefinition types) { Optional<String> defaultPackage = types.definitions().defaultConjurePackage().map(ConjureParserUtils::parseConjurePackage); BaseObjectTypeDefinition maybeDirectDef = types.definitions().objects().get(name); String conjurePackage; String typeName; if (maybeDirectDef == null) { ExternalTypeDefinition maybeExternalDef = types.imports().get(name); if (maybeExternalDef == null) { throw new IllegalStateException("Unknown LocalReferenceType: " + name); } String externalPath = maybeExternalDef.external().java(); int lastIndex = externalPath.lastIndexOf("."); conjurePackage = externalPath.substring(0, lastIndex); typeName = externalPath.substring(lastIndex + 1); return Type.external(ExternalReference.builder() .externalReference(TypeName.of(typeName, conjurePackage)) .fallback(ConjureParserUtils.parsePrimitiveType(maybeExternalDef.baseType())) .build()); } else { // Conjure-defined object conjurePackage = ConjureParserUtils.parsePackageOrElseThrow( maybeDirectDef.conjurePackage(), defaultPackage); return Type.reference(TypeName.of(name.name(), conjurePackage)); } } }