Idempotency.stat

80 columns                                                                     |
<<< paulp example #192
class A {
  def traced(in: A => Unit, out: B => Unit): Fun[A, B] = ( f
    .   mapIn[A] { x => in(x) ; x }
    .  mapOut[B] { x => out(x) ; x }
  )
}
>>>
class A {
  def traced(in: A => Unit, out: B => Unit): Fun[A, B] =
    (f.mapIn[A] { x =>
        in(x); x
      }
      .mapOut[B] { x =>
        out(x); x
      })
}

<<< akka 1
{{{
val bindingFuture = Http().bindAndHandleSync({
        case HttpRequest(_, _, headers, _, _) ⇒
          val upgrade = headers.collectFirst { case u: UpgradeToWebSocket ⇒ u }.get
          upgrade.handleMessages(Flow.fromSinkAndSource(Sink.ignore, Source.fromPublisher(source)), None)
      }, interface = "localhost", port = 0)
}}}
>>>
{
  {
    {
      val bindingFuture = Http().bindAndHandleSync({
        case HttpRequest(_, _, headers, _, _) ⇒
          val upgrade =
            headers.collectFirst { case u: UpgradeToWebSocket ⇒ u }.get
          upgrade.handleMessages(
              Flow.fromSinkAndSource(Sink.ignore,
                                     Source.fromPublisher(source)),
              None)
      }, interface = "localhost", port = 0)
    }
  }
}
<<< raw-request idempotent
{{{{{{
          RawRequestURI(new String(uriBytes, HttpCharsets.aaaaaaaaaa.nioCharset)) :: headers
}}}}}}
>>>
{
  {
    {
      {
        {
          {
            RawRequestURI(new String(
                uriBytes,
                HttpCharsets.aaaaaaaaaa.nioCharset)) :: headers
          }
        }
      }
    }
  }
}
<<< PSI #339

{ {

     {
      {
        {
          {
            {
            {
                tokenError(
                if (e.getMessage != null) e.getMessage else "malformed URL")
                }
            }
          }
       }
      }
    }
  }

}

>>>
{
  {
    {
      {
        {
          {
            {
              {
                tokenError(
                    if (e.getMessage != null) e.getMessage
                    else "malformed URL")
              }
            }
          }
        }
      }
    }
  }
}
<<< rendering #339
{{
    val core = BidiFlow.fromGraph(GraphDSL.create() { implicit b ⇒
      b.add {
        Flow[HttpRequest].map { request ⇒
          val sendEntityTrigger = request.headers.collectFirst { case headers.Expect.`100-continue` ⇒ Promise[NotUsed]().future }
          RequestRenderingContext(request, hostHeader, sendEntityTrigger)
        }
      }

    })
     }}

>>>
{
  {
    val core = BidiFlow.fromGraph(GraphDSL.create() { implicit b ⇒
      b.add {
        Flow[HttpRequest].map { request ⇒
          val sendEntityTrigger = request.headers.collectFirst {
            case headers.Expect.`100-continue` ⇒ Promise[NotUsed]().future
          }
          RequestRenderingContext(request, hostHeader, sendEntityTrigger)
        }
      }
    })
  }
}
<<< rendering 2 #339
{{
    val core = BidiFlow.fromGraph(GraphDSL.create() { implicit b ⇒

      val responseParsingMerge = b.add {
        // the initial header parser we initially use for every connection,
        // will not be mutated, all "shared copy" parsers copy on first-write into the header cache
        val rootParser = new HttpResponseParser(parserSettings, HttpHeaderParser(parserSettings) { info ⇒
          if (parserSettings.illegalHeaderWarnings)
            logParsingError(info withSummaryPrepended "Illegal response header", log, parserSettings.errorLoggingVerbosity)
        })
        new ResponseParsingMerge(rootParser)
      }

    })
     }}

>>>
{
  {
    val core = BidiFlow.fromGraph(GraphDSL.create() { implicit b ⇒
      val responseParsingMerge = b.add {
        // the initial header parser we initially use for every connection,
        // will not be mutated, all "shared copy" parsers copy on first-write into the header cache
        val rootParser =
          new HttpResponseParser(parserSettings,
                                 HttpHeaderParser(parserSettings) { info ⇒
                                   if (parserSettings.illegalHeaderWarnings)
                                     logParsingError(
                                         info withSummaryPrepended "Illegal response header",
                                         log,
                                         parserSettings.errorLoggingVerbosity)
                                 })
        new ResponseParsingMerge(rootParser)
      }
    })
  }
}