core/it.unibo.pulvreakt.api.component/AbstractComponent

AbstractComponent

abstract class AbstractComponent : Component

Preconfigured abstract implementation of Component. This class provides in the companion object some helper methods to send and receive messages without specifying the serialization. Preconfigures the component defining the initialize and finalize methods.

This abstract class implements all the machinery needed for a component to work, letting the user focusing only on the implementation of the execute method. The execute method can fail with a ComponentError and it is executed in a coroutine scope. An example of generic component implementation is the following:

class MyComponent : AbstractComponent() {
    override suspend fun execute(): Either<ComponentError, Unit> = either {
        // component logic implementation
    }
}

When a pulverization model is adopted, used the component-specific class provided in the pulverization package.

Inheritors

AbstractPulverizedComponent

Constructors

AbstractComponent

constructor()

Types

Companion

object Companion

Properties

open lateinit override var di: DI

diContext

open val diContext: DIContext<*>

diTrigger

open val diTrigger: DITrigger?

Functions

execute

abstract suspend fun execute(): Either<ComponentError, Unit>

Starts the execution of the component logic. The execution may fail with a ComponentError. Before calling this method the setupWiring method MUST be called.

finalize

open suspend override fun finalize(): Either<ComponentError, Unit>

Asynchronously finalizes the entity. Can Either succeed or fail with an Error.

getRef

open override fun getRef(): ComponentRef

Returns a symbolic reference to this component. This method is used internally by the runtime and should not be called by the user.

initialize

open suspend override fun initialize(): Either<ComponentError, Unit>

Asynchronously initializes the entity. Can Either succeed or fail with an Error.

receive

suspend override fun receive(fromComponent: ComponentRef, serializer: KSerializer<out P>): Either<ComponentError, Flow>

Receives a message of type P by deserializing it with the given serializer. If the message pushed in the flow cannot be serialized with the given serializer the flow will fail with an exception. This method can fail with a ComponentNotRegistered if the fromComponent is not registered as link of this component.

receive

inline suspend fun Component.receive(fromComponent: ComponentRef): Either<ComponentError, Flow>

Helper method to receive messages fromComponent without specifying the serialization.

send

suspend override fun send(toComponent: ComponentRef, message: P, serializer: KSerializer<in P>): Either<ComponentError, Unit>

Sends a message of type P by serializing it with the given serializer. This method can fail with a ComponentNotRegistered if the toComponent is not registered as link of this component.

send

inline suspend fun Component.send(toComponent: ComponentRef, message: P): Either<ComponentError, Unit>

Helper method to send a message without specifying the serialization.

setupInjector

open override fun setupInjector(kodein: DI)

Configures the module of the dependency injection module that the resource will use.

setupWiring

open override fun setupWiring(vararg components: ComponentRef)

Setup all the other components to which this component will communicate. The components represents the symbolic references to the other components allowing a distributed communication. This method is generally called by the runtime when the pulverization model is adopted. In case of custom Logical Device partitioning this method should be called manually.