Application
Interfaces, Classes, Traits and Enums
- ContentSearchIndex
- EmailTemplate
- WithExtend
- Define implementation details for object attribute extension
- SearchIndex
- SessionHandler
- Define a session handler interface with start and end points
- WithCheckAccess
- WithConfig
- Define implementation details for 3 configuration related endpoints
- WithHookUpdate
- WithIncludes
- WithNotifications
- ServiceInterface
- Interface ServiceInterface.
- CacheInterface
- Generic Cache Interface.
- ContainerInterface
- Describes the interface of a container that exposes methods to read its entries.
- ContainerException
- Base interface representing a generic exception in a container.
- NotFoundException
- No entry was found in the container.
- ClientInterface
- Client interface for sending HTTP requests.
- CookieJarInterface
- Stores HTTP cookies.
- GuzzleException
- CurlFactoryInterface
- PromiseInterface
- A promise represents the eventual result of an asynchronous operation.
- PromisorInterface
- Interface used with classes that return a promise.
- TaskQueueInterface
- CacheException
- Exception interface for all exceptions thrown by an Implementing Library.
- CacheItemInterface
- CacheItemInterface defines an interface for interacting with objects inside a cache.
- CacheItemPoolInterface
- CacheItemPoolInterface generates CacheItemInterface objects.
- InvalidArgumentException
- Exception interface for invalid cache arguments.
- ContainerExceptionInterface
- Base interface representing a generic exception in a container.
- ContainerInterface
- Describes the interface of a container that exposes methods to read its entries.
- NotFoundExceptionInterface
- No entry was found in the container.
- MessageInterface
- HTTP messages consist of requests from a client to a server and responses from a server to a client. This interface defines the methods common to each.
- RequestInterface
- Representation of an outgoing, client-side request.
- ResponseInterface
- Representation of an outgoing, server-side response.
- ServerRequestInterface
- Representation of an incoming, server-side HTTP request.
- StreamInterface
- Describes a data stream.
- UploadedFileInterface
- Value object representing a file uploaded through an HTTP request.
- UriInterface
- Value object representing a URI.
- LoggerAwareInterface
- Describes a logger-aware instance.
- LoggerInterface
- Describes a logger instance.
- CacheException
- Interface used for all types of exceptions thrown by the implementing library.
- CacheInterface
- InvalidArgumentException
- Exception interface for invalid cache arguments.
- ExceptionInterface
- PatternInterface
- AvailableSpaceCapableInterface
- ClearByNamespaceInterface
- ClearByPrefixInterface
- ClearExpiredInterface
- FlushableInterface
- IterableInterface
- IteratorInterface
- OptimizableInterface
- PluginInterface
- Interface for self-registering event listeners.
- StorageInterface
- TaggableInterface
- TotalSpaceCapableInterface
- EventInterface
- Representation of an event
- EventManagerAwareInterface
- Interface to automate setter injection for an EventManager instance
- EventManagerInterface
- Interface for messengers
- EventsCapableInterface
- Interface indicating that an object composes an EventManagerInterface instance.
- ExceptionInterface
- Base exception interface
- FilterInterface
- Interface for intercepting filter chains
- ListenerAggregateInterface
- Interface for self-registering event listeners.
- SharedEventManagerInterface
- Interface for shared event listener collections
- SharedEventsCapableInterface
- Interface indicating that an object composes or can compose a SharedEventManagerInterface instance.
- AbstractFactoryInterface
- Backwards-compatibility shim for AbstractFactoryInterface.
- ConfigInterface
- DelegatorFactoryInterface
- Backwards-compatibility shim for DelegatorFactoryInterface.
- ExceptionInterface
- Base exception for all Zend\ServiceManager exceptions.
- AbstractFactoryInterface
- Interface for an abstract factory.
- DelegatorFactoryInterface
- Delegator factory interface.
- FactoryInterface
- Interface for a factory
- FactoryInterface
- Backwards-compatibility shim for FactoryInterface.
- InitializerInterface
- Interface for an initializer
- InitializerInterface
- Backwards-compatibility shim for InitializerInterface.
- PluginManagerInterface
- Interface for a plugin manager
- ServiceLocatorInterface
- Interface for service locator
- ArraySerializableInterface
- MergeReplaceKeyInterface
- Marker interface: can be used to replace keys completely in {@see ArrayUtils::merge()} operations
- DispatchableInterface
- ExceptionInterface
- Exception marker interface
- InitializableInterface
- Interface to allow objects to have initialization logic
- JsonSerializable
- MessageInterface
- ParameterObjectInterface
- ParametersInterface
- RequestInterface
- ResponseInterface
- StringWrapperInterface
- GoogleAuthenticatorInterface
- Cacheable
- TusMiddleware
- ClientInterface
- Client interface for sending HTTP requests.
- CookieJarInterface
- Stores HTTP cookies.
- GuzzleException
- CurlFactoryInterface
- PromiseInterface
- A promise represents the eventual result of an asynchronous operation.
- PromisorInterface
- Interface used with classes that return a promise.
- TaskQueueInterface
- CarbonInterface
- Common interface for Carbon and CarbonImmutable.
- CarbonDoctrineType
- BadMethodCallException
- Exception
- InvalidArgumentException
- RuntimeException
- ClientContextInterface
- Interface defining a client-side context such as a pipeline or transaction.
- ClientInterface
- Interface defining a client able to execute commands against Redis.
- DistributorInterface
- A distributor implements the logic to automatically distribute keys among several nodes for client-side sharding.
- HashGeneratorInterface
- An hash generator implements the logic used to calculate the hash of a key to distribute operations among Redis nodes.
- StrategyInterface
- Interface for classes defining the strategy used to calculate an hash out of keys extracted from supported commands.
- CommandInterface
- Defines an abstraction representing a Redis command.
- PrefixableCommandInterface
- Defines a command whose keys can be prefixed.
- ProcessorInterface
- A command processor processes Redis commands before they are sent to Redis.
- OptionInterface
- Defines an handler used by Predis\Configuration\Options to filter, validate or return default values for a given option.
- OptionsInterface
- Interface defining a container for client options.
- ClusterInterface
- Defines a cluster of Redis servers formed by aggregating multiple connection instances to single Redis nodes.
- ReplicationInterface
- Defines a group of Redis nodes in a master / slave replication setup.
- AggregateConnectionInterface
- Defines a virtual connection composed of multiple connection instances to single Redis nodes.
- CompositeConnectionInterface
- Defines a connection to communicate with a single Redis server that leverages an external protocol processor to handle pluggable protocol handlers.
- ConnectionInterface
- Defines a connection object used to communicate with one or multiple Redis servers.
- FactoryInterface
- Interface for classes providing a factory of connections to Redis nodes.
- NodeConnectionInterface
- Defines a connection used to communicate with a single Redis node.
- ParametersInterface
- Interface defining a container for connection parameters.
- ProfileInterface
- A profile defines all the features and commands supported by certain versions of Redis. Instances of Predis\Client should use a server profile matching the version of Redis being used.
- ProtocolProcessorInterface
- Defines a pluggable protocol processor capable of serializing commands and deserializing responses into PHP objects directly from a connection.
- RequestSerializerInterface
- Defines a pluggable serializer for Redis commands.
- ResponseReaderInterface
- Defines a pluggable reader capable of parsing responses returned by Redis and deserializing them to PHP objects.
- ResponseHandlerInterface
- Defines a pluggable handler used to parse a particular type of response.
- ErrorInterface
- Represents an error returned by Redis (responses identified by "-" in the Redis protocol) during the execution of an operation on the server.
- ResponseInterface
- Represents a complex response object from Redis.
- CacheException
- Exception interface for all exceptions thrown by an Implementing Library.
- CacheItemInterface
- CacheItemInterface defines an interface for interacting with objects inside a cache.
- CacheItemPoolInterface
- CacheItemPoolInterface generates CacheItemInterface objects.
- InvalidArgumentException
- Exception interface for invalid cache arguments.
- ContainerExceptionInterface
- Base interface representing a generic exception in a container.
- ContainerInterface
- Describes the interface of a container that exposes methods to read its entries.
- NotFoundExceptionInterface
- No entry was found in the container.
- MessageInterface
- HTTP messages consist of requests from a client to a server and responses from a server to a client. This interface defines the methods common to each.
- RequestInterface
- Representation of an outgoing, client-side request.
- ResponseInterface
- Representation of an outgoing, server-side response.
- ServerRequestInterface
- Representation of an incoming, server-side HTTP request.
- StreamInterface
- Describes a data stream.
- UploadedFileInterface
- Value object representing a file uploaded through an HTTP request.
- UriInterface
- Value object representing a URI.
- LoggerAwareInterface
- Describes a logger-aware instance.
- LoggerInterface
- Describes a logger instance.
- ArrayInterface
- `ArrayInterface` provides traversable array functionality to data types.
- CollectionInterface
- A collection represents a group of objects, known as its elements.
- DoubleEndedQueueInterface
- A linear collection that supports element insertion and removal at both ends.
- MapInterface
- An object that maps keys to values.
- TypedMapInterface
- A `TypedMapInterface` represents a map of elements where key and value are typed.
- QueueInterface
- A queue is a collection in which the entities in the collection are kept in order.
- UuidBuilderInterface
- A UUID builder builds instances of UuidInterface
- CodecInterface
- A codec encodes and decodes a UUID according to defined rules
- NumberConverterInterface
- A number converter converts UUIDs from hexadecimal characters into representations of integers and vice versa
- TimeConverterInterface
- A time converter converts timestamps into representations that may be used in UUIDs
- DeprecatedUuidInterface
- This interface encapsulates deprecated methods for ramsey/uuid; this interface and its methods will be removed in ramsey/uuid 5.0.0.
- FieldsInterface
- UUIDs are comprised of unsigned integers, the bytes of which are separated into fields and arranged in a particular layout defined by the specification for the variant
- DceSecurityGeneratorInterface
- A DCE Security generator generates strings of binary data based on a local domain, local identifier, node ID, clock sequence, and the current time
- NameGeneratorInterface
- A name generator generates strings of binary data created by hashing together a namespace with a name, according to a hashing algorithm
- RandomGeneratorInterface
- A random generator generates strings of random binary data
- TimeGeneratorInterface
- A time generator generates strings of binary data based on a node ID, clock sequence, and the current time
- CalculatorInterface
- A calculator performs arithmetic operations on numbers
- DceSecurityProviderInterface
- A DCE provider provides access to local domain identifiers for version 2, DCE Security, UUIDs
- NodeProviderInterface
- A node provider retrieves or generates a node ID
- TimeProviderInterface
- A time provider retrieves the current time
- FieldsInterface
- RFC 4122 defines fields for a specific variant of UUID
- UuidInterface
- Also known as a Leach-Salz variant UUID, an RFC 4122 variant UUID is a universally unique identifier defined by RFC 4122
- NumberInterface
- NumberInterface ensures consistency in numeric values returned by ramsey/uuid
- TypeInterface
- TypeInterface ensures consistency in typed values returned by ramsey/uuid
- UuidFactoryInterface
- UuidFactoryInterface defines common functionality all `UuidFactory` instances must implement
- UuidInterface
- A UUID is a universally unique identifier adhering to an agreed-upon representation format and standard for generation
- ValidatorInterface
- A validator validates a string as a proper UUID
- AdapterInterface
- Interface for adapters managing instances of Symfony's CacheItem.
- TagAwareAdapterInterface
- Interface for invalidating cached items using tags.
- MarshallerInterface
- Serializes/unserializes PHP values.
- PruneableInterface
- Interface extends psr-6 and psr-16 caches to allow for pruning (deletion) of all expired cache items.
- ResettableInterface
- Resets a pool's local state.
- CacheInterface
- Covers most simple to advanced caching needs.
- CallbackInterface
- Computes and returns the cached value of an item.
- ItemInterface
- Augments PSR-6's CacheItemInterface with support for tags and metadata.
- TagAwareCacheInterface
- Allows invalidating cached items using tags.
- ConfigCacheFactoryInterface
- Interface for a ConfigCache factory. This factory creates an instance of ConfigCacheInterface and initializes the cache if necessary.
- ConfigCacheInterface
- Interface for ConfigCache.
- BuilderAwareInterface
- An interface that can be implemented by nodes which build other nodes.
- NodeParentInterface
- An interface that must be implemented by all node parents.
- ParentNodeDefinitionInterface
- An interface that must be implemented by nodes which can have children.
- ConfigurationInterface
- Configuration interface.
- NodeInterface
- Common Interface among all nodes.
- PrototypeNodeInterface
- This interface must be implemented by nodes which can be used as prototypes.
- FileLocatorInterface
- LoaderInterface
- LoaderInterface is the interface implemented by all loader classes.
- LoaderResolverInterface
- LoaderResolverInterface selects a loader for a given resource.
- ResourceInterface
- ResourceInterface is the interface that must be implemented by all Resource classes.
- SelfCheckingResourceInterface
- Interface for Resources that can check for freshness autonomously, without special support from external services.
- ResourceCheckerInterface
- Interface for ResourceCheckers.
- CommandLoaderInterface
- DescriptorInterface
- Descriptor interface.
- ExceptionInterface
- ExceptionInterface.
- OutputFormatterInterface
- Formatter interface for console output.
- OutputFormatterStyleInterface
- Formatter style interface for defining styles.
- WrappableOutputFormatterInterface
- Formatter interface for console output that supports word wrapping.
- HelperInterface
- HelperInterface is the interface all helpers must implement.
- InputAwareInterface
- InputAwareInterface should be implemented by classes that depends on the Console Input.
- InputInterface
- InputInterface is the interface implemented by all input classes.
- StreamableInputInterface
- StreamableInputInterface is the interface implemented by all input classes that have an input stream.
- ConsoleOutputInterface
- ConsoleOutputInterface is the interface implemented by ConsoleOutput class.
- OutputInterface
- OutputInterface is the interface implemented by all Output classes.
- StyleInterface
- Output style helpers.
- FatalErrorHandlerInterface
- Attempts to convert fatal errors to exceptions.
- ArgumentInterface
- Represents a complex argument containing nested values.
- CompilerPassInterface
- Interface that must be implemented by compilation passes.
- ContainerAwareInterface
- ContainerAwareInterface should be implemented by classes that depends on a Container.
- ContainerInterface
- ContainerInterface is the interface implemented by service container classes.
- DumperInterface
- DumperInterface is the interface implemented by service container dumper classes.
- EnvVarLoaderInterface
- EnvVarLoaderInterface objects return key/value pairs that are added to the list of available env vars.
- EnvVarProcessorInterface
- The EnvVarProcessorInterface is implemented by objects that manage environment-like variables.
- ExceptionInterface
- Base ExceptionInterface for Dependency Injection component.
- ConfigurationExtensionInterface
- ConfigurationExtensionInterface is the interface implemented by container extension classes.
- ExtensionInterface
- ExtensionInterface is the interface implemented by container extension classes.
- PrependExtensionInterface
- InstantiatorInterface
- Lazy proxy instantiator, capable of instantiating a proxy given a container, the service definitions and a callback that produces the real service instance.
- DumperInterface
- Lazy proxy dumper capable of generating the instantiation logic PHP code for proxied services.
- ContainerBagInterface
- ContainerBagInterface is the interface implemented by objects that manage service container parameters.
- ParameterBagInterface
- ParameterBagInterface is the interface implemented by objects that manage service container parameters.
- TaggedContainerInterface
- TaggedContainerInterface is the interface implemented when a container knows how to deals with tags.
- ErrorEnhancerInterface
- ErrorRendererInterface
- Formats an exception to be used as response content.
- TraceableEventDispatcherInterface
- The EventDispatcherInterface is the central point of Symfony's event listener system.
- EventDispatcherInterface
- The EventDispatcherInterface is the central point of Symfony's event listener system.
- EventSubscriberInterface
- An EventSubscriber knows itself what events it is interested in.
- EventDispatcherInterface
- Allows providing hooks on domain-specific lifecycles by dispatching events.
- ExceptionInterface
- Exception interface for all exceptions thrown by the component.
- IOExceptionInterface
- IOException interface for file and input/output stream related exceptions thrown by the component.
- TemplateFinderInterface
- Interface for finding all the templates.
- RouteLoaderInterface
- Marker interface for service route loaders.
- EngineInterface
- EngineInterface is the interface each engine must implement.
- RequestExceptionInterface
- Interface for Request exceptions.
- ExtensionGuesserInterface
- Guesses the file extension corresponding to a given mime type.
- MimeTypeGuesserInterface
- Guesses the mime type of a file.
- RequestMatcherInterface
- RequestMatcherInterface is an interface for strategies to match a Request.
- AttributeBagInterface
- Attributes store.
- FlashBagInterface
- FlashBagInterface.
- SessionBagInterface
- Session Bag store.
- SessionInterface
- Interface for the session.
- SessionStorageInterface
- StorageInterface.
- BundleInterface
- BundleInterface.
- CacheClearerInterface
- CacheClearerInterface.
- CacheWarmerInterface
- Interface for classes able to warm up the cache.
- WarmableInterface
- Interface for classes that support warming their cache.
- ArgumentResolverInterface
- An ArgumentResolverInterface instance knows how to determine the arguments for a specific action.
- ArgumentValueResolverInterface
- Responsible for resolving the value of an argument based on its metadata.
- ControllerResolverInterface
- A ControllerResolverInterface implementation knows how to determine the controller to execute based on a Request object.
- ArgumentMetadataFactoryInterface
- Builds method argument data.
- DataCollectorInterface
- DataCollectorInterface.
- LateDataCollectorInterface
- LateDataCollectorInterface.
- HttpExceptionInterface
- Interface for HTTP error exceptions.
- FragmentRendererInterface
- Interface implemented by all rendering strategies.
- ResponseCacheStrategyInterface
- ResponseCacheStrategyInterface implementations know how to compute the Response cache HTTP header based on the different response cache headers.
- StoreInterface
- Interface implemented by HTTP cache stores.
- SurrogateInterface
- HttpKernelInterface
- HttpKernelInterface handles a Request to convert it to a Response.
- KernelInterface
- The Kernel is the heart of the Symfony system.
- DebugLoggerInterface
- DebugLoggerInterface.
- RebootableInterface
- Allows the Kernel to be rebooted using a temporary cache directory.
- TerminableInterface
- Terminable extends the Kernel request/response cycle with dispatching a post response event after sending the response and before shutting down the kernel.
- BodyRendererInterface
- AddressEncoderInterface
- ContentEncoderInterface
- EncoderInterface
- MimeHeaderEncoderInterface
- ExceptionInterface
- HeaderInterface
- A MIME Header.
- MimeTypeGuesserInterface
- Guesses the MIME type of a file.
- MimeTypesInterface
- Guesses the MIME type of a file.
- ExceptionInterface
- ExceptionInterface.
- ConfigurableRequirementsInterface
- 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.
- GeneratorDumperInterface
- GeneratorDumperInterface is the interface that all generator dumper classes must implement.
- UrlGeneratorInterface
- UrlGeneratorInterface is the interface that all URL generator classes must implement.
- MatcherDumperInterface
- MatcherDumperInterface is the interface that all matcher dumper classes must implement.
- RedirectableUrlMatcherInterface
- RedirectableUrlMatcherInterface knows how to redirect the user.
- RequestMatcherInterface
- RequestMatcherInterface is the interface that all request matcher classes must implement.
- UrlMatcherInterface
- UrlMatcherInterface is the interface that all URL matcher classes must implement.
- RequestContextAwareInterface
- RouteCompilerInterface
- RouteCompilerInterface is the interface that all RouteCompiler classes must implement.
- RouterInterface
- RouterInterface is the interface that all Router classes must implement.
- ResetInterface
- Provides a way to reset an object to its initial state.
- ServiceProviderInterface
- A ServiceProviderInterface exposes the identifiers and the types of services provided by a container.
- ServiceSubscriberInterface
- A ServiceSubscriber exposes its dependencies via the static {@link getSubscribedServices} method.
- OperationInterface
- Represents an operation on catalogue(s).
- DumperInterface
- DumperInterface is the interface implemented by all translation dumpers.
- ExceptionInterface
- Exception interface for all exceptions thrown by the component.
- ExtractorInterface
- Extracts translation messages from a directory or files to the catalogue.
- ChoiceMessageFormatterInterface
- IntlFormatterInterface
- Formats ICU message patterns.
- MessageFormatterInterface
- LoaderInterface
- LoaderInterface is the interface implemented by all translation loaders.
- MessageCatalogueInterface
- MessageCatalogueInterface.
- MetadataAwareInterface
- MetadataAwareInterface.
- TranslationReaderInterface
- TranslationReader reads translation messages from translation files.
- TranslatorBagInterface
- TranslatorBagInterface.
- TranslatorInterface
- TranslatorInterface.
- TranslationWriterInterface
- TranslationWriter writes translation messages.
- LocaleAwareInterface
- TranslatorInterface
- ClonerInterface
- DumperInterface
- DumperInterface used by Data objects.
- DumpDescriptorInterface
- ContextProviderInterface
- Interface to provide contextual data about dump data clones sent to a server.
- DataDumperInterface
- DataDumperInterface for dumping Data objects.
- ExceptionInterface
- ExceptionInterface
- ExceptionInterface
- MyApcu
- MyJwt
- Define abstraction layer for jwt token encode and decode
- SetupCache
- implement cache handler
- WidgetCache
- implement cache handler for widgets Fileaccess andromedas objects need a mighty cache abstraction layer, this class provides it
- CommandLineContext
- Context
- ContextManager
- FilesystemDateFilter
- BillServiceParent
- Class providing shared methods to implement bills and services
- Price
- VideoAsset
- Implement asset master object
- FilterCustom
- Search filter object This is the is a custom filter.
- FilterLike
- Define search filter
- FilterNotNull
- Define search filter
- FilterRange
- Define search filter
- HookArgument
- SwooleRequest
- Define common HTTP request object
- ImapDomain
- Class ImapDomain
- ImportContentParam
- ManifestContentHook
- TemplateController
- The template controller class
- ArrayTable
- AbstractPlugin
- AddThis
- Class AddThis.
- BackendManager
- Class BackendManager.
- Buffer
- Class Buffer.
- Class Facebook.
- Flattr
- Class Flattr.
- Class Pinterest.
- Class Reddit.
- Request
- Class Request.
- ServiceFactory
- Class ServiceFactory.
- StumbleUpon
- Class StumbleUpon.
- Vk
- Class Vk.
- Class Xing.
- Backend
- Class Backend.
- ZendCache
- Implement ZendCache.
- ComposerAutoloaderInitc2e05b3412b5b96739da81506749a3d1
- ComposerStaticInitc2e05b3412b5b96739da81506749a3d1
- ClassLoader
- ClassLoader implements a PSR-0, PSR-4 and classmap class loader.
- Client
- CookieJar
- Cookie jar that stores cookies as an array
- FileCookieJar
- Persists non-session cookies using a JSON formatted file
- SessionCookieJar
- Persists cookies in the client session
- SetCookie
- Set-Cookie object
- BadResponseException
- Exception when an HTTP error occurs (4xx or 5xx error)
- ClientException
- Exception when a client error is encountered (4xx codes)
- ConnectException
- Exception thrown when a connection cannot be established.
- RequestException
- HTTP Request exception
- SeekException
- Exception thrown when a seek fails on a stream.
- ServerException
- Exception when a server error is encountered (5xx codes)
- TooManyRedirectsException
- HTTP Request exception
- TransferException
- CurlFactory
- Creates curl resources from a request
- CurlHandler
- HTTP handler that uses cURL easy handles as a transport layer.
- CurlMultiHandler
- Returns an asynchronous response using curl_multi_* functions.
- MockHandler
- Handler that returns responses or throw exceptions from a queue.
- Proxy
- Provides basic proxies for handlers.
- StreamHandler
- HTTP handler that uses PHP's HTTP stream wrapper.
- HandlerStack
- Creates a composed Guzzle handler function by stacking middlewares on top of an HTTP handler function.
- MessageFormatter
- Formats log messages using variable substitutions for requests, responses, and other transactional data.
- Middleware
- Functions used to create and wrap handlers with handler middleware.
- Pool
- Sends and iterator of requests concurrently using a capped pool size.
- PrepareBodyMiddleware
- Prepares requests that contain a body, adding the Content-Length, Content-Type, and Expect headers.
- RedirectMiddleware
- Request redirect middleware.
- RequestOptions
- This class contains a list of built-in Guzzle request options.
- RetryMiddleware
- Middleware that retries requests based on the boolean result of invoking the provided "decider" function.
- TransferStats
- Represents data at the point after it was transferred either successfully or after a network error.
- UriTemplate
- Expands URI templates. Userland implementation of PECL uri_template.
- AggregateException
- Exception thrown when too many errors occur in the some() or any() methods.
- CancellationException
- Exception that is set as the reason for a promise that has been cancelled.
- Coroutine
- Creates a promise that is resolved using a generator that yields values or promises (somewhat similar to C#'s async keyword).
- EachPromise
- Represents a promise that iterates over many promises and invokes side-effect functions in the process.
- FulfilledPromise
- A promise that has been fulfilled.
- Promise
- Promises/A+ implementation that avoids recursion when possible.
- RejectedPromise
- A promise that has been rejected.
- RejectionException
- A special exception that is thrown when waiting on a rejected promise.
- TaskQueue
- A task queue that executes tasks in a FIFO order.
- AppendStream
- Reads from multiple streams, one after the other.
- BufferStream
- Provides a buffer stream that can be written to to fill a buffer, and read from to remove bytes from the buffer.
- CachingStream
- Stream decorator that can cache previously read bytes from a sequentially read stream.
- DroppingStream
- Stream decorator that begins dropping data once the size of the underlying stream becomes too full.
- FnStream
- Compose stream implementations based on a hash of functions.
- InflateStream
- Uses PHP's zlib.inflate filter to inflate deflate or gzipped content.
- LazyOpenStream
- Lazily reads or writes to a file that is opened only after an IO operation take place on the stream.
- LimitStream
- Decorator used to return only a subset of a stream
- MultipartStream
- Stream that when read returns bytes for a streaming multipart or multipart/form-data stream.
- NoSeekStream
- Stream decorator that prevents a stream from being seeked
- PumpStream
- Provides a read only stream that pumps data from a PHP callable.
- Request
- PSR-7 request implementation.
- Response
- PSR-7 response implementation.
- Rfc7230
- ServerRequest
- Server-side HTTP request
- Stream
- PHP stream implementation.
- StreamWrapper
- Converts Guzzle streams into PHP stream resources.
- UploadedFile
- Uri
- PSR-7 URI implementation.
- UriNormalizer
- Provides methods to normalize and compare URIs.
- UriResolver
- Resolves a URI reference in the context of a base URI and the opposite way.
- AbstractLogger
- This is a simple Logger implementation that other Loggers can inherit from.
- InvalidArgumentException
- LogLevel
- Describes log levels.
- NullLogger
- This Logger can be used to avoid conditional log calls.
- LoggerInterfaceTest
- Provides a base test class for ensuring compliance with the LoggerInterface.
- DummyTest
- TestLogger
- Used for testing purposes.
- GetAllHeadersTest
- ConfigProvider
- BadMethodCallException
- ExtensionNotLoadedException
- InvalidArgumentException
- LogicException
- MissingDependencyException
- MissingKeyException
- OutOfSpaceException
- RuntimeException
- UnexpectedValueException
- UnsupportedMethodCallException
- Module
- AbstractPattern
- CallbackCache
- CaptureCache
- ClassCache
- ObjectCache
- OutputCache
- PatternOptions
- PatternFactory
- PatternPluginManagerV2Polyfill
- zend-servicemanager v2-compatible plugin manager implementation for cache pattern adapters.
- PatternPluginManagerV3Polyfill
- zend-servicemanager v3-compatible plugin manager implementation for cache pattern adapters.
- CacheException
- CacheItem
- CacheItemPoolDecorator
- Decorate zend-cache adapters as PSR-6 cache item pools.
- InvalidArgumentException
- SimpleCacheDecorator
- Decorate a zend-cache storage adapter for usage as a PSR-16 implementation.
- SimpleCacheException
- SimpleCacheInvalidArgumentException
- PatternPluginManagerFactory
- StorageAdapterPluginManagerFactory
- StorageCacheAbstractServiceFactory
- Storage cache factory for multiple caches.
- StorageCacheFactory
- Storage cache factory.
- StoragePluginManagerFactory
- AbstractAdapter
- AbstractZendServer
- AdapterOptions
- Unless otherwise marked, all options in this class affect all adapters.
- Apc
- ApcIterator
- ApcOptions
- These are options specific to the APC adapter
- Apcu
- ApcuIterator
- ApcuOptions
- These are options specific to the APCu adapter
- BlackHole
- Dba
- DbaIterator
- DbaOptions
- These are options specific to the APC adapter
- ExtMongoDb
- Cache storage adapter for ext-mongodb
- ExtMongoDbOptions
- Options for the ext-mongodb adapter implementation.
- ExtMongoDbResourceManager
- Resource manager for the ext-mongodb adapter.
- Filesystem
- FilesystemIterator
- FilesystemOptions
- These are options specific to the Filesystem adapter
- KeyListIterator
- Memcache
- Memcached
- MemcachedOptions
- These are options specific to the Memcached adapter
- MemcachedResourceManager
- This is a resource manager for memcached
- MemcacheOptions
- These are options specific to the Memcache adapter
- MemcacheResourceManager
- This is a resource manager for memcache
- Memory
- MemoryOptions
- These are options specific to the APC adapter
- MongoDb
- MongoDbOptions
- Unless otherwise marked, all options in this class affect all adapters.
- MongoDbResourceManager
- Redis
- RedisOptions
- Unless otherwise marked, all options in this class affect all adapters.
- RedisResourceManager
- This is a resource manager for redis
- Session
- SessionOptions
- These are options specific to the APC adapter
- WinCache
- WinCacheOptions
- These are options specific to the APC adapter
- XCache
- XCacheOptions
- These are options specific to the XCache adapter
- ZendServerDisk
- ZendServerShm
- AdapterPluginManager
- Plugin manager implementation for cache storage adapters
- Capabilities
- Event
- Representation of an event
- ExceptionEvent
- Representation of an event
- AbstractPlugin
- Abstract aggregate listener
- ClearExpiredByFactor
- Abstract aggregate listener
- ExceptionHandler
- Abstract aggregate listener
- IgnoreUserAbort
- Abstract aggregate listener
- OptimizeByFactor
- Abstract aggregate listener
- PluginOptions
- Serializer
- Abstract aggregate listener
- PluginManager
- Plugin manager implementation for cache plugins
- PostEvent
- Representation of an event
- StorageFactory
- AbstractListenerAggregate
- Abstract aggregate listener
- Event
- Representation of an event
- EventManager
- Event manager: notification system
- DomainException
- InvalidArgumentException
- Invalid argument exception
- InvalidCallbackException
- Invalid callback exception
- RuntimeException
- FilterIterator
- Specialized priority queue implementation for use with an intercepting filter chain.
- FilterChain
- FilterChain: intercepting filter manager
- LazyEventListener
- Lazy listener instance for use with LazyListenerAggregate.
- LazyListener
- Lazy listener instance.
- LazyListenerAggregate
- Aggregate listener for attaching lazy listeners.
- ResponseCollection
- Collection of signal handler return values
- SharedEventManager
- Shared/contextual EventManager
- ConfigAbstractFactory
- ReflectionBasedAbstractFactory
- Reflection-based factory.
- AbstractPluginManager
- Abstract plugin manager.
- Config
- Object for defining configuration and configuring an existing service manager instance.
- ContainerModificationsNotAllowedException
- CyclicAliasException
- InvalidArgumentException
- InvalidServiceException
- This exception is thrown by plugin managers when the created object does not match the plugin manager's conditions
- ServiceNotCreatedException
- This exception is thrown when the service locator do not manage to create the service (factory that has an error...)
- ServiceNotFoundException
- This exception is thrown when the service locator do not manage to find a valid factory to create a service
- InvokableFactory
- Factory for instantiating classes with no dependencies or which accept a single array.
- LazyServiceFactory
- Delegator factory responsible of instantiating lazy loading value holder proxies of given services at runtime
- ServiceManager
- Service Manager.
- ConfigDumper
- ConfigDumperCommand
- FactoryCreator
- FactoryCreatorCommand
- AbstractOptions
- ArrayObject
- Custom framework ArrayObject implementation
- ArrayStack
- ArrayObject that acts as a stack with regards to iteration
- MergeRemoveKey
- MergeReplaceKey
- ArrayUtils
- Utility class for testing and manipulation of PHP arrays.
- ConsoleHelper
- Utilities for console tooling.
- ErrorHandler
- ErrorHandler that can be used to catch internal PHP errors and convert to an ErrorException instance.
- BadMethodCallException
- Bad method call exception
- DomainException
- Domain exception
- ExtensionNotLoadedException
- Extension not loaded exception
- InvalidArgumentException
- Invalid Argument Exception
- LogicException
- Logic exception
- RuntimeException
- Runtime exception
- FastPriorityQueue
- This is an efficient implementation of an integer priority queue in PHP
- Glob
- Wrapper for glob with fallback if GLOB_BRACE is not available.
- Message
- Parameters
- PriorityList
- PriorityQueue
- Re-usable, serializable priority queue implementation
- Request
- Response
- SplPriorityQueue
- Serializable version of SplPriorityQueue
- SplQueue
- Serializable version of SplQueue
- SplStack
- Serializable version of SplStack
- StringUtils
- Utility class for handling strings of different character encodings using available PHP extensions.
- AbstractStringWrapper
- Iconv
- Intl
- MbString
- Native
- ShariffCache
- Implement cache handler
- IndexTask
- Status
- FixedBitNotation
- FixedBitNotation.
- GoogleAuthenticatorLib
- RuntimeException
- Contains runtime exception templates.
- TrelloCurl
- Vimeo
- Copyright 2013 Vimeo
- AbstractCache
- ApcuStore
- CacheFactory
- FileStore
- RedisStore
- ExpirationCommand
- Base class for all commands.
- Config
- TusEvent
- UploadComplete
- UploadCreated
- UploadMerged
- UploadProgress
- ConnectionException
- FileException
- OutOfRangeException
- TusException
- File
- Cors
- GlobalHeaders
- Middleware
- Request
- Response
- AbstractTus
- Client
- Server
- BigDecimal
- Immutable, arbitrary-precision signed decimal numbers.
- BigInteger
- An arbitrary-size integer.
- BigNumber
- Common interface for arbitrary-precision rational numbers.
- BigRational
- An arbitrarily large rational number.
- DivisionByZeroException
- Exception thrown when a division by zero occurs.
- IntegerOverflowException
- Exception thrown when an integer overflow occurs.
- MathException
- Base class for all math exceptions.
- NegativeNumberException
- Exception thrown when attempting to perform an unsupported operation, such as a square root, on a negative number.
- NumberFormatException
- Exception thrown when attempting to create a number from a string with an invalid format.
- RoundingNecessaryException
- Exception thrown when a number cannot be represented at the requested scale without rounding.
- RoundingMode
- Specifies a rounding behavior for numerical operations capable of discarding precision.
- ComposerAutoloaderInit94a925f1e94190dddeabac0607d3aa7a
- ComposerStaticInit94a925f1e94190dddeabac0607d3aa7a
- ClassLoader
- ClassLoader implements a PSR-0, PSR-4 and classmap class loader.
- Client
- CookieJar
- Cookie jar that stores cookies as an array
- FileCookieJar
- Persists non-session cookies using a JSON formatted file
- SessionCookieJar
- Persists cookies in the client session
- SetCookie
- Set-Cookie object
- BadResponseException
- Exception when an HTTP error occurs (4xx or 5xx error)
- ClientException
- Exception when a client error is encountered (4xx codes)
- ConnectException
- Exception thrown when a connection cannot be established.
- InvalidArgumentException
- RequestException
- HTTP Request exception
- SeekException
- Exception thrown when a seek fails on a stream.
- ServerException
- Exception when a server error is encountered (5xx codes)
- TooManyRedirectsException
- HTTP Request exception
- TransferException
- CurlFactory
- Creates curl resources from a request
- CurlHandler
- HTTP handler that uses cURL easy handles as a transport layer.
- CurlMultiHandler
- Returns an asynchronous response using curl_multi_* functions.
- MockHandler
- Handler that returns responses or throw exceptions from a queue.
- Proxy
- Provides basic proxies for handlers.
- StreamHandler
- HTTP handler that uses PHP's HTTP stream wrapper.
- HandlerStack
- Creates a composed Guzzle handler function by stacking middlewares on top of an HTTP handler function.
- MessageFormatter
- Formats log messages using variable substitutions for requests, responses, and other transactional data.
- Middleware
- Functions used to create and wrap handlers with handler middleware.
- Pool
- Sends an iterator of requests concurrently using a capped pool size.
- PrepareBodyMiddleware
- Prepares requests that contain a body, adding the Content-Length, Content-Type, and Expect headers.
- RedirectMiddleware
- Request redirect middleware.
- RequestOptions
- This class contains a list of built-in Guzzle request options.
- RetryMiddleware
- Middleware that retries requests based on the boolean result of invoking the provided "decider" function.
- TransferStats
- Represents data at the point after it was transferred either successfully or after a network error.
- UriTemplate
- Expands URI templates. Userland implementation of PECL uri_template.
- Utils
- AggregateException
- Exception thrown when too many errors occur in the some() or any() methods.
- CancellationException
- Exception that is set as the reason for a promise that has been cancelled.
- Coroutine
- Creates a promise that is resolved using a generator that yields values or promises (somewhat similar to C#'s async keyword).
- EachPromise
- Represents a promise that iterates over many promises and invokes side-effect functions in the process.
- FulfilledPromise
- A promise that has been fulfilled.
- Promise
- Promises/A+ implementation that avoids recursion when possible.
- RejectedPromise
- A promise that has been rejected.
- RejectionException
- A special exception that is thrown when waiting on a rejected promise.
- TaskQueue
- A task queue that executes tasks in a FIFO order.
- AppendStream
- Reads from multiple streams, one after the other.
- BufferStream
- Provides a buffer stream that can be written to to fill a buffer, and read from to remove bytes from the buffer.
- CachingStream
- Stream decorator that can cache previously read bytes from a sequentially read stream.
- DroppingStream
- Stream decorator that begins dropping data once the size of the underlying stream becomes too full.
- FnStream
- Compose stream implementations based on a hash of functions.
- InflateStream
- Uses PHP's zlib.inflate filter to inflate deflate or gzipped content.
- LazyOpenStream
- Lazily reads or writes to a file that is opened only after an IO operation take place on the stream.
- LimitStream
- Decorator used to return only a subset of a stream
- MultipartStream
- Stream that when read returns bytes for a streaming multipart or multipart/form-data stream.
- NoSeekStream
- Stream decorator that prevents a stream from being seeked
- PumpStream
- Provides a read only stream that pumps data from a PHP callable.
- Request
- PSR-7 request implementation.
- Response
- PSR-7 response implementation.
- Rfc7230
- ServerRequest
- Server-side HTTP request
- Stream
- PHP stream implementation.
- StreamWrapper
- Converts Guzzle streams into PHP stream resources.
- UploadedFile
- Uri
- PSR-7 URI implementation.
- UriNormalizer
- Provides methods to normalize and compare URIs.
- UriResolver
- Resolves a URI reference in the context of a base URI and the opposite way.
- Carbon
- A simple API extension for DateTime.
- CarbonImmutable
- A simple API extension for DateTimeImmutable.
- CarbonInterval
- A simple API extension for DateInterval.
- CarbonPeriod
- Substitution of DatePeriod with some modifications and many more features.
- CarbonTimeZone
- Invoker
- CarbonImmutableType
- CarbonType
- DateTimeDefaultPrecision
- DateTimeImmutableType
- DateTimeType
- BadComparisonUnitException
- BadFluentConstructorException
- BadFluentSetterException
- ImmutableException
- InvalidCastException
- InvalidDateException
- InvalidFormatException
- InvalidIntervalException
- InvalidPeriodDateException
- InvalidPeriodParameterException
- InvalidTimeZoneException
- InvalidTypeException
- NotACarbonClassException
- NotAPeriodException
- NotLocaleAwareException
- OutOfRangeException
- ParseErrorException
- UnitException
- UnitNotConfiguredException
- UnknownGetterException
- UnknownMethodException
- UnknownSetterException
- UnknownUnitException
- UnreachableException
- Factory
- A factory to generate Carbon instances with common settings.
- FactoryImmutable
- A factory to generate CarbonImmutable instances with common settings.
- Language
- ServiceProvider
- Translator
- NaiveDistributor
- SimpleDebuggableConnection
- Standard connection to Redis servers implemented on top of PHP's streams.
- EventsListener
- IncrementExistingKeysBy
- Base class used to implement an higher level abstraction for commands based on Lua scripting with EVAL and EVALSHA.
- HashMultipleGetAll
- Base class used to implement an higher level abstraction for commands based on Lua scripting with EVAL and EVALSHA.
- Autoloader
- Implements a lightweight PSR-0 compliant autoloader for Predis.
- Client
- Client class used for connecting and executing commands on Redis.
- ClientException
- Exception class that identifies client-side errors.
- ClusterStrategy
- Common class implementing the logic needed to support clustering strategies.
- EmptyRingException
- Exception class that identifies empty rings.
- HashRing
- This class implements an hashring-based distributor that uses the same algorithm of memcache to distribute keys in a cluster using client-side sharding.
- KetamaRing
- This class implements an hashring-based distributor that uses the same algorithm of libketama to distribute keys in a cluster using client-side sharding.
- CRC16
- Hash generator implementing the CRC-CCITT-16 algorithm used by redis-cluster.
- PredisStrategy
- Default cluster strategy used by Predis to handle client-side sharding.
- RedisStrategy
- Default class used by Predis to calculate hashes out of keys of commands supported by redis-cluster.
- CursorBasedIterator
- Provides the base implementation for a fully-rewindable PHP iterator that can incrementally iterate over cursor-based collections stored on Redis using the commands in the `SCAN` family.
- HashKey
- Abstracts the iteration of fields and values of an hash by leveraging the HSCAN command (Redis >= 2.8) wrapped in a fully-rewindable PHP iterator.
- Keyspace
- Abstracts the iteration of the keyspace on a Redis instance by leveraging the SCAN command (Redis >= 2.8) wrapped in a fully-rewindable PHP iterator.
- ListKey
- Abstracts the iteration of items stored in a list by leveraging the LRANGE command wrapped in a fully-rewindable PHP iterator.
- SetKey
- Abstracts the iteration of members stored in a set by leveraging the SSCAN command (Redis >= 2.8) wrapped in a fully-rewindable PHP iterator.
- SortedSetKey
- Abstracts the iteration of members stored in a sorted set by leveraging the ZSCAN command (Redis >= 2.8) wrapped in a fully-rewindable PHP iterator.
- Command
- Base class for Redis commands.
- ConnectionAuth
- Base class for Redis commands.
- ConnectionEcho
- Base class for Redis commands.
- ConnectionPing
- Base class for Redis commands.
- ConnectionQuit
- Base class for Redis commands.
- ConnectionSelect
- Base class for Redis commands.
- GeospatialGeoAdd
- Base class for Redis commands.
- GeospatialGeoDist
- Base class for Redis commands.
- GeospatialGeoHash
- Base class for Redis commands.
- GeospatialGeoPos
- Base class for Redis commands.
- GeospatialGeoRadius
- Base class for Redis commands.
- GeospatialGeoRadiusByMember
- Base class for Redis commands.
- HashDelete
- Base class for Redis commands.
- HashExists
- Base class for Redis commands.
- HashGet
- Base class for Redis commands.
- HashGetAll
- Base class for Redis commands.
- HashGetMultiple
- Base class for Redis commands.
- HashIncrementBy
- Base class for Redis commands.
- HashIncrementByFloat
- Base class for Redis commands.
- HashKeys
- Base class for Redis commands.
- HashLength
- Base class for Redis commands.
- HashScan
- Base class for Redis commands.
- HashSet
- Base class for Redis commands.
- HashSetMultiple
- Base class for Redis commands.
- HashSetPreserve
- Base class for Redis commands.
- HashStringLength
- Base class for Redis commands.
- HashValues
- Base class for Redis commands.
- HyperLogLogAdd
- Base class for Redis commands.
- HyperLogLogCount
- Base class for Redis commands.
- HyperLogLogMerge
- Base class for Redis commands.
- KeyDelete
- Base class for Redis commands.
- KeyDump
- Base class for Redis commands.
- KeyExists
- Base class for Redis commands.
- KeyExpire
- Base class for Redis commands.
- KeyExpireAt
- Base class for Redis commands.
- KeyKeys
- Base class for Redis commands.
- KeyMigrate
- Base class for Redis commands.
- KeyMove
- Base class for Redis commands.
- KeyPersist
- Base class for Redis commands.
- KeyPreciseExpire
- Base class for Redis commands.
- KeyPreciseExpireAt
- Base class for Redis commands.
- KeyPreciseTimeToLive
- Base class for Redis commands.
- KeyRandom
- Base class for Redis commands.
- KeyRename
- Base class for Redis commands.
- KeyRenamePreserve
- Base class for Redis commands.
- KeyRestore
- Base class for Redis commands.
- KeyScan
- Base class for Redis commands.
- KeySort
- Base class for Redis commands.
- KeyTimeToLive
- Base class for Redis commands.
- KeyType
- Base class for Redis commands.
- ListIndex
- Base class for Redis commands.
- ListInsert
- Base class for Redis commands.
- ListLength
- Base class for Redis commands.
- ListPopFirst
- Base class for Redis commands.
- ListPopFirstBlocking
- Base class for Redis commands.
- ListPopLast
- Base class for Redis commands.
- ListPopLastBlocking
- Base class for Redis commands.
- ListPopLastPushHead
- Base class for Redis commands.
- ListPopLastPushHeadBlocking
- Base class for Redis commands.
- ListPushHead
- Base class for Redis commands.
- ListPushHeadX
- Base class for Redis commands.
- ListPushTail
- Base class for Redis commands.
- ListPushTailX
- Base class for Redis commands.
- ListRange
- Base class for Redis commands.
- ListRemove
- Base class for Redis commands.
- ListSet
- Base class for Redis commands.
- ListTrim
- Base class for Redis commands.
- KeyPrefixProcessor
- Command processor capable of prefixing keys stored in the arguments of Redis commands supported.
- ProcessorChain
- Default implementation of a command processors chain.
- PubSubPublish
- Base class for Redis commands.
- PubSubPubsub
- Base class for Redis commands.
- PubSubSubscribe
- Base class for Redis commands.
- PubSubSubscribeByPattern
- Base class for Redis commands.
- PubSubUnsubscribe
- Base class for Redis commands.
- PubSubUnsubscribeByPattern
- Base class for Redis commands.
- RawCommand
- Class for generic "anonymous" Redis commands.
- ScriptCommand
- Base class used to implement an higher level abstraction for commands based on Lua scripting with EVAL and EVALSHA.
- ServerBackgroundRewriteAOF
- Base class for Redis commands.
- ServerBackgroundSave
- Base class for Redis commands.
- ServerClient
- Base class for Redis commands.
- ServerCommand
- Base class for Redis commands.
- ServerConfig
- Base class for Redis commands.
- ServerDatabaseSize
- Base class for Redis commands.
- ServerEval
- Base class for Redis commands.
- ServerEvalSHA
- Base class for Redis commands.
- ServerFlushAll
- Base class for Redis commands.
- ServerFlushDatabase
- Base class for Redis commands.
- ServerInfo
- Base class for Redis commands.
- ServerInfoV26x
- Base class for Redis commands.
- ServerLastSave
- Base class for Redis commands.
- ServerMonitor
- Base class for Redis commands.
- ServerObject
- Base class for Redis commands.
- ServerSave
- Base class for Redis commands.
- ServerScript
- Base class for Redis commands.
- ServerSentinel
- Base class for Redis commands.
- ServerShutdown
- Base class for Redis commands.
- ServerSlaveOf
- Base class for Redis commands.
- ServerSlowlog
- Base class for Redis commands.
- ServerTime
- Base class for Redis commands.
- SetAdd
- Base class for Redis commands.
- SetCardinality
- Base class for Redis commands.
- SetDifference
- Base class for Redis commands.
- SetDifferenceStore
- Base class for Redis commands.
- SetIntersection
- Base class for Redis commands.
- SetIntersectionStore
- Base class for Redis commands.
- SetIsMember
- Base class for Redis commands.
- SetMembers
- Base class for Redis commands.
- SetMove
- Base class for Redis commands.
- SetPop
- Base class for Redis commands.
- SetRandomMember
- Base class for Redis commands.
- SetRemove
- Base class for Redis commands.
- SetScan
- Base class for Redis commands.
- SetUnion
- Base class for Redis commands.
- SetUnionStore
- Base class for Redis commands.
- StringAppend
- Base class for Redis commands.
- StringBitCount
- Base class for Redis commands.
- StringBitField
- Base class for Redis commands.
- StringBitOp
- Base class for Redis commands.
- StringBitPos
- Base class for Redis commands.
- StringDecrement
- Base class for Redis commands.
- StringDecrementBy
- Base class for Redis commands.
- StringGet
- Base class for Redis commands.
- StringGetBit
- Base class for Redis commands.
- StringGetMultiple
- Base class for Redis commands.
- StringGetRange
- Base class for Redis commands.
- StringGetSet
- Base class for Redis commands.
- StringIncrement
- Base class for Redis commands.
- StringIncrementBy
- Base class for Redis commands.
- StringIncrementByFloat
- Base class for Redis commands.
- StringPreciseSetExpire
- Base class for Redis commands.
- StringSet
- Base class for Redis commands.
- StringSetBit
- Base class for Redis commands.
- StringSetExpire
- Base class for Redis commands.
- StringSetMultiple
- Base class for Redis commands.
- StringSetMultiplePreserve
- Base class for Redis commands.
- StringSetPreserve
- Base class for Redis commands.
- StringSetRange
- Base class for Redis commands.
- StringStrlen
- Base class for Redis commands.
- StringSubstr
- Base class for Redis commands.
- TransactionDiscard
- Base class for Redis commands.
- TransactionExec
- Base class for Redis commands.
- TransactionMulti
- Base class for Redis commands.
- TransactionUnwatch
- Base class for Redis commands.
- TransactionWatch
- Base class for Redis commands.
- ZSetAdd
- Base class for Redis commands.
- ZSetCardinality
- Base class for Redis commands.
- ZSetCount
- Base class for Redis commands.
- ZSetIncrementBy
- Base class for Redis commands.
- ZSetIntersectionStore
- Base class for Redis commands.
- ZSetLexCount
- Base class for Redis commands.
- ZSetRange
- Base class for Redis commands.
- ZSetRangeByLex
- Base class for Redis commands.
- ZSetRangeByScore
- Base class for Redis commands.
- ZSetRank
- Base class for Redis commands.
- ZSetRemove
- Base class for Redis commands.
- ZSetRemoveRangeByLex
- Base class for Redis commands.
- ZSetRemoveRangeByRank
- Base class for Redis commands.
- ZSetRemoveRangeByScore
- Base class for Redis commands.
- ZSetReverseRange
- Base class for Redis commands.
- ZSetReverseRangeByLex
- Base class for Redis commands.
- ZSetReverseRangeByScore
- Base class for Redis commands.
- ZSetReverseRank
- Base class for Redis commands.
- ZSetScan
- Base class for Redis commands.
- ZSetScore
- Base class for Redis commands.
- ZSetUnionStore
- Base class for Redis commands.
- CommunicationException
- Base exception class for network-related errors.
- ClusterOption
- Configures an aggregate connection used for clustering multiple Redis nodes using various implementations with different algorithms or strategies.
- ConnectionFactoryOption
- Configures a connection factory used by the client to create new connection instances for single Redis nodes.
- ExceptionsOption
- Configures whether consumers (such as the client) should throw exceptions on Redis errors (-ERR responses) or just return instances of error responses.
- Options
- Manages Predis options with filtering, conversion and lazy initialization of values using a mini-DI container approach.
- PrefixOption
- Configures a command processor that apply the specified prefix string to a series of Redis commands considered prefixable.
- ProfileOption
- Configures the server profile to be used by the client to create command instances depending on the specified version of the Redis server.
- ReplicationOption
- Configures an aggregate connection used for master/slave replication among multiple Redis nodes.
- AbstractConnection
- Base class with the common logic used by connection classes to communicate with Redis.
- MasterSlaveReplication
- Aggregate connection handling replication of Redis nodes configured in a single master / multiple slaves setup.
- PredisCluster
- Abstraction for a cluster of aggregate connections to various Redis servers implementing client-side sharding based on pluggable distribution strategies.
- RedisCluster
- Abstraction for a Redis-backed cluster of nodes (Redis >= 3.0.0).
- SentinelReplication
- CompositeStreamConnection
- Connection abstraction to Redis servers based on PHP's stream that uses an external protocol processor defining the protocol used for the communication.
- ConnectionException
- Exception class that identifies connection-related errors.
- Factory
- Standard connection factory for creating connections to Redis nodes.
- Parameters
- Container for connection parameters used to initialize connections to Redis.
- PhpiredisSocketConnection
- This class provides the implementation of a Predis connection that uses the PHP socket extension for network communication and wraps the phpiredis C extension (PHP bindings for hiredis) to parse the Redis protocol.
- PhpiredisStreamConnection
- This class provides the implementation of a Predis connection that uses PHP's streams for network communication and wraps the phpiredis C extension (PHP bindings for hiredis) to parse and serialize the Redis protocol.
- StreamConnection
- Standard connection to Redis servers implemented on top of PHP's streams.
- WebdisConnection
- This class implements a Predis connection that actually talks with Webdis instead of connecting directly to Redis. It relies on the cURL extension to communicate with the web server and the phpiredis extension to parse the protocol for responses returned in the http response bodies.
- Consumer
- Redis MONITOR consumer.
- NotSupportedException
- Exception class thrown when trying to use features not supported by certain classes or abstractions of Predis.
- Atomic
- Command pipeline wrapped into a MULTI / EXEC transaction.
- ConnectionErrorProof
- Command pipeline that does not throw exceptions on connection errors, but returns the exception instances as the rest of the response elements.
- FireAndForget
- Command pipeline that writes commands to the servers but discards responses.
- Pipeline
- Implementation of a command pipeline in which write and read operations of Redis commands are pipelined to alleviate the effects of network round-trips.
- PredisException
- Base exception class for Predis-related errors.
- Factory
- Factory class for creating profile instances from strings.
- RedisProfile
- Base class implementing common functionalities for Redis server profiles.
- RedisUnstable
- Server profile for the current unstable version of Redis.
- RedisVersion200
- Server profile for Redis 2.0.
- RedisVersion220
- Server profile for Redis 2.2.
- RedisVersion240
- Server profile for Redis 2.4.
- RedisVersion260
- Server profile for Redis 2.6.
- RedisVersion280
- Server profile for Redis 2.8.
- RedisVersion300
- Server profile for Redis 3.0.
- RedisVersion320
- Server profile for Redis 3.0.
- ProtocolException
- Exception used to indentify errors encountered while parsing the Redis wire protocol.
- CompositeProtocolProcessor
- Composite protocol processor for the standard Redis wire protocol using pluggable handlers to serialize requests and deserialize responses.
- BulkResponse
- Handler for the bulk response type in the standard Redis wire protocol.
- ErrorResponse
- Handler for the error response type in the standard Redis wire protocol.
- IntegerResponse
- Handler for the integer response type in the standard Redis wire protocol.
- MultiBulkResponse
- Handler for the multibulk response type in the standard Redis wire protocol.
- StatusResponse
- Handler for the status response type in the standard Redis wire protocol. It translates certain classes of status response to PHP objects or just returns the payload as a string.
- StreamableMultiBulkResponse
- Handler for the multibulk response type in the standard Redis wire protocol.
- ProtocolProcessor
- Protocol processor for the standard Redis wire protocol.
- RequestSerializer
- Request serializer for the standard Redis wire protocol.
- ResponseReader
- Response reader for the standard Redis wire protocol.
- AbstractConsumer
- Base implementation of a PUB/SUB consumer abstraction based on PHP iterators.
- Consumer
- PUB/SUB consumer abstraction.
- DispatcherLoop
- Method-dispatcher loop built around the client-side abstraction of a Redis PUB / SUB context.
- MissingMasterException
- Exception class that identifies when master is missing in a replication setup.
- ReplicationStrategy
- Defines a strategy for master/slave replication.
- RoleException
- Exception class that identifies a role mismatch when connecting to node managed by redis-sentinel.
- Error
- Represents an error returned by Redis (-ERR responses) during the execution of a command on the server.
- MultiBulk
- Streamable multibulk response.
- MultiBulkIterator
- Iterator that abstracts the access to multibulk responses allowing them to be consumed in a streamable fashion without keeping the whole payload in memory.
- MultiBulkTuple
- Outer iterator consuming streamable multibulk responses by yielding tuples of keys and values.
- ServerException
- Exception class that identifies server-side Redis errors.
- Status
- Represents a status response returned by Redis.
- Handler
- Session handler class that relies on Predis\Client to store PHP's sessions data into one or multiple Redis servers.
- AbortedMultiExecException
- Exception class that identifies a MULTI / EXEC transaction aborted by Redis.
- MultiExec
- Client-side abstraction of a Redis transaction based on MULTI / EXEC.
- MultiExecState
- Utility class used to track the state of a MULTI / EXEC transaction.
- AbstractLogger
- This is a simple Logger implementation that other Loggers can inherit from.
- InvalidArgumentException
- LogLevel
- Describes log levels.
- NullLogger
- This Logger can be used to avoid conditional log calls.
- LoggerInterfaceTest
- Provides a base test class for ensuring compliance with the LoggerInterface.
- TestLogger
- Used for testing purposes.
- AbstractArray
- This class provides a basic implementation of `ArrayInterface`, to minimize the effort required to implement this interface.
- AbstractCollection
- This class provides a basic implementation of `CollectionInterface`, to minimize the effort required to implement this interface
- AbstractSet
- This class contains the basic implementation of a collection that does not allow duplicated values (a set), to minimize the effort required to implement this specific type of collection.
- Collection
- A collection represents a group of objects.
- DoubleEndedQueue
- This class provides a basic implementation of `DoubleEndedQueueInterface`, to minimize the effort required to implement this interface.
- CollectionMismatchException
- Thrown when attempting to operate on collections of differing types.
- InvalidArgumentException
- Thrown to indicate an argument is not of the expected type.
- InvalidSortOrderException
- Thrown when attempting to use a sort order that is not recognized.
- NoSuchElementException
- Thrown when attempting to access an element that does not exist.
- OutOfBoundsException
- Thrown when attempting to access an element out of the range of the collection.
- UnsupportedOperationException
- Thrown to indicate that the requested operation is not supported.
- ValueExtractionException
- Thrown when attempting to extract a value for a method or property that does not exist.
- GenericArray
- `GenericArray` represents a standard array object.
- AbstractMap
- This class provides a basic implementation of `MapInterface`, to minimize the effort required to implement this interface.
- AbstractTypedMap
- This class provides a basic implementation of `TypedMapInterface`, to minimize the effort required to implement this interface.
- AssociativeArrayMap
- `AssociativeArrayMap` represents a standard associative array object.
- TypedMap
- A `TypedMap` represents a map of elements where key and value are typed.
- Queue
- This class provides a basic implementation of `QueueInterface`, to minimize the effort required to implement this interface.
- Set
- A set is a collection that contains no duplicate elements.
- BinaryUtils
- Provides binary math utilities
- BuilderCollection
- A collection of UuidBuilderInterface objects
- DefaultUuidBuilder
- UuidBuilder builds instances of RFC 4122 UUIDs
- DegradedUuidBuilder
- FallbackBuilder
- FallbackBuilder builds a UUID by stepping through a list of UUID builders until a UUID can be constructed without exceptions
- GuidStringCodec
- GuidStringCodec encodes and decodes globally unique identifiers (GUID)
- OrderedTimeCodec
- OrderedTimeCodec encodes and decodes a UUID, optimizing the byte order for more efficient storage
- StringCodec
- StringCodec encodes and decodes RFC 4122 UUIDs
- TimestampFirstCombCodec
- TimestampFirstCombCodec encodes and decodes COMBs, with the timestamp as the first 48 bits
- TimestampLastCombCodec
- TimestampLastCombCodec encodes and decodes COMBs, with the timestamp as the last 48 bits
- BigNumberConverter
- Previously used to integrate moontoast/math as a bignum arithmetic library, BigNumberConverter is deprecated in favor of GenericNumberConverter
- DegradedNumberConverter
- Previously used to integrate moontoast/math as a bignum arithmetic library, BigNumberConverter is deprecated in favor of GenericNumberConverter
- GenericNumberConverter
- GenericNumberConverter uses the provided calculate to convert decimal numbers to and from hexadecimal values
- BigNumberTimeConverter
- Previously used to integrate moontoast/math as a bignum arithmetic library, BigNumberTimeConverter is deprecated in favor of GenericTimeConverter
- DegradedTimeConverter
- Previously used to integrate moontoast/math as a bignum arithmetic library, BigNumberTimeConverter is deprecated in favor of GenericTimeConverter
- GenericTimeConverter
- GenericTimeConverter uses the provided calculator to calculate and convert time values
- PhpTimeConverter
- PhpTimeConverter uses built-in PHP functions and standard math operations available to the PHP programming language to provide facilities for converting parts of time into representations that may be used in UUIDs
- DegradedUuid
- Uuid provides constants and static methods for working with and generating UUIDs
- BuilderNotFoundException
- Thrown to indicate that no suitable builder could be found
- DateTimeException
- Thrown to indicate that the PHP DateTime extension encountered an exception/error
- DceSecurityException
- Thrown to indicate an exception occurred while dealing with DCE Security (version 2) UUIDs
- InvalidArgumentException
- Thrown to indicate that the argument received is not valid
- InvalidBytesException
- Thrown to indicate that the bytes being operated on are invalid in some way
- InvalidUuidStringException
- Thrown to indicate that the string received is not a valid UUID
- NameException
- Thrown to indicate that an error occurred while attempting to hash a namespace and name
- NodeException
- Thrown to indicate that attempting to fetch or create a node ID encountered an error
- RandomSourceException
- Thrown to indicate that the source of random data encountered an error
- TimeSourceException
- Thrown to indicate that the source of time encountered an error
- UnableToBuildUuidException
- Thrown to indicate a builder is unable to build a UUID
- UnsupportedOperationException
- Thrown to indicate that the requested operation is not supported
- FeatureSet
- FeatureSet detects and exposes available features in the current environment
- CombGenerator
- CombGenerator generates COMBs (combined UUID/timestamp)
- DceSecurityGenerator
- DceSecurityGenerator generates strings of binary data based on a local domain, local identifier, node ID, clock sequence, and the current time
- DefaultNameGenerator
- DefaultNameGenerator generates strings of binary data based on a namespace, name, and hashing algorithm
- DefaultTimeGenerator
- DefaultTimeGenerator generates strings of binary data based on a node ID, clock sequence, and the current time
- NameGeneratorFactory
- NameGeneratorFactory retrieves a default name generator, based on the environment
- PeclUuidNameGenerator
- PeclUuidNameGenerator generates strings of binary data from a namespace and a name, using ext-uuid
- PeclUuidRandomGenerator
- PeclUuidRandomGenerator generates strings of random binary data using ext-uuid
- PeclUuidTimeGenerator
- PeclUuidTimeGenerator generates strings of binary data for time-base UUIDs, using ext-uuid
- RandomBytesGenerator
- RandomBytesGenerator generates strings of random binary data using the built-in `random_bytes()` PHP function
- RandomGeneratorFactory
- RandomGeneratorFactory retrieves a default random generator, based on the environment
- RandomLibAdapter
- RandomLibAdapter generates strings of random binary data using the paragonie/random-lib library
- TimeGeneratorFactory
- TimeGeneratorFactory retrieves a default time generator, based on the environment
- Fields
- GUIDs are comprised of a set of named fields, according to RFC 4122
- Guid
- Guid represents a UUID with "native" (little-endian) byte order
- GuidBuilder
- GuidBuilder builds instances of Guid
- BrickMathCalculator
- A calculator using the brick/math library for arbitrary-precision arithmetic
- RoundingMode
- Specifies a rounding behavior for numerical operations capable of discarding precision.
- Fields
- Nonstandard UUID fields do not conform to the RFC 4122 standard
- Uuid
- Nonstandard\Uuid is a UUID that doesn't conform to RFC 4122
- UuidBuilder
- Nonstandard\UuidBuilder builds instances of Nonstandard\Uuid
- UuidV6
- Ordered-time, or version 6, UUIDs include timestamp, clock sequence, and node values that are combined into a 128-bit unsigned integer
- SystemDceSecurityProvider
- SystemDceSecurityProvider retrieves the user or group identifiers from the system
- FallbackNodeProvider
- FallbackNodeProvider retrieves the system node ID by stepping through a list of providers until a node ID can be obtained
- NodeProviderCollection
- A collection of NodeProviderInterface objects
- RandomNodeProvider
- RandomNodeProvider generates a random node ID
- StaticNodeProvider
- StaticNodeProvider provides a static node value with the multicast bit set
- SystemNodeProvider
- SystemNodeProvider retrieves the system node ID, if possible
- FixedTimeProvider
- FixedTimeProvider uses an known time to provide the time
- SystemTimeProvider
- SystemTimeProvider retrieves the current time using built-in PHP functions
- Fields
- RFC 4122 variant UUIDs are comprised of a set of named fields
- NilUuid
- The nil UUID is special form of UUID that is specified to have all 128 bits set to zero
- UuidBuilder
- UuidBuilder builds instances of RFC 4122 UUIDs
- UuidV1
- Time-based, or version 1, UUIDs include timestamp, clock sequence, and node values that are combined into a 128-bit unsigned integer
- UuidV2
- DCE Security version, or version 2, UUIDs include local domain identifier, local ID for the specified domain, and node values that are combined into a 128-bit unsigned integer
- UuidV3
- Version 3 UUIDs are named-based, using combination of a namespace and name that are hashed into a 128-bit unsigned integer using MD5
- UuidV4
- Random, or version 4, UUIDs are randomly or pseudo-randomly generated 128-bit integers
- UuidV5
- Version 5 UUIDs are named-based, using combination of a namespace and name that are hashed into a 128-bit unsigned integer using SHA1
- Validator
- Rfc4122\Validator validates strings as UUIDs of the RFC 4122 variant
- Decimal
- A value object representing a decimal
- Hexadecimal
- A value object representing a hexadecimal number
- Integer
- A value object representing an integer
- Time
- A value object representing a timestamp
- Uuid
- Uuid provides constants and static methods for working with and generating UUIDs
- UuidFactory
- GenericValidator
- GenericValidator validates strings as UUIDs of any variant
- AbstractAdapter
- ApcuAdapter
- ArrayAdapter
- ChainAdapter
- Chains several adapters together.
- DoctrineAdapter
- FilesystemAdapter
- FilesystemTagAwareAdapter
- Stores tag id <> cache id relationship as a symlink, and lookup on invalidation calls.
- MemcachedAdapter
- NullAdapter
- PdoAdapter
- PhpArrayAdapter
- Caches items at warm up time using a PHP array that is stored in shared memory by OPCache since PHP 7.0.
- PhpFilesAdapter
- ProxyAdapter
- Psr16Adapter
- Turns a PSR-16 cache into a PSR-6 one.
- RedisAdapter
- RedisTagAwareAdapter
- Stores tag id <> cache id relationship as a Redis Set, lookup on invalidation using RENAME+SMEMBERS.
- TagAwareAdapter
- TraceableAdapter
- An adapter that collects data about all cache calls.
- TraceableAdapterEvent
- TraceableTagAwareAdapter
- An adapter that collects data about all cache calls.
- CacheItem
- CacheDataCollector
- DataCollector.
- CacheCollectorPass
- Inject a data collector to all the cache services to be able to get detailed statistics.
- CachePoolClearerPass
- CachePoolPass
- CachePoolPrunerPass
- DoctrineProvider
- CacheException
- InvalidArgumentException
- LogicException
- LockRegistry
- LockRegistry is used internally by existing adapters to protect against cache stampede.
- DefaultMarshaller
- Serializes/unserializes values using igbinary_serialize() if available, serialize() otherwise.
- DeflateMarshaller
- Compresses values using gzdeflate().
- TagAwareMarshaller
- A marshaller optimized for data structures generated by AbstractTagAwareAdapter.
- Psr16Cache
- Turns a PSR-6 cache into a PSR-16 one.
- ConfigCache
- ConfigCache caches arbitrary content in files on disk.
- ConfigCacheFactory
- Basic implementation of ConfigCacheFactoryInterface that creates an instance of the default ConfigCache.
- ArrayNode
- Represents an Array node in the config tree.
- BaseNode
- The base node class.
- BooleanNode
- This node represents a Boolean value in the config tree.
- ArrayNodeDefinition
- This class provides a fluent interface for defining an array node.
- BooleanNodeDefinition
- This class provides a fluent interface for defining a node.
- EnumNodeDefinition
- Enum Node Definition.
- ExprBuilder
- This class builds an if expression.
- FloatNodeDefinition
- This class provides a fluent interface for defining a float node.
- IntegerNodeDefinition
- This class provides a fluent interface for defining an integer node.
- MergeBuilder
- This class builds merge conditions.
- NodeBuilder
- This class provides a fluent interface for building a node.
- NodeDefinition
- This class provides a fluent interface for defining a node.
- NormalizationBuilder
- This class builds normalization conditions.
- NumericNodeDefinition
- Abstract class that contains common code of integer and float node definitions.
- ScalarNodeDefinition
- This class provides a fluent interface for defining a node.
- TreeBuilder
- This is the entry class for building a config tree.
- ValidationBuilder
- This class builds validation conditions.
- VariableNodeDefinition
- This class provides a fluent interface for defining a node.
- XmlReferenceDumper
- Dumps a XML reference configuration for the given configuration/node instance.
- YamlReferenceDumper
- Dumps a Yaml reference configuration for the given configuration/node instance.
- EnumNode
- Node which only allows a finite set of values.
- DuplicateKeyException
- 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.
- Exception
- Base exception for all configuration exceptions.
- ForbiddenOverwriteException
- This exception is thrown when a configuration path is overwritten from a subsequent configuration file, but the entry node specifically forbids this.
- InvalidConfigurationException
- A very general exception which can be thrown whenever non of the more specific exceptions is suitable.
- InvalidDefinitionException
- Thrown when an error is detected in a node Definition.
- InvalidTypeException
- This exception is thrown if an invalid type is encountered.
- UnsetKeyException
- This exception is usually not encountered by the end-user, but only used internally to signal the parent scope to unset a key.
- FloatNode
- This node represents a float value in the config tree.
- IntegerNode
- This node represents an integer value in the config tree.
- NumericNode
- This node represents a numeric value in the config tree.
- Processor
- This class is the entry point for config normalization/merging/finalization.
- PrototypedArrayNode
- Represents a prototyped Array node in the config tree.
- ScalarNode
- This node represents a scalar value in the config tree.
- VariableNode
- This node represents a value of variable type in the config tree.
- FileLoaderImportCircularReferenceException
- Exception class for when a circular reference is detected when importing resources.
- FileLocatorFileNotFoundException
- File locator exception if a file does not exist.
- LoaderLoadException
- Exception class for when a resource cannot be loaded or imported.
- FileLocator
- FileLocator uses an array of pre-defined paths to find files.
- DelegatingLoader
- DelegatingLoader delegates loading to other loaders using a loader resolver.
- FileLoader
- FileLoader is the abstract class used by all built-in loaders that are file based.
- GlobFileLoader
- GlobFileLoader loads files from a glob pattern.
- Loader
- Loader is the abstract class used by all built-in loaders.
- LoaderResolver
- LoaderResolver selects a loader for a given resource.
- ClassExistenceResource
- ClassExistenceResource represents a class existence.
- ComposerResource
- ComposerResource tracks the PHP version and Composer dependencies.
- DirectoryResource
- DirectoryResource represents a resources stored in a subdirectory tree.
- FileExistenceResource
- FileExistenceResource represents a resource stored on the filesystem.
- FileResource
- FileResource represents a resource stored on the filesystem.
- GlobResource
- GlobResource represents a set of resources stored on the filesystem.
- ReflectionClassResource
- SelfCheckingResourceChecker
- Resource checker for instances of SelfCheckingResourceInterface.
- ResourceCheckerConfigCache
- ResourceCheckerConfigCache uses instances of ResourceCheckerInterface to check whether cached data is still fresh.
- ResourceCheckerConfigCacheFactory
- A ConfigCacheFactory implementation that validates the cache with an arbitrary set of ResourceCheckers.
- InvalidXmlException
- Exception class for when XML parsing with an XSD schema file path or a callable validator produces errors unrelated to the actual XML parsing.
- XmlParsingException
- Exception class for when XML cannot be parsed properly.
- XmlUtils
- XMLUtils is a bunch of utility methods to XML operations.
- Application
- An Application is the container for a collection of commands.
- Command
- Base class for all commands.
- HelpCommand
- HelpCommand displays the help for a given command.
- ListCommand
- ListCommand displays the list of all available commands for the application.
- ContainerCommandLoader
- Loads commands from a PSR-11 container.
- FactoryCommandLoader
- A simple command loader using factories to instantiate commands lazily.
- ConsoleEvents
- Contains all events dispatched by an Application.
- AddConsoleCommandPass
- Registers console commands.
- ConsoleCommandEvent
- Allows to do things before the command is executed, like skipping the command or changing the input.
- ConsoleErrorEvent
- Allows to handle throwables thrown while running a command.
- ConsoleEvent
- Allows to inspect input and output of a command.
- ConsoleTerminateEvent
- Allows to manipulate the exit code of a command after its execution.
- ErrorListener
- CommandNotFoundException
- Represents an incorrect command name typed in the console.
- InvalidArgumentException
- InvalidOptionException
- Represents an incorrect option name typed in the console.
- LogicException
- MissingInputException
- Represents failure to read input from stdin.
- NamespaceNotFoundException
- Represents an incorrect namespace typed in the console.
- RuntimeException
- OutputFormatter
- Formatter class for console output.
- OutputFormatterStyle
- Formatter style class for defining styles.
- OutputFormatterStyleStack
- DebugFormatterHelper
- Helps outputting debug information when running an external program from a command.
- DescriptorHelper
- This class adds helper method to describe objects in various formats.
- Dumper
- FormatterHelper
- The Formatter class provides helpers to format messages.
- Helper
- Helper is the base class for all helper classes.
- HelperSet
- HelperSet represents a set of helpers to be used with a command.
- InputAwareHelper
- An implementation of InputAwareInterface for Helpers.
- ProcessHelper
- The ProcessHelper class provides helpers to run external processes.
- ProgressBar
- The ProgressBar provides helpers to display progress output.
- ProgressIndicator
- QuestionHelper
- The QuestionHelper class provides helpers to interact with the user.
- SymfonyQuestionHelper
- Symfony Style Guide compliant question helper.
- Table
- Provides helpers to display a table.
- TableCell
- TableSeparator
- Marks a row as being a separator.
- TableStyle
- Defines the styles for a Table.
- ArgvInput
- ArgvInput represents an input coming from the CLI arguments.
- ArrayInput
- ArrayInput represents an input provided as an array.
- Input
- Input is the base class for all concrete Input classes.
- InputArgument
- Represents a command line argument.
- InputDefinition
- A InputDefinition represents a set of valid command line arguments and options.
- InputOption
- Represents a command line option.
- StringInput
- StringInput represents an input provided as a string.
- ConsoleLogger
- PSR-3 compliant console logger.
- BufferedOutput
- Base class for output classes.
- ConsoleOutput
- ConsoleOutput is the default class for all CLI output. It uses STDOUT and STDERR.
- ConsoleSectionOutput
- StreamOutput writes the output to a given stream.
- NullOutput
- NullOutput suppresses all output.
- Output
- Base class for output classes.
- StreamOutput
- StreamOutput writes the output to a given stream.
- ChoiceQuestion
- Represents a choice question.
- ConfirmationQuestion
- Represents a yes/no question.
- Question
- Represents a Question.
- OutputStyle
- Decorates output to add console style guide helpers.
- SymfonyStyle
- Output decorator helpers for the Symfony Style Guide.
- Terminal
- ApplicationTester
- Eases the testing of console applications.
- CommandTester
- Eases the testing of console commands.
- BufferingLogger
- A buffering logger that stacks logs for later.
- Debug
- Registers all the debug tools.
- DebugClassLoader
- Autoloader checking if the class is really defined in the file found.
- ErrorHandler
- A generic ErrorHandler for the PHP engine.
- ClassNotFoundException
- Class (or Trait or Interface) Not Found Exception.
- FatalErrorException
- Fatal Error Exception.
- FatalThrowableError
- Fatal Throwable Error.
- FlattenException
- FlattenException wraps a PHP Error or Exception to be able to serialize it.
- OutOfMemoryException
- Out of memory exception.
- SilencedErrorContext
- Data Object that represents a Silenced Error.
- UndefinedFunctionException
- Undefined Function Exception.
- UndefinedMethodException
- Undefined Method Exception.
- ExceptionHandler
- ExceptionHandler converts an exception to a Response object.
- ClassNotFoundFatalErrorHandler
- ErrorHandler for classes that do not exist.
- UndefinedFunctionFatalErrorHandler
- ErrorHandler for undefined functions.
- UndefinedMethodFatalErrorHandler
- ErrorHandler for undefined methods.
- Alias
- BoundArgument
- IteratorArgument
- Represents a collection of values to lazily iterate over.
- ServiceClosureArgument
- Represents a service wrapped in a memoizing closure.
- ServiceLocatorArgument
- Represents a closure acting as a service locator.
- TaggedIteratorArgument
- Represents a collection of services found by tag name to lazily iterate over.
- ChildDefinition
- This definition extends another definition.
- AbstractRecursivePass
- AnalyzeServiceReferencesPass
- Run this pass before passes that need to know more about the relation of your services.
- AutoAliasServicePass
- Sets a service to be an alias of another one, given a format pattern.
- AutowirePass
- Inspects existing service definitions and wires the autowired ones using the type hints of their classes.
- AutowireRequiredMethodsPass
- Looks for definitions with autowiring enabled and registers their corresponding "@required" methods as setters.
- CheckArgumentsValidityPass
- Checks if arguments of methods are properly configured.
- CheckCircularReferencesPass
- Checks your services for circular references.
- CheckDefinitionValidityPass
- This pass validates each definition individually only taking the information into account which is contained in the definition itself.
- CheckExceptionOnInvalidReferenceBehaviorPass
- Checks that all references are pointing to a valid service.
- CheckReferenceValidityPass
- Checks the validity of references.
- CheckTypeDeclarationsPass
- Checks whether injected parameters are compatible with type declarations.
- Compiler
- This class is used to remove circular dependencies between individual passes.
- DecoratorServicePass
- Overwrites a service but keeps the overridden one.
- DefinitionErrorExceptionPass
- Throws an exception for any Definitions that have errors and still exist.
- ExtensionCompilerPass
- A pass to automatically process extensions if they implement CompilerPassInterface.
- InlineServiceDefinitionsPass
- Inline service definitions where this is possible.
- MergeExtensionConfigurationPass
- Merges extension configs into the container builder.
- PassConfig
- Compiler Pass Configuration.
- RegisterEnvVarProcessorsPass
- Creates the container.env_var_processors_locator service.
- RegisterReverseContainerPass
- RegisterServiceSubscribersPass
- Compiler pass to register tagged services that require a service locator.
- RemoveAbstractDefinitionsPass
- Removes abstract Definitions.
- RemovePrivateAliasesPass
- 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.
- RemoveUnusedDefinitionsPass
- Removes unused service definitions from the container.
- ReplaceAliasByActualDefinitionPass
- Replaces aliases with actual service definitions, effectively removing these aliases.
- ResolveBindingsPass
- ResolveChildDefinitionsPass
- This replaces all ChildDefinition instances with their equivalent fully merged Definition instance.
- ResolveClassPass
- ResolveEnvPlaceholdersPass
- Replaces env var placeholders by their current values.
- ResolveFactoryClassPass
- ResolveHotPathPass
- Propagate "container.hot_path" tags to referenced services.
- ResolveInstanceofConditionalsPass
- Applies instanceof conditionals to definitions.
- ResolveInvalidReferencesPass
- Emulates the invalid behavior if the reference is not found within the container.
- ResolveNamedArgumentsPass
- Resolves named arguments to their corresponding numeric index.
- ResolveParameterPlaceHoldersPass
- Resolves all parameter placeholders "%somevalue%" to their real values.
- ResolvePrivatesPass
- ResolveReferencesToAliasesPass
- Replaces all references to aliases with references to the actual service.
- ResolveServiceSubscribersPass
- Compiler pass to inject their service locator to service subscribers.
- ResolveTaggedIteratorArgumentPass
- Resolves all TaggedIteratorArgument arguments.
- ServiceLocatorTagPass
- Applies the "container.service_locator" tag by wrapping references into ServiceClosureArgument instances.
- ServiceReferenceGraph
- This is a directed graph of your services.
- ServiceReferenceGraphEdge
- Represents an edge in your service graph.
- ServiceReferenceGraphNode
- Represents a node in your service graph.
- ValidateEnvPlaceholdersPass
- Validates environment variable placeholders used in extension configuration with dummy values.
- ContainerParametersResource
- Tracks container parameters.
- ContainerParametersResourceChecker
- Container
- Container is a dependency injection container.
- ContainerBuilder
- ContainerBuilder is a DI container that provides an API to easily describe services.
- Definition
- Definition represents a service definition.
- Dumper
- Dumper is the abstract class for all built-in dumpers.
- GraphvizDumper
- GraphvizDumper dumps a service container as a graphviz file.
- PhpDumper
- PhpDumper dumps a service container as a PHP class.
- XmlDumper
- XmlDumper dumps a service container as an XML string.
- YamlDumper
- YamlDumper dumps a service container as a YAML string.
- EnvVarProcessor
- AutowiringFailedException
- Thrown when a definition cannot be autowired.
- BadMethodCallException
- Base BadMethodCallException for Dependency Injection component.
- EnvNotFoundException
- This exception is thrown when an environment variable is not found.
- EnvParameterException
- This exception wraps exceptions whose messages contain a reference to an env parameter.
- InvalidArgumentException
- Base InvalidArgumentException for Dependency Injection component.
- InvalidParameterTypeException
- Thrown when trying to inject a parameter into a constructor/method with an incompatible type.
- LogicException
- Base LogicException for Dependency Injection component.
- OutOfBoundsException
- Base OutOfBoundsException for Dependency Injection component.
- ParameterCircularReferenceException
- This exception is thrown when a circular reference in a parameter is detected.
- ParameterNotFoundException
- This exception is thrown when a non-existent parameter is used.
- RuntimeException
- Base RuntimeException for Dependency Injection component.
- ServiceCircularReferenceException
- This exception is thrown when a circular reference is detected.
- ServiceNotFoundException
- This exception is thrown when a non-existent service is requested.
- ExpressionLanguage
- Adds some function to the default ExpressionLanguage.
- ExpressionLanguageProvider
- Define some ExpressionLanguage functions.
- Extension
- Provides useful features shared by many extensions.
- RealServiceInstantiator
- {@inheritdoc}
- NullDumper
- Null dumper, negates any proxy code generation for any given service definition.
- ClosureLoader
- ClosureLoader loads service definitions from a PHP closure.
- AbstractConfigurator
- AbstractServiceConfigurator
- AliasConfigurator
- ContainerConfigurator
- DefaultsConfigurator
- InlineServiceConfigurator
- InstanceofConfigurator
- ParametersConfigurator
- PrototypeConfigurator
- ReferenceConfigurator
- ServiceConfigurator
- ServicesConfigurator
- DirectoryLoader
- DirectoryLoader is a recursive loader to go through directories.
- FileLoader
- FileLoader is the abstract class used by all built-in loaders that are file based.
- GlobFileLoader
- GlobFileLoader loads files from a glob pattern.
- IniFileLoader
- IniFileLoader loads parameters from INI files.
- PhpFileLoader
- PhpFileLoader loads service definitions from a PHP file.
- XmlFileLoader
- XmlFileLoader loads XML files service definitions.
- YamlFileLoader
- YamlFileLoader loads YAML files service definitions.
- Parameter
- Parameter represents a parameter reference.
- ContainerBag
- Holds read-only parameters.
- EnvPlaceholderParameterBag
- Holds parameters.
- FrozenParameterBag
- Holds read-only parameters.
- ParameterBag
- Holds parameters.
- Reference
- Reference represents a service reference.
- ReverseContainer
- Turns public and "container.reversible" services back to their ids.
- ServiceLocator
- TypedReference
- Represents a PHP type-hinted service reference.
- Variable
- Represents a variable.
- BufferingLogger
- A buffering logger that stacks logs for later.
- Debug
- Registers all the debug tools.
- DebugClassLoader
- Autoloader checking if the class is really defined in the file found.
- ClassNotFoundError
- FatalError
- OutOfMemoryError
- UndefinedFunctionError
- UndefinedMethodError
- ClassNotFoundErrorEnhancer
- UndefinedFunctionErrorEnhancer
- UndefinedMethodErrorEnhancer
- ErrorHandler
- A generic ErrorHandler for the PHP engine.
- CliErrorRenderer
- HtmlErrorRenderer
- SerializerErrorRenderer
- Formats an exception using Serializer for rendering.
- FlattenException
- FlattenException wraps a PHP Error or Exception to be able to serialize it.
- SilencedErrorContext
- Data Object that represents a Silenced Error.
- TraceableEventDispatcher
- Collects some data about event listeners.
- WrappedListener
- AddEventAliasesPass
- This pass allows bundles to extend the list of event aliases.
- RegisterListenersPass
- Compiler pass to register tagged services for an event dispatcher.
- Event
- EventDispatcher
- The EventDispatcherInterface is the central point of Symfony's event listener system.
- GenericEvent
- Event encapsulation class.
- ImmutableEventDispatcher
- A read-only proxy for an event dispatcher.
- LegacyEventDispatcherProxy
- A helper class to provide BC/FC with the legacy signature of EventDispatcherInterface::dispatch().
- Event
- Event is the base class for classes containing event data.
- FileNotFoundException
- Exception class thrown when a file couldn't be found.
- InvalidArgumentException
- IOException
- Exception class thrown when a filesystem operation failure happens.
- Filesystem
- Provides basic utility to manipulate the file system.
- Comparator
- Comparator.
- DateComparator
- DateCompare compiles date comparisons.
- NumberComparator
- NumberComparator compiles a simple comparison to an anonymous subroutine, which you can call with a value to be tested again.
- AccessDeniedException
- DirectoryNotFoundException
- Finder
- Finder allows to build rules to find files and directories.
- Gitignore
- Gitignore matches against text.
- Glob
- Glob matches globbing patterns against text.
- CustomFilterIterator
- CustomFilterIterator filters files by applying anonymous functions.
- DateRangeFilterIterator
- DateRangeFilterIterator filters out files that are not in the given date range (last modified dates).
- DepthRangeFilterIterator
- DepthRangeFilterIterator limits the directory depth.
- ExcludeDirectoryFilterIterator
- ExcludeDirectoryFilterIterator filters out directories.
- FilecontentFilterIterator
- FilecontentFilterIterator filters files by their contents using patterns (regexps or strings).
- FilenameFilterIterator
- FilenameFilterIterator filters files by patterns (a regexp, a glob, or a string).
- FileTypeFilterIterator
- FileTypeFilterIterator only keeps files, directories, or both.
- MultiplePcreFilterIterator
- MultiplePcreFilterIterator filters files using patterns (regexps, globs or strings).
- PathFilterIterator
- PathFilterIterator filters files by path patterns (e.g. some/special/dir).
- RecursiveDirectoryIterator
- Extends the \RecursiveDirectoryIterator to support relative paths.
- SizeRangeFilterIterator
- SizeRangeFilterIterator filters out files that are not in the given size range.
- SortableIterator
- SortableIterator applies a sort on a given Iterator.
- SplFileInfo
- Extends \SplFileInfo to support relative paths.
- AnnotationsCacheWarmer
- Warms up annotation caches for classes found in composer's autoload class map and declared in DI bundle extensions using the addAnnotatedClassesToCache method.
- RouterCacheWarmer
- Generates the router matcher and generator classes.
- SerializerCacheWarmer
- Warms up XML and YAML serializer metadata.
- TemplateFinder
- Finds all the templates.
- TemplatePathsCacheWarmer
- Computes the association between template names and their paths on the disk.
- TranslationsCacheWarmer
- Generates the catalogues for translations.
- ValidatorCacheWarmer
- Warms up XML and YAML validator metadata.
- Client
- Client simulates a browser and makes requests to a Kernel object.
- AboutCommand
- A console command to display information about the current installation.
- AbstractConfigCommand
- A console command for dumping available configuration reference.
- AssetsInstallCommand
- Command that places bundle web assets into a given directory.
- CacheClearCommand
- Clear and Warmup the cache.
- CachePoolClearCommand
- Clear cache pools.
- CachePoolDeleteCommand
- Delete an item from a cache pool.
- CachePoolListCommand
- List available cache pools.
- CachePoolPruneCommand
- Cache pool pruner command.
- CacheWarmupCommand
- Warmup the cache.
- ConfigDebugCommand
- A console command for dumping available configuration reference.
- ConfigDumpReferenceCommand
- A console command for dumping available configuration reference.
- ContainerAwareCommand
- Command.
- ContainerLintCommand
- Base class for all commands.
- EventDispatcherDebugCommand
- A console command for retrieving information about event dispatcher.
- RouterDebugCommand
- A console command for retrieving information about routes.
- RouterMatchCommand
- A console command to test route matching.
- TranslationDebugCommand
- Helps finding unused or missing translation messages in a given locale and comparing them with the fallback ones.
- TranslationUpdateCommand
- A command that parses templates to extract translation messages and adds them into the translation files.
- WorkflowDumpCommand
- Base class for all commands.
- XliffLintCommand
- Validates XLIFF files syntax and outputs encountered errors.
- YamlLintCommand
- Validates YAML files syntax and outputs encountered errors.
- Application
- An Application is the container for a collection of commands.
- AbstractController
- Provides common features needed in controllers.
- Controller
- Controller is a simple implementation of a Controller.
- ControllerNameParser
- 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
- A controller resolver searching for a controller in a psr-11 container when using the "service:method" notation.
- RedirectController
- Redirects a request to another URL.
- TemplateController
- TemplateController.
- RequestDataCollector
- RequestDataCollector.
- RouterDataCollector
- RouterDataCollector.
- AddDebugLogProcessorPass
- AddExpressionLanguageProvidersPass
- Registers the expression language providers.
- CacheCollectorPass
- Inject a data collector to all the cache services to be able to get detailed statistics.
- CachePoolClearerPass
- CachePoolPass
- CachePoolPrunerPass
- ContainerBuilderDebugDumpPass
- Dumps the ContainerBuilder to a cache file so that it can be used by debugging tools such as the debug:container console command.
- DataCollectorTranslatorPass
- LoggingTranslatorPass
- ProfilerPass
- Adds tagged data_collector services to profiler service.
- TemplatingPass
- TestServiceContainerRealRefPass
- TestServiceContainerWeakRefPass
- UnusedTagsPass
- Find all service tags which are defined, but not used and yield a warning log message.
- WorkflowGuardListenerPass
- Configuration
- FrameworkExtension configuration structure.
- FrameworkExtension
- FrameworkExtension.
- ResolveControllerNameSubscriber
- Guarantees that the _controller key is parsed into its final format.
- FrameworkBundle
- Bundle.
- HttpCache
- Manages HTTP cache objects in a Container.
- KernelBrowser
- Client simulates a browser and makes requests to a Kernel object.
- AnnotatedRouteControllerLoader
- AnnotatedRouteControllerLoader is an implementation of AnnotationClassLoader that sets the '_controller' default based on the class and method names.
- DelegatingLoader
- DelegatingLoader delegates route loading to other loaders using a loader resolver.
- RedirectableUrlMatcher
- UrlMatcher matches URL based on a set of routes.
- Router
- This Router creates the Loader only when the cache is empty.
- DelegatingEngine
- DelegatingEngine selects an engine for a given template.
- GlobalVariables
- GlobalVariables is the entry point for Symfony global variables in PHP templates.
- ActionsHelper
- ActionsHelper manages action inclusions.
- AssetsHelper
- AssetsHelper helps manage asset URLs.
- FormHelper
- FormHelper provides helpers to help display forms.
- RequestHelper
- RequestHelper provides access to the current request parameters.
- RouterHelper
- RouterHelper manages links between pages in a template context.
- SessionHelper
- SessionHelper provides read-only access to the session attributes.
- StopwatchHelper
- StopwatchHelper provides methods time your PHP templates.
- TranslatorHelper
- FilesystemLoader
- FilesystemLoader is a loader that read templates from the filesystem.
- TemplateLocator
- TemplateLocator locates templates in bundles.
- PhpEngine
- This engine knows how to render Symfony templates.
- TemplateFilenameParser
- TemplateFilenameParser converts template filenames to TemplateReferenceInterface instances.
- TemplateNameParser
- TemplateNameParser converts template names from the short notation "bundle:section:template.format.engine" to TemplateReferenceInterface instances.
- TemplateReference
- Internal representation of a template.
- TimedPhpEngine
- Times the time spent to render a template.
- KernelTestCase
- KernelTestCase is the base class for tests needing a Kernel.
- WebTestCase
- WebTestCase is the base class for functional tests.
- Translator
- Translator.
- AcceptHeader
- Represents an Accept-* header.
- AcceptHeaderItem
- Represents an Accept-* header item.
- ApacheRequest
- Request represents an HTTP request from an Apache server.
- BinaryFileResponse
- BinaryFileResponse represents an HTTP response delivering a file.
- Cookie
- Represents a cookie.
- ConflictingHeadersException
- The HTTP request contains headers with conflicting information.
- SuspiciousOperationException
- Raised when a user has performed an operation that should be considered suspicious from a security perspective.
- ExpressionRequestMatcher
- ExpressionRequestMatcher uses an expression to match a Request.
- AccessDeniedException
- Thrown when the access on a file was denied.
- CannotWriteFileException
- Thrown when an UPLOAD_ERR_CANT_WRITE error occurred with UploadedFile.
- ExtensionFileException
- Thrown when an UPLOAD_ERR_EXTENSION error occurred with UploadedFile.
- FileException
- Thrown when an error occurred in the component File.
- FileNotFoundException
- Thrown when a file was not found.
- FormSizeFileException
- Thrown when an UPLOAD_ERR_FORM_SIZE error occurred with UploadedFile.
- IniSizeFileException
- Thrown when an UPLOAD_ERR_INI_SIZE error occurred with UploadedFile.
- NoFileException
- Thrown when an UPLOAD_ERR_NO_FILE error occurred with UploadedFile.
- NoTmpDirFileException
- Thrown when an UPLOAD_ERR_NO_TMP_DIR error occurred with UploadedFile.
- PartialFileException
- Thrown when an UPLOAD_ERR_PARTIAL error occurred with UploadedFile.
- UnexpectedTypeException
- Thrown when an error occurred in the component File.
- UploadException
- Thrown when an error occurred during file upload.
- File
- A file in the file system.
- ExtensionGuesser
- A singleton mime type to file extension guesser.
- FileBinaryMimeTypeGuesser
- Guesses the mime type with the binary "file" (only available on *nix).
- FileinfoMimeTypeGuesser
- Guesses the mime type using the PECL extension FileInfo.
- MimeTypeExtensionGuesser
- Provides a best-guess mapping of mime type to file extension.
- MimeTypeGuesser
- A singleton mime type guesser.
- Stream
- A PHP stream of unknown size.
- UploadedFile
- A file uploaded through a form.
- FileBag
- FileBag is a container for uploaded files.
- HeaderBag
- HeaderBag is a container for HTTP headers.
- HeaderUtils
- HTTP header utility functions.
- IpUtils
- Http utility functions.
- JsonResponse
- Response represents an HTTP response in JSON format.
- ParameterBag
- ParameterBag is a container for key/value pairs.
- RedirectResponse
- RedirectResponse represents an HTTP response doing a redirect.
- Request
- Request represents an HTTP request.
- RequestMatcher
- RequestMatcher compares a pre-defined set of checks against a Request instance.
- RequestStack
- Request stack that controls the lifecycle of requests.
- Response
- Response represents an HTTP response.
- ResponseHeaderBag
- ResponseHeaderBag is a container for Response HTTP headers.
- ServerBag
- ServerBag is a container for HTTP headers from the $_SERVER variable.
- AttributeBag
- This class relates to session attribute storage.
- NamespacedAttributeBag
- This class provides structured storage of session attributes using a name spacing character in the key.
- AutoExpireFlashBag
- AutoExpireFlashBag flash message container.
- FlashBag
- FlashBag flash message container.
- Session
- AbstractSessionHandler
- This abstract session handler provides a generic implementation of the PHP 7.0 SessionUpdateTimestampHandlerInterface, enabling strict and lazy session handling.
- MemcachedSessionHandler
- Memcached based session storage handler based on the Memcached class provided by the PHP memcached extension.
- MigratingSessionHandler
- Migrating session handler for migrating from one handler to another. It reads from the current handler and writes both the current and new ones.
- MongoDbSessionHandler
- Session handler using the mongodb/mongodb package and MongoDB driver extension.
- NativeFileSessionHandler
- Native session handler using PHP's built in file storage.
- NullSessionHandler
- Can be used in unit testing or in a situations where persisted sessions are not desired.
- PdoSessionHandler
- Session handler using a PDO connection to read and write data.
- RedisSessionHandler
- Redis based session storage handler based on the Redis class provided by the PHP redis extension.
- SessionHandlerFactory
- StrictSessionHandler
- Adds basic `SessionUpdateTimestampHandlerInterface` behaviors to another `SessionHandlerInterface`.
- MetadataBag
- Metadata container.
- MockArraySessionStorage
- MockArraySessionStorage mocks the session for unit tests.
- MockFileSessionStorage
- MockFileSessionStorage is used to mock sessions for functional testing when done in a single PHP process.
- NativeSessionStorage
- This provides a base class for session attribute storage.
- PhpBridgeSessionStorage
- Allows session to be started by PHP and managed by Symfony.
- AbstractProxy
- SessionHandlerProxy
- StreamedResponse
- StreamedResponse represents a streamed HTTP response.
- RequestAttributeValueSame
- ResponseCookieValueSame
- ResponseHasCookie
- ResponseHasHeader
- ResponseHeaderSame
- ResponseIsRedirected
- ResponseIsSuccessful
- ResponseStatusCodeSame
- UrlHelper
- A helper service for manipulating URLs within and outside the request scope.
- Bundle
- An implementation of BundleInterface that adds a few conventions for DependencyInjection extensions.
- ChainCacheClearer
- ChainCacheClearer.
- Psr6CacheClearer
- CacheWarmer
- Abstract cache warmer that knows how to write a file to the cache.
- CacheWarmerAggregate
- Aggregates several cache warmers into a single one.
- Client
- Client simulates a browser and makes requests to an HttpKernel instance.
- FileLocator
- FileLocator uses the KernelInterface to locate resources in bundles.
- DefaultValueResolver
- Yields the default value defined in the action signature when no value has been given.
- NotTaggedControllerValueResolver
- Provides an intuitive error message when controller fails because it is not registered as a service.
- RequestAttributeValueResolver
- Yields a non-variadic argument's value from the request attributes.
- RequestValueResolver
- Yields the same instance as the request object passed along.
- ServiceValueResolver
- Yields a service keyed by _controller and argument name.
- SessionValueResolver
- Yields the Session.
- TraceableValueResolver
- Provides timing information via the stopwatch.
- VariadicValueResolver
- Yields a variadic argument's values from the request attributes.
- ArgumentResolver
- Responsible for resolving the arguments passed to an action.
- ContainerControllerResolver
- A controller resolver searching for a controller in a psr-11 container when using the "service:method" notation.
- ControllerReference
- Acts as a marker and a data holder for a Controller.
- ControllerResolver
- This implementation uses the '_controller' request attribute to determine the controller to execute.
- ErrorController
- Renders error or exception pages from a given FlattenException.
- TraceableArgumentResolver
- TraceableControllerResolver
- ArgumentMetadata
- Responsible for storing metadata of an argument.
- ArgumentMetadataFactory
- Builds {@see ArgumentMetadata} objects based on the given Controller.
- AjaxDataCollector
- AjaxDataCollector.
- ConfigDataCollector
- DataCollector.
- DataCollector
- DataCollector.
- DumpDataCollector
- DataCollector.
- EventDataCollector
- EventDataCollector.
- ExceptionDataCollector
- ExceptionDataCollector.
- LoggerDataCollector
- LogDataCollector.
- MemoryDataCollector
- MemoryDataCollector.
- RequestDataCollector
- DataCollector.
- RouterDataCollector
- DataCollector.
- TimeDataCollector
- DataCollector.
- FileLinkFormatter
- Formats debug file links.
- TraceableEventDispatcher
- Collects some data about event listeners.
- AddAnnotatedClassesToCachePass
- Sets the classes to compile in the cache for the container.
- ConfigurableExtension
- This extension sub-class provides first-class integration with the Config/Definition Component.
- ControllerArgumentValueResolverPass
- Gathers and configures the argument value resolvers.
- Extension
- Allow adding classes to the class cache.
- FragmentRendererPass
- Adds services tagged kernel.fragment_renderer as HTTP content rendering strategies.
- LazyLoadingFragmentHandler
- Lazily loads fragment renderers from the dependency injection container.
- LoggerPass
- Registers the default logger if necessary.
- MergeExtensionConfigurationPass
- Ensures certain extensions are always loaded.
- RegisterControllerArgumentLocatorsPass
- Creates the service-locators required by ServiceValueResolver.
- RegisterLocaleAwareServicesPass
- Register all services that have the "kernel.locale_aware" tag into the listener.
- RemoveEmptyControllerArgumentLocatorsPass
- Removes empty service-locators registered for ServiceValueResolver.
- ResettableServicePass
- ControllerArgumentsEvent
- Allows filtering of controller arguments.
- ControllerEvent
- Allows filtering of a controller callable.
- ExceptionEvent
- Allows to create a response for a thrown exception.
- FilterControllerArgumentsEvent
- Base class for events thrown in the HttpKernel component.
- FilterControllerEvent
- Base class for events thrown in the HttpKernel component.
- FilterResponseEvent
- Base class for events thrown in the HttpKernel component.
- FinishRequestEvent
- Triggered whenever a request is fully processed.
- GetResponseEvent
- Base class for events thrown in the HttpKernel component.
- GetResponseForControllerResultEvent
- Allows to create a response for a request.
- GetResponseForExceptionEvent
- Allows to create a response for a request.
- KernelEvent
- Base class for events thrown in the HttpKernel component.
- PostResponseEvent
- Base class for events thrown in the HttpKernel component.
- RequestEvent
- Allows to create a response for a request.
- ResponseEvent
- Allows to filter a Response object.
- TerminateEvent
- Allows to execute logic after a response was sent.
- ViewEvent
- Allows to create a response for the return value of a controller.
- AddRequestFormatsListener
- Adds configured formats to each request.
- DebugHandlersListener
- Configures errors and exceptions handlers.
- DisallowRobotsIndexingListener
- Ensures that the application is not indexed by search engines.
- DumpListener
- Configures dump() handler.
- ErrorListener
- ExceptionListener
- FragmentListener
- Handles content fragments represented by special URIs.
- LocaleAwareListener
- Pass the current locale to the provided services.
- LocaleListener
- Initializes the locale based on the current request.
- ProfilerListener
- ProfilerListener collects data for the current request by listening to the kernel events.
- ResponseListener
- ResponseListener fixes the Response headers based on the Request.
- RouterListener
- Initializes the context from the request and sets request attributes based on a matching route.
- SaveSessionListener
- SessionListener
- Sets the session in the request.
- StreamedResponseListener
- StreamedResponseListener is responsible for sending the Response to the client.
- SurrogateListener
- SurrogateListener adds a Surrogate-Control HTTP header when the Response needs to be parsed for Surrogates.
- TestSessionListener
- Sets the session in the request.
- TranslatorListener
- Synchronizes the locale between the request and the translator.
- ValidateRequestListener
- Validates Requests.
- AccessDeniedHttpException
- HttpException.
- BadRequestHttpException
- HttpException.
- ConflictHttpException
- HttpException.
- ControllerDoesNotReturnResponseException
- GoneHttpException
- HttpException.
- HttpException
- HttpException.
- LengthRequiredHttpException
- HttpException.
- MethodNotAllowedHttpException
- HttpException.
- NotAcceptableHttpException
- HttpException.
- NotFoundHttpException
- HttpException.
- PreconditionFailedHttpException
- HttpException.
- PreconditionRequiredHttpException
- HttpException.
- ServiceUnavailableHttpException
- HttpException.
- TooManyRequestsHttpException
- HttpException.
- UnauthorizedHttpException
- HttpException.
- UnprocessableEntityHttpException
- HttpException.
- UnsupportedMediaTypeHttpException
- HttpException.
- AbstractSurrogateFragmentRenderer
- Implements Surrogate rendering strategy.
- EsiFragmentRenderer
- Implements the ESI rendering strategy.
- FragmentHandler
- Renders a URI that represents a resource fragment.
- HIncludeFragmentRenderer
- Implements the Hinclude rendering strategy.
- InlineFragmentRenderer
- Implements the inline rendering strategy where the Request is rendered by the current HTTP kernel.
- RoutableFragmentRenderer
- Adds the possibility to generate a fragment URI for a given Controller.
- SsiFragmentRenderer
- Implements the SSI rendering strategy.
- AbstractSurrogate
- Abstract class implementing Surrogate capabilities to Request and Response instances.
- Esi
- Esi implements the ESI capabilities to Request and Response instances.
- HttpCache
- Cache provides HTTP caching.
- ResponseCacheStrategy
- ResponseCacheStrategy knows how to compute the Response cache HTTP header based on the different response cache headers.
- Ssi
- Ssi implements the SSI capabilities to Request and Response instances.
- Store
- Store implements all the logic for storing cache metadata (Request and Response headers).
- HttpClientKernel
- An implementation of a Symfony HTTP kernel using a "real" HTTP client.
- HttpKernel
- HttpKernel notifies events to convert a Request object to a Response one.
- HttpKernelBrowser
- Client simulates a browser and makes requests to an HttpKernel instance.
- Kernel
- The Kernel is the heart of the Symfony system.
- KernelEvents
- Contains all events thrown in the HttpKernel component.
- Logger
- Minimalist PSR-3 logger designed to write in stderr or any other stream.
- FileProfilerStorage
- Storage for profiler using files.
- Profile
- Profile.
- Profiler
- Profiler.
- UriSigner
- Signs URIs.
- Address
- SMimeEncrypter
- SMimeSigner
- AddMimeTypeGuesserPass
- Registers custom mime types guessers.
- Base64ContentEncoder
- Base64Encoder
- Base64MimeHeaderEncoder
- EightBitContentEncoder
- IdnAddressEncoder
- An IDN email address encoder.
- QpContentEncoder
- QpEncoder
- QpMimeHeaderEncoder
- Rfc2231Encoder
- AddressEncoderException
- InvalidArgumentException
- LogicException
- RfcComplianceException
- RuntimeException
- FileBinaryMimeTypeGuesser
- Guesses the MIME type with the binary "file" (only available on *nix).
- FileinfoMimeTypeGuesser
- Guesses the MIME type using the PECL extension FileInfo.
- AbstractHeader
- An abstract base MIME Header.
- DateHeader
- A Date MIME Header.
- Headers
- A collection of headers.
- IdentificationHeader
- An ID MIME Header for something like Message-ID or Content-ID (one or more addresses).
- MailboxHeader
- A Mailbox MIME Header for something like Sender (one named address).
- MailboxListHeader
- A Mailbox list MIME Header for something like From, To, Cc, and Bcc (one or more named addresses).
- ParameterizedHeader
- A Simple MIME Header.
- PathHeader
- A Path Header, such a Return-Path (one address).
- UnstructuredHeader
- A Simple MIME Header.
- Message
- MessageConverter
- MimeTypes
- Manages MIME types and file extensions.
- AbstractMultipartPart
- AbstractPart
- DataPart
- MessagePart
- AlternativePart
- DigestPart
- FormDataPart
- Implements RFC 7578.
- MixedPart
- RelatedPart
- SMimePart
- TextPart
- RawMessage
- EmailAddressContains
- EmailAttachmentCount
- EmailHasHeader
- EmailHeaderSame
- EmailHtmlBodyContains
- EmailTextBodyContains
- JsonException
- Route
- Annotation class for @Route().
- CompiledRoute
- CompiledRoutes are returned by the RouteCompiler class.
- RoutingResolverPass
- Adds tagged routing.loader services to routing.resolver service.
- InvalidParameterException
- Exception thrown when a parameter is not valid.
- MethodNotAllowedException
- The resource was found but the request method is not allowed.
- MissingMandatoryParametersException
- Exception thrown when a route cannot be generated because of missing mandatory parameters.
- NoConfigurationException
- Exception thrown when no routes are configured.
- ResourceNotFoundException
- The resource was not found.
- RouteNotFoundException
- Exception thrown when a route does not exist.
- CompiledUrlGenerator
- Generates URLs based on rules dumped by CompiledUrlGeneratorDumper.
- CompiledUrlGeneratorDumper
- CompiledUrlGeneratorDumper creates a PHP array to be used with CompiledUrlGenerator.
- GeneratorDumper
- GeneratorDumper is the base class for all built-in generator dumpers.
- UrlGenerator
- UrlGenerator can generate a URL or a path for any route in the RouteCollection based on the passed parameters.
- AnnotationClassLoader
- AnnotationClassLoader loads routing information from a PHP class and its methods.
- AnnotationDirectoryLoader
- AnnotationDirectoryLoader loads routing information from annotations set on PHP classes and methods.
- AnnotationFileLoader
- AnnotationFileLoader loads routing information from annotations set on a PHP class and its methods.
- ClosureLoader
- ClosureLoader loads routes from a PHP closure.
- CollectionConfigurator
- ImportConfigurator
- RouteConfigurator
- RoutingConfigurator
- ContainerLoader
- A route loader that executes a service from a PSR-11 container to load the routes.
- DirectoryLoader
- FileLoader is the abstract class used by all built-in loaders that are file based.
- GlobFileLoader
- GlobFileLoader loads files from a glob pattern.
- ObjectLoader
- A route loader that calls a method on an object to load the routes.
- PhpFileLoader
- PhpFileLoader loads routes from a PHP file.
- XmlFileLoader
- XmlFileLoader loads XML routing files.
- YamlFileLoader
- YamlFileLoader loads Yaml routing files.
- CompiledUrlMatcher
- Matches URLs based on rules dumped by CompiledUrlMatcherDumper.
- CompiledUrlMatcherDumper
- CompiledUrlMatcherDumper creates PHP arrays to be used with CompiledUrlMatcher.
- MatcherDumper
- MatcherDumper is the abstract class for all built-in matcher dumpers.
- RedirectableUrlMatcher
- UrlMatcher matches URL based on a set of routes.
- TraceableUrlMatcher
- TraceableUrlMatcher helps debug path info matching by tracing the match.
- UrlMatcher
- UrlMatcher matches URL based on a set of routes.
- RequestContext
- Holds information about the current request.
- Route
- A Route describes a route and its parameters.
- RouteCollection
- A RouteCollection represents a set of Route instances.
- RouteCollectionBuilder
- Helps add and import routes into a RouteCollection.
- RouteCompiler
- RouteCompiler compiles Route instances to CompiledRoute instances.
- Router
- The Router class is an example of the integration of all pieces of the routing system for easier use.
- ServiceLocatorTest
- AbstractOperation
- Base catalogues binary operation class.
- MergeOperation
- Merge operation between two catalogues as follows: all = source ∪ target = {x: x ∈ source ∨ x ∈ target} new = all ∖ source = {x: x ∈ target ∧ x ∉ source} obsolete = source ∖ all = {x: x ∈ source ∧ x ∉ source ∧ x ∉ target} = ∅ Basically, the result contains messages from both catalogues.
- TargetOperation
- Target operation between two catalogues: intersection = source ∩ target = {x: x ∈ source ∧ x ∈ target} all = intersection ∪ (target ∖ intersection) = target new = all ∖ source = {x: x ∈ target ∧ x ∉ source} obsolete = source ∖ all = source ∖ target = {x: x ∈ source ∧ x ∉ target} Basically, the result contains messages from the target catalogue.
- XliffLintCommand
- Validates XLIFF files syntax and outputs encountered errors.
- TranslationDataCollector
- DataCollector.
- DataCollectorTranslator
- TranslationDumperPass
- Adds tagged translation.formatter services to translation writer.
- TranslationExtractorPass
- Adds tagged translation.extractor services to translation extractor.
- TranslatorPass
- TranslatorPathsPass
- CsvFileDumper
- CsvFileDumper generates a csv formatted string representation of a message catalogue.
- FileDumper
- FileDumper is an implementation of DumperInterface that dump a message catalogue to file(s).
- IcuResFileDumper
- IcuResDumper generates an ICU ResourceBundle formatted string representation of a message catalogue.
- IniFileDumper
- IniFileDumper generates an ini formatted string representation of a message catalogue.
- JsonFileDumper
- JsonFileDumper generates an json formatted string representation of a message catalogue.
- MoFileDumper
- MoFileDumper generates a gettext formatted string representation of a message catalogue.
- PhpFileDumper
- PhpFileDumper generates PHP files from a message catalogue.
- PoFileDumper
- PoFileDumper generates a gettext formatted string representation of a message catalogue.
- QtFileDumper
- QtFileDumper generates ts files from a message catalogue.
- XliffFileDumper
- XliffFileDumper generates xliff files from a message catalogue.
- YamlFileDumper
- YamlFileDumper generates yaml files from a message catalogue.
- InvalidArgumentException
- Base InvalidArgumentException for the Translation component.
- InvalidResourceException
- Thrown when a resource cannot be loaded.
- LogicException
- Base LogicException for Translation component.
- NotFoundResourceException
- Thrown when a resource does not exist.
- RuntimeException
- Base RuntimeException for the Translation component.
- AbstractFileExtractor
- Base class used by classes that extract translation messages from files.
- ChainExtractor
- ChainExtractor extracts translation messages from template files.
- PhpExtractor
- PhpExtractor extracts translation messages from a PHP template.
- PhpStringTokenParser
- IntlFormatter
- MessageFormatter
- IdentityTranslator
- IdentityTranslator does not translate anything.
- Interval
- Tests if a given number belongs to a given math interval.
- ArrayLoader
- ArrayLoader loads translations from a PHP array.
- CsvFileLoader
- CsvFileLoader loads translations from CSV files.
- FileLoader
- ArrayLoader loads translations from a PHP array.
- IcuDatFileLoader
- IcuResFileLoader loads translations from a resource bundle.
- IcuResFileLoader
- IcuResFileLoader loads translations from a resource bundle.
- IniFileLoader
- IniFileLoader loads translations from an ini file.
- JsonFileLoader
- JsonFileLoader loads translations from an json file.
- MoFileLoader
- ArrayLoader loads translations from a PHP array.
- PhpFileLoader
- PhpFileLoader loads translations from PHP files returning an array of translations.
- PoFileLoader
- ArrayLoader loads translations from a PHP array.
- QtFileLoader
- QtFileLoader loads translations from QT Translations XML files.
- XliffFileLoader
- XliffFileLoader loads translations from XLIFF files.
- YamlFileLoader
- YamlFileLoader loads translations from Yaml files.
- LoggingTranslator
- MessageCatalogue
- MessageSelector
- MessageSelector.
- PluralizationRules
- Returns the plural rules for a given locale.
- TranslationReader
- TranslationReader reads translation messages from translation files.
- Translator
- ArrayConverter
- ArrayConverter generates tree like structure from a message catalogue.
- XliffUtils
- Provides some utility methods for XLIFF translation files, such as validating their contents according to the XSD schema.
- TranslationWriter
- TranslationWriter writes translation messages.
- TranslatorTest
- Test should cover all languages mentioned on http://translate.sourceforge.net/wiki/l10n/pluralforms and Plural forms mentioned on http://www.gnu.org/software/gettext/manual/gettext.html#Plural-forms.
- AmqpCaster
- Casts Amqp related classes to array representation.
- ArgsStub
- Represents a list of function arguments.
- Caster
- Helper for filtering out properties in casters.
- ClassStub
- Represents a PHP class identifier.
- ConstStub
- Represents a PHP constant and its value.
- CutArrayStub
- Represents a cut array.
- CutStub
- Represents the main properties of a PHP variable, pre-casted by a caster.
- DateCaster
- Casts DateTimeInterface related classes to array representation.
- DoctrineCaster
- Casts Doctrine related classes to array representation.
- DOMCaster
- Casts DOM related classes to array representation.
- DsCaster
- Casts Ds extension classes to array representation.
- DsPairStub
- Represents the main properties of a PHP variable.
- EnumStub
- Represents an enumeration of values.
- ExceptionCaster
- Casts common Exception classes to array representation.
- FrameStub
- Represents a single backtrace frame as returned by debug_backtrace() or Exception->getTrace().
- GmpCaster
- Casts GMP objects to array representation.
- ImagineCaster
- ImgStub
- Represents a PHP constant and its value.
- IntlCaster
- LinkStub
- Represents a file or a URL.
- MemcachedCaster
- PdoCaster
- Casts PDO related classes to array representation.
- PgSqlCaster
- Casts pqsql resources to array representation.
- ProxyManagerCaster
- RedisCaster
- Casts Redis class from ext-redis to array representation.
- ReflectionCaster
- Casts Reflector related classes to array representation.
- ResourceCaster
- Casts common resource types to array representation.
- SplCaster
- Casts SPL related classes to array representation.
- StubCaster
- Casts a caster's Stub.
- SymfonyCaster
- TraceStub
- Represents a backtrace as returned by debug_backtrace() or Exception->getTrace().
- UuidCaster
- XmlReaderCaster
- Casts XmlReader class to array representation.
- XmlResourceCaster
- Casts XML resources to array representation.
- AbstractCloner
- AbstractCloner implements a generic caster mechanism for objects and resources.
- Cursor
- Represents the current state of a dumper while dumping.
- Data
- Stub
- Represents the main properties of a PHP variable.
- VarCloner
- AbstractCloner implements a generic caster mechanism for objects and resources.
- CliDescriptor
- Describe collected data clones for cli output.
- HtmlDescriptor
- Describe collected data clones for html output.
- ServerDumpCommand
- Starts a dump server to collect and output dumps on a single place with multiple formats support.
- AbstractDumper
- Abstract mechanism for dumping a Data object.
- CliDumper
- CliDumper dumps variables for command line output.
- CliContextProvider
- Tries to provide context on CLI.
- RequestContextProvider
- Tries to provide context from a request.
- SourceContextProvider
- Tries to provide context from sources (class name, file, line, code excerpt, ...).
- ContextualizedDumper
- HtmlDumper
- HtmlDumper dumps variables as HTML.
- ServerDumper
- ServerDumper forwards serialized Data clones to a server.
- ThrowingCasterException
- Connection
- Forwards serialized Data clones to a server.
- DumpServer
- A server collecting Data clones sent by a ServerDumper.
- VarDumper
- ClassNotFoundException
- NotInstantiableTypeException
- Instantiator
- A utility class to create objects without calling their constructor.
- VarExporter
- Exports serializable PHP values to PHP code.
- VimeoException
- VimeoException class for general failures.
- VimeoRequestException
- VimeoRequestException class for failure to make request.
- VimeoUploadException
- VimeoUploadException class for failure to upload to the server.
- TusClient
- Vimeo
- VimeoTest
- ManifestContentAdmin
- CustomerDashboard
- Define common system widget object This is the default and minimal form of a system widget object used in all file access systems.
- ImportContentRowParam
- Used in hook before content row import
- Archive
- Intl
- Intl abstraction layer
- DataHash
- MainFolder
- RangeActive
- TextAuthor
- Trait TextAuthor
- ContextSuperGlobals
- WithSelfRegister
- Define interface to register job runner
- WithSingle
- Define interface to register a single job runner
- MessageTrait
- Trait implementing functionality common to requests and responses.
- StreamDecoratorTrait
- Stream decorator trait
- LoggerAwareTrait
- Basic Implementation of LoggerAwareInterface.
- LoggerTrait
- This is a simple Logger trait that classes unable to extend AbstractLogger (because they extend another class, etc) can include.
- PatternPluginManagerTrait
- Trait providing common logic between FormElementManager implementations.
- SerializationTrait
- Provides common functionality surrounding value de/serialization as required by both PSR-6 and PSR-16
- PluginManagerLookupTrait
- EventManagerAwareTrait
- A trait for objects that provide events.
- ListenerAggregateTrait
- Provides logic to easily create aggregate listeners, without worrying about manually detaching events
- EventListenerIntrospectionTrait
- Trait providing utility methods and assertions for use in PHPUnit test cases.
- CommonPluginManagerTrait
- Trait for testing plugin managers for v2-v3 compatibility
- AllGuardsTrait
- An aggregate for all guard traits
- ArrayOrTraversableGuardTrait
- Provide a guard method for array or Traversable data
- EmptyGuardTrait
- Provide a guard method against empty data
- NullGuardTrait
- Provide a guard method against null data
- MessageTrait
- Trait implementing functionality common to requests and responses.
- StreamDecoratorTrait
- Stream decorator trait
- CarbonTypeConverter
- Boundaries
- Trait Boundaries.
- Cast
- Trait Cast.
- Comparison
- Trait Comparison.
- Converter
- Trait Converter.
- Creator
- Trait Creator.
- Date
- A simple API extension for DateTime.
- Difference
- Trait Difference.
- IntervalRounding
- Trait to call rounding methods to interval or the interval of a period.
- Localization
- Trait Localization.
- Macro
- Trait Boundaries.
- Mixin
- Trait Boundaries.
- Modifiers
- Trait Modifiers.
- Mutability
- Trait Mutability.
- ObjectInitialisation
- Options
- Trait Options.
- Rounding
- Trait Rounding.
- Serialization
- Trait Serialization.
- Test
- Timestamp
- Trait Timestamp.
- Units
- Trait Units.
- Week
- Trait Week.
- LoggerAwareTrait
- Basic Implementation of LoggerAwareInterface.
- LoggerTrait
- This is a simple Logger trait that classes unable to extend AbstractLogger (because they extend another class, etc) can include.
- TypeTrait
- Provides functionality to check values for specific types.
- ValueExtractorTrait
- Provides functionality to extract the value of a property or method from an object.
- ValueToStringTrait
- Provides functionality to express a value as string
- DeprecatedUuidMethodsTrait
- This trait encapsulates deprecated methods for ramsey/uuid; this trait and its methods will be removed in ramsey/uuid 5.0.0.
- SerializableFieldsTrait
- Provides common serialization functionality to fields
- NilTrait
- Provides common functionality for nil UUIDs
- VariantTrait
- Provides common functionality for handling the variant, as defined by RFC 4122
- VersionTrait
- Provides common functionality for handling the version, as defined by RFC 4122
- CacheTrait
- An implementation of CacheInterface for PSR-6 CacheItemPoolInterface classes.
- LockableTrait
- Basic lock feature for commands.
- TesterTrait
- ReferenceSetArgumentTrait
- PriorityTaggedServiceTrait
- Trait that allows a generic method to find and sort service by priority option in the tag.
- ContainerAwareTrait
- ContainerAware trait.
- AbstractTrait
- ArgumentTrait
- AutoconfigureTrait
- AutowireTrait
- BindTrait
- CallTrait
- ClassTrait
- ConfiguratorTrait
- DecorateTrait
- DeprecateTrait
- FactoryTrait
- FileTrait
- LazyTrait
- ParentTrait
- PropertyTrait
- PublicTrait
- ShareTrait
- SyntheticTrait
- TagTrait
- MicroKernelTrait
- A Kernel that provides configuration hooks.
- BrowserKitAssertionsTrait
- Ideas borrowed from Laravel Dusk's assertions.
- DomCrawlerAssertionsTrait
- Ideas borrowed from Laravel Dusk's assertions.
- MailerAssertionsTrait
- WebTestAssertionsTrait
- AddTrait
- RouteTrait
- ServiceLocatorTrait
- A trait to help implement ServiceProviderInterface.
- ServiceSubscriberTrait
- Implementation of ServiceSubscriberInterface that determines subscribed services from private method return types. Service ids are available as "ClassName::methodName".
- TranslatorTrait
- A trait to help implement TranslatorInterface and LocaleAwareInterface.
- VarDumperTestTrait
- PluginIsInContext
- ChildAddress
- ParallelSearchIndex
Table of Contents
- APPLICATION_SWOOLE = \false
- FAA_APCU_ENABLED = \true
- FAA_APP_MAX_VERSION = '1.1.0'
- FAA_APP_MIN_VERSION = '0.4.0'
- FAA_APPLICATION_CDN_HANDLER = \false
- FAA_APPLICATION_SEARCH_HANDLER = 'Solarium'
- FAA_ASSET_PASS = '23c8d367124f1ef55f07624790e7809e'
- FAA_ASSET_URL = 'http://asset-service.local'
- FAA_ASSET_USER = 'service'
- FAA_AV_DISABLED = \false
- FAA_AV_PASS = 'R1MeHaFzQqa4tRpW'
- FAA_AV_URL = 'http://av-gateway.local:3000'
- FAA_AV_USER = 'user'
- FAA_CACHE_CACERT = \FAA_PATHS_VAR . \FAA_DATAABS . '/ca.crt'
- FAA_CACHE_CERT = \FAA_PATHS_VAR . \FAA_DATAABS . '/client.pem'
- FAA_CACHE_CERTPASS = 'default'
- FAA_CACHE_COSMIC = \true
- FAA_CACHE_FILE = \false
- FAA_CACHE_ID_FETCH = 25
- FAA_CACHE_ID_MIN_THRESHOLD = 10
- FAA_CACHE_LOG = \true
- FAA_CACHE_LOG_FILE = ''
- FAA_CACHE_REDIS = \true
- FAA_CACHE_REDIS_PASS = \trim(\file_get_contents('/var/www/.redis_pass'))
- FAA_CACHE_REDIS_PATH = ''
- FAA_CACHE_REDIS_TTL = 84600
- FAA_CACHE_TEMPLATE = \true
- FAA_CHANGE_LOG_MAX_AGE = 31536000
- FAA_CHANGE_LOG_MIN_LENGTH = 1000
- FAA_CODE = '73a90acaae2b1ccc0e969709665bc62f'
- FAA_CODE_IV = '12345678'
- FAA_CRON_IDENTIFIER = 'b3daf67d5720c469eac5060a90fa6330'
- FAA_CRON_MAXAGE = 172800
- FAA_CRON_PARALELLS = 10
- FAA_DATA_BRANCH = 'master'
- FAA_DATAABS = 'andromeda.data'
- FAA_DATE = 'Y-m-d H:i:s'
- FAA_DATE_SHORT = 'Y-m-d H:i'
- FAA_DB_HOST = ''
- FAA_DB_NAME = ''
- FAA_DB_PASS = ''
- FAA_DB_USER = ''
- FAA_DBAL_NAME = 'Doctrine'
- FAA_DEFAULT_ENCODING_SET = 'utf-8'
- FAA_DEFAULT_LANGUAGE = 'en'
- FAA_GIT_DEFAULT_HASH = '0000000000000000000000000000000000000000'
- FAA_HTML_TEMPLATE_IMAGE = '<img src="{url}" title="{title}" alt="{title}" width="{width}" height="{height}" />'
- FAA_HTML_TEMPLATE_LINK = '<a title="{title}" href="{href}" class="orion-link"{blank}>{title}</a>'
- FAA_HTTP_CACHE_BROWSER = \false
- FAA_HTTP_CACHE_BROWSER_DURATION = 84600
- FAA_HTTP_CACHE_SHOW_TIMES = \true
- FAA_ID_URL = 'https://id-server.local'
- FAA_IDENTIFY = 'andromeda.data'
- FAA_LOCALE = 'de_DE'
- FAA_LOCALE_KEY_CUT = 100
- FAA_LOG_BACKTRACE = \false
- FAA_LOG_DEBUG_BASKET = \true
- FAA_LOG_DEBUG_GENERAL = \false
- FAA_LOG_DEBUG_JOB = \false
- FAA_LOG_DEBUG_NAVIGATION = \false
- FAA_LOG_DEBUG_SEARCH = \false
- FAA_LOG_EMPTY = \false
- FAA_LOG_ERROR_DECRYPT = \true
- FAA_LOG_ERROR_ENABLED = \true
- FAA_LOG_ERROR_MINIMAL = \false
- FAA_LOG_ERROR_TERMINATE = \true
- FAA_LOG_LEVEL_DEBUG = 'debug'
- FAA_LOG_LEVEL_ERROR = 'error'
- FAA_LOG_LEVEL_INFO = 'info'
- FAA_LOG_LEVEL_WARN = 'warn'
- FAA_LOG_SUFFIX = 'error'
- FAA_MAIL_ENCODING = 'utf-8'
- FAA_MAIL_WORD_WRAP = 80
- FAA_MINIFY_INCLUDES = \true
- FAA_MINIFY_URL = ''
- FAA_PATHS_ASR = \FAA_PATHS_ROOTABS . 'core/asr/'
- FAA_PATHS_ASSETS = '/tmp/' . \FAA_IDENTIFY . '/' . \FAA_DATAABS . '/compiled/'
- FAA_PATHS_CACHE = \FAA_PATHS_TMPABS . 'cache/'
- FAA_PATHS_CACHE_LEN = \strlen(\FAA_PATHS_CACHE)
- FAA_PATHS_CFGABS = \FAA_PATHS_ROOTABS . 'core/cfg/'
- FAA_PATHS_DATA_REAL = \FAA_PATHS_REAL . \FAA_DATAABS . '/'
- FAA_PATHS_DATAABS = \FAA_PATHS_ROOTABS . \FAA_DATAABS . '/'
- FAA_PATHS_GENERIC = \FAA_PATHS_LIBABS . 'obj/generic/'
- FAA_PATHS_GENERIC_CRON = \FAA_PATHS_LIBABS . 'cron/'
- FAA_PATHS_GENERIC_TPL = \FAA_PATHS_LIBABS . 'template/'
- FAA_PATHS_LIBABS = \FAA_PATHS_ROOTABS . 'core/lib/'
- FAA_PATHS_LOCAL_CONFIG = \FAA_PATHS_ROOTABS . 'local.config/'
- FAA_PATHS_LOG = '/var/log/php-fpm/default.log'
- FAA_PATHS_LOG_DIR = \FAA_PATHS_ROOTABS . 'log/'
- FAA_PATHS_REAL = \realpath(\FAA_PATHS_ROOTABS) . '/'
- FAA_PATHS_ROOTABS = \realpath(__DIR__ . '/../../') . '/'
- FAA_PATHS_TEMPLATE = \FAA_PATHS_TMPABS . 'template/'
- FAA_PATHS_TMP_ROOT = '/tmp/' . \FAA_IDENTIFY . '/' . \FAA_DATAABS . '/'
- FAA_PATHS_TMPABS = '/tmp/' . \FAA_IDENTIFY . '/' . \FAA_DATAABS . '/' . \FAA_DATA_BRANCH . '/'
- FAA_PATHS_UPLOADS = \FAA_PATHS_TMPABS . 'upload/'
- FAA_PATHS_VAR = \FAA_PATHS_ROOTABS . 'var/'
- FAA_PATHS_VARABS = \FAA_PATHS_VAR . \FAA_DATAABS . '/' . \FAA_DATA_BRANCH . '/'
- FAA_PATHS_WEB = \FAA_PATHS_ROOTABS . 'core/html/'
- FAA_PATHS_WIDGETS = \FAA_PATHS_LIBABS . 'widgets/'
- FAA_REGEX_ASCII = '/^\\w+$/'
- FAA_REGEX_ASCII_EXTENDED = '/^[0-9a-zA-Z_\\-\\+ \\.]+$/'
- FAA_REGEX_ASCII_EXTENDED_INVERSE = '/[^0-9a-zA-Z_\\-\\+ \\.]/'
- FAA_REGEX_DATE = '/^(\\d{4}-\\d{1,2}-\\d{1,2})|(\\d{1,2}\\.\\d{1,2}\\.\\d{4})$/'
- FAA_REGEX_DATE_SHORT = '/^\\d{4}-\\d{1,2}-\\d{1,2} \\d{1,2}\\.\\d{1,2}$/'
- FAA_REGEX_DATETIME = '/^((\\d{4}-\\d{1,2}-\\d{1,2})|(\\d{1,2}\\.\\d{1,2}\\.\\d{4})) ?\\d{2}\\:\\d{2}(\\:\\d{2})?$/'
- FAA_REGEX_EMAIL = '/^[\\w-]+(\\.[\\w-]+)*@([a-z0-9-]+(\\.[a-z0-9-]+)*?\\.[a-z]{2,6}|(\\d{1,3}\\.){3}\\d{1,3})(:\\d{4})?$/'
- FAA_REGEX_ENDPOINT = '/^[\\/#]\\^.*\\$[\\/#]$/'
- FAA_REGEX_FLOAT = '/^\\d+(\\.\\d+)?$/'
- FAA_REGEX_INT = '/^\\d+$/'
- FAA_REGEX_MD5 = '/^\\w{32}$/'
- FAA_REGEX_PHONE = '/^[0-9\\/\\(\\) \\+\\-]+$/'
- FAA_REGEX_UUID = '[0-9a-fA-F]{8}\\-[0-9a-fA-F]{4}\\-[0-9a-fA-F]{4}\\-[0-9a-fA-F]{4}\\-[0-9a-fA-F]{12}'
- FAA_REGEX_ZIP = '/^[ \\/\\-a-zA-Z0-9]+$/'
- FAA_REQUEST_ARG_FORMAT_INT = 1
- FAA_REQUEST_ARG_FORMAT_NONE = 0
- FAA_RESPONSE_TYPE_ATTACHMENT = 2
- FAA_RESPONSE_TYPE_ATTACHMENT_AUTO = 8
- FAA_RESPONSE_TYPE_ATTACHMENT_HTML = 10
- FAA_RESPONSE_TYPE_ATTACHMENT_SCRIPT = 9
- FAA_RESPONSE_TYPE_ATTACHMENT_XML = 11
- FAA_RESPONSE_TYPE_CORS = 3
- FAA_RESPONSE_TYPE_CUSTOM = 7
- FAA_RESPONSE_TYPE_DIRECT_REDIRECT = 4
- FAA_RESPONSE_TYPE_HTML = 1
- FAA_RESPONSE_TYPE_JSON = 0
- FAA_RESPONSE_TYPE_TXT = 6
- FAA_RESPONSE_TYPE_XML = 5
- FAA_ROOT_USER_ID = ''
- FAA_SESSION_CACHE = \true
- FAA_SESSION_CACHE_PERSISTENT = \true
- FAA_SESSION_CHECK_ANTI_CSRF = \true
- FAA_SESSION_ENABLE_SECOND_FACTOR = \true
- FAA_SESSION_KEY = 'FAA'
- FAA_SESSION_LENGTH = 592200
- FAA_SESSION_LOGIN_CASEINVARIANT = \true
- FAA_SESSION_LOGIN_ID = \true
- FAA_SESSION_MAX_TRY = 12
- FAA_SESSION_NAME = 'FileAccess'
- FAA_SESSION_PHOENIX_ACCOUNT = ''
- FAA_SESSION_ROOT_FIXED = \FAA_ROOT_USER_ID
- FAA_SESSION_VISITOR_GROUP = 'visitor'
- FAA_SOLRDATE = 'Y-m-d\\TH:i:s\\Z'
- FAA_SYSTEM_CODENAME = 'Andromeda'
- FAA_SYSTEM_TIME = \microtime(\true)
- FAA_TIMEZONE = 'Europe/Berlin'
- FAA_WRITE_RETRY = 200
- FAA_WRITE_RETRY_GIT = 150
- IDNA_ALLOW_UNASSIGNED = 1
- IDNA_CHECK_BIDI = 4
- IDNA_CHECK_CONTEXTJ = 8
- IDNA_DEFAULT = 0
- IDNA_ERROR_BIDI = 2048
- IDNA_ERROR_CONTEXTJ = 4096
- IDNA_ERROR_DISALLOWED = 128
- IDNA_ERROR_DOMAIN_NAME_TOO_LONG = 4
- IDNA_ERROR_EMPTY_LABEL = 1
- IDNA_ERROR_HYPHEN_3_4 = 32
- IDNA_ERROR_INVALID_ACE_LABEL = 1024
- IDNA_ERROR_LABEL_HAS_DOT = 512
- IDNA_ERROR_LABEL_TOO_LONG = 2
- IDNA_ERROR_LEADING_COMBINING_MARK = 64
- IDNA_ERROR_LEADING_HYPHEN = 8
- IDNA_ERROR_PUNYCODE = 256
- IDNA_ERROR_TRAILING_HYPHEN = 16
- IDNA_NONTRANSITIONAL_TO_ASCII = 16
- IDNA_NONTRANSITIONAL_TO_UNICODE = 32
- IDNA_USE_STD3_RULES = 2
- INTL_IDNA_VARIANT_2003 = 0
- INTL_IDNA_VARIANT_UTS46 = 1
- MB_CASE_LOWER = 1
- MB_CASE_TITLE = 2
- MB_CASE_UPPER = 0
- PHP_FLOAT_DIG = 15
- PHP_FLOAT_EPSILON = 2.2204460492503E-16
- PHP_FLOAT_MAX = 1.7976931348623157E+308
- PHP_FLOAT_MIN = 2.2250738585072E-308
- PHP_OS_FAMILY = \Symfony\Polyfill\Php72\Php72::php_os_family()
- U_IDNA_ACE_PREFIX_ERROR = 66564
- U_IDNA_CHECK_BIDI_ERROR = 66562
- U_IDNA_DOMAIN_NAME_TOO_LONG_ERROR = 66568
- U_IDNA_ERROR_LIMIT = 66569
- U_IDNA_ERROR_START = 66560
- U_IDNA_LABEL_TOO_LONG_ERROR = 66566
- U_IDNA_PROHIBITED_ERROR = 66560
- U_IDNA_STD3_ASCII_RULES_ERROR = 66563
- U_IDNA_UNASSIGNED_ERROR = 66561
- U_IDNA_VERIFICATION_ERROR = 66565
- U_IDNA_ZERO_LENGTH_LABEL_ERROR = 66567
- U_STRINGPREP_CHECK_BIDI_ERROR = 66562
- U_STRINGPREP_PROHIBITED_ERROR = 66560
- U_STRINGPREP_UNASSIGNED_ERROR = 66561
- composerRequirec2e05b3412b5b96739da81506749a3d1() : mixed
- includeFile() : mixed
- Scope isolated include.
- uri_template() : string
- Expands a URI template
- describe_type() : string
- Debug function used to describe the provided value type and class.
- headers_from_lines() : array<string|int, mixed>
- Parses an array of header lines into an associative array of headers.
- debug_resource() : resource
- Returns a debug stream based on the provided variable.
- choose_handler() : callable
- Chooses and creates a default handler to use based on the environment.
- default_user_agent() : string
- Get the default User-Agent string to use with Guzzle
- default_ca_bundle() : string
- Returns the default cacert bundle for the current system.
- normalize_header_keys() : array<string|int, mixed>
- Creates an associative array of lowercase header names to the actual header casing.
- is_host_in_noproxy() : bool
- Returns true if the provided host matches any of the no proxy areas.
- json_decode() : mixed
- Wrapper for json_decode that throws when an error occurs.
- json_encode() : string
- Wrapper for JSON encoding that throws when an error occurs.
- queue() : TaskQueueInterface
- Get the global task queue used for promise resolution.
- task() : PromiseInterface
- Adds a function to run in the task queue when it is next `run()` and returns a promise that is fulfilled or rejected with the result.
- promise_for() : PromiseInterface
- Creates a promise for a value if the value is not a promise.
- rejection_for() : PromiseInterface
- Creates a rejected promise for a reason if the reason is not a promise. If the provided reason is a promise, then it is returned as-is.
- exception_for() : Exception|Throwable
- Create an exception for a rejected promise value.
- iter_for() : Iterator
- Returns an iterator for the given value.
- inspect() : array<string|int, mixed>
- Synchronously waits on a promise to resolve and returns an inspection state array.
- inspect_all() : array<string|int, mixed>
- Waits on all of the provided promises, but does not unwrap rejected promises as thrown exception.
- unwrap() : array<string|int, mixed>
- Waits on all of the provided promises and returns the fulfilled values.
- all() : PromiseInterface
- Given an array of promises, return a promise that is fulfilled when all the items in the array are fulfilled.
- some() : PromiseInterface
- Initiate a competitive race between multiple promises or values (values will become immediately fulfilled promises).
- any() : PromiseInterface
- Like some(), with 1 as count. However, if the promise fulfills, the fulfillment value is not an array of 1 but the value directly.
- settle() : PromiseInterface
- Returns a promise that is fulfilled when all of the provided promises have been fulfilled or rejected.
- each() : PromiseInterface
- Given an iterator that yields promises or values, returns a promise that is fulfilled with a null value when the iterator has been consumed or the aggregate promise has been fulfilled or rejected.
- each_limit() : PromiseInterface
- Like each, but only allows a certain number of outstanding promises at any given time.
- each_limit_all() : PromiseInterface
- Like each_limit, but ensures that no promise in the given $iterable argument is rejected. If any promise is rejected, then the aggregate promise is rejected with the encountered rejection.
- is_fulfilled() : bool
- Returns true if a promise is fulfilled.
- is_rejected() : bool
- Returns true if a promise is rejected.
- is_settled() : bool
- Returns true if a promise is fulfilled or rejected.
- coroutine() : PromiseInterface
- str() : string
- Returns the string representation of an HTTP message.
- uri_for() : UriInterface
- Returns a UriInterface for the given value.
- stream_for() : StreamInterface
- Create a new stream based on the input type.
- parse_header() : array<string|int, mixed>
- Parse an array of header values containing ";" separated data into an array of associative arrays representing the header key value pair data of the header. When a parameter does not contain a value, but just contains a key, this function will inject a key with a '' string value.
- normalize_header() : array<string|int, mixed>
- Converts an array of header values that may contain comma separated headers into an array of headers with no comma separated values.
- modify_request() : RequestInterface
- Clone and modify a request with the given changes.
- rewind_body() : mixed
- Attempts to rewind a message body and throws an exception on failure.
- try_fopen() : resource
- Safely opens a PHP stream resource using a filename.
- copy_to_string() : string
- Copy the contents of a stream into a string until the given number of bytes have been read.
- copy_to_stream() : mixed
- Copy the contents of a stream into another stream until the given number of bytes have been read.
- hash() : string
- Calculate a hash of a Stream
- readline() : string
- Read a line from the stream up to the maximum allowed buffer length
- parse_request() : Request
- Parses a request message string into a request object.
- parse_response() : Response
- Parses a response message string into a response object.
- parse_query() : array<string|int, mixed>
- Parse a query string into an associative array.
- build_query() : string
- Build a query string from an array of key value pairs.
- mimetype_from_filename() : null|string
- Determines the mimetype of a file by looking at its extension.
- mimetype_from_extension() : string|null
- Maps a file extensions to a mimetype.
- get_message_body_summary() : null|string
- Get a short summary of the message body
- getallheaders() : mixed
- Get all HTTP header key/values as an associative array for the current request.
- composerRequire94a925f1e94190dddeabac0607d3aa7a() : mixed
- includeFile() : mixed
- Scope isolated include.
- uri_template() : string
- Expands a URI template
- describe_type() : string
- Debug function used to describe the provided value type and class.
- headers_from_lines() : array<string|int, mixed>
- Parses an array of header lines into an associative array of headers.
- debug_resource() : resource
- Returns a debug stream based on the provided variable.
- choose_handler() : callable
- Chooses and creates a default handler to use based on the environment.
- default_user_agent() : string
- Get the default User-Agent string to use with Guzzle
- default_ca_bundle() : string
- Returns the default cacert bundle for the current system.
- normalize_header_keys() : array<string|int, mixed>
- Creates an associative array of lowercase header names to the actual header casing.
- is_host_in_noproxy() : bool
- Returns true if the provided host matches any of the no proxy areas.
- json_decode() : mixed
- Wrapper for json_decode that throws when an error occurs.
- json_encode() : string
- Wrapper for JSON encoding that throws when an error occurs.
- queue() : TaskQueueInterface
- Get the global task queue used for promise resolution.
- task() : PromiseInterface
- Adds a function to run in the task queue when it is next `run()` and returns a promise that is fulfilled or rejected with the result.
- promise_for() : PromiseInterface
- Creates a promise for a value if the value is not a promise.
- rejection_for() : PromiseInterface
- Creates a rejected promise for a reason if the reason is not a promise. If the provided reason is a promise, then it is returned as-is.
- exception_for() : Exception|Throwable
- Create an exception for a rejected promise value.
- iter_for() : Iterator
- Returns an iterator for the given value.
- inspect() : array<string|int, mixed>
- Synchronously waits on a promise to resolve and returns an inspection state array.
- inspect_all() : array<string|int, mixed>
- Waits on all of the provided promises, but does not unwrap rejected promises as thrown exception.
- unwrap() : array<string|int, mixed>
- Waits on all of the provided promises and returns the fulfilled values.
- all() : PromiseInterface
- Given an array of promises, return a promise that is fulfilled when all the items in the array are fulfilled.
- some() : PromiseInterface
- Initiate a competitive race between multiple promises or values (values will become immediately fulfilled promises).
- any() : PromiseInterface
- Like some(), with 1 as count. However, if the promise fulfills, the fulfillment value is not an array of 1 but the value directly.
- settle() : PromiseInterface
- Returns a promise that is fulfilled when all of the provided promises have been fulfilled or rejected.
- each() : PromiseInterface
- Given an iterator that yields promises or values, returns a promise that is fulfilled with a null value when the iterator has been consumed or the aggregate promise has been fulfilled or rejected.
- each_limit() : PromiseInterface
- Like each, but only allows a certain number of outstanding promises at any given time.
- each_limit_all() : PromiseInterface
- Like each_limit, but ensures that no promise in the given $iterable argument is rejected. If any promise is rejected, then the aggregate promise is rejected with the encountered rejection.
- is_fulfilled() : bool
- Returns true if a promise is fulfilled.
- is_rejected() : bool
- Returns true if a promise is rejected.
- is_settled() : bool
- Returns true if a promise is fulfilled or rejected.
- coroutine() : PromiseInterface
- str() : string
- Returns the string representation of an HTTP message.
- uri_for() : UriInterface
- Returns a UriInterface for the given value.
- stream_for() : StreamInterface
- Create a new stream based on the input type.
- parse_header() : array<string|int, mixed>
- Parse an array of header values containing ";" separated data into an array of associative arrays representing the header key value pair data of the header. When a parameter does not contain a value, but just contains a key, this function will inject a key with a '' string value.
- normalize_header() : array<string|int, mixed>
- Converts an array of header values that may contain comma separated headers into an array of headers with no comma separated values.
- modify_request() : RequestInterface
- Clone and modify a request with the given changes.
- rewind_body() : mixed
- Attempts to rewind a message body and throws an exception on failure.
- try_fopen() : resource
- Safely opens a PHP stream resource using a filename.
- copy_to_string() : string
- Copy the contents of a stream into a string until the given number of bytes have been read.
- copy_to_stream() : mixed
- Copy the contents of a stream into another stream until the given number of bytes have been read.
- hash() : string
- Calculate a hash of a Stream
- readline() : string
- Read a line from the stream up to the maximum allowed buffer length
- parse_request() : Request
- Parses a request message string into a request object.
- parse_response() : Response
- Parses a response message string into a response object.
- parse_query() : array<string|int, mixed>
- Parse a query string into an associative array.
- build_query() : string
- Build a query string from an array of key value pairs.
- mimetype_from_filename() : null|string
- Determines the mimetype of a file by looking at its extension.
- mimetype_from_extension() : string|null
- Maps a file extensions to a mimetype.
- get_message_body_summary() : null|string
- Get a short summary of the message body
- redis_version() : mixed
- zpop() : mixed
- getallheaders() : mixed
- Get all HTTP header key/values as an associative array for the current request.
- v1() : string
- Returns a version 1 (time-based) UUID from a host ID, sequence number, and the current time
- v2() : string
- Returns a version 2 (DCE Security) UUID from a local domain, local identifier, host ID, clock sequence, and the current time
- v3() : string
- Returns a version 3 (name-based) UUID based on the MD5 hash of a namespace ID and a name
- v4() : string
- Returns a version 4 (random) UUID
- v5() : string
- Returns a version 5 (name-based) UUID based on the SHA-1 hash of a namespace ID and a name
- v6() : string
- Returns a version 6 (ordered-time) UUID from a host ID, sequence number, and the current time
- ref() : ReferenceConfigurator
- Creates a service reference.
- inline() : InlineServiceConfigurator
- Creates an inline service.
- service_locator() : ServiceLocatorArgument
- Creates a service locator.
- iterator() : IteratorArgument
- Creates a lazy iterator.
- tagged_iterator() : TaggedIteratorArgument
- Creates a lazy iterator by tag name.
- tagged_locator() : ServiceLocatorArgument
- Creates a service locator by tag name.
- expr() : Expression
- Creates an expression.
- ctype_alnum() : mixed
- ctype_alpha() : mixed
- ctype_cntrl() : mixed
- ctype_digit() : mixed
- ctype_graph() : mixed
- ctype_lower() : mixed
- ctype_print() : mixed
- ctype_punct() : mixed
- ctype_space() : mixed
- ctype_upper() : mixed
- ctype_xdigit() : mixed
- idn_to_ascii() : mixed
- idn_to_utf8() : mixed
- mb_convert_encoding() : mixed
- mb_decode_mimeheader() : mixed
- mb_encode_mimeheader() : mixed
- mb_decode_numericentity() : mixed
- mb_encode_numericentity() : mixed
- mb_convert_case() : mixed
- mb_internal_encoding() : mixed
- mb_language() : mixed
- mb_list_encodings() : mixed
- mb_encoding_aliases() : mixed
- mb_check_encoding() : mixed
- mb_detect_encoding() : mixed
- mb_detect_order() : mixed
- mb_parse_str() : mixed
- mb_strlen() : mixed
- mb_strpos() : mixed
- mb_strtolower() : mixed
- mb_strtoupper() : mixed
- mb_substitute_character() : mixed
- mb_substr() : mixed
- mb_stripos() : mixed
- mb_stristr() : mixed
- mb_strrchr() : mixed
- mb_strrichr() : mixed
- mb_strripos() : mixed
- mb_strrpos() : mixed
- mb_strstr() : mixed
- mb_get_info() : mixed
- mb_http_output() : mixed
- mb_strwidth() : mixed
- mb_substr_count() : mixed
- mb_output_handler() : mixed
- mb_http_input() : mixed
- mb_convert_variables() : mixed
- mb_ord() : mixed
- mb_chr() : mixed
- mb_scrub() : mixed
- mb_str_split() : mixed
- sapi_windows_vt100_support() : mixed
- stream_isatty() : mixed
- utf8_encode() : mixed
- utf8_decode() : mixed
- spl_object_id() : mixed
- mb_ord() : mixed
- mb_chr() : mixed
- mb_scrub() : mixed
- is_countable() : mixed
- hrtime() : mixed
- array_key_first() : mixed
- array_key_last() : mixed
- findTranslationFiles() : mixed
- calculateTranslationStatus() : mixed
- printTranslationStatus() : mixed
- extractLocaleFromFilePath() : mixed
- extractTranslationKeys() : mixed
- printTitle() : mixed
- printTable() : mixed
- textColorGreen() : mixed
- textColorRed() : mixed
- textColorNormal() : mixed
- esc() : mixed
- dump() : mixed
- dd() : mixed
Constants
APPLICATION_SWOOLE
public
mixed
APPLICATION_SWOOLE
= \false
FAA_APCU_ENABLED
public
mixed
FAA_APCU_ENABLED
= \true
FAA_APP_MAX_VERSION
public
mixed
FAA_APP_MAX_VERSION
= '1.1.0'
FAA_APP_MIN_VERSION
public
mixed
FAA_APP_MIN_VERSION
= '0.4.0'
FAA_APPLICATION_CDN_HANDLER
public
mixed
FAA_APPLICATION_CDN_HANDLER
= \false
FAA_APPLICATION_SEARCH_HANDLER
public
mixed
FAA_APPLICATION_SEARCH_HANDLER
= 'Solarium'
FAA_ASSET_PASS
public
mixed
FAA_ASSET_PASS
= '23c8d367124f1ef55f07624790e7809e'
FAA_ASSET_URL
public
mixed
FAA_ASSET_URL
= 'http://asset-service.local'
FAA_ASSET_USER
public
mixed
FAA_ASSET_USER
= 'service'
FAA_AV_DISABLED
public
mixed
FAA_AV_DISABLED
= \false
FAA_AV_PASS
public
mixed
FAA_AV_PASS
= 'R1MeHaFzQqa4tRpW'
FAA_AV_URL
public
mixed
FAA_AV_URL
= 'http://av-gateway.local:3000'
FAA_AV_USER
public
mixed
FAA_AV_USER
= 'user'
FAA_CACHE_CACERT
public
mixed
FAA_CACHE_CACERT
= \FAA_PATHS_VAR . \FAA_DATAABS . '/ca.crt'
FAA_CACHE_CERT
public
mixed
FAA_CACHE_CERT
= \FAA_PATHS_VAR . \FAA_DATAABS . '/client.pem'
FAA_CACHE_CERTPASS
public
mixed
FAA_CACHE_CERTPASS
= 'default'
FAA_CACHE_COSMIC
public
mixed
FAA_CACHE_COSMIC
= \true
FAA_CACHE_FILE
public
mixed
FAA_CACHE_FILE
= \false
FAA_CACHE_ID_FETCH
public
mixed
FAA_CACHE_ID_FETCH
= 25
FAA_CACHE_ID_MIN_THRESHOLD
public
mixed
FAA_CACHE_ID_MIN_THRESHOLD
= 10
FAA_CACHE_LOG
public
mixed
FAA_CACHE_LOG
= \true
FAA_CACHE_LOG_FILE
public
mixed
FAA_CACHE_LOG_FILE
= ''
FAA_CACHE_REDIS
public
mixed
FAA_CACHE_REDIS
= \true
FAA_CACHE_REDIS_PASS
public
mixed
FAA_CACHE_REDIS_PASS
= \trim(\file_get_contents('/var/www/.redis_pass'))
FAA_CACHE_REDIS_PATH
public
mixed
FAA_CACHE_REDIS_PATH
= ''
FAA_CACHE_REDIS_TTL
public
mixed
FAA_CACHE_REDIS_TTL
= 84600
FAA_CACHE_TEMPLATE
public
mixed
FAA_CACHE_TEMPLATE
= \true
FAA_CHANGE_LOG_MAX_AGE
public
mixed
FAA_CHANGE_LOG_MAX_AGE
= 31536000
FAA_CHANGE_LOG_MIN_LENGTH
public
mixed
FAA_CHANGE_LOG_MIN_LENGTH
= 1000
FAA_CODE
public
mixed
FAA_CODE
= '73a90acaae2b1ccc0e969709665bc62f'
FAA_CODE_IV
public
mixed
FAA_CODE_IV
= '12345678'
FAA_CRON_IDENTIFIER
public
mixed
FAA_CRON_IDENTIFIER
= 'b3daf67d5720c469eac5060a90fa6330'
FAA_CRON_MAXAGE
public
mixed
FAA_CRON_MAXAGE
= 172800
FAA_CRON_PARALELLS
public
mixed
FAA_CRON_PARALELLS
= 10
FAA_DATA_BRANCH
public
mixed
FAA_DATA_BRANCH
= 'master'
FAA_DATAABS
public
mixed
FAA_DATAABS
= 'andromeda.data'
FAA_DATE
public
mixed
FAA_DATE
= 'Y-m-d H:i:s'
FAA_DATE_SHORT
public
mixed
FAA_DATE_SHORT
= 'Y-m-d H:i'
FAA_DB_HOST
public
mixed
FAA_DB_HOST
= ''
FAA_DB_NAME
public
mixed
FAA_DB_NAME
= ''
FAA_DB_PASS
public
mixed
FAA_DB_PASS
= ''
FAA_DB_USER
public
mixed
FAA_DB_USER
= ''
FAA_DBAL_NAME
public
mixed
FAA_DBAL_NAME
= 'Doctrine'
FAA_DEFAULT_ENCODING_SET
public
mixed
FAA_DEFAULT_ENCODING_SET
= 'utf-8'
FAA_DEFAULT_LANGUAGE
public
mixed
FAA_DEFAULT_LANGUAGE
= 'en'
FAA_GIT_DEFAULT_HASH
public
mixed
FAA_GIT_DEFAULT_HASH
= '0000000000000000000000000000000000000000'
FAA_HTML_TEMPLATE_IMAGE
public
mixed
FAA_HTML_TEMPLATE_IMAGE
= '<img src="{url}" title="{title}" alt="{title}" width="{width}" height="{height}" />'
FAA_HTML_TEMPLATE_LINK
public
mixed
FAA_HTML_TEMPLATE_LINK
= '<a title="{title}" href="{href}" class="orion-link"{blank}>{title}</a>'
FAA_HTTP_CACHE_BROWSER
public
mixed
FAA_HTTP_CACHE_BROWSER
= \false
FAA_HTTP_CACHE_BROWSER_DURATION
public
mixed
FAA_HTTP_CACHE_BROWSER_DURATION
= 84600
FAA_HTTP_CACHE_SHOW_TIMES
public
mixed
FAA_HTTP_CACHE_SHOW_TIMES
= \true
FAA_ID_URL
public
mixed
FAA_ID_URL
= 'https://id-server.local'
FAA_IDENTIFY
public
mixed
FAA_IDENTIFY
= 'andromeda.data'
FAA_LOCALE
public
mixed
FAA_LOCALE
= 'de_DE'
FAA_LOCALE_KEY_CUT
public
mixed
FAA_LOCALE_KEY_CUT
= 100
FAA_LOG_BACKTRACE
public
mixed
FAA_LOG_BACKTRACE
= \false
FAA_LOG_DEBUG_BASKET
public
mixed
FAA_LOG_DEBUG_BASKET
= \true
FAA_LOG_DEBUG_GENERAL
public
mixed
FAA_LOG_DEBUG_GENERAL
= \false
FAA_LOG_DEBUG_JOB
public
mixed
FAA_LOG_DEBUG_JOB
= \false
FAA_LOG_DEBUG_NAVIGATION
public
mixed
FAA_LOG_DEBUG_NAVIGATION
= \false
FAA_LOG_DEBUG_SEARCH
public
mixed
FAA_LOG_DEBUG_SEARCH
= \false
FAA_LOG_EMPTY
public
mixed
FAA_LOG_EMPTY
= \false
FAA_LOG_ERROR_DECRYPT
public
mixed
FAA_LOG_ERROR_DECRYPT
= \true
FAA_LOG_ERROR_ENABLED
public
mixed
FAA_LOG_ERROR_ENABLED
= \true
FAA_LOG_ERROR_MINIMAL
public
mixed
FAA_LOG_ERROR_MINIMAL
= \false
FAA_LOG_ERROR_TERMINATE
public
mixed
FAA_LOG_ERROR_TERMINATE
= \true
FAA_LOG_LEVEL_DEBUG
public
mixed
FAA_LOG_LEVEL_DEBUG
= 'debug'
FAA_LOG_LEVEL_ERROR
public
mixed
FAA_LOG_LEVEL_ERROR
= 'error'
FAA_LOG_LEVEL_INFO
public
mixed
FAA_LOG_LEVEL_INFO
= 'info'
FAA_LOG_LEVEL_WARN
public
mixed
FAA_LOG_LEVEL_WARN
= 'warn'
FAA_LOG_SUFFIX
public
mixed
FAA_LOG_SUFFIX
= 'error'
FAA_MAIL_ENCODING
public
mixed
FAA_MAIL_ENCODING
= 'utf-8'
FAA_MAIL_WORD_WRAP
public
mixed
FAA_MAIL_WORD_WRAP
= 80
FAA_MINIFY_INCLUDES
public
mixed
FAA_MINIFY_INCLUDES
= \true
FAA_MINIFY_URL
public
mixed
FAA_MINIFY_URL
= ''
FAA_PATHS_ASR
public
mixed
FAA_PATHS_ASR
= \FAA_PATHS_ROOTABS . 'core/asr/'
FAA_PATHS_ASSETS
public
mixed
FAA_PATHS_ASSETS
= '/tmp/' . \FAA_IDENTIFY . '/' . \FAA_DATAABS . '/compiled/'
FAA_PATHS_CACHE
public
mixed
FAA_PATHS_CACHE
= \FAA_PATHS_TMPABS . 'cache/'
FAA_PATHS_CACHE_LEN
public
mixed
FAA_PATHS_CACHE_LEN
= \strlen(\FAA_PATHS_CACHE)
FAA_PATHS_CFGABS
public
mixed
FAA_PATHS_CFGABS
= \FAA_PATHS_ROOTABS . 'core/cfg/'
FAA_PATHS_DATA_REAL
public
mixed
FAA_PATHS_DATA_REAL
= \FAA_PATHS_REAL . \FAA_DATAABS . '/'
FAA_PATHS_DATAABS
public
mixed
FAA_PATHS_DATAABS
= \FAA_PATHS_ROOTABS . \FAA_DATAABS . '/'
FAA_PATHS_GENERIC
public
mixed
FAA_PATHS_GENERIC
= \FAA_PATHS_LIBABS . 'obj/generic/'
FAA_PATHS_GENERIC_CRON
public
mixed
FAA_PATHS_GENERIC_CRON
= \FAA_PATHS_LIBABS . 'cron/'
FAA_PATHS_GENERIC_TPL
public
mixed
FAA_PATHS_GENERIC_TPL
= \FAA_PATHS_LIBABS . 'template/'
FAA_PATHS_LIBABS
public
mixed
FAA_PATHS_LIBABS
= \FAA_PATHS_ROOTABS . 'core/lib/'
FAA_PATHS_LOCAL_CONFIG
public
mixed
FAA_PATHS_LOCAL_CONFIG
= \FAA_PATHS_ROOTABS . 'local.config/'
FAA_PATHS_LOG
public
mixed
FAA_PATHS_LOG
= '/var/log/php-fpm/default.log'
FAA_PATHS_LOG_DIR
public
mixed
FAA_PATHS_LOG_DIR
= \FAA_PATHS_ROOTABS . 'log/'
FAA_PATHS_REAL
public
mixed
FAA_PATHS_REAL
= \realpath(\FAA_PATHS_ROOTABS) . '/'
FAA_PATHS_ROOTABS
public
mixed
FAA_PATHS_ROOTABS
= \realpath(__DIR__ . '/../../') . '/'
FAA_PATHS_TEMPLATE
public
mixed
FAA_PATHS_TEMPLATE
= \FAA_PATHS_TMPABS . 'template/'
FAA_PATHS_TMP_ROOT
public
mixed
FAA_PATHS_TMP_ROOT
= '/tmp/' . \FAA_IDENTIFY . '/' . \FAA_DATAABS . '/'
FAA_PATHS_TMPABS
public
mixed
FAA_PATHS_TMPABS
= '/tmp/' . \FAA_IDENTIFY . '/' . \FAA_DATAABS . '/' . \FAA_DATA_BRANCH . '/'
FAA_PATHS_UPLOADS
public
mixed
FAA_PATHS_UPLOADS
= \FAA_PATHS_TMPABS . 'upload/'
FAA_PATHS_VAR
public
mixed
FAA_PATHS_VAR
= \FAA_PATHS_ROOTABS . 'var/'
FAA_PATHS_VARABS
public
mixed
FAA_PATHS_VARABS
= \FAA_PATHS_VAR . \FAA_DATAABS . '/' . \FAA_DATA_BRANCH . '/'
FAA_PATHS_WEB
public
mixed
FAA_PATHS_WEB
= \FAA_PATHS_ROOTABS . 'core/html/'
FAA_PATHS_WIDGETS
public
mixed
FAA_PATHS_WIDGETS
= \FAA_PATHS_LIBABS . 'widgets/'
FAA_REGEX_ASCII
public
mixed
FAA_REGEX_ASCII
= '/^\\w+$/'
FAA_REGEX_ASCII_EXTENDED
public
mixed
FAA_REGEX_ASCII_EXTENDED
= '/^[0-9a-zA-Z_\\-\\+ \\.]+$/'
FAA_REGEX_ASCII_EXTENDED_INVERSE
public
mixed
FAA_REGEX_ASCII_EXTENDED_INVERSE
= '/[^0-9a-zA-Z_\\-\\+ \\.]/'
FAA_REGEX_DATE
public
mixed
FAA_REGEX_DATE
= '/^(\\d{4}-\\d{1,2}-\\d{1,2})|(\\d{1,2}\\.\\d{1,2}\\.\\d{4})$/'
FAA_REGEX_DATE_SHORT
public
mixed
FAA_REGEX_DATE_SHORT
= '/^\\d{4}-\\d{1,2}-\\d{1,2} \\d{1,2}\\.\\d{1,2}$/'
FAA_REGEX_DATETIME
public
mixed
FAA_REGEX_DATETIME
= '/^((\\d{4}-\\d{1,2}-\\d{1,2})|(\\d{1,2}\\.\\d{1,2}\\.\\d{4})) ?\\d{2}\\:\\d{2}(\\:\\d{2})?$/'
FAA_REGEX_EMAIL
public
mixed
FAA_REGEX_EMAIL
= '/^[\\w-]+(\\.[\\w-]+)*@([a-z0-9-]+(\\.[a-z0-9-]+)*?\\.[a-z]{2,6}|(\\d{1,3}\\.){3}\\d{1,3})(:\\d{4})?$/'
FAA_REGEX_ENDPOINT
public
mixed
FAA_REGEX_ENDPOINT
= '/^[\\/#]\\^.*\\$[\\/#]$/'
FAA_REGEX_FLOAT
public
mixed
FAA_REGEX_FLOAT
= '/^\\d+(\\.\\d+)?$/'
FAA_REGEX_INT
public
mixed
FAA_REGEX_INT
= '/^\\d+$/'
FAA_REGEX_MD5
public
mixed
FAA_REGEX_MD5
= '/^\\w{32}$/'
FAA_REGEX_PHONE
public
mixed
FAA_REGEX_PHONE
= '/^[0-9\\/\\(\\) \\+\\-]+$/'
FAA_REGEX_UUID
public
mixed
FAA_REGEX_UUID
= '[0-9a-fA-F]{8}\\-[0-9a-fA-F]{4}\\-[0-9a-fA-F]{4}\\-[0-9a-fA-F]{4}\\-[0-9a-fA-F]{12}'
FAA_REGEX_ZIP
public
mixed
FAA_REGEX_ZIP
= '/^[ \\/\\-a-zA-Z0-9]+$/'
FAA_REQUEST_ARG_FORMAT_INT
public
mixed
FAA_REQUEST_ARG_FORMAT_INT
= 1
FAA_REQUEST_ARG_FORMAT_NONE
public
mixed
FAA_REQUEST_ARG_FORMAT_NONE
= 0
FAA_RESPONSE_TYPE_ATTACHMENT
public
mixed
FAA_RESPONSE_TYPE_ATTACHMENT
= 2
FAA_RESPONSE_TYPE_ATTACHMENT_AUTO
public
mixed
FAA_RESPONSE_TYPE_ATTACHMENT_AUTO
= 8
FAA_RESPONSE_TYPE_ATTACHMENT_HTML
public
mixed
FAA_RESPONSE_TYPE_ATTACHMENT_HTML
= 10
FAA_RESPONSE_TYPE_ATTACHMENT_SCRIPT
public
mixed
FAA_RESPONSE_TYPE_ATTACHMENT_SCRIPT
= 9
FAA_RESPONSE_TYPE_ATTACHMENT_XML
public
mixed
FAA_RESPONSE_TYPE_ATTACHMENT_XML
= 11
FAA_RESPONSE_TYPE_CORS
public
mixed
FAA_RESPONSE_TYPE_CORS
= 3
FAA_RESPONSE_TYPE_CUSTOM
public
mixed
FAA_RESPONSE_TYPE_CUSTOM
= 7
FAA_RESPONSE_TYPE_DIRECT_REDIRECT
public
mixed
FAA_RESPONSE_TYPE_DIRECT_REDIRECT
= 4
FAA_RESPONSE_TYPE_HTML
public
mixed
FAA_RESPONSE_TYPE_HTML
= 1
FAA_RESPONSE_TYPE_JSON
public
mixed
FAA_RESPONSE_TYPE_JSON
= 0
FAA_RESPONSE_TYPE_TXT
public
mixed
FAA_RESPONSE_TYPE_TXT
= 6
FAA_RESPONSE_TYPE_XML
public
mixed
FAA_RESPONSE_TYPE_XML
= 5
FAA_ROOT_USER_ID
public
mixed
FAA_ROOT_USER_ID
= ''
FAA_SESSION_CACHE
public
mixed
FAA_SESSION_CACHE
= \true
FAA_SESSION_CACHE_PERSISTENT
public
mixed
FAA_SESSION_CACHE_PERSISTENT
= \true
FAA_SESSION_CHECK_ANTI_CSRF
public
mixed
FAA_SESSION_CHECK_ANTI_CSRF
= \true
FAA_SESSION_ENABLE_SECOND_FACTOR
public
mixed
FAA_SESSION_ENABLE_SECOND_FACTOR
= \true
FAA_SESSION_KEY
public
mixed
FAA_SESSION_KEY
= 'FAA'
FAA_SESSION_LENGTH
public
mixed
FAA_SESSION_LENGTH
= 592200
FAA_SESSION_LOGIN_CASEINVARIANT
public
mixed
FAA_SESSION_LOGIN_CASEINVARIANT
= \true
FAA_SESSION_LOGIN_ID
public
mixed
FAA_SESSION_LOGIN_ID
= \true
FAA_SESSION_MAX_TRY
public
mixed
FAA_SESSION_MAX_TRY
= 12
FAA_SESSION_NAME
public
mixed
FAA_SESSION_NAME
= 'FileAccess'
FAA_SESSION_PHOENIX_ACCOUNT
public
mixed
FAA_SESSION_PHOENIX_ACCOUNT
= ''
FAA_SESSION_ROOT_FIXED
public
mixed
FAA_SESSION_ROOT_FIXED
= \FAA_ROOT_USER_ID
FAA_SESSION_VISITOR_GROUP
public
mixed
FAA_SESSION_VISITOR_GROUP
= 'visitor'
FAA_SOLRDATE
public
mixed
FAA_SOLRDATE
= 'Y-m-d\\TH:i:s\\Z'
FAA_SYSTEM_CODENAME
public
mixed
FAA_SYSTEM_CODENAME
= 'Andromeda'
FAA_SYSTEM_TIME
public
mixed
FAA_SYSTEM_TIME
= \microtime(\true)
FAA_TIMEZONE
public
mixed
FAA_TIMEZONE
= 'Europe/Berlin'
FAA_WRITE_RETRY
public
mixed
FAA_WRITE_RETRY
= 200
FAA_WRITE_RETRY_GIT
public
mixed
FAA_WRITE_RETRY_GIT
= 150
IDNA_ALLOW_UNASSIGNED
public
mixed
IDNA_ALLOW_UNASSIGNED
= 1
IDNA_CHECK_BIDI
public
mixed
IDNA_CHECK_BIDI
= 4
IDNA_CHECK_CONTEXTJ
public
mixed
IDNA_CHECK_CONTEXTJ
= 8
IDNA_DEFAULT
public
mixed
IDNA_DEFAULT
= 0
IDNA_ERROR_BIDI
public
mixed
IDNA_ERROR_BIDI
= 2048
IDNA_ERROR_CONTEXTJ
public
mixed
IDNA_ERROR_CONTEXTJ
= 4096
IDNA_ERROR_DISALLOWED
public
mixed
IDNA_ERROR_DISALLOWED
= 128
IDNA_ERROR_DOMAIN_NAME_TOO_LONG
public
mixed
IDNA_ERROR_DOMAIN_NAME_TOO_LONG
= 4
IDNA_ERROR_EMPTY_LABEL
public
mixed
IDNA_ERROR_EMPTY_LABEL
= 1
IDNA_ERROR_HYPHEN_3_4
public
mixed
IDNA_ERROR_HYPHEN_3_4
= 32
IDNA_ERROR_INVALID_ACE_LABEL
public
mixed
IDNA_ERROR_INVALID_ACE_LABEL
= 1024
IDNA_ERROR_LABEL_HAS_DOT
public
mixed
IDNA_ERROR_LABEL_HAS_DOT
= 512
IDNA_ERROR_LABEL_TOO_LONG
public
mixed
IDNA_ERROR_LABEL_TOO_LONG
= 2
IDNA_ERROR_LEADING_COMBINING_MARK
public
mixed
IDNA_ERROR_LEADING_COMBINING_MARK
= 64
IDNA_ERROR_LEADING_HYPHEN
public
mixed
IDNA_ERROR_LEADING_HYPHEN
= 8
IDNA_ERROR_PUNYCODE
public
mixed
IDNA_ERROR_PUNYCODE
= 256
IDNA_ERROR_TRAILING_HYPHEN
public
mixed
IDNA_ERROR_TRAILING_HYPHEN
= 16
IDNA_NONTRANSITIONAL_TO_ASCII
public
mixed
IDNA_NONTRANSITIONAL_TO_ASCII
= 16
IDNA_NONTRANSITIONAL_TO_UNICODE
public
mixed
IDNA_NONTRANSITIONAL_TO_UNICODE
= 32
IDNA_USE_STD3_RULES
public
mixed
IDNA_USE_STD3_RULES
= 2
INTL_IDNA_VARIANT_2003
public
mixed
INTL_IDNA_VARIANT_2003
= 0
INTL_IDNA_VARIANT_UTS46
public
mixed
INTL_IDNA_VARIANT_UTS46
= 1
MB_CASE_LOWER
public
mixed
MB_CASE_LOWER
= 1
MB_CASE_TITLE
public
mixed
MB_CASE_TITLE
= 2
MB_CASE_UPPER
public
mixed
MB_CASE_UPPER
= 0
PHP_FLOAT_DIG
public
mixed
PHP_FLOAT_DIG
= 15
PHP_FLOAT_EPSILON
public
mixed
PHP_FLOAT_EPSILON
= 2.2204460492503E-16
PHP_FLOAT_MAX
public
mixed
PHP_FLOAT_MAX
= 1.7976931348623157E+308
PHP_FLOAT_MIN
public
mixed
PHP_FLOAT_MIN
= 2.2250738585072E-308
PHP_OS_FAMILY
public
mixed
PHP_OS_FAMILY
= \Symfony\Polyfill\Php72\Php72::php_os_family()
U_IDNA_ACE_PREFIX_ERROR
public
mixed
U_IDNA_ACE_PREFIX_ERROR
= 66564
U_IDNA_CHECK_BIDI_ERROR
public
mixed
U_IDNA_CHECK_BIDI_ERROR
= 66562
U_IDNA_DOMAIN_NAME_TOO_LONG_ERROR
public
mixed
U_IDNA_DOMAIN_NAME_TOO_LONG_ERROR
= 66568
U_IDNA_ERROR_LIMIT
public
mixed
U_IDNA_ERROR_LIMIT
= 66569
U_IDNA_ERROR_START
public
mixed
U_IDNA_ERROR_START
= 66560
U_IDNA_LABEL_TOO_LONG_ERROR
public
mixed
U_IDNA_LABEL_TOO_LONG_ERROR
= 66566
U_IDNA_PROHIBITED_ERROR
public
mixed
U_IDNA_PROHIBITED_ERROR
= 66560
U_IDNA_STD3_ASCII_RULES_ERROR
public
mixed
U_IDNA_STD3_ASCII_RULES_ERROR
= 66563
U_IDNA_UNASSIGNED_ERROR
public
mixed
U_IDNA_UNASSIGNED_ERROR
= 66561
U_IDNA_VERIFICATION_ERROR
public
mixed
U_IDNA_VERIFICATION_ERROR
= 66565
U_IDNA_ZERO_LENGTH_LABEL_ERROR
public
mixed
U_IDNA_ZERO_LENGTH_LABEL_ERROR
= 66567
U_STRINGPREP_CHECK_BIDI_ERROR
public
mixed
U_STRINGPREP_CHECK_BIDI_ERROR
= 66562
U_STRINGPREP_PROHIBITED_ERROR
public
mixed
U_STRINGPREP_PROHIBITED_ERROR
= 66560
U_STRINGPREP_UNASSIGNED_ERROR
public
mixed
U_STRINGPREP_UNASSIGNED_ERROR
= 66561
Functions
composerRequirec2e05b3412b5b96739da81506749a3d1()
composerRequirec2e05b3412b5b96739da81506749a3d1(mixed $fileIdentifier, mixed $file) : mixed
Parameters
- $fileIdentifier : mixed
- $file : mixed
Return values
mixed —includeFile()
Scope isolated include.
includeFile(mixed $file) : mixed
Prevents access to $this/self from included files.
Parameters
- $file : mixed
Return values
mixed —uri_template()
Expands a URI template
uri_template(string $template, array<string|int, mixed> $variables) : string
Parameters
- $template : string
-
URI template
- $variables : array<string|int, mixed>
-
Template variables
Return values
string —describe_type()
Debug function used to describe the provided value type and class.
describe_type(mixed $input) : string
Parameters
- $input : mixed
Return values
string —Returns a string containing the type of the variable and if a class is provided, the class name.
headers_from_lines()
Parses an array of header lines into an associative array of headers.
headers_from_lines(array<string|int, mixed> $lines) : array<string|int, mixed>
Parameters
- $lines : array<string|int, mixed>
-
Header lines array of strings in the following format: "Name: Value"
Return values
array<string|int, mixed> —debug_resource()
Returns a debug stream based on the provided variable.
debug_resource([mixed $value = null ]) : resource
Parameters
- $value : mixed = null
-
Optional value
Return values
resource —choose_handler()
Chooses and creates a default handler to use based on the environment.
choose_handler() : callable
The returned handler is not wrapped by any default middlewares.
Tags
Return values
callable —Returns the best handler for the given system.
default_user_agent()
Get the default User-Agent string to use with Guzzle
default_user_agent() : string
Return values
string —default_ca_bundle()
Returns the default cacert bundle for the current system.
default_ca_bundle() : string
First, the openssl.cafile and curl.cainfo php.ini settings are checked. If those settings are not configured, then the common locations for bundles found on Red Hat, CentOS, Fedora, Ubuntu, Debian, FreeBSD, OS X and Windows are checked. If any of these file locations are found on disk, they will be utilized.
Note: the result of this function is cached for subsequent calls.
Tags
Return values
string —normalize_header_keys()
Creates an associative array of lowercase header names to the actual header casing.
normalize_header_keys(array<string|int, mixed> $headers) : array<string|int, mixed>
Parameters
- $headers : array<string|int, mixed>
Return values
array<string|int, mixed> —is_host_in_noproxy()
Returns true if the provided host matches any of the no proxy areas.
is_host_in_noproxy(string $host, array<string|int, mixed> $noProxyArray) : bool
This method will strip a port from the host if it is present. Each pattern can be matched with an exact match (e.g., "foo.com" == "foo.com") or a partial match: (e.g., "foo.com" == "baz.foo.com" and ".foo.com" == "baz.foo.com", but ".foo.com" != "foo.com").
Areas are matched in the following cases:
- "*" (without quotes) always matches any hosts.
- An exact match.
- The area starts with "." and the area is the last part of the host. e.g. '.mit.edu' will match any host that ends with '.mit.edu'.
Parameters
- $host : string
-
Host to check against the patterns.
- $noProxyArray : array<string|int, mixed>
-
An array of host patterns.
Return values
bool —json_decode()
Wrapper for json_decode that throws when an error occurs.
json_decode(string $json[, bool $assoc = false ][, int $depth = 512 ], int $options) : mixed
Parameters
- $json : string
-
JSON data to parse
- $assoc : bool = false
-
When true, returned objects will be converted into associative arrays.
- $depth : int = 512
-
User specified recursion depth.
- $options : int
-
Bitmask of JSON decode options.
Tags
Return values
mixed —json_encode()
Wrapper for JSON encoding that throws when an error occurs.
json_encode(mixed $value, int $options[, int $depth = 512 ]) : string
Parameters
- $value : mixed
-
The value being encoded
- $options : int
-
JSON encode option bitmask
- $depth : int = 512
-
Set the maximum depth. Must be greater than zero.
Tags
Return values
string —queue()
Get the global task queue used for promise resolution.
queue([TaskQueueInterface $assign = null ]) : TaskQueueInterface
This task queue MUST be run in an event loop in order for promises to be settled asynchronously. It will be automatically run when synchronously waiting on a promise.
while ($eventLoop->isRunning()) {
GuzzleHttp\Promise\queue()->run();
}
Parameters
- $assign : TaskQueueInterface = null
-
Optionally specify a new queue instance.
Return values
TaskQueueInterface —task()
Adds a function to run in the task queue when it is next `run()` and returns a promise that is fulfilled or rejected with the result.
task(callable $task) : PromiseInterface
Parameters
- $task : callable
-
Task function to run.
Return values
PromiseInterface —promise_for()
Creates a promise for a value if the value is not a promise.
promise_for(mixed $value) : PromiseInterface
Parameters
- $value : mixed
-
Promise or value.
Return values
PromiseInterface —rejection_for()
Creates a rejected promise for a reason if the reason is not a promise. If the provided reason is a promise, then it is returned as-is.
rejection_for(mixed $reason) : PromiseInterface
Parameters
- $reason : mixed
-
Promise or reason.
Return values
PromiseInterface —exception_for()
Create an exception for a rejected promise value.
exception_for(mixed $reason) : Exception|Throwable
Parameters
- $reason : mixed
Return values
Exception|Throwable —iter_for()
Returns an iterator for the given value.
iter_for(mixed $value) : Iterator
Parameters
- $value : mixed
Return values
Iterator —inspect()
Synchronously waits on a promise to resolve and returns an inspection state array.
inspect(PromiseInterface $promise) : array<string|int, mixed>
Returns a state associative array containing a "state" key mapping to a valid promise state. If the state of the promise is "fulfilled", the array will contain a "value" key mapping to the fulfilled value of the promise. If the promise is rejected, the array will contain a "reason" key mapping to the rejection reason of the promise.
Parameters
- $promise : PromiseInterface
-
Promise or value.
Return values
array<string|int, mixed> —inspect_all()
Waits on all of the provided promises, but does not unwrap rejected promises as thrown exception.
inspect_all(array<string|int, PromiseInterface> $promises) : array<string|int, mixed>
Returns an array of inspection state arrays.
Parameters
- $promises : array<string|int, PromiseInterface>
-
Traversable of promises to wait upon.
Tags
Return values
array<string|int, mixed> —unwrap()
Waits on all of the provided promises and returns the fulfilled values.
unwrap(mixed $promises) : array<string|int, mixed>
Returns an array that contains the value of each promise (in the same order the promises were provided). An exception is thrown if any of the promises are rejected.
Parameters
- $promises : mixed
-
Iterable of PromiseInterface objects to wait on.
Tags
Return values
array<string|int, mixed> —all()
Given an array of promises, return a promise that is fulfilled when all the items in the array are fulfilled.
all(mixed $promises) : PromiseInterface
The promise's fulfillment value is an array with fulfillment values at respective positions to the original array. If any promise in the array rejects, the returned promise is rejected with the rejection reason.
Parameters
- $promises : mixed
-
Promises or values.
Return values
PromiseInterface —some()
Initiate a competitive race between multiple promises or values (values will become immediately fulfilled promises).
some(int $count, mixed $promises) : PromiseInterface
When count amount of promises have been fulfilled, the returned promise is fulfilled with an array that contains the fulfillment values of the winners in order of resolution.
This prommise is rejected with a AggregateException if the number of fulfilled promises is less than the desired $count.
Parameters
- $count : int
-
Total number of promises.
- $promises : mixed
-
Promises or values.
Return values
PromiseInterface —any()
Like some(), with 1 as count. However, if the promise fulfills, the fulfillment value is not an array of 1 but the value directly.
any(mixed $promises) : PromiseInterface
Parameters
- $promises : mixed
-
Promises or values.
Return values
PromiseInterface —settle()
Returns a promise that is fulfilled when all of the provided promises have been fulfilled or rejected.
settle(mixed $promises) : PromiseInterface
The returned promise is fulfilled with an array of inspection state arrays.
Parameters
- $promises : mixed
-
Promises or values.
Tags
Return values
PromiseInterface —each()
Given an iterator that yields promises or values, returns a promise that is fulfilled with a null value when the iterator has been consumed or the aggregate promise has been fulfilled or rejected.
each(mixed $iterable[, callable $onFulfilled = null ][, callable $onRejected = null ]) : PromiseInterface
$onFulfilled is a function that accepts the fulfilled value, iterator index, and the aggregate promise. The callback can invoke any necessary side effects and choose to resolve or reject the aggregate promise if needed.
$onRejected is a function that accepts the rejection reason, iterator index, and the aggregate promise. The callback can invoke any necessary side effects and choose to resolve or reject the aggregate promise if needed.
Parameters
- $iterable : mixed
-
Iterator or array to iterate over.
- $onFulfilled : callable = null
- $onRejected : callable = null
Return values
PromiseInterface —each_limit()
Like each, but only allows a certain number of outstanding promises at any given time.
each_limit(mixed $iterable, int|callable $concurrency[, callable $onFulfilled = null ][, callable $onRejected = null ]) : PromiseInterface
$concurrency may be an integer or a function that accepts the number of pending promises and returns a numeric concurrency limit value to allow for dynamic a concurrency size.
Parameters
- $iterable : mixed
- $concurrency : int|callable
- $onFulfilled : callable = null
- $onRejected : callable = null
Return values
PromiseInterface —each_limit_all()
Like each_limit, but ensures that no promise in the given $iterable argument is rejected. If any promise is rejected, then the aggregate promise is rejected with the encountered rejection.
each_limit_all(mixed $iterable, int|callable $concurrency[, callable $onFulfilled = null ]) : PromiseInterface
Parameters
- $iterable : mixed
- $concurrency : int|callable
- $onFulfilled : callable = null
Return values
PromiseInterface —is_fulfilled()
Returns true if a promise is fulfilled.
is_fulfilled(PromiseInterface $promise) : bool
Parameters
- $promise : PromiseInterface
Return values
bool —is_rejected()
Returns true if a promise is rejected.
is_rejected(PromiseInterface $promise) : bool
Parameters
- $promise : PromiseInterface
Return values
bool —is_settled()
Returns true if a promise is fulfilled or rejected.
is_settled(PromiseInterface $promise) : bool
Parameters
- $promise : PromiseInterface
Return values
bool —coroutine()
coroutine(callable $generatorFn) : PromiseInterface
Parameters
- $generatorFn : callable
Tags
Return values
PromiseInterface —str()
Returns the string representation of an HTTP message.
str(MessageInterface $message) : string
Parameters
- $message : MessageInterface
-
Message to convert to a string.
Return values
string —uri_for()
Returns a UriInterface for the given value.
uri_for(string|UriInterface $uri) : UriInterface
This function accepts a string or UriInterface and
returns a UriInterface for the given value. If the value is already a
UriInterface, it is returned as-is.
Parameters
- $uri : string|UriInterface
Tags
Return values
UriInterface —stream_for()
Create a new stream based on the input type.
stream_for([resource|string|null|int|float|bool|StreamInterface|callable|Iterator $resource = '' ][, array<string|int, mixed> $options = [] ]) : StreamInterface
Options is an associative array that can contain the following keys:
- metadata: Array of custom metadata.
- size: Size of the stream.
Parameters
- $resource : resource|string|null|int|float|bool|StreamInterface|callable|Iterator = ''
-
Entity body data
- $options : array<string|int, mixed> = []
-
Additional options
Tags
Return values
StreamInterface —parse_header()
Parse an array of header values containing ";" separated data into an array of associative arrays representing the header key value pair data of the header. When a parameter does not contain a value, but just contains a key, this function will inject a key with a '' string value.
parse_header(string|array<string|int, mixed> $header) : array<string|int, mixed>
Parameters
- $header : string|array<string|int, mixed>
-
Header to parse into components.
Return values
array<string|int, mixed> —Returns the parsed header values.
normalize_header()
Converts an array of header values that may contain comma separated headers into an array of headers with no comma separated values.
normalize_header(string|array<string|int, mixed> $header) : array<string|int, mixed>
Parameters
- $header : string|array<string|int, mixed>
-
Header to normalize.
Return values
array<string|int, mixed> —Returns the normalized header field values.
modify_request()
Clone and modify a request with the given changes.
modify_request(RequestInterface $request, array<string|int, mixed> $changes) : RequestInterface
The changes can be one of:
- method: (string) Changes the HTTP method.
- set_headers: (array) Sets the given headers.
- remove_headers: (array) Remove the given headers.
- body: (mixed) Sets the given body.
- uri: (UriInterface) Set the URI.
- query: (string) Set the query string value of the URI.
- version: (string) Set the protocol version.
Parameters
- $request : RequestInterface
-
Request to clone and modify.
- $changes : array<string|int, mixed>
-
Changes to apply.
Return values
RequestInterface —rewind_body()
Attempts to rewind a message body and throws an exception on failure.
rewind_body(MessageInterface $message) : mixed
The body of the message will only be rewound if a call to tell() returns a
value other than 0.
Parameters
- $message : MessageInterface
-
Message to rewind
Tags
Return values
mixed —try_fopen()
Safely opens a PHP stream resource using a filename.
try_fopen(string $filename, string $mode) : resource
When fopen fails, PHP normally raises a warning. This function adds an error handler that checks for errors and throws an exception instead.
Parameters
- $filename : string
-
File to open
- $mode : string
-
Mode used to open the file
Tags
Return values
resource —copy_to_string()
Copy the contents of a stream into a string until the given number of bytes have been read.
copy_to_string(StreamInterface $stream[, int $maxLen = -1 ]) : string
Parameters
- $stream : StreamInterface
-
Stream to read
- $maxLen : int = -1
-
Maximum number of bytes to read. Pass -1 to read the entire stream.
Tags
Return values
string —copy_to_stream()
Copy the contents of a stream into another stream until the given number of bytes have been read.
copy_to_stream(StreamInterface $source, StreamInterface $dest[, int $maxLen = -1 ]) : mixed
Parameters
- $source : StreamInterface
-
Stream to read from
- $dest : StreamInterface
-
Stream to write to
- $maxLen : int = -1
-
Maximum number of bytes to read. Pass -1 to read the entire stream.
Tags
Return values
mixed —hash()
Calculate a hash of a Stream
hash(StreamInterface $stream, string $algo[, bool $rawOutput = false ]) : string
Parameters
- $stream : StreamInterface
-
Stream to calculate the hash for
- $algo : string
-
Hash algorithm (e.g. md5, crc32, etc)
- $rawOutput : bool = false
-
Whether or not to use raw output
Tags
Return values
string —Returns the hash of the stream
readline()
Read a line from the stream up to the maximum allowed buffer length
readline(StreamInterface $stream[, int $maxLength = null ]) : string
Parameters
- $stream : StreamInterface
-
Stream to read from
- $maxLength : int = null
-
Maximum buffer length
Return values
string —parse_request()
Parses a request message string into a request object.
parse_request(string $message) : Request
Parameters
- $message : string
-
Request message string.
Return values
Request —parse_response()
Parses a response message string into a response object.
parse_response(string $message) : Response
Parameters
- $message : string
-
Response message string.
Return values
Response —parse_query()
Parse a query string into an associative array.
parse_query(string $str[, int|bool $urlEncoding = true ]) : array<string|int, mixed>
If multiple values are found for the same key, the value of that key value pair will become an array. This function does not parse nested PHP style arrays into an associative array (e.g., foo[a]=1&foo[b]=2 will be parsed into ['foo[a]' => '1', 'foo[b]' => '2']).
Parameters
- $str : string
-
Query string to parse
- $urlEncoding : int|bool = true
-
How the query string is encoded
Return values
array<string|int, mixed> —build_query()
Build a query string from an array of key value pairs.
build_query(array<string|int, mixed> $params[, int|false $encoding = PHP_QUERY_RFC3986 ]) : string
This function can use the return value of parse_query() to build a query string. This function does not modify the provided keys when an array is encountered (like http_build_query would).
Parameters
- $params : array<string|int, mixed>
-
Query string parameters.
- $encoding : int|false = PHP_QUERY_RFC3986
-
Set to false to not encode, PHP_QUERY_RFC3986 to encode using RFC3986, or PHP_QUERY_RFC1738 to encode using RFC1738.
Return values
string —mimetype_from_filename()
Determines the mimetype of a file by looking at its extension.
mimetype_from_filename( $filename) : null|string
Parameters
Return values
null|string —mimetype_from_extension()
Maps a file extensions to a mimetype.
mimetype_from_extension( $extension) : string|null
Parameters
Tags
Return values
string|null —get_message_body_summary()
Get a short summary of the message body
get_message_body_summary(MessageInterface $message[, int $truncateAt = 120 ]) : null|string
Will return null if the response is not printable.
Parameters
- $message : MessageInterface
-
The message to get the body summary
- $truncateAt : int = 120
-
The maximum allowed size of the summary
Return values
null|string —getallheaders()
Get all HTTP header key/values as an associative array for the current request.
getallheaders() : mixed
Return values
mixed —composerRequire94a925f1e94190dddeabac0607d3aa7a()
composerRequire94a925f1e94190dddeabac0607d3aa7a(mixed $fileIdentifier, mixed $file) : mixed
Parameters
- $fileIdentifier : mixed
- $file : mixed
Return values
mixed —includeFile()
Scope isolated include.
includeFile(mixed $file) : mixed
Prevents access to $this/self from included files.
Parameters
- $file : mixed
Return values
mixed —uri_template()
Expands a URI template
uri_template(string $template, array<string|int, mixed> $variables) : string
Parameters
- $template : string
-
URI template
- $variables : array<string|int, mixed>
-
Template variables
Return values
string —describe_type()
Debug function used to describe the provided value type and class.
describe_type(mixed $input) : string
Parameters
- $input : mixed
Return values
string —Returns a string containing the type of the variable and if a class is provided, the class name.
headers_from_lines()
Parses an array of header lines into an associative array of headers.
headers_from_lines(iteratable<string|int, mixed> $lines) : array<string|int, mixed>
Parameters
- $lines : iteratable<string|int, mixed>
-
Header lines array of strings in the following format: "Name: Value"
Return values
array<string|int, mixed> —debug_resource()
Returns a debug stream based on the provided variable.
debug_resource([mixed $value = null ]) : resource
Parameters
- $value : mixed = null
-
Optional value
Return values
resource —choose_handler()
Chooses and creates a default handler to use based on the environment.
choose_handler() : callable
The returned handler is not wrapped by any default middlewares.
Tags
Return values
callable —Returns the best handler for the given system.
default_user_agent()
Get the default User-Agent string to use with Guzzle
default_user_agent() : string
Return values
string —default_ca_bundle()
Returns the default cacert bundle for the current system.
default_ca_bundle() : string
First, the openssl.cafile and curl.cainfo php.ini settings are checked. If those settings are not configured, then the common locations for bundles found on Red Hat, CentOS, Fedora, Ubuntu, Debian, FreeBSD, OS X and Windows are checked. If any of these file locations are found on disk, they will be utilized.
Note: the result of this function is cached for subsequent calls.
Tags
Return values
string —normalize_header_keys()
Creates an associative array of lowercase header names to the actual header casing.
normalize_header_keys(array<string|int, mixed> $headers) : array<string|int, mixed>
Parameters
- $headers : array<string|int, mixed>
Return values
array<string|int, mixed> —is_host_in_noproxy()
Returns true if the provided host matches any of the no proxy areas.
is_host_in_noproxy(string $host, array<string|int, mixed> $noProxyArray) : bool
This method will strip a port from the host if it is present. Each pattern can be matched with an exact match (e.g., "foo.com" == "foo.com") or a partial match: (e.g., "foo.com" == "baz.foo.com" and ".foo.com" == "baz.foo.com", but ".foo.com" != "foo.com").
Areas are matched in the following cases:
- "*" (without quotes) always matches any hosts.
- An exact match.
- The area starts with "." and the area is the last part of the host. e.g. '.mit.edu' will match any host that ends with '.mit.edu'.
Parameters
- $host : string
-
Host to check against the patterns.
- $noProxyArray : array<string|int, mixed>
-
An array of host patterns.
Return values
bool —json_decode()
Wrapper for json_decode that throws when an error occurs.
json_decode(string $json[, bool $assoc = false ][, int $depth = 512 ], int $options) : mixed
Parameters
- $json : string
-
JSON data to parse
- $assoc : bool = false
-
When true, returned objects will be converted into associative arrays.
- $depth : int = 512
-
User specified recursion depth.
- $options : int
-
Bitmask of JSON decode options.
Tags
Return values
mixed —json_encode()
Wrapper for JSON encoding that throws when an error occurs.
json_encode(mixed $value, int $options[, int $depth = 512 ]) : string
Parameters
- $value : mixed
-
The value being encoded
- $options : int
-
JSON encode option bitmask
- $depth : int = 512
-
Set the maximum depth. Must be greater than zero.
Tags
Return values
string —queue()
Get the global task queue used for promise resolution.
queue([TaskQueueInterface $assign = null ]) : TaskQueueInterface
This task queue MUST be run in an event loop in order for promises to be settled asynchronously. It will be automatically run when synchronously waiting on a promise.
while ($eventLoop->isRunning()) {
GuzzleHttp\Promise\queue()->run();
}
Parameters
- $assign : TaskQueueInterface = null
-
Optionally specify a new queue instance.
Return values
TaskQueueInterface —task()
Adds a function to run in the task queue when it is next `run()` and returns a promise that is fulfilled or rejected with the result.
task(callable $task) : PromiseInterface
Parameters
- $task : callable
-
Task function to run.
Return values
PromiseInterface —promise_for()
Creates a promise for a value if the value is not a promise.
promise_for(mixed $value) : PromiseInterface
Parameters
- $value : mixed
-
Promise or value.
Return values
PromiseInterface —rejection_for()
Creates a rejected promise for a reason if the reason is not a promise. If the provided reason is a promise, then it is returned as-is.
rejection_for(mixed $reason) : PromiseInterface
Parameters
- $reason : mixed
-
Promise or reason.
Return values
PromiseInterface —exception_for()
Create an exception for a rejected promise value.
exception_for(mixed $reason) : Exception|Throwable
Parameters
- $reason : mixed
Return values
Exception|Throwable —iter_for()
Returns an iterator for the given value.
iter_for(mixed $value) : Iterator
Parameters
- $value : mixed
Return values
Iterator —inspect()
Synchronously waits on a promise to resolve and returns an inspection state array.
inspect(PromiseInterface $promise) : array<string|int, mixed>
Returns a state associative array containing a "state" key mapping to a valid promise state. If the state of the promise is "fulfilled", the array will contain a "value" key mapping to the fulfilled value of the promise. If the promise is rejected, the array will contain a "reason" key mapping to the rejection reason of the promise.
Parameters
- $promise : PromiseInterface
-
Promise or value.
Return values
array<string|int, mixed> —inspect_all()
Waits on all of the provided promises, but does not unwrap rejected promises as thrown exception.
inspect_all(array<string|int, PromiseInterface> $promises) : array<string|int, mixed>
Returns an array of inspection state arrays.
Parameters
- $promises : array<string|int, PromiseInterface>
-
Traversable of promises to wait upon.
Tags
Return values
array<string|int, mixed> —unwrap()
Waits on all of the provided promises and returns the fulfilled values.
unwrap(mixed $promises) : array<string|int, mixed>
Returns an array that contains the value of each promise (in the same order the promises were provided). An exception is thrown if any of the promises are rejected.
Parameters
- $promises : mixed
-
Iterable of PromiseInterface objects to wait on.
Tags
Return values
array<string|int, mixed> —all()
Given an array of promises, return a promise that is fulfilled when all the items in the array are fulfilled.
all(mixed $promises) : PromiseInterface
The promise's fulfillment value is an array with fulfillment values at respective positions to the original array. If any promise in the array rejects, the returned promise is rejected with the rejection reason.
Parameters
- $promises : mixed
-
Promises or values.
Return values
PromiseInterface —some()
Initiate a competitive race between multiple promises or values (values will become immediately fulfilled promises).
some(int $count, mixed $promises) : PromiseInterface
When count amount of promises have been fulfilled, the returned promise is fulfilled with an array that contains the fulfillment values of the winners in order of resolution.
This prommise is rejected with a AggregateException if the number of fulfilled promises is less than the desired $count.
Parameters
- $count : int
-
Total number of promises.
- $promises : mixed
-
Promises or values.
Return values
PromiseInterface —any()
Like some(), with 1 as count. However, if the promise fulfills, the fulfillment value is not an array of 1 but the value directly.
any(mixed $promises) : PromiseInterface
Parameters
- $promises : mixed
-
Promises or values.
Return values
PromiseInterface —settle()
Returns a promise that is fulfilled when all of the provided promises have been fulfilled or rejected.
settle(mixed $promises) : PromiseInterface
The returned promise is fulfilled with an array of inspection state arrays.
Parameters
- $promises : mixed
-
Promises or values.
Tags
Return values
PromiseInterface —each()
Given an iterator that yields promises or values, returns a promise that is fulfilled with a null value when the iterator has been consumed or the aggregate promise has been fulfilled or rejected.
each(mixed $iterable[, callable $onFulfilled = null ][, callable $onRejected = null ]) : PromiseInterface
$onFulfilled is a function that accepts the fulfilled value, iterator index, and the aggregate promise. The callback can invoke any necessary side effects and choose to resolve or reject the aggregate promise if needed.
$onRejected is a function that accepts the rejection reason, iterator index, and the aggregate promise. The callback can invoke any necessary side effects and choose to resolve or reject the aggregate promise if needed.
Parameters
- $iterable : mixed
-
Iterator or array to iterate over.
- $onFulfilled : callable = null
- $onRejected : callable = null
Return values
PromiseInterface —each_limit()
Like each, but only allows a certain number of outstanding promises at any given time.
each_limit(mixed $iterable, int|callable $concurrency[, callable $onFulfilled = null ][, callable $onRejected = null ]) : PromiseInterface
$concurrency may be an integer or a function that accepts the number of pending promises and returns a numeric concurrency limit value to allow for dynamic a concurrency size.
Parameters
- $iterable : mixed
- $concurrency : int|callable
- $onFulfilled : callable = null
- $onRejected : callable = null
Return values
PromiseInterface —each_limit_all()
Like each_limit, but ensures that no promise in the given $iterable argument is rejected. If any promise is rejected, then the aggregate promise is rejected with the encountered rejection.
each_limit_all(mixed $iterable, int|callable $concurrency[, callable $onFulfilled = null ]) : PromiseInterface
Parameters
- $iterable : mixed
- $concurrency : int|callable
- $onFulfilled : callable = null
Return values
PromiseInterface —is_fulfilled()
Returns true if a promise is fulfilled.
is_fulfilled(PromiseInterface $promise) : bool
Parameters
- $promise : PromiseInterface
Return values
bool —is_rejected()
Returns true if a promise is rejected.
is_rejected(PromiseInterface $promise) : bool
Parameters
- $promise : PromiseInterface
Return values
bool —is_settled()
Returns true if a promise is fulfilled or rejected.
is_settled(PromiseInterface $promise) : bool
Parameters
- $promise : PromiseInterface
Return values
bool —coroutine()
coroutine(callable $generatorFn) : PromiseInterface
Parameters
- $generatorFn : callable
Tags
Return values
PromiseInterface —str()
Returns the string representation of an HTTP message.
str(MessageInterface $message) : string
Parameters
- $message : MessageInterface
-
Message to convert to a string.
Return values
string —uri_for()
Returns a UriInterface for the given value.
uri_for(string|UriInterface $uri) : UriInterface
This function accepts a string or UriInterface and
returns a UriInterface for the given value. If the value is already a
UriInterface, it is returned as-is.
Parameters
- $uri : string|UriInterface
Tags
Return values
UriInterface —stream_for()
Create a new stream based on the input type.
stream_for([resource|string|null|int|float|bool|StreamInterface|callable|Iterator $resource = '' ][, array<string|int, mixed> $options = [] ]) : StreamInterface
Options is an associative array that can contain the following keys:
- metadata: Array of custom metadata.
- size: Size of the stream.
Parameters
- $resource : resource|string|null|int|float|bool|StreamInterface|callable|Iterator = ''
-
Entity body data
- $options : array<string|int, mixed> = []
-
Additional options
Tags
Return values
StreamInterface —parse_header()
Parse an array of header values containing ";" separated data into an array of associative arrays representing the header key value pair data of the header. When a parameter does not contain a value, but just contains a key, this function will inject a key with a '' string value.
parse_header(string|array<string|int, mixed> $header) : array<string|int, mixed>
Parameters
- $header : string|array<string|int, mixed>
-
Header to parse into components.
Return values
array<string|int, mixed> —Returns the parsed header values.
normalize_header()
Converts an array of header values that may contain comma separated headers into an array of headers with no comma separated values.
normalize_header(string|array<string|int, mixed> $header) : array<string|int, mixed>
Parameters
- $header : string|array<string|int, mixed>
-
Header to normalize.
Return values
array<string|int, mixed> —Returns the normalized header field values.
modify_request()
Clone and modify a request with the given changes.
modify_request(RequestInterface $request, array<string|int, mixed> $changes) : RequestInterface
The changes can be one of:
- method: (string) Changes the HTTP method.
- set_headers: (array) Sets the given headers.
- remove_headers: (array) Remove the given headers.
- body: (mixed) Sets the given body.
- uri: (UriInterface) Set the URI.
- query: (string) Set the query string value of the URI.
- version: (string) Set the protocol version.
Parameters
- $request : RequestInterface
-
Request to clone and modify.
- $changes : array<string|int, mixed>
-
Changes to apply.
Return values
RequestInterface —rewind_body()
Attempts to rewind a message body and throws an exception on failure.
rewind_body(MessageInterface $message) : mixed
The body of the message will only be rewound if a call to tell() returns a
value other than 0.
Parameters
- $message : MessageInterface
-
Message to rewind
Tags
Return values
mixed —try_fopen()
Safely opens a PHP stream resource using a filename.
try_fopen(string $filename, string $mode) : resource
When fopen fails, PHP normally raises a warning. This function adds an error handler that checks for errors and throws an exception instead.
Parameters
- $filename : string
-
File to open
- $mode : string
-
Mode used to open the file
Tags
Return values
resource —copy_to_string()
Copy the contents of a stream into a string until the given number of bytes have been read.
copy_to_string(StreamInterface $stream[, int $maxLen = -1 ]) : string
Parameters
- $stream : StreamInterface
-
Stream to read
- $maxLen : int = -1
-
Maximum number of bytes to read. Pass -1 to read the entire stream.
Tags
Return values
string —copy_to_stream()
Copy the contents of a stream into another stream until the given number of bytes have been read.
copy_to_stream(StreamInterface $source, StreamInterface $dest[, int $maxLen = -1 ]) : mixed
Parameters
- $source : StreamInterface
-
Stream to read from
- $dest : StreamInterface
-
Stream to write to
- $maxLen : int = -1
-
Maximum number of bytes to read. Pass -1 to read the entire stream.
Tags
Return values
mixed —hash()
Calculate a hash of a Stream
hash(StreamInterface $stream, string $algo[, bool $rawOutput = false ]) : string
Parameters
- $stream : StreamInterface
-
Stream to calculate the hash for
- $algo : string
-
Hash algorithm (e.g. md5, crc32, etc)
- $rawOutput : bool = false
-
Whether or not to use raw output
Tags
Return values
string —Returns the hash of the stream
readline()
Read a line from the stream up to the maximum allowed buffer length
readline(StreamInterface $stream[, int $maxLength = null ]) : string
Parameters
- $stream : StreamInterface
-
Stream to read from
- $maxLength : int = null
-
Maximum buffer length
Return values
string —parse_request()
Parses a request message string into a request object.
parse_request(string $message) : Request
Parameters
- $message : string
-
Request message string.
Return values
Request —parse_response()
Parses a response message string into a response object.
parse_response(string $message) : Response
Parameters
- $message : string
-
Response message string.
Return values
Response —parse_query()
Parse a query string into an associative array.
parse_query(string $str[, int|bool $urlEncoding = true ]) : array<string|int, mixed>
If multiple values are found for the same key, the value of that key value pair will become an array. This function does not parse nested PHP style arrays into an associative array (e.g., foo[a]=1&foo[b]=2 will be parsed into ['foo[a]' => '1', 'foo[b]' => '2']).
Parameters
- $str : string
-
Query string to parse
- $urlEncoding : int|bool = true
-
How the query string is encoded
Return values
array<string|int, mixed> —build_query()
Build a query string from an array of key value pairs.
build_query(array<string|int, mixed> $params[, int|false $encoding = PHP_QUERY_RFC3986 ]) : string
This function can use the return value of parse_query() to build a query string. This function does not modify the provided keys when an array is encountered (like http_build_query would).
Parameters
- $params : array<string|int, mixed>
-
Query string parameters.
- $encoding : int|false = PHP_QUERY_RFC3986
-
Set to false to not encode, PHP_QUERY_RFC3986 to encode using RFC3986, or PHP_QUERY_RFC1738 to encode using RFC1738.
Return values
string —mimetype_from_filename()
Determines the mimetype of a file by looking at its extension.
mimetype_from_filename( $filename) : null|string
Parameters
Return values
null|string —mimetype_from_extension()
Maps a file extensions to a mimetype.
mimetype_from_extension( $extension) : string|null
Parameters
Tags
Return values
string|null —get_message_body_summary()
Get a short summary of the message body
get_message_body_summary(MessageInterface $message[, int $truncateAt = 120 ]) : null|string
Will return null if the response is not printable.
Parameters
- $message : MessageInterface
-
The message to get the body summary
- $truncateAt : int = 120
-
The maximum allowed size of the summary
Return values
null|string —redis_version()
redis_version(mixed $info) : mixed
Parameters
- $info : mixed
Return values
mixed —zpop()
zpop(mixed $client, mixed $key) : mixed
Parameters
- $client : mixed
- $key : mixed
Return values
mixed —getallheaders()
Get all HTTP header key/values as an associative array for the current request.
getallheaders() : mixed
Return values
mixed —v1()
Returns a version 1 (time-based) UUID from a host ID, sequence number, and the current time
v1([Hexadecimal|int|string|null $node = null ][, int $clockSeq = null ]) : string
Parameters
- $node : Hexadecimal|int|string|null = null
-
A 48-bit number representing the hardware address; this number may be represented as an integer or a hexadecimal string
- $clockSeq : int = null
-
A 14-bit number used to help avoid duplicates that could arise when the clock is set backwards in time or if the node ID changes
Return values
string —Version 1 UUID as a string
v2()
Returns a version 2 (DCE Security) UUID from a local domain, local identifier, host ID, clock sequence, and the current time
v2(int $localDomain[, Integer|null $localIdentifier = null ][, Hexadecimal|null $node = null ][, int|null $clockSeq = null ]) : string
Parameters
- $localDomain : int
-
The local domain to use when generating bytes, according to DCE Security
- $localIdentifier : Integer|null = null
-
The local identifier for the given domain; this may be a UID or GID on POSIX systems, if the local domain is person or group, or it may be a site-defined identifier if the local domain is org
- $node : Hexadecimal|null = null
-
A 48-bit number representing the hardware address
- $clockSeq : int|null = null
-
A 14-bit number used to help avoid duplicates that could arise when the clock is set backwards in time or if the node ID changes
Return values
string —Version 2 UUID as a string
v3()
Returns a version 3 (name-based) UUID based on the MD5 hash of a namespace ID and a name
v3(string|UuidInterface $ns, string $name) : string
Parameters
- $ns : string|UuidInterface
-
The namespace (must be a valid UUID)
- $name : string
Return values
string —Version 3 UUID as a string
v4()
Returns a version 4 (random) UUID
v4() : string
Return values
string —Version 4 UUID as a string
v5()
Returns a version 5 (name-based) UUID based on the SHA-1 hash of a namespace ID and a name
v5(string|UuidInterface $ns, string $name) : string
Parameters
- $ns : string|UuidInterface
-
The namespace (must be a valid UUID)
- $name : string
Return values
string —Version 5 UUID as a string
v6()
Returns a version 6 (ordered-time) UUID from a host ID, sequence number, and the current time
v6([Hexadecimal|null $node = null ][, int $clockSeq = null ]) : string
Parameters
- $node : Hexadecimal|null = null
-
A 48-bit number representing the hardware address
- $clockSeq : int = null
-
A 14-bit number used to help avoid duplicates that could arise when the clock is set backwards in time or if the node ID changes
Return values
string —Version 6 UUID as a string
ref()
Creates a service reference.
ref(string $id) : ReferenceConfigurator
Parameters
- $id : string
Return values
ReferenceConfigurator —inline()
Creates an inline service.
inline([string $class = null ]) : InlineServiceConfigurator
Parameters
- $class : string = null
Return values
InlineServiceConfigurator —service_locator()
Creates a service locator.
service_locator(array<string|int, ReferenceConfigurator> $values) : ServiceLocatorArgument
Parameters
- $values : array<string|int, ReferenceConfigurator>
Return values
ServiceLocatorArgument —iterator()
Creates a lazy iterator.
iterator(array<string|int, ReferenceConfigurator> $values) : IteratorArgument
Parameters
- $values : array<string|int, ReferenceConfigurator>
Return values
IteratorArgument —tagged_iterator()
Creates a lazy iterator by tag name.
tagged_iterator(string $tag[, string $indexAttribute = null ][, string $defaultIndexMethod = null ][, string $defaultPriorityMethod = null ]) : TaggedIteratorArgument
Parameters
- $tag : string
- $indexAttribute : string = null
- $defaultIndexMethod : string = null
- $defaultPriorityMethod : string = null
Return values
TaggedIteratorArgument —tagged_locator()
Creates a service locator by tag name.
tagged_locator(string $tag[, string $indexAttribute = null ][, string $defaultIndexMethod = null ]) : ServiceLocatorArgument
Parameters
- $tag : string
- $indexAttribute : string = null
- $defaultIndexMethod : string = null
Return values
ServiceLocatorArgument —expr()
Creates an expression.
expr(string $expression) : Expression
Parameters
- $expression : string
Return values
Expression —ctype_alnum()
ctype_alnum(mixed $text) : mixed
Parameters
- $text : mixed
Return values
mixed —ctype_alpha()
ctype_alpha(mixed $text) : mixed
Parameters
- $text : mixed
Return values
mixed —ctype_cntrl()
ctype_cntrl(mixed $text) : mixed
Parameters
- $text : mixed
Return values
mixed —ctype_digit()
ctype_digit(mixed $text) : mixed
Parameters
- $text : mixed
Return values
mixed —ctype_graph()
ctype_graph(mixed $text) : mixed
Parameters
- $text : mixed
Return values
mixed —ctype_lower()
ctype_lower(mixed $text) : mixed
Parameters
- $text : mixed
Return values
mixed —ctype_print()
ctype_print(mixed $text) : mixed
Parameters
- $text : mixed
Return values
mixed —ctype_punct()
ctype_punct(mixed $text) : mixed
Parameters
- $text : mixed
Return values
mixed —ctype_space()
ctype_space(mixed $text) : mixed
Parameters
- $text : mixed
Return values
mixed —ctype_upper()
ctype_upper(mixed $text) : mixed
Parameters
- $text : mixed
Return values
mixed —ctype_xdigit()
ctype_xdigit(mixed $text) : mixed
Parameters
- $text : mixed
Return values
mixed —idn_to_ascii()
idn_to_ascii(mixed $domain[, mixed $options = IDNA_DEFAULT ][, mixed $variant = INTL_IDNA_VARIANT_UTS46 ][, mixed &$idna_info = array() ]) : mixed
Parameters
- $domain : mixed
- $options : mixed = IDNA_DEFAULT
- $variant : mixed = INTL_IDNA_VARIANT_UTS46
- $idna_info : mixed = array()
Return values
mixed —idn_to_utf8()
idn_to_utf8(mixed $domain[, mixed $options = IDNA_DEFAULT ][, mixed $variant = INTL_IDNA_VARIANT_UTS46 ][, mixed &$idna_info = array() ]) : mixed
Parameters
- $domain : mixed
- $options : mixed = IDNA_DEFAULT
- $variant : mixed = INTL_IDNA_VARIANT_UTS46
- $idna_info : mixed = array()
Return values
mixed —mb_convert_encoding()
mb_convert_encoding(mixed $s, mixed $to[, mixed $from = null ]) : mixed
Parameters
- $s : mixed
- $to : mixed
- $from : mixed = null
Return values
mixed —mb_decode_mimeheader()
mb_decode_mimeheader(mixed $s) : mixed
Parameters
- $s : mixed
Return values
mixed —mb_encode_mimeheader()
mb_encode_mimeheader(mixed $s[, mixed $charset = null ][, mixed $transferEnc = null ][, mixed $lf = null ][, mixed $indent = null ]) : mixed
Parameters
- $s : mixed
- $charset : mixed = null
- $transferEnc : mixed = null
- $lf : mixed = null
- $indent : mixed = null
Return values
mixed —mb_decode_numericentity()
mb_decode_numericentity(mixed $s, mixed $convmap[, mixed $enc = null ]) : mixed
Parameters
- $s : mixed
- $convmap : mixed
- $enc : mixed = null
Return values
mixed —mb_encode_numericentity()
mb_encode_numericentity(mixed $s, mixed $convmap[, mixed $enc = null ][, mixed $is_hex = false ]) : mixed
Parameters
- $s : mixed
- $convmap : mixed
- $enc : mixed = null
- $is_hex : mixed = false
Return values
mixed —mb_convert_case()
mb_convert_case(mixed $s, mixed $mode[, mixed $enc = null ]) : mixed
Parameters
- $s : mixed
- $mode : mixed
- $enc : mixed = null
Return values
mixed —mb_internal_encoding()
mb_internal_encoding([mixed $enc = null ]) : mixed
Parameters
- $enc : mixed = null
Return values
mixed —mb_language()
mb_language([mixed $lang = null ]) : mixed
Parameters
- $lang : mixed = null
Return values
mixed —mb_list_encodings()
mb_list_encodings() : mixed
Return values
mixed —mb_encoding_aliases()
mb_encoding_aliases(mixed $encoding) : mixed
Parameters
- $encoding : mixed
Return values
mixed —mb_check_encoding()
mb_check_encoding([mixed $var = null ][, mixed $encoding = null ]) : mixed
Parameters
- $var : mixed = null
- $encoding : mixed = null
Return values
mixed —mb_detect_encoding()
mb_detect_encoding(mixed $str[, mixed $encodingList = null ][, mixed $strict = false ]) : mixed
Parameters
- $str : mixed
- $encodingList : mixed = null
- $strict : mixed = false
Return values
mixed —mb_detect_order()
mb_detect_order([mixed $encodingList = null ]) : mixed
Parameters
- $encodingList : mixed = null
Return values
mixed —mb_parse_str()
mb_parse_str(mixed $s[, mixed &$result = array() ]) : mixed
Parameters
- $s : mixed
- $result : mixed = array()
Return values
mixed —mb_strlen()
mb_strlen(mixed $s[, mixed $enc = null ]) : mixed
Parameters
- $s : mixed
- $enc : mixed = null
Return values
mixed —mb_strpos()
mb_strpos(mixed $s, mixed $needle, mixed $offset[, mixed $enc = null ]) : mixed
Parameters
- $s : mixed
- $needle : mixed
- $offset : mixed
- $enc : mixed = null
Return values
mixed —mb_strtolower()
mb_strtolower(mixed $s[, mixed $enc = null ]) : mixed
Parameters
- $s : mixed
- $enc : mixed = null
Return values
mixed —mb_strtoupper()
mb_strtoupper(mixed $s[, mixed $enc = null ]) : mixed
Parameters
- $s : mixed
- $enc : mixed = null
Return values
mixed —mb_substitute_character()
mb_substitute_character([mixed $char = null ]) : mixed
Parameters
- $char : mixed = null
Return values
mixed —mb_substr()
mb_substr(mixed $s, mixed $start[, mixed $length = 2147483647 ][, mixed $enc = null ]) : mixed
Parameters
- $s : mixed
- $start : mixed
- $length : mixed = 2147483647
- $enc : mixed = null
Return values
mixed —mb_stripos()
mb_stripos(mixed $s, mixed $needle, mixed $offset[, mixed $enc = null ]) : mixed
Parameters
- $s : mixed
- $needle : mixed
- $offset : mixed
- $enc : mixed = null
Return values
mixed —mb_stristr()
mb_stristr(mixed $s, mixed $needle[, mixed $part = false ][, mixed $enc = null ]) : mixed
Parameters
- $s : mixed
- $needle : mixed
- $part : mixed = false
- $enc : mixed = null
Return values
mixed —mb_strrchr()
mb_strrchr(mixed $s, mixed $needle[, mixed $part = false ][, mixed $enc = null ]) : mixed
Parameters
- $s : mixed
- $needle : mixed
- $part : mixed = false
- $enc : mixed = null
Return values
mixed —mb_strrichr()
mb_strrichr(mixed $s, mixed $needle[, mixed $part = false ][, mixed $enc = null ]) : mixed
Parameters
- $s : mixed
- $needle : mixed
- $part : mixed = false
- $enc : mixed = null
Return values
mixed —mb_strripos()
mb_strripos(mixed $s, mixed $needle, mixed $offset[, mixed $enc = null ]) : mixed
Parameters
- $s : mixed
- $needle : mixed
- $offset : mixed
- $enc : mixed = null
Return values
mixed —mb_strrpos()
mb_strrpos(mixed $s, mixed $needle, mixed $offset[, mixed $enc = null ]) : mixed
Parameters
- $s : mixed
- $needle : mixed
- $offset : mixed
- $enc : mixed = null
Return values
mixed —mb_strstr()
mb_strstr(mixed $s, mixed $needle[, mixed $part = false ][, mixed $enc = null ]) : mixed
Parameters
- $s : mixed
- $needle : mixed
- $part : mixed = false
- $enc : mixed = null
Return values
mixed —mb_get_info()
mb_get_info([mixed $type = 'all' ]) : mixed
Parameters
- $type : mixed = 'all'
Return values
mixed —mb_http_output()
mb_http_output([mixed $enc = null ]) : mixed
Parameters
- $enc : mixed = null
Return values
mixed —mb_strwidth()
mb_strwidth(mixed $s[, mixed $enc = null ]) : mixed
Parameters
- $s : mixed
- $enc : mixed = null
Return values
mixed —mb_substr_count()
mb_substr_count(mixed $haystack, mixed $needle[, mixed $enc = null ]) : mixed
Parameters
- $haystack : mixed
- $needle : mixed
- $enc : mixed = null
Return values
mixed —mb_output_handler()
mb_output_handler(mixed $contents, mixed $status) : mixed
Parameters
- $contents : mixed
- $status : mixed
Return values
mixed —mb_http_input()
mb_http_input([mixed $type = '' ]) : mixed
Parameters
- $type : mixed = ''
Return values
mixed —mb_convert_variables()
mb_convert_variables(mixed $toEncoding, mixed $fromEncoding[, mixed &$a = null ][, mixed &$b = null ][, mixed &$c = null ][, mixed &$d = null ][, mixed &$e = null ][, mixed &$f = null ]) : mixed
Parameters
- $toEncoding : mixed
- $fromEncoding : mixed
- $a : mixed = null
- $b : mixed = null
- $c : mixed = null
- $d : mixed = null
- $e : mixed = null
- $f : mixed = null
Return values
mixed —mb_ord()
mb_ord(mixed $s[, mixed $enc = null ]) : mixed
Parameters
- $s : mixed
- $enc : mixed = null
Return values
mixed —mb_chr()
mb_chr(mixed $code[, mixed $enc = null ]) : mixed
Parameters
- $code : mixed
- $enc : mixed = null
Return values
mixed —mb_scrub()
mb_scrub(mixed $s[, mixed $enc = null ]) : mixed
Parameters
- $s : mixed
- $enc : mixed = null
Return values
mixed —mb_str_split()
mb_str_split(mixed $string[, mixed $split_length = 1 ][, mixed $encoding = null ]) : mixed
Parameters
- $string : mixed
- $split_length : mixed = 1
- $encoding : mixed = null
Return values
mixed —sapi_windows_vt100_support()
sapi_windows_vt100_support(mixed $stream[, mixed $enable = null ]) : mixed
Parameters
- $stream : mixed
- $enable : mixed = null
Return values
mixed —stream_isatty()
stream_isatty(mixed $stream) : mixed
Parameters
- $stream : mixed
Return values
mixed —utf8_encode()
utf8_encode(mixed $s) : mixed
Parameters
- $s : mixed
Return values
mixed —utf8_decode()
utf8_decode(mixed $s) : mixed
Parameters
- $s : mixed
Return values
mixed —spl_object_id()
spl_object_id(mixed $s) : mixed
Parameters
- $s : mixed
Return values
mixed —mb_ord()
mb_ord(mixed $s[, mixed $enc = null ]) : mixed
Parameters
- $s : mixed
- $enc : mixed = null
Return values
mixed —mb_chr()
mb_chr(mixed $code[, mixed $enc = null ]) : mixed
Parameters
- $code : mixed
- $enc : mixed = null
Return values
mixed —mb_scrub()
mb_scrub(mixed $s[, mixed $enc = null ]) : mixed
Parameters
- $s : mixed
- $enc : mixed = null
Return values
mixed —is_countable()
is_countable(mixed $var) : mixed
Parameters
- $var : mixed
Return values
mixed —hrtime()
hrtime([mixed $asNum = false ]) : mixed
Parameters
- $asNum : mixed = false
Return values
mixed —array_key_first()
array_key_first(array<string|int, mixed> $array) : mixed
Parameters
- $array : array<string|int, mixed>
Return values
mixed —array_key_last()
array_key_last(array<string|int, mixed> $array) : mixed
Parameters
- $array : array<string|int, mixed>
Return values
mixed —findTranslationFiles()
findTranslationFiles(mixed $originalFilePath, mixed $localeToAnalyze) : mixed
Parameters
- $originalFilePath : mixed
- $localeToAnalyze : mixed
Return values
mixed —calculateTranslationStatus()
calculateTranslationStatus(mixed $originalFilePath, mixed $translationFilePaths) : mixed
Parameters
- $originalFilePath : mixed
- $translationFilePaths : mixed
Return values
mixed —printTranslationStatus()
printTranslationStatus(mixed $originalFilePath, mixed $translationStatus, mixed $verboseOutput) : mixed
Parameters
- $originalFilePath : mixed
- $translationStatus : mixed
- $verboseOutput : mixed
Return values
mixed —extractLocaleFromFilePath()
extractLocaleFromFilePath(mixed $filePath) : mixed
Parameters
- $filePath : mixed
Return values
mixed —extractTranslationKeys()
extractTranslationKeys(mixed $filePath) : mixed
Parameters
- $filePath : mixed
Return values
mixed —printTitle()
printTitle(mixed $title) : mixed
Parameters
- $title : mixed
Return values
mixed —printTable()
printTable(mixed $translations, mixed $verboseOutput) : mixed
Parameters
- $translations : mixed
- $verboseOutput : mixed
Return values
mixed —textColorGreen()
textColorGreen() : mixed
Return values
mixed —textColorRed()
textColorRed() : mixed
Return values
mixed —textColorNormal()
textColorNormal() : mixed
Return values
mixed —esc()
esc(mixed $str) : mixed
Parameters
- $str : mixed
Return values
mixed —dump()
dump(mixed $var, mixed ...$moreVars) : mixed
Parameters
- $var : mixed
- $moreVars : mixed
Tags
Return values
mixed —dd()
dd(mixed ...$vars) : mixed
Parameters
- $vars : mixed