capsule
A capsule represents something which is startable and stoppable.
A capsule represents something which is startable and stoppable. After being started and before being stopped, we say the capsule is active. Otherwise, we say it's inactive.
As end user, you usually don't come into contact with capsules directly, you rather add them using convenience methods.
As capsule provider, you should implement this interface in order to provide logic which will be started and stopped on certain events. You might also want to implement convenience methods which use CapsuleContext to add the logic to the current capsule scope.
Represents the tree structure which is formed by capsule scopes and their contained capsules.
Represents the tree structure which is formed by capsule scopes and their contained capsules.
As end user, you usually don't deal with this interface.
As capsule provider, you use this interface for implementing the convenience methods and providing new capsule scopes.
As context provider, you can implement this interface. However, you can also use the existing implementation DynamicCapsuleContext.
Provides convenient onStart and onStop methods which the end user can use for ad-hoc adding
start and stop logic to the current scope.
Represents a collection of capsules which shall all be stopped on the same event.
Represents a collection of capsules which shall all be stopped on the same event.
As end user, you don't deal with this interface at all.
As capsule provider, you might use this interface but you don't have to implement it. An object of this type is returned from CapsuleContext.executeWithinNewCapsuleScope which is used to create a new scope. You should then use this object later to stop all capsules in your new scope when the stopping event occurs.
A capsule scope implementation based on a scala.collection.Traversable.
A CapsuleContext implementation based on scala.util.DynamicVariable and DefaultCapsuleScope.
A CapsuleContext implementation based on scala.util.DynamicVariable and DefaultCapsuleScope.
As a context provider, you might want to mix this trait into your class to provide the framework for a capsule-based DSL. See class domino.OsgiContext in the project "Domino" for an example.
A class extending from DynamicCapsuleContext.
A class extending from DynamicCapsuleContext. Use this if you want to use a class instead of a trait.
Contains a basic API and default implementation for building, using and extending a capsule-based DSL.
A capsule-based DSL is a generalization of the DSL used in the project "Domino". Here's an illustrative example how a capsuled-based DSL might look like:
// Somewhere in your code whenTurnedOn { whenDevicePluggedIn { lightLED() } }The documentation distinguishes between 3 types of API clients: End users, capsule providers and context providers. The majority of developers will just come into contact with this API as end users.