import graphql.schema.GraphQLEnumType; //导入依赖的package包/类
@SuppressWarnings("JdkObsolete")
static Set<GraphQLType> getAllTypes(GraphQLSchema schema) {
  LinkedHashSet<GraphQLType> types = new LinkedHashSet<>();
  LinkedList<GraphQLObjectType> loop = new LinkedList<>();
  loop.add(schema.getQueryType());
  types.add(schema.getQueryType());

  while (!loop.isEmpty()) {
    for (GraphQLFieldDefinition field : loop.pop().getFieldDefinitions()) {
      GraphQLType type = field.getType();
      if (type instanceof GraphQLList) {
        type = ((GraphQLList) type).getWrappedType();
      }
      if (!types.contains(type)) {
        if (type instanceof GraphQLEnumType) {
          types.add(field.getType());
        }
        if (type instanceof GraphQLObjectType) {
          types.add(type);
          loop.add((GraphQLObjectType) type);
        }
      }
    }
  }
  return types;
}
 

import graphql.schema.GraphQLEnumType; //导入依赖的package包/类
@Override
public Object get(DataFetchingEnvironment environment) {
  Object source = environment.getSource();
  if (source == null) {
    return null;
  }
  if (source instanceof Map) {
    return ((Map<?, ?>) source).get(name);
  }
  GraphQLType type = environment.getFieldType();
  if (type instanceof GraphQLNonNull) {
    type = ((GraphQLNonNull) type).getWrappedType();
  }
  if (type instanceof GraphQLList) {
    return call(source, "get" + LOWER_CAMEL_TO_UPPER.convert(name) + "List");
  }
  if (type instanceof GraphQLEnumType) {
    Object o = call(source, "get" + LOWER_CAMEL_TO_UPPER.convert(name));
    if (o != null) {
      return o.toString();
    }
  }

  return call(source, "get" + LOWER_CAMEL_TO_UPPER.convert(name));
}
 

import graphql.schema.GraphQLEnumType; //导入依赖的package包/类
private void buildValidArgs(boolean isListFetcher) { 
	validArgs = new LinkedList<GraphQLArgument>();
	validArgs.addAll(arguments.values());
	//Only accept the f argument if we can actually do anything with it. 
	if (fetchers.size() > 0) {
		String enumName = resource.getBeanClass().getSimpleName() + (isListFetcher ? "s" : "") + "_functions";
		GraphQLEnumType.Builder functionNamesEnum = GraphQLEnumType.newEnum()
			.name(enumName);
		for (String functionName : fetchers.keySet()) { 
			functionNamesEnum.value(functionName);
		}
		validArgs.add(GraphQLArgument.newArgument()
			.name("f")
			.type(functionNamesEnum.build())
			.build());
	}
}
 

import graphql.schema.GraphQLEnumType; //导入依赖的package包/类
@SuppressWarnings("serial")
@Test
public void testRecursiveTypes() {
	GraphQLList listType = (GraphQLList) graphQLObjectMapper
			.getOutputType(new TypeToken<Map<TestEnum, List<List<List<List<List<List<String>>>>>>>>() {
			}.getType());
	GraphQLObjectType outputType = (GraphQLObjectType) listType.getWrappedType();

	assertEquals("Map_TestEnum_List_List_List_List_List_List_String", outputType.getName());

	GraphQLEnumType keyType = (GraphQLEnumType) outputType.getFieldDefinition(MapMapper.KEY_NAME).getType();
	GraphQLType valueType = outputType.getFieldDefinition(MapMapper.VALUE_NAME).getType();
	int depth = 0;
	while (valueType.getClass() == GraphQLList.class) {
		depth++;
		valueType = ((GraphQLList) valueType).getWrappedType();
	}
	assertEquals(6, depth);

	// now we verify the key type
	assertEquals(Scalars.GraphQLString, valueType);
}
 

import graphql.schema.GraphQLEnumType; //导入依赖的package包/类
protected GraphQLOutputType generateOutputType(Object object) {
    //An enum is a special case in both java and graphql,
    //and must be checked for while generating other kinds of types
    GraphQLEnumType enumType = generateEnumType(object);
    if (enumType != null) {
        return enumType;
    }
    
    List<GraphQLFieldDefinition> fields = getOutputFieldDefinitions(object);
    if (fields == null || fields.isEmpty()) {
        return null;
    }
    
    String typeName = getGraphQLTypeNameOrIdentityCode(object);
    GraphQLObjectType.Builder builder = newObject()
            .name(typeName)
            .fields(fields)
            .description(getTypeDescription(object));
    
    GraphQLInterfaceType[] interfaces = getInterfaces(object);
    if (interfaces != null) {
        builder.withInterfaces(interfaces);
    }
    return builder.build();
}
 

import graphql.schema.GraphQLEnumType; //导入依赖的package包/类
protected GraphQLInputType generateInputType(Object object) {
    //An enum is a special case in both java and graphql,
    //and must be checked for while generating other kinds of types
    GraphQLEnumType enumType = generateEnumType(object);
    if (enumType != null) {
        return enumType;
    }
    
    List<GraphQLInputObjectField> fields = getInputFieldDefinitions(object);
    if (fields == null || fields.isEmpty()) {
        return null;
    }
    String typeName = getGraphQLTypeNameOrIdentityCode(object);
    
    GraphQLInputObjectType.Builder builder = new GraphQLInputObjectType.Builder();
    builder.name(typeName);
    builder.fields(fields);
    builder.description(getTypeDescription(object));
    return builder.build();
}
 

import graphql.schema.GraphQLEnumType; //导入依赖的package包/类
@Test
public void testEnum() {
    logger.debug("testEnum");
    Object enumObj = testContext.getOutputType(graphql.java.generator.Enum.class);
    Assert.assertThat(enumObj, instanceOf(GraphQLEnumType.class));
    Matcher<Iterable<GraphQLEnumValueDefinition>> hasItemsMatcher =
            hasItems(
                    hasProperty("name", is("A")),
                    hasProperty("name", is("B")),
                    hasProperty("name", is("C")));
    assertThat(((GraphQLEnumType)enumObj).getValues(), hasItemsMatcher);
    
    enumObj = testContext.getOutputType(graphql.java.generator.EmptyEnum.class);
    Assert.assertThat(enumObj, instanceOf(GraphQLEnumType.class));
    assertThat(((GraphQLEnumType)enumObj).getValues(),
            instanceOf(List.class));
    assertThat(((GraphQLEnumType)enumObj).getValues().size(),
            is(0));
}
 

import graphql.schema.GraphQLEnumType; //导入依赖的package包/类
@Override
public int getComplexity(ResolvedField node, int childScore) {
    String expression = node.getResolver().getComplexityExpression();
    if (expression == null) {
        GraphQLType fieldType = GraphQLUtils.unwrap(node.getFieldDefinition().getType());
        if (fieldType instanceof GraphQLScalarType || fieldType instanceof GraphQLEnumType) {
            return 1;
        }
        return 1 + childScore;
    }
    Bindings bindings = engine.createBindings();
    bindings.putAll(node.getArguments());
    bindings.put("childScore", childScore);
    try {
        return ((Number) engine.eval(expression, bindings)).intValue();
    } catch (ScriptException e) {
        throw new IllegalArgumentException(e);
    }
}
 

import graphql.schema.GraphQLEnumType; //导入依赖的package包/类
/**
 * Converts an enum to a GraphQLEnumType.
 * @param enumClazz the Enum to convert
 * @return A GraphQLEnum type for class.
 */
public GraphQLEnumType classToEnumType(Class<?> enumClazz) {
    if (enumConversions.containsKey(enumClazz)) {
        return enumConversions.get(enumClazz);
    }

    Enum [] values = (Enum []) enumClazz.getEnumConstants();

    GraphQLEnumType.Builder builder = newEnum().name(toValidNameName(enumClazz.getName()));

    for (Enum value : values) {
        builder.value(toValidNameName(value.name()), value);
    }

    GraphQLEnumType enumResult = builder.build();

    enumConversions.put(enumClazz, enumResult);

    return enumResult;
}
 

import graphql.schema.GraphQLEnumType; //导入依赖的package包/类
/** Returns a proto source file for the schema. */
public static String toTs(GraphQLSchema schema) {
  ArrayList<String> messages = new ArrayList<>();
  for (GraphQLType type : SchemaToProto.getAllTypes(schema)) {
    if (type instanceof GraphQLEnumType) {
      messages.add(toEnum((GraphQLEnumType) type));
    } else if (type instanceof GraphQLObjectType) {
      messages.add(toMessage((GraphQLObjectType) type));
    }
  }
  return HEADER + Joiner.on("\n\n").join(messages);
}
 

import graphql.schema.GraphQLEnumType; //导入依赖的package包/类
private static String toEnum(GraphQLEnumType type) {
  String types =
      type.getValues()
          .stream()
          .map(value -> value.getName())
          .filter(name -> !name.equals("UNRECOGNIZED"))
          .collect(Collectors.joining(", \n  "));
  return String.format("export enum %s {\n  %s\n}", type.getName() + "Enum", types);
}
 

import graphql.schema.GraphQLEnumType; //导入依赖的package包/类
private static String toType(GraphQLType type) {
  if (type instanceof GraphQLList) {
    return toType(((GraphQLList) type).getWrappedType()) + "[]";
  } else if (type instanceof GraphQLObjectType) {
    return type.getName();
  } else if (type instanceof GraphQLEnumType) {
    return type.getName() + "Enum";
  } else {
    return TYPE_MAP.get(type.getName());
  }
}
 

import graphql.schema.GraphQLEnumType; //导入依赖的package包/类
/** Returns a proto source file for the schema. */
public static String toProto(GraphQLSchema schema) {
  ArrayList<String> messages = new ArrayList<>();

  for (GraphQLType type : getAllTypes(schema)) {
    if (type instanceof GraphQLEnumType) {
      messages.add(toEnum((GraphQLEnumType) type));
    } else if (type instanceof GraphQLObjectType) {
      messages.add(toMessage((GraphQLObjectType) type));
    }
  }

  return HEADER + Joiner.on("\n\n").join(messages);
}
 

import graphql.schema.GraphQLEnumType; //导入依赖的package包/类
private static String toEnum(GraphQLEnumType type) {
  ArrayList<String> values = new ArrayList<>();
  int i = 0;
  for (GraphQLEnumValueDefinition value : type.getValues()) {
    if (value.getName().equals("UNRECOGNIZED")) {
      continue;
    }
    values.add(String.format("%s = %d;", value.getName(), i));
    i++;
  }
  return String.format(
      "message %s {\n %s\n enum Enum {\n%s\n}\n}",
      type.getName(), getJspb(type), Joiner.on("\n").join(values));
}
 

import graphql.schema.GraphQLEnumType; //导入依赖的package包/类
private static String toType(GraphQLType type) {
  if (type instanceof GraphQLList) {
    return "repeated " + toType(((GraphQLList) type).getWrappedType());
  } else if (type instanceof GraphQLObjectType) {
    return type.getName();
  } else if (type instanceof GraphQLEnumType) {
    return type.getName() + ".Enum";
  } else {
    return TYPE_MAP.get(type.getName());
  }
}
 

import graphql.schema.GraphQLEnumType; //导入依赖的package包/类
static GraphQLEnumType convert(EnumDescriptor descriptor) {
  GraphQLEnumType.Builder builder = GraphQLEnumType.newEnum().name(getReferenceName(descriptor));
  for (EnumValueDescriptor value : descriptor.getValues()) {
    builder.value(value.getName());
  }
  return builder.build();
}
 

import graphql.schema.GraphQLEnumType; //导入依赖的package包/类
@Test
public void convertShouldWorkForEnums() {
  GraphQLEnumType result = ProtoToGql.convert(TestEnum.getDescriptor());
  assertThat(result.getName())
      .isEqualTo("javatests_com_google_api_graphql_rejoiner_proto_Proto2_TestEnum");
  assertThat(result.getValues()).hasSize(3);
  assertThat(result.getValues().stream().map(a -> a.getName()).toArray())
      .asList()
      .containsExactly("UNKNOWN", "FOO", "BAR");
}
 

import graphql.schema.GraphQLEnumType; //导入依赖的package包/类
public static GraphQLEnumType gqlEnumBuilder(Class<? extends Enum<?>> enumClazz) { 
	Enum<?>[] constants = enumClazz.getEnumConstants();
	GraphQLEnumType.Builder builder = GraphQLEnumType.newEnum().name(enumClazz.getSimpleName());
	for (Enum<?> s : constants) { 
		builder.value(s.name(), s);
	}
	return builder.build();
}
 

import graphql.schema.GraphQLEnumType; //导入依赖的package包/类
@Override
public GraphQLOutputType getOutputType(IGraphQLObjectMapper graphQLObjectMapper, Type type) {
	Class<?> classType = (Class<?>) type;
	Class<?> enumClassType = classType.getComponentType();
	GraphQLEnumType.Builder enumType = GraphQLEnumType.newEnum()
			.name(graphQLObjectMapper.getTypeNamingStrategy().getTypeName(graphQLObjectMapper, enumClassType));

	for (Object value : enumClassType.getEnumConstants()) {
		enumType.value(value.toString(), value);
	}
	return new GraphQLList(enumType.build());

}
 

import graphql.schema.GraphQLEnumType; //导入依赖的package包/类
@Override
public GraphQLInputType getInputType(IGraphQLObjectMapper graphQLObjectMapper, Type type) {
	Class<?> classType = (Class<?>) type;
	Class<?> enumClassType = classType.getComponentType();
	GraphQLEnumType.Builder enumType = GraphQLEnumType.newEnum()
			.name(graphQLObjectMapper.getTypeNamingStrategy().getTypeName(graphQLObjectMapper, enumClassType));

	for (Object value : enumClassType.getEnumConstants()) {
		enumType.value(value.toString(), value);
	}
	return new GraphQLList(enumType.build());
}