Module roopes::prelude

Exposes the most used types from the library.

Modules

• abstract_factory
  Doc images not enabled. Compile with feature doc-images and Rust version >= 1.54 to enable. Provides an abstraction for object creation.
• command
  Doc images not enabled. Compile with feature doc-images and Rust version >= 1.54 to enable. Contains types which encapsulate a repeatedly callable block of code.
• command_executable
  Doc images not enabled. Compile with feature doc-images and Rust version >= 1.54 to enable. The executable_command module creates Executables from arbitrary Commands. ![executable command diagram][executable-command-diagram]
• emitter
  Provides an encapsulated unit of production.
• executable
  Provides an encapsulated unit of execution.
• executable_command
  Doc images not enabled. Compile with feature doc-images and Rust version >= 1.54 to enable. The executable_command module creates Executables from arbitrary Commands. ![executable command diagram][executable-command-diagram]
• executable_observer
  This module enables conversion between Observer and Executable.
• handler
  Provides types which receive a borrowed value.
• handling_publisher
  Doc images not enabled. Compile with feature doc-images and Rust version >= 1.54 to enable. The handling_publisher module creates Handlers from arbitrary Publishers.
• heap_pool
  Contains types which allow client code to generate, use, and re-use heap-allocated objects efficiently.
• observer
  Contains types which implement the “Observer” pattern, in which a single object is used to delegate notifications to a group of dynamic listening object.
• observing_command
  Doc images not enabled. Compile with feature doc-images and Rust version >= 1.54 to enable. The observing_command module creates Observers from arbitrary Commands.
• publisher_subscriber
  This module implements the Publisher-Subscriber pattern. In this model, a Publisher contains a list of Subscribers. When a message is delivered to the Publisher, it is then delegated directly to all its Subscribers, one at a time. Typically, implementations are dynamic, in that Subscribers are able to be dded or removed at will by the client code - these features are delineated separately in the DetachablePublisher and AttachablePublisher traits, but can be implemented by any Publisher, and together as a MutablePublisher.
• state
  This module implements the State pattern.
• subscribing_handler
  Doc images not enabled. Compile with feature doc-images and Rust version >= 1.54 to enable. The subscribing_handler module creates Subscribers from arbitrary Handlers.
• transformer
  Provides types which receive a borrowed value, and return a new, owned value.
• transformer_chain
  Provides arbitrarily chained groups of crate::primitives::transformer::Transformers to be setup and used repeatedly.
• transforming_handler
  Combines a transformer and a handler to create a new handler which conforms to the transformer’s input, but forwards its output to the handler.

Structs

• CommandExecutable
  Bridges Commands and Executables into one type, which implements both traits.
• ExecutableCommand
  Bridges Commands and Executables into one type, which implements both traits.
• ExecutableObserver
  Wraps an Observer such that calls to Executable::execute are forwarded to Observer::notify.
• HandlingPublisher
  Provides the Subscriber and Handler traits for a wrapped Handler delegate.
• ObservingCommand
  Provides the Observer and Command traits for a given command.
• SubscribingHandler
  Provides the Subscriber and Handler traits for a wrapped Handler delegate.
• TransformingHandler
  Combines a transformer and a handler to create a new handler which conforms to the transformer’s input, but forwards its output to the handler.

Traits

• AbstractFactory
  This trait enables the abstraction of the creation of objects.
• AttachablePublisher
  Allows Subscribers to be added to the implementing Publisher.
• AttachableSubject
  Allows Observers to be added to the implementing Subject.
• Command
  Encapsulates a repeatedly callable block of code.
• Context
  This trait holds the active state, and acts as a persistent handle for the state machine, which could otherwise be the states themselves.
• DetachablePublisher
  Allows Subscribers to be removed from the implementing Publisher.
• DetachableSubject
  Allows Observers to be removed from the implementing Subject.
• Emitter
  Emitters are capable of continuously returning an owned object to the caller. Iterator is a subset of this interface in that Emitter<Option<T>> is equivalent to Iterator<T>.
• Executable
  Encapsulates a block of execution which may be run zero-or-more times.
• Handler
  Defines a primitive interface which handles messages via borrowing.
• HeapPool
  Holds a list of allocated objects in a scalable pool. Previously allocated objects can be checked back in after use, to prevent immediate deallocation.
• Observer
  An object notified by a Subject.
• Publisher
  A Publisher distributes messages it receives to the Subscribers which it currently holds.
• State
  Provides transitions between states.
• Subject
  An object which notifies some group of Observers. When it is notified, all the listeners are notified.
• Subscriber
  Subscribers can be attached to, and will receive messages from, Publishers.
• Transformer
  A Transformer receives a borrowed value and creates a new value of a possibly different type, giving ownership to the caller.

Derive Macros

• Builder
  Creates a new type on the specified struct, which allows fields to be set one at a time. The new builder type’s name is the specified type, appended with “Builder”.
• PubSub
  Creates a Publisher and Subscriber for the given message type.
• Visitor
  Creates a new trait for user code to implement on the specified enum. This trait requires implementors to implement handlers for all the specified variants in the given enum.