Scala：读取 Enumerator[T] 的一些数据并返回剩余的 Enumerator[T]

Question

我正在使用使用 Iteratees 和 Enumerators 的 playframework 的异步 I/O 库。我现在有一个 Iterator[T] 作为数据接收器（为简单起见，它是一个将其内容存储到文件中的 Iterator[Byte]）。这个 Iterator[Byte] 被传递给处理写入的函数。

但在写之前我想在文件开头添加一些统计信息（为了简化说它是一个字节），所以我在将迭代器传递给写函数之前按以下方式传输它：

def write(value: Byte, output: Iteratee[Byte]): Iteratee[Byte] =
    Iteratee.flatten(output.feed(Input.El(value)))

当我现在从磁盘读取存储的文件时，我得到了一个 Enumerator[Byte]。 首先，我想读取并删除附加数据，然后我想将 Enumerator[Byte] 的其余部分传递给处理读取的函数。 所以我还需要对枚举器进行改造：

def read(input: Enumerator[Byte]): (Byte, Enumerator[Byte]) = {
   val firstEnumeratorEntry = ...
   val remainingEnumerator = ...
   (firstEnumeratorEntry, remainingEnumerator)
}

但我不知道该怎么做。如何从 Enumerator 读取一些字节并获取剩余的 Enumerator？

用OutputStream替换Iteratee[Byte]，用InputStream替换Enumerator[Byte]，这很容易：

def write(value: Byte, output: OutputStream) = {
    output.write(value)
    output
}
def read(input: InputStream) = (input.read,input)

但我需要播放框架的异步 I/O。

Answer 1

我想知道你是否可以从另一个角度解决你的目标。

那个将使用剩余枚举数的函数，我们称它为remaining，大概它适用于一个迭代器来处理余数：remaining |>> iteratee 产生另一个迭代器。让我们称这个结果为 iteratee iteratee2... 你能检查一下你是否可以获得对 iteratee2 的引用吗？如果是这种情况，那么您可以使用第一个迭代对象head 获取并处理第一个字节，然后通过 flatMap 组合head 和iteratee2：

val head = Enumeratee.take[Byte](1) &>> Iteratee.foreach[Byte](println)
val processing = for { h <- head; i <- iteratee2 } yield (h, i)
Iteratee.flatten(processing).run

如果您无法获得iteratee2 - 如果您的枚举器与您未实现的枚举器组合时就是这种情况 - 那么这种方法将不起作用。

Answer 2

这是通过在 Iteratee 和适当的（某种）状态累加器（此处为元组）内折叠来实现此目的的一种方法

我去读取routes 文件，第一个字节将作为Char 读取，另一个将作为UTF-8 字节串附加到String。

  def index = Action {
    /*let's do everything asyncly*/
    Async {
      /*for comprehension for read-friendly*/
      for (
        i <- read; /*read the file */
        (r:(Option[Char], String)) <- i.run /*"create" the related Promise and run it*/
      ) yield Ok("first : " + r._1.get + "\n" + "rest" + r._2) /* map the Promised result in a correct Request's Result*/
    }
  }


  def read = {
    //get the routes file in an Enumerator
    val file: Enumerator[Array[Byte]] = Enumerator.fromFile(Play.getFile("/conf/routes"))

    //apply the enumerator with an Iteratee that folds the data as wished
    file(Iteratee.fold((None, ""):(Option[Char], String)) { (acc, b) =>
       acc._1 match {
         /*on the first chunk*/ case None => (Some(b(0).toChar), acc._2 + new String(b.tail, Charset.forName("utf-8")))
         /*on other chunks*/ case x => (x, acc._2 + new String(b, Charset.forName("utf-8")))
       }
    })

  }

编辑

我发现了另一种使用 Enumeratee 的方法，但它需要创建 2 个 Enumerator s（一个短暂的）。但是，它是否更优雅一些。我们使用“一种” Enumeratee，但 Traversal 的工作水平比 Enumeratee（块级）更好。 我们使用 take 1 ，它只占用 1 个字节，然后关闭流。另一方面，我们使用drop，它只是删除第一个字节（因为我们使用的是 Enumerator[Array[Byte]]）

此外，现在read2 的签名比您希望的更接近，因为它返回 2 个枚举器（距离 Promise 和枚举器不远）

def index = Action {
  Async {
    val (first, rest) = read2
    val enee = Enumeratee.map[Array[Byte]] {bs => new String(bs, Charset.forName("utf-8"))}

    def useEnee(enumor:Enumerator[Array[Byte]]) = Iteratee.flatten(enumor &> enee |>> Iteratee.consume[String]()).run.asInstanceOf[Promise[String]]

    for {
      f <- useEnee(first);
      r <- useEnee(rest)
    } yield Ok("first : " + f + "\n" + "rest" + r)
  }
}

def read2 = {
  def create = Enumerator.fromFile(Play.getFile("/conf/routes"))

  val file: Enumerator[Array[Byte]] = create
  val file2: Enumerator[Array[Byte]] = create

  (file &> Traversable.take[Array[Byte]](1), file2 &> Traversable.drop[Array[Byte]](1))

}

Answer 3

实际上我们喜欢Iteratees，因为他们会作曲。因此，与其从原来的创建多个 Enumerators，不如按顺序组合两个 Iteratee（先读和再读），然后用您的单个 Enumerator 提供它。

为此，您需要一个顺序组合方法，现在我称之为andThen。这是一个粗略的实现。请注意，返回未使用的输入有点苛刻，也许可以使用基于 Input 类型的类型类自定义行为。它也不处理将剩余的东西从第一个迭代器传递给第二个迭代器（练习：）。

object Iteratees {
  def andThen[E, A, B](a: Iteratee[E, A], b: Iteratee[E, B]): Iteratee[E, (A,B)] = new Iteratee[E, (A,B)] {
    def fold[C](
        done: ((A, B), Input[E]) => Promise[C],
        cont: ((Input[E]) => Iteratee[E, (A, B)]) => Promise[C],
        error: (String, Input[E]) => Promise[C]): Promise[C] = {

      a.fold(
        (ra, aleft) => b.fold(
          (rb, bleft) => done((ra, rb), aleft /* could be magicop(aleft, bleft)*/),
          (bcont) => cont(e => bcont(e) map (rb => (ra, rb))),
          (s, err) => error(s, err)
        ),
        (acont) => cont(e => andThen[E, A, B](acont(e), b)),
        (s, err) => error(s, err)
      )
    }
  }
}

现在您可以使用以下内容：

object Application extends Controller {

  def index = Action { Async {

    val strings: Enumerator[String] = Enumerator("1","2","3","4")
    val takeOne = Cont[String, String](e => e match {
      case Input.El(e) => Done(e, Input.Empty)
      case x => Error("not enough", x)
    })
    val takeRest = Iteratee.consume[String]()
    val firstAndRest = Iteratees.andThen(takeOne, takeRest)

    val futureRes = strings(firstAndRest) flatMap (_.run)

    futureRes.map(x => Ok(x.toString)) // prints (1,234)
  } }

}