How to use

TypeName

in

com.palantir.conjure.parser.types.names

@JsonCreator
public static PrimitiveType fromString(String type) {
  return fromTypeName(TypeName.of(type))
      .orElseThrow(() -> new IllegalArgumentException("Unknown primitive type: " + type));
}

@Value.Check
protected final void check() {
  Preconditions.checkArgument(
      CUSTOM_TYPE_PATTERN.matcher(name()).matches() || PRIMITIVE_TYPES.contains(name()),
      "TypeNames must be a primitive type %s or match pattern %s: %s",
      PRIMITIVE_TYPES, CUSTOM_TYPE_PATTERN, name());
}

@Test
public void testParser_refType() throws ParseException {
  assertThat(TypeParser.INSTANCE.parse("Foo"))
      .isEqualTo(LocalReferenceType.of(TypeName.of("Foo")));
}

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();
}

@Test
public void testParser_foreignRefType() throws ParseException {
  assertThat(TypeParser.INSTANCE.parse("bar.Foo"))
      .isEqualTo(ForeignReferenceType.of(Namespace.of("bar"), TypeName.of("Foo")));
}

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));
}

  @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));
  }
}

servicesBuilder.add(parseService(
    service,
    TypeName.of(serviceName.name(), parseConjurePackage(service.conjurePackage())),
    typeResolver,
    dealiasingVisitor));

@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"));
}

  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));
    }
  }
}

@Test
public void testParseAlias_validReference() throws IOException {
  assertThat(mapper.readValue("alias: Foo", BaseObjectTypeDefinition.class))
      .isEqualTo(AliasTypeDefinition.builder().alias(LocalReferenceType.of(TypeName.of("Foo"))).build());
}

  @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));
  }
}

ConjureSourceFile.builder()
    .types(TypesDefinition.builder()
        .putImports(TypeName.of("ResourceIdentifier"),
            ExternalTypeDefinition.javaType(
                "com.palantir.ri.ResourceIdentifier", PrimitiveType.STRING))
        .definitions(NamedTypesDefinition.builder()
            .defaultConjurePackage(ConjurePackage.of("test.api"))
            .putObjects(TypeName.of("SimpleObject"), ObjectTypeDefinition.builder()
                .putFields(FieldName.of("stringField"),
                    FieldDefinition.of(PrimitiveType.STRING))
                .build())
            .putObjects(TypeName.of("StringAlias"), AliasTypeDefinition.builder()
                .alias(PrimitiveType.STRING)
                .build())
            .build())
        .build())
    .putServices(TypeName.of("TestService"), ServiceDefinition.builder()
        .doNotUseName("Test Service")
        .conjurePackage(ConjurePackage.of("test.api"))
            .args(ImmutableMap.of(ParameterName.of("foo"), ArgumentDefinition.builder()
                .paramType(ArgumentDefinition.ParamType.HEADER)
                .type(LocalReferenceType.of(TypeName.of("StringAlias")))
                .build()))
            .build())