From d6ad67150a16764e0f20d35e55db4e5350a0e961 Mon Sep 17 00:00:00 2001 From: Patrik Nordwall Date: Thu, 6 Nov 2014 14:03:01 +0100 Subject: [PATCH] =str Fix scaladoc warnings --- .../scala/akka/stream/FlowMaterializer.scala | 16 ++++++++-------- .../scala/akka/stream/javadsl/FlexiMerge.scala | 6 +++--- .../main/scala/akka/stream/javadsl/Flow.scala | 8 ++++---- .../akka/stream/javadsl/MaterializedMap.scala | 6 +++--- .../main/scala/akka/stream/javadsl/Source.scala | 12 ++++-------- .../main/scala/akka/stream/scaladsl/Flow.scala | 10 +++++----- .../main/scala/akka/stream/scaladsl/Source.scala | 7 ++++--- .../scala/akka/stream/scaladsl/package.scala | 6 +++--- 8 files changed, 34 insertions(+), 37 deletions(-) diff --git a/akka-stream/src/main/scala/akka/stream/FlowMaterializer.scala b/akka-stream/src/main/scala/akka/stream/FlowMaterializer.scala index 3635f89251..d47300e31a 100644 --- a/akka-stream/src/main/scala/akka/stream/FlowMaterializer.scala +++ b/akka-stream/src/main/scala/akka/stream/FlowMaterializer.scala @@ -153,8 +153,8 @@ object MaterializerSettings { /** * Create [[MaterializerSettings]]. * - * You can refine the configuration based settings using [[MaterializerSettings#withBuffer]], - * [[MaterializerSettings#withFanOut]], [[MaterializerSettings#withSubscriptionTimeout]] + * You can refine the configuration based settings using [[MaterializerSettings#withInputBuffer]], + * [[MaterializerSettings#withFanOutBuffer]], [[MaterializerSettings#withDispatcher]] */ def apply(system: ActorSystem): MaterializerSettings = apply(system.settings.config.getConfig("akka.stream.materializer")) @@ -162,8 +162,8 @@ object MaterializerSettings { /** * Create [[MaterializerSettings]]. * - * You can refine the configuration based settings using [[MaterializerSettings#withBuffer]], - * [[MaterializerSettings#withFanOut]], [[MaterializerSettings#withSubscriptionTimeout]] + * You can refine the configuration based settings using [[MaterializerSettings#withInputBuffer]], + * [[MaterializerSettings#withFanOutBuffer]], [[MaterializerSettings#withDispatcher]] */ def apply(config: Config): MaterializerSettings = MaterializerSettings( @@ -176,8 +176,8 @@ object MaterializerSettings { /** * Java API * - * You can refine the configuration based settings using [[MaterializerSettings#withBuffer]], - * [[MaterializerSettings#withFanOut]], [[MaterializerSettings#withSubscriptionTimeout]] + * You can refine the configuration based settings using [[MaterializerSettings#withInputBuffer]], + * [[MaterializerSettings#withFanOutBuffer]], [[MaterializerSettings#withDispatcher]] */ def create(system: ActorSystem): MaterializerSettings = apply(system) @@ -185,8 +185,8 @@ object MaterializerSettings { /** * Java API * - * You can refine the configuration based settings using [[MaterializerSettings#withBuffer]], - * [[MaterializerSettings#withFanOut]], [[MaterializerSettings#withSubscriptionTimeout]] + * You can refine the configuration based settings using [[MaterializerSettings#withInputBuffer]], + * [[MaterializerSettings#withFanOutBuffer]], [[MaterializerSettings#withDispatcher]] */ def create(config: Config): MaterializerSettings = apply(config) diff --git a/akka-stream/src/main/scala/akka/stream/javadsl/FlexiMerge.scala b/akka-stream/src/main/scala/akka/stream/javadsl/FlexiMerge.scala index e51a231544..2a9a78e3d7 100644 --- a/akka-stream/src/main/scala/akka/stream/javadsl/FlexiMerge.scala +++ b/akka-stream/src/main/scala/akka/stream/javadsl/FlexiMerge.scala @@ -109,12 +109,12 @@ object FlexiMerge { * How to handle completion or error from upstream input. * * The `onComplete` method is called when an upstream input was completed sucessfully. - * It returns next behavior or [[#SameState]] to keep current behavior. + * It returns next behavior or [[MergeLogic#sameState]] to keep current behavior. * A completion can be propagated downstream with [[MergeLogicContext#complete]], * or it can be swallowed to continue with remaining inputs. * * The `onError` method is called when an upstream input was completed sucessfully. - * It returns next behavior or [[#SameState]] to keep current behavior. + * It returns next behavior or [[MergeLogic#sameState]] to keep current behavior. * An error can be propagated downstream with [[MergeLogicContext#error]], * or it can be swallowed to continue with remaining inputs. */ @@ -130,7 +130,7 @@ object FlexiMerge { * emit at least one element downstream with [[MergeLogicContext#emit]]. * * The `onInput` method is called when an `element` was read from the `input`. - * The method returns next behavior or [[#SameState]] to keep current behavior. + * The method returns next behavior or [[MergeLogic#sameState]] to keep current behavior. */ abstract class State[In, Out](val condition: ReadCondition) { def onInput(ctx: MergeLogicContext[Out], input: InputHandle, element: In): State[_, Out] diff --git a/akka-stream/src/main/scala/akka/stream/javadsl/Flow.scala b/akka-stream/src/main/scala/akka/stream/javadsl/Flow.scala index 33bc2348f1..658f07ab75 100644 --- a/akka-stream/src/main/scala/akka/stream/javadsl/Flow.scala +++ b/akka-stream/src/main/scala/akka/stream/javadsl/Flow.scala @@ -263,8 +263,8 @@ class Flow[-In, +Out](delegate: scaladsl.Flow[In, Out]) { /** * Adds a fixed size buffer in the flow that allows to store elements from a faster upstream until it becomes full. - * Depending on the defined [[OverflowStrategy]] it might drop elements or backpressure the upstream if there is no - * space available + * Depending on the defined [[akka.stream.OverflowStrategy]] it might drop elements or backpressure the upstream if + * there is no space available * * @param size The size of the buffer in element count * @param overflowStrategy Strategy that is used when incoming elements cannot fit inside the buffer @@ -280,7 +280,7 @@ class Flow[-In, +Out](delegate: scaladsl.Flow[In, Out]) { * subscribers, the [[akka.stream.Transformer#isComplete]] predicate determines whether to end * stream processing at this point; in that case the upstream subscription is * canceled. Before signaling normal completion to the downstream subscribers, - * the [[akka.stream.Transformer#onComplete]] function is invoked to produce a (possibly empty) + * the [[akka.stream.Transformer#onTermination]] function is invoked to produce a (possibly empty) * sequence of elements in response to the end-of-stream event. * * [[akka.stream.Transformer#onError]] is called when failure is signaled from upstream. @@ -307,7 +307,7 @@ class Flow[-In, +Out](delegate: scaladsl.Flow[In, Out]) { * subscribers, the [[akka.stream.Transformer#isComplete]] predicate determines whether to end * stream processing at this point; in that case the upstream subscription is * canceled. Before signaling normal completion to the downstream subscribers, - * the [[akka.stream.Transformer#onComplete]] function is invoked to produce a (possibly empty) + * the [[akka.stream.Transformer#onTermination]] function is invoked to produce a (possibly empty) * sequence of elements in response to the end-of-stream event. * * [[akka.stream.Transformer#onError]] is called when failure is signaled from upstream. diff --git a/akka-stream/src/main/scala/akka/stream/javadsl/MaterializedMap.scala b/akka-stream/src/main/scala/akka/stream/javadsl/MaterializedMap.scala index 290901d273..58f536b0af 100644 --- a/akka-stream/src/main/scala/akka/stream/javadsl/MaterializedMap.scala +++ b/akka-stream/src/main/scala/akka/stream/javadsl/MaterializedMap.scala @@ -11,17 +11,17 @@ import akka.stream.scaladsl * * Returned by [[RunnableFlow#run]] and can be used as parameter to the * accessor method to retrieve the materialized `Source` or `Sink`, e.g. - * [[akka.stream.scaladsl.SubscriberSource#subscriber]] or [[akka.stream.scaladsl.PublisherSink#publisher]]. + * [[akka.stream.javadsl.Source#subscriber]] or [[akka.stream.javadsl.Sink#publisher]]. */ class MaterializedMap(delegate: scaladsl.MaterializedMap) { /** - * Retrieve a materialized `Source`, e.g. the `Subscriber` of a [[akka.stream.scaladsl.SubscriberSource]]. + * Retrieve a materialized `Source`, e.g. the `Subscriber` of a [[akka.stream.javadsl.Source#subscriber]]. */ def get[T](key: javadsl.KeyedSource[_, T]): T = delegate.get(key.asScala).asInstanceOf[T] /** - * Retrieve a materialized `Sink`, e.g. the `Publisher` of a [[akka.stream.scaladsl.PublisherSink]]. + * Retrieve a materialized `Sink`, e.g. the `Publisher` of a [[akka.stream.javadsl.Sink#publisher]]. */ def get[D](key: javadsl.KeyedSink[_, D]): D = delegate.get(key.asScala).asInstanceOf[D] diff --git a/akka-stream/src/main/scala/akka/stream/javadsl/Source.scala b/akka-stream/src/main/scala/akka/stream/javadsl/Source.scala index a5853eaa82..d3135c7c1f 100644 --- a/akka-stream/src/main/scala/akka/stream/javadsl/Source.scala +++ b/akka-stream/src/main/scala/akka/stream/javadsl/Source.scala @@ -29,10 +29,6 @@ object Source { def adapt[O](source: scaladsl.Source[O]): Source[O] = new Source(source) - /** Adapt [[scaladsl.SourcePipe]] for use within JavaDSL */ - def adapt[O](source: scaladsl.SourcePipe[O]): Source[O] = - new Source(source) - /** * Create a `Source` with no elements, i.e. an empty stream that is completed immediately * for every connected `Sink`. @@ -380,8 +376,8 @@ class Source[+Out](delegate: scaladsl.Source[Out]) { /** * Adds a fixed size buffer in the flow that allows to store elements from a faster upstream until it becomes full. - * Depending on the defined [[OverflowStrategy]] it might drop elements or backpressure the upstream if there is no - * space available + * Depending on the defined [[akka.stream.OverflowStrategy]] it might drop elements or backpressure the upstream if + * there is no space available * * @param size The size of the buffer in element count * @param overflowStrategy Strategy that is used when incoming elements cannot fit inside the buffer @@ -397,7 +393,7 @@ class Source[+Out](delegate: scaladsl.Source[Out]) { * subscribers, the [[akka.stream.Transformer#isComplete]] predicate determines whether to end * stream processing at this point; in that case the upstream subscription is * canceled. Before signaling normal completion to the downstream subscribers, - * the [[akka.stream.Transformer#onComplete]] function is invoked to produce a (possibly empty) + * the [[akka.stream.Transformer#onTermination]] function is invoked to produce a (possibly empty) * sequence of elements in response to the end-of-stream event. * * [[akka.stream.Transformer#onError]] is called when failure is signaled from upstream. @@ -424,7 +420,7 @@ class Source[+Out](delegate: scaladsl.Source[Out]) { * subscribers, the [[akka.stream.Transformer#isComplete]] predicate determines whether to end * stream processing at this point; in that case the upstream subscription is * canceled. Before signaling normal completion to the downstream subscribers, - * the [[akka.stream.Transformer#onComplete]] function is invoked to produce a (possibly empty) + * the [[akka.stream.Transformer#onTermination]] function is invoked to produce a (possibly empty) * sequence of elements in response to the end-of-stream event. * * [[akka.stream.Transformer#onError]] is called when failure is signaled from upstream. diff --git a/akka-stream/src/main/scala/akka/stream/scaladsl/Flow.scala b/akka-stream/src/main/scala/akka/stream/scaladsl/Flow.scala index 17670f35d2..22d223d883 100644 --- a/akka-stream/src/main/scala/akka/stream/scaladsl/Flow.scala +++ b/akka-stream/src/main/scala/akka/stream/scaladsl/Flow.scala @@ -298,8 +298,8 @@ trait FlowOps[+Out] { /** * Adds a fixed size buffer in the flow that allows to store elements from a faster upstream until it becomes full. - * Depending on the defined [[OverflowStrategy]] it might drop elements or backpressure the upstream if there is no - * space available + * Depending on the defined [[akka.stream.OverflowStrategy]] it might drop elements or backpressure the upstream if + * there is no space available * * @param size The size of the buffer in element count * @param overflowStrategy Strategy that is used when incoming elements cannot fit inside the buffer @@ -317,7 +317,7 @@ trait FlowOps[+Out] { * subscribers, the [[akka.stream.Transformer#isComplete]] predicate determines whether to end * stream processing at this point; in that case the upstream subscription is * canceled. Before signaling normal completion to the downstream subscribers, - * the [[akka.stream.Transformer#onComplete]] function is invoked to produce a (possibly empty) + * the [[akka.stream.Transformer#onTermination]] function is invoked to produce a (possibly empty) * sequence of elements in response to the end-of-stream event. * * [[akka.stream.Transformer#onError]] is called when failure is signaled from upstream. @@ -375,7 +375,7 @@ trait FlowOps[+Out] { /** * Transforms a stream of streams into a contiguous stream of elements using the provided flattening strategy. - * This operation can be used on a stream of element type [[Source]]. + * This operation can be used on a stream of element type [[akka.stream.scaladsl.Source]]. */ def flatten[U](strategy: akka.stream.FlattenStrategy[Out, U]): Repr[U] = strategy match { case _: FlattenStrategy.Concat[Out] ⇒ andThen(ConcatAll) @@ -394,7 +394,7 @@ trait FlowOps[+Out] { * subscribers, the [[akka.stream.Transformer#isComplete]] predicate determines whether to end * stream processing at this point; in that case the upstream subscription is * canceled. Before signaling normal completion to the downstream subscribers, - * the [[akka.stream.Transformer#onComplete]] function is invoked to produce a (possibly empty) + * the [[akka.stream.Transformer#onTermination]] function is invoked to produce a (possibly empty) * sequence of elements in response to the end-of-stream event. * * [[akka.stream.Transformer#onError]] is called when failure is signaled from upstream. diff --git a/akka-stream/src/main/scala/akka/stream/scaladsl/Source.scala b/akka-stream/src/main/scala/akka/stream/scaladsl/Source.scala index 2bf974e561..7d9b009c0d 100644 --- a/akka-stream/src/main/scala/akka/stream/scaladsl/Source.scala +++ b/akka-stream/src/main/scala/akka/stream/scaladsl/Source.scala @@ -21,18 +21,19 @@ trait Source[+Out] extends FlowOps[Out] { override type Repr[+O] <: Source[O] /** - * Transform this [[Source]] by appending the given processing stages. + * Transform this [[akka.stream.scaladsl.Source]] by appending the given processing stages. */ def via[T](flow: Flow[Out, T]): Source[T] /** - * Connect this [[Source]] to a [[Sink]], concatenating the processing steps of both. + * Connect this [[akka.stream.scaladsl.Source]] to a [[akka.stream.scaladsl.Sink]], + * concatenating the processing steps of both. */ def to(sink: Sink[Out]): RunnableFlow /** * Connect this `Source` to a `Sink` and run it. The returned value is the materialized value - * of the `Sink`, e.g. the `Publisher` of a [[Sink.fanoutPublisher]]. + * of the `Sink`, e.g. the `Publisher` of a [[akka.stream.scaladsl.Sink#publisher]]. */ def runWith(sink: Sink[Out])(implicit materializer: FlowMaterializer): sink.MaterializedType = to(sink).run().get(sink) diff --git a/akka-stream/src/main/scala/akka/stream/scaladsl/package.scala b/akka-stream/src/main/scala/akka/stream/scaladsl/package.scala index 2baa7fa1aa..1a8fdc9114 100644 --- a/akka-stream/src/main/scala/akka/stream/scaladsl/package.scala +++ b/akka-stream/src/main/scala/akka/stream/scaladsl/package.scala @@ -7,10 +7,10 @@ package akka.stream * Scala API: The flow DSL allows the formulation of stream transformations based on some * input. The starting point is called [[Source]] and can be a collection, an iterator, * a block of code which is evaluated repeatedly or a [[org.reactivestreams.Publisher]]. - * A flow with an attached input and open output, is also a [[Source]]. + * A flow with an attached input and open output is also a [[Source]]. * * A flow may also be defined without an attached input or output and that is then - * a [[Flow]]. The `Flow` can be connected to the `Source` later by using [[Source#connect]] with + * a [[Flow]]. The `Flow` can be connected to the `Source` later by using [[Source#via]] with * the flow as argument, and it remains a [[Source]]. * * Transformations can be appended to `Source` and `Flow` with the operations @@ -25,7 +25,7 @@ package akka.stream * In order to execute this pipeline the flow must be materialized by calling [[RunnableFlow#run]] on it. * * You can create your `Source`, `Flow` and `Sink` in any order and then wire them together before - * they are materialized by connecting them using [[Flow#connect]], or connecting them into a + * they are materialized by connecting them using [[Flow#via]] and [[Flow#to]], or connecting them into a * [[FlowGraph]] with fan-in and fan-out elements. * * See Reactive Streams for