private[this] def isValid[T]()

in util-validator/src/main/scala/com/twitter/util/validation/ScalaValidator.scala [1269:1354]
80 lines of code
12 McCabe index (conditional complexity)

  private[this] def isValid[T](
    context: ValidationContext[T],
    constraint: Annotation,
    scalaType: ScalaType,
    value: Any,
    groups: Seq[Class[_]]
  ): Set[ConstraintViolation[T]] =
    isValid(context, constraint, scalaType, value, None, None, groups)

  private[this] def isValid[T](
    context: ValidationContext[T],
    constraint: Annotation,
    scalaType: ScalaType,
    value: Any,
    constraintDescriptorOption: Option[ConstraintDescriptorImpl[Annotation]],
    validatorOption: Option[ConstraintValidator[Annotation, Any]],
    groups: Seq[Class[_]]
  ): Set[ConstraintViolation[T]] = value match {
    case _: Option[_] =>
      isValidOption(
        context,
        constraint,
        scalaType,
        value,
        constraintDescriptorOption,
        validatorOption,
        groups)
    case _ =>
      val constraintDescriptor = constraintDescriptorOption match {
        case Some(descriptor) =>
          descriptor
        case _ =>
          constraintDescriptorFactory.newConstraintDescriptor(
            name = context.fieldName.orNull,
            clazz = scalaType.erasure,
            declaringClazz = context.rootClazz.getOrElse(scalaType.erasure),
            annotation = constraint
          )
      }

      if (!ignorable(value, constraint) && groupsEnabled(constraintDescriptor, groups)) {
        val refinedScalaType =
          Types.refineScalaType(value, scalaType)

        val constraintValidator: ConstraintValidator[Annotation, Any] = validatorOption match {
          case Some(validator) =>
            validator // should already be initialized
          case _ =>
            constraintValidatorManager
              .getInitializedValidator[Annotation](
                Types.getJavaType(refinedScalaType),
                constraintDescriptor,
                validatorFactory.constraintValidatorFactory,
                validatorFactory.validatorFactoryScopedContext.getConstraintValidatorInitializationContext
              ).asInstanceOf[ConstraintValidator[Annotation, Any]]
        }

        if (constraintValidator == null) {
          val configuration =
            if (context.path.toString.isEmpty) Classes.simpleName(scalaType.erasure)
            else context.path.toString
          throw new UnexpectedTypeException(
            s"No validator could be found for constraint '${constraint.annotationType()}' " +
              s"validating type '${scalaType.erasure.getName}'. " +
              s"Check configuration for '$configuration'")
        }
        // create validator context
        val constraintValidatorContext: ConstraintValidatorContext =
          constraintValidatorContextFactory.newConstraintValidatorContext(
            context.path,
            constraintDescriptor)
        // compute if valid
        if (constraintValidator.isValid(value, constraintValidatorContext)) Set.empty
        else {
          constraintViolationFactory.buildConstraintViolations[T](
            rootClazz = context.rootClazz,
            root = context.root,
            leaf = context.leaf,
            path = context.path,
            invalidValue = value,
            constraintDescriptor = constraintDescriptor,
            constraintValidatorContext = constraintValidatorContext
          )
        }
      } else Set.empty
  }