Classes
The proxy generator cache warmer generates all entity proxies.
Allows lazy loading of listener services.
DoctrineDataCollector.
Doctrine data fixtures loader that injects the service container into
fixture objects that implement ContainerAwareInterface.
This abstract classes groups common code that Doctrine Object Manager extensions (ORM, MongoDB, CouchDB) need.
Registers additional validators.
Registers event listeners and subscribers to the available doctrine connections.
Base class for the doctrine bundles to provide a compiler pass class that
helps to register doctrine mappings.
EntityFactory creates services for Doctrine user provider.
Loads choices using a Doctrine object manager.
Custom loader for entities in the choice list.
A utility for reading object IDs.
Loads entities using a {@link QueryBuilder} instance.
Merge changes from the request to a Doctrine\Common\Collections\Collection instance.
References Doctrine connections and entity/document managers.
Wraps all handlers in a single doctrine transaction.
Extracts data using Doctrine ORM and ODM metadata.
References Doctrine connections and entity managers.
This class provides storage for the tokens that is set in "remember me"
cookies. This way no password secrets will be stored in the cookies on
the client machine, and thus the security is improved.
Wrapper around a Doctrine ObjectManager.
Represents a class that loads UserInterface objects from Doctrine source for the authentication system.
Provides utility functions needed in tests.
Constraint for the Unique Entity validator.
Unique Entity Validator checks if one or a set of fields contain unique values.
Automatically loads proxy object before validation.
Formats incoming records for console output by coloring them depending on log level.
ChromePhpHandler.
Writes logs to the console output depending on its verbosity setting.
Activation strategy that ignores certain HTTP codes.
Activation strategy that ignores 404s for certain URLs.
FirePHPHandler.
Extended SwiftMailerHandler that flushes mail queue if necessary.
Adds the current security token to the log entry.
WebProcessor override to read from the HttpFoundation's Request.
Catch deprecation notices and print a summary report at the end of the test suite.
{@inheritdoc}
{@inheritdoc}
CoverageListener adds
@covers <className> on each test when possible to
make the code coverage more accurate.
CoverageListener adds
@covers <className> on each test when possible to
make the code coverage more accurate.
CoverageListener adds
@covers <className> on each test when possible to
make the code coverage more accurate.
PHP 5.3 compatible trait-like shared implementation.
Collects and replays skipped tests.
Collects and replays skipped tests.
Collects and replays skipped tests.
PHP 5.3 compatible trait-like shared implementation.
{@inheritdoc}
{@inheritdoc}
{@inheritdoc}
Runtime lazy loading proxy generator.
Generates dumped PHP code of proxies via reflection.
Exposes some Symfony parameters and services as an "app" global variable.
Lists twig functions, filters, globals and tests present in the current project.
Command that will validate your template syntax and output encountered errors.
TwigDataCollector.
Twig extension for the Symfony Asset component.
Twig extension relate to PHP code and used by the profiler and the default exception templates.
Provides integration of the dump() function with Twig.
ExpressionExtension gives a way to create Expressions from a template.
FormExtension extends Twig with form capabilities.
Twig extension for the Symfony HttpFoundation component.
Provides integration with the HttpKernel component.
Provides integration with the HttpKernel component.
LogoutUrlHelper provides generator functions for the logout URL to Twig.
Provides integration of the Routing component with Twig.
SecurityExtension exposes security context features.
Twig extension for the stopwatch helper.
Provides integration of the Translation component with Twig.
Twig extension for the Symfony WebLink component.
WorkflowExtension.
Provides integration of the Yaml component with Twig.
TranslationNodeVisitor extracts translation messages.
Compiles a call to {@link \Symfony\Component\Form\FormRendererInterface::renderBlock()}.
Represents a stopwatch node.
Token Parser for the 'dump' tag.
Token Parser for the 'form_theme' tag.
Token Parser for the stopwatch tag.
TransChoiceTokenParser
deprecated
Token Parser for the 'transchoice' tag.
Token Parser for the 'trans_default_domain' tag.
Token Parser for the 'trans' tag.
TwigExtractor extracts translation messages from a twig template.
This engine knows how to render Twig templates.
A placeholder command easing VarDumper server discovery.
Registers the file link format for the {@link \Symfony\Component\HttpKernel\DataCollector\DumpDataCollector}.
DebugExtension configuration structure.
DebugExtension.
Warms up annotation caches for classes found in composer's autoload class map
and declared in DI bundle extensions using the addAnnotatedClassesToCache method.
Generates the router matcher and generator classes.
Warms up XML and YAML serializer metadata.
Finds all the templates.
Interface for finding all the templates.
Computes the association between template names and their paths on the disk.
Generates the catalogues for translations.
Warms up XML and YAML validator metadata.
Client simulates a browser and makes requests to a Kernel object.
A console command to display information about the current installation.
A console command for dumping available configuration reference.
Command that places bundle web assets into a given directory.
Clear and Warmup the cache.
Clear cache pools.
Delete an item from a cache pool.
Cache pool pruner command.
Warmup the cache.
A console command for dumping available configuration reference.
A console command for dumping available configuration reference.
ContainerAwareCommand
deprecated
Command.
A console command for retrieving information about services.
A console command for autowiring information.
A console command for retrieving information about event dispatcher.
A console command for retrieving information about routes.
A console command to test route matching.
Helps finding unused or missing translation messages in a given locale
and comparing them with the fallback ones.
A command that parses templates to extract translation messages and adds them
into the translation files.
Validates XLIFF files syntax and outputs encountered errors.
Validates YAML files syntax and outputs encountered errors.
Provides common features needed in controllers.
Controller
deprecated
Controller is a simple implementation of a Controller.
ControllerNameParser
deprecated
ControllerNameParser converts controller from the short notation a:b:c
(BlogBundle:Post:index) to a fully-qualified class::method string
(Bundle\BlogBundle\Controller\PostController::indexAction).
Common features needed in controllers.
Redirects a request to another URL.
TemplateController.
RequestDataCollector
deprecated
RequestDataCollector.
RouterDataCollector.
Registers the expression language providers.
CacheCollectorPass
deprecated
Inject a data collector to all the cache services to be able to get detailed statistics.
CachePoolClearerPass
deprecated
CachePoolPass
deprecated
CachePoolPrunerPass
deprecated
Dumps the ContainerBuilder to a cache file so that it can be used by
debugging tools such as the debug:container console command.
Adds tagged data_collector services to profiler service.
Find all service tags which are defined, but not used and yield a warning log message.
FrameworkExtension configuration structure.
FrameworkExtension.
ResolveControllerNameSubscriber
deprecated
Guarantees that the _controller key is parsed into its final format.
Bundle.
Manages HTTP cache objects in a Container.
A Kernel that provides configuration hooks.
AnnotatedRouteControllerLoader is an implementation of AnnotationClassLoader
that sets the '_controller' default based on the class and method names.
DelegatingLoader delegates route loading to other loaders using a loader resolver.
This Router creates the Loader only when the cache is empty.
DelegatingEngine selects an engine for a given template.
EngineInterface is the interface each engine must implement.
GlobalVariables is the entry point for Symfony global variables in PHP templates.
ActionsHelper manages action inclusions.
AssetsHelper helps manage asset URLs.
FormHelper provides helpers to help display forms.
RequestHelper provides access to the current request parameters.
RouterHelper manages links between pages in a template context.
SessionHelper provides read-only access to the session attributes.
StopwatchHelper provides methods time your PHP templates.
FilesystemLoader is a loader that read templates from the filesystem.
TemplateLocator locates templates in bundles.
This engine knows how to render Symfony templates.
TemplateFilenameParser converts template filenames to
TemplateReferenceInterface instances.
TemplateNameParser converts template names from the short notation
"bundle:section:template.format.engine" to TemplateReferenceInterface
instances.
Internal representation of a template.
Times the time spent to render a template.
KernelTestCase is the base class for tests needing a Kernel.
WebTestCase is the base class for functional tests.
Translator.
A marker to be able to check if symfony/symfony is installed instead of the individual components/bundles.
Encode a user's password.
Firewall collecting called listeners.
Wraps a security listener for calls record.
Registers the expression language providers.
Adds all configured security voters to the access decision manager.
Uses the session domain to restrict allowed redirection targets.
SecurityExtension configuration structure.
SecurityExtension.
AbstractFactory is the base class for all classes inheriting from
AbstractAuthenticationListener.
FormLoginFactory creates services for form login authentication.
FormLoginLdapFactory creates services for form login ldap authentication.
Configures the "guard" authentication provider key under a firewall.
HttpBasicFactory creates services for HTTP basic authentication.
HttpBasicFactory creates services for HTTP basic authentication.
JsonLoginFactory creates services for JSON login authentication.
JsonLoginLdapFactory creates services for json login ldap authentication.
RemoteUserFactory creates services for REMOTE_USER based authentication.
SecurityFactoryInterface is the interface for all security authentication listener.
SimpleFormFactory
deprecated
SimplePreAuthenticationFactory
deprecated
X509Factory creates services for X509 certificate authentication.
InMemoryFactory creates services for the memory provider.
LdapFactory creates services for Ldap user provider.
UserProviderFactoryInterface is the interface for all user provider factories.
Listen to vote events from traceable voters.
Bundle.
SecurityUserValueResolver
deprecated
Supports the argument type of {see UserInterface}.
This is a wrapper around the actual firewall configuration which allows us
to lazy load the context for one specific firewall only when we need it.
This is a lazy-loading firewall map implementation.
LogoutUrlHelper provides generator functions for the logout URL.
SecurityHelper provides read-only access to the security checker.
Generates the Twig cache for all templates.
Generates the Twig cache for all templates.
Command that will validate your template syntax and output encountered errors.
ExceptionController renders error or exception pages for a given
FlattenException.
PreviewErrorController can be used to test error pages.
Registers the Twig exception listener if Twig is registered as a templating engine.
Registers Twig runtime services.
Adds tagged twig.extension services to twig service.
Adds services tagged twig.loader as Twig loaders.
TwigExtension configuration structure.
Twig environment configurator.
TwigExtension.
FilesystemLoader extends the default Twig filesystem loader
to work with the Symfony paths and template references.
Iterator for all templates in bundles and in the application Resources directory.
Bundle.
This engine renders Twig templates.
ExceptionController.
RouterController.
Handles Content-Security-Policy HTTP header for the WebProfiler Bundle.
Generates Content-Security-Policy nonce.
This class contains the configuration information for the bundle.
WebProfilerExtension.
WebDebugToolbarListener injects the Web Debug Toolbar.
Profiler Templates Manager.
Twig extension for the profiler.
Runs Symfony application using a local web server.
Runs a local web server in a background process.
Shows the status of a process that is running PHP's built-in web server in
the background.
Stops a background process running a local web server.
Manages a local HTTP web server.
Holds information about the current request.
A context that does nothing.
Uses a RequestStack to populate the context.
Base ExceptionInterface for the Asset component.
Base InvalidArgumentException for the Asset component.
Base LogicException for the Asset component.
Basic package that adds a version to asset URLs.
Asset package interface.
Helps manage asset URLs.
Package that adds a base path to asset URLs in addition to a version.
Package that adds a base URL to asset URLs in addition to a version.
Disable version for all assets.
Reads the versioned path of an asset from a JSON manifest file.
Returns the same version for all assets.
Asset version strategy interface.
Client simulates a browser.
Cookie represents an HTTP cookie.
CookieJar.
History.
Interface for adapters managing instances of Symfony's CacheItem.
Chains several adapters together.
Caches items at warm up time using a PHP array that is stored in shared memory by OPCache since PHP 7.0.
Interface for invalidating cached items using tags.
An adapter that collects data about all cache calls.
Inject a data collector to all the cache services to be able to get detailed statistics.
LockRegistry is used internally by existing adapters to protect against cache stampede.
Serializes/unserializes values using igbinary_serialize() if available, serialize() otherwise.
Serializes/unserializes PHP values.
Interface extends psr-6 and psr-16 caches to allow for pruning (deletion) of all expired cache items.
Resets a pool's local state.
Chains several caches together.
Caches items at warm up time using a PHP array that is stored in shared memory by OPCache since PHP 7.0.
An adapter that collects data about all cache calls.
ConfigCache caches arbitrary content in files on disk.
Basic implementation of ConfigCacheFactoryInterface that
creates an instance of the default ConfigCache.
Interface for a ConfigCache factory. This factory creates
an instance of ConfigCacheInterface and initializes the
cache if necessary.
Interface for ConfigCache.
Represents an Array node in the config tree.
The base node class.
This node represents a Boolean value in the config tree.
This class provides a fluent interface for defining an array node.
This class provides a fluent interface for defining a node.
An interface that can be implemented by nodes which build other nodes.
Enum Node Definition.
This class builds an if expression.
This class provides a fluent interface for defining a float node.
This class provides a fluent interface for defining an integer node.
This class builds merge conditions.
This class provides a fluent interface for building a node.
This class provides a fluent interface for defining a node.
An interface that must be implemented by all node parents.
This class builds normalization conditions.
Abstract class that contains common code of integer and float node definitions.
An interface that must be implemented by nodes which can have children.
This class provides a fluent interface for defining a node.
This is the entry class for building a config tree.
This class builds validation conditions.
This class provides a fluent interface for defining a node.
Configuration interface.
Dumps a XML reference configuration for the given configuration/node instance.
Dumps a Yaml reference configuration for the given configuration/node instance.
Node which only allows a finite set of values.
This exception is thrown whenever the key of an array is not unique. This can
only be the case if the configuration is coming from an XML file.
Base exception for all configuration exceptions.
This exception is thrown when a configuration path is overwritten from a
subsequent configuration file, but the entry node specifically forbids this.
A very general exception which can be thrown whenever non of the more specific
exceptions is suitable.
Thrown when an error is detected in a node Definition.
This exception is thrown if an invalid type is encountered.
This exception is usually not encountered by the end-user, but only used
internally to signal the parent scope to unset a key.
This node represents a float value in the config tree.
This node represents an integer value in the config tree.
Common Interface among all nodes.
This node represents a numeric value in the config tree.
This class is the entry point for config normalization/merging/finalization.
This interface must be implemented by nodes which can be used as prototypes.
Represents a prototyped Array node in the config tree.
This node represents a scalar value in the config tree.
This node represents a value of variable type in the config tree.
Exception class for when a circular reference is detected when importing resources.
FileLoaderLoadException
deprecated
Exception class for when a resource cannot be loaded or imported.
File locator exception if a file does not exist.
Exception class for when a resource cannot be loaded or imported.
FileLocator uses an array of pre-defined paths to find files.
DelegatingLoader delegates loading to other loaders using a loader resolver.
FileLoader is the abstract class used by all built-in loaders that are file based.
GlobFileLoader loads files from a glob pattern.
Loader is the abstract class used by all built-in loaders.
LoaderInterface is the interface implemented by all loader classes.
LoaderResolver selects a loader for a given resource.
LoaderResolverInterface selects a loader for a given resource.
ResourceCheckerConfigCache uses instances of ResourceCheckerInterface
to check whether cached data is still fresh.
A ConfigCacheFactory implementation that validates the
cache with an arbitrary set of ResourceCheckers.
Interface for ResourceCheckers.
ClassExistenceResource represents a class existence.
ComposerResource tracks the PHP version and Composer dependencies.
DirectoryResource represents a resources stored in a subdirectory tree.
FileExistenceResource represents a resource stored on the filesystem.
FileResource represents a resource stored on the filesystem.
GlobResource represents a set of resources stored on the filesystem.
ResourceInterface is the interface that must be implemented by all Resource classes.
Resource checker for instances of SelfCheckingResourceInterface.
Interface for Resources that can check for freshness autonomously,
without special support from external services.
Exception class for when XML parsing with an XSD schema file path or a callable validator produces errors unrelated
to the actual XML parsing.
Exception class for when XML cannot be parsed properly.
XMLUtils is a bunch of utility methods to XML operations.
An Application is the container for a collection of commands.
Loads commands from a PSR-11 container.
A simple command loader using factories to instantiate commands lazily.
Base class for all commands.
HelpCommand displays the help for a given command.
ListCommand displays the list of all available commands for the application.
Basic lock feature for commands.
Contains all events dispatched by an Application.
Registers console commands.
Descriptor interface.
JSON descriptor.
Markdown descriptor.
Text descriptor.
XML descriptor.
Allows to do things before the command is executed, like skipping the command or changing the input.
Allows to handle throwables thrown while running a command.
Allows to inspect input and output of a command.
Allows to manipulate the exit code of a command after its execution.
Represents an incorrect command name typed in the console.
ExceptionInterface.
Represents an incorrect option name typed in the console.
Represents an incorrect namespace typed in the console.
Formatter class for console output.
Formatter interface for console output.
Formatter style class for defining styles.
Formatter style interface for defining styles.
Formatter interface for console output that supports word wrapping.
Helps outputting debug information when running an external program from a command.
This class adds helper method to describe objects in various formats.
The Formatter class provides helpers to format messages.
Helper is the base class for all helper classes.
HelperInterface is the interface all helpers must implement.
HelperSet represents a set of helpers to be used with a command.
An implementation of InputAwareInterface for Helpers.
The ProcessHelper class provides helpers to run external processes.
The ProgressBar provides helpers to display progress output.
The QuestionHelper class provides helpers to interact with the user.
Symfony Style Guide compliant question helper.
Provides helpers to display a table.
Marks a row as being a separator.
Defines the styles for a Table.
ArgvInput represents an input coming from the CLI arguments.
ArrayInput represents an input provided as an array.
Input is the base class for all concrete Input classes.
Represents a command line argument.
InputAwareInterface should be implemented by classes that depends on the
Console Input.
A InputDefinition represents a set of valid command line arguments and options.
InputInterface is the interface implemented by all input classes.
Represents a command line option.
StreamableInputInterface is the interface implemented by all input classes
that have an input stream.
StringInput represents an input provided as a string.
PSR-3 compliant console logger.
ConsoleOutput is the default class for all CLI output. It uses STDOUT and STDERR.
ConsoleOutputInterface is the interface implemented by ConsoleOutput class.
NullOutput suppresses all output.
Base class for output classes.
OutputInterface is the interface implemented by all Output classes.
StreamOutput writes the output to a given stream.
Represents a choice question.
Represents a yes/no question.
Represents a Question.
Decorates output to add console style guide helpers.
Output style helpers.
Output decorator helpers for the Symfony Style Guide.
Eases the testing of console applications.
Eases the testing of console commands.
CssSelectorConverter is the main entry point of the component and can convert CSS
selectors to XPath expressions.
Interface for exceptions.
ParseException is thrown when a CSS selector syntax is not valid.
ParseException is thrown when a CSS selector syntax is not valid.
ParseException is thrown when a CSS selector syntax is not valid.
ParseException is thrown when a CSS selector syntax is not valid.
Abstract base node class.
Represents a "[| ]" node.
Represents a "." node.
Represents a combined node.
Represents a "|" node.
Represents a ":()" node.
Represents a "#" node.
Represents a ":not()" node.
Interface for nodes.
Represents a ":" node.
Represents a "(::|:)" node.
Represents a node specificity.
CSS selector comment handler.
CSS selector handler interface.
CSS selector comment handler.
CSS selector comment handler.
CSS selector comment handler.
CSS selector comment handler.
CSS selector whitespace handler.
CSS selector parser.
CSS selector parser interface.
CSS selector reader.
CSS selector class parser shortcut.
CSS selector element parser shortcut.
CSS selector class parser shortcut.
CSS selector hash parser shortcut.
CSS selector token.
CSS selector token stream.
CSS selector tokenizer.
CSS selector tokenizer escaping applier.
CSS selector tokenizer patterns builder.
XPath expression translator abstract extension.
XPath expression translator attribute extension.
XPath expression translator combination extension.
XPath expression translator extension interface.
XPath expression translator function extension.
XPath expression translator HTML extension.
XPath expression translator node extension.
XPath expression translator pseudo-class extension.
XPath expression translator interface.
XPath expression translator interface.
XPath expression translator interface.
A buffering logger that stacks logs for later.
Registers all the debug tools.
Autoloader checking if the class is really defined in the file found.
A generic ErrorHandler for the PHP engine.
ExceptionHandler converts an exception to a Response object.
Class (or Trait or Interface) Not Found Exception.
Fatal Error Exception.
Fatal Throwable Error.
FlattenException wraps a PHP Error or Exception to be able to serialize it.
Out of memory exception.
Data Object that represents a Silenced Error.
Undefined Function Exception.
Undefined Method Exception.
ErrorHandler for classes that do not exist.
Attempts to convert fatal errors to exceptions.
ErrorHandler for undefined functions.
ErrorHandler for undefined methods.
Represents a complex argument containing nested values.
Represents a collection of values to lazily iterate over.
Represents a service wrapped in a memoizing closure.
Represents a closure acting as a service locator.
Represents a collection of services found by tag name to lazily iterate over.
This definition extends another definition.
Run this pass before passes that need to know more about the relation of
your services.
Sets a service to be an alias of another one, given a format pattern.
Inspects existing service definitions and wires the autowired ones using the type hints of their classes.
Looks for definitions with autowiring enabled and registers their corresponding "@required" methods as setters.
Checks if arguments of methods are properly configured.
Checks your services for circular references.
This pass validates each definition individually only taking the information
into account which is contained in the definition itself.
Checks that all references are pointing to a valid service.
Checks the validity of references.
This class is used to remove circular dependencies between individual passes.
Interface that must be implemented by compilation passes.
Overwrites a service but keeps the overridden one.
Throws an exception for any Definitions that have errors and still exist.
A pass to automatically process extensions if they implement
CompilerPassInterface.
Inline service definitions where this is possible.
A container builder preventing using methods that wouldn't have any effect from extensions.
Merges extension configs into the container builder.
Compiler Pass Configuration.
Trait that allows a generic method to find and sort service by priority option in the tag.
Creates the container.env_var_processors_locator service.
Compiler pass to register tagged services that require a service locator.
Removes abstract Definitions.
Remove private aliases from the container. They were only used to establish
dependencies between services, and these dependencies have been resolved in
one of the previous passes.
Removes unused service definitions from the container.
RepeatablePassInterface
deprecated
Interface that must be implemented by passes that are run as part of an
RepeatedPass.
RepeatedPass
deprecated
A pass that might be run repeatedly.
Replaces aliases with actual service definitions, effectively removing these
aliases.
This replaces all ChildDefinition instances with their equivalent fully
merged Definition instance.
Replaces env var placeholders by their current values.
Propagate "container.hot_path" tags to referenced services.
Applies instanceof conditionals to definitions.
Emulates the invalid behavior if the reference is not found within the
container.
Resolves named arguments to their corresponding numeric index.
Resolves all parameter placeholders "%somevalue%" to their real values.
Replaces all references to aliases with references to the actual service.
Compiler pass to inject their service locator to service subscribers.
Resolves all TaggedIteratorArgument arguments.
Applies the "container.service_locator" tag by wrapping references into ServiceClosureArgument instances.
This is a directed graph of your services.
Represents an edge in your service graph.
Represents a node in your service graph.
Validates environment variable placeholders used in extension configuration with dummy values.
Tracks container parameters.
Container is a dependency injection container.
ContainerAwareInterface should be implemented by classes that depends on a Container.
ContainerAware trait.
ContainerBuilder is a DI container that provides an API to easily describe services.
ContainerInterface is the interface implemented by service container classes.
Definition represents a service definition.
Dumper is the abstract class for all built-in dumpers.
DumperInterface is the interface implemented by service container dumper classes.
GraphvizDumper dumps a service container as a graphviz file.
PhpDumper dumps a service container as a PHP class.
XmlDumper dumps a service container as an XML string.
YamlDumper dumps a service container as a YAML string.
The EnvVarProcessorInterface is implemented by objects that manage environment-like variables.
Thrown when a definition cannot be autowired.
Base BadMethodCallException for Dependency Injection component.
This exception is thrown when an environment variable is not found.
This exception wraps exceptions whose messages contain a reference to an env parameter.
Base ExceptionInterface for Dependency Injection component.
Base InvalidArgumentException for Dependency Injection component.
Base LogicException for Dependency Injection component.
Base OutOfBoundsException for Dependency Injection component.
This exception is thrown when a circular reference in a parameter is detected.
This exception is thrown when a non-existent parameter is used.
Base RuntimeException for Dependency Injection component.
This exception is thrown when a circular reference is detected.
This exception is thrown when a non-existent service is requested.
Adds some function to the default ExpressionLanguage.
Define some ExpressionLanguage functions.
ConfigurationExtensionInterface is the interface implemented by container extension classes.
Provides useful features shared by many extensions.
ExtensionInterface is the interface implemented by container extension classes.
Lazy proxy instantiator, capable of instantiating a proxy given a container, the
service definitions and a callback that produces the real service instance.
{@inheritdoc}
Lazy proxy dumper capable of generating the instantiation logic PHP code for proxied services.
Null dumper, negates any proxy code generation for any given service definition.
ClosureLoader loads service definitions from a PHP closure.
DirectoryLoader is a recursive loader to go through directories.
FileLoader is the abstract class used by all built-in loaders that are file based.
GlobFileLoader loads files from a glob pattern.
IniFileLoader loads parameters from INI files.
PhpFileLoader loads service definitions from a PHP file.
XmlFileLoader loads XML files service definitions.
YamlFileLoader loads YAML files service definitions.
Parameter represents a parameter reference.
ContainerBagInterface is the interface implemented by objects that manage service container parameters.
Holds read-only parameters.
Holds parameters.
ParameterBagInterface is the interface implemented by objects that manage service container parameters.
Reference represents a service reference.
ResettableContainerInterface
deprecated
ResettableContainerInterface defines additional resetting functionality
for containers, allowing to release shared services when the container is
not needed anymore.
ServiceSubscriberInterface
deprecated
{@inheritdoc}
TaggedContainerInterface is the interface implemented when a container knows how to deals with tags.
Represents a PHP type-hinted service reference.
Represents a variable.
Any HTML element that can link to an URI.
Crawler eases navigation of a list of \DOMNode objects.
ChoiceFormField represents a choice form field.
FileFormField represents a file form field (an HTML file input tag).
FormField is the abstract class for all form fields.
InputFormField represents an input form field (an HTML input tag).
TextareaFormField represents a textarea form field (an HTML textarea tag).
Form represents an HTML form.
This is an internal class that must not be used directly.
Image represents an HTML image (an HTML img tag).
Link represents an HTML link (an HTML a, area or link tag).
Manages .env files.
Interface for exceptions.
Thrown when a file has a syntax error.
Thrown when a file does not exist or is not readable.
Collects some data about event listeners.
TraceableEventDispatcherInterface
deprecated
Compiler pass to register tagged services for an event dispatcher.
Event is the base class for classes containing event data.
The EventDispatcherInterface is the central point of Symfony's event listener system.
The EventDispatcherInterface is the central point of Symfony's event listener system.
An EventSubscriber knows itself what events it is interested in.
Event encapsulation class.
A read-only proxy for an event dispatcher.
Compiles a node to PHP code.
Represents an expression.
Represents a function that can be used in an expression.
Allows to compile and evaluate expressions written in your own DSL.
Lexes an expression.
Represents a node in the AST.
Represents an already parsed expression.
Parsers a token stream.
Represents an already parsed expression.
Represents a Token.
Represents a token stream.
Exception interface for all exceptions thrown by the component.
Exception class thrown when a file couldn't be found.
Exception class thrown when a filesystem operation failure happens.
IOException interface for file and input/output stream related exceptions thrown by the component.
Provides basic utility to manipulate the file system.
Comparator.
DateCompare compiles date comparisons.
NumberComparator compiles a simple comparison to an anonymous
subroutine, which you can call with a value to be tested again.
Finder allows to build rules to find files and directories.
Glob matches globbing patterns against text.
CustomFilterIterator filters files by applying anonymous functions.
DateRangeFilterIterator filters out files that are not in the given date range (last modified dates).
DepthRangeFilterIterator limits the directory depth.
ExcludeDirectoryFilterIterator filters out directories.
FileTypeFilterIterator only keeps files, directories, or both.
FilecontentFilterIterator filters files by their contents using patterns (regexps or strings).
FilenameFilterIterator filters files by patterns (a regexp, a glob, or a string).
MultiplePcreFilterIterator filters files using patterns (regexps, globs or strings).
PathFilterIterator filters files by path patterns (e.g. some/special/dir).
Extends the \RecursiveDirectoryIterator to support relative paths.
SizeRangeFilterIterator filters out files that are not in the given size range.
SortableIterator applies a sort on a given Iterator.
Extends \SplFileInfo to support relative paths.
Default implementation of {@link FormRendererEngineInterface}.
A form button.
A builder for {@link Button} instances.
A type that should be converted into a {@link Button} instance.
A list of choices with arbitrary data types.
A list of choices that can be selected in a choice field.
Caches the choice lists created by the decorated factory.
Creates {@link ChoiceListInterface} instances.
Default implementation of {@link ChoiceListFactoryInterface}.
Adds property path support to a choice list factory.
A choice list that loads its choices lazily.
Loads an {@link ArrayChoiceList} instance from a callable returning an array of choices.
Loads a choice list.
Callback choice loader optimized for Intl choice types.
Represents a group of choices in templates.
Represents a choice list in templates.
Represents a choice in templates.
A form element whose errors can be cleared.
A clickable form element.
A console command for retrieving information about form types.
Transforms a value between different representations.
Adds all services with the tags "form.type", "form.type_extension" and
"form.type_guesser" as arguments of the "form.extension" service.
Thrown when an operation is called that is not acceptable after submitting
a form.
Base BadMethodCallException for the Form component.
Base ExceptionInterface for the Form component.
Base InvalidArgumentException for the Form component.
Base LogicException for Form component.
Base OutOfBoundsException for Form component.
Base RuntimeException for the Form component.
Indicates a value transformation error.
Represents the main form extension, which loads the core functionality.
Maps choices to/from checkbox forms.
Maps arrays/objects to/from forms using property paths.
Maps choices to/from radio forms.
Transforms between a Boolean and a string.
Passes a value through multiple value transformers.
Transforms between a normalized date interval and an interval string/array.
Transforms between a date string and a DateInterval object.
Transforms between a DateTimeImmutable object and a DateTime object.
Transforms between a normalized time and a localized time string/array.
Transforms between a normalized time and a localized time string.
Transforms between a date string and a DateTime object.
Transforms between a timestamp and a DateTime object.
Transforms between a timezone identifier string and a DateTimeZone object.
Transforms between an integer and a localized number with grouping
(each thousand) and comma separators.
Transforms between a normalized format and a localized money string.
Transforms between a number type and a localized number with grouping
(each thousand) and comma separators.
Transforms between a normalized format (integer or float) and a percentage value.
Adds a protocol to a URL if it doesn't already have one.
Resize a collection form element based on the data sent from the client.
Trims string data.
Encapsulates common logic of {@link FormType} and {@link ButtonType}.
A form button.
A reset button.
A submit button.
This extension protects forms by using a CSRF token.
Extension for collecting data of the forms on a page.
Listener that invokes a data collector for the {@link FormEvents::POST_SET_DATA}
and {@link FormEvents::POST_SUBMIT} events.
Data collector for {@link FormInterface} instances.
Collects and structures information about forms.
Default implementation of {@link FormDataExtractorInterface}.
Extracts arrays of information out of forms.
Proxy that invokes a data collector when creating a form and its view.
Proxy that wraps resolved types into {@link ResolvedTypeDataCollectorProxy}
instances.
Type extension for collecting data of a form with this type.
Integrates the HttpFoundation component with the Form library.
A request processor using the {@link Request} class of the HttpFoundation
component.
Integrates the Templating component with the Form library.
Encapsulates common logic of {@link FormTypeValidatorExtension} and
{@link SubmitTypeValidatorExtension}.
Extension supporting the Symfony Validator component in forms.
Form represents a form.
A builder for creating {@link Form} instances.
A basic form configuration.
The configuration of a {@link Form} object.
Wraps errors in forms.
Iterates over the errors of a form.
To learn more about how form events work check the documentation
entry at {@link https://symfony.com/doc/any/components/form/form_events.html}.
Interface for extensions which provide types, type extensions and a guesser.
The default implementation of FormFactoryBuilderInterface.
A builder for FormFactoryInterface objects.
Allows creating a form based on a name, a class or a property.
A form group bundling multiple forms in a hierarchical structure.
The central registry of the Form component.
The central registry of the Form component.
Renders a form into HTML using a rendering engine.
Adapter for rendering form templates with a specific templating engine.
Renders a form into HTML.
Entry point of the Form component.
Base class for guesses made by TypeGuesserInterface implementation.
Contains a guessed class name and a list of options for creating an instance
of that class.
Contains a guessed value.
A request handler using PHP super globals $_GET, $_POST and $_SERVER.
A form extension with preloaded types, type extensions and type guessers.
Submits forms if they were submitted.
A wrapper for a form type and its extensions.
Creates ResolvedFormTypeInterface instances.
A wrapper for a form type and its extensions.
Reverses a transformer.
A button that submits the form.
A builder for {@link SubmitButton} instances.
A type that should be converted into a {@link SubmitButton} instance.
Base class for performance tests.
Iterator that traverses an array of forms.
A hash map which keeps track of deletions and additions.
Iterator for {@link OrderedHashMap} objects.
Represents an Accept-* header.
Represents an Accept-* header item.
Request represents an HTTP request from an Apache server.
BinaryFileResponse represents an HTTP response delivering a file.
Represents a cookie.
The HTTP request contains headers with conflicting information.
Interface for Request exceptions.
Raised when a user has performed an operation that should be considered
suspicious from a security perspective.
ExpressionRequestMatcher uses an expression to match a Request.
FileBag is a container for uploaded files.
Thrown when the access on a file was denied.
Thrown when an UPLOAD_ERR_CANT_WRITE error occurred with UploadedFile.
Thrown when an UPLOAD_ERR_EXTENSION error occurred with UploadedFile.
Thrown when an error occurred in the component File.
Thrown when a file was not found.
Thrown when an UPLOAD_ERR_FORM_SIZE error occurred with UploadedFile.
Thrown when an UPLOAD_ERR_INI_SIZE error occurred with UploadedFile.
Thrown when an UPLOAD_ERR_NO_FILE error occurred with UploadedFile.
Thrown when an UPLOAD_ERR_NO_TMP_DIR error occurred with UploadedFile.
Thrown when an UPLOAD_ERR_PARTIAL error occurred with UploadedFile.
Thrown when an error occurred during file upload.
A file in the file system.
A singleton mime type to file extension guesser.
Guesses the file extension corresponding to a given mime type.
Guesses the mime type with the binary "file" (only available on *nix).
Guesses the mime type using the PECL extension FileInfo.
Provides a best-guess mapping of mime type to file extension.
A singleton mime type guesser.
Guesses the mime type of a file.
A PHP stream of unknown size.
A file uploaded through a form.
HeaderBag is a container for HTTP headers.
HTTP header utility functions.
Http utility functions.
Response represents an HTTP response in JSON format.
ParameterBag is a container for key/value pairs.
RedirectResponse represents an HTTP response doing a redirect.
Request represents an HTTP request.
RequestMatcher compares a pre-defined set of checks against a Request instance.
RequestMatcherInterface is an interface for strategies to match a Request.
Request stack that controls the lifecycle of requests.
Response represents an HTTP response.
ResponseHeaderBag is a container for Response HTTP headers.
ServerBag is a container for HTTP headers from the $_SERVER variable.
This class relates to session attribute storage.
Attributes store.
This class provides structured storage of session attributes using
a name spacing character in the key.
AutoExpireFlashBag flash message container.
FlashBag flash message container.
FlashBagInterface.
Session Bag store.
Interface for the session.
Session utility functions.
This abstract session handler provides a generic implementation
of the PHP 7.0 SessionUpdateTimestampHandlerInterface,
enabling strict and lazy session handling.
Memcached based session storage handler based on the Memcached class
provided by the PHP memcached extension.
Migrating session handler for migrating from one handler to another. It reads
from the current handler and writes both the current and new ones.
Session handler using the mongodb/mongodb package and MongoDB driver extension.
Native session handler using PHP's built in file storage.
Can be used in unit testing or in a situations where persisted sessions are not desired.
Session handler using a PDO connection to read and write data.
Redis based session storage handler based on the Redis class
provided by the PHP redis extension.
Adds basic
SessionUpdateTimestampHandlerInterface behaviors to another SessionHandlerInterface.
Metadata container.
MockArraySessionStorage mocks the session for unit tests.
MockFileSessionStorage is used to mock sessions for
functional testing when done in a single PHP process.
This provides a base class for session attribute storage.
Allows session to be started by PHP and managed by Symfony.
StorageInterface.
StreamedResponse represents a streamed HTTP response.
An implementation of BundleInterface that adds a few conventions
for DependencyInjection extensions and Console commands.
BundleInterface.
CacheClearerInterface.
ChainCacheClearer.
Abstract cache warmer that knows how to write a file to the cache.
Aggregates several cache warmers into a single one.
Interface for classes able to warm up the cache.
Interface for classes that support warming their cache.
Client simulates a browser and makes requests to a Kernel object.
FileLocator uses the KernelInterface to locate resources in bundles.
Responsible for storing metadata of an argument.
Builds {see ArgumentMetadata} objects based on the given Controller.
Builds method argument data.
Responsible for resolving the arguments passed to an action.
An ArgumentResolverInterface instance knows how to determine the
arguments for a specific action.
Yields the default value defined in the action signature when no value has been given.
Yields a non-variadic argument's value from the request attributes.
Yields the same instance as the request object passed along.
Yields a service keyed by _controller and argument name.
Yields the Session.
Provides timing information via the stopwatch.
Yields a variadic argument's values from the request attributes.
Responsible for resolving the value of an argument based on its metadata.
A controller resolver searching for a controller in a psr-11 container when using the "service:method" notation.
Acts as a marker and a data holder for a Controller.
This implementation uses the '_controller' request attribute to determine
the controller to execute.
A ControllerResolverInterface implementation knows how to determine the
controller to execute based on a Request object.
AjaxDataCollector.
DataCollector.
DataCollectorInterface.
EventDataCollector.
ExceptionDataCollector.
LateDataCollectorInterface.
LogDataCollector.
MemoryDataCollector.
RouterDataCollector.
TimeDataCollector.
Formats debug file links.
Collects some data about event listeners.
Sets the classes to compile in the cache for the container.
This extension sub-class provides first-class integration with the
Config/Definition Component.
Gathers and configures the argument value resolvers.
Allow adding classes to the class cache.
Adds services tagged kernel.fragment_renderer as HTTP content rendering strategies.
Lazily loads fragment renderers from the dependency injection container.
Registers the default logger if necessary.
Ensures certain extensions are always loaded.
Creates the service-locators required by ServiceValueResolver.
Removes empty service-locators registered for ServiceValueResolver.
Resets provided services.
Sets the session onto the request on the "kernel.request" event and saves
it on the "kernel.response" event.
TestSessionListener.
Adds configured formats to each request.
Configures errors and exceptions handlers.
Configures dump() handler.
ExceptionListener.
Handles content fragments represented by special URIs.
Initializes the locale based on the current request.
ProfilerListener collects data for the current request by listening to the kernel events.
ResponseListener fixes the Response headers based on the Request.
Initializes the context from the request and sets request attributes based on a matching route.
SaveSessionListener
deprecated
Sets the session in the request.
StreamedResponseListener is responsible for sending the Response
to the client.
SurrogateListener adds a Surrogate-Control HTTP header when the Response needs to be parsed for Surrogates.
Sets the session in the request.
Synchronizes the locale between the request and the translator.
Validates Requests.
Allows filtering of controller arguments.
Allows filtering of a controller callable.
Allows to filter a Response object.
Triggered whenever a request is fully processed.
Allows to create a response for a request.
Allows to create a response for the return value of a controller.
Allows to create a response for a thrown exception.
Base class for events thrown in the HttpKernel component.
Allows to execute logic after a response was sent.
HttpException.
Interface for HTTP error exceptions.
Implements Surrogate rendering strategy.
Implements the ESI rendering strategy.
Renders a URI that represents a resource fragment.
Interface implemented by all rendering strategies.
Implements the Hinclude rendering strategy.
Implements the inline rendering strategy where the Request is rendered by the current HTTP kernel.
Adds the possibility to generate a fragment URI for a given Controller.
Implements the SSI rendering strategy.
Abstract class implementing Surrogate capabilities to Request and Response instances.
Esi implements the ESI capabilities to Request and Response instances.
Cache provides HTTP caching.
ResponseCacheStrategy knows how to compute the Response cache HTTP header
based on the different response cache headers.
ResponseCacheStrategyInterface implementations know how to compute the
Response cache HTTP header based on the different response cache headers.
Ssi implements the SSI capabilities to Request and Response instances.
Store implements all the logic for storing cache metadata (Request and Response headers).
Interface implemented by HTTP cache stores.
HttpKernel notifies events to convert a Request object to a Response one.
HttpKernelInterface handles a Request to convert it to a Response.
The Kernel is the heart of the Symfony system.
Contains all events thrown in the HttpKernel component.
The Kernel is the heart of the Symfony system.
DebugLoggerInterface.
Minimalist PSR-3 logger designed to write in stderr or any other stream.
Storage for profiler using files.
Profile.
Profiler.
ProfilerStorageInterface.
Allows the Kernel to be rebooted using a temporary cache directory.
Terminable extends the Kernel request/response cycle with dispatching a post
response event after sending the response and before shutting down the kernel.
Signs URIs.
Converts words between singular and plural forms.
Replacement for PHP's native {@link \Collator} class.
Compiles a resource bundle.
Compiles .txt resource bundles to binary .res files.
Default implementation of {@link BundleEntryReaderInterface}.
Reads individual entries of a resource file.
Reads resource bundle files.
Reads binary .res resource bundles.
Reads .json resource bundles.
Reads .php resource bundles.
Writes resource bundle files.
Writes .json resource bundles.
Writes .php resource bundles.
Writes .txt resource bundles.
The rule for compiling the currency bundle.
The rule for compiling the currency bundle.
Stores contextual information for resource bundle generation.
The rule for compiling the language bundle.
The rule for compiling the locale bundle.
The rule for compiling the region bundle.
The rule for compiling the script bundle.
Data provider for currency-related data.
Data provider for language-related ICU data.
Data provider for locale-related ICU data.
Data provider for region-related ICU data.
Data provider for script-related ICU data.
Work-around for a bug in PHP's \ResourceBundle implementation.
Scans a directory with data files for locales.
Implements a ring buffer.
Parser and formatter for AM/PM markers format.
Parser and formatter for day of week format.
Parser and formatter for day of year format.
Parser and formatter for day format.
Parser and formatter for date formats.
Parser and formatter for 12 hour format (0-11).
Parser and formatter for 12 hour format (1-12).
Parser and formatter for 24 hour format (0-23).
Parser and formatter for 24 hour format (1-24).
Base class for hour transformers.
Parser and formatter for minute format.
Parser and formatter for month format.
Parser and formatter for quarter format.
Parser and formatter for the second format.
Parser and formatter for time zone format.
Parser and formatter for date formats.
Parser and formatter for year format.
Replacement for PHP's native {@link \IntlDateFormatter} class.
Base BadMethodCallException for the Intl component.
Base ExceptionInterface for the Intl component.
InvalidArgumentException for the Intl component.
Thrown when an invalid entry of a resource bundle was requested.
Base exception class for not implemented behaviors of the intl extension in the Locale component.
Base OutOfBoundsException for the Intl component.
RuntimeException for the Intl component.
Thrown when a method argument had an unexpected type.
Provides fake static versions of the global functions in the intl extension.
Gives access to internationalization data.
Provides access to locale-related data.
Replacement for PHP's native {@link \Locale} class.
Replacement for PHP's native {@link \NumberFormatter} class.
Default implementation of {@link CurrencyBundleInterface}.
Gives access to currency-related ICU data.
Default implementation of {@link LanguageBundleInterface}.
Gives access to language-related ICU data.
Default implementation of {@link LocaleBundleInterface}.
Gives access to locale-related ICU data.
Default implementation of {@link RegionBundleInterface}.
Gives access to region-related ICU data.
Gives access to ICU data.
Facilitates the comparison of ICU version strings.
Helper class for preparing test cases that rely on the Intl component.
Facilitates the comparison of version strings.
Entry manager interface.
A class representing the Ldap extension's options, which can be used with
ldap_set_option or ldap_get_option.
ConnectionException is throw if binding to ldap can not be established.
LdapException is throw if php ldap module is not loaded.
Base ExceptionInterface for the Ldap component.
LdapException is throw if php ldap module is not loaded.
NotBoundException is thrown if the connection with the LDAP server is not yet bound.
Ldap interface.
Base ExceptionInterface for the Lock Component.
LockAcquiringException is thrown when an issue happens during the acquisition of a lock.
LockConflictedException is thrown when a lock is acquired by someone else.
LockExpiredException is thrown when a lock may conflict due to a TTL expiration.
LockReleasingException is thrown when an issue happens during the release of a lock.
LockStorageException is thrown when an issue happens during the manipulation of a lock in a store.
NotSupportedException is thrown when an unsupported method is called.
Factory provides method to create locks.
Key is a container for the state of the locks in stores.
Lock is the default implementation of the LockInterface.
LockInterface defines an interface to manipulate the status of a lock.
StoreInterface defines an interface to manipulate a lock store.
CombinedStore is a StoreInterface implementation able to manage and synchronize several StoreInterfaces.
FlockStore is a StoreInterface implementation using the FileSystem flock.
MemcachedStore is a StoreInterface implementation using Memcached as store engine.
PdoStore is a StoreInterface implementation using a PDO connection.
RedisStore is a StoreInterface implementation using Redis as store engine.
RetryTillSaveStore is a StoreInterface implementation which decorate a non blocking StoreInterface to provide a
blocking storage.
SemaphoreStore is a StoreInterface implementation using Semaphore as store engine.
StoreFactory create stores and connections.
ZookeeperStore is a StoreInterface implementation using Zookeeper as store engine.
ConsensusStrategy is a StrategyInterface implementation where strictly more than 50% items should be successful.
StrategyInterface defines an interface to indicate when a quorum is met and can be met.
UnanimousStrategy is a StrategyInterface implementation where 100% of elements should be successful.
A console command to debug Messenger information.
A message wrapped in an envelope with stamps (configurations, markers, .
Base Message component's exception.
Leverages a message bus to expect a single, synchronous message handling and return its result.
Maps a message to a list of handlers.
Maps a message to a list of handlers.
Marker interface for message handlers.
Handlers can implement this interface to handle multiple messages.
Execute the inner middleware according to an activation strategy.
Collects some data about a middleware.
Stamp identifying a message handled by the
HandleMessageMiddleware middleware
and storing the handler returned value.
Marker stamp for a received message.
Marker stamp identifying a message sent by the
SendMessageMiddleware.
An envelope stamp related to a message.
Symfony Messenger receiver to get messages from AMQP brokers using PHP's AMQP extension.
Symfony Messenger sender to send messages to AMQP brokers using PHP's AMQP extension.
An AMQP connection.
If something goes wrong while consuming and handling a message from the AMQP broker, there are two choices: rejecting
or re-queuing the message.
Maps a message to a list of senders.
Maps a message to a list of senders.
Creates a Messenger transport.
Thrown when trying to read an option outside of or write it inside of
{@link \Symfony\Component\OptionsResolver\Options::resolve()}.
Marker interface for all exceptions thrown by the OptionsResolver component.
Thrown when an argument is invalid.
Thrown when the value of an option does not match its validation rules.
Exception thrown when a required option is missing.
Thrown when trying to introspect an option definition property
for which no value was configured inside the OptionsResolver instance.
Thrown when trying to read an option that has no value set.
Thrown when two lazy options have a cyclic dependency.
Exception thrown when an undefined option is passed.
Contains resolved option values.
Validates options and merges them with default values.
Marker Interface for the Process Component.
InvalidArgumentException for the Process Component.
LogicException for the Process Component.
Exception for failed processes.
Exception that is thrown when a process has been signaled.
Exception that is thrown when a process times out.
RuntimeException for the Process Component.
Generic executable finder.
Provides a way to continuously write to the input of a Process until the InputStream is closed.
An executable finder specifically designed for the PHP executable.
PhpProcess runs a PHP script in an independent process.
PipesInterface manages descriptors and pipes for the use of proc_open.
UnixPipes implementation uses unix pipes as handles.
WindowsPipes implementation uses temporary files as handles.
Process is a thin wrapper around proc_* functions to easily
start independent PHP processes.
ProcessUtils is a bunch of utility methods.
Thrown when a property path is not available.
Marker interface for the PropertyAccess component.
Base InvalidArgumentException for the PropertyAccess component.
Thrown when a property path is malformed.
Thrown when an index cannot be found.
Thrown when a property cannot be found.
Base OutOfBoundsException for the PropertyAccess component.
Base RuntimeException for the PropertyAccess component.
Thrown when a value does not match an expected type.
Entry point of the PropertyAccess component.
Default implementation of {@link PropertyAccessorInterface}.
A configurable builder to create a PropertyAccessor.
Writes and reads values to/from an object/array graph.
Default implementation of {@link PropertyPathInterface}.
A sequence of property names or array indices.
Traverses a property path and provides additional methods to find out
information about the current element.
Adds extractors to the property_info service.
Extracts data using a PHPDoc parser.
Extracts data using the reflection API.
Lists available properties using Symfony Serializer Component metadata.
Guesses if the property can be accessed or mutated.
Guesses the property's human readable description.
Adds a PSR-6 cache layer on top of an extractor.
Default {see PropertyInfoExtractorInterface} implementation.
Gets info about PHP class properties.
Guesses if the property can be initialized through the constructor.
Extracts the list of properties available for the given class.
Type Extractor Interface.
Type value object (immutable).
Transforms a php doc type to a {@link Type} instance.
Annotation class for @Route().
CompiledRoutes are returned by the RouteCompiler class.
Adds tagged routing.loader services to routing.resolver service.
ExceptionInterface.
Exception thrown when a parameter is not valid.
The resource was found but the request method is not allowed.
Exception thrown when a route cannot be generated because of missing
mandatory parameters.
Exception thrown when no routes are configured.
The resource was not found.
Exception thrown when a route does not exist.
ConfigurableRequirementsInterface must be implemented by URL generators that
can be configured whether an exception should be generated when the parameters
do not match the requirements. It is also possible to disable the requirements
check for URL generation completely.
GeneratorDumper is the base class for all built-in generator dumpers.
GeneratorDumperInterface is the interface that all generator dumper classes must implement.
PhpGeneratorDumper creates a PHP class able to generate URLs for a given set of routes.
UrlGenerator can generate a URL or a path for any route in the RouteCollection
based on the passed parameters.
UrlGeneratorInterface is the interface that all URL generator classes must implement.
AnnotationClassLoader loads routing information from a PHP class and its methods.
AnnotationDirectoryLoader loads routing information from annotations set
on PHP classes and methods.
AnnotationFileLoader loads routing information from annotations set
on a PHP class and its methods.
ClosureLoader loads routes from a PHP closure.
A route loader that executes a service to load the routes.
GlobFileLoader loads files from a glob pattern.
A route loader that calls a method on an object to load the routes.
PhpFileLoader loads routes from a PHP file.
XmlFileLoader loads XML routing files.
YamlFileLoader loads Yaml routing files.
MatcherDumper is the abstract class for all built-in matcher dumpers.
MatcherDumperInterface is the interface that all matcher dumper classes must implement.
PhpMatcherDumper creates a PHP class able to match URLs for a given set of routes.
Prefix tree of routes preserving routes order.
RedirectableUrlMatcherInterface knows how to redirect the user.
RequestMatcherInterface is the interface that all request matcher classes must implement.
TraceableUrlMatcher helps debug path info matching by tracing the match.
UrlMatcher matches URL based on a set of routes.
UrlMatcherInterface is the interface that all URL matcher classes must implement.
Holds information about the current request.
A Route describes a route and its parameters.
A RouteCollection represents a set of Route instances.
Helps add and import routes into a RouteCollection.
RouteCompiler compiles Route instances to CompiledRoute instances.
RouteCompilerInterface is the interface that all RouteCompiler classes must implement.
The Router class is an example of the integration of all pieces of the
routing system for easier use.
RouterInterface is the interface that all Router classes must implement.
AuthenticationManagerInterface is the interface for authentication managers,
which process Token authentication.
AuthenticationProviderManager uses a list of AuthenticationProviderInterface
instances to authenticate a Token.
The default implementation of the authentication trust resolver.
Interface for resolving the authentication status of a given token.
AnonymousAuthenticationProvider validates AnonymousToken instances.
AuthenticationProviderInterface is the interface for all authentication
providers.
DaoAuthenticationProvider uses a UserProviderInterface to retrieve the user
for a UsernamePasswordToken.
LdapBindAuthenticationProvider authenticates a user against an LDAP server.
Processes a pre-authenticated authentication request.
SimpleAuthenticationProvider
deprecated
UserProviderInterface retrieves users for UsernamePasswordToken tokens.
This class is used for testing purposes, and is not really suited for production.
Interface to be implemented by persistent token classes (such as
Doctrine entities representing a remember-me token).
Interface for TokenProviders.
SimpleAuthenticatorInterface
deprecated
Base class for Token instances.
AnonymousToken represents an anonymous token.
PreAuthenticatedToken implements a pre-authenticated token.
Authentication Token for "Remember-Me".
TokenStorage contains a TokenInterface.
The TokenStorageInterface.
TokenInterface is the interface for the user authentication information.
UsernamePasswordToken implements a username and password token.
AccessDecisionManager is the base class for all access decision managers
that use decision voters.
AccessDecisionManagerInterface makes authorization decisions.
AuthorizationChecker is the main authorization point of the Security component.
The AuthorizationCheckerInterface.
Adds some function to the default ExpressionLanguage.
Define some ExpressionLanguage functions.
Decorates the original AccessDecisionManager class to log information
about the security voters and the decisions made by them.
AuthenticatedVoter votes if an attribute like IS_AUTHENTICATED_FULLY,
IS_AUTHENTICATED_REMEMBERED, or IS_AUTHENTICATED_ANONYMOUSLY is present.
ExpressionVoter votes based on the evaluation of an expression.
RoleHierarchyVoter uses a RoleHierarchy to determine the roles granted to
the user before voting.
RoleVoter votes if any attribute starts with a given prefix.
Decorates voter classes to send result events.
Voter is an abstract default implementation of a voter.
VoterInterface is the interface implemented by all voters.
Argon2iPasswordEncoder uses the Argon2i hashing algorithm.
BasePasswordEncoder is the base class for all password encoders.
A generic encoder factory implementation.
EncoderFactoryInterface to support different encoders for different accounts.
MessageDigestPasswordEncoder uses a message digest algorithm.
PasswordEncoderInterface is the interface for all encoders.
Pbkdf2PasswordEncoder uses the PBKDF2 (Password-Based Key Derivation Function 2).
PlaintextPasswordEncoder does not do any encoding.
SelfSaltingEncoderInterface is a marker interface for encoders that do not
require a user-generated salt.
A generic password encoder.
UserPasswordEncoderInterface is the interface for the password encoder service.
This is a general purpose authentication event.
This event is dispatched on authentication failure.
This event is dispatched on voter vote.
AccessDeniedException is thrown when the account has not the required role.
AccountExpiredException is thrown when the user account has expired.
AccountStatusException is the base class for authentication exceptions
caused by the user account status.
AuthenticationCredentialsNotFoundException is thrown when an authentication is rejected
because no Token is available.
AuthenticationException is the base class for all authentication exceptions.
AuthenticationServiceException is thrown when an authenticated token becomes un-authenticated between requests.
AuthenticationServiceException is thrown when an authentication request could not be processed due to a system problem.
BadCredentialsException is thrown when the user credentials are invalid.
This exception is thrown when the RememberMeServices implementation
detects that a presented cookie has already been used by someone else.
CredentialsExpiredException is thrown when the user account credentials have expired.
An authentication exception where you can control the message shown to the user.
DisabledException is thrown when the user account is disabled.
Base ExceptionInterface for the Security component.
InsufficientAuthenticationException is thrown if the user credentials are not sufficiently trusted.
Base InvalidArgumentException for the Security component.
This exception is thrown when the csrf token is invalid.
LockedException is thrown if the user account is locked.
Base LogicException for the Security component.
LogoutException is thrown when the account cannot be logged out.
ProviderNotFoundException is thrown when no AuthenticationProviderInterface instance
supports an authentication Token.
Base RuntimeException for the Security component.
This exception is thrown when no session is available.
TokenNotFoundException is thrown if a Token cannot be found.
This exception is thrown when an account is reloaded from a provider which
doesn't support the passed implementation of UserInterface.
UsernameNotFoundException is thrown if a User cannot be found by its username.
Role is a simple implementation representing a role identified by a string.
RoleHierarchy defines a role hierarchy.
RoleHierarchyInterface is the interface for a role hierarchy.
SwitchUserRole is used when the current user temporarily impersonates
another one.
Helper class for commonly-needed security tasks.
AdvancedUserInterface
deprecated
Adds extra features to a user class related to account status flags.
Chain User Provider.
EquatableInterface used to test if two objects are equal in security
and re-authentication context.
InMemoryUserProvider is a simple non persistent user provider.
LdapUserProvider is a simple user provider on top of ldap.
MissingUserProvider is a dummy user provider used to throw proper exception
when a firewall requires a user provider but none was defined.
User is the user implementation used by the in-memory user provider.
UserChecker checks the user account flags.
Implement to throw AccountStatusException during the authentication process.
Represents the interface that all user classes must implement.
Represents a class that loads UserInterface objects from some source for the authentication system.
A CSRF token.
Default implementation of {@link CsrfTokenManagerInterface}.
Manages CSRF tokens.
Generates CSRF tokens.
Generates CSRF tokens.
Token storage that uses PHP's native session handling.
Token storage that uses a Symfony Session object.
Stores CSRF tokens.
An optional base class that creates a PostAuthenticationGuardToken for you.
The interface for all "guard" authenticators.
A base class to make form login authentication easier!
Authentication listener for the "guard" system.
A utility class that does much of the work during the guard authentication process.
Responsible for accepting the PreAuthenticationGuardToken and calling
the correct authenticator to retrieve the authenticated token.
A marker interface that both guard tokens implement.
Used as an "authenticated" token, though it could be set to not-authenticated later.
The token used by the guard auth system before authentication.
AccessMap allows configuration of different access control rules for
specific parts of the website.
AccessMap allows configuration of different access control rules for
specific parts of the website.
Interface for custom authentication failure handlers.
Interface for a custom authentication success handler.
Extracts Security Errors from Request.
Class with the default authentication failure handling logic.
Class with the default authentication success handling logic.
SimpleAuthenticationHandler
deprecated
Class to proxy authentication success/failure handlers.
SimpleFormAuthenticatorInterface
deprecated
SimplePreAuthenticatorInterface
deprecated
This is used by the ExceptionListener to translate an AccessDeniedException
to a Response object.
Supports the argument type of {see UserInterface}.
Implement this interface for any classes that will be called to "start"
the authentication process (see method for more details).
BasicAuthenticationEntryPoint starts an HTTP Basic authentication.
FormAuthenticationEntryPoint starts an authentication via a login form.
RetryAuthenticationEntryPoint redirects URL based on the configured scheme.
SwitchUserEvent.
Firewall uses a FirewallMap to register security listeners for the given
request.
FirewallMap allows configuration of different firewalls for specific parts
of the website.
This interface must be implemented by firewall maps.
The AbstractAuthenticationListener is the preferred base class for all
browser-/HTTP-based authentication requests.
AbstractPreAuthenticatedListener is the base class for all listener that
authenticates users based on a pre-authenticated request (like a certificate
for instance).
AccessListener enforces access control rules.
AnonymousAuthenticationListener automatically adds a Token if none is
already present.
BasicAuthenticationListener implements Basic HTTP authentication.
ChannelListener switches the HTTP protocol based on the access control
configuration.
ContextListener manages the SecurityContext persistence through a session.
ExceptionListener catches authentication exception and converts them to
Response instances.
Interface that must be implemented by firewall listeners.
LogoutListener logout users.
RememberMeListener implements authentication capabilities via a cookie.
REMOTE_USER authentication listener.
SimpleFormAuthenticationListener
deprecated
SimplePreAuthenticationListener
deprecated
SimplePreAuthenticationListener implements simple proxying to an authenticator.
SwitchUserListener allows a user to impersonate another one temporarily
(like the Unix su command).
UsernamePasswordFormAuthenticationListener is the default implementation of
an authentication via a simple form composed of a username and a password.
UsernamePasswordJsonAuthenticationListener is a stateless implementation of
an authentication via a JSON document composed of a username and a password.
X509 authentication listener.
Encapsulates the logic needed to create sub-requests, redirect the user, and match URLs.
This handler clears the passed cookies when a user logs out.
Default logout success handler will redirect users to a configured path.
Interface that needs to be implemented by LogoutHandlers.
LogoutSuccesshandlerInterface.
Provides generator functions for the logout URL.
Handler for clearing invalidating the current session.
Base class implementing the RememberMeServicesInterface.
Concrete implementation of the RememberMeServicesInterface which needs
an implementation of TokenProviderInterface for providing remember-me
capabilities.
Interface that needs to be implemented by classes which provide remember-me
capabilities.
Adds remember-me cookies to the Response.
Concrete implementation of the RememberMeServicesInterface providing
remember-me capabilities without requiring a TokenProvider.
The default session strategy implementation.
SessionAuthenticationStrategyInterface.
Trait to get (and set) the URL the user last visited before being forced to authenticate.
Annotation class for @DiscriminatorMap().
Annotation class for @Groups().
Annotation class for @MaxDepth().
Annotation class for @SerializedName().
Adds all services with the tags "serializer.encoder" and "serializer.normalizer" as
encoders and normalizers to the "serializer" service.
Decoder delegating the decoding to a chain of decoders.
Encoder delegating the decoding to a chain of encoders.
Adds the support of an extra $context parameter for the supportsDecoding method.
Adds the support of an extra $context parameter for the supportsEncoding method.
Encodes CSV data.
Defines the interface of decoders.
Defines the interface of encoders.
Decodes JSON data.
Encodes JSON data.
Encodes JSON data.
Defines the interface of encoders that will normalize data themselves.
Encodes XML data.
Encodes YAML data.
CircularReferenceException.
Base exception interface.
ExtraAttributesException.
InvalidArgumentException.
LogicException.
MappingException.
RuntimeException.
UnexpectedValueException.
UnsupportedException.
{@inheritdoc}
Stores metadata needed for serializing and deserializing attributes.
Knows how to get the class discriminator mapping for classes and objects.
{@inheritdoc}
Stores metadata needed for serializing and deserializing objects of specific class.
Caches metadata using a PSR-6 implementation.
Returns a {@link ClassMetadata}.
Returns a {see ClassMetadataInterface}.
Resolves a class name.
Annotation loader.
Base class for all file based loaders.
Calls multiple {@link LoaderInterface} instances in a chain.
Loads {@link ClassMetadataInterface}.
Loads XML mapping files.
YAML File Loader.
Gives access to the class, the format and the context in the property name converters.
CamelCase to Underscore name converter.
Defines the interface for property name converters.
Normalizer implementation.
Base class for a normalizer dealing with objects.
Denormalizes arrays of objects.
Marker interface for normalizers and denormalizers that use
only the type and the format in their supports*() methods.
A normalizer that normalizes a ConstraintViolationListInterface instance.
Adds the support of an extra $context parameter for the supportsDenormalization method.
Adds the support of an extra $context parameter for the supportsNormalization method.
Normalizes an {see \SplFileInfo} object to a data URI.
Normalizes an instance of {see \DateInterval} to an interval string.
Normalizes an object implementing the {see \DateTimeInterface} to a date string.
Defines the most basic interface a class must implement to be denormalizable.
Class accepting a denormalizer.
DenormalizerAware trait.
Defines the interface of denormalizers.
Converts between objects with getter and setter methods and arrays.
A normalizer that uses an objects own JsonSerializable implementation.
Defines the most basic interface a class must implement to be normalizable.
Class accepting a normalizer.
NormalizerAware trait.
Defines the interface of normalizers.
Converts between objects and arrays using the PropertyAccess component.
Converts between objects and arrays by mapping properties.
Serializer serializes and deserializes data.
Defines the interface of encoders.
SerializerAware trait.
Defines the interface of the Serializer.
Stopwatch section.
Stopwatch provides a way to profile code.
Represents an Event managed by Stopwatch.
Represents an Period for an Event.
DelegatingEngine selects an engine for a given template.
EngineInterface is the interface each engine must implement.
Helper is the base class for all helper classes.
HelperInterface is the interface all helpers must implement.
SlotsHelper manages template slots.
CacheLoader is a loader that caches other loaders responses
on the filesystem.
ChainLoader is a loader that calls other loaders to load templates.
FilesystemLoader is a loader that read templates from the filesystem.
Loader is the base class for all template loader classes.
LoaderInterface is the interface all loaders must implement.
PhpEngine is an engine able to render PHP templates.
FileStorage represents a template stored on the filesystem.
Storage is the base class for all storage classes.
StringStorage represents a template stored in a string.
StreamingEngineInterface provides a method that knows how to stream a template.
TemplateNameParser is the default implementation of TemplateNameParserInterface.
TemplateNameParserInterface converts template names to TemplateReferenceInterface
instances.
Internal representation of a template.
Interface to be implemented by all templates.
Base catalogues binary operation class.
Merge operation between two catalogues as follows:
all = source ∪ target = {x: x ∈ source ∨ x ∈ target}
new = all ∖ source = {x: x ∈ target ∧ x ∉ source}
obsolete = source ∖ all = {x: x ∈ source ∧ x ∉ source ∧ x ∉ target} = ∅
Basically, the result contains messages from both catalogues.
Represents an operation on catalogue(s).
Target operation between two catalogues:
intersection = source ∩ target = {x: x ∈ source ∧ x ∈ target}
all = intersection ∪ (target ∖ intersection) = target
new = all ∖ source = {x: x ∈ target ∧ x ∉ source}
obsolete = source ∖ all = source ∖ target = {x: x ∈ source ∧ x ∉ target}
Basically, the result contains messages from the target catalogue.
Validates XLIFF files syntax and outputs encountered errors.
Adds tagged translation.formatter services to translation writer.
Adds tagged translation.extractor services to translation extractor.
CsvFileDumper generates a csv formatted string representation of a message catalogue.
DumperInterface is the interface implemented by all translation dumpers.
FileDumper is an implementation of DumperInterface that dump a message catalogue to file(s).
IcuResDumper generates an ICU ResourceBundle formatted string representation of a message catalogue.
IniFileDumper generates an ini formatted string representation of a message catalogue.
JsonFileDumper generates an json formatted string representation of a message catalogue.
MoFileDumper generates a gettext formatted string representation of a message catalogue.
PhpFileDumper generates PHP files from a message catalogue.
PoFileDumper generates a gettext formatted string representation of a message catalogue.
QtFileDumper generates ts files from a message catalogue.
XliffFileDumper generates xliff files from a message catalogue.
YamlFileDumper generates yaml files from a message catalogue.
Exception interface for all exceptions thrown by the component.
Base InvalidArgumentException for the Translation component.
Thrown when a resource cannot be loaded.
Base LogicException for Translation component.
Thrown when a resource does not exist.
Base RuntimeException for the Translation component.
Base class used by classes that extract translation messages from files.
ChainExtractor extracts translation messages from template files.
Extracts translation messages from a directory or files to the catalogue.
PhpExtractor extracts translation messages from a PHP template.
ChoiceMessageFormatterInterface
deprecated
Formats ICU message patterns.
IdentityTranslator does not translate anything.
Interval
deprecated
Tests if a given number belongs to a given math interval.
ArrayLoader loads translations from a PHP array.
CsvFileLoader loads translations from CSV files.
IcuResFileLoader loads translations from a resource bundle.
IcuResFileLoader loads translations from a resource bundle.
IniFileLoader loads translations from an ini file.
JsonFileLoader loads translations from an json file.
LoaderInterface is the interface implemented by all translation loaders.
PhpFileLoader loads translations from PHP files returning an array of translations.
QtFileLoader loads translations from QT Translations XML files.
XliffFileLoader loads translations from XLIFF files.
YamlFileLoader loads translations from Yaml files.
MessageCatalogueInterface.
MessageSelector
deprecated
MessageSelector.
MetadataAwareInterface.
PluralizationRules
deprecated
Returns the plural rules for a given locale.
TranslationReader reads translation messages from translation files.
TranslationReader reads translation messages from translation files.
TranslatorBagInterface.
TranslatorInterface
deprecated
TranslatorInterface.
ArrayConverter generates tree like structure from a message catalogue.
Provides some utility methods for XLIFF translation files, such as validating
their contents according to the XSD schema.
TranslationWriter writes translation messages.
TranslationWriter writes translation messages.
Contains the properties of a constraint definition.
Base class for constraint validators.
Default implementation of the ConstraintValidatorFactoryInterface.
Specifies an object able to return the correct ConstraintValidatorInterface
instance given a Constraint object.
Default implementation of {@ConstraintViolationInterface}.
A violation of a constraint that happened during validation.
Default implementation of {@ConstraintViolationListInterface}.
A list of constraint violations.
Used for the comparison of values.
Provides a base class for the validation of property comparisons.
Validator for Callback constraint.
Metadata for the CardSchemeValidator.
Validates that a card number belongs to a specified scheme.
ChoiceValidator validates that the value is one of the expected values.
A constraint that is composed of other constraints.
Validates whether a value is a valid country code.
Validates whether a value is a valid currency.
Validates that values are a multiple of the given number.
Validates values are equal (==).
Validates values are greater than or equal to the previous (>=).
Validates values are greater than the previous (>).
A sequence of validation groups.
Annotation to define a group sequence provider.
Validates values are identical (===).
Validates whether a value is a valid image file and is valid
against minWidth, maxWidth, minHeight and maxHeight constraints.
Validates that a value is a valid IP address.
Validates whether a value is a valid IP address.
Validates whether the value is a valid ISBN-10 or ISBN-13.
Validates whether the value is a valid ISSN.
Validates whether a value is a valid language code.
Validates values are less than or equal to the previous (<=).
Validates values are less than the previous (<).
Validates whether a value is a valid locale code.
Metadata for the LuhnValidator.
Validates a PAN using the LUHN Algorithm.
Validates values are all unequal (!=).
Validates values aren't identical (!==).
Validates whether a value match or not given regexp pattern.
Validates whether the value is a valid UUID (also known as GUID).
Uses a service container to create constraint validators.
The context used and created by {@link ExecutionContextFactory}.
Creates new {@link ExecutionContext} instances.
Creates instances of {@link ExecutionContextInterface}.
The context of a validation run.
Base BadMethodCallException for the Validator component.
Base ExceptionInterface for the Validator component.
Base InvalidArgumentException for the Validator component.
Base OutOfBoundsException for the Validator component.
Base RuntimeException for the Validator component.
Defines the interface for a group sequence provider.
Persists ClassMetadata instances in a cache.
Adapts a Doctrine cache to a CacheInterface.
PSR-6 adapter.
Specifies whether an object should be cascaded.
Default implementation of {@link ClassMetadataInterface}.
Stores all metadata needed for validating objects of specific class.
Metadata factory that does not store metadata.
Creates new {@link ClassMetadataInterface} instances.
Returns {@link \Symfony\Component\Validator\Mapping\MetadataInterface} instances for values.
A generic container of {@link Constraint} objects.
Stores all metadata needed for validating a class property via its getter
method.
Base loader for validation metadata.
Loads validation metadata using a Doctrine annotation {@link Reader}.
Base loader for loading validation metadata from a file.
Base loader for loading validation metadata from a list of files.
Loads validation metadata from multiple {@link LoaderInterface} instances.
Loads validation metadata into {@link ClassMetadata} instances.
Loads validation metadata by calling a static method on the loaded class.
Loads validation metadata from an XML file.
Loads validation metadata from a list of XML files.
Loads validation metadata from a YAML file.
Loads validation metadata from a list of YAML files.
Stores all metadata needed for validating a class property.
A container for validation metadata.
Stores all metadata needed for validating a class property.
Stores all metadata needed for validating the value of a class property.
Specifies whether and how a traversable object should be traversed.
Prepares an object for validation.
A test case to ease testing Constraint Validators.
Contains utility methods for dealing with property paths.
Entry point for the Validator component.
The default implementation of {@link ValidatorBuilderInterface}.
ValidatorBuilderInterface
deprecated
A configurable builder for ValidatorInterface objects.
A validator in a specific execution context.
Recursive implementation of {@link ContextualValidatorInterface}.
Recursive implementation of {@link ValidatorInterface}.
Collects some data about validator calls.
Validates PHP values against constraints.
Default implementation of {@link ConstraintViolationBuilderInterface}.
Builds {@link \Symfony\Component\Validator\ConstraintViolationInterface}
objects.
Casts Amqp related classes to array representation.
Represents a list of function arguments.
Helper for filtering out properties in casters.
Represents a PHP class identifier.
Represents a PHP constant and its value.
Represents a cut array.
Represents the main properties of a PHP variable, pre-casted by a caster.
Casts DOM related classes to array representation.
Casts DateTimeInterface related classes to array representation.
Casts Doctrine related classes to array representation.
Represents an enumeration of values.
Casts common Exception classes to array representation.
Represents a single backtrace frame as returned by debug_backtrace() or Exception->getTrace().
Casts GMP objects to array representation.
Represents a file or a URL.
Casts PDO related classes to array representation.
Casts pqsql resources to array representation.
Casts Redis class from ext-redis to array representation.
Casts Reflector related classes to array representation.
Casts common resource types to array representation.
Casts SPL related classes to array representation.
Casts a caster's Stub.
Represents a backtrace as returned by debug_backtrace() or Exception->getTrace().
Casts XmlReader class to array representation.
Casts XML resources to array representation.
AbstractCloner implements a generic caster mechanism for objects and resources.
Represents the current state of a dumper while dumping.
DumperInterface used by Data objects.
Represents the main properties of a PHP variable.
Describe collected data clones for cli output.
Describe collected data clones for html output.
Starts a dump server to collect and output dumps on a single place with multiple formats support.
Abstract mechanism for dumping a Data object.
CliDumper dumps variables for command line output.
Tries to provide context on CLI.
Interface to provide contextual data about dump data clones sent to a server.
Tries to provide context from a request.
Tries to provide context from sources (class name, file, line, code excerpt, .
DataDumperInterface for dumping Data objects.
HtmlDumper dumps variables as HTML.
ServerDumper forwards serialized Data clones to a server.
Forwards serialized Data clones to a server.
A server collecting Data clones sent by a ServerDumper.
A utility class to create objects without calling their constructor.
Exports serializable PHP values to PHP code.
Adds the Link HTTP header to the response.
Serializes a list of Link instances to a HTTP Link header.
Builds a definition.
DumperInterface is the interface implemented by workflow dumper classes.
GraphvizDumper dumps a workflow as a graphviz file.
PlantUmlDumper dumps a workflow as a PlantUML file.
Adds some function to the default Symfony Security ExpressionLanguage.
Thrown by the DefinitionValidatorInterface when the definition is invalid.
Thrown by GuardListener when there is no token set, but guards are placed on a transition.
Thrown by Workflow when a not enabled transition is applied on a subject.
Base RuntimeException for the Workflow component.
Thrown by Workflow when an undefined transition is applied on a subject.
Marking contains the place of every tokens.
MarkingStoreInterface is the interface between the Workflow Component and a
plain old PHP object: the subject.
MultipleStateMarkingStore stores the marking into a property of the
subject.
SingleStateMarkingStore stores the marking into a property of the subject.
MetadataStoreInterface is able to fetch metadata for a specific workflow.
ClassInstanceSupportStrategy
deprecated
SupportStrategyInterface
deprecated
A reason why a transition cannot be performed for a subject.
A list of transition blockers.
Validates YAML files syntax and outputs encountered errors.
Dumper dumps PHP variables to YAML strings.
Escaper encapsulates escaping rules for single and double-quoted
YAML strings.
Exception class thrown when an error occurs during dumping.
Exception interface for all exceptions thrown by the component.
Exception class thrown when an error occurs during parsing.
Exception class thrown when an error occurs during parsing.
Inline implements a YAML parser/dumper for the YAML inline syntax.
Parser parses YAML strings to convert them to PHP arrays.
Unescaper encapsulates unescaping rules for single and double-quoted
YAML strings.
Yaml offers convenience methods to load and dump YAML.
Covers most simple to advanced caching needs.
An implementation of CacheInterface for PSR-6 CacheItemPoolInterface classes.
Computes and returns the cached value of an item.
Augments PSR-6's CacheItemInterface with support for tags and metadata.
Allows invalidating cached items using tags.
Provides a way to reset an object to its initial state.
A trait to help implement PSR-11 service locators.
A ServiceSubscriber exposes its dependencies via the static {@link getSubscribedServices} method.
Implementation of ServiceSubscriberInterface that determines subscribed services from
private method return types. Service ids are available as "ClassName::methodName".
A trait to help implement TranslatorInterface and LocaleAwareInterface.