4

我正在使用使用 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)
}

但我不知道如何做到这一点。如何从枚举器中读取一些字节并获取剩余的枚举器？

将 Iteratee[Byte] 替换为 OutputStream 并将 Enumerator[Byte] 替换为 InputStream，这将非常简单：

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

但是我需要play框架的异步I/O。

4

3 回答 3

3

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

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

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- 如果您的枚举器与您未实现的枚举器组合时就是这种情况 - 那么这种方法将不起作用。

于 2012-06-09T06:07:55.663 回答
1

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

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

  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但它需要创建 2Enumerator秒（一个短命）。但是，它是否更优雅一些。我们使用一种“类型”的 Enumeratee，但Traversal它的工作水平比 Enumeratee（块级）更好。我们使用take1 只占用 1 个字节，然后关闭流。另一方面，我们使用drop它只是删除第一个字节（因为我们使用的是 Enumerator[Array[Byte]]）

此外，现在read2的签名比您希望的要近得多，因为它返回 2 个枚举器（距离 Promise、Enumerator 不远）

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))

}
于 2012-06-08T17:31:25.830 回答
1

实际上我们喜欢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)
  } }

}
于 2012-06-08T19:56:22.313 回答