object ZSink extends ZSinkPlatformSpecificConstructors
- Alphabetic
- By Inheritance
- ZSink
- ZSinkPlatformSpecificConstructors
- AnyRef
- Any
- Hide All
- Show All
- Public
- All
Type Members
- final class EnvironmentWithPartiallyApplied[R] extends AnyVal
- final class EnvironmentWithSinkPartiallyApplied[R] extends AnyVal
- final class EnvironmentWithZIOPartiallyApplied[R] extends AnyVal
- final class ServiceAtPartiallyApplied[Service] extends AnyVal
- final class ServiceWithPartiallyApplied[Service] extends AnyVal
- final class ServiceWithSinkPartiallyApplied[Service] extends AnyVal
- final class ServiceWithZIOPartiallyApplied[Service] extends AnyVal
- final class UnwrapScopedPartiallyApplied[R] extends AnyVal
Value Members
-
final
def
!=(arg0: Any): Boolean
- Definition Classes
- AnyRef → Any
-
final
def
##(): Int
- Definition Classes
- AnyRef → Any
-
final
def
==(arg0: Any): Boolean
- Definition Classes
- AnyRef → Any
-
final
def
asInstanceOf[T0]: T0
- Definition Classes
- Any
-
def
clone(): AnyRef
- Attributes
- protected[lang]
- Definition Classes
- AnyRef
- Annotations
- @throws( ... ) @native()
- def collectAll[In](implicit trace: Trace): ZSink[Any, Nothing, In, Nothing, Chunk[In]]
-
def
collectAllN[In](n: ⇒ Int)(implicit trace: Trace): ZSink[Any, Nothing, In, In, Chunk[In]]
A sink that collects first
n
elements into a chunk.A sink that collects first
n
elements into a chunk. Note that the chunk is preallocated and must fit in memory. -
def
collectAllToMap[In, K](key: (In) ⇒ K)(f: (In, In) ⇒ In)(implicit trace: Trace): ZSink[Any, Nothing, In, Nothing, Map[K, In]]
A sink that collects all of its inputs into a map.
A sink that collects all of its inputs into a map. The keys are extracted from inputs using the keying function
key
; if multiple inputs use the same key, they are merged using thef
function. -
def
collectAllToMapN[Err, In, K](n: ⇒ Long)(key: (In) ⇒ K)(f: (In, In) ⇒ In)(implicit trace: Trace): ZSink[Any, Err, In, In, Map[K, In]]
A sink that collects first
n
keys into a map.A sink that collects first
n
keys into a map. The keys are calculated from inputs using the keying functionkey
; if multiple inputs use the the same key, they are merged using thef
function. -
def
collectAllToSet[In](implicit trace: Trace): ZSink[Any, Nothing, In, Nothing, Set[In]]
A sink that collects all of its inputs into a set.
-
def
collectAllToSetN[In](n: ⇒ Long)(implicit trace: Trace): ZSink[Any, Nothing, In, In, Set[In]]
A sink that collects first
n
distinct inputs into a set. -
def
collectAllUntil[In](p: (In) ⇒ Boolean)(implicit trace: Trace): ZSink[Any, Nothing, In, In, Chunk[In]]
Accumulates incoming elements into a chunk until predicate
p
is satisfied. -
def
collectAllUntilZIO[Env, Err, In](p: (In) ⇒ ZIO[Env, Err, Boolean])(implicit trace: Trace): ZSink[Env, Err, In, In, Chunk[In]]
Accumulates incoming elements into a chunk until effectful predicate
p
is satisfied. -
def
collectAllWhile[In](p: (In) ⇒ Boolean)(implicit trace: Trace): ZSink[Any, Nothing, In, In, Chunk[In]]
Accumulates incoming elements into a chunk as long as they verify predicate
p
. -
def
collectAllWhileZIO[Env, Err, In](p: (In) ⇒ ZIO[Env, Err, Boolean])(implicit trace: Trace): ZSink[Env, Err, In, In, Chunk[In]]
Accumulates incoming elements into a chunk as long as they verify effectful predicate
p
. -
def
count(implicit trace: Trace): ZSink[Any, Nothing, Any, Nothing, Long]
A sink that counts the number of elements fed to it.
-
def
die(e: ⇒ Throwable)(implicit trace: Trace): ZSink[Any, Nothing, Any, Nothing, Nothing]
Creates a sink halting with the specified
Throwable
. -
def
dieMessage(m: ⇒ String)(implicit trace: Trace): ZSink[Any, Nothing, Any, Nothing, Nothing]
Creates a sink halting with the specified message, wrapped in a
RuntimeException
. -
def
drain(implicit trace: Trace): ZSink[Any, Nothing, Any, Nothing, Unit]
A sink that ignores its inputs.
-
def
dropUntil[In](p: (In) ⇒ Boolean)(implicit trace: Trace): ZSink[Any, Nothing, In, In, Any]
Drops incoming elements until the predicate
p
is satisfied. -
def
dropUntilZIO[R, InErr, In](p: (In) ⇒ ZIO[R, InErr, Boolean])(implicit trace: Trace): ZSink[R, InErr, In, In, Any]
Drops incoming elements until the effectful predicate
p
is satisfied. -
def
dropWhile[In](p: (In) ⇒ Boolean)(implicit trace: Trace): ZSink[Any, Nothing, In, In, Any]
Drops incoming elements as long as the predicate
p
is satisfied. -
def
dropWhileZIO[R, InErr, In](p: (In) ⇒ ZIO[R, InErr, Boolean])(implicit trace: Trace): ZSink[R, InErr, In, In, Any]
Drops incoming elements as long as the effectful predicate
p
is satisfied. -
def
environment[R](implicit trace: Trace): ZSink[R, Nothing, Any, Nothing, ZEnvironment[R]]
Accesses the whole environment of the sink.
-
def
environmentWith[R]: EnvironmentWithPartiallyApplied[R]
Accesses the environment of the sink.
-
def
environmentWithSink[R]: EnvironmentWithSinkPartiallyApplied[R]
Accesses the environment of the sink in the context of a sink.
-
def
environmentWithZIO[R]: EnvironmentWithZIOPartiallyApplied[R]
Accesses the environment of the sink in the context of an effect.
-
final
def
eq(arg0: AnyRef): Boolean
- Definition Classes
- AnyRef
-
def
equals(arg0: Any): Boolean
- Definition Classes
- AnyRef → Any
-
def
exists[In](f: (In) ⇒ Boolean)(implicit trace: Trace): ZSink[Any, Nothing, In, In, Boolean]
A sink that returns whether an element satisfies the specified predicate.
-
def
fail[E](e: ⇒ E)(implicit trace: Trace): ZSink[Any, E, Any, Nothing, Nothing]
A sink that always fails with the specified error.
-
def
failCause[E](e: ⇒ Cause[E])(implicit trace: Trace): ZSink[Any, E, Any, Nothing, Nothing]
Creates a sink halting with a specified cause.
-
def
finalize(): Unit
- Attributes
- protected[lang]
- Definition Classes
- AnyRef
- Annotations
- @throws( classOf[java.lang.Throwable] )
-
def
fold[In, S](z: ⇒ S)(contFn: (S) ⇒ Boolean)(f: (S, In) ⇒ S)(implicit trace: Trace): ZSink[Any, Nothing, In, In, S]
A sink that folds its inputs with the provided function, termination predicate and initial state.
-
def
foldChunks[In, S](z: ⇒ S)(contFn: (S) ⇒ Boolean)(f: (S, Chunk[In]) ⇒ S)(implicit trace: Trace): ZSink[Any, Nothing, In, Nothing, S]
A sink that folds its input chunks with the provided function, termination predicate and initial state.
A sink that folds its input chunks with the provided function, termination predicate and initial state.
contFn
condition is checked only for the initial value and at the end of processing of each chunk.f
andcontFn
must preserve chunking-invariance. -
def
foldChunksZIO[Env, Err, In, S](z: ⇒ S)(contFn: (S) ⇒ Boolean)(f: (S, Chunk[In]) ⇒ ZIO[Env, Err, S])(implicit trace: Trace): ZSink[Env, Err, In, In, S]
A sink that effectfully folds its input chunks with the provided function, termination predicate and initial state.
A sink that effectfully folds its input chunks with the provided function, termination predicate and initial state.
contFn
condition is checked only for the initial value and at the end of processing of each chunk.f
andcontFn
must preserve chunking-invariance. -
def
foldLeft[In, S](z: ⇒ S)(f: (S, In) ⇒ S)(implicit trace: Trace): ZSink[Any, Nothing, In, Nothing, S]
A sink that folds its inputs with the provided function and initial state.
-
def
foldLeftChunks[In, S](z: ⇒ S)(f: (S, Chunk[In]) ⇒ S)(implicit trace: Trace): ZSink[Any, Nothing, In, Nothing, S]
A sink that folds its input chunks with the provided function and initial state.
A sink that folds its input chunks with the provided function and initial state.
f
must preserve chunking-invariance. -
def
foldLeftChunksZIO[R, Err, In, S](z: ⇒ S)(f: (S, Chunk[In]) ⇒ ZIO[R, Err, S])(implicit trace: Trace): ZSink[R, Err, In, Nothing, S]
A sink that effectfully folds its input chunks with the provided function and initial state.
A sink that effectfully folds its input chunks with the provided function and initial state.
f
must preserve chunking-invariance. -
def
foldLeftZIO[R, Err, In, S](z: ⇒ S)(f: (S, In) ⇒ ZIO[R, Err, S])(implicit trace: Trace): ZSink[R, Err, In, In, S]
A sink that effectfully folds its inputs with the provided function and initial state.
-
def
foldUntil[In, S](z: ⇒ S, max: ⇒ Long)(f: (S, In) ⇒ S)(implicit trace: Trace): ZSink[Any, Nothing, In, In, S]
Creates a sink that folds elements of type
In
into a structure of typeS
untilmax
elements have been folded.Creates a sink that folds elements of type
In
into a structure of typeS
untilmax
elements have been folded.Like foldWeighted, but with a constant cost function of 1.
-
def
foldUntilZIO[Env, Err, In, S](z: ⇒ S, max: ⇒ Long)(f: (S, In) ⇒ ZIO[Env, Err, S])(implicit trace: Trace): ZSink[Env, Err, In, In, S]
Creates a sink that effectfully folds elements of type
In
into a structure of typeS
untilmax
elements have been folded.Creates a sink that effectfully folds elements of type
In
into a structure of typeS
untilmax
elements have been folded.Like foldWeightedZIO, but with a constant cost function of 1.
-
def
foldWeighted[In, S](z: ⇒ S)(costFn: (S, In) ⇒ Long, max: ⇒ Long)(f: (S, In) ⇒ S)(implicit trace: Trace): ZSink[Any, Nothing, In, In, S]
Creates a sink that folds elements of type
In
into a structure of typeS
, untilmax
worth of elements (determined by thecostFn
) have been folded.Creates a sink that folds elements of type
In
into a structure of typeS
, untilmax
worth of elements (determined by thecostFn
) have been folded.- Note
Elements that have an individual cost larger than
max
will force the sink to cross themax
cost. See foldWeightedDecompose for a variant that can handle these cases.
-
def
foldWeightedDecompose[In, S](z: ⇒ S)(costFn: (S, In) ⇒ Long, max: ⇒ Long, decompose: (In) ⇒ Chunk[In])(f: (S, In) ⇒ S)(implicit trace: Trace): ZSink[Any, Nothing, In, In, S]
Creates a sink that folds elements of type
In
into a structure of typeS
, untilmax
worth of elements (determined by thecostFn
) have been folded.Creates a sink that folds elements of type
In
into a structure of typeS
, untilmax
worth of elements (determined by thecostFn
) have been folded.The
decompose
function will be used for decomposing elements that cause anS
aggregate to crossmax
into smaller elements. For example:Stream(1, 5, 1) .transduce( ZSink .foldWeightedDecompose(List[Int]())((i: Int) => i.toLong, 4, (i: Int) => Chunk(i - 1, 1)) { (acc, el) => el :: acc } .map(_.reverse) ) .runCollect
The stream would emit the elements
List(1), List(4), List(1, 1)
.Be vigilant with this function, it has to generate "simpler" values or the fold may never end. A value is considered indivisible if
decompose
yields the empty chunk or a single-valued chunk. In these cases, there is no other choice than to yield a value that will cross the threshold.The foldWeightedDecomposeZIO allows the decompose function to return a
ZIO
value, and consequently it allows the sink to fail. -
def
foldWeightedDecomposeZIO[Env, Err, In, S](z: ⇒ S)(costFn: (S, In) ⇒ ZIO[Env, Err, Long], max: ⇒ Long, decompose: (In) ⇒ ZIO[Env, Err, Chunk[In]])(f: (S, In) ⇒ ZIO[Env, Err, S])(implicit trace: Trace): ZSink[Env, Err, In, In, S]
Creates a sink that effectfully folds elements of type
In
into a structure of typeS
, untilmax
worth of elements (determined by thecostFn
) have been folded.Creates a sink that effectfully folds elements of type
In
into a structure of typeS
, untilmax
worth of elements (determined by thecostFn
) have been folded.The
decompose
function will be used for decomposing elements that cause anS
aggregate to crossmax
into smaller elements. Be vigilant with this function, it has to generate "simpler" values or the fold may never end. A value is considered indivisible ifdecompose
yields the empty chunk or a single-valued chunk. In these cases, there is no other choice than to yield a value that will cross the threshold.See foldWeightedDecompose for an example.
-
def
foldWeightedZIO[Env, Err, In, S](z: ⇒ S)(costFn: (S, In) ⇒ ZIO[Env, Err, Long], max: Long)(f: (S, In) ⇒ ZIO[Env, Err, S])(implicit trace: Trace): ZSink[Env, Err, In, In, S]
Creates a sink that effectfully folds elements of type
In
into a structure of typeS
, untilmax
worth of elements (determined by thecostFn
) have been folded.Creates a sink that effectfully folds elements of type
In
into a structure of typeS
, untilmax
worth of elements (determined by thecostFn
) have been folded.- Note
Elements that have an individual cost larger than
max
will force the sink to cross themax
cost. See foldWeightedDecomposeZIO for a variant that can handle these cases.
-
def
foldZIO[Env, Err, In, S](z: ⇒ S)(contFn: (S) ⇒ Boolean)(f: (S, In) ⇒ ZIO[Env, Err, S])(implicit trace: Trace): ZSink[Env, Err, In, In, S]
A sink that effectfully folds its inputs with the provided function, termination predicate and initial state.
-
def
forall[In](f: (In) ⇒ Boolean)(implicit trace: Trace): ZSink[Any, Nothing, In, In, Boolean]
A sink that returns whether all elements satisfy the specified predicate.
-
def
foreach[R, Err, In](f: (In) ⇒ ZIO[R, Err, Any])(implicit trace: Trace): ZSink[R, Err, In, Nothing, Unit]
A sink that executes the provided effectful function for every element fed to it.
-
def
foreachChunk[R, Err, In](f: (Chunk[In]) ⇒ ZIO[R, Err, Any])(implicit trace: Trace): ZSink[R, Err, In, Nothing, Unit]
A sink that executes the provided effectful function for every chunk fed to it.
-
def
foreachChunkWhile[R, Err, In](f: (Chunk[In]) ⇒ ZIO[R, Err, Boolean])(implicit trace: Trace): ZSink[R, Err, In, In, Unit]
A sink that executes the provided effectful function for every chunk fed to it until
f
evaluates tofalse
. -
def
foreachWhile[R, Err, In](f: (In) ⇒ ZIO[R, Err, Boolean])(implicit trace: Trace): ZSink[R, Err, In, In, Unit]
A sink that executes the provided effectful function for every element fed to it until
f
evaluates tofalse
. -
def
fromChannel[R, E, In, L, Z](channel: ZChannel[R, ZNothing, Chunk[In], Any, E, Chunk[L], Z]): ZSink[R, E, In, L, Z]
Creates a sink from a zio.stream.ZChannel
-
def
fromHub[I](hub: ⇒ Hub[I])(implicit trace: Trace): ZSink[Any, Nothing, I, Nothing, Unit]
Create a sink which publishes each element to the specified hub.
-
def
fromHubWithShutdown[I](hub: ⇒ Hub[I])(implicit trace: Trace): ZSink[Any, Nothing, I, Nothing, Unit]
Create a sink which publishes each element to the specified hub.
Create a sink which publishes each element to the specified hub. The hub will be shutdown once the stream is closed.
-
def
fromPush[R, E, I, L, Z](push: ZIO[Scope with R, Nothing, (Option[Chunk[I]]) ⇒ ZIO[R, (Either[E, Z], Chunk[L]), Unit]])(implicit trace: Trace): ZSink[R, E, I, L, Z]
Creates a sink from a chunk processing function.
-
def
fromQueue[I](queue: ⇒ Enqueue[I])(implicit trace: Trace): ZSink[Any, Nothing, I, Nothing, Unit]
Create a sink which enqueues each element into the specified queue.
-
def
fromQueueWithShutdown[I](queue: ⇒ Enqueue[I])(implicit trace: Trace): ZSink[Any, Nothing, I, Nothing, Unit]
Create a sink which enqueues each element into the specified queue.
Create a sink which enqueues each element into the specified queue. The queue will be shutdown once the stream is closed.
-
def
fromZIO[R, E, Z](b: ⇒ ZIO[R, E, Z])(implicit trace: Trace): ZSink[R, E, Any, Nothing, Z]
Creates a single-value sink produced from an effect
-
final
def
getClass(): Class[_]
- Definition Classes
- AnyRef → Any
- Annotations
- @native()
-
def
hashCode(): Int
- Definition Classes
- AnyRef → Any
- Annotations
- @native()
-
def
head[In](implicit trace: Trace): ZSink[Any, Nothing, In, In, Option[In]]
Creates a sink containing the first value.
-
final
def
isInstanceOf[T0]: Boolean
- Definition Classes
- Any
-
def
last[In](implicit trace: Trace): ZSink[Any, Nothing, In, In, Option[In]]
Creates a sink containing the last value.
-
def
leftover[L](c: ⇒ Chunk[L])(implicit trace: Trace): ZSink[Any, Nothing, Any, L, Unit]
Creates a sink that does not consume any input but provides the given chunk as its leftovers
-
def
log(message: ⇒ String)(implicit trace: Trace): ZSink[Any, Nothing, Any, Nothing, Unit]
Logs the specified message at the current log level.
-
def
logAnnotate[R, E, In, L, Z](annotations: ⇒ Set[LogAnnotation])(sink: ZSink[R, E, In, L, Z])(implicit trace: Trace): ZSink[R, E, In, L, Z]
Annotates each log in streams composed after this with the specified log annotation.
-
def
logAnnotate[R, E, In, L, Z](annotation: ⇒ LogAnnotation, annotations: LogAnnotation*)(sink: ZSink[R, E, In, L, Z])(implicit trace: Trace): ZSink[R, E, In, L, Z]
Annotates each log in streams composed after this with the specified log annotation.
-
def
logAnnotate[R, E, In, L, Z](key: ⇒ String, value: ⇒ String)(sink: ZSink[R, E, In, L, Z])(implicit trace: Trace): ZSink[R, E, In, L, Z]
Annotates each log in streams composed after this with the specified log annotation.
-
def
logAnnotations(implicit trace: Trace): ZSink[Any, Nothing, Any, Nothing, Map[String, String]]
Retrieves the log annotations associated with the current scope.
-
def
logDebug(message: ⇒ String)(implicit trace: Trace): ZSink[Any, Nothing, Any, Nothing, Unit]
Logs the specified message at the debug log level.
-
def
logError(message: ⇒ String)(implicit trace: Trace): ZSink[Any, Nothing, Any, Nothing, Unit]
Logs the specified message at the error log level.
-
def
logErrorCause(cause: ⇒ Cause[Any])(implicit trace: Trace): ZSink[Any, Nothing, Any, Nothing, Unit]
Logs the specified cause as an error.
-
def
logFatal(message: ⇒ String)(implicit trace: Trace): ZSink[Any, Nothing, Any, Nothing, Unit]
Logs the specified message at the fatal log level.
-
def
logInfo(message: ⇒ String)(implicit trace: Trace): ZSink[Any, Nothing, Any, Nothing, Unit]
Logs the specified message at the informational log level.
-
def
logLevel[R, E, In, L, Z](level: LogLevel)(sink: ZSink[R, E, In, L, Z])(implicit trace: Trace): ZSink[R, E, In, L, Z]
Sets the log level for streams composed after this.
-
def
logSpan[R, E, In, L, Z](label: ⇒ String)(sink: ZSink[R, E, In, L, Z])(implicit trace: Trace): ZSink[R, E, In, L, Z]
Adjusts the label for the logging span for streams composed after this.
-
def
logTrace(message: ⇒ String)(implicit trace: Trace): ZSink[Any, Nothing, Any, Nothing, Unit]
Logs the specified message at the trace log level.
-
def
logWarning(message: ⇒ String)(implicit trace: Trace): ZSink[Any, Nothing, Any, Nothing, Unit]
Logs the specified message at the warning log level.
- def mkString(implicit trace: Trace): ZSink[Any, Nothing, Any, Nothing, String]
-
final
def
ne(arg0: AnyRef): Boolean
- Definition Classes
- AnyRef
- def never(implicit trace: Trace): ZSink[Any, Nothing, Any, Nothing, Nothing]
-
final
def
notify(): Unit
- Definition Classes
- AnyRef
- Annotations
- @native()
-
final
def
notifyAll(): Unit
- Definition Classes
- AnyRef
- Annotations
- @native()
-
def
service[Z](implicit arg0: Tag[Z], trace: Trace): ZSink[Z, Nothing, Any, Nothing, Z]
Accesses the specified service in the environment of the effect.
-
def
serviceAt[Service]: ZStream.ServiceAtPartiallyApplied[Service]
Accesses the service corresponding to the specified key in the environment.
-
def
serviceWith[Service]: ServiceWithPartiallyApplied[Service]
Accesses the specified service in the environment of the sink.
-
def
serviceWithSink[Service]: ServiceWithSinkPartiallyApplied[Service]
Accesses the specified service in the environment of the sink in the context of a sink.
-
def
serviceWithZIO[Service]: ServiceWithZIOPartiallyApplied[Service]
Accesses the specified service in the environment of the sink in the context of an effect.
-
def
succeed[Z](z: ⇒ Z)(implicit trace: Trace): ZSink[Any, Nothing, Any, Nothing, Z]
A sink that immediately ends with the specified value.
-
def
sum[A](implicit A: Numeric[A], trace: Trace): ZSink[Any, Nothing, A, Nothing, A]
A sink that sums incoming numeric values.
-
def
suspend[Env, E, In, Leftover, Done](sink: ⇒ ZSink[Env, E, In, Leftover, Done])(implicit trace: Trace): ZSink[Env, E, In, Leftover, Done]
Returns a lazily constructed sink that may require effects for its creation.
-
final
def
synchronized[T0](arg0: ⇒ T0): T0
- Definition Classes
- AnyRef
-
def
tagged[R, E, In, L, Z](tags: ⇒ Set[MetricLabel])(sink: ZSink[R, E, In, L, Z])(implicit trace: Trace): ZSink[R, E, In, L, Z]
Tags each metric in this sink with the specific tag.
-
def
tagged[R, E, In, L, Z](tag: ⇒ MetricLabel, tags: MetricLabel*)(sink: ZSink[R, E, In, L, Z])(implicit trace: Trace): ZSink[R, E, In, L, Z]
Tags each metric in this sink with the specific tag.
-
def
tagged[R, E, In, L, Z](key: ⇒ String, value: ⇒ String)(sink: ZSink[R, E, In, L, Z])(implicit trace: Trace): ZSink[R, E, In, L, Z]
Tags each metric in this sink with the specific tag.
-
def
tags(implicit trace: Trace): ZSink[Any, Nothing, Any, Nothing, Set[MetricLabel]]
Retrieves the metric tags associated with the current scope.
-
def
take[In](n: Int)(implicit trace: Trace): ZSink[Any, Nothing, In, In, Chunk[In]]
A sink that takes the specified number of values.
- def timed(implicit trace: Trace): ZSink[Any, Nothing, Any, Nothing, zio.Duration]
-
def
toString(): String
- Definition Classes
- AnyRef → Any
-
def
unwrap[R, E, In, L, Z](zio: ⇒ ZIO[R, E, ZSink[R, E, In, L, Z]])(implicit trace: Trace): ZSink[R, E, In, L, Z]
Creates a sink produced from an effect.
-
def
unwrapScoped[R]: UnwrapScopedPartiallyApplied[R]
Creates a sink produced from a scoped effect.
-
final
def
wait(): Unit
- Definition Classes
- AnyRef
- Annotations
- @throws( ... )
-
final
def
wait(arg0: Long, arg1: Int): Unit
- Definition Classes
- AnyRef
- Annotations
- @throws( ... )
-
final
def
wait(arg0: Long): Unit
- Definition Classes
- AnyRef
- Annotations
- @throws( ... ) @native()