如何动态提供N个编解码器作为VectorCodec来处理字段，以记录不包含大小字节的二进制字段

Question

在解码器中考虑此功能：

  final def decodeCollect[F[_], A](dec: Decoder[A], limit: Option[Int])(buffer: BitVector)(implicit cbf: Factory[A, F[A]]): Attempt[DecodeResult[F[A]]] = {

我真正需要的是dec：Vector [Decoder [A]]，像这样：

  final def decodeCollect[F[_], A](dec: Vector[Decoder[A]], limit: Option[Int])(buffer: BitVector)(implicit cbf: Factory[A, F[A]]): Attempt[DecodeResult[F[A]]] = {

处理具有不自我描述的字段的二进制格式。文件的开头是描述记录，这​​些记录来自字段大小，以后必须在数据记录中应用这些字段大小。因此，我想建立一个解码器列表并将其应用N次，其中N是解码器的数量。

我可以编写一个以decodeCollect为模型的新函数，但是它需要一个隐式Factory，因此我可能必须编译scodec库并添加它。

使用scodec库中存在的方法有没有更简单的方法？处理工厂的方法还是其他方法？

Answer 1

我终于在编解码器代码库中破解了一个解决方案。现在那扇门已经打开，我将添加所需的任何东西，直到成功为止。

  final def decodeNCollect[F[_], A](dec: Vector[Decoder[A]])(buffer: BitVector)(implicit cbf: Factory[A, F[A]]): Attempt[DecodeResult[F[A]]] = {
    val bldr = cbf.newBuilder
    var remaining = buffer
    var count = 0
    val maxCount = dec.length
    var error: Option[Err] = None
    while (count < maxCount && remaining.nonEmpty) {
      dec(count).decode(remaining) match {
        case Attempt.Successful(DecodeResult(value, rest)) =>
          bldr += value
          count += 1
          remaining = rest
        case Attempt.Failure(err) =>
          error = Some(err.pushContext(count.toString))
          remaining = BitVector.empty
      }
    }
    Attempt.fromErrOption(error, DecodeResult(bldr.result, remaining))
  }

  final def encodeNSeq[A](encs: Vector[Encoder[A]])(seq: collection.immutable.Seq[A]): Attempt[BitVector] = {
    if (encs.length != seq.length)
      return Attempt.failure(Err("encodeNSeq: length of coders and items does not match"))
    val buf = new collection.mutable.ArrayBuffer[BitVector](seq.size)
    ((seq zip (0 until encs.length)): Seq[(A, Int)]) foreach { case (a, i) =>
      encs(i).encode(a) match {
        case Attempt.Successful(aa) => buf += aa
        case Attempt.Failure(err) => return Attempt.failure(err.pushContext(buf.size.toString))
      }
    }
    def merge(offset: Int, size: Int): BitVector = size match {
      case 0 => BitVector.empty
      case 1 => buf(offset)
      case n =>
        val half = size / 2
        merge(offset, half) ++ merge(offset + half, half + (if (size % 2 == 0) 0 else 1))
    }
    Attempt.successful(merge(0, buf.size))
  }


private[codecs] final class VectorNCodec[A](codecs: Vector[Codec[A]]) extends Codec[Vector[A]] {

  def sizeBound = SizeBound(0, Some(codecs.length.toLong))

  def encode(vector: Vector[A]) = Encoder.encodeNSeq(codecs)(vector)

  def decode(buffer: BitVector) =
    Decoder.decodeNCollect[Vector, A](codecs)(buffer)

  override def toString = s"vector($codecs)"

}

  def vectorOf[A](valueCodecs: Vector[Codec[A]]): Codec[Vector[A]] =
    provide(valueCodecs.length).
      flatZip { count => new VectorNCodec(valueCodecs) }.
      narrow[Vector[A]]({ case (cnt, xs) =>
        if (xs.size == cnt) Attempt.successful(xs)
        else Attempt.failure(Err(s"Insufficient number of elements: decoded ${xs.size} but should have decoded $cnt"))
      }, xs => (xs.size, xs)).
      withToString(s"vectorOf($valueCodecs)")