Download the PHP package sroze/chain-of-responsibility without Composer
On this page you can find all versions of the php package sroze/chain-of-responsibility. It is possible to download/install these versions without Composer. Possible dependencies are resolved automatically.
Download sroze/chain-of-responsibility
More information about sroze/chain-of-responsibility
Files in sroze/chain-of-responsibility
Package chain-of-responsibility
Short Description A light library that simplify the implementation of a chain of responsibility
License MIT
Homepage https://github.com/sroze/ChainOfResponsibility
FAQ
Example:
In general, it is recommended to use always a project to download your libraries. In an application normally there is more than one library needed.
- Some hosting areas are not accessible by a terminal or SSH. Then it is not possible to use Composer.
- To use Composer is sometimes complicated. Especially for beginners.
- Composer needs much resources. Sometimes they are not available on a simple webspace.
- If you are using private repositories you don't need to share your credentials. You can set up everything on our site and then you provide a simple download link to your team member.
- Simplify your Composer build process. Use our own command line tool to download the vendor folder as binary. This makes your build process faster and you don't need to expose your credentials for private repositories.
Informations about the package chain-of-responsibility
Chain Of Responsibility
This light library helps to implement quickly a chain of responsibility. This pattern is especially useful when you need a clear process that involve multiple steps.
Installation
The suggested installation method is via composer:
Usage
There's two components:
- The Runner that will take a brunch of processes, decorates them to create the chain-of-responsibility and execute the head.
- The builder adds a little bit of like to processes because they can declare a list of other processes that needs to be run before.
Runner
Create your processes classes that implements the ChainProcessInterface. This interface only has one execute method
that take a ChainContext object as parameter. This parameter is usable like an array and will provides your processes
a common way to exchange information between them.
Create the chain runner with a list of given processes. The list order is quite important since it'll be the order of execution of processes.
Then, use the run method to run each process, with an optional ChainContext argument.
Builder
The builder is able to construct your chain of responsibility based on dependencies between processes. To declare
dependencies, your process have to implement the DependentChainProcessInterface interface.
Then, create another BarProcess which getName method will return bar and its dependsOn will return an empty
array.
Create a ChainBuilder by creating an instance of it and pass an array of processes that implement at least the
ChainProcessInterface. As the ChainRunner, you also can call the add method to add one or more processes.
You now can retrieve the chain runner by calling the getRunner method.
We the given previous example, the bar process will be executed before the foo one.
Advanced
Use a custom process decorator
To create the chain, the ChainBuilder decorate your processes with the ChainProcessDecorator class. If you want to
use your own decorator to add additional logic such as error recovering or logging, you can easily override the decorator
by providing an object that implements DecoratorFactoryInterface.
