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.
DBAL based session storage.
DBAL Session Storage Schema.
DbalLogger.
References Doctrine connections and entity/document managers.
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.
DebugLogger.
Activation strategy that ignores 404s for certain URLs.
FirePHPHandler.
Extended SwiftMailerHandler that flushes mail queue if necessary.
Logger.
WebProcessor override to read from the HttpFoundation's Request.
Catch deprecation notices and print a summary report at the end of the test suite.
Test that your code triggers expected error messages.
Collects and replays skipped tests.
{@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.
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.
WorkflowExtension.
Provides integration of the Yaml component with Twig.
TranslationDefaultDomainNodeVisitor.
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.
Token Parser for the 'transchoice' tag.
Token Parser for the 'transdefaultdomain' tag.
Token Parser for the 'trans' tag.
TwigExtractor extracts translation messages from a twig template.
This engine knows how to render Twig templates.
Registers the file link format for the {@link \Symfony\Component\HttpKernel\DataCollector\DumpDataCollector}.
DebugExtension configuration structure.
DebugExtension.
Generates the Class Cache (classes.php) file.
Generates the router matcher and generator classes.
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.
Client simulates a browser and makes requests to a Kernel object.
A console command for dumping available configuration reference.
Command that places bundle web assets into a given directory.
Clear and Warmup the cache.
Warmup the cache.
A console command for dumping available configuration reference.
A console command for dumping available configuration reference.
A console command for retrieving information about services.
A console command for retrieving information about event dispatcher.
A console command for retrieving information about routes.
A console command to test route matching.
Base methods for commands related to PHP's built-in web server.
Runs Symfony application using PHP built-in web server.
Runs PHP's built-in 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 PHP's built-in web server.
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 YAML files syntax and outputs encountered errors.
Application.
Controller is a simple implementation of a Controller.
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).
ControllerResolver.
Redirects a request to another URL.
TemplateController.
RequestDataCollector.
RouterDataCollector.
Registers the cache clearers.
Registers the cache warmers.
AddConsoleCommandPass.
Registers the expression language providers.
Adds services tagged configcache.resourcechecker to the configcachefactory service, ordering them by priority.
Dumps the ContainerBuilder to a cache file so that it can be used by debugging tools such as the debug:container console command.
Gathers and configures the argument value resolvers.
Adds all services with the tags "form.type" and "form.type_guesser" as arguments of the "form.extension" service.
Adds tagged data_collector services to profiler service.
Adds extractors to the property_info service.
Adds tagged routing.loader services to routing.resolver service.
Adds all services with the tags "serializer.encoder" and "serializer.normalizer" as encoders and normalizers to the Serializer service.
Adds tagged translation.formatter services to translation writer.
Adds tagged translation.extractor services to translation extractor.
Find all service tags which are defined, but not used and yield a warning log message.
FrameworkExtension configuration structure.
FrameworkExtension.
Sets the session in the request.
TestSessionListener.
Bundle.
Manages HTTP cache objects in a Container.
A Kernel that provides configuration hooks.
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.
CodeHelper.
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.
TranslatorHelper.
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.
PhpExtractor extracts translation messages from a PHP template.
TranslationLoader loads translation messages from translation files.
Translator.
Uses a service container to create constraint validators.
Installs the tables required by the ACL system.
Sets ACL for objects.
Encode a user's password.
SecurityDataCollector.
Adds all configured security voters to the access decision manager.
This class contains the configuration information.
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.
HttpDigestFactory creates services for HTTP digest authentication.
RemoteUserFactory creates services for REMOTE_USER based authentication.
SecurityFactoryInterface is the interface for all security authentication listener.
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.
Merges ACL schema into the given schema.
Bundle.
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.
Lists twig functions, filters, globals and tests present in the current project.
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.
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.
ProfilerController.
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.
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.
Returns the same version for all assets.
Asset version strategy interface.
Client simulates a browser.
Cookie represents an HTTP cookie.
CookieJar.
History.
Request object.
Response object.
Interface for adapters managing instances of Symfony's {see CacheItem}.
Chains several adapters together.
Interface for invalidating cached items using tags.
Interface for adding tags to cache items.
ApcClassLoader implements a wrapping autoloader cached in APC for PHP 5.3.
ClassCollectionLoader.
ClassLoader implements an PSR-0 class loader.
ClassMapGenerator.
A class loader that uses a mapping file to look up paths.
A PSR-4 compatible class loader.
WinCacheClassLoader implements a wrapping autoloader cached in WinCache.
XcacheClassLoader implements a wrapping autoloader cached in XCache for PHP 5.3.
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.
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.
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.
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.
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.
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.
XMLUtils is a bunch of utility methods to XML operations.
An Application is the container for a collection of commands.
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.
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 inspect input and output of a command.
Allows to handle exception thrown in 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.
Formatter class for console output.
Formatter interface for console output.
Formatter style class for defining styles.
Formatter style interface for defining styles.
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.
Error Exception with Variable Context.
Fatal Error Exception.
Fatal Throwable Error.
FlattenException wraps a PHP Exception to be able to serialize it.
Out of memory exception.
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.
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.
Guesses constructor arguments of services definitions and try to instantiate services if necessary.
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.
A pass to automatically process extensions if they implement CompilerPassInterface.
Inline service definitions where this is possible.
Used to format logging messages during the compilation.
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.
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.
Interface that must be implemented by passes that are run as part of an RepeatedPass.
A pass that might be run repeatedly.
Replaces aliases with actual service definitions, effectively removing these aliases.
This replaces all DefinitionDecorator instances with their equivalent fully merged Definition instance.
Emulates the invalid behavior if the reference is not found within the container.
Resolves all parameter placeholders "%somevalue%" to their real values.
Replaces all references to aliases with references to the actual service.
This is a directed graph of your services.
Represents an edge in your service graph.
Represents a node in your service graph.
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.
This definition decorates another 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.
Base BadMethodCallException for Dependency Injection component.
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.
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.
Holds read-only parameters.
Holds parameters.
ParameterBagInterface.
Reference represents a service reference.
ResettableContainerInterface defines additional resetting functionality for containers, allowing to release shared services when the container is not needed anymore.
TaggedContainerInterface is the interface implemented when a container knows how to deals with tags.
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).
Lazily loads listeners and subscribers from the dependency injection container.
Collects some data about event listeners.
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 himself what events he 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.
LockHandler class provides a simple abstraction to lock anything by means of a file lock.
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).
This iterator just overrides the rewind method in order to correct a PHP bug, which existed before version 5.5.23/5.6.7.
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.
Represents a group of choices in templates.
Represents a choice list in templates.
Represents a choice in templates.
A clickable form element.
Transforms a value between different representations.
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 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 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::POSTSETDATA} 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.
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's super globals $GET, $POST and $_SERVER.
A form extension with preloaded types, type exceptions 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.
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 error occurred in the component File.
Thrown when a file was not found.
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 file uploaded through a form.
HeaderBag is a container for HTTP headers.
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.
Session Bag store.
Interface for the session.
MemcacheSessionHandler.
MemcachedSessionHandler.
MongoDB session handler.
NativeFileSessionHandler.
Adds SessionHandler functionality if available.
NullSessionHandler.
Session handler using a PDO connection to read and write data.
Wraps another SessionHandlerInterface to only write the session when it has been modified.
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.
AbstractProxy.
NativeProxy.
SessionHandler proxy.
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.
EnvParametersResource represents resources stored in prefixed environment variables.
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 variadic argument's values from the request attributes.
Responsible for resolving the value of an argument based on its metadata.
Acts as a marker and a data holder for a Controller.
ControllerResolver.
A ControllerResolverInterface implementation knows how to determine the controller to execute based on a Request object.
TraceableControllerResolver.
AjaxDataCollector.
ConfigDataCollector.
DataCollector.
DataCollectorInterface.
EventDataCollector.
ExceptionDataCollector.
LateDataCollectorInterface.
LogDataCollector.
MemoryDataCollector.
RequestDataCollector.
RouterDataCollector.
TimeDataCollector.
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.
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.
Ensures certain extensions are always loaded.
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.
Saves the session, in case it is still open, before sending the response/headers.
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.
TestSessionListener.
Synchronizes the locale between the request and the translator.
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.
AccessDeniedHttpException.
BadRequestHttpException.
ConflictHttpException.
GoneHttpException.
HttpException.
Interface for HTTP error exceptions.
LengthRequiredHttpException.
MethodNotAllowedHttpException.
NotAcceptableHttpException.
NotFoundHttpException.
PreconditionFailedHttpException.
PreconditionRequiredHttpException.
ServiceUnavailableHttpException.
TooManyRequestsHttpException.
UnauthorizedHttpException.
UnprocessableEntityHttpException.
UnsupportedMediaTypeHttpException.
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
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
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.
Storage for profiler using files.
Profile.
Profiler.
ProfilerStorageInterface.
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.
An SVN commit.
A SVN repository containing ICU data.
Facilitates the comparison of version strings.
Entry manager interface.
A class representing the Ldap extension's options, which can be used with ldapsetoption or ldapgetoption.
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.
LdapClient deprecated
LdapClientInterface deprecated
Ldap interface.
Ldap interface.
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 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 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.
Process builder.
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.
StringUtil deprecated
Creates singulars from plurals.
Extracts data using a PHPDoc parser.
Extracts PHP informations using the reflection API.
Lists available properties using Symfony Serializer Component metadata.
Guesses if the property can be accessed or mutated.
Description extractor Interface.
Adds a PSR-6 cache layer on top of an extractor.
Default {see PropertyInfoExtractorInterface} implementation.
Gets info about PHP class properties.
Extracts the list of properties available for the given class.
Type Extractor Interface.
Type value object (immutable).
Annotation class for @Route().
CompiledRoutes are returned by the RouteCompiler class.
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.
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.
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.
Collection of routes.
Prefix tree of routes preserving routes order.
Container for a Route.
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.
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.
UserProviderInterface retrieves users for UsernamePasswordToken tokens.
This class is used for testing purposes, and is not really suited for production.
This class is only used by PersistentTokenRememberMeServices internally.
Interface to be implemented by persistent token classes (such as Doctrine entities representing a remember-me token).
Interface for TokenProviders.
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.
Decorates the original AccessDecisionManager class to log information about the security voters and the decisions made by them.
Adds some function to the default ExpressionLanguage.
Define some ExpressionLanguage functions.
AuthenticatedVoter votes if an attribute like ISAUTHENTICATEDFULLY, ISAUTHENTICATEDREMEMBERED, or ISAUTHENTICATEDANONYMOUSLY 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.
Voter is an abstract default implementation of a voter.
VoterInterface is the interface implemented by all voters.
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.
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.
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-authentcated 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.
LogoutException is thrown when the account cannot be logged out.
NonceExpiredException is thrown when an authentication is rejected because the digest nonce has expired.
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 of a RoleInterface where the role is a string.
RoleHierarchy defines a role hierarchy.
RoleHierarchyInterface is the interface for a role hierarchy.
RoleInterface represents a role granted to a user.
SwitchUserRole is used when the current user temporarily impersonates another one.
This class holds security information.
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.
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 Symfony2 Session object.
Stores CSRF tokens.
An optional base class that creates a PostAuthenticationGuardToken for you.
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.
The interface for all "guard" authenticators.
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.
Class to proxy authentication success/failure handlers.
This is used by the ExceptionListener to translate an AccessDeniedException to a Response object.
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.
DigestAuthenticationEntryPoint starts an HTTP Digest authentication.
FormAuthenticationEntryPoint starts an authentication via a login form.
RetryAuthenticationEntryPoint redirects URL based on the configured scheme.
InteractiveLoginEvent.
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.
DigestAuthenticationListener implements Digest HTTP authentication.
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.
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.
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 @Groups().
Annotation class for @MaxDepth().
Decoder delegating the decoding to a chain of decoders.
Encoder delegating the decoding to a chain of encoders.
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.
SerializerAware Encoder implementation.
Encodes XML data.
CircularReferenceException.
Base exception interface.
InvalidArgumentException.
LogicException.
MappingException.
RuntimeException.
UnexpectedValueException.
UnsupportedException.
{@inheritdoc}
Stores metadata needed for serializing and deserializing attributes.
{@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.
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.
Normalizes an {see \SplFileInfo} object to a data URI.
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.
SerializerAware Normalizer implementation.
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.
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.
Thrown when a resource cannot be loaded.
Thrown when a resource does not exist.
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.
IdentityTranslator does not translate anything.
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.
MessageCatalogue.
MessageCatalogueInterface.
MessageSelector.
MetadataAwareInterface.
Returns the plural rules for a given locale.
Translator.
TranslatorBagInterface.
TranslatorInterface.
ArrayConverter generates tree like structure from a message catalogue.
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.
All
Bic
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 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.
Ip
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.
Url
Validates whether the value is a valid UUID per RFC 4122.
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}.
A configurable builder for ValidatorInterface objects.
A validator in a specific execution context.
Recursive implementation of {@link ContextualValidatorInterface}.
Recursive implementation of {@link ValidatorInterface}.
Validates PHP values against constraints.
Default implementation of {@link ConstraintViolationBuilderInterface}.
Builds {@link \Symfony\Component\Validator\ConstraintViolationInterface} objects.
Casts Amqp related classes to array representation.
Helper for filtering out properties in casters.
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 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 classes from the MongoDb extension to array representation.
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.
Abstract mechanism for dumping a Data object.
CliDumper dumps variables for command line output.
DataDumperInterface for dumping Data objects.
HtmlDumper dumps variables as HTML.
DumperInterface is the interface implemented by workflow dumper classes.
GraphvizDumper dumps a workflow as a graphviz file.
Marking contains the place of every tokens.
MarkingStoreInterface.
PropertyAccessorMarkingStore.
ScalarMarkingStore.
UniqueTransitionOutputInterface.
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.