private def nvl[T]()

in nlpcraft/src/main/scala/org/apache/nlpcraft/internal/impl/NCModelPipelineManager.scala [83:155]
40 lines of code
16 McCabe index (conditional complexity)

    private def nvl[T](list: List[T]): Seq[T] = if list == null then List.empty else list

    /**
      *
      * @param m
      */
    private def mkProps(m: NCPropertyMap): String =
        if m.keysSet.isEmpty then ""
        else m.keysSet.toSeq.sorted.map(p => s"$p=${m(p)}").mkString("{", ", ", "}")

    /**
      *
      * @param txt
      * @param data
      * @param usrId
      */
    def prepare(txt: String, data: Map[String, Any], usrId: String): NCPipelineData =
        require(txt != null && usrId != null)

        /**
          *
          * @param ents
          */
        def newVariant(ents: List[NCEntity]): NCVariant =
            new NCVariant:
                override val getEntities: List[NCEntity] = ents

        val req: NCRequest = new NCRequest:
            override val getUserId: String = usrId
            override val getRequestId: String = UUID.randomUUID().toString
            override val getText: String = txt
            override val getReceiveTimestamp: Long = System.currentTimeMillis()
            override val getRequestData: Map[String, Any] = data

        val toks = tokParser.tokenize(txt)

        if toks.nonEmpty then
            for (e <- tokEnrichers) e.enrich(req, cfg, toks)

        val tbl = NCAsciiTable("Text", "Start index", "End index", "Properties")

        for (t <- toks)
            tbl += (
                t.getText,
                t.getStartCharIndex,
                t.getEndCharIndex,
                mkProps(t)
            )
        tbl.info(logger, s"Tokens for: ${req.getText}".?)

        // NOTE: we run validators regardless of whether token list is empty.
        for (v <- tokVals) v.validate(req, cfg, toks)

        var entities: List[NCEntity] = List.empty

        for (p <- entParsers) entities ++= p.parse(req, cfg, toks)

        if entities.nonEmpty then
            for (e <- entEnrichers) e.enrich(req, cfg, entities)

        // NOTE: we run validators regardless of whether entity list is empty.
        for (v <- entVals) v.validate(req, cfg, entities)

        for (m <- entMappers)
            entities = m.map(req, cfg, entities)
            if entities == null then E("Entity mapper cannot return null values.")

        val overlapEnts: Seq[Set[NCEntity]] =
            toks.
            // Looks at each token.
            map(t => t.getIndex -> entities.filter(_.getTokens.contains(t))).
            // Collects all overlapped entities.
            map { case (_, ents) => if ents.sizeIs > 1 then ents.toSet else Set.empty }.filter(_.nonEmpty)