Apache Pekko1.0.2 < Back

Packages

package root
Definition Classes
root
package org
Definition Classes
root
package apache
Definition Classes
org
package pekko
Definition Classes
apache
package actor
package annotation
package cluster
package coordination
package discovery
package dispatch
package event
package io
package japi
package osgi
package pattern
This package is used as a collection point for usage patterns which involve actors, futures, etc.
Commonly Used Patterns With Akka
This package is used as a collection point for usage patterns which involve actors, futures, etc. but are loosely enough coupled to (multiple of) them to present them separately from the core implementation. Currently supported are:
- ask: create a temporary one-off actor for receiving a reply to a message and complete a scala.concurrent.Future with it; returns said Future.
- pipeTo: feed eventually computed value of a future to an org.apache.pekko.actor.ActorRef as a message.
- pipeToSelection: feed eventually computed value of a future to an org.apache.pekko.actor.ActorSelection as a message.
In Scala the recommended usage is to import the pattern from the package object:
```
import org.apache.pekko.pattern.ask

ask(actor, message) // use it directly
actor ask message   // use it by implicit conversion
```
For Java the patterns are available as static methods of the org.apache.pekko.pattern.Patterns class:
```
import static org.apache.pekko.pattern.Patterns.ask;

ask(actor, message);
```
package persistence
package pki
package remote
package routing
package serialization
package stream
package testkit
package util
ConfigurationException
Done
Main
NotUsed
OnlyCauseStackTrace
PekkoException
PekkoVersion
UnsupportedPekkoVersion
Version

p

pekko

package pekko

Content Hierarchy

Ordering

Alphabetic

Visibility

Public
Protected

Package Members

package actor
package annotation
package cluster
package coordination
package discovery
package dispatch
package event
package io
package japi
package osgi
package pattern
This package is used as a collection point for usage patterns which involve actors, futures, etc.
Commonly Used Patterns With Akka
This package is used as a collection point for usage patterns which involve actors, futures, etc. but are loosely enough coupled to (multiple of) them to present them separately from the core implementation. Currently supported are:
- ask: create a temporary one-off actor for receiving a reply to a message and complete a scala.concurrent.Future with it; returns said Future.
- pipeTo: feed eventually computed value of a future to an org.apache.pekko.actor.ActorRef as a message.
- pipeToSelection: feed eventually computed value of a future to an org.apache.pekko.actor.ActorSelection as a message.
In Scala the recommended usage is to import the pattern from the package object:
```
import org.apache.pekko.pattern.ask

ask(actor, message) // use it directly
actor ask message   // use it by implicit conversion
```
For Java the patterns are available as static methods of the org.apache.pekko.pattern.Patterns class:
```
import static org.apache.pekko.pattern.Patterns.ask;

ask(actor, message);
```
package persistence
package pki
package remote
package routing
package serialization
package stream
package testkit
package util

Type Members

class ConfigurationException extends PekkoException
This exception is thrown when Apache Pekko detects a problem with the provided configuration
sealed abstract class Done extends Serializable
Typically used together with Future to signal completion but there is no actual value completed.
Typically used together with Future to signal completion but there is no actual value completed. More clearly signals intent than Unit and is available both from Scala and Java (which Unit is not).
Annotations
@DoNotInherit()
sealed abstract class NotUsed extends AnyRef
This type is used in generic type signatures wherever the actual value is of no importance.
This type is used in generic type signatures wherever the actual value is of no importance. It is a combination of Scala’s Unit and Java’s Void, which both have different issues when used from the other language. An example use-case is the materialized value of a Pekko Stream for cases where no result shall be returned from materialization.
trait OnlyCauseStackTrace extends AnyRef
Mix in this trait to suppress the StackTrace for the instance of the exception but not the cause, scala.util.control.NoStackTrace suppresses all the StackTraces.
class PekkoException extends RuntimeException with Serializable
Pekko base Exception.
Pekko base Exception.
Annotations
@SerialVersionUID()
final class UnsupportedPekkoVersion extends RuntimeException

Value Members

case object Done extends Done with Product with Serializable
case object NotUsed extends NotUsed with Product with Serializable
object PekkoVersion
object Version

Deprecated Value Members

object Main
Main class to start an pekko.actor.ActorSystem with one top level application supervisor actor.
Main class to start an pekko.actor.ActorSystem with one top level application supervisor actor. It will shutdown the actor system when the top level actor is terminated.
Annotations
@deprecated
Deprecated
(Since version Akka 2.6.0) Implement your own main class instead, from which you start the ActorSystem and actors.

Ungrouped