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.
A choice list presenting a list of Doctrine entities as choices
Custom loader for entities in the choice list.
Getting Entities through the ORM QueryBuilder
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.
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.
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.
ChromePhpHandler.
DebugLogger.
FirePHPHandler.
Extended SwiftMailerHandler that flushes mail queue if necessary
Logger.
WebProcessor override to read from the HttpFoundation's Request
The PropelDataCollector collector class collects information.
PropelFactory creates services for Propel user provider.
A choice list for object choices based on Propel model.
CollectionToArrayTransformer class.
listener class for propel1translatablecollection
Event Listener class for propel1_translation
Represents the Propel form extension, which loads the Propel functionality.
Propel Type guesser.
ModelType class.
form type for i18n-columns in propel
Translation type class
PropelLogger.
Provides easy to use provisioning for Propel model users.
Runtime lazy loading proxy generator.
Generates dumped PHP code of proxies via reflection.
MessageDataCollector.
Twig extension relate to PHP code and used by the profiler and the default exception templates.
FormExtension extends Twig with form capabilities.
Provides integration with the HttpKernel component.
Provides integration of the Routing component with Twig.
SecurityExtension exposes security context features.
Provides integration of the Translation component with Twig.
Provides integration of the Yaml component with Twig.
TranslationDefaultDomainNodeVisitor.
TranslationNodeVisitor extracts translation messages.
FormEnctypeNode deprecated
Compiles a call to {@link FormRendererInterface::renderBlock()}.
Token Parser for the 'form_theme' 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.
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.
Client simulates a browser and makes requests to a Kernel object.
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 retrieving information about services
RouterApacheDumperCommand.
A console command for retrieving information about routes
A console command to test route matching.
Runs Symfony2 application using PHP built-in web server
A command that parse templates to extract translation messages and add them into the translation files.
Application.
Shell.
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.
RouterDataCollector.
Registers the cache clearers.
Registers the cache warmers.
Dumps the ContainerBuilder to a cache file so that it can be used by debugging tools such as the container:debug console command.
Adds all services with the tags "form.type" and "form.type_guesser" as arguments of the "form.extension" service
Adds services tagged kernel.fragment_renderer as HTTP content rendering strategies.
Adds tagged data_collector services to profiler 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
FrameworkExtension configuration structure.
FrameworkExtension.
Sets the session in the request.
TestSessionListener.
Implements the Hinclude rendering strategy.
Bundle.
Manages HTTP cache objects in a Container.
DelegatingLoader delegates route loading to other loaders using a loader resolver.
This Router creates the Loader only when the cache is empty.
Creates packages based on whether the current request is secure.
The path packages adds a version and a base path to asset URLs.
Binds the Symfony templating loader debugger to the Symfony logger.
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 Twig templates.
ActionsHelper manages action inclusions.
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.
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.
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
SecurityDataCollector.
Adds all configured security voters to the access decision manager
This class contains the configuration information for the following tags:
SecurityExtension.
AbstractFactory is the base class for all classes inheriting from AbstractAuthenticationListener
FormLoginFactory creates services for form login authentication.
HttpBasicFactory creates services for HTTP basic authentication.
HttpDigestFactory creates services for HTTP digest authentication.
SecurityFactoryInterface is the interface for all security authentication listener.
X509Factory creates services for X509 certificate authentication.
InMemoryFactory creates services for the memory 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 context.
LogoutUrlHelper provides generator functions for the logout URL to Twig.
Generates the Twig cache for all templates.
Command that will validate your template syntax and output encountered errors.
ExceptionController.
Times the time spent to render a template.
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.
TwigExtension.
Twig extension for Symfony actions helper
Twig extension for Symfony assets helper
FilesystemLoader extends the default Twig filesystem loader to work with the Symfony2 paths.
Represents a render node.
Token Parser for the render tag.
Bundle.
This engine renders Twig templates.
ExceptionController.
ProfilerController.
RouterController.
This class contains the configuration information for the bundle
WebProfilerExtension.
WebDebugToolbarListener injects the Web Debug Toolbar.
Profiler Templates Manager
Client simulates a browser.
Cookie represents an HTTP cookie.
CookieJar.
History.
Request object.
Response object.
ApcClassLoader implements a wrapping autoloader cached in APC for PHP 5.3.
ApcUniversalClassLoader implements a "universal" autoloader cached in APC for PHP 5.3.
ClassCollectionLoader.
ClassLoader implements an PSR-0 class loader
ClassMapGenerator
Autoloader checking if the class is really defined in the file found.
Checks that the class is actually declared in the included file.
A class loader that uses a mapping file to look up paths.
UniversalClassLoader implements a "universal" autoloader for PHP 5.3.
WinCacheClassLoader implements a wrapping autoloader cached in WinCache.
XcacheClassLoader implements a wrapping autoloader cached in Xcache for PHP 5.3.
ConfigCache manages PHP cache files.
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 contain common code of integer and float node definition.
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
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.
Dumps a reference configuration for the given configuration/node instance.
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.
DirectoryResource represents a resources stored in a subdirectory tree.
FileResource represents a resource stored on the filesystem.
ResourceInterface is the interface that must be implemented by all Resource classes.
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.
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.
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.
Formatter class for console output.
Formatter interface for console output.
Formatter style class for defining styles.
Formatter style interface for defining styles.
This class adds helper method to describe objects in various formats.
The Dialog class provides helpers to interact with the user.
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.
The Progress class provides helpers to display progress output.
Provides helpers to display table output.
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.
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.
StringInput represents an input provided as a string.
ConsoleOutput is the default class for all CLI output. It uses STDOUT.
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.
A Shell wraps an Application to add shell capabilities to it.
Eases the testing of console applications.
Eases the testing of console commands.
CssSelector 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.
Registers all the debug tools.
ErrorHandler.
ExceptionHandler converts an exception to a Response object.
Error Exception with Variable Context.
Used to stop execution of a PHP script after handling a fatal error.
Fatal Error Exception.
FlattenException wraps a PHP Exception to be able to serialize it.
Run this pass before passes that need to know more about the relation of your services.
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
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
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.
A simple implementation of ContainerAwareInterface.
ContainerAwareInterface should be implemented by classes that depends on a Container.
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.
This exception is thrown when you try to create a service of an inactive scope.
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 the a scope crossing injection is detected.
Thrown when a scope widening injection is detected.
This exception is thrown when a circular reference is detected.
This exception is thrown when a non-existent service is requested.
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.
IntrospectableContainerInterface defines additional introspection functionality for containers, allowing logic to be implemented based on a Container's state.
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.
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.
Scope class.
Scope Interface.
SimpleXMLElement class.
TaggedContainerInterface is the interface implemented when a container knows how to deals with tags.
Represents a variable.
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.
Link represents an HTML link (an HTML a tag).
Lazily loads listeners and subscribers from the dependency injection container
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.
Exception interface for all exceptions thrown by the component.
Exception class thrown when a filesystem operation failure happens
Provides basic utility to manipulate the file system.
Interface for finder engine implementations.
Shell engine implementation using GNU find command.
Shell engine implementation using BSD find command.
Shell engine implementation using GNU find command.
PHP finder engine implementation.
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.
Base exception for all adapter failures.
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.
Iterate over shell command result.
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.
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 clickable form element.
Transforms a value between different representations.
Alias of {@link AlreadySubmittedException}.
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.
A choice list for choices of arbitrary data types.
Contains choices that can be selected in a form field.
A choice list that is loaded lazily
A choice list for object choices.
A choice list for choices of type string or integer.
Represents the main form extension, which loads the core functionality.
A data mapper using property paths to read/write data.
Transforms between a Boolean and a string.
Passes a value through multiple value transformers
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.
Takes care of converting the input from a list of checkboxes to a correctly indexed array.
Takes care of converting the input from a single radio button to an array.
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.
Represents a choice in templates.
This extension protects forms by using a CSRF token.
Marks classes able to provide CSRF protection
Default implementation of CsrfProviderInterface.
This provider uses a Symfony2 Session object to retrieve the user's session ID.
BindRequestListener deprecated
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 Symfony2 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
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.
Iterator that traverses an array of forms.
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
FileBag is a container for HTTP headers.
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.
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.
NullSessionHandler.
PdoSessionHandler.
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 Symfony2
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.
FileLocator uses the KernelInterface to locate resources in bundles.
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.
ConfigDataCollector.
DataCollector.
DataCollectorInterface.
EventDataCollector.
ExceptionDataCollector.
LogDataCollector.
MemoryDataCollector.
RequestDataCollector.
RouterDataCollector.
TimeDataCollector.
ErrorHandler deprecated
ErrorHandler.
ExceptionHandler deprecated
ExceptionHandler converts an exception to a Response object.
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.
Adds a managed request scope.
Allow adding classes to the class cache.
Ensures certain extensions are always loaded.
Compiler pass to register tagged services for an event dispatcher.
Injects the logger into the ErrorHandler, so that it can log various errors.
EsiListener adds a Surrogate-Control HTTP header when the Response needs to be parsed for ESI.
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 onKernelResponse event.
ResponseListener fixes the Response headers based on the Request.
Initializes the context from the request and sets request attributes based on a matching route.
StreamedResponseListener is responsible for sending the Response to the client.
Allows filtering of a controller callable
Allows to filter a Response object
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.
FatalErrorException deprecated
Fatal Error Exception.
FlattenException deprecated
FlattenException wraps a PHP Exception to be able to serialize it.
GoneHttpException.
HttpException.
Interface for HTTP error exceptions.
LengthRequiredHttpException.
MethodNotAllowedHttpException.
NotAcceptableHttpException.
NotFoundHttpException.
PreconditionFailedHttpException.
PreconditionRequiredHttpException.
ServiceUnavailableHttpException.
TooManyRequestsHttpException.
UnauthorizedHttpException.
UnsupportedMediaTypeHttpException.
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.
Esi
Esi implements the ESI capabilities to Request and Response instances.
EsiResponseCacheStrategy knows how to compute the Response cache HTTP header based on the different ESI response cache headers.
EsiResponseCacheStrategyInterface implementations know how to compute the Response cache HTTP header based on the different ESI response cache headers.
Cache provides HTTP caching.
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.
LoggerInterface deprecated
LoggerInterface.
NullLogger.
Base Memcache storage for profiling information in a Memcache.
Storage for profiler using files.
Memcache Profiler Storage
Memcached Profiler Storage
A ProfilerStorage for Mysql
Base PDO storage for profiling information in a PDO database.
Profile.
Profiler.
ProfilerStorageInterface.
RedisProfilerStorage stores profiling information in Redis.
SqliteProfilerStorage stores profiling information in a SQLite database.
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.
Replacement for PHP's native {@link \Collator} class.
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.
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.
Provides fake static versions of the global functions in the intl extension
Gives access to internationalization data.
Replacement for PHP's native {@link \Locale} class.
Replacement for PHP's native {@link \NumberFormatter} class.
Base class for {@link ResourceBundleInterface} implementations.
Compiles .txt resource bundles to binary .res files.
Compiles a resource bundle.
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.
Base class for {@link BundleReaderInterface} implementations.
Reads binary .res resource bundles.
Reads resource bundle files.
Reads .php resource bundles.
A structured reader wrapping an existing resource bundle reader.
Reads individual entries of a resource file.
Default implementation of {@link RegionBundleInterface}.
Gives access to region-related ICU data.
Gives access to ICU data.
Compiles a number of resource bundles based on predefined compilation rules.
Default implementation of {@link CompilationContextInterface}.
Stores contextual information for resource bundle compilation.
The rule for compiling the currency bundle.
The rule for compiling the language bundle.
The rule for compiling the locale bundle.
The rule for compiling the region bundle.
Contains instruction for compiling a resource bundle.
Work-around for a bug in PHP's \ResourceBundle implementation.
Implements a ring buffer.
Writes resource bundle files.
Writes .php resource bundles.
Writes .txt resource bundles.
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.
Alias of {@link \Symfony\Component\Intl\Exception\MethodArgumentNotImplementedException}.
Alias of {@link \Symfony\Component\Intl\Exception\MethodArgumentValueNotImplementedException}.
Alias of {@link \Symfony\Component\Intl\Exception\MethodNotImplementedException}.
Alias of {@link \Symfony\Component\Intl\Exception\NotImplementedException}.
Locale deprecated
Helper class for dealing with locale strings.
AmPmTransformer deprecated
Alias of {@link \Symfony\Component\Intl\DateFormatter\DateFormat\AmPmTransformer}.
Alias of {@link \Symfony\Component\Intl\DateFormatter\DateFormat\DayOfWeekTransformer}.
Alias of {@link \Symfony\Component\Intl\DateFormatter\DateFormat\DayOfYearTransformer}.
DayTransformer deprecated
Alias of {@link \Symfony\Component\Intl\DateFormatter\DateFormat\DayTransformer}.
FullTransformer deprecated
Alias of {@link \Symfony\Component\Intl\DateFormatter\DateFormat\FullTransformer}.
Hour1200Transformer deprecated
Alias of {@link \Symfony\Component\Intl\DateFormatter\DateFormat\Hour1200Transformer}.
Hour1201Transformer deprecated
Alias of {@link \Symfony\Component\Intl\DateFormatter\DateFormat\Hour1201Transformer}.
Hour2400Transformer deprecated
Alias of {@link \Symfony\Component\Intl\DateFormatter\DateFormat\Hour2400Transformer}.
Hour2401Transformer deprecated
Alias of {@link \Symfony\Component\Intl\DateFormatter\DateFormat\Hour2401Transformer}.
HourTransformer deprecated
Alias of {@link \Symfony\Component\Intl\DateFormatter\DateFormat\HourTransformer}.
MinuteTransformer deprecated
Alias of {@link \Symfony\Component\Intl\DateFormatter\DateFormat\MinuteTransformer}.
MonthTransformer deprecated
Alias of {@link \Symfony\Component\Intl\DateFormatter\DateFormat\MonthTransformer}.
QuarterTransformer deprecated
Alias of {@link \Symfony\Component\Intl\DateFormatter\DateFormat\QuarterTransformer}.
SecondTransformer deprecated
Alias of {@link \Symfony\Component\Intl\DateFormatter\DateFormat\SecondTransformer}.
TimeZoneTransformer deprecated
Alias of {@link \Symfony\Component\Intl\DateFormatter\DateFormat\TimeZoneTransformer}.
Transformer deprecated
Alias of {@link \Symfony\Component\Intl\DateFormatter\DateFormat\Transformer}.
YearTransformer deprecated
Alias of {@link \Symfony\Component\Intl\DateFormatter\DateFormat\YearTransformer}.
StubCollator deprecated
Alias of {@link \Symfony\Component\Intl\Collator\Collator}.
StubIntl deprecated
Alias of {@link \Symfony\Component\Intl\Globals\IntlGlobals}.
Alias of {@link \Symfony\Component\Intl\DateFormatter\IntlDateFormatter}.
StubLocale deprecated
Alias of {@link \Symfony\Component\Intl\Locale\Locale}.
StubNumberFormatter deprecated
Alias of {@link \Symfony\Component\Intl\NumberFormatter\NumberFormatter}.
Marker interface for the Options component.
Exception thrown when an invalid option is passed.
Exception thrown when a required option is missing.
Thrown when an option definition is invalid.
Container for resolving inter-dependent options.
Helper for merging default and concrete option values.
Marker Interface for the Process Component.
InvalidArgumentException for the Process Component.
LogicException for the Process Component.
Exception for failed processes.
RuntimeException for the Process Component.
Generic executable finder.
An executable finder specifically designed for the PHP executable.
PhpProcess runs a PHP script in an independent process.
Process is a thin wrapper around proc_* functions to ease start independent PHP processes.
Process builder.
ProcessPipes manages descriptors and pipes for the use of proc_open.
ProcessUtils is a bunch of utility methods.
Marker interface for the PropertyAccess component.
Thrown when a property path is malformed.
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 for PropertyAccessorInterface objects.
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
Creates singulars from plurals.
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.
PhpFileLoader loads routes from a PHP file.
XmlFileLoader loads XML routing files.
YamlFileLoader loads Yaml routing files.
ApacheUrlMatcher matches URL based on Apache mod_rewrite matching (see ApacheMatcherDumper).
Dumps a set of Apache mod_rewrite rules.
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.
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.
An ACL provider implementation.
An implementation of the MutableAclProviderInterface using Doctrine DBAL.
The schema used for the ACL system.
Acl
An ACL implementation.
This service caches ACLs for an entire collection of objects.
Base audit logger implementation
This class is a wrapper around the actual cache implementation.
Auditable ACE implementation
Field-aware ACE implementation which is auditable
ObjectIdentity implementation
Strategy to be used for retrieving object identities from domain objects
The permission granting strategy to apply to the access control list.
A SecurityIdentity implementation for roles
Strategy for retrieving security identities
A SecurityIdentity implementation used for actual users
This exception is thrown when someone tries to create an ACL for an object identity that already has one.
This exception is thrown when we cannot locate an ACL for a passed ObjectIdentity implementation.
This exception is thrown whenever you change shared properties of more than one ACL of the same class type concurrently.
Base ACL exception
This exception is thrown when ObjectIdentity fails to construct an object identity from the passed domain object.
This exception is thrown when we cannot locate an ACE that matches the combination of permission masks and security identities.
This exception is thrown when you have requested ACLs for multiple object identities, but the AclProvider implementation failed to find ACLs for all identities.
This exception is thrown when ACEs for an SID are requested which has not been loaded from the database.
AclCache Interface
This interface represents an access control list (ACL) for a domain object.
Provides a common interface for retrieving ACLs.
Interface for audit loggers
This interface adds auditing capabilities to the ACL.
ACEs can implement this interface if they support auditing capabilities.
This method can be implemented by domain objects which you want to store ACLs for if they do not have a getId() method, or getId() does not return a unique identifier.
This class represents an individual entry in the ACL list.
Interface for entries which are restricted to specific fields
This interface adds mutators for the AclInterface.
Provides support for creating and storing ACL instances.
Represents the identity of an individual domain object instance.
Retrieves the object identity for a given domain object
Interface used by permission granting implementations.
This interface provides an additional level of indirection, so that we can work with abstracted versions of security objects and do not have to save the entire objects.
Interface for retrieving security identities from tokens
This is basic permission map complements the masks which have been defined on the standard implementation of the MaskBuilder.
This class allows you to build cumulative permissions easily, or convert masks to a human-readable format.
This is the interface that must be implemented by permission maps.
This voter can be used as a base class for implementing your own permissions.
This class is a lightweight wrapper around field vote requests which does not violate any interface contracts.
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.
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".
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.
AuthenticatedVoter votes if an attribute like ISAUTHENTICATEDFULLY, ISAUTHENTICATEDREMEMBERED, or ISAUTHENTICATEDANONYMOUSLY is present.
RoleHierarchyVoter uses a RoleHierarchy to determine the roles granted to the user before voting.
RoleVoter votes if any attribute starts with a given prefix.
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.
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 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.
DisabledException is thrown when the user account is disabled.
InsufficientAuthenticationException is thrown if the user credentials are not sufficiently trusted.
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.
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.
SecurityContext is the main entry point of the Security component.
The SecurityContextInterface.
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.
User is the user implementation used by the in-memory user provider.
UserChecker checks the user account flags.
UserCheckerInterface checks user account when authentication occurs.
Represents the interface that all user classes must implement.
Represents a class that loads UserInterface objects from some source for the authentication system.
Class related functionality for objects that might or might not be proxy objects at the moment.
A secure random number generator implementation.
Interface that needs to be implemented by all secure random number generators.
String utility functions.
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
Class with the default authentication failure handling logic.
Class with the default authentication success handling logic.
This is used by the ExceptionListener to translate an AccessDeniedException to a Response object.
AuthenticationEntryPointInterface is the interface used to start the authentication scheme.
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
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.
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
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
Base exception
InvalidArgumentException
LogicException
RuntimeException
UnexpectedValueException
UnsupportedException
Defines the most basic interface a class must implement to be denormalizable
Defines the interface of denormalizers.
Converts between objects with getter and setter methods and arrays.
Defines the most basic interface a class must implement to be normalizable
Defines the interface of normalizers.
SerializerAware Normalizer implementation
Serializer serializes and deserializes data
Defines the interface of encoders
Defines the interface of the Serializer
Stopwatch provides a way to profile code.
Represents an Event managed by Stopwatch.
Represents an Period for an Event.
The basic package will add a version to asset URLs.
Asset package interface.
The path packages adds a version and a base path to asset URLs.
The URL packages adds a version and a base URL to asset URLs.
DebuggerInterface is the interface you need to implement to debug template loader instances.
DelegatingEngine selects an engine for a given template.
EngineInterface is the interface each engine must implement.
AssetsHelper helps manage asset URLs.
CoreAssetsHelper helps manage asset URLs.
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.
Diff operation between two catalogues.
Merge operation between two catalogues.
Represents an operation on catalogue(s).
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.
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.
ChainExtractor extracts translation messages from template files.
Extracts translation messages from a template directory 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.
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.
TranslatorInterface.
TranslationWriter writes translation messages.
An object backed by a PHP class.
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
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.
Optional deprecated
Required deprecated
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 (>).
Annotation for group sequences
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
Simple translator implementation that simply replaces the parameters in the message IDs.
Base BadMethodCallException for the Validator component.
Base ExceptionInterface for the Validator component.
Base InvalidArgumentException for the Validator component.
Default implementation of {@link ExecutionContextInterface}.
Stores the validator's state during validation.
Stores the node-independent state of a validation run.
Defines the interface for a group sequence provider.
Simple implementation of MetadataFactoryInterface that can be used when using ValidatorInterface::validateValue().
Persists ClassMetadata instances in a cache
Represents all the configured constraints on a given class.
A factory for creating metadata for PHP classes.
Creates mapping loaders for array of files.
Calls multiple LoaderInterface instances in a chain
Loads multiple xml mapping files
Loads multiple yaml mapping files
Returns {@link MetadataInterface} instances for values.
A container for validation metadata.
Prepares an object for validation.
A container for {@link PropertyMetadataInterface} instances.
A container for validation metadata of a property.
Entry point for the Validator component.
Default implementation of {@link ValidationVisitorInterface} and {@link GlobalExecutionContextInterface}.
Validates values against constraints defined in {@link MetadataInterface} instances.
Default implementation of {@link ValidatorInterface}.
The default implementation of {@link ValidatorBuilderInterface}.
A configurable builder for ValidatorInterface objects.
Validates values and graphs of objects and arrays.
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.