Packages

object ZPipeline extends ZPipelinePlatformSpecificConstructors

Linear Supertypes
ZPipelinePlatformSpecificConstructors, AnyRef, Any
Ordering
  1. Alphabetic
  2. By Inheritance
Inherited
  1. ZPipeline
  2. ZPipelinePlatformSpecificConstructors
  3. AnyRef
  4. Any
  1. Hide All
  2. Show All
Visibility
  1. Public
  2. Protected

Type Members

  1. final class EnvironmentWithPipelinePartiallyApplied[Env] extends AnyVal
  2. final class ServiceWithPipelinePartiallyApplied[Service] extends AnyVal
  3. final class UnwrapScopedPartiallyApplied[Env] extends AnyVal

Value Members

  1. final def !=(arg0: Any): Boolean
    Definition Classes
    AnyRef → Any
  2. final def ##: Int
    Definition Classes
    AnyRef → Any
  3. final def ==(arg0: Any): Boolean
    Definition Classes
    AnyRef → Any
  4. def aggregateAsync[Env, Err, In, Out](sink: => ZSink[Env, Err, In, In, Out])(implicit trace: Trace): ZPipeline[Env, Err, In, Out]

    Aggregates elements of this stream using the provided sink for as long as the downstream operators on the stream are busy.

    Aggregates elements of this stream using the provided sink for as long as the downstream operators on the stream are busy.

    This operator divides the stream into two asynchronous "islands". Operators upstream of this operator run on one fiber, while downstream operators run on another. Whenever the downstream fiber is busy processing elements, the upstream fiber will feed elements into the sink until it signals completion.

    Any sink can be used here, but see ZSink.foldWeightedZIO and ZSink.foldUntilZIO for sinks that cover the common usecases.

  5. def aggregateAsyncWithin[Env, Err, In, Out](sink: => ZSink[Env, Err, In, In, Out], schedule: => Schedule[Env, Option[Out], Any])(implicit trace: Trace): ZPipeline[Env, Err, In, Out]

    Like aggregateAsyncWithinEither, but only returns the Right results.

  6. def aggregateAsyncWithinEither[Env, Err, In, Out, Out2](sink: => ZSink[Env, Err, In, In, Out], schedule: => Schedule[Env, Option[Out], Out2])(implicit trace: Trace): ZPipeline[Env, Err, In, Either[Out2, Out]]

    Aggregates elements using the provided sink until it completes, or until the delay signalled by the schedule has passed.

    Aggregates elements using the provided sink until it completes, or until the delay signalled by the schedule has passed.

    This operator divides the stream into two asynchronous islands. Operators upstream of this operator run on one fiber, while downstream operators run on another. Elements will be aggregated by the sink until the downstream fiber pulls the aggregated value, or until the schedule's delay has passed.

    Aggregated elements will be fed into the schedule to determine the delays between pulls.

  7. def append[In](values: => Chunk[In])(implicit trace: Trace): ZPipeline[Any, Nothing, In, In]
  8. def apply[In](implicit trace: Trace): ZPipeline[Any, Nothing, In, In]

    A shorter version of ZPipeline.identity, which can facilitate more compact definition of pipelines.

    A shorter version of ZPipeline.identity, which can facilitate more compact definition of pipelines.

    ZPipeline[Int] >>> ZPipeline.filter(_ % 2 != 0)
  9. final def asInstanceOf[T0]: T0
    Definition Classes
    Any
  10. def branchAfter[Env, Err, In, Out](n: => Int)(f: (Chunk[In]) => ZPipeline[Env, Err, In, Out])(implicit trace: Trace): ZPipeline[Env, Err, In, Out]

    A dynamic pipeline that first collects n elements from the stream, then creates another pipeline with the function f and sends all the following elements through that.

  11. def changes[Err, In](implicit trace: Trace): ZPipeline[Any, Err, In, In]
  12. def changesWith[Err, In](f: (In, In) => Boolean)(implicit trace: Trace): ZPipeline[Any, Err, In, In]
  13. def changesWithZIO[Env, Err, In](f: (In, In) => ZIO[Env, Err, Boolean])(implicit trace: Trace): ZPipeline[Env, Err, In, In]
  14. def chunks[In](implicit trace: Trace): ZPipeline[Any, Nothing, In, Chunk[In]]

    Creates a pipeline that exposes the chunk structure of the stream.

  15. def clone(): AnyRef
    Attributes
    protected[lang]
    Definition Classes
    AnyRef
    Annotations
    @throws(classOf[java.lang.CloneNotSupportedException]) @native()
  16. def collect[In, Out](f: PartialFunction[In, Out])(implicit trace: Trace): ZPipeline[Any, Nothing, In, Out]

    Creates a pipeline that collects elements with the specified partial function.

    Creates a pipeline that collects elements with the specified partial function.

    ZPipeline.collect[Option[Int], Int] { case Some(v) => v }
  17. def collectLeft[Err, A, B](implicit trace: Trace): ZPipeline[Any, Err, Either[A, B], A]
  18. def collectRight[Err, A, B](implicit trace: Trace): ZPipeline[Any, Err, Either[A, B], B]
  19. def collectSome[Err, A](implicit trace: Trace): ZPipeline[Any, Err, Option[A], A]
  20. def collectSuccess[A, B](implicit trace: Trace): ZPipeline[Any, Nothing, Exit[B, A], A]
  21. def collectWhile[Err, In, Out](pf: PartialFunction[In, Out])(implicit trace: Trace): ZPipeline[Any, Err, In, Out]
  22. def collectWhileLeft[Err, A, B](implicit trace: Trace): ZPipeline[Any, Err, Either[A, B], A]
  23. def collectWhileRight[Err, A, B](implicit trace: Trace): ZPipeline[Any, Err, Either[A, B], B]
  24. def collectWhileSome[Err, A](implicit trace: Trace): ZPipeline[Any, Err, Option[A], A]
  25. def collectWhileSuccess[Err, A](implicit trace: Trace): ZPipeline[Any, Nothing, Exit[Err, A], A]
  26. def collectWhileZIO[Env, Err, In, Out](pf: PartialFunction[In, ZIO[Env, Err, Out]])(implicit trace: Trace): ZPipeline[Env, Err, In, Out]
  27. def debounce[In](d: => zio.Duration)(implicit trace: Trace): ZPipeline[Any, Nothing, In, In]

    Delays the emission of values by holding new values for a set duration.

    Delays the emission of values by holding new values for a set duration. If no new values arrive during that time the value is emitted, however if a new value is received during the holding period the previous value is discarded and the process is repeated with the new value.

    This operator is useful if you have a stream of "bursty" events which eventually settle down and you only need the final event of the burst.

    Example:

    1. A search engine may only want to initiate a search after a user has paused typing so as to not prematurely recommend results.

  28. def decodeCharsWith(charset: => Charset, bufSize: => Int = 4096)(implicit trace: Trace): ZPipeline[Any, CharacterCodingException, Byte, Char]

    Creates a pipeline that decodes a stream of bytes into a stream of characters using the given charset

  29. def decodeCharsWithDecoder(charsetDecoder: => CharsetDecoder, bufSize: => Int = 4096)(implicit trace: Trace): ZPipeline[Any, CharacterCodingException, Byte, Char]

    Creates a pipeline that decodes a stream of bytes into a stream of characters using the given charset decoder.

  30. def decodeStringWith(charset: => Charset)(implicit trace: Trace): ZPipeline[Any, CharacterCodingException, Byte, String]

    Creates a pipeline that decodes a stream of bytes into a stream of strings using the given charset

  31. def deflate(bufferSize: => Int = 64 * 1024, noWrap: => Boolean = false, level: => CompressionLevel = CompressionLevel.DefaultCompression, strategy: => CompressionStrategy = CompressionStrategy.DefaultStrategy, flushMode: => FlushMode = FlushMode.NoFlush)(implicit trace: Trace): ZPipeline[Any, Nothing, Byte, Byte]
    Definition Classes
    ZPipelinePlatformSpecificConstructors
  32. def drain[Err](implicit trace: Trace): ZPipeline[Any, Err, Any, Nothing]
  33. def drop[In](n: => Int)(implicit trace: Trace): ZPipeline[Any, Nothing, In, In]

    Creates a pipeline that drops n elements.

  34. def dropRight[Err, In](n: => Int)(implicit trace: Trace): ZPipeline[Any, Err, In, In]
  35. def dropUntil[In](f: (In) => Boolean)(implicit trace: Trace): ZPipeline[Any, Nothing, In, In]

    Creates a pipeline that drops elements until the specified predicate evaluates to true.

    Creates a pipeline that drops elements until the specified predicate evaluates to true.

    ZPipeline.dropUntil[Int](_ > 100)
  36. def dropUntilZIO[Env, Err, In](p: (In) => ZIO[Env, Err, Boolean])(implicit trace: Trace): ZPipeline[Env, Err, In, In]

    Drops incoming elements until the effectful predicate p is satisfied.

  37. def dropWhile[In](f: (In) => Boolean)(implicit trace: Trace): ZPipeline[Any, Nothing, In, In]

    Creates a pipeline that drops elements while the specified predicate evaluates to true.

    Creates a pipeline that drops elements while the specified predicate evaluates to true.

    ZPipeline.dropWhile[Int](_ <= 100)
  38. def dropWhileZIO[Env, Err, In, Out](p: (In) => ZIO[Env, Err, Boolean])(implicit trace: Trace): ZPipeline[Env, Err, In, In]

    Drops incoming elements as long as the effectful predicate p is satisfied.

  39. def encodeCharsWith(charset: => Charset, bufferSize: => Int = 4096)(implicit trace: Trace): ZPipeline[Any, CharacterCodingException, Char, Byte]

    Creates a pipeline that converts a stream of characters into a stream of bytes using the given charset

  40. def encodeStringWith(charset: => Charset, bom: => Chunk[Byte] = Chunk.empty)(implicit trace: Trace): ZPipeline[Any, CharacterCodingException, String, Byte]

    Creates a pipeline that converts a stream of strings into a stream of bytes using the given charset

  41. def environmentWithPipeline[Env]: EnvironmentWithPipelinePartiallyApplied[Env]

    Accesses the environment of the pipeline in the context of a pipeline.

  42. final def eq(arg0: AnyRef): Boolean
    Definition Classes
    AnyRef
  43. def equals(arg0: AnyRef): Boolean
    Definition Classes
    AnyRef → Any
  44. def filter[In](f: (In) => Boolean)(implicit trace: Trace): ZPipeline[Any, Nothing, In, In]

    Creates a pipeline that filters elements according to the specified predicate.

  45. def filterZIO[Env, Err, In](f: (In) => ZIO[Env, Err, Boolean])(implicit trace: Trace): ZPipeline[Env, Err, In, In]
  46. def flattenChunks[In](implicit trace: Trace): ZPipeline[Any, Nothing, Chunk[In], In]

    Creates a pipeline that submerges chunks into the structure of the stream.

  47. def flattenExit[Err, Out](implicit trace: Trace): ZPipeline[Any, Err, Exit[Err, Out], Out]

    Creates a pipeline that converts exit results into a stream of values with failure terminating the stream.

  48. def flattenIterables[Out](implicit trace: Trace): ZPipeline[Any, Nothing, Iterable[Out], Out]

    Creates a pipeline that submerges iterables into the structure of the stream.

  49. def flattenStreamsPar[Env, Err, Out](n: => Int, outputBuffer: => Int = 16)(implicit trace: Trace): ZPipeline[Env, Err, ZStream[Env, Err, Out], Out]

    Creates a pipeline that flattens a stream of streams into a single stream of values.

    Creates a pipeline that flattens a stream of streams into a single stream of values. The streams are merged in parallel up to the specified maximum concurrency and will buffer up to output buffer size elements.

  50. def flattenTake[Err, Out](implicit trace: Trace): ZPipeline[Any, Err, Take[Err, Out], Out]

    Creates a pipeline that flattens a stream of takes.

  51. def fromChannel[Env, Err, In, Out](channel: => ZChannel[Env, Nothing, Chunk[In], Any, Err, Chunk[Out], Any]): ZPipeline[Env, Err, In, Out]

    Creates a pipeline that sends all the elements through the given channel.

  52. def fromFunction[Env, Err, In, Out](f: (ZStream[Any, Nothing, In]) => ZStream[Env, Err, Out])(implicit trace: Trace): ZPipeline[Env, Err, In, Out]

    Constructs a pipeline from a stream transformation function.

  53. def fromPush[Env, Err, In, Out](push: => ZIO[Scope with Env, Nothing, (Option[Chunk[In]]) => ZIO[Env, Err, Chunk[Out]]])(implicit trace: Trace): ZPipeline[Env, Err, In, Out]

    Creates a pipeline from a chunk processing function.

  54. def fromSink[Env, Err, In, Out](sink: => ZSink[Env, Err, In, In, Out])(implicit trace: Trace): ZPipeline[Env, Err, In, Out]

    Creates a pipeline that repeatedly sends all elements through the given sink.

  55. final def getClass(): Class[_ <: AnyRef]
    Definition Classes
    AnyRef → Any
    Annotations
    @native()
  56. def groupAdjacentBy[In, Key](f: (In) => Key)(implicit trace: Trace): ZPipeline[Any, Nothing, In, (Key, NonEmptyChunk[In])]

    Creates a pipeline that groups on adjacent keys, calculated by function f.

  57. def grouped[In](chunkSize: => Int)(implicit trace: Trace): ZPipeline[Any, Nothing, In, Chunk[In]]
  58. def groupedWithin[In](chunkSize: => Int, within: => zio.Duration)(implicit trace: Trace): ZPipeline[Any, Nothing, In, Chunk[In]]

    Partitions the stream with the specified chunkSize or until the specified duration has passed, whichever is satisfied first.

  59. def gunzip[Env](bufferSize: => Int = 64 * 1024)(implicit trace: Trace): ZPipeline[Any, CompressionException, Byte, Byte]
    Definition Classes
    ZPipelinePlatformSpecificConstructors
  60. def gunzipAuto[Env](bufferSize: => Int = 64 * 1024)(implicit trace: Trace): ZPipeline[Any, CompressionException, Byte, Byte]
    Definition Classes
    ZPipelinePlatformSpecificConstructors
  61. def gzip(bufferSize: => Int = 64 * 1024, level: => CompressionLevel = CompressionLevel.DefaultCompression, strategy: => CompressionStrategy = CompressionStrategy.DefaultStrategy, flushMode: => FlushMode = FlushMode.NoFlush)(implicit trace: Trace): ZPipeline[Any, Nothing, Byte, Byte]
    Definition Classes
    ZPipelinePlatformSpecificConstructors
  62. def hashCode(): Int
    Definition Classes
    AnyRef → Any
    Annotations
    @native()
  63. def hexDecode(implicit trace: Trace): ZPipeline[Any, EncodingException, Char, Byte]

    Decode each pair of hex digit input characters (both lower or upper case letters are allowed) as one output byte.

  64. def hexEncode(implicit trace: Trace): ZPipeline[Any, Nothing, Byte, Char]

    Encode each input byte as two output bytes as the hex representation of the input byte.

  65. def identity[In](implicit trace: Trace): ZPipeline[Any, Nothing, In, In]

    The identity pipeline, which does not modify streams in any way.

  66. def inflate(bufferSize: => Int = 64 * 1024, noWrap: => Boolean = false)(implicit trace: Trace): ZPipeline[Any, CompressionException, Byte, Byte]
    Definition Classes
    ZPipelinePlatformSpecificConstructors
  67. def intersperse[In](start: => In, middle: => In, end: => In)(implicit trace: Trace): ZPipeline[Any, Nothing, In, In]
  68. def intersperse[Err, In](middle: => In)(implicit trace: Trace): ZPipeline[Any, Err, In, In]
  69. final def isInstanceOf[T0]: Boolean
    Definition Classes
    Any
  70. def iso_8859_1Decode(implicit trace: Trace): ZPipeline[Any, CharacterCodingException, Byte, String]

    Creates a pipeline that converts a stream of bytes into a stream of strings using the ISO_8859_1 charset

  71. def iso_8859_1Encode(implicit trace: Trace): ZPipeline[Any, CharacterCodingException, String, Byte]

    Creates a pipeline that converts a stream of strings into a stream of bytes using the ISO_8859_1 charset

  72. def map[In, Out](f: (In) => Out)(implicit trace: Trace): ZPipeline[Any, Nothing, In, Out]

    Creates a pipeline that maps elements with the specified function.

  73. def mapAccum[In, State, Out](s: => State)(f: (State, In) => (State, Out))(implicit trace: Trace): ZPipeline[Any, Nothing, In, Out]

    Creates a pipeline that statefully maps elements with the specified function.

  74. def mapAccumZIO[Env, Err, In, State, Out](s: => State)(f: (State, In) => ZIO[Env, Err, (State, Out)])(implicit trace: Trace): ZPipeline[Env, Err, In, Out]

    Creates a pipeline that statefully maps elements with the specified effect.

  75. def mapChunks[In, Out](f: (Chunk[In]) => Chunk[Out])(implicit trace: Trace): ZPipeline[Any, Nothing, In, Out]

    Creates a pipeline that maps chunks of elements with the specified function.

  76. def mapChunksZIO[Env, Err, In, Out](f: (Chunk[In]) => ZIO[Env, Err, Chunk[Out]])(implicit trace: Trace): ZPipeline[Env, Err, In, Out]

    Creates a pipeline that maps chunks of elements with the specified effect.

  77. def mapStream[Env, Err, In, Out](f: (In) => ZStream[Env, Err, Out])(implicit trace: Trace): ZPipeline[Env, Err, In, Out]

    Creates a pipeline that maps elements with the specified function that returns a stream.

  78. def mapZIO[Env, Err, In, Out](f: (In) => ZIO[Env, Err, Out])(implicit trace: Trace): ZPipeline[Env, Err, In, Out]

    Creates a pipeline that maps elements with the specified effectful function.

  79. def mapZIOPar[Env, Err, In, Out](n: => Int, bufferSize: => Int = 16)(f: (In) => ZIO[Env, Err, Out])(implicit trace: Trace): ZPipeline[Env, Err, In, Out]

    Maps over elements of the stream with the specified effectful function, executing up to n invocations of f concurrently.

    Maps over elements of the stream with the specified effectful function, executing up to n invocations of f concurrently. Transformed elements will be emitted in the original order.

    Note

    This combinator destroys the chunking structure. It's recommended to use rechunk afterwards.

  80. def mapZIOPar[Env, Err, In, Out](n: => Int)(f: (In) => ZIO[Env, Err, Out])(implicit trace: Trace): ZPipeline[Env, Err, In, Out]

    Maps over elements of the stream with the specified effectful function, executing up to n invocations of f concurrently.

    Maps over elements of the stream with the specified effectful function, executing up to n invocations of f concurrently. Transformed elements will be emitted in the original order.

    Note

    This combinator destroys the chunking structure. It's recommended to use rechunk afterwards.

  81. def mapZIOParUnordered[Env, Err, In, Out](n: => Int, bufferSize: => Int = 16)(f: (In) => ZIO[Env, Err, Out])(implicit trace: Trace): ZPipeline[Env, Err, In, Out]

    Maps over elements of the stream with the specified effectful function, executing up to n invocations of f concurrently.

    Maps over elements of the stream with the specified effectful function, executing up to n invocations of f concurrently. The element order is not enforced by this combinator, and elements may be reordered.

  82. def mapZIOParUnordered[Env, Err, In, Out](n: => Int)(f: (In) => ZIO[Env, Err, Out])(implicit trace: Trace): ZPipeline[Env, Err, In, Out]

    Maps over elements of the stream with the specified effectful function, executing up to n invocations of f concurrently.

    Maps over elements of the stream with the specified effectful function, executing up to n invocations of f concurrently. The element order is not enforced by this combinator, and elements may be reordered.

  83. final def ne(arg0: AnyRef): Boolean
    Definition Classes
    AnyRef
  84. final def notify(): Unit
    Definition Classes
    AnyRef
    Annotations
    @native()
  85. final def notifyAll(): Unit
    Definition Classes
    AnyRef
    Annotations
    @native()
  86. def prepend[In](values: => Chunk[In])(implicit trace: Trace): ZPipeline[Any, Nothing, In, In]

    Emits the provided chunk before emitting any other value.

  87. def rechunk[In](n: => Int)(implicit trace: Trace): ZPipeline[Any, Nothing, In, In]

    A pipeline that rechunks the stream into chunks of the specified size.

  88. def sample[In](p: => Double)(implicit trace: Trace): ZPipeline[Any, Nothing, In, In]

    Creates a pipeline that randomly samples elements according to the specified percentage.

  89. def scan[In, Out](s: => Out)(f: (Out, In) => Out)(implicit trace: Trace): ZPipeline[Any, Nothing, In, Out]

    Creates a pipeline that scans elements with the specified function.

  90. def scanZIO[Env, Err, In, Out](s: => Out)(f: (Out, In) => ZIO[Env, Err, Out])(implicit trace: Trace): ZPipeline[Env, Err, In, Out]

    Creates a pipeline that scans elements with the specified function.

  91. def serviceWithPipeline[Service]: ServiceWithPipelinePartiallyApplied[Service]

    Accesses the specified service in the environment of the pipeline in the context of a pipeline.

  92. def splitLines(implicit trace: Trace): ZPipeline[Any, Nothing, String, String]

    Splits strings on newlines.

    Splits strings on newlines. Handles both Windows newlines (\r\n) and UNIX newlines (\n).

  93. def splitOn(delimiter: => String)(implicit trace: Trace): ZPipeline[Any, Nothing, String, String]

    Splits strings on a delimiter.

  94. def splitOnChunk[In](delimiter: => Chunk[In])(implicit trace: Trace): ZPipeline[Any, Nothing, In, In]

    Splits strings on a delimiter.

  95. def suspend[Env, Err, In, Out](pipeline: => ZPipeline[Env, Err, In, Out]): ZPipeline[Env, Err, In, Out]

    Lazily constructs a pipeline.

  96. final def synchronized[T0](arg0: => T0): T0
    Definition Classes
    AnyRef
  97. def take[In](n: => Long)(implicit trace: Trace): ZPipeline[Any, Nothing, In, In]

    Creates a pipeline that takes n elements.

  98. def takeUntil[In](f: (In) => Boolean)(implicit trace: Trace): ZPipeline[Any, Nothing, In, In]

    Creates a pipeline that takes elements until the specified predicate evaluates to true.

  99. def takeUntilZIO[Env, Err, In](f: (In) => ZIO[Env, Err, Boolean])(implicit trace: Trace): ZPipeline[Env, Err, In, In]
  100. def takeWhile[In](f: (In) => Boolean)(implicit trace: Trace): ZPipeline[Any, Nothing, In, In]

    Creates a pipeline that takes elements while the specified predicate evaluates to true.

  101. def takeWhileZIO[Env, Err, In](f: (In) => ZIO[Env, Err, Boolean])(implicit trace: Trace): ZPipeline[Env, Err, In, In]

    Creates a pipeline that takes elements while the specified effectual predicate evaluates to true.

  102. def tap[Env, Err, In](f: (In) => ZIO[Env, Err, Any])(implicit trace: Trace): ZPipeline[Env, Err, In, In]

    Adds an effect to consumption of every element of the pipeline.

  103. def throttleEnforce[In](units: Long, duration: => zio.Duration, burst: => Long = 0)(costFn: (Chunk[In]) => Long)(implicit trace: Trace): ZPipeline[Any, Nothing, In, In]

    Throttles the chunks of this pipeline according to the given bandwidth parameters using the token bucket algorithm.

    Throttles the chunks of this pipeline according to the given bandwidth parameters using the token bucket algorithm. Allows for burst in the processing of elements by allowing the token bucket to accumulate tokens up to a units + burst threshold. Chunks that do not meet the bandwidth constraints are dropped. The weight of each chunk is determined by the costFn function.

  104. def throttleEnforceZIO[Env, Err, In](units: => Long, duration: => zio.Duration, burst: => Long = 0)(costFn: (Chunk[In]) => ZIO[Env, Err, Long])(implicit trace: Trace): ZPipeline[Env, Err, In, In]

    Throttles the chunks of this pipeline according to the given bandwidth parameters using the token bucket algorithm.

    Throttles the chunks of this pipeline according to the given bandwidth parameters using the token bucket algorithm. Allows for burst in the processing of elements by allowing the token bucket to accumulate tokens up to a units + burst threshold. Chunks that do not meet the bandwidth constraints are dropped. The weight of each chunk is determined by the costFn effectful function.

  105. def throttleShape[In](units: => Long, duration: => zio.Duration, burst: Long = 0)(costFn: (Chunk[In]) => Long)(implicit trace: Trace): ZPipeline[Any, Nothing, In, In]

    Delays the chunks of this pipeline according to the given bandwidth parameters using the token bucket algorithm.

    Delays the chunks of this pipeline according to the given bandwidth parameters using the token bucket algorithm. Allows for burst in the processing of elements by allowing the token bucket to accumulate tokens up to a units + burst threshold. The weight of each chunk is determined by the costFn function.

  106. def throttleShapeZIO[Env, Err, In](units: => Long, duration: => zio.Duration, burst: => Long = 0)(costFn: (Chunk[In]) => ZIO[Env, Err, Long])(implicit trace: Trace): ZPipeline[Env, Err, In, In]

    Delays the chunks of this pipeline according to the given bandwidth parameters using the token bucket algorithm.

    Delays the chunks of this pipeline according to the given bandwidth parameters using the token bucket algorithm. Allows for burst in the processing of elements by allowing the token bucket to accumulate tokens up to a units + burst threshold. The weight of each chunk is determined by the costFn effectful function.

  107. def toString(): String
    Definition Classes
    AnyRef → Any
  108. def unwrap[Env, Err, In, Out](zio: ZIO[Env, Err, ZPipeline[Env, Err, In, Out]])(implicit trace: Trace): ZPipeline[Env, Err, In, Out]

    Creates a pipeline produced from an effect.

  109. def unwrapScoped[Env]: UnwrapScopedPartiallyApplied[Env]

    Created a pipeline produced from a scoped effect.

  110. def usASCIIDecode(implicit trace: Trace): ZPipeline[Any, CharacterCodingException, Byte, String]

    Creates a pipeline that converts a stream of bytes into a stream of strings using the US ASCII charset

  111. def usASCIIEncode(implicit trace: Trace): ZPipeline[Any, CharacterCodingException, String, Byte]

    Creates a pipeline that converts a stream of strings into a stream of bytes using the US ASCII charset

  112. def utf16BEDecode(implicit trace: Trace): ZPipeline[Any, CharacterCodingException, Byte, String]

    Creates a pipeline that converts a stream of bytes into a stream of strings using the UTF_16BE charset

  113. def utf16BEEncode(implicit trace: Trace): ZPipeline[Any, CharacterCodingException, String, Byte]

    Creates a pipeline that converts a stream of strings into a stream of bytes using the UTF_16BE charset, without adding a BOM

  114. def utf16BEWithBomEncode(implicit trace: Trace): ZPipeline[Any, CharacterCodingException, String, Byte]

    Creates a pipeline that converts a stream of strings into a stream of bytes using the UTF_16BE charset prefixing it with a BOM

  115. def utf16Decode(implicit trace: Trace): ZPipeline[Any, CharacterCodingException, Byte, String]

    Creates a pipeline that converts a stream of bytes into a stream of strings using the UTF_16 charset

  116. def utf16Encode(implicit trace: Trace): ZPipeline[Any, CharacterCodingException, String, Byte]

    Creates a pipeline that converts a stream of strings into a stream of bytes using the UTF_16BE charset prefixing it with a BOM

  117. def utf16LEDecode(implicit trace: Trace): ZPipeline[Any, CharacterCodingException, Byte, String]

    Creates a pipeline that converts a stream of bytes into a stream of strings using the UTF_16LE charset

  118. def utf16LEEncode(implicit trace: Trace): ZPipeline[Any, CharacterCodingException, String, Byte]

    Creates a pipeline that converts a stream of strings into a stream of bytes using the UTF_16LE charset, without adding a BOM

  119. def utf16LEWithBomEncode(implicit trace: Trace): ZPipeline[Any, CharacterCodingException, String, Byte]

    Creates a pipeline that converts a stream of strings into a stream of bytes using the UTF_16LE charset prefixing it with a BOM

  120. def utf16WithBomEncode(implicit trace: Trace): ZPipeline[Any, CharacterCodingException, String, Byte]

    Creates a pipeline that converts a stream of strings into a stream of bytes using the UTF_16 charset prefixing it with a BOM

  121. def utf32BEDecode(implicit trace: Trace): ZPipeline[Any, CharacterCodingException, Byte, String]

    Creates a pipeline that converts a stream of bytes into a stream of strings using the UTF_32BE charset

  122. def utf32BEEncode(implicit trace: Trace): ZPipeline[Any, CharacterCodingException, String, Byte]

    Creates a pipeline that converts a stream of strings into a stream of bytes using the UTF_32BE charset, without adding a BOM

  123. def utf32BEWithBomEncode(implicit trace: Trace): ZPipeline[Any, CharacterCodingException, String, Byte]

    Creates a pipeline that converts a stream of strings into a stream of bytes using the UTF_32BE charset prefixing it with a BOM

  124. def utf32Decode(implicit trace: Trace): ZPipeline[Any, CharacterCodingException, Byte, String]

    Creates a pipeline that converts a stream of bytes into a stream of strings using the UTF_32 charset

  125. def utf32Encode(implicit trace: Trace): ZPipeline[Any, CharacterCodingException, String, Byte]

    Creates a pipeline that converts a stream of strings into a stream of bytes using the UTF_32BE charset, without adding a BOM

  126. def utf32LEDecode(implicit trace: Trace): ZPipeline[Any, CharacterCodingException, Byte, String]

    Creates a pipeline that converts a stream of bytes into a stream of strings using the UTF_32LE charset

  127. def utf32LEEncode(implicit trace: Trace): ZPipeline[Any, CharacterCodingException, String, Byte]

    Creates a pipeline that converts a stream of strings into a stream of bytes using the UTF_32LE charset, without adding a BOM

  128. def utf32LEWithBomEncode(implicit trace: Trace): ZPipeline[Any, CharacterCodingException, String, Byte]

    Creates a pipeline that converts a stream of strings into a stream of bytes using the UTF_32LE charset prefixing it with a BOM

  129. def utf32WithBomEncode(implicit trace: Trace): ZPipeline[Any, CharacterCodingException, String, Byte]

    Creates a pipeline that converts a stream of strings into a stream of bytes using the UTF_32BE charset prefixing it with a BOM

  130. def utf8Decode(implicit trace: Trace): ZPipeline[Any, CharacterCodingException, Byte, String]

    Creates a pipeline that converts a stream of bytes into a stream of strings using the UTF_8 charset

  131. def utf8Encode(implicit trace: Trace): ZPipeline[Any, CharacterCodingException, String, Byte]

    Creates a pipeline that converts a stream of strings into a stream of bytes using the UTF_8 charset, without adding a BOM

  132. def utf8WithBomEncode(implicit trace: Trace): ZPipeline[Any, CharacterCodingException, String, Byte]

    Creates a pipeline that converts a stream of strings into a stream of bytes using the UTF_8 charset prefixing it with a BOM

  133. def utfDecode(implicit trace: Trace): ZPipeline[Any, CharacterCodingException, Byte, String]

    utfDecode determines the right encoder to use based on the Byte Order Mark (BOM).

    utfDecode determines the right encoder to use based on the Byte Order Mark (BOM). If it doesn't detect one, it defaults to utf8Decode. In the case of utf16 and utf32 without BOM, utf16Decode and utf32Decode should be used instead as both default to their own default decoder respectively.

  134. final def wait(): Unit
    Definition Classes
    AnyRef
    Annotations
    @throws(classOf[java.lang.InterruptedException])
  135. final def wait(arg0: Long, arg1: Int): Unit
    Definition Classes
    AnyRef
    Annotations
    @throws(classOf[java.lang.InterruptedException])
  136. final def wait(arg0: Long): Unit
    Definition Classes
    AnyRef
    Annotations
    @throws(classOf[java.lang.InterruptedException]) @native()
  137. def zipWithIndex[In](implicit trace: Trace): ZPipeline[Any, Nothing, In, (In, Long)]

    Zips this pipeline together with the index of elements.

  138. def zipWithNext[In](implicit trace: Trace): ZPipeline[Any, Nothing, In, (In, Option[In])]

    Zips each element with the next element if present.

  139. def zipWithPrevious[In](implicit trace: Trace): ZPipeline[Any, Nothing, In, (Option[In], In)]
  140. def zipWithPreviousAndNext[In](implicit trace: Trace): ZPipeline[Any, Nothing, In, (Option[In], In, Option[In])]

Deprecated Value Members

  1. def finalize(): Unit
    Attributes
    protected[lang]
    Definition Classes
    AnyRef
    Annotations
    @throws(classOf[java.lang.Throwable]) @Deprecated
    Deprecated

    (Since version 9)

Inherited from ZPipelinePlatformSpecificConstructors

Inherited from AnyRef

Inherited from Any

Ungrouped