raboof/pekko
1
0
Fork 0
Code Issues Pull requests Projects Releases 6 Packages Wiki Activity Actions 10

replace unicode arrows

Browse source 
* ⇒, →, ←
* because we don't want to show them in documentation snippets and
  then it's complicated to avoid that when snippets are
  located in src/test/scala in individual modules
* dont replace object `→` in FSM.scala and PersistentFSM.scala
This commit is contained in:
Patrik Nordwall 2019-02-09 15:25:39 +01:00
parent e4d38f92a4
commit 5c96a5f556
1521 changed files with 18846 additions and 18786 deletions
Download patch file Download diff file Expand all files Collapse all files

48
akka-stream/src/main/scala/akka/stream/impl/QueueSource.scala
View file

@ -63,43 +63,43 @@ import scala.concurrent.{ Future, Promise }
if (!buffer.isFull) {
enqueueAndSuccess(offer)
} else overflowStrategy match {
case s: DropHead ⇒
case s: DropHead =>
log.log(s.logLevel, "Dropping the head element because buffer is full and overflowStrategy is: [DropHead]")
buffer.dropHead()
enqueueAndSuccess(offer)
case s: DropTail ⇒
case s: DropTail =>
log.log(s.logLevel, "Dropping the tail element because buffer is full and overflowStrategy is: [DropTail]")
buffer.dropTail()
enqueueAndSuccess(offer)
case s: DropBuffer ⇒
case s: DropBuffer =>
log.log(s.logLevel, "Dropping all the buffered elements because buffer is full and overflowStrategy is: [DropBuffer]")
buffer.clear()
enqueueAndSuccess(offer)
case s: DropNew ⇒
case s: DropNew =>
log.log(s.logLevel, "Dropping the new element because buffer is full and overflowStrategy is: [DropNew]")
offer.promise.success(QueueOfferResult.Dropped)
case s: Fail ⇒
case s: Fail =>
log.log(s.logLevel, "Failing because buffer is full and overflowStrategy is: [Fail]")
val bufferOverflowException = BufferOverflowException(s"Buffer overflow (max capacity was: $maxBuffer)!")
offer.promise.success(QueueOfferResult.Failure(bufferOverflowException))
completion.failure(bufferOverflowException)
failStage(bufferOverflowException)
case s: Backpressure ⇒
case s: Backpressure =>
log.log(s.logLevel, "Backpressuring because buffer is full and overflowStrategy is: [Backpressure]")
pendingOffer match {
case Some(_) ⇒
case Some(_) =>
offer.promise.failure(new IllegalStateException("You have to wait for previous offer to be resolved to send another request"))
case None ⇒
case None =>
pendingOffer = Some(offer)
}
}
}
private val callback = getAsyncCallback[Input[T]] {
case Offer(_, promise) if terminating ⇒
case Offer(_, promise) if terminating =>
promise.success(QueueOfferResult.Dropped)
case offer @ Offer(elem, promise) ⇒
case offer @ Offer(elem, promise) =>
if (maxBuffer != 0) {
bufferElem(offer)
if (isAvailable(out)) push(out, buffer.dequeue())
@ -109,32 +109,32 @@ import scala.concurrent.{ Future, Promise }
} else if (pendingOffer.isEmpty)
pendingOffer = Some(offer)
else overflowStrategy match {
case s @ (_: DropHead | _: DropBuffer) ⇒
case s @ (_: DropHead | _: DropBuffer) =>
log.log(s.logLevel, "Dropping element because buffer is full and overflowStrategy is: [{}]", s)
pendingOffer.get.promise.success(QueueOfferResult.Dropped)
pendingOffer = Some(offer)
case s @ (_: DropTail | _: DropNew) ⇒
case s @ (_: DropTail | _: DropNew) =>
log.log(s.logLevel, "Dropping element because buffer is full and overflowStrategy is: [{}]", s)
promise.success(QueueOfferResult.Dropped)
case s: Fail ⇒
case s: Fail =>
log.log(s.logLevel, "Failing because buffer is full and overflowStrategy is: [Fail]")
val bufferOverflowException = BufferOverflowException(s"Buffer overflow (max capacity was: $maxBuffer)!")
promise.success(QueueOfferResult.Failure(bufferOverflowException))
completion.failure(bufferOverflowException)
failStage(bufferOverflowException)
case s: Backpressure ⇒
case s: Backpressure =>
log.log(s.logLevel, "Failing because buffer is full and overflowStrategy is: [Backpressure]")
promise.failure(new IllegalStateException("You have to wait for previous offer to be resolved to send another request"))
}
case Completion ⇒
case Completion =>
if (maxBuffer != 0 && buffer.nonEmpty || pendingOffer.nonEmpty) terminating = true
else {
completion.success(Done)
completeStage()
}
case Failure(ex) ⇒
case Failure(ex) =>
completion.failure(ex)
failStage(ex)
}
@ -143,10 +143,10 @@ import scala.concurrent.{ Future, Promise }
override def onDownstreamFinish(): Unit = {
pendingOffer match {
case Some(Offer(_, promise)) ⇒
case Some(Offer(_, promise)) =>
promise.success(QueueOfferResult.QueueClosed)
pendingOffer = None
case None ⇒ // do nothing
case None => // do nothing
}
completion.success(Done)
completeStage()
@ -155,7 +155,7 @@ import scala.concurrent.{ Future, Promise }
override def onPull(): Unit = {
if (maxBuffer == 0) {
pendingOffer match {
case Some(Offer(elem, promise)) ⇒
case Some(Offer(elem, promise)) =>
push(out, elem)
promise.success(QueueOfferResult.Enqueued)
pendingOffer = None
@ -163,15 +163,15 @@ import scala.concurrent.{ Future, Promise }
completion.success(Done)
completeStage()
}
case None ⇒
case None =>
}
} else if (buffer.nonEmpty) {
push(out, buffer.dequeue())
pendingOffer match {
case Some(offer) ⇒
case Some(offer) =>
enqueueAndSuccess(offer)
pendingOffer = None
case None ⇒ //do nothing
case None => //do nothing
}
if (terminating && buffer.isEmpty) {
completion.success(Done)
@ -185,8 +185,8 @@ import scala.concurrent.{ Future, Promise }
val p = Promise[QueueOfferResult]
callback.invokeWithFeedback(Offer(element, p))
.onComplete {
case scala.util.Success(_) ⇒
case scala.util.Failure(e) ⇒ p.tryFailure(e)
case scala.util.Success(_) =>
case scala.util.Failure(e) => p.tryFailure(e)
}(akka.dispatch.ExecutionContexts.sameThreadExecutionContext)
p.future
}