func()

in _examples/enum/api/exec.go [99:286]

• 142 lines of code
• 46 McCabe index (conditional complexity)

func (e *executableSchema) Complexity(typeName, field string, childComplexity int, rawArgs map[string]interface{}) (int, bool) {
	ec := executionContext{nil, e, 0, 0, nil}
	_ = ec
	switch typeName + "." + field {

	case "Query.boolTyped":
		if e.complexity.Query.BoolTyped == nil {
			break
		}

		args, err := ec.field_Query_boolTyped_args(context.TODO(), rawArgs)
		if err != nil {
			return 0, false
		}

		return e.complexity.Query.BoolTyped(childComplexity, args["arg"].(model.BoolTyped)), true

	case "Query.boolTypedN":
		if e.complexity.Query.BoolTypedN == nil {
			break
		}

		args, err := ec.field_Query_boolTypedN_args(context.TODO(), rawArgs)
		if err != nil {
			return 0, false
		}

		return e.complexity.Query.BoolTypedN(childComplexity, args["arg"].(*model.BoolTyped)), true

	case "Query.boolUntyped":
		if e.complexity.Query.BoolUntyped == nil {
			break
		}

		args, err := ec.field_Query_boolUntyped_args(context.TODO(), rawArgs)
		if err != nil {
			return 0, false
		}

		return e.complexity.Query.BoolUntyped(childComplexity, args["arg"].(bool)), true

	case "Query.boolUntypedN":
		if e.complexity.Query.BoolUntypedN == nil {
			break
		}

		args, err := ec.field_Query_boolUntypedN_args(context.TODO(), rawArgs)
		if err != nil {
			return 0, false
		}

		return e.complexity.Query.BoolUntypedN(childComplexity, args["arg"].(*bool)), true

	case "Query.inPackage":
		if e.complexity.Query.InPackage == nil {
			break
		}

		args, err := ec.field_Query_inPackage_args(context.TODO(), rawArgs)
		if err != nil {
			return 0, false
		}

		return e.complexity.Query.InPackage(childComplexity, args["arg"].(InPackage)), true

	case "Query.intTyped":
		if e.complexity.Query.IntTyped == nil {
			break
		}

		args, err := ec.field_Query_intTyped_args(context.TODO(), rawArgs)
		if err != nil {
			return 0, false
		}

		return e.complexity.Query.IntTyped(childComplexity, args["arg"].(model.IntTyped)), true

	case "Query.intTypedN":
		if e.complexity.Query.IntTypedN == nil {
			break
		}

		args, err := ec.field_Query_intTypedN_args(context.TODO(), rawArgs)
		if err != nil {
			return 0, false
		}

		return e.complexity.Query.IntTypedN(childComplexity, args["arg"].(*model.IntTyped)), true

	case "Query.intUntyped":
		if e.complexity.Query.IntUntyped == nil {
			break
		}

		args, err := ec.field_Query_intUntyped_args(context.TODO(), rawArgs)
		if err != nil {
			return 0, false
		}

		return e.complexity.Query.IntUntyped(childComplexity, args["arg"].(int)), true

	case "Query.intUntypedN":
		if e.complexity.Query.IntUntypedN == nil {
			break
		}

		args, err := ec.field_Query_intUntypedN_args(context.TODO(), rawArgs)
		if err != nil {
			return 0, false
		}

		return e.complexity.Query.IntUntypedN(childComplexity, args["arg"].(*int)), true

	case "Query.stringTyped":
		if e.complexity.Query.StringTyped == nil {
			break
		}

		args, err := ec.field_Query_stringTyped_args(context.TODO(), rawArgs)
		if err != nil {
			return 0, false
		}

		return e.complexity.Query.StringTyped(childComplexity, args["arg"].(model.StringTyped)), true

	case "Query.stringTypedN":
		if e.complexity.Query.StringTypedN == nil {
			break
		}

		args, err := ec.field_Query_stringTypedN_args(context.TODO(), rawArgs)
		if err != nil {
			return 0, false
		}

		return e.complexity.Query.StringTypedN(childComplexity, args["arg"].(*model.StringTyped)), true

	case "Query.stringUntyped":
		if e.complexity.Query.StringUntyped == nil {
			break
		}

		args, err := ec.field_Query_stringUntyped_args(context.TODO(), rawArgs)
		if err != nil {
			return 0, false
		}

		return e.complexity.Query.StringUntyped(childComplexity, args["arg"].(string)), true

	case "Query.stringUntypedN":
		if e.complexity.Query.StringUntypedN == nil {
			break
		}

		args, err := ec.field_Query_stringUntypedN_args(context.TODO(), rawArgs)
		if err != nil {
			return 0, false
		}

		return e.complexity.Query.StringUntypedN(childComplexity, args["arg"].(*string)), true

	case "Query.varTyped":
		if e.complexity.Query.VarTyped == nil {
			break
		}

		args, err := ec.field_Query_varTyped_args(context.TODO(), rawArgs)
		if err != nil {
			return 0, false
		}

		return e.complexity.Query.VarTyped(childComplexity, args["arg"].(model.VarTyped)), true

	case "Query.varUntyped":
		if e.complexity.Query.VarUntyped == nil {
			break
		}

		args, err := ec.field_Query_varUntyped_args(context.TODO(), rawArgs)
		if err != nil {
			return 0, false
		}

		return e.complexity.Query.VarUntyped(childComplexity, args["arg"].(bool)), true

	}
	return 0, false
}