Classes
Abstracts the task of creating a BackendInterface implementation with it's options.
An abstract caching backend
A caching backend which stores cache entries by using APCu.
A contract for a Cache Backend
A caching backend which stores cache entries in files
A contract for a cache backend which can be frozen.
A contract for a cache backend which provides Iterator functionality.
A caching backend which stores cache entries by using Memcache/Memcached.
A multi backend, falling back to multiple backends if errors occur.
A caching backend which forgets everything immediately
A PDO database cache backend
A contract for a cache backend which is capable of storing, retrieving and including PHP source code.
A caching backend which stores cache entries in Redis using the phpredis PHP extension.
A caching backend which stores cache entries in files, but does not support or care about expiry times and tags.
A contract for a Cache Backend which supports tagging.
A taggable multi backend, falling back to multiple backends if errors occur.
A caching backend which stores cache entries during one script run.
A contract for a Cache Backend which allows to be set up
A contract for a Cache Backend which allows to retrieve its status
Interface for objects which are cache aware and are collaborative when it comes to storing them in a cache.
This cache factory takes care of instantiating a cache frontend and injecting a certain cache backend. After creation of the new cache, the cache object is registered at the cache manager.
This cache factory takes care of instantiating a cache frontend and injecting a certain cache backend. After creation of the new cache, the cache object is registered at the cache manager.
Global Configuration about the environment to be used by caches.
A generic Cache exception
A "Class Already Loaded" exception
A "Duplicate Identifier" exception
An "Invalid Backend" exception
An "Invalid Cache" exception
An "Invalid Data" exception
A "No Such Cache" exception
A "Not Supported by Backend" exception
An abstract cache
An iterator for cache entries
Contract for a Cache (frontend)
A cache frontend tailored to PHP code.
A cache frontend for strings. Nothing else.
A cache frontend for any kinds of PHP variables
A factory for the PSR-6 compatible cache pool.
A cache item (entry).
An implementation of the CacheItemPoolInterface from the PSR-6 specification to be used with our provided backends.
An invalid argument (usually an inacceptable cache key) was given to a PSR cache.
A simple cache frontend Note: This does not follow the \Neos\Cache\Frontend\FrontendInterface this package provides.
A factory for PSR-16 simple caches.
This Abstract Parser class contains definitions for absolutely basic types, like quoted strings or identifiers
A compiling expression parser
An evaluator that compiles expressions down to PHP code
A Eel evaluation context
An Eel evaluator interface
Eel parser
Some exception that occurred during evaluation of an expression
A general Eel exception
Fizzle parser
FlowQuery is jQuery for PHP, a selector and traversal engine for object sets.
Contract for a FlowQuery operation which is applied onto a set of objects.
FlowQuery Operation Resolver
FlowQuery Operation Resolver Interface
Convenience base class for FlowQuery Operations. You should set $shortName and optionally also $final and $priority when subclassing.
Adds the given items to the current context.
Count the number of elements in the context.
Get the first element inside the context.
Get a (non-wrapped) element from the context.
Check whether the at least one of the context elements match the given filter.
Get the last element inside the context.
"children" operation working on generic objects. It iterates over all context elements and returns the values of the properties given in the filter expression that has to be specified as argument or in a following filter operation.
Filter operation, limiting the set of objects. The filter expression is expected as string argument and used to reduce the context to matching elements by checking each value against the filter.
Access properties of an object using ObjectAccess.
Removes the given items from the current context.
Slice the current context
Array helpers for Eel contexts
Configuration helpers for Eel contexts
Date helpers for Eel contexts
Helper to read files.
JSON helpers for Eel contexts
Math helpers for Eel contexts
Helper for security related information
String helpers for Eel contexts
Type helper for Eel contexts
An interpreting expression parser
An expression evalutator that interprets expressions
An exception that is thrown when methods are accessed which are not allowed
Package base class of the Eel package.
Some exception that occurred during parsing of an expression
A protected evaluation context
Interface for classes that are aware of a protected Eel context
Utility to reduce boilerplate code needed to set default context variables and evaluate a string that possibly is an EEL expression.
A validator which checks for the correct syntax of an eel expression (without the wrapping ${…}).
An object representation of a generic error. Subclass this to create more specific errors if necessary.
An object representation of a generic message. Usually, you will use Error, Warning or Notice instead of this one.
An object representation of a generic notice. Subclass this to create more specific notices if necessary.
Result object for operations dealing with objects, such as the Property Mapper or the Validators.
An object representation of a generic warning. Subclass this to create more specific warnings if necessary.
Declares a method as an after advice to be triggered after any pointcut matching the given expression.
Declares a method as an after returning advice to be triggered after any pointcut matching the given expression returns.
Declares a method as an after throwing advice to be triggered after any pointcut matching the given expression throws an exception.
Declares a method as an around advice to be triggered around any pointcut matching the given expression.
Marks a class as an aspect.
Used to disable autowiring for Dependency Injection on the whole class or on the annotated property only.
Declares a method as an before advice to be triggered before any pointcut matching the given expression.
Marks an object as an entity.
Marks a CLI command as a cache-flushing command.
Marks a property as being (part of) the identity of an object.
Used to ignore validation on a specific method argument or class property.
Used to enable property injection.
Used to enable property injection for configuration including settings.
Used to mark a command as internal - it will not be shown in CLI help output.
Introduces the given interface or property into any target class matching the given pointcut expression.
Marks a property or class as lazy-loaded.
Used to map the request body to a single action argument.
Declares a named pointcut. The annotated method does not become an advice but can be used as a named pointcut instead of the given expression.
Used to disable proxy building for an object.
Used to set the scope of an object.
Used to control the behavior of session handling when the annotated method is called.
Marks a method as a signal for the signal/slot implementation of Flow. The method will be augmented as needed (using AOP) to be a usable signal.
Action methods marked with this annotation will not be secured against CSRF.
Marks a property as transient - it will never be considered by the persistence layer for storage and retrieval.
Controls how a property or method argument will be validated by Flow.
Marks the annotate class as a value object.
Base class for Advices.
The advice chain holds a number of subsequent advices that match a given join point and calls the advices in the right order.
This is the interface for a generic AOP advice. It is never implemented directly.
Implementation of the After Advice.
Implementation of the After Returning Advice.
Implementation of the After Throwing Advice.
Implementation of the Around Advice.
Implementation of the Before Advice.
Contains boilerplate code for AOP execution and is added to AOP proxy classes.
An advisor is the combination of a single advice and the pointcut where the advice will become active.
An aspect is represented by class tagged with the "aspect" annotation.
An abstract class with builder functions for AOP method interceptors code builders.
A method interceptor build for constructors with advice.
An AOP interceptor code builder for methods enriched by advices.
A filterable index of class names
The main class of the AOP (Aspect Oriented Programming) framework.
A generic AOP Framework Exception
A "Circular PointcutReference" Exception
A "Invalid Argument" Exception
A "Invalid Constructor Signature" Exception
A "Invalid Pointcut Expression" Exception
An "Invalid Target Class" Exception
A "unknown pointcut" Exception
A "Void Implementation" Exception
Implementation of the interface introduction declaration.
In Flow the join point object contains context information when a point cut matches and the registered advices are executed.
Contract for a join point
The pointcut defines the set of join points (ie. "situations") in which certain code associated with the pointcut (ie. advices) should be executed. This set of join points is defined by a pointcut expression which is matched against class and method signatures.
A class filter which fires on classes annotated with a certain annotation
A simple class filter which fires on class names defined by a regular expression
A class type filter which fires on class or interface names
The pointcut expression parser parses the definition of the place and circumstances where advices can be inserted later on. The input of the parse() function is a string from a pointcut- or advice annotation and returns a pointcut filter composite.
A filter which refers to another pointcut.
This composite allows to check for match against a row pointcut filters by only one method call. All registered filters will be invoked and if one filter doesn't match, the overall result is "no".
The contract for an AOP Pointcut Filter class
A method filter which fires on methods annotated with a certain annotation
A little filter which filters for method names
A settings filter which fires on configuration setting set to true or equal to the given condition.
An evaluator for AOP runtime expressions
Implementation of the property introduction declaration.
Contract and marker interface for the AOP Proxy classes
Implementation of the trait introduction declaration.
This cache factory takes care of instantiating a cache frontend and injecting a certain cache backend. In a Flow context you should use the CacheManager to get a Cache.
The Cache Manager
Represents a command
Represents a CommandArgumentDefinition
A controller which processes requests from the command line
Transitional interface for command controllers.
A helper for CLI Commands
A request handler which can handle command line requests.
A wrapper for Symfony ConsoleOutput and related helpers
An interface which allows a CommandController to tweak command descriptions before they are displayed to the user.
A command dispatcher.
An "Infinite Loop" exception
Represents a CLI request.
Builds a CLI request object from the raw command call
A CLI specific response implementation
A special request handler which handles "slave" command requests as used by the interactive shell.
Command controller for managing caches
Configuration command controller for the Neos.Flow package
Command controller for core commands
Command controller for tasks related to database handling
Command controller for tasks related to Doctrine
A Command Controller which provides help for available commands
Package command controller to handle packages from CLI
PersistentResource command controller for the Neos.Flow package
Command controller for tasks related to routing
Configuration command controller for the TYPO3.Flow package
Command controller for tasks related to security
Command controller for starting the development-server
Command controller for managing sessions
Command controller for listing active type converters
Utility to access composer information like composer manifests (composer.json) and the lock file.
A generic Composer Exception
An Invalid Configuration Exception
An "package manifest could not be converted to JSON" exception
An "Invalid Package Key" exception
An Invalid Configuration Exception
Class for Composer install scripts
A general purpose configuration manager
A validator for all configuration entries using Schema
A generic Configuration Exception
A Container Is Locked exception
An Invalid Configuration Exception
An Invalid Configuration Type Exception
A No Such File exception
A No Such Option exception
A Parse Error exception
A Recursion exception
A Schema Validation Exception
Configuration source based on YAML files
The Flow Context object.
A Sub Process exception
Initialization scripts for modules of the Flow package
A boot sequence, consisting of individual steps, each of them initializing a specific part of the application.
A Step within a Sequence
General purpose central core hyper Flow bootstrap class
Class Loader implementation as fallback to the compoer loader and for test classes.
The Lock Manager controls the master lock of the whole site which is mainly used to regenerate code caches in peace.
Class loader for Flow proxy classes.
The interface for a request handler
An abstract exception handler
A basic but solid exception handler which catches everything which falls through the other exception handlers and provides useful debugging information.
A debugging utility class
Global error handler for Flow
An exception which represents a PHP error.
Contract for an exception handler
A quite exception handler which catches but ignores any exception.
Marks Exceptions having a HTTP status code to return.
Marks Exceptions having a reference code to look up.
A generic Flow Exception
Supports to get a baseUri from various possible sources.
An HTTP client simulating a web browser
A Request Engine which uses cURL in order to send requests to external HTTP servers.
An exception for the Curl Engine
An HTTP exception occuring if an endless Location: redirect is suspect to happen
A Request Engine which uses Flow's request dispatcher directly for processing HTTP requests internally.
Interface for a Request Engine which can be used by a HTTP Client implementation for sending requests and returning responses.
The HTTP component chain
Creates a new ComponentChain according to the specified settings
The component context
An HTTP component
A HTTP component exception
Adds the "X-Flow-Powered" to the response.
Parses the request body and adds the result to the ServerRequest instance.
A HTTP component that handles authentication exceptions that were thrown by the dispatcher (\Neos\Flow\Mvc\Dispatcher::dispatch()) and
- rethrows the exception if not token with Entry Point is authenticated
- or otherwise invokes the Entry Point of all authenticated tokens
HTTP component that makes sure that the current response is standards-compliant. It is usually the last component in the chain.
HTTP component that checks request headers against a configured list of trusted proxy IP addresses.
Implementation of a PSR-7 HTTP stream
Represents a HTTP Cookie as of RFC 6265
A generic HTTP exception
Container for HTTP header fields
Helper to unify different HTTP request arguments.
Helper for dealing with HTTP media type resolution.
Helper to extract various information from PSR-7 requests.
Helper to extract various information from PSR-7 responses.
Helper functions about request safety and security.
Helper to re-organize uploaded file data for requests.
Helper to extract information from Uris.
The interface for a request handler which handles and works with HTTP requests
A middleware that invokes the old Http component chain and returns the final response in the component context
A HTTP middleware exception
Creates a new MiddlewaresChain according to the specified settings
A request handler which can handle HTTP requests.
Declares attributes Flow uses in PSR-7 ServerRequestInterface to carry derived information about the request.
Generic implementation of the PSR-7 UploadedFileInterface.
Represents a URI Template as per http://tools.ietf.org/html/rfc6570
An abstract class for all concrete classes that parses any kind of XML data.
A model representing data from one or few CLDR files.
A class which parses CLDR file to simple but useful array representation.
The CldrRepository class
The "Invalid CLDR Data" exception
A reader for data placed in "currencyData" tag in CLDR.
A reader for data placed in "dates" tag in CLDR.
The "Invalid DateTime Format" exception
The "Invalid Format Length" exception
The "Invalid Format Type" exception
The "Invalid Plural Rule" exception
The "Unable To Find Format" exception
The "Unsupported Number Format" exception
A reader for data placed in "numbers" tag in CLDR.
A reader for data placed in "plurals" tag in CLDR.
A Configuration instance represents settings to be used with the I18n functionality. Examples of such settings are the locale to be used and overrides for message catalogs.
The Detector class provides methods for automatic locale detection
Translation helpers for Eel contexts
Provides a chainable interface to collect all arguments needed to translate messages using source message or key ID
A generic Locale exception
The "Index Out Of Bounds" exception
The "Invalid Argument" exception
The "Invalid Format Placeholder" exception
The "Unsatisfactory Formatter" exception
The "Invalid Locale Identifier" exception
The "Invalid XML File" exception
The "Unknown Formatter" exception
A class for replacing placeholders in strings with formatted values.
Formatter for date and time.
An interface for formatters.
Formatter for numbers.
Represents a locale
The LocaleCollection class contains all locales available in current Flow installation, and describes hierarchical relations between them.
Converter which transforms strings to a Locale object.
Parser for date and time.
The "Invalid Parse String" exception
The "Unsupported Parser Mode" exception
Parser for numbers.
A Service which provides further information about a given locale and the current state of the i18n and L10n components.
An "Invalid Plural Form" exception
An "Unsupported Translation Method" exception
An interface for providers of translation labels (messages).
The concrete implementation of TranslationProviderInterface which uses XLIFF file format to store labels.
A class for translating messages
The Utility class for locale specific actions
An "Invalid XLIFF Data" exception
A model representing data from an XLIFF file object that may be distributed over several documents in different versions.
A provider service for XLIFF file objects within the application
An Xliff reader
A class which parses XLIFF file to simple but useful array representation.
An abstract Log backend
Extended ANSI console backend with human friendly formatting
Contract for a logger backend interface
A log backend which writes log entries to the console (STDOUT or STDERR)
A log backend which writes log entries into a file
A log backend which writes log entries into a file in an easy to parse json format
A backend which just ignores everything
A generic Log exception
A "Could Not Open Resource" exception
An "Invalid Backend" exception
A "No Such Backend" exception
Format any value as plain text representation.
This actually creates a logger from the Neos.Log package.
Interface for PSR-3 logger factories. Any adapter for logging in Flow should bring such a factory.
Marker interface for the security logger.
Marker interface for the system logger.
PSR-3 supporting logger.
An interface for storages that can store full exceptions and their stack traces.
Stores detailed information about throwables into files.
Contract for a change detection strategy
A change detection strategy based on modification times
Contract for a change detection strategy that allows the FileMonitor to mark a file deleted directly.
A monitor which detects changes in directories or files
Represents an internal request targeted to a controller action
Creates an ActionRequest from a PSR-7 http request and sets appropriate defaults.
The minimal MVC response object.
An abstract base class for HTTP based controllers
An HTTP based multi-action controller.
A controller argument
A composite of controller arguments
The controller context holds information about the request, response, arguments and further details of a controller. Instances of this class act as a container for conveniently passing the information to other classes who need it, usually views being views or view helpers.
Generic interface for controllers
A generic Controller exception
An Inactive Package Exception
An Invalid Controller Exception.
An Invalid Package Exception.
The default property mapping configuration is available inside the Argument-object.
This is a Service which can generate a request hash and check whether the currently given arguments fit to the request hash.
An action controller for RESTful web services
A Special Case of a Controller: If no controller has been specified in the request, this controller is chosen.
A dispatch component
Dispatches requests to the controller which was specified by the request and returns the response the controller generated.
A generic MVC exception
An "Ambiguous command identifier" exception
Base command exception
This exception is thrown by a controller to stop the execution of the current action and return the control to the dispatcher for the special case of a forward().
An "Infinite Loop" exception
An "invalid action name" exception
An "invalid action visibility" exception
An "Invalid Argument Mixing" exception
An "Invalid Argument Name" exception
An "Invalid Argument Type" exception
An "Invalid Argument Value" exception
An "Invalid Command Identifier" exception
An "Invalid Controller Name" exception
An "Invalid FlashMessage Configuration" exception
An "Invalid Format" exception
An "Invalid Marker" exception
An "Invalid Or Missing Request Hash" exception
An "Invalid Package Key" exception
An "Invalid Part" exception
An "Invalid Request Method" exception
An "Invalid Request Type" exception
An "invalid RoutePartHandler" exception
An "invalid RoutePartValue" exception
An "invalid Route setup" exception
An "Invalid Template Resource" exception
An "Invalid URI Pattern" exception
An "no matching route" exception that is thrown if the router could not find a route that matches/resolves the given uri pattern/route values
A "No Such Action" exception
A "No Such Argument" exception
A "No Such Command" exception
A "No Such Controller" exception
A "No Such View" exception
A "Required Argument missing" exception
This exception is thrown by a controller to stop the execution of the current action and return the control to the dispatcher. The dispatcher catches this exception and - depending on the "dispatched" status of the request - either continues dispatching the request or returns control to the request handler.
An "Unsupported Request Type" exception
A "View not found" exception
A HTTP Component that persists any new FlashMessages that have been added during the current request cycle
This is a container for all Flash Messages.
Contract for FlashMessage storages
Contract for a dispatchable request.
This class is a helper that can be used as a context for an Eel evaluation to match a request using the Eel Syntax. This is primarily used in the requestFilter of the Views.yaml configuration.
abstract Route Part
The result of a RoutePartInterface::match() call if the corresponding Route Part matched
Simple DTO wrapping the values required for a Router::resolve() call
The result of a RoutePartInterface::resolve() call if the corresponding Route Part resolved
Simple DTO wrapping the values required for a Router::route() call
This class allows the whole routing behavior to be parametrized.
RouteTags to be associated with matched/resolved routes
This class allows constraints to be applied to a given URI, transforming it accordingly as a result.
Dynamic Route Part
Contract for Dynamic Route Parts
An Invalid Controller Exception.
A Missing actionName Exception.
Identity Route Part This route part can be used to create and resolve ObjectPathMappings.
An ObjectPathMapping model This contains the URI representation of an object (pathSegment)
Repository for object path mapping objects
Contract for Route parts that are aware of Routing RouteParameters
Implementation of a standard route
Contract for all Route Parts.
The default web router
Caching of findMatchResults() and resolve() calls on the web Router.
Contract for a Web Router
A routing HTTP component
Static Route Part
An URI Builder
A View Configuration Manager
An abstract View
A JSON view
An abstract View
Interface of a view
A specialized Object Manager which is able to do some basic dependency injection for singleton scoped objects. This Object Manager is used during compile time when the proxy class based DI mechanism is not yet available.
Flow Object Configuration
Injection (constructor-) argument as used in a Object Configuration
Object Configuration Builder which can build object configuration objects from information collected by reflection combined with arrays of configuration options as defined in an Objects.yaml file.
Injection property as used in a Object Configuration
A Proxy Class Builder which integrates Dependency Injection.
Boilerplate code for dependency injection
A Proxy Class Builder which integrates Dependency Injection.
A generic Object Exception
"Cannot build object" Exception
"Cannot reconstitute object" Exception
"Invalid class" Exception
"Invalid Object Configuration" Exception
"Invalid object" Exception
"Invalid object name" Exception
"Object already registered" Exception
"Unknown Class" Exception
"Unknown Interface" Exception
"Unknown Object" Exception
"Unresolved Dependencies" Exception
"Wrong Scope" Exception
Object Manager
Interface for the Flow Object Manager This is a superset of the PSR-11 ContainerInterface.
Builder for proxy classes which are used to implement Dependency Injection and Aspect-Oriented Programming
A generic Proxy Exception
Methods used to serialize objects used by proxy classes.
Representation of a Proxy Class during rendering time
Representation of a constructor method within a proxy class
A marker interface for Proxy Classes
Representation of a method within a proxy class
The Flow Package
An interface to indicate a bootable package
A generic Package Exception
"Corrupt Package" Exception
An "Invalid Package Key" exception
"Invalid Package Path" Exception
An "Invalid Package State" exception
A "Package Key Already Exists" exception
"Package states file not writable" Exception
A "Protected Package Key" exception
"Unknown Package" Exception
An interface for Flow packages that might have configuration or resources
The generic base package that represents third party packages
A Flow Package
Class for building Packages
Interface for a basic Package class
An interface for packages that are aware of the concept of package keys, eg. "Neos.Flow".
The default Flow Package Manager
A simple package dependency order solver. Just sorts by simple dependencies, does no checking or versions.
The Flow Persistence Manager base class
A container for the list of allowed objects to be persisted during this request.
Pointcut filter matching embeddable value objects
Adds the aspect of persistence magic to relevant objects
A marker interface used to support object persistence
An onFlush listener for Flow's Doctrine PersistenceManager, that validates to be persisted entities against the list of allowed objects.
Converts Doctrine collections to arrays
Cache adapter to use Flow caches as Doctrine cache
A walker to transform a select query into a count query.
Extends the default doctrine JsonArrayType to work with entities.
A datatype that replaces references to entities in arrays with a type/identifier tuple and strips singletons from the data to be stored.
EntityManager configuration handler
EntityManager factory for Doctrine integration
An database connection exception
An generic database exception
An database connection exception
A SQL logger that logs to a Flow logger.
A ClassMetadata instance holds all the object-relational mapping metadata of an entity and it's associations.
A factory for Doctrine to create our ClassMetadata instances, aware of the object manager.
This driver reads the mapping metadata from docblock annotations.
A Class Schema Not Found Exception
An onFlush listener for Flow's Doctrine PersistenceManager.
Flow's Doctrine PersistenceManager
A Query class for Doctrine 2
A lazy result list that is returned by Query::execute()
The Flow default Repository, based on Doctrine 2
Service class for tasks related to Doctrine
An empty result list
A generic Persistence exception
An Illegal Object Type Exception
An "Invalid Query" Exception
A Known Object Exception
An ObjectValidationFailedException thrown when a validation error is encountered during persistence.
An Unknown Object Exception
Adds the aspect of lazy loading to relevant objects
An interface used to introduce certain methods to support lazy loading objects
An abstract storage backend for the Flow persistence
A persistence backend interface
A data mapper to map raw records to objects
An "Invalid Number Of Constraints" exception
An "Invalid Object Data" Exception
A "Missing Backend" exception
A "Too Dirty" exception
A "Flow Persistence Unexpected Type" Exception
A lazy loading variant of \SplObjectStorage
The generic Flow Persistence Manager
Filters tuples based on the outcome of a binary operation.
Base class for constraints in the QOM.
An operand whose value can only be determined in evaluating the query.
Performs a logical conjunction of two other constraints.
Performs a logical negation of another constraint.
Performs a logical disjunction of two other constraints.
Evaluates to the lower-case string value (or values, if multi-valued) of operand.
An operand to a binary operation specified by a Comparison.
Evaluates to the value (or values, if multi-valued) of a property.
The Query Object Model Factory
An operand whose value can be determined from static analysis of the query, prior to its evaluation.
Evaluates to the upper-case string value (or values, if multi-valued) of operand.
The Query class used to run queries like $query->matching($query->equals('foo', 'bar'))->setLimit(10)->execute();
The QueryFactory used to create queries against the storage backend
A persistence query factory interface
A lazy result list that is returned by Query::execute()
The persistence session - acts as a UoW and Identity Map for Flow's persistence framework.
The Flow Persistence Manager interface
A persistence query interface.
A lazy result list that is returned by Query::execute()
The Flow default Repository
Contract for a repository
An generic Property related exception
A "Duplicate Object" Exception
A "Duplicate Type Converter" Exception
An "Format not supported" Exception
An "Invalid Data Type" Exception
An "Invalid Format" Exception
An "Invalid Property" Exception
An "Invalid Property Mapping Configuration" Exception
An "Invalid Source" Exception
An "Invalid Target" Exception
A "TargetNotFound" Exception
A "Type Converter" Exception
The Property Mapper transforms simple types (arrays, strings, integers, floats, booleans) to objects or other simple types.
Concrete configuration object for the PropertyMapper.
Configuration object for the property mapper. This interface specifies all methods which are used by the property mapper and by the type converters during the conversion process. Thus, this interface does only contain read-only methods, and no methods to set any of these options.
Interface for type converters, which can convert from a simple type to an object or another simple type.
Type converter which provides sensible default implementations for most methods. If you extend this class you only need to do the following:
Converter which transforms various types to arrays.
TypeConverter which converts generic objects to arrays by converting and returning
Converter which transforms ArrayObjects to arrays.
Converter which transforms simple types to a boolean.
Converter which transforms strings and arrays into a Doctrine ArrayCollection.
Converter which transforms from string, integer and array into DateTime objects.
A "target not found" error that is issued when a referenced object/value could not be fetched
Converter which transforms a float, integer or string to a float.
Converter which transforms to an integer.
Converter which transforms strings to arrays using the configured strategy.
A marker interface for type converters that are used to decode the content of a HTTP request
This converter transforms arrays to simple objects (POPO) by setting properties.
This converter transforms arrays or strings to persistent objects. It does the following:
This converter transforms persistent objects to strings by returning their (technical) identifier.
A type converter which converts a scalar type (string, boolean, float or integer) to an object by instantiating the object and passing the string as the constructor argument.
This converter transforms a session identifier into a real session object.
Converter which transforms simple types to a string.
Converter which recursively transforms typed arrays (array
A type converter for converting URI strings to Http Uri objects.
Extended version of the ReflectionClass
A class schema
A little parser which creates tag objects from doc comments
A generic Reflection Exception
A "Class loading for reflection failed" exception
An "ClassSchema Constraint Violation" exception
An "Invalid Class" exception
An "Invalid Property Type" exception
An "Invalid Value Object" exception
An "Unknown Class" exception
Extended version of the ReflectionMethod
Extended version of the ReflectionParameter
Extended version of the ReflectionProperty
A service for acquiring reflection based information in a performant way. This service also builds up class schema information which is used by the Flow's persistence layer.
Factory for getting an reflection service instance.
A resource collection
Interface for a resource collection
Generic ResourceManagement Exception
"Invalid Resource Data" Exception
Interface for a resource processing filter
Model representing a persistable resource
Message Collector
The ResourceManager
Interface which defines the basic meta data getters and setters for PersistentResource and Storage/Object objects.
PersistentResource Repository
A type converter for converting strings, array and uploaded files to PersistentResource objects.
Generic Storage Exception
A resource storage based on the (local) file system
A resource storage which stores and retrieves resources from active Flow packages.
Interface for a resource storage
An Object which is stored in a Storage
A resource storage based on the (local) file system
Interface of a PersistentResource Storage which provides import functionality.
A stream wrapper for resources.
A generic stream wrapper sitting between PHP and stream wrappers implementing StreamWrapperInterface.
A stream wrapper interface. Modeled after the PHP streamWrapper class prototype. Check http://php.net/streamwrapper for details on that.
Generic Target Exception
A target which publishes resources by creating symlinks.
A target which publishes resources to a specific directory in a file system.
An account model
A factory for conveniently creating new accounts
The repository for accounts
An aspect which centralizes the logging of security relevant actions.
The central security aspect, that invokes the security interceptors.
Contract for an authentication manager.
Contract for an authentication provider used by the AuthenticationProviderManager.
The default authentication manager, which relies on Authentication Providers to authenticate the tokens stored in the security context.
The authentication provider resolver. It resolves the class name of a authentication provider based on names.
The authentication token resolver. It resolves the class name of a authentication token based on names.
An action controller for generic authentication in Flow
Contract for an authentication entry point
An abstract authentication entry point.
An authentication entry point, that sends an HTTP header to start HTTP Basic authentication.
An authentication entry point, that redirects to another webpage.
An abstract authentication provider.
An authentication provider that authenticates Neos\Flow\Security\Authentication\Token\PasswordToken tokens.
An authentication provider that authenticates Neos\Flow\Security\Authentication\Token\UsernamePassword tokens.
A singleton authentication provider for functional tests with mockable authentication.
Default factory for providers and tokens.
Factory contract for providers and their tokens.
Contract for an authentication token.
An abstract authentication token.
An authentication token used for simple password authentication.
Interface for authentication tokens which only hold a password
Marker interface for authentication tokens which don't need a session.
An authentication token used for functional tests
An authentication token used for simple username and password authentication.
An authentication token used for simple username and password authentication via HTTP Basic Auth.
Interface for authentication tokens which hold a username and password
Contract for an after invocation manager. It is used to check return values of a method against security rules.
Contract for an after invocation processor.
The default after invocation manager that uses AfterInvocationProcessorInterface to process the return objects.
Default Firewall which analyzes the request with a RequestFilter chain.
Contract for firewall
Contract for a security interceptor.
The security interceptor resolver. It resolves the class name of a security interceptor based on names.
This security interceptor always denys access.
This security interceptor always grants access.
This is the second main security interceptor, which enforces the current security policy for return values and is usually applied over AOP:
This security interceptor always denys access.
This is the main security interceptor, which enforces the current security policy and is usually called by the central security aspect:
This security interceptor invokes the authentication of the authentication tokens in the security context.
An access decision voter manager
Contract for a privilege manager
An abstract base class for privileges
A condition generator used as an eel context to orchestrate the different sql condition generators.
A sql generator to create a sql conjunction condition.
A sql generator to create a sql disjunction condition.
A filter to rewrite doctrine queries according to the security policy.
An evaluator that compiles expressions down to PHP code
A compiling expression parser
A SQL generator to create a condition matching nothing.
A sql generator to create a sql not condition.
A sql generator to create a sql condition for an entity property.
A filter to rewrite doctrine queries according to the security policy.
Contract for a SQL condition generator.
A SQL generator to create a condition matching anything.
An entity privilege
A method privilege, able to restrict method calls based on pointcut expressions
Contract for a privilege used to restrict method calls
Pointcut filter which connects the method privileges to the AOP framework
A method privilege subject
A specialized pointcut expression parser tailored to policy expressions
A privilege parameter
A privilege parameter definition
Contract for a privilege parameter
A privilege parameter of type string
Contract for a privilege
Marker interface for privilege subjects
A privilege target
A RequestFilter is configured to match specific ActionRequests and call a InterceptorInterface if needed.
An access decision manager that can be overridden for tests
This security interceptor switches the current channel between HTTP and HTTPS protocol.
This is the default implementation of a security context, which holds current security information like roles oder details of authenticated users.
Cryptographic algorithms
Hashing passwords using BCrypt
File based simple encrypted key service
A hash service which should be used to generate and validate hashes.
An RSA key
A password hashing strategy interface
A PBKDF2 based password hashing strategy
Precomposes a hash to be used to prevent timing attacks
RSA related service functions (e.g. used for the RSA authentication provider)
Implementation of the RSAWalletServiceInterface using PHP's OpenSSL extension
A salted MD5 based password hashing strategy
This is dummy implementation of a security context, which holds security information like roles oder details of authenticated users.
A generic Security exception
An "AccessDenied" Exception
An "AccessDenied" Exception
A "CircularResourceDefinitionDetected" Exception
A "DecryptionNotAllowed" Exception
A "InvalidArgumentForHashGeneration" Exception
A "InvalidArgumentForRequestHashGeneration" Exception
An "InvalidAuthenticationProvider" Exception
A "InvalidAuthenticationStatus" Exception
A "InvalidHash" Exception, thrown when a HMAC validation failed.
A "NoEntryInPolicy" Exception
An "InvalidPolicyException" Exception
An "InvalidPrivilegeException" Exception
An "InvalidPrivilegeTypeException" Exception
A "InvalidQueryRewritingConstraintException" Exception
An "InvalidRequestPattern" Exception
A "MissingConfiguration" Exception
A "NoAuthenticationProviderFound" Exception
A "NoAuthenticationTokenFound" Exception
A "NoContextAvailable" Exception
A "NoRequestPatternFound" Exception
A "NoInterceptorFound" Exception
A "NoRequestPatternFound" Exception
A "NoSuchRole" Exception, thrown when a roles is not defined.
An "NoTokensAuthenticated" Exception
An "OperationNotPermitted" Exception
A "RoleExists" Exception, thrown when a role already exists.
A "SyntacticallyWrongRequestHash" Exception
An "UnsupportedAuthenticationToken" Exception
The policy service reads the policy configuration. The security advice asks this service which methods have to be intercepted by a security interceptor.
A role. These roles can be structured in a tree.
This converter transforms strings to role instances
Contract for a request pattern.
The request pattern resolver. It resolves the class name of a request pattern based on names.
This class holds an controller object name pattern an decides, if a \Neos\Flow\Mvc\ActionRequest object matches against this pattern
This class holds a request pattern that decides, if csrf protection was enabled for the current request and searches for invalid csrf protection tokens.
This class holds a host URI pattern and decides, if an ActionRequest object matches against this pattern Note: the pattern is a simple wildcard matching pattern, with * as the wildcard character.
This class holds a CIDR IP pattern an decides, if an ActionRequest object matches against this pattern, comparing the client IP address.
This class holds an URI pattern an decides, if a \Neos\Flow\Mvc\ActionRequest object matches against this pattern
Adds the aspect of lazy loading to objects with scope session.
Marker interface for a Session Lazy Loading Proxy
An aspect which centralizes the logging of important session actions.
Pointcut filter matching proxyable methods in objects of scope session
Interface for Sessions that are related to a cookie.
A "Data not serializable" Exception
An "Invalid Request Handler" Exception
An "Invalid Request or Response" Exception
A HTTP component that initialises the standard Flow session with cookie information.
A component to set a cookie header for the standard Flow session.
A modular session implementation based on the caching framework.
Contract for a session.
Session Manager
Interface for a session manager
Implementation of a transient session.
A dispatcher which dispatches signals by calling its registered slot methods and passing them the method arguments which were originally passed to the signal method.
"Invalid Slot" Exception
Aspect which connects signal methods with the Signal Dispatcher
A utility class for various algorithms.
Abstraction methods which return system environment variables.
A generic Utility Exception
A utility class for dealing with IP addresses.
A unique DateTime object which serves as a reliable reference for the time "now" for all parts of Flow and its packages. It also improves testability of code relying on a certain time.
This utility class can be used to extract information about PHP files without having to instantiate/reflect classes.
This object holds a validation error.
A generic validation exception
An "Invalid Subject" Exception
An "Invalid Type Hint" Exception
An "Invalid Validation Configuration" Exception
An "Invalid Validation Options" Exception
A "No Such Filter" Exception
A "No Such Validator" Exception
Validator resolver to automatically find a appropriate validator for a given subject
An abstract composite validator consisting of other validators
Abstract validator
A validator which will not validate Aggregates that are lazy loaded and uninitialized.
Validator for alphanumeric strings.
Validator for a specific boolean value.
A generic collection validator.
Validator to chain many validators in a conjunction (logical and).
Validator for countable things
Validator for checking Date and Time boundaries
Validator for DateTime objects.
Validator to chain many validators in a disjunction (logical or).
Validator for email addresses
Validator for floats.
A generic object validator which allows for specifying property validators.
Validator for integers.
A validator for labels.
A validator for locale identifiers.
Validator for not empty values.
Validator for general numbers
Validator for general numbers.
Contract for a validator
Contract for a poly type validator, able to act on possibly any type.
A validator which accepts any input.
Validator based on regular expressions.
Validator for string length.
Validator for strings.
Validator for "plain" text.
Validator for uniqueness of entities.
Validator for Universally Unique Identifiers.
Contract for a validator
Command controller for Fluid documentation rendering
A generic Fluid Core exception.
This interceptor looks for URIs pointing to package resources and in place of those adds ResourceUriNode instances using the ResourceViewHelper to make those URIs work in the rendered template.
A node representing an additional namespace declaration inside the template.
A special ViewHelperNode that works via injections and is created by the ResourceInterceptor
This interface should be implemented by proxy objects which want to return something different than themselves when being part of a Fluid ObjectAccess chain such as {foo.bar.baz}.
This is needed to support the EscapingFlagProcessor and globally (en|dis)able escaping in the template.
Preprocessor to detect the "escapingEnabled" inline flag in a template.
Note: this detects Namespace declarations AND takes care of CDATA because the class in TYPO3Fluid does so as well.
Interface for rendering contexts that are Flow aware.
A Fluid rendering context specifically to be used in conjunction with Flow.
This view helper is an abstract ViewHelper which implements an if/else condition.
Abstract view helper with locale awareness.
Tag based view helper.
The abstract base class for all view helpers.
A ViewHelper Exception
A "Invalid Variable" exception.
A "Rendering Context not Accessible" exception.
A "Wrong enctype" exception.
Child Node Access Facet. View Helpers should implement this interface if they need access to the direct children in the Syntax Tree at rendering-time.
Provides the variables inside fluid template. Adds TemplateObjectAccessInterface functionality.
Class ViewHelperResolver
This is the base class for all widget controllers.
A HTTP component specifically for Ajax widgets It's task is to interrupt the default dispatching as soon as possible if the current request is an AJAX request triggered by a Fluid widget (e.g. contains the arguments "widgetId" or "widgetContext").
This object stores the WidgetContext for the currently active widgets of the current user, to make sure the WidgetContext is available in Widget AJAX requests.
A Fluid Widget exception.
An exception if the widget controller has been changed
An exception if the controller is missing.
An exception if no widget context could be found inside the AjaxWidgetContextHolder.
An exception if no widget context could be found inside the AjaxWidgetContextHolder.
The WidgetContext stores all information a widget needs to know about the environment.
The most general Fluid exception.
The Fluid Package
Common base class for XML generators.
A Fluid Service exception.
XML Schema (XSD) Generator. Will generate an XML schema which can be used for auto-completion in schema-aware editors like Eclipse XML editor.
View helper that outputs its child nodes with \Neos\Flow\var_dump()
View helper which renders the flash messages (if there are any) as an unsorted list.
Used to output an HTML
Abstract Form View Helper. Bundles functionality related to direct property access of objects in other Form ViewHelpers.
Abstract Form View Helper. Bundles functionality related to direct property access of objects in other Form ViewHelpers.
Creates a button.
View Helper which creates a simple checkbox ().
Renders an <input type="hidden" ...> tag.
View Helper which creates a simple Password Text Box ().
View Helper which creates a simple radio button ().
This ViewHelper generates a
Creates a submit button.
Textarea view helper.
View Helper which creates a text field ().
A view helper which generates an HTML element.
Applies base64_decode to the input
Formats an integer with a byte count into human-readable form.
Modifies the case of an input string to upper- or lowercase or capitalization.
Use this view helper to crop the text between its opening and closing tags.
Formats a given float to a currency representation.
Formats a \DateTime object.
Applies html_entity_decode() to a value
Applies htmlentities() escaping to a value
This ViewHelper renders the identifier of a persisted object (if it has an identity).
Wrapper for PHPs json_encode function.
Wrapper for PHPs nl2br function.
Formats a number with custom precision, decimal point and grouped thousands.
Formats a string using PHPs str_pad function.
Removes tags from the given string (applying PHPs strip_tags() function)
Encodes the given string according to http://www.faqs.org/rfcs/rfc3986.html (applying PHPs rawurlencode() function)
A view helper for creating links to actions.
Email link view helper.
A view helper for creating links to external targets.
Render the inner parts of a Widget.
ViewHelper that outputs a CSRF token which is required for "unsafe" requests (e.g. POST, PUT, DELETE, ...).
This view helper implements an ifAccess/else condition.
This view helper implements an ifAuthenticated/else condition.
This view helper implements an ifHasRole/else condition.
Returns translated message using source message or key ID.
A view helper for creating URIs to actions.
Email uri view helper.
A view helper for creating URIs to external targets.
A view helper for creating URIs to resources.
This view helper allows to check whether validation errors adhere to the current request.
Validation results view helper
Usage: <f:input id="name" ... />
Controller for the auto-complete widget
Controller for the paginate widget
widget.link ViewHelper This ViewHelper can be used inside widget templates in order to render links pointing to widget actions
This ViewHelper renders a Pagination of objects.
widget.uri ViewHelper This ViewHelper can be used inside widget templates in order to render URIs pointing to widget actions
The abstract base of all Fluid views.
A generic Fluid View exception.
An "Invalid Section" exception
An "Invalid Template Resource" exception
A standalone template view.
Class TemplatePaths
A standard Flow view based on Fluid.
A Flow specific uploaded file.
Command controller for the Kickstart generator
The Kickstart Package
Service for the Kickstart generator
Inflector utilities for the Kickstarter. This is a basic conversion from PHP class and field names to a human readable form.
Validation utilities for the Kickstarter.
Wrapper for PHPs ltrim function.
Wrapper for PHPs ucfirst function.
Humanize a camel cased value
Pluralize a word
Some array functions to help with common tasks
A generic File Utility Exception
An Invalid Position Exception
An Invalid Type Exception
An "Invalid Property Type" exception
File and directory functions
Utility class for converting Internet Media Types to file extensions and vice versa.
Provides methods to call appropriate getter/setter on an object given the property name. It does this following these rules:
This class contains a helper to clear PHP Opcode Caches, auto-detecting the current opcache system in use.
A helper class for handling PDO databases
Flexible array sorter that sorts an array according to a "position" meta data.
Configuration schema generator.
A general purpose Array Validator which can check PHP arrays for validity according to some schema.
PHP type handling functions
Exception thrown by the Unicode methods.
A class with UTF-8 string functions, some inspired by what might be in some future PHP version.
A UTF8-aware TextIterator
A UTF8-aware TextIterator
Exception thrown if a feature is not supported.