diff --git a/akka-actor/src/main/scala/akka/actor/ActorDSL.scala b/akka-actor/src/main/scala/akka/actor/ActorDSL.scala index 182d65a26b..7692f28664 100644 --- a/akka-actor/src/main/scala/akka/actor/ActorDSL.scala +++ b/akka-actor/src/main/scala/akka/actor/ActorDSL.scala @@ -118,7 +118,7 @@ abstract class Inbox { * Receive the next message from this Inbox. This call will return immediately * if the internal actor previously received a message, or it will block for * up to the specified duration to await reception of a message. If no message - * is received a [[TimeoutException]] will be raised. + * is received a [[java.util.concurrent.TimeoutException]] will be raised. */ def receive(max: FiniteDuration): Any diff --git a/akka-actor/src/main/scala/akka/actor/ActorRef.scala b/akka-actor/src/main/scala/akka/actor/ActorRef.scala index 11c762ac7a..d7bcf02b76 100644 --- a/akka-actor/src/main/scala/akka/actor/ActorRef.scala +++ b/akka-actor/src/main/scala/akka/actor/ActorRef.scala @@ -16,7 +16,7 @@ import akka.event.LoggingAdapter object ActorRef { /** - * Use this value as an argument to [[#tell]] if there is not actor to + * Use this value as an argument to [[ActorRef#tell]] if there is not actor to * reply to (e.g. when sending from non-actor code). */ final val noSender: ActorRef = Actor.noSender diff --git a/akka-actor/src/main/scala/akka/actor/DynamicAccess.scala b/akka-actor/src/main/scala/akka/actor/DynamicAccess.scala index 9d865b7da9..91decec249 100644 --- a/akka-actor/src/main/scala/akka/actor/DynamicAccess.scala +++ b/akka-actor/src/main/scala/akka/actor/DynamicAccess.scala @@ -55,11 +55,10 @@ abstract class DynamicAccess { } /** - * This is the default [[akka.actor.DynamicAccess]] implementation used by [[akka.actor.ActorSystemImpl]] + * This is the default [[akka.actor.DynamicAccess]] implementation used by [[akka.actor.ExtendedActorSystem]] * unless overridden. It uses reflection to turn fully-qualified class names into `Class[_]` objects * and creates instances from there using `getDeclaredConstructor()` and invoking that. The class loader - * to be used for all this is determined by the [[akka.actor.ActorSystemImpl]]’s `findClassLoader` method - * by default. + * to be used for all this is determined by the actor system’s class loader by default. */ class ReflectiveDynamicAccess(val classLoader: ClassLoader) extends DynamicAccess { diff --git a/akka-actor/src/main/scala/akka/actor/FSM.scala b/akka-actor/src/main/scala/akka/actor/FSM.scala index f521c77d53..7bb63f00f8 100644 --- a/akka-actor/src/main/scala/akka/actor/FSM.scala +++ b/akka-actor/src/main/scala/akka/actor/FSM.scala @@ -27,27 +27,27 @@ object FSM { /** * Message type which is sent directly to the subscribed actor in - * [[akka.actor.FSM.SubscribeTransitionCallback]] before sending any + * [[akka.actor.FSM.SubscribeTransitionCallBack]] before sending any * [[akka.actor.FSM.Transition]] messages. */ case class CurrentState[S](fsmRef: ActorRef, state: S) /** * Message type which is used to communicate transitions between states to - * all subscribed listeners (use [[akka.actor.FSM.SubscribeTransitionCallback]]). + * all subscribed listeners (use [[akka.actor.FSM.SubscribeTransitionCallBack]]). */ case class Transition[S](fsmRef: ActorRef, from: S, to: S) /** - * Send this to an [[akka.actor.FSM]] to request first the [[akka.actor.CurrentState]] - * and then a series of [[akka.actor.Transition]] updates. Cancel the subscription - * using [[akka.actor.FSM.UnsubscribeTransitionCallback]]. + * Send this to an [[akka.actor.FSM]] to request first the [[FSM.CurrentState]] + * and then a series of [[FSM.Transition]] updates. Cancel the subscription + * using [[FSM.UnsubscribeTransitionCallBack]]. */ case class SubscribeTransitionCallBack(actorRef: ActorRef) /** * Unsubscribe from [[akka.actor.FSM.Transition]] notifications which was - * effected by sending the corresponding [[akka.actor.FSM.SubscribeTransitionCallback]]. + * effected by sending the corresponding [[akka.actor.FSM.SubscribeTransitionCallBack]]. */ case class UnsubscribeTransitionCallBack(actorRef: ActorRef) @@ -658,7 +658,7 @@ trait FSM[S, D] extends Actor with Listeners with ActorLogging { } /** - * By default [[Failure]] is logged at error level and other reason + * By default [[FSM.Failure]] is logged at error level and other reason * types are not logged. It is possible to override this behavior. */ protected def logTermination(reason: Reason): Unit = reason match { diff --git a/akka-actor/src/main/scala/akka/actor/FaultHandling.scala b/akka-actor/src/main/scala/akka/actor/FaultHandling.scala index 99d54af15f..58dd06c5e7 100644 --- a/akka-actor/src/main/scala/akka/actor/FaultHandling.scala +++ b/akka-actor/src/main/scala/akka/actor/FaultHandling.scala @@ -156,7 +156,7 @@ object SupervisorStrategy extends SupervisorStrategyLowPriorityImplicits { * When supervisorStrategy is not specified for an actor this * [[Decider]] is used by default in the supervisor strategy. * The child will be stopped when [[akka.actor.ActorInitializationException]], - * [[akka.ActorKilledException]], or [[akka.actor.DeathPactException]] is + * [[akka.actor.ActorKilledException]], or [[akka.actor.DeathPactException]] is * thrown. It will be restarted for other `Exception` types. * The error is escalated if it's a `Throwable`, i.e. `Error`. */ diff --git a/akka-actor/src/main/scala/akka/actor/Props.scala b/akka-actor/src/main/scala/akka/actor/Props.scala index 3bd6693de8..bf2cd57f77 100644 --- a/akka-actor/src/main/scala/akka/actor/Props.scala +++ b/akka-actor/src/main/scala/akka/actor/Props.scala @@ -120,7 +120,7 @@ object Props { def create(clazz: Class[_], args: AnyRef*): Props = apply(defaultDeploy, clazz, args.toVector) /** - * Create new Props from the given [[Creator]]. + * Create new Props from the given [[akka.japi.Creator]]. */ def create[T <: Actor](creator: Creator[T]): Props = { if ((creator.getClass.getEnclosingClass ne null) && (creator.getClass.getModifiers & Modifier.STATIC) == 0) @@ -216,7 +216,7 @@ final case class Props(deploy: Deploy, clazz: Class[_], args: immutable.Seq[Any] def this(factory: UntypedActorFactory) = this(Props.defaultDeploy, classOf[UntypedActorFactoryConsumer], Vector(factory)) /** - * Java API: create Props from a given [[Class]] + * Java API: create Props from a given [[java.lang.Class]] * * @deprecated use Props.create(clazz) instead; deprecated since it duplicates * another API @@ -303,7 +303,7 @@ final case class Props(deploy: Deploy, clazz: Class[_], args: immutable.Seq[Any] /** * Obtain an upper-bound approximation of the actor class which is going to - * be created by these Props. In other words, the [[#newActor]] method will + * be created by these Props. In other words, the actor factory method will * produce an instance of this class or a subclass thereof. This is used by * the actor system to select special dispatchers or mailboxes in case * dependencies are encoded in the actor type. diff --git a/akka-actor/src/main/scala/akka/dispatch/sysmsg/SystemMessage.scala b/akka-actor/src/main/scala/akka/dispatch/sysmsg/SystemMessage.scala index 69cc1062f5..5e73fcbee0 100644 --- a/akka-actor/src/main/scala/akka/dispatch/sysmsg/SystemMessage.scala +++ b/akka-actor/src/main/scala/akka/dispatch/sysmsg/SystemMessage.scala @@ -12,7 +12,7 @@ import akka.actor.{ ActorInitializationException, InternalActorRef, ActorRef, Po * Helper companion object for [[akka.dispatch.sysmsg.LatestFirstSystemMessageList]] and * [[akka.dispatch.sysmsg.EarliestFirstSystemMessageList]] */ -object SystemMessageList { +private[akka] object SystemMessageList { final val LNil: LatestFirstSystemMessageList = new LatestFirstSystemMessageList(null) final val ENil: EarliestFirstSystemMessageList = new EarliestFirstSystemMessageList(null) @@ -33,7 +33,7 @@ object SystemMessageList { * * INTERNAL API * - * Value class supporting list operations on system messages. The `next` field of [[akka.dispatch.sysmsg.SystemMessage]] + * Value class supporting list operations on system messages. The `next` field of [[SystemMessage]] * is hidden, and can only accessed through the value classes [[akka.dispatch.sysmsg.LatestFirstSystemMessageList]] and * [[akka.dispatch.sysmsg.EarliestFirstSystemMessageList]], abstracting over the fact that system messages are the * list nodes themselves. If used properly, this stays a compile time construct without any allocation overhead. @@ -44,7 +44,7 @@ object SystemMessageList { * latest appended element. * */ -class LatestFirstSystemMessageList(val head: SystemMessage) extends AnyVal { +private[akka] class LatestFirstSystemMessageList(val head: SystemMessage) extends AnyVal { import SystemMessageList._ /** @@ -65,7 +65,7 @@ class LatestFirstSystemMessageList(val head: SystemMessage) extends AnyVal { /** * Gives back the list containing all the elements except the first. This operation has constant cost. * - * *Warning:* as the underlying list nodes (the [[akka.dispatch.sysmsg.SystemMessage]] instances) are mutable, care + * *Warning:* as the underlying list nodes (the [[SystemMessage]] instances) are mutable, care * should be taken when passing the tail to other methods. [[akka.dispatch.sysmsg.SystemMessage#unlink]] should be * called on the head if one wants to detach the tail permanently. */ @@ -94,7 +94,7 @@ class LatestFirstSystemMessageList(val head: SystemMessage) extends AnyVal { * * INTERNAL API * - * Value class supporting list operations on system messages. The `next` field of [[akka.dispatch.sysmsg.SystemMessage]] + * Value class supporting list operations on system messages. The `next` field of [[SystemMessage]] * is hidden, and can only accessed through the value classes [[akka.dispatch.sysmsg.LatestFirstSystemMessageList]] and * [[akka.dispatch.sysmsg.EarliestFirstSystemMessageList]], abstracting over the fact that system messages are the * list nodes themselves. If used properly, this stays a compile time construct without any allocation overhead. @@ -105,7 +105,7 @@ class LatestFirstSystemMessageList(val head: SystemMessage) extends AnyVal { * latest appended element. * */ -class EarliestFirstSystemMessageList(val head: SystemMessage) extends AnyVal { +private[akka] class EarliestFirstSystemMessageList(val head: SystemMessage) extends AnyVal { import SystemMessageList._ /** @@ -126,7 +126,7 @@ class EarliestFirstSystemMessageList(val head: SystemMessage) extends AnyVal { /** * Gives back the list containing all the elements except the first. This operation has constant cost. * - * *Warning:* as the underlying list nodes (the [[akka.dispatch.sysmsg.SystemMessage]] instances) are mutable, care + * *Warning:* as the underlying list nodes (the [[SystemMessage]] instances) are mutable, care * should be taken when passing the tail to other methods. [[akka.dispatch.sysmsg.SystemMessage#unlink]] should be * called on the head if one wants to detach the tail permanently. */ diff --git a/akka-actor/src/main/scala/akka/io/Inet.scala b/akka-actor/src/main/scala/akka/io/Inet.scala index e33b7ee6d1..35a14bbb76 100644 --- a/akka-actor/src/main/scala/akka/io/Inet.scala +++ b/akka-actor/src/main/scala/akka/io/Inet.scala @@ -31,7 +31,7 @@ object Inet { object SO { /** - * [[akka.io.Tcp.SocketOption]] to set the SO_RCVBUF option + * [[akka.io.Inet.SocketOption]] to set the SO_RCVBUF option * * For more information see [[java.net.Socket.setReceiveBufferSize]] */ @@ -45,7 +45,7 @@ object Inet { // server socket options /** - * [[akka.io.Tcp.SocketOption]] to enable or disable SO_REUSEADDR + * [[akka.io.Inet.SocketOption]] to enable or disable SO_REUSEADDR * * For more information see [[java.net.Socket.setReuseAddress]] */ @@ -56,7 +56,7 @@ object Inet { } /** - * [[akka.io.Tcp.SocketOption]] to set the SO_SNDBUF option. + * [[akka.io.Inet.SocketOption]] to set the SO_SNDBUF option. * * For more information see [[java.net.Socket.setSendBufferSize]] */ @@ -66,7 +66,7 @@ object Inet { } /** - * [[akka.io.Tcp.SocketOption]] to set the traffic class or + * [[akka.io.Inet.SocketOption]] to set the traffic class or * type-of-service octet in the IP header for packets sent from this * socket. * @@ -81,28 +81,28 @@ object Inet { trait SoForwarders { /** - * [[akka.io.Tcp.SocketOption]] to set the SO_RCVBUF option + * [[akka.io.Inet.SocketOption]] to set the SO_RCVBUF option * * For more information see [[java.net.Socket.setReceiveBufferSize]] */ val ReceiveBufferSize = SO.ReceiveBufferSize /** - * [[akka.io.Tcp.SocketOption]] to enable or disable SO_REUSEADDR + * [[akka.io.Inet.SocketOption]] to enable or disable SO_REUSEADDR * * For more information see [[java.net.Socket.setReuseAddress]] */ val ReuseAddress = SO.ReuseAddress /** - * [[akka.io.Tcp.SocketOption]] to set the SO_SNDBUF option. + * [[akka.io.Inet.SocketOption]] to set the SO_SNDBUF option. * * For more information see [[java.net.Socket.setSendBufferSize]] */ val SendBufferSize = SO.SendBufferSize /** - * [[akka.io.Tcp.SocketOption]] to set the traffic class or + * [[akka.io.Inet.SocketOption]] to set the traffic class or * type-of-service octet in the IP header for packets sent from this * socket. * @@ -114,28 +114,28 @@ object Inet { trait SoJavaFactories { import SO._ /** - * [[akka.io.Tcp.SocketOption]] to set the SO_RCVBUF option + * [[akka.io.Inet.SocketOption]] to set the SO_RCVBUF option * * For more information see [[java.net.Socket.setReceiveBufferSize]] */ def receiveBufferSize(size: Int) = ReceiveBufferSize(size) /** - * [[akka.io.Tcp.SocketOption]] to enable or disable SO_REUSEADDR + * [[akka.io.Inet.SocketOption]] to enable or disable SO_REUSEADDR * * For more information see [[java.net.Socket.setReuseAddress]] */ def reuseAddress(on: Boolean) = ReuseAddress(on) /** - * [[akka.io.Tcp.SocketOption]] to set the SO_SNDBUF option. + * [[akka.io.Inet.SocketOption]] to set the SO_SNDBUF option. * * For more information see [[java.net.Socket.setSendBufferSize]] */ def sendBufferSize(size: Int) = SendBufferSize(size) /** - * [[akka.io.Tcp.SocketOption]] to set the traffic class or + * [[akka.io.Inet.SocketOption]] to set the traffic class or * type-of-service octet in the IP header for packets sent from this * socket. * diff --git a/akka-actor/src/main/scala/akka/io/Pipelines.scala b/akka-actor/src/main/scala/akka/io/Pipelines.scala index 7ec0a72db0..79c785f340 100644 --- a/akka-actor/src/main/scala/akka/io/Pipelines.scala +++ b/akka-actor/src/main/scala/akka/io/Pipelines.scala @@ -148,7 +148,7 @@ abstract class AbstractPipePair[CmdAbove, CmdBelow, EvtAbove, EvtBelow] { /** * Wrap a single command for efficient return to the pipeline’s machinery. - * This method avoids allocating a [[Right]] and an [[java.lang.Iterable]] by reusing + * This method avoids allocating a [[scala.util.Right]] and an [[java.lang.Iterable]] by reusing * one such instance within the AbstractPipePair, hence it can be used ONLY ONCE by * each pipeline stage. Prototypic and safe usage looks like this: * @@ -166,7 +166,7 @@ abstract class AbstractPipePair[CmdAbove, CmdBelow, EvtAbove, EvtBelow] { /** * Wrap a single event for efficient return to the pipeline’s machinery. - * This method avoids allocating a [[Left]] and an [[Iterable]] by reusing + * This method avoids allocating a [[scala.util.Left]] and an [[java.lang.Iterable]] by reusing * one such instance within the AbstractPipePair, hence it can be used ONLY ONCE by * each pipeline stage. Prototypic and safe usage looks like this: * @@ -490,7 +490,7 @@ trait PipelineContext { /** * Scala API: Wrap a single command for efficient return to the pipeline’s machinery. - * This method avoids allocating a [[Right]] and an [[Iterable]] by reusing + * This method avoids allocating a [[scala.util.Right]] and an [[scala.collection.Iterable]] by reusing * one such instance within the PipelineContext, hence it can be used ONLY ONCE by * each pipeline stage. Prototypic and safe usage looks like this: * @@ -510,7 +510,7 @@ trait PipelineContext { /** * Scala API: Wrap a single event for efficient return to the pipeline’s machinery. - * This method avoids allocating a [[Left]] and an [[Iterable]] by reusing + * This method avoids allocating a [[scala.util.Left]] and an [[scala.collection.Iterable]] by reusing * one such instance within the context, hence it can be used ONLY ONCE by * each pipeline stage. Prototypic and safe usage looks like this: * @@ -742,15 +742,15 @@ object BackpressureBuffer { * This pipeline stage implements a configurable buffer for transforming the * per-write ACK/NACK-based backpressure model of a TCP connection actor into * an edge-triggered back-pressure model: the upper stages will receive - * notification when the buffer runs full ([[HighWatermarkReached]]) and when - * it subsequently empties ([[LowWatermarkReached]]). The upper layers should + * notification when the buffer runs full ([[BackpressureBuffer.HighWatermarkReached]]) and when + * it subsequently empties ([[BackpressureBuffer.LowWatermarkReached]]). The upper layers should * respond by not generating more writes when the buffer is full. There is also * a hard limit upon which this buffer will abort the connection. * * All limits are configurable and are given in number of bytes. * The `highWatermark` should be set such that the * amount of data generated before reception of the asynchronous - * [[HighWatermarkReached]] notification does not lead to exceeding the + * [[BackpressureBuffer.HighWatermarkReached]] notification does not lead to exceeding the * `maxCapacity` hard limit; if the writes may arrive in bursts then the * difference between these two should allow for at least one burst to be sent * after the high watermark has been reached. The `lowWatermark` must be less @@ -758,7 +758,7 @@ object BackpressureBuffer { * defines the hysteresis, i.e. how often these notifications are sent out (i.e. * if the difference is rather large then it will take some time for the buffer * to empty below the low watermark, and that room is then available for data - * sent in response to the [[LowWatermarkReached]] notification; if the + * sent in response to the [[BackpressureBuffer.LowWatermarkReached]] notification; if the * difference was small then the buffer would more quickly oscillate between * these two limits). */ @@ -1152,7 +1152,7 @@ class StringByteStringAdapter(charset: String = "utf-8") */ trait HasLogging extends PipelineContext { /** - * Retrieve the [[LoggingAdapter]] for this pipeline’s context. + * Retrieve the [[akka.event.LoggingAdapter]] for this pipeline’s context. */ def getLogger: LoggingAdapter } @@ -1164,7 +1164,7 @@ trait HasLogging extends PipelineContext { */ trait HasActorContext extends PipelineContext { /** - * Retrieve the [[ActorContext]] for this pipeline’s context. + * Retrieve the [[akka.actor.ActorContext]] for this pipeline’s context. */ def getContext: ActorContext } diff --git a/akka-actor/src/main/scala/akka/io/SslTlsSupport.scala b/akka-actor/src/main/scala/akka/io/SslTlsSupport.scala index af7ac2c7cd..43e78bfe5b 100644 --- a/akka-actor/src/main/scala/akka/io/SslTlsSupport.scala +++ b/akka-actor/src/main/scala/akka/io/SslTlsSupport.scala @@ -45,7 +45,7 @@ object SslTlsSupport { /** * This pipeline stage implements SSL / TLS support, using an externally - * configured [[SSLEngine]]. It operates on the level of [[Tcp.Event]] and + * configured [[javax.net.ssl.SSLEngine]]. It operates on the level of [[Tcp.Event]] and * [[Tcp.Command]] messages, which means that it will typically be one of * the lowest stages in a protocol stack. Since SSLEngine relies on contiguous * transmission of a data stream you will need to handle backpressure from diff --git a/akka-actor/src/main/scala/akka/io/Tcp.scala b/akka-actor/src/main/scala/akka/io/Tcp.scala index d2b231392b..30db38168b 100644 --- a/akka-actor/src/main/scala/akka/io/Tcp.scala +++ b/akka-actor/src/main/scala/akka/io/Tcp.scala @@ -526,8 +526,8 @@ object TcpMessage { /** * The Connect message is sent to the TCP manager actor, which is obtained via - * [[TcpExt#getManager]]. Either the manager replies with a [[CommandFailed]] - * or the actor handling the new connection replies with a [[Connected]] + * [[TcpExt#getManager]]. Either the manager replies with a [[Tcp.CommandFailed]] + * or the actor handling the new connection replies with a [[Tcp.Connected]] * message. * * @param remoteAddress is the address to connect to @@ -567,13 +567,13 @@ object TcpMessage { /** * The Bind message is send to the TCP manager actor, which is obtained via * [[TcpExt#getManager]] in order to bind to a listening socket. The manager - * replies either with a [[CommandFailed]] or the actor handling the listen - * socket replies with a [[Bound]] message. If the local port is set to 0 in - * the Bind message, then the [[Bound]] message should be inspected to find + * replies either with a [[Tcp.CommandFailed]] or the actor handling the listen + * socket replies with a [[Tcp.Bound]] message. If the local port is set to 0 in + * the Bind message, then the [[Tcp.Bound]] message should be inspected to find * the actual port which was bound to. * * @param handler The actor which will receive all incoming connection requests - * in the form of [[Connected]] messages. + * in the form of [[Tcp.Connected]] messages. * * @param localAddress The socket address to bind to; use port zero for * automatic assignment (i.e. an ephemeral port, see [[Bound]]) @@ -596,7 +596,7 @@ object TcpMessage { /** * This message must be sent to a TCP connection actor after receiving the - * [[Connected]] message. The connection will not read any data from the + * [[Tcp.Connected]] message. The connection will not read any data from the * socket until this message is received, because this message defines the * actor which will receive all inbound data. * @@ -605,11 +605,11 @@ object TcpMessage { * * @param keepOpenOnPeerClosed If this is set to true then the connection * is not automatically closed when the peer closes its half, - * requiring an explicit [[Closed]] from our side when finished. + * requiring an explicit [[Tcp.Closed]] from our side when finished. * * @param useResumeWriting If this is set to true then the connection actor - * will refuse all further writes after issuing a [[CommandFailed]] - * notification until [[ResumeWriting]] is received. This can + * will refuse all further writes after issuing a [[Tcp.CommandFailed]] + * notification until [[Tcp.ResumeWriting]] is received. This can * be used to implement NACK-based write backpressure. */ def register(handler: ActorRef, keepOpenOnPeerClosed: Boolean, useResumeWriting: Boolean): Command = @@ -621,15 +621,15 @@ object TcpMessage { /** * In order to close down a listening socket, send this message to that socket’s - * actor (that is the actor which previously had sent the [[Bound]] message). The - * listener socket actor will reply with a [[Unbound]] message. + * actor (that is the actor which previously had sent the [[Tcp.Bound]] message). The + * listener socket actor will reply with a [[Tcp.Unbound]] message. */ def unbind: Command = Unbind /** * A normal close operation will first flush pending writes and then close the * socket. The sender of this command and the registered handler for incoming - * data will both be notified once the socket is closed using a [[Closed]] + * data will both be notified once the socket is closed using a [[Tcp.Closed]] * message. */ def close: Command = Close @@ -638,7 +638,7 @@ object TcpMessage { * A confirmed close operation will flush pending writes and half-close the * connection, waiting for the peer to close the other half. The sender of this * command and the registered handler for incoming data will both be notified - * once the socket is closed using a [[ConfirmedClosed]] message. + * once the socket is closed using a [[Tcp.ConfirmedClosed]] message. */ def confirmedClose: Command = ConfirmedClose @@ -647,28 +647,28 @@ object TcpMessage { * command to the O/S kernel which should result in a TCP_RST packet being sent * to the peer. The sender of this command and the registered handler for * incoming data will both be notified once the socket is closed using a - * [[Aborted]] message. + * [[Tcp.Aborted]] message. */ def abort: Command = Abort /** - * Each [[WriteCommand]] can optionally request a positive acknowledgment to be sent - * to the commanding actor. If such notification is not desired the [[WriteCommand#ack]] + * Each [[Tcp.WriteCommand]] can optionally request a positive acknowledgment to be sent + * to the commanding actor. If such notification is not desired the [[Tcp.WriteCommand#ack]] * must be set to an instance of this class. The token contained within can be used - * to recognize which write failed when receiving a [[CommandFailed]] message. + * to recognize which write failed when receiving a [[Tcp.CommandFailed]] message. */ def noAck(token: AnyRef): NoAck = NoAck(token) /** - * Default [[NoAck]] instance which is used when no acknowledgment information is + * Default [[Tcp.NoAck]] instance which is used when no acknowledgment information is * explicitly provided. Its “token” is `null`. */ def noAck: NoAck = NoAck /** * Write data to the TCP connection. If no ack is needed use the special - * `NoAck` object. The connection actor will reply with a [[CommandFailed]] - * message if the write could not be enqueued. If [[WriteCommand#wantsAck]] - * returns true, the connection actor will reply with the supplied [[WriteCommand#ack]] + * `NoAck` object. The connection actor will reply with a [[Tcp.CommandFailed]] + * message if the write could not be enqueued. If [[Tcp.WriteCommand#wantsAck]] + * returns true, the connection actor will reply with the supplied [[Tcp.WriteCommand#ack]] * token once the write has been successfully enqueued to the O/S kernel. * Note that this does not in any way guarantee that the data will be * or have been sent! Unfortunately there is no way to determine whether @@ -682,9 +682,9 @@ object TcpMessage { /** * Write `count` bytes starting at `position` from file at `filePath` to the connection. - * The count must be > 0. The connection actor will reply with a [[CommandFailed]] - * message if the write could not be enqueued. If [[WriteCommand#wantsAck]] - * returns true, the connection actor will reply with the supplied [[WriteCommand#ack]] + * The count must be > 0. The connection actor will reply with a [[Tcp.CommandFailed]] + * message if the write could not be enqueued. If [[Tcp.WriteCommand#wantsAck]] + * returns true, the connection actor will reply with the supplied [[Tcp.WriteCommand#ack]] * token once the write has been successfully enqueued to the O/S kernel. * Note that this does not in any way guarantee that the data will be * or have been sent! Unfortunately there is no way to determine whether @@ -694,23 +694,23 @@ object TcpMessage { WriteFile(filePath, position, count, ack) /** - * When `useResumeWriting` is in effect as was indicated in the [[Register]] message + * When `useResumeWriting` is in effect as was indicated in the [[Tcp.Register]] message * then this command needs to be sent to the connection actor in order to re-enable - * writing after a [[CommandFailed]] event. All [[WriteCommand]] processed by the - * connection actor between the first [[CommandFailed]] and subsequent reception of - * this message will also be rejected with [[CommandFailed]]. + * writing after a [[Tcp.CommandFailed]] event. All [[Tcp.WriteCommand]] processed by the + * connection actor between the first [[Tcp.CommandFailed]] and subsequent reception of + * this message will also be rejected with [[Tcp.CommandFailed]]. */ def resumeWriting: Command = ResumeWriting /** * Sending this command to the connection actor will disable reading from the TCP * socket. TCP flow-control will then propagate backpressure to the sender side - * as buffers fill up on either end. To re-enable reading send [[ResumeReading]]. + * as buffers fill up on either end. To re-enable reading send [[Tcp.ResumeReading]]. */ def suspendReading: Command = SuspendReading /** - * This command needs to be sent to the connection actor after a [[SuspendReading]] + * This command needs to be sent to the connection actor after a [[Tcp.SuspendReading]] * command in order to resume reading from the socket. */ def resumeReading: Command = ResumeReading diff --git a/akka-actor/src/main/scala/akka/io/TcpPipelineHandler.scala b/akka-actor/src/main/scala/akka/io/TcpPipelineHandler.scala index 5c49d92957..3d4d2295bc 100644 --- a/akka-actor/src/main/scala/akka/io/TcpPipelineHandler.scala +++ b/akka-actor/src/main/scala/akka/io/TcpPipelineHandler.scala @@ -94,7 +94,7 @@ object TcpPipelineHandler { case class TcpEvent(@BeanProperty evt: Tcp.Event) extends Tcp.Command /** - * create [[Props]] for a pipeline handler + * create [[akka.actor.Props]] for a pipeline handler */ def props[Ctx <: PipelineContext, Cmd, Evt](init: TcpPipelineHandler.Init[Ctx, Cmd, Evt], connection: ActorRef, handler: ActorRef) = Props(classOf[TcpPipelineHandler[_, _, _]], init, connection, handler) @@ -104,8 +104,8 @@ object TcpPipelineHandler { /** * This actor wraps a pipeline and forwards commands and events between that * one and a [[Tcp]] connection actor. In order to inject commands into the - * pipeline send an [[Init.Command]] message to this actor; events will be sent - * to the designated handler wrapped in [[Init.Event]] messages. + * pipeline send an [[TcpPipelineHandler.Init.Command]] message to this actor; events will be sent + * to the designated handler wrapped in [[TcpPipelineHandler.Init.Event]] messages. * * When the designated handler terminates the TCP connection is aborted. When * the connection actor terminates this actor terminates as well; the designated @@ -164,7 +164,7 @@ class TcpPipelineHandler[Ctx <: PipelineContext, Cmd, Evt]( * * While this adapter communicates to the stage above it via raw ByteStrings, it is possible to inject Tcp Command * by sending them to the management port, and the adapter will simply pass them down to the stage below. Incoming Tcp Events - * that are not Receive events will be passed downwards wrapped in a [[TcpEvent]]; the [[TcpPipelineHandler]] will + * that are not Receive events will be passed downwards wrapped in a [[TcpPipelineHandler.TcpEvent]]; the [[TcpPipelineHandler]] will * send these notifications to the registered event handler actor. */ class TcpReadWriteAdapter extends PipelineStage[PipelineContext, ByteString, Tcp.Command, ByteString, Tcp.Event] { diff --git a/akka-actor/src/main/scala/akka/io/Udp.scala b/akka-actor/src/main/scala/akka/io/Udp.scala index e101aad1aa..6fc4082ff9 100644 --- a/akka-actor/src/main/scala/akka/io/Udp.scala +++ b/akka-actor/src/main/scala/akka/io/Udp.scala @@ -244,33 +244,33 @@ object UdpMessage { import language.implicitConversions /** - * Each [[Send]] can optionally request a positive acknowledgment to be sent - * to the commanding actor. If such notification is not desired the [[Send#ack]] + * Each [[Udp.Send]] can optionally request a positive acknowledgment to be sent + * to the commanding actor. If such notification is not desired the [[Udp.Send#ack]] * must be set to an instance of this class. The token contained within can be used - * to recognize which write failed when receiving a [[CommandFailed]] message. + * to recognize which write failed when receiving a [[Udp.CommandFailed]] message. */ def noAck(token: AnyRef): NoAck = NoAck(token) /** - * Default [[NoAck]] instance which is used when no acknowledgment information is + * Default [[Udp.NoAck]] instance which is used when no acknowledgment information is * explicitly provided. Its “token” is `null`. */ def noAck: NoAck = NoAck /** * This message is understood by the “simple sender” which can be obtained by - * sending the [[SimpleSender]] query to the [[UdpExt#manager]] as well as by - * the listener actors which are created in response to [[Bind]]. It will send + * sending the [[Udp.SimpleSender]] query to the [[UdpExt#manager]] as well as by + * the listener actors which are created in response to [[Udp.Bind]]. It will send * the given payload data as one UDP datagram to the given target address. The - * UDP actor will respond with [[CommandFailed]] if the send could not be + * UDP actor will respond with [[Udp.CommandFailed]] if the send could not be * enqueued to the O/S kernel because the send buffer was full. If the given - * `ack` is not of type [[NoAck]] the UDP actor will reply with the given + * `ack` is not of type [[Udp.NoAck]] the UDP actor will reply with the given * object as soon as the datagram has been successfully enqueued to the O/S * kernel. * * The sending UDP socket’s address belongs to the “simple sender” which does * not handle inbound datagrams and sends from an ephemeral port; therefore * sending using this mechanism is not suitable if replies are expected, use - * [[Bind]] in that case. + * [[Udp.Bind]] in that case. */ def send(payload: ByteString, target: InetSocketAddress, ack: Event): Command = Send(payload, target, ack) /** @@ -281,8 +281,8 @@ object UdpMessage { /** * Send this message to the [[UdpExt#manager]] in order to bind to the given * local port (or an automatically assigned one if the port number is zero). - * The listener actor for the newly bound port will reply with a [[Bound]] - * message, or the manager will reply with a [[CommandFailed]] message. + * The listener actor for the newly bound port will reply with a [[Udp.Bound]] + * message, or the manager will reply with a [[Udp.CommandFailed]] message. */ def bind(handler: ActorRef, endpoint: InetSocketAddress, options: JIterable[SocketOption]): Command = Bind(handler, endpoint, options.asScala.to) @@ -292,15 +292,15 @@ object UdpMessage { def bind(handler: ActorRef, endpoint: InetSocketAddress): Command = Bind(handler, endpoint, Nil) /** - * Send this message to the listener actor that previously sent a [[Bound]] + * Send this message to the listener actor that previously sent a [[Udp.Bound]] * message in order to close the listening socket. The recipient will reply - * with an [[Unbound]] message. + * with an [[Udp.Unbound]] message. */ def unbind: Command = Unbind /** * Retrieve a reference to a “simple sender” actor of the UDP extension. - * The newly created “simple sender” will reply with the [[SimpleSenderReady]] notification. + * The newly created “simple sender” will reply with the [[Udp.SimpleSenderReady]] notification. * * The “simple sender” is a convenient service for being able to send datagrams * when the originating address is meaningless, i.e. when no reply is expected. @@ -315,16 +315,16 @@ object UdpMessage { def simpleSender: Command = SimpleSender /** - * Send this message to a listener actor (which sent a [[Bound]] message) to + * Send this message to a listener actor (which sent a [[Udp.Bound]] message) to * have it stop reading datagrams from the network. If the O/S kernel’s receive * buffer runs full then subsequent datagrams will be silently discarded. - * Re-enable reading from the socket using the [[ResumeReading]] command. + * Re-enable reading from the socket using the [[Udp.ResumeReading]] command. */ def suspendReading: Command = SuspendReading /** * This message must be sent to the listener actor to re-enable reading from - * the socket after a [[SuspendReading]] command. + * the socket after a [[Udp.SuspendReading]] command. */ def resumeReading: Command = ResumeReading } diff --git a/akka-actor/src/main/scala/akka/io/UdpConnected.scala b/akka-actor/src/main/scala/akka/io/UdpConnected.scala index 19105df1c0..c8e91e7067 100644 --- a/akka-actor/src/main/scala/akka/io/UdpConnected.scala +++ b/akka-actor/src/main/scala/akka/io/UdpConnected.scala @@ -103,7 +103,7 @@ object UdpConnected extends ExtensionId[UdpConnectedExt] with ExtensionIdProvide case object Disconnect extends Command /** - * Send this message to a listener actor (which sent a [[Bound]] message) to + * Send this message to a listener actor (which sent a [[Udp.Bound]] message) to * have it stop reading datagrams from the network. If the O/S kernel’s receive * buffer runs full then subsequent datagrams will be silently discarded. * Re-enable reading from the socket using the [[ResumeReading]] command. @@ -123,7 +123,7 @@ object UdpConnected extends ExtensionId[UdpConnectedExt] with ExtensionIdProvide /** * When a connection actor receives a datagram from its socket it will send - * it to the handler designated in the [[Bind]] message using this message type. + * it to the handler designated in the [[Udp.Bind]] message using this message type. */ case class Received(data: ByteString) extends Event @@ -201,8 +201,8 @@ object UdpConnectedMessage { /** * This message is understood by the connection actors to send data to their * designated destination. The connection actor will respond with - * [[CommandFailed]] if the send could not be enqueued to the O/S kernel - * because the send buffer was full. If the given `ack` is not of type [[NoAck]] + * [[UdpConnected.CommandFailed]] if the send could not be enqueued to the O/S kernel + * because the send buffer was full. If the given `ack` is not of type [[UdpConnected.NoAck]] * the connection actor will reply with the given object as soon as the datagram * has been successfully enqueued to the O/S kernel. */ @@ -214,36 +214,36 @@ object UdpConnectedMessage { /** * Send this message to a connection actor (which had previously sent the - * [[Connected]] message) in order to close the socket. The connection actor - * will reply with a [[Disconnected]] message. + * [[UdpConnected.Connected]] message) in order to close the socket. The connection actor + * will reply with a [[UdpConnected.Disconnected]] message. */ def disconnect: Command = Disconnect /** - * Each [[Send]] can optionally request a positive acknowledgment to be sent - * to the commanding actor. If such notification is not desired the [[Send#ack]] + * Each [[UdpConnected.Send]] can optionally request a positive acknowledgment to be sent + * to the commanding actor. If such notification is not desired the [[UdpConnected.Send#ack]] * must be set to an instance of this class. The token contained within can be used - * to recognize which write failed when receiving a [[CommandFailed]] message. + * to recognize which write failed when receiving a [[UdpConnected.CommandFailed]] message. */ def noAck(token: AnyRef): NoAck = NoAck(token) /** - * Default [[NoAck]] instance which is used when no acknowledgment information is + * Default [[UdpConnected.NoAck]] instance which is used when no acknowledgment information is * explicitly provided. Its “token” is `null`. */ def noAck: NoAck = NoAck /** - * Send this message to a listener actor (which sent a [[Bound]] message) to + * Send this message to a listener actor (which sent a [[Udp.Bound]] message) to * have it stop reading datagrams from the network. If the O/S kernel’s receive * buffer runs full then subsequent datagrams will be silently discarded. - * Re-enable reading from the socket using the [[ResumeReading]] command. + * Re-enable reading from the socket using the [[UdpConnected.ResumeReading]] command. */ def suspendReading: Command = SuspendReading /** * This message must be sent to the listener actor to re-enable reading from - * the socket after a [[SuspendReading]] command. + * the socket after a [[UdpConnected.SuspendReading]] command. */ def resumeReading: Command = ResumeReading diff --git a/akka-actor/src/main/scala/akka/pattern/AskSupport.scala b/akka-actor/src/main/scala/akka/pattern/AskSupport.scala index 1905d73533..c741c53803 100644 --- a/akka-actor/src/main/scala/akka/pattern/AskSupport.scala +++ b/akka-actor/src/main/scala/akka/pattern/AskSupport.scala @@ -41,7 +41,7 @@ trait AskSupport { * val future = actor.ask(message)(timeout) // => ask(actor, message)(timeout) * }}} * - * All of the above use an implicit [[akka.actor.Timeout]]. + * All of the above use an implicit [[akka.util.Timeout]]. */ implicit def ask(actorRef: ActorRef): AskableActorRef = new AskableActorRef(actorRef) @@ -88,7 +88,7 @@ trait AskSupport { * val future = selection.ask(message)(timeout) // => ask(selection, message)(timeout) * }}} * - * All of the above use an implicit [[akka.actor.Timeout]]. + * All of the above use an implicit [[akka.util.Timeout]]. */ implicit def ask(actorSelection: ActorSelection): AskableActorSelection = new AskableActorSelection(actorSelection) diff --git a/akka-actor/src/main/scala/akka/routing/ConsistentHashingRouter.scala b/akka-actor/src/main/scala/akka/routing/ConsistentHashingRouter.scala index 9a6e7a4692..ad2ef4602d 100644 --- a/akka-actor/src/main/scala/akka/routing/ConsistentHashingRouter.scala +++ b/akka-actor/src/main/scala/akka/routing/ConsistentHashingRouter.scala @@ -35,7 +35,7 @@ object ConsistentHashingRouter { * the hash, but the data to be hashed. * * If returning an `Array[Byte]` or String it will be used as is, - * otherwise the configured [[akka.akka.serialization.Serializer]] + * otherwise the configured [[akka.serialization.Serializer]] * will be applied to the returned data. * * If messages can't implement this interface themselves, @@ -67,7 +67,7 @@ object ConsistentHashingRouter { * the hash that is to be returned, but the data to be hashed. * * If returning an `Array[Byte]` or String it will be used as is, - * otherwise the configured [[akka.akka.serialization.Serializer]] + * otherwise the configured [[akka.serialization.Serializer]] * will be applied to the returned data. */ type ConsistentHashMapping = PartialFunction[Any, Any] @@ -88,13 +88,14 @@ object ConsistentHashingRouter { * this mapping. * * If returning an `Array[Byte]` or String it will be used as is, - * otherwise the configured [[akka.akka.serialization.Serializer]] + * otherwise the configured [[akka.serialization.Serializer]] * will be applied to the returned data. */ trait ConsistentHashMapper { def hashKey(message: Any): Any } } + /** * A Router that uses consistent hashing to select a connection based on the * sent message. @@ -137,7 +138,7 @@ object ConsistentHashingRouter { * * @param routees string representation of the actor paths of the routees that will be looked up * using `actorFor` in [[akka.actor.ActorRefProvider]] - * @param virtualNodesFactor number of virtual nodes per node, used in [[akka.routing.ConsistantHash]] + * @param virtualNodesFactor number of virtual nodes per node, used in [[akka.routing.ConsistentHash]] * @param hashMapping partial function from message to the data to * use for the consistent hash key */