Documentation

Application

Interfaces

ExceptionInterface: Base exception marker interface for the instantiator component
InstantiatorInterface: Instantiator provides utility methods to build objects without invoking their constructors
EventEmitterInterface
BodySummarizerInterface
ClientInterface: Client interface for sending HTTP requests.
CookieJarInterface: Stores HTTP cookies.
GuzzleException: Every HTTP client related exception MUST implement this interface.
CurlFactoryInterface
MessageFormatterInterface
PromiseInterface: A promise represents the eventual result of an asynchronous operation.
PromisorInterface: Interface used with classes that return a promise.
TaskQueueInterface
Listenable: Interface \Hoa\Event\Listenable.
Source: Interface \Hoa\Event\Source.
Aggregate: Interface \Hoa\Iterator\Aggregate.
Iterator: Interface \Hoa\Iterator.
Outer: Interface \Hoa\Iterator\Outer.
Recursive: Class \Hoa\Iterator\Recursive.
Seekable: Interface \Hoa\IteratorSeekable.
Bufferable: Interface \Hoa\Stream\IStream\Bufferable.
In: Interface \Hoa\Stream\IStream\In.
Lockable: Interface \Hoa\Stream\IStream\Lockable.
Out: Interface \Hoa\Stream\IStream\Out.
Pathable: Interface \Hoa\Stream\IStream\Pathable.
Pointable: Interface \Hoa\Stream\IStream\Pointable.
Statable: Interface \Hoa\Stream\IStream\Statable.
Stream: Interface \Hoa\Stream\IStream\Stream.
Structural: Interface \Hoa\Stream\IStream\Structural.
Touchable: Interface \Hoa\Stream\IStream\Touchable.
File: Interface \Hoa\Stream\Wrapper\IWrapper\File.
IWrapper: Interface \Hoa\Stream\Wrapper\IWrapper.
Stream: Interface \Hoa\Stream\Wrapper\IWrapper\Stream.
EmitterAwareInterface
EmitterInterface
EventInterface
GeneratorInterface
ListenerAcceptorInterface
ListenerInterface
ListenerProviderInterface
Filter: Filter to apply to a property while copying an object
Matcher
TypeFilter
Builder
ErrorHandler
FunctionLike
Node
NodeTraverserInterface
NodeVisitor
Parser
PrettyPrinter
Exception
Requirement
VersionConstraint
Exception
ArrayConvertable: Array convertable entity.
TestInterface
Exception
Exception
Exception
Exception
InvocationStubber
MockObject
ParametersRule
Stub
Test
TestListener: This interface, as well as the associated mechanism for extending PHPUnit, will be removed in PHPUnit 10. There is no alternative available in this version of PHPUnit.
AfterIncompleteTestHook: This interface, as well as the associated mechanism for extending PHPUnit, will be removed in PHPUnit 10. There is no alternative available in this version of PHPUnit.
AfterLastTestHook: This interface, as well as the associated mechanism for extending PHPUnit, will be removed in PHPUnit 10. There is no alternative available in this version of PHPUnit.
AfterRiskyTestHook: This interface, as well as the associated mechanism for extending PHPUnit, will be removed in PHPUnit 10. There is no alternative available in this version of PHPUnit.
AfterSkippedTestHook: This interface, as well as the associated mechanism for extending PHPUnit, will be removed in PHPUnit 10. There is no alternative available in this version of PHPUnit.
AfterSuccessfulTestHook: This interface, as well as the associated mechanism for extending PHPUnit, will be removed in PHPUnit 10. There is no alternative available in this version of PHPUnit.
AfterTestErrorHook: This interface, as well as the associated mechanism for extending PHPUnit, will be removed in PHPUnit 10. There is no alternative available in this version of PHPUnit.
AfterTestFailureHook: This interface, as well as the associated mechanism for extending PHPUnit, will be removed in PHPUnit 10. There is no alternative available in this version of PHPUnit.
AfterTestHook: This interface, as well as the associated mechanism for extending PHPUnit, will be removed in PHPUnit 10. There is no alternative available in this version of PHPUnit.
AfterTestWarningHook: This interface, as well as the associated mechanism for extending PHPUnit, will be removed in PHPUnit 10. There is no alternative available in this version of PHPUnit.
BeforeFirstTestHook: This interface, as well as the associated mechanism for extending PHPUnit, will be removed in PHPUnit 10. There is no alternative available in this version of PHPUnit.
BeforeTestHook: This interface, as well as the associated mechanism for extending PHPUnit, will be removed in PHPUnit 10. There is no alternative available in this version of PHPUnit.
Hook: This interface, as well as the associated mechanism for extending PHPUnit, will be removed in PHPUnit 10. There is no alternative available in this version of PHPUnit.
TestHook: This interface, as well as the associated mechanism for extending PHPUnit, will be removed in PHPUnit 10. There is no alternative available in this version of PHPUnit.
TestSuiteLoader
ResultPrinter: This interface, as well as the associated mechanism for extending PHPUnit, will be removed in PHPUnit 10. There is no alternative available in this version of PHPUnit.
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.
ClientExceptionInterface: Every HTTP client related exception MUST implement this interface.
ClientInterface
NetworkExceptionInterface: Thrown when the request cannot be completed because of network issues.
RequestExceptionInterface: Exception for when a request failed.
RequestFactoryInterface
ResponseFactoryInterface
ServerRequestFactoryInterface
StreamFactoryInterface
UploadedFileFactoryInterface
UriFactoryInterface
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.
NegotiatorInterface: A standard interface for interacting with the various version of the WebSocket protocol
DataInterface
FrameInterface
MessageInterface
CacheInterface
ExecutorInterface
ResolverInterface
LoopInterface
TimerInterface
PromiseInterface
ConnectionInterface: Any incoming and outgoing connection is represented by this interface, such as a normal TCP/IP connection.
ConnectorInterface: The `ConnectorInterface` is responsible for providing an interface for establishing streaming connections, such as a normal TCP/IP connection.
ServerInterface: The `ServerInterface` is responsible for providing an interface for accepting incoming streaming connections, such as a normal TCP/IP connection.
DuplexStreamInterface: The `DuplexStreamInterface` is responsible for providing an interface for duplex streams (both readable and writable).
ReadableStreamInterface: The `ReadableStreamInterface` is responsible for providing an interface for read-only streams and the readable side of duplex streams.
WritableStreamInterface: The `WritableStreamInterface` is responsible for providing an interface for write-only streams and the writable side of duplex streams.
Exception
Exception
Exception
Exception
Exception
LongestCommonSubsequenceCalculator
DiffOutputBuilderInterface: Defines how an output builder should take a generated diff array and return a string representation of that diff.
Exception
Exception
Exception
Exception
Exception
Exception
ConfigBuilderGeneratorInterface: Generates ConfigBuilders to help create valid config.
ConfigBuilderInterface: A ConfigBuilder provides helper methods to build a large complex array.
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.
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.
Stringable
ExceptionInterface: Marker Interface for the Process Component.
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.
ExceptionInterface: Exception interface for all exceptions thrown by the component.

Classes

Utils
UtilsTest
ApiException
ApiResponseTest
Client
ClientTest
MultipartBuilder
MultipartBuilderTest
Auth
Platform
PlatformTest
SDK
SDKTest
ErrorEvent: Event is the base class for classes containing event data.
NotificationEvent: Event is the base class for classes containing event data.
SuccessEvent: Event is the base class for classes containing event data.
PubnubCallback
PubnubSubscription: The EventDispatcherInterface is the central point of Symfony's event listener system.
SubscriptionBase: The EventDispatcherInterface is the central point of Symfony's event listener system.
SubscriptionTest
TestCase
ApiException
ApiRequest
ApiResponse
CloseEvent: Event is the base class for classes containing event data.
ErrorEvent: Event is the base class for classes containing event data.
NotificationEvent: Event is the base class for classes containing event data.
SuccessEvent: Event is the base class for classes containing event data.
Subscription: The EventDispatcherInterface is the central point of Symfony's event listener system.
WebSocketSubscriptionTest
WebSocket: The EventDispatcherInterface is the central point of Symfony's event listener system.
WebSocketTest
ComposerAutoloaderInitbda01b18b54393c39f40761038f02a6f
ComposerStaticInitbda01b18b54393c39f40761038f02a6f
ClassLoader: ClassLoader implements a PSR-0, PSR-4 and classmap class loader.
InstalledVersions: This class is copied in every Composer installed project and available to all
InvalidArgumentException: Exception for invalid arguments provided to the instantiator
UnexpectedValueException: Exception for given parameters causing invalid/unexpected state on instantiation
Instantiator
EventEmitter
BodySummarizer
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
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.
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).
Create
Each
EachPromise: Represents a promise that iterates over many promises and invokes side-effect functions in the process.
FulfilledPromise: A promise that has been fulfilled.
Is
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.
Utils
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.
MalformedUriException: Exception thrown if a URI cannot be parsed because it's malformed.
FnStream: Compose stream implementations based on a hash of functions.
Header
HttpFactory: Implements all of the PSR-17 interfaces.
InflateStream: Uses PHP's zlib.inflate filter to inflate zlib (HTTP deflate, RFC1950) or gzipped (RFC1952) 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.
Message
MimeType
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.
Query
Request: PSR-7 request implementation.
Response: PSR-7 response implementation.
ServerRequest: Server-side HTTP request
Stream: PHP stream implementation.
StreamWrapper: Converts Guzzle streams into PHP stream resources.
UploadedFile
Uri: PSR-7 URI implementation.
UriComparator: Provides methods to determine if a modified URL should be considered cross-origin.
UriNormalizer: Provides methods to normalize and compare URIs.
UriResolver: Resolves a URI reference in the context of a base URI and the opposite way.
Utils
Autoloader: Class Hoa\Consistency\Autoloader.
Exception: Class \Hoa\Consistency\Exception.
Autoloader: Class \Hoa\Consistency\Test\Unit\Autoloader.
Consistency: Class \Hoa\Consistency\Test\Unit\Consistency.
Exception: Class \Hoa\Consistency\Test\Unit\Exception.
Xcallable: Class \Hoa\Consistency\Test\Unit\Xcallable.
Bucket: Class \Hoa\Event\Bucket.
Event: Class \Hoa\Event\Event.
Exception: Class \Hoa\Event\Exception.
Listener: Class \Hoa\Event\Listener.
Bucket: Class \Hoa\Event\Test\Unit\Bucket.
Event: Class \Hoa\Event\Test\Unit\Event.
Exception: Class \Hoa\Event\Test\Unit\Exception.
Listenable: Class \Hoa\Event\Test\Unit\Listenable.
Listener: Class \Hoa\Event\Test\Unit\Listener.
Listens: Class \Hoa\Event\Test\Unit\Listens.
_Listenable
Source: Class \Hoa\Event\Test\Unit\Source.
Error: Class \Hoa\Exception\Error.
Exception: Class \Hoa\Exception\Exception.
Group: Class \Hoa\Exception\Group.
Idle: Class \Hoa\Exception\Idle.
Error: Class \Hoa\Exception\Test\Unit\Error.
Exception: Class \Hoa\Exception\Test\Unit\Exception.
Group: Class \Hoa\Exception\Test\Unit\Group.
Idle: Class \Hoa\Exception\Test\Unit\Idle.
Directory: Class \Hoa\File\Directory.
Exception: Class \Hoa\File\Exception.
FileDoesNotExist: Class \Hoa\File\Exception\FileDoesNotExist.
File: Class \Hoa\File.
Finder: Class \Hoa\File\Finder.
Generic: Class \Hoa\File\Generic.
Link: Class \Hoa\File\Link.
Read: Class \Hoa\File\Link\Read.
ReadWrite: Class \Hoa\File\Link\ReadWrite.
Write: Class \Hoa\File\Link\Write.
Read: Class \Hoa\File\Read.
ReadWrite: Class \Hoa\File\ReadWrite.
SplFileInfo: Class \Hoa\File\SplFileInfo.
Read: Class \Hoa\File\Temporary\Read.
ReadWrite: Class \Hoa\File\Temporary\ReadWrite.
Temporary: Class \Hoa\File\Temporary.
Write: Class \Hoa\File\Temporary\Write.
Watcher: Class \Hoa\File\Watcher.
Write: Class \Hoa\File\Write.
Append: Class \Hoa\Iterator\Append.
Buffer: Class \Hoa\Iterator\Buffer.
CallbackFilter: Class \Hoa\Iterator\CallbackFilter.
CallbackGenerator: Class \Hoa\Iterator\CallbackGenerator.
Counter: Class \Hoa\Iterator\Counter.
Demultiplexer: Class \Hoa\Iterator\Demultiplexer.
Directory: Class \Hoa\Iterator\Directory.
Exception: Class \Hoa\Iterator\Exception.
FileSystem: Class \Hoa\Iterator\FileSystem.
Filter: Class \Hoa\Iterator\Filter.
Glob: Class \Hoa\Iterator\Glob.
Infinite: Class \Hoa\Iterator\Infinite.
IteratorIterator: Class \Hoa\Iterator\IteratorIterator.
Limit: Class \Hoa\Iterator\Limit.
Lookahead: Class \Hoa\Iterator\Lookahead.
Lookbehind: Class \Hoa\Iterator\Lookbehind.
Map: Class \Hoa\Iterator\Map.
Mock: Class \Hoa\Iterator\Mock.
Multiple: Class \Hoa\Iterator\Multiple.
NoRewind: Class \Hoa\Iterator\NoRewind.
CallbackFilter: Class \Hoa\Iterator\Recursive\CallbackFilter.
Directory: Class \Hoa\Iterator\Recursive\Directory.
Filter: Class \Hoa\Iterator\Recursive\Filter.
Iterator: Class \Hoa\Iterator\Recursive\Iterator.
Map: Class \Hoa\Iterator\Recursive\Map.
Mock: Class \Hoa\Iterator\Recursive\Mock.
RegularExpression: Class \Hoa\Iterator\Recursive\RegularExpression.
RegularExpression: Class \Hoa\Iterator\RegularExpression.
Repeater: Class \Hoa\Iterator\Repeater.
SplFileInfo: Class \Hoa\Iterator\SplFileInfo.
Append: Class \Hoa\Iterator\Test\Unit\Append.
Buffer: Class \Hoa\Iterator\Test\Unit\Buffer.
CallbackFilter: Class \Hoa\Iterator\Test\Unit\CallbackFilter.
CallbackGenerator: Class \Hoa\Iterator\Test\Unit\CallbackGenerator.
Counter: Class \Hoa\Iterator\Test\Unit\Counter.
Demultiplexer: Class \Hoa\Iterator\Test\Unit\Demultiplexer.
Directory: Class \Hoa\Iterator\Test\Unit\Directory.
FileSystem: Class \Hoa\Iterator\Test\Unit\FileSystem.
MyFilter: Class \Hoa\Iterator\Test\Unit\MyFilter.
Filter: Class \Hoa\Iterator\Test\Unit\Filter.
Infinite: Class \Hoa\Iterator\Test\Unit\Infinite.
IteratorIterator: Class \Hoa\Iterator\Test\Unit\IteratorIterator.
Limit: Class \Hoa\Iterator\Test\Unit\Limit.
Lookahead: Class \Hoa\Iterator\Test\Unit\Lookahead.
Lookbehind: Class \Hoa\Iterator\Test\Unit\Lookbehind.
Map: Class \Hoa\Iterator\Test\Unit\Map.
Mock: Class \Hoa\Iterator\Test\Unit\Mock.
Multiple: Class \Hoa\Iterator\Test\Unit\Multiple.
NoRewind: Class \Hoa\Iterator\Test\Unit\NoRewind.
RegularExpression: Class \Hoa\Iterator\Test\Unit\RegularExpression.
Repeater: Class \Hoa\Iterator\Test\Unit\Repeater.
SplFileInfo: Class \Hoa\Iterator\Test\Unit\SplFileInfo.
Resolve: Class \Hoa\Protocol\Bin\Resolve.
Exception: Class \Hoa\Protocol\Exception.
Library: Class \Hoa\Protocol\Node\Library.
Node: Class \Hoa\Protocol\Node\Node.
Protocol: Class \Hoa\Protocol\Protocol.
Exception: Class \Hoa\Protocol\Test\Unit\Exception.
Library: Class \Hoa\Protocol\Test\Unit\Node\Library.
Node: Class \Hoa\Protocol\Test\Unit\Node\Node.
Protocol: Class \Hoa\Protocol\Test\Unit\Protocol.
Wrapper: Class \Hoa\Protocol\Test\Unit\Wrapper.
Bucket: Class \Hoa\Stream\Bucket.
Composite: Class \Hoa\Stream\Composite.
Context: Class \Hoa\Stream\Context.
Exception: Class \Hoa\Stream\Exception.
Basic: Class \Hoa\Stream\Filter\Basic.
Exception: Class \Hoa\Stream\Filter\Exception.
Filter: Class \Hoa\Stream\Filter.
LateComputed: Class \Hoa\Stream\Filter\LateComputed.
Stream: Class \Hoa\Stream.
_Protocol: Class \Hoa\Stream\_Protocol.
Filter: Class \Hoa\Stream\Test\Integration\Filter\Filter.
LateComputed: Class \Hoa\Stream\Test\Integration\Filter\LateComputed.
CustomFilter: Class \Hoa\Stream\Filter\LateComputed.
Stream: Class \Hoa\Stream\Test\Integration\Stream.
SUT: Class \Hoa\Stream.
Bucket: Class \Hoa\Stream\Test\Unit\Bucket.
Composite: Class \Hoa\Stream\Test\Unit\Composite.
Context: Class \Hoa\Stream\Test\Unit\Context.
Exception: Class \Hoa\Stream\Test\Unit\Exception.
Basic: Class \Hoa\Stream\Test\Unit\Filter\Basic.
Exception: Class \Hoa\Stream\Test\Unit\Filter\Exception.
Filter: Class \Hoa\Stream\Test\Unit\Filter\Filter.
Bufferable: Class \Hoa\Stream\Test\Unit\IStream\Bufferable.
In: Class \Hoa\Stream\Test\Unit\IStream\In.
Lockable: Class \Hoa\Stream\Test\Unit\IStream\Lockable.
Out: Class \Hoa\Stream\Test\Unit\IStream\Out.
Pathable: Class \Hoa\Stream\Test\Unit\IStream\Pathable.
Pointable: Class \Hoa\Stream\Test\Unit\IStream\Pointable.
Statable: Class \Hoa\Stream\Test\Unit\IStream\Statable.
Stream: Class \Hoa\Stream\Test\Unit\IStream\Stream.
Structural: Class \Hoa\Stream\Test\Unit\IStream\Structural.
Touchable: Class \Hoa\Stream\Test\Unit\IStream\Touchable.
Stream: Class \Hoa\Stream\Test\Unit\Stream.
SUT: Class \Hoa\Stream.
SUTWithPublicClose: Class \Hoa\Stream.
Exception: Class \Hoa\Stream\Test\Unit\Wrapper\Exception.
File: Class \Hoa\Stream\Test\Unit\Wrapper\IWrapper\File.
IWrapper: Class \Hoa\Stream\Test\Unit\Wrapper\IWrapper\IWrapper.
Stream: Class \Hoa\Stream\Test\Unit\Wrapper\IWrapper\Stream.
Wrapper: Class \Hoa\Stream\Test\Unit\Wrapper\Wrapper.
Exception: Class \Hoa\Stream\Wrapper\Exception.
Wrapper: Class \Hoa\Stream\Wrapper.
AbstractEvent
AbstractListener
BufferedEmitter
CallbackListener
Emitter
Event
Generator
ListenerAcceptor
OneTimeListener
DeepCopy
CloneException
PropertyException
ChainableFilter: Defines a decorator filter that will not stop the chain of filters.
DoctrineCollectionFilter
DoctrineEmptyCollectionFilter
DoctrineProxyFilter
KeepFilter
ReplaceFilter
SetNullFilter
DoctrineProxyMatcher
PropertyMatcher
PropertyNameMatcher
PropertyTypeMatcher: Matches a property by its type.
ReflectionHelper
DateIntervalFilter
ReplaceFilter
ShallowCopyFilter
ArrayObjectFilter: In PHP 7.4 the storage of an ArrayObject isn't returned as ReflectionProperty. So we deep copy its array copy.
SplDoublyLinkedList
SplDoublyLinkedListFilter
TypeMatcher
SignalHandler
CallableStub
SignalHandlerTest
Class_
ClassConst
Declaration
Enum_
EnumCase
Function_
FunctionLike
Interface_
Method
Namespace_
Param
Property
Trait_
TraitUse
TraitUseAdaptation
Use_
BuilderFactory
Doc
Comment
ConstExprEvaluationException
ConstExprEvaluator: Evaluates constant expressions.
Error
Collecting: Error handler that collects all errors into an array.
Throwing: Error handler that handles all errors by throwing them.
JsonDecoder
Emulative
AttributeEmulator
EnumTokenEmulator
ExplicitOctalEmulator
KeywordEmulator
MatchTokenEmulator
NullsafeTokenEmulator
ReadonlyFunctionTokenEmulator
ReadonlyTokenEmulator
ReverseEmulator: Reverses emulation direction of the inner emulator.
Lexer
Modifiers: Modifiers used (as a bit mask) by various flags subnodes, for example on classes, functions, properties and constants.
NameContext
Arg
ArrayItem
Attribute
AttributeGroup
ClosureUse
ComplexType: This is a base class for complex types, including nullable types and union types.
Const_
DeclareItem
Array_
ArrayDimFetch
ArrowFunction
Assign
BitwiseAnd
BitwiseOr
BitwiseXor
Coalesce
Concat
Div
Minus
Mod
Mul
Plus
Pow
ShiftLeft
ShiftRight
AssignOp
AssignRef
BitwiseAnd
BitwiseOr
BitwiseXor
BooleanAnd
BooleanOr
Coalesce
Concat
Div
Equal
Greater
GreaterOrEqual
Identical
LogicalAnd
LogicalOr
LogicalXor
Minus
Mod
Mul
NotEqual
NotIdentical
Plus
Pow
ShiftLeft
ShiftRight
Smaller
SmallerOrEqual
Spaceship
BinaryOp
BitwiseNot
BooleanNot
CallLike
Array_
Bool_
Double
Int_
Object_
String_
Unset_
Cast
ClassConstFetch
Clone_
Closure
ConstFetch
Empty_
Error: Error node used during parsing with error recovery.
ErrorSuppress
Eval_
Exit_
FuncCall
Include_
Instanceof_
Isset_
List_
Match_
MethodCall
New_
NullsafeMethodCall
NullsafePropertyFetch
PostDec
PostInc
PreDec
PreInc
Print_
PropertyFetch
ShellExec
StaticCall
StaticPropertyFetch
Ternary
Throw_
UnaryMinus
UnaryPlus
Variable
Yield_
YieldFrom
Expr
Identifier: Represents a non-namespaced name. Namespaced names are represented using Name nodes.
InterpolatedStringPart
IntersectionType: This is a base class for complex types, including nullable types and union types.
MatchArm
FullyQualified
Relative
Name
NullableType: This is a base class for complex types, including nullable types and union types.
Param
PropertyItem
Float_
Int_
InterpolatedString
Class_
Dir
File
Function_
Line
Method
Namespace_
Trait_
MagicConst
String_
Scalar
StaticVar
Block
Break_
Case_
Catch_
Class_
ClassConst
ClassLike
ClassMethod
Const_
Continue_
Declare_
Do_
Echo_
Else_
ElseIf_
Enum_
EnumCase
Expression: Represents statements of type "expr;"
Finally_
For_
Foreach_
Function_
Global_
Goto_
GroupUse
HaltCompiler
If_
InlineHTML
Interface_
Label
Namespace_
Nop: Nop/empty statement (;).
Property
Return_
Static_
Switch_
Trait_
TraitUse
Alias
Precedence
TraitUseAdaptation
TryCatch
Unset_
Use_
While_
Stmt
UnionType: This is a base class for complex types, including nullable types and union types.
UseItem
VariadicPlaceholder: Represents the "..." in "foo(...)" of the first-class callable syntax.
VarLikeIdentifier: Represents a name that is written in source code with a leading dollar, but is not a proper variable. The leading dollar is not stored as part of the name.
NodeAbstract
NodeDumper
NodeFinder
NodeTraverser
CloningVisitor: Visitor cloning all nodes and linking to the original nodes using an attribute.
CommentAnnotatingVisitor
FindingVisitor: This visitor can be used to find and collect all nodes satisfying some criterion determined by a filter callback.
FirstFindingVisitor: This visitor can be used to find the first node satisfying some criterion determined by a filter callback.
NameResolver
NodeConnectingVisitor: Visitor that connects a child node to its parent node as well as its sibling nodes.
ParentConnectingVisitor: Visitor that connects a child node to its parent node.
NodeVisitorAbstract
Php7
Php8
ParserAbstract
ParserFactory
PhpVersion: A PHP version, representing only the major and minor version components.
Standard
PrettyPrinterAbstract
Token: A PHP token. On PHP 8.0 this extends from PhpToken.
ElementCollectionException
InvalidApplicationNameException
InvalidEmailException
InvalidUrlException
ManifestDocumentException
ManifestDocumentLoadingException
ManifestDocumentMapperException
ManifestElementException
ManifestLoaderException
NoEmailAddressException
ManifestDocumentMapper
ManifestLoader
ManifestSerializer
Application
ApplicationName
Author
AuthorCollection
AuthorCollectionIterator
BundledComponent
BundledComponentCollection
BundledComponentCollectionIterator
CopyrightInformation
Email
Extension
Library
License
Manifest
PhpExtensionRequirement
PhpVersionRequirement
RequirementCollection
RequirementCollectionIterator
Type
Url
AuthorElement
AuthorElementCollection
BundlesElement
ComponentElement
ComponentElementCollection
ContainsElement
CopyrightElement
ElementCollection
ExtElement
ExtElementCollection
ExtensionElement
LicenseElement
ManifestDocument
ManifestElement
PhpElement
RequiresElement
PhpdocSingleLineVarFixer: Main implementation taken from kubawerlos/php-cs-fixer-customere-fixers Copyright (c) 2018 Kuba Werłos
BuildMetaData
AbstractVersionConstraint
AndVersionConstraintGroup
AnyVersionConstraint
ExactVersionConstraint
GreaterThanOrEqualToVersionConstraint
OrVersionConstraintGroup
SpecificMajorAndMinorVersionConstraint
SpecificMajorVersionConstraint
InvalidPreReleaseSuffixException
InvalidVersionException
NoBuildMetaDataException
NoPreReleaseSuffixException
UnsupportedVersionConstraintException
PreReleaseSuffix
Version
VersionConstraintParser
VersionConstraintValue
VersionNumber
CoverallsApi: Coveralls API client.
Jobs: Jobs API.
CiEnvVarsCollector: Environment variables collector for CI envrionment.
CloverXmlCoverageCollector: Coverage collector for clover.xml.
GitInfoCollector: Git repository info collector.
CoverallsJobsCommand: Coveralls Jobs API v1 command.
Configuration: Coveralls API configuration.
Configurator: Coveralls API configurator.
CoverallsConfiguration: Definition of .coveralls.yml configuration.
Application: Coveralls API application.
ApplicationFactory: In symfony/console 3.1 and lower provides only one way to realize single command application.
CoverallsBundle: Coveralls bundle.
Coveralls: Data for Coveralls API.
RequirementsNotSatisfiedException: Requirements of json_file are not satisfied.
Commit: Commit info.
Git: Data represents "git" of Coveralls API.
Remote: Remote info.
JsonFile: Data represents "json_file" of Coveralls API.
Metrics: Metrics.
SourceFile: Data represents "source_files" element of Coveralls' "json_file".
JobsRepository: Jobs API client.
Version: CoverallsBundle version.
Path: Path utils.
ConsoleLogger: Console logger for php-coveralls command.
GitCommand: Git command.
AbstractClass
Coverage0
Coverage10
Coverage100
Coverage70
Coverage80
Coverage90
TestFile
TestFile
TestFileBis
ProjectTestCase
CodeCoverage: Provides collection functionality for PHP code coverage information.
Selector
BranchAndPathCoverageNotSupportedException
DeadCodeDetectionNotSupportedException
DirectoryCouldNotBeCreatedException
InvalidArgumentException
NoCodeCoverageDriverAvailableException
NoCodeCoverageDriverWithPathCoverageSupportAvailableException
ParserException
PathExistsButIsNotDirectoryException
PcovNotAvailableException
PhpdbgNotAvailableException
ReflectionException
ReportAlreadyFinalizedException
StaticAnalysisCacheNotConfiguredException
TestIdMissingException
UnintentionallyCoveredCodeException
WriteOperationFailedException
WrongXdebugVersionException
Xdebug2NotEnabledException
Xdebug3NotEnabledException
XdebugNotAvailableException
XmlException
Filter
Clover
Cobertura
Crap4j
Facade
PHP
Text
Facade
CacheWarmer
Version
Facade
Factory
Iterator
ProcessControlExtensionNotLoadedException
TimeoutException
Invoker
InvalidArgumentException
RuntimeException
Template
Duration
NoActiveTimerException
TimeSinceStartOfRequestNotAvailableException
ResourceUsageFormatter
Timer
Assert
IsFalse
IsTrue
Callback
Count
GreaterThan
IsEmpty
LessThan
SameSize
Constraint
IsEqual
IsEqualCanonicalizing
IsEqualIgnoringCase
IsEqualWithDelta
Exception
ExceptionCode
ExceptionMessage
ExceptionMessageRegularExpression
DirectoryExists
FileExists
IsReadable
IsWritable
IsAnything
IsIdentical
JsonMatches
JsonMatchesErrorMessageProvider
IsFinite
IsInfinite
IsNan
ClassHasAttribute
ClassHasStaticAttribute
ObjectEquals
ObjectHasAttribute
ObjectHasProperty
BinaryOperator
LogicalAnd
LogicalNot
LogicalOr
LogicalXor
Operator
UnaryOperator
IsJson
RegularExpression
StringContains
StringEndsWith
StringMatchesFormatDescription
StringStartsWith
ArrayHasKey
TraversableContains
TraversableContainsEqual
TraversableContainsIdentical
TraversableContainsOnly
IsInstanceOf
IsNull
IsType
InvocationMocker
MockBuilder
TestCase
Version
Command
Blacklist
ExcludeList
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.
SubscribeOperation
UnsubscribeOperation
PubSubBuilder
SubscribeBuilder
SubscribeCallback
AesCbcCryptor
Cryptor
Header
LegacyCryptor
Payload
CryptoModule
Audit
Grant
GrantToken
Revoke
RevokeToken
AddChannelToChannelGroup
ListChannelsInChannelGroup
RemoveChannelFromChannelGroup
RemoveChannelGroup
Endpoint
History
HistoryDelete
MessageCount
GetAllChannelMetadata
GetChannelMetadata
RemoveChannelMetadata
SetChannelMetadata
GetMembers
RemoveMembers
SetMembers
GetMemberships
RemoveMemberships
SetMemberships
ObjectsCollectionEndpoint
GetAllUUIDMetadata
GetUUIDMetadata
RemoveUUIDMetadata
SetUUIDMetadata
GetState
HereNow
Leave
WhereNow
Publish
Signal
Subscribe
AddChannelsToPush
ListPushProvisions
RemoveChannelsFromPush
RemoveDeviceFromPush
Time
PNHttpMethod
PNOperationType
PNPushType
PNStatusCategory
PubNubBuildRequestException: Class PubNubException
PubNubConfigurationException: Class PubNubException
PubNubConnectionException: Class PubNubException
PubNubCryptoException: Class PubNubException
PubNubNotImplementException: Class PubNubException
PubNubResponseParsingException: Class PubNubException
PubNubServerException: Class PubNubException
PubNubTokenParseException: Class PubNubException
PubNubUnsubscribeException
PubNubValidationException: Class PubNubException
BasePathManager
ListenerManager
StateManager
SubscriptionManager
TelemetryManager
TokenManager
Permissions
PNAccessManagerAbstractResult
PNAccessManagerAuditResult
PNAccessManagerChannelData
PNAccessManagerChannelGroupData
PNAccessManagerGrantResult
PNAccessManagerKeyData
PNAccessManagerTokenResult
PNAccessManagerUserData
PNPAMEntityData
PNChannelGroupsAddChannelResult
PNChannelGroupsListChannelsResult
PNChannelGroupsRemoveChannelResult
PNChannelGroupsRemoveGroupResult
PNHistoryDeleteResult
PNHistoryItemResult
PNMessageCountResult
PNChannelMetadata
PNGetAllChannelMetadataResult
PNGetChannelMetadataResult
PNSetChannelMetadataResult
PNMember
PNMembersResult
PNMembersResultItem
PNMembership
PNMembershipsResult
PNMembershipsResultItem
PNGetAllUUIDMetadataResult
PNGetUUIDMetadataResult
PNSetUUIDMetadataResult
PNUUIDMetadata
PNPublishResult
PNRequestResult
PNTimeResult
PNGetStateResult
PNHereNowChannelData
PNHereNowOccupantsData
PNHereNowResult
PNSetStateResult
PNWhereNowResult
PNMessageResult
PNPresenceEventResult
PNSignalMessageResult
PNSignalResult
SubscribeEnvelope
PNPushAddChannelResult
PNPushListProvisionsResult
PNPushRemoveAllChannelsResult
PNPushRemoveChannelResult
PNEnvelope
PNStatus
ResponseInfo
PublishMetadata
MessageType
SubscribeMessage
SubscribeMetadata
SubscriptionItem
PNConfiguration
PubNub
PubNubCborDecode
PubNubCrypto
PubNubCryptoCore
PubNubCryptoLegacy
PubNubUtil
Connector
WebSocket
ConnectorTest
RequestUriTest
ClientNegotiator
InvalidPermessageDeflateOptionsException
PermessageDeflateOptions
RequestVerifier: These are checks to ensure the client requested handshake are valid Verification rules come from section 4.2.1 of the RFC6455 document
ResponseVerifier
ServerNegotiator: The latest version of the WebSocket protocol
CloseFrameChecker
Message
MessageBuffer
AbResultsTest
PermessageDeflateOptionsTest
RequestVerifierTest
ResponseVerifierTest
ServerNegotiatorTest
FrameTest
MessageBufferTest
MessageTest
ArrayCache
BadServerException
Config
HostsFile: Represents a static hosts file which maps hostnames to IPs
Message: This class represents an outgoing query message or an incoming response message
Record: This class represents a single resulting record in a response message
BinaryDumper
Parser: DNS protocol parser
CachingExecutor
CancellationException
CoopExecutor: Cooperatively resolves hosts via the given base executor to ensure same query is not run concurrently
FallbackExecutor
HostsFileExecutor: Resolves hosts from the given HostsFile or falls back to another executor
Query: This class represents a single question in a query/response message
RetryExecutor
SelectiveTransportExecutor: Send DNS queries over a UDP or TCP/IP stream transport.
TcpTransportExecutor: Send DNS queries over a TCP/IP stream transport.
TimeoutException
TimeoutExecutor
UdpTransportExecutor: Send DNS queries over a UDP transport.
RecordNotFoundException
Factory
Resolver
ExtEventLoop: An `ext-event` based event loop.
ExtEvLoop: An `ext-ev` based event loop.
ExtLibeventLoop: [Deprecated] An `ext-libevent` based event loop.
ExtLibevLoop: [Deprecated] An `ext-libev` based event loop.
ExtUvLoop: An `ext-uv` based event loop.
Factory: [Deprecated] The `Factory` class exists as a convenient way to pick the best available event loop implementation.
Loop: The `Loop` class exists as a convenient way to get the currently relevant loop
StreamSelectLoop: A `stream_select()` based event loop.
Deferred
CompositeException: Represents an exception that is a composite of one or more other exceptions.
LengthException
Promise
Connector: The `Connector` class is the main class in this package that implements the `ConnectorInterface` and allows you to create streaming connections.
DnsConnector
FixedUriConnector: Decorates an existing Connector to always use a fixed, preconfigured URI
HappyEyeBallsConnector
LimitingServer: The `LimitingServer` decorator wraps a given `ServerInterface` and is responsible for limiting and keeping track of open connections to this server instance.
SecureConnector
SecureServer: The `SecureServer` class implements the `ServerInterface` and is responsible for providing a secure TLS (formerly known as SSL) server.
Server
SocketServer
TcpConnector
TcpServer: The `TcpServer` class implements the `ServerInterface` and is responsible for accepting plaintext TCP/IP connections.
TimeoutConnector
UnixConnector: Unix domain socket connector
UnixServer: The `UnixServer` class implements the `ServerInterface` and is responsible for accepting plaintext connections on unix domain sockets.
CompositeStream
DuplexResourceStream
ReadableResourceStream
ThroughStream: The `ThroughStream` implements the [`DuplexStreamInterface`](#duplexstreaminterface) and will simply pass any data you write to it through to its readable end.
Util
WritableResourceStream
ByteSizeTest
BinaryTest
MetricTest
AmbiguousOptionException
OptionDoesNotAllowArgumentException
RequiredOptionArgumentMissingException
UnknownOptionException
Parser
ClassMethodUnit
ClassUnit
CodeUnit
CodeUnitCollection
CodeUnitCollectionIterator
InvalidCodeUnitException
NoTraitException
ReflectionException
FunctionUnit
InterfaceMethodUnit
InterfaceUnit
Mapper
TraitMethodUnit
TraitUnit
Wizard
ArrayComparator: Compares arrays for equality.
Comparator: Abstract base class for comparators which compare values for equality.
ComparisonFailure: Thrown when an assertion for string equality failed.
DateTimeComparator: Compares DateTimeInterface instances for equality.
DOMNodeComparator: Compares DOMNode instances for equality.
DoubleComparator: Compares doubles for equality.
ExceptionComparator: Compares Exception instances for equality.
RuntimeException
Factory: Factory for comparators which compare values for equality.
MockObjectComparator: Compares PHPUnit\Framework\MockObject\MockObject instances for equality.
NumericComparator: Compares numerical values for equality.
ObjectComparator: Compares objects for equality.
ResourceComparator: Compares resources for equality.
ScalarComparator: Compares scalar or NULL values for equality.
SplObjectStorageComparator: Compares \SplObjectStorage instances for equality.
TypeComparator: Compares values for type equality.
Calculator
Complexity
ComplexityCollection
ComplexityCollectionIterator
RuntimeException
ComplexityCalculatingVisitor
CyclomaticComplexityCalculatingVisitor
Chunk
Diff
Differ
ConfigurationException
InvalidArgumentException
Line
MemoryEfficientLongestCommonSubsequenceCalculator
AbstractChunkOutputBuilder
DiffOnlyOutputBuilder: Builds a diff string representation in a loose unified diff format listing only changes lines. Does not include line numbers.
StrictUnifiedDiffOutputBuilder: Strict Unified diff output builder.
UnifiedDiffOutputBuilder: Builds a diff string representation in unified diff format in chunks.
Parser: Unified diff parser.
TimeEfficientLongestCommonSubsequenceCalculator
Console
OperatingSystem
Runtime: Utility class for HHVM/PHP environment handling.
Exporter: A nifty utility for visualizing PHP variables.
CodeExporter: Exports parts of a Snapshot as PHP code.
RuntimeException
ExcludeList
Restorer: Restorer of snapshots of global state.
Snapshot: A snapshot of global state.
Counter
IllogicalValuesException
NegativeValueException
RuntimeException
LineCountingVisitor
LinesOfCode
Enumerator: Traverses array structures and object graphs to enumerate all referenced objects.
InvalidArgumentException
InvalidArgumentException
ObjectReflector
Context: A context containing previously processed arrays and objects when recursively processing a value.
InvalidArgumentException
ResourceOperations
RuntimeException
Parameter
ReflectionMapper
CallableType
FalseType
GenericObjectType
IntersectionType
IterableType
MixedType
NeverType
NullType
ObjectType
SimpleType
StaticType
TrueType
Type
UnionType
UnknownType
VoidType
TypeName
Version
ConfigBuilderGenerator: Generate ConfigBuilders to help create valid config.
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 an 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.
ParamConfigurator: Placeholder for a parameter.
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 or value 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.
TrimmedBufferOutput: A BufferedOutput that keeps only the last N chars.
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.
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.
RuntimeException
Filesystem: Provides basic utility to manipulate the file system.
Path: Contains utility methods for handling path strings.
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.
JsonException
Attribute
PhpToken
UnhandledMatchError
ValueError
CURLStringFile
ReturnTypeWillChange
InvalidArgumentException: InvalidArgumentException for the Process Component.
LogicException: LogicException for the Process Component.
ProcessFailedException: Exception for failed processes.
ProcessSignaledException: Exception that is thrown when a process has been signaled.
ProcessTimedOutException: Exception that is thrown when a process times out.
RuntimeException: RuntimeException for the Process Component.
ExecutableFinder: Generic executable finder.
InputStream: Provides a way to continuously write to the input of a Process until the InputStream is closed.
PhpExecutableFinder: An executable finder specifically designed for the PHP executable.
PhpProcess: PhpProcess runs a PHP script in an independent process.
Process: Process is a thin wrapper around proc_* functions to easily start independent PHP processes.
ProcessUtils: ProcessUtils is a bunch of utility methods.
Required: A required dependency.
SubscribedService: Use with {@see ServiceSubscriberTrait} to mark a method's return type as a subscribed service.
ServiceLocatorTest
ServiceLocatorTestCase
Section: Stopwatch section.
Stopwatch: Stopwatch provides a way to profile code.
StopwatchEvent: Represents an Event managed by Stopwatch.
StopwatchPeriod: Represents an Period for an Event.
LintCommand: Validates YAML files syntax and outputs encountered errors.
Dumper: Dumper dumps PHP variables to YAML strings.
DumpException: Exception class thrown when an error occurs during dumping.
ParseException: Exception class thrown when an error occurs during parsing.
RuntimeException: Exception class thrown when an error occurs during parsing.
Parser: Parser parses YAML strings to convert them to PHP arrays.
TaggedValue
Yaml: Yaml offers convenience methods to load and dump YAML.
Exception
NamespaceUri
NamespaceUriException
Token
TokenCollection
TokenCollectionException
Tokenizer
XMLSerializer
ReadableDuration
BaseTest
GetRoundedUnitTest
DemoTest
GetDaysTest
GetHoursTest
GetInDaysTest
GetInHoursTest
GetInMinutesTest
GetInMonthsTest
GetInMostAppropriateUnitsTestWithPrecisionTwo
GetInMostAppropriateUnitsTestWithSinglePrecision
GetInSecondsTest
GetInYearsTest
GetMinutesTest
GetMonthsTest
GetRoundedDaysTest
GetRoundedHoursTest
GetRoundedMinutesTest
GetRoundedMonthsTest
GetRoundedYearsTest
GetSecondsTest
GetYearsTest

Traits

EventEmitterTrait
ClientTrait: Client interface for sending HTTP requests.
MessageTrait: Trait implementing functionality common to requests and responses.
StreamDecoratorTrait: Stream decorator trait
Listens: Trait \Hoa\Event\Listens.
EmitterAwareTrait
EmitterTrait
GeneratorTrait
TestListenerDefaultImplementation
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.
PaddingTrait
LockableTrait: Basic lock feature for commands.
TesterTrait
ServiceLocatorTrait: A trait to help implement ServiceProviderInterface.
ServiceSubscriberTrait: Implementation of ServiceSubscriberInterface that determines subscribed services from method return types. Service ids are available as "ClassName::methodName".

Constants

AGENT = 'Pawl/0.4'
AGENT = 'RatchetRFC/0.3'
FILTER_VALIDATE_BOOL = \FILTER_VALIDATE_BOOLEAN
HOA = \true
MB_CASE_LOWER = 1
MB_CASE_LOWER = 1
MB_CASE_TITLE = 2
MB_CASE_TITLE = 2
MB_CASE_UPPER = 0
MB_CASE_UPPER = 0
MYSQLI_REFRESH_REPLICA = 64
PUBNUB_LIB_BASE_DIR = __DIR__

Functions

uniqid() : mixed
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() : object|array<string|int, mixed>|string|int|float|bool|null: Wrapper for json_decode that throws when an error occurs.
json_encode() : string: Wrapper for JSON encoding that throws when an error occurs.
xcallable() : mixed
deep_copy() : mixed: Deep copies the given value.
defineCompatibilityTokens() : void
assertArrayHasKey() : void: Asserts that an array has a specified key.
assertArrayNotHasKey() : void: Asserts that an array does not have a specified key.
assertContains() : void: Asserts that a haystack contains a needle.
assertContainsEquals() : void
assertNotContains() : void: Asserts that a haystack does not contain a needle.
assertNotContainsEquals() : void
assertContainsOnly() : void: Asserts that a haystack contains only values of a given type.
assertContainsOnlyInstancesOf() : void: Asserts that a haystack contains only instances of a given class name.
assertNotContainsOnly() : void: Asserts that a haystack does not contain only values of a given type.
assertCount() : void: Asserts the number of elements of an array, Countable or Traversable.
assertNotCount() : void: Asserts the number of elements of an array, Countable or Traversable.
assertEquals() : void: Asserts that two variables are equal.
assertEqualsCanonicalizing() : void: Asserts that two variables are equal (canonicalizing).
assertEqualsIgnoringCase() : void: Asserts that two variables are equal (ignoring case).
assertEqualsWithDelta() : void: Asserts that two variables are equal (with delta).
assertNotEquals() : void: Asserts that two variables are not equal.
assertNotEqualsCanonicalizing() : void: Asserts that two variables are not equal (canonicalizing).
assertNotEqualsIgnoringCase() : void: Asserts that two variables are not equal (ignoring case).
assertNotEqualsWithDelta() : void: Asserts that two variables are not equal (with delta).
assertObjectEquals() : void
assertEmpty() : void: Asserts that a variable is empty.
assertNotEmpty() : void: Asserts that a variable is not empty.
assertGreaterThan() : void: Asserts that a value is greater than another value.
assertGreaterThanOrEqual() : void: Asserts that a value is greater than or equal to another value.
assertLessThan() : void: Asserts that a value is smaller than another value.
assertLessThanOrEqual() : void: Asserts that a value is smaller than or equal to another value.
assertFileEquals() : void: Asserts that the contents of one file is equal to the contents of another file.
assertFileEqualsCanonicalizing() : void: Asserts that the contents of one file is equal to the contents of another file (canonicalizing).
assertFileEqualsIgnoringCase() : void: Asserts that the contents of one file is equal to the contents of another file (ignoring case).
assertFileNotEquals() : void: Asserts that the contents of one file is not equal to the contents of another file.
assertFileNotEqualsCanonicalizing() : void: Asserts that the contents of one file is not equal to the contents of another file (canonicalizing).
assertFileNotEqualsIgnoringCase() : void: Asserts that the contents of one file is not equal to the contents of another file (ignoring case).
assertStringEqualsFile() : void: Asserts that the contents of a string is equal to the contents of a file.
assertStringEqualsFileCanonicalizing() : void: Asserts that the contents of a string is equal to the contents of a file (canonicalizing).
assertStringEqualsFileIgnoringCase() : void: Asserts that the contents of a string is equal to the contents of a file (ignoring case).
assertStringNotEqualsFile() : void: Asserts that the contents of a string is not equal to the contents of a file.
assertStringNotEqualsFileCanonicalizing() : void: Asserts that the contents of a string is not equal to the contents of a file (canonicalizing).
assertStringNotEqualsFileIgnoringCase() : void: Asserts that the contents of a string is not equal to the contents of a file (ignoring case).
assertIsReadable() : void: Asserts that a file/dir is readable.
assertIsNotReadable() : void: Asserts that a file/dir exists and is not readable.
assertNotIsReadable() : void: Asserts that a file/dir exists and is not readable.
assertIsWritable() : void: Asserts that a file/dir exists and is writable.
assertIsNotWritable() : void: Asserts that a file/dir exists and is not writable.
assertNotIsWritable() : void: Asserts that a file/dir exists and is not writable.
assertDirectoryExists() : void: Asserts that a directory exists.
assertDirectoryDoesNotExist() : void: Asserts that a directory does not exist.
assertDirectoryNotExists() : void: Asserts that a directory does not exist.
assertDirectoryIsReadable() : void: Asserts that a directory exists and is readable.
assertDirectoryIsNotReadable() : void: Asserts that a directory exists and is not readable.
assertDirectoryNotIsReadable() : void: Asserts that a directory exists and is not readable.
assertDirectoryIsWritable() : void: Asserts that a directory exists and is writable.
assertDirectoryIsNotWritable() : void: Asserts that a directory exists and is not writable.
assertDirectoryNotIsWritable() : void: Asserts that a directory exists and is not writable.
assertFileExists() : void: Asserts that a file exists.
assertFileDoesNotExist() : void: Asserts that a file does not exist.
assertFileNotExists() : void: Asserts that a file does not exist.
assertFileIsReadable() : void: Asserts that a file exists and is readable.
assertFileIsNotReadable() : void: Asserts that a file exists and is not readable.
assertFileNotIsReadable() : void: Asserts that a file exists and is not readable.
assertFileIsWritable() : void: Asserts that a file exists and is writable.
assertFileIsNotWritable() : void: Asserts that a file exists and is not writable.
assertFileNotIsWritable() : void: Asserts that a file exists and is not writable.
assertTrue() : void: Asserts that a condition is true.
assertNotTrue() : void: Asserts that a condition is not true.
assertFalse() : void: Asserts that a condition is false.
assertNotFalse() : void: Asserts that a condition is not false.
assertNull() : void: Asserts that a variable is null.
assertNotNull() : void: Asserts that a variable is not null.
assertFinite() : void: Asserts that a variable is finite.
assertInfinite() : void: Asserts that a variable is infinite.
assertNan() : void: Asserts that a variable is nan.
assertClassHasAttribute() : void: Asserts that a class has a specified attribute.
assertClassNotHasAttribute() : void: Asserts that a class does not have a specified attribute.
assertClassHasStaticAttribute() : void: Asserts that a class has a specified static attribute.
assertClassNotHasStaticAttribute() : void: Asserts that a class does not have a specified static attribute.
assertObjectHasAttribute() : void: Asserts that an object has a specified attribute.
assertObjectNotHasAttribute() : void: Asserts that an object does not have a specified attribute.
assertObjectHasProperty() : void: Asserts that an object has a specified property.
assertObjectNotHasProperty() : void: Asserts that an object does not have a specified property.
assertSame() : void: Asserts that two variables have the same type and value.
assertNotSame() : void: Asserts that two variables do not have the same type and value.
assertInstanceOf() : void: Asserts that a variable is of a given type.
assertNotInstanceOf() : void: Asserts that a variable is not of a given type.
assertIsArray() : void: Asserts that a variable is of type array.
assertIsBool() : void: Asserts that a variable is of type bool.
assertIsFloat() : void: Asserts that a variable is of type float.
assertIsInt() : void: Asserts that a variable is of type int.
assertIsNumeric() : void: Asserts that a variable is of type numeric.
assertIsObject() : void: Asserts that a variable is of type object.
assertIsResource() : void: Asserts that a variable is of type resource.
assertIsClosedResource() : void: Asserts that a variable is of type resource and is closed.
assertIsString() : void: Asserts that a variable is of type string.
assertIsScalar() : void: Asserts that a variable is of type scalar.
assertIsCallable() : void: Asserts that a variable is of type callable.
assertIsIterable() : void: Asserts that a variable is of type iterable.
assertIsNotArray() : void: Asserts that a variable is not of type array.
assertIsNotBool() : void: Asserts that a variable is not of type bool.
assertIsNotFloat() : void: Asserts that a variable is not of type float.
assertIsNotInt() : void: Asserts that a variable is not of type int.
assertIsNotNumeric() : void: Asserts that a variable is not of type numeric.
assertIsNotObject() : void: Asserts that a variable is not of type object.
assertIsNotResource() : void: Asserts that a variable is not of type resource.
assertIsNotClosedResource() : void: Asserts that a variable is not of type resource.
assertIsNotString() : void: Asserts that a variable is not of type string.
assertIsNotScalar() : void: Asserts that a variable is not of type scalar.
assertIsNotCallable() : void: Asserts that a variable is not of type callable.
assertIsNotIterable() : void: Asserts that a variable is not of type iterable.
assertMatchesRegularExpression() : void: Asserts that a string matches a given regular expression.
assertRegExp() : void: Asserts that a string matches a given regular expression.
assertDoesNotMatchRegularExpression() : void: Asserts that a string does not match a given regular expression.
assertNotRegExp() : void: Asserts that a string does not match a given regular expression.
assertSameSize() : void: Assert that the size of two arrays (or `Countable` or `Traversable` objects) is the same.
assertNotSameSize() : void: Assert that the size of two arrays (or `Countable` or `Traversable` objects) is not the same.
assertStringMatchesFormat() : void: Asserts that a string matches a given format string.
assertStringNotMatchesFormat() : void: Asserts that a string does not match a given format string.
assertStringMatchesFormatFile() : void: Asserts that a string matches a given format file.
assertStringNotMatchesFormatFile() : void: Asserts that a string does not match a given format string.
assertStringStartsWith() : void: Asserts that a string starts with a given prefix.
assertStringStartsNotWith() : void: Asserts that a string starts not with a given prefix.
assertStringContainsString() : void
assertStringContainsStringIgnoringCase() : void
assertStringNotContainsString() : void
assertStringNotContainsStringIgnoringCase() : void
assertStringEndsWith() : void: Asserts that a string ends with a given suffix.
assertStringEndsNotWith() : void: Asserts that a string ends not with a given suffix.
assertXmlFileEqualsXmlFile() : void: Asserts that two XML files are equal.
assertXmlFileNotEqualsXmlFile() : void: Asserts that two XML files are not equal.
assertXmlStringEqualsXmlFile() : void: Asserts that two XML documents are equal.
assertXmlStringNotEqualsXmlFile() : void: Asserts that two XML documents are not equal.
assertXmlStringEqualsXmlString() : void: Asserts that two XML documents are equal.
assertXmlStringNotEqualsXmlString() : void: Asserts that two XML documents are not equal.
assertEqualXMLStructure() : void: Asserts that a hierarchy of DOMElements matches.
assertThat() : void: Evaluates a PHPUnit\Framework\Constraint matcher object.
assertJson() : void: Asserts that a string is a valid JSON string.
assertJsonStringEqualsJsonString() : void: Asserts that two given JSON encoded objects or arrays are equal.
assertJsonStringNotEqualsJsonString() : void: Asserts that two given JSON encoded objects or arrays are not equal.
assertJsonStringEqualsJsonFile() : void: Asserts that the generated JSON encoded object and the content of the given file are equal.
assertJsonStringNotEqualsJsonFile() : void: Asserts that the generated JSON encoded object and the content of the given file are not equal.
assertJsonFileEqualsJsonFile() : void: Asserts that two JSON files are equal.
assertJsonFileNotEqualsJsonFile() : void: Asserts that two JSON files are not equal.
logicalAnd() : LogicalAnd
logicalOr() : LogicalOr
logicalNot() : LogicalNot
logicalXor() : LogicalXor
anything() : IsAnything
isTrue() : IsTrue
callback() : Callback
isFalse() : IsFalse
isJson() : IsJson
isNull() : IsNull
isFinite() : IsFinite
isInfinite() : IsInfinite
isNan() : IsNan
containsEqual() : TraversableContainsEqual
containsIdentical() : TraversableContainsIdentical
containsOnly() : TraversableContainsOnly
containsOnlyInstancesOf() : TraversableContainsOnly
arrayHasKey() : ArrayHasKey
equalTo() : IsEqual
equalToCanonicalizing() : IsEqualCanonicalizing
equalToIgnoringCase() : IsEqualIgnoringCase
equalToWithDelta() : IsEqualWithDelta
isEmpty() : IsEmpty
isWritable() : IsWritable
isReadable() : IsReadable
directoryExists() : DirectoryExists
fileExists() : FileExists
greaterThan() : GreaterThan
greaterThanOrEqual() : LogicalOr
classHasAttribute() : ClassHasAttribute
classHasStaticAttribute() : ClassHasStaticAttribute
objectHasAttribute() : ObjectHasAttribute
identicalTo() : IsIdentical
isInstanceOf() : IsInstanceOf
isType() : IsType
lessThan() : LessThan
lessThanOrEqual() : LogicalOr
matchesRegularExpression() : RegularExpression
matches() : StringMatchesFormatDescription
stringStartsWith() : StringStartsWith
stringContains() : StringContains
stringEndsWith() : StringEndsWith
countOf() : Count
objectEquals() : ObjectEquals
any() : AnyInvokedCount: Returns a matcher that matches when the method is executed zero or more times.
never() : InvokedCount: Returns a matcher that matches when the method is never executed.
atLeast() : InvokedAtLeastCount: Returns a matcher that matches when the method is executed at least N times.
atLeastOnce() : InvokedAtLeastOnce: Returns a matcher that matches when the method is executed at least once.
once() : InvokedCount: Returns a matcher that matches when the method is executed exactly once.
exactly() : InvokedCount: Returns a matcher that matches when the method is executed exactly $count times.
atMost() : InvokedAtMostCount: Returns a matcher that matches when the method is executed at most N times.
at() : InvokedAtIndex: Returns a matcher that matches when the method is executed at the given index.
returnValue() : ReturnStub
returnValueMap() : ReturnValueMap
returnArgument() : ReturnArgument
returnCallback() : ReturnCallback
returnSelf() : ReturnSelf: Returns the current object.
throwException() : Exception
onConsecutiveCalls() : ConsecutiveCalls
pubnubAutoloader() : mixed
getallheaders() : mixed: Get all HTTP header key/values as an associative array for the current request.
connect() : PromiseInterface<string|int, WebSocket>
echoStreamerFactory() : mixed
getTestCases() : mixed
runTest() : mixed
createReport() : mixed
await() : T: Block waiting for the given `$promise` to be fulfilled.
delay() : void: Delay program execution for duration given in `$seconds`.
coroutine() : PromiseInterface<string|int, T>: Execute a Generator-based coroutine to "await" promises.
parallel() : PromiseInterface<string|int, array<string|int, T>>
series() : PromiseInterface<string|int, array<string|int, T>>
waterfall() : PromiseInterface<string|int, mixed>
resolve() : PromiseInterface<string|int, T>: Creates a promise for the supplied `$promiseOrValue`.
reject() : PromiseInterface<string|int, never>: Creates a rejected promise for the supplied `$reason`.
all() : PromiseInterface<string|int, array<string|int, T>>: Returns a promise that will resolve only once all the items in `$promisesOrValues` have resolved. The resolution value of the returned promise will be an array containing the resolution values of each of the items in `$promisesOrValues`.
race() : PromiseInterface<string|int, T>: Initiates a competitive race that allows one winner. Returns a promise which is resolved in the same way the first settled promise resolves.
any() : PromiseInterface<string|int, T>: Returns a promise that will resolve when any one of the items in `$promisesOrValues` resolves. The resolution value of the returned promise will be the resolution value of the triggering item.
set_rejection_handler() : callable(Throwable): void|null: Sets the global rejection handler for unhandled promise rejections.
trigger_deprecation() : void: Triggers a silenced deprecation notice.
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
ctype_alnum() : bool
ctype_alpha() : bool
ctype_cntrl() : bool
ctype_digit() : bool
ctype_graph() : bool
ctype_lower() : bool
ctype_print() : bool
ctype_punct() : bool
ctype_space() : bool
ctype_upper() : bool
ctype_xdigit() : bool
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
mb_str_pad() : string
mb_convert_encoding() : array<string|int, mixed>|string|false
mb_decode_mimeheader() : string
mb_encode_mimeheader() : string
mb_decode_numericentity() : string
mb_encode_numericentity() : string
mb_convert_case() : string
mb_internal_encoding() : string|bool
mb_language() : string|bool
mb_list_encodings() : array<string|int, mixed>
mb_encoding_aliases() : array<string|int, mixed>
mb_check_encoding() : bool
mb_detect_encoding() : string|false
mb_detect_order() : array<string|int, mixed>|bool
mb_parse_str() : bool
mb_strlen() : int
mb_strpos() : int|false
mb_strtolower() : string
mb_strtoupper() : string
mb_substitute_character() : string|int|bool
mb_substr() : string
mb_stripos() : int|false
mb_stristr() : string|false
mb_strrchr() : string|false
mb_strrichr() : string|false
mb_strripos() : int|false
mb_strrpos() : int|false
mb_strstr() : string|false
mb_get_info() : array<string|int, mixed>|string|int|false
mb_http_output() : string|bool
mb_strwidth() : int
mb_substr_count() : int
mb_output_handler() : string
mb_http_input() : array<string|int, mixed>|string|false
mb_convert_variables() : string|false
mb_ord() : int|false
mb_chr() : string|false
mb_scrub() : string
mb_str_split() : array<string|int, mixed>
mb_str_pad() : string
is_countable() : mixed
hrtime() : mixed
array_key_first() : mixed
array_key_last() : mixed
fdiv() : float
preg_last_error_msg() : string
str_contains() : bool
str_starts_with() : bool
str_ends_with() : bool
get_debug_type() : string
get_resource_id() : int
array_is_list() : bool
enum_exists() : bool
autoload() : mixed

AGENT


    public
        mixed
    AGENT
    = 'Pawl/0.4'

AGENT


    public
        mixed
    AGENT
    = 'RatchetRFC/0.3'

FILTER_VALIDATE_BOOL


    public
        mixed
    FILTER_VALIDATE_BOOL
    = \FILTER_VALIDATE_BOOLEAN

HOA


    public
        mixed
    HOA
    = \true

MB_CASE_LOWER


    public
        mixed
    MB_CASE_LOWER
    = 1

MB_CASE_LOWER


    public
        mixed
    MB_CASE_LOWER
    = 1

MB_CASE_TITLE


    public
        mixed
    MB_CASE_TITLE
    = 2

MB_CASE_TITLE


    public
        mixed
    MB_CASE_TITLE
    = 2

MB_CASE_UPPER


    public
        mixed
    MB_CASE_UPPER
    = 0

MB_CASE_UPPER


    public
        mixed
    MB_CASE_UPPER
    = 0

MYSQLI_REFRESH_REPLICA


    public
        mixed
    MYSQLI_REFRESH_REPLICA
    = 64

PUBNUB_LIB_BASE_DIR


    public
        mixed
    PUBNUB_LIB_BASE_DIR
    = __DIR__

uniqid()


    
                    uniqid() : mixed

describe_type()

Debug function used to describe the provided value type and class.


    
                    describe_type(mixed $input) : string

Parameters

$input : mixed: Any type of variable to describe the type of. This parameter misses a typehint because of that.

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(iterable<string|int, mixed> $lines) : array<string|int, mixed>

Parameters

$lines : iterable<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.

Return values

callable —

\GuzzleHttp\Promise\PromiseInterface 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.

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, string> $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, string>: 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 = 0 ]) : object|array<string|int, mixed>|string|int|float|bool|null

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 = 0: Bitmask of JSON decode options.

Return values

json_encode()

Wrapper for JSON encoding that throws when an error occurs.


    
                    json_encode(mixed $value[, int $options = 0 ][, int $depth = 512 ]) : string

Parameters

$value : mixed: The value being encoded
$options : int = 0: JSON encode option bitmask
$depth : int = 512: Set the maximum depth. Must be greater than zero.

Return values

string

xcallable()


    
                    xcallable(mixed $call[, mixed $able = '' ]) : mixed

Parameters

$call : mixed
$able : mixed = ''

deep_copy()

Deep copies the given value.


    
                    deep_copy(mixed $value[, bool $useCloneMethod = false ]) : mixed

Parameters

$value : mixed
$useCloneMethod : bool = false

defineCompatibilityTokens()


    
                    defineCompatibilityTokens() : void

assertArrayHasKey()

Asserts that an array has a specified key.


    
                    assertArrayHasKey(int|string $key, array<string|int, mixed>|ArrayAccess $array[, string $message = '' ]) : void

Parameters

$key : int|string
$array : array<string|int, mixed>|ArrayAccess
$message : string = ''

assertArrayNotHasKey()

Asserts that an array does not have a specified key.


    
                    assertArrayNotHasKey(int|string $key, array<string|int, mixed>|ArrayAccess $array[, string $message = '' ]) : void

Parameters

$key : int|string
$array : array<string|int, mixed>|ArrayAccess
$message : string = ''

assertContains()

Asserts that a haystack contains a needle.


    
                    assertContains(mixed $needle, iterable<string|int, mixed> $haystack[, string $message = '' ]) : void

Parameters

$needle : mixed
$haystack : iterable<string|int, mixed>
$message : string = ''

assertContainsEquals()


    
                    assertContainsEquals(mixed $needle, iterable<string|int, mixed> $haystack[, string $message = '' ]) : void

Parameters

$needle : mixed
$haystack : iterable<string|int, mixed>
$message : string = ''

assertNotContains()

Asserts that a haystack does not contain a needle.


    
                    assertNotContains(mixed $needle, iterable<string|int, mixed> $haystack[, string $message = '' ]) : void

Parameters

$needle : mixed
$haystack : iterable<string|int, mixed>
$message : string = ''

assertNotContainsEquals()


    
                    assertNotContainsEquals(mixed $needle, iterable<string|int, mixed> $haystack[, string $message = '' ]) : void

Parameters

$needle : mixed
$haystack : iterable<string|int, mixed>
$message : string = ''

assertContainsOnly()

Asserts that a haystack contains only values of a given type.


    
                    assertContainsOnly(string $type, iterable<string|int, mixed> $haystack[, bool|null $isNativeType = null ][, string $message = '' ]) : void

Parameters

$type : string
$haystack : iterable<string|int, mixed>
$isNativeType : bool|null = null
$message : string = ''

assertContainsOnlyInstancesOf()

Asserts that a haystack contains only instances of a given class name.


    
                    assertContainsOnlyInstancesOf(string $className, iterable<string|int, mixed> $haystack[, string $message = '' ]) : void

Parameters

$className : string
$haystack : iterable<string|int, mixed>
$message : string = ''

assertNotContainsOnly()

Asserts that a haystack does not contain only values of a given type.


    
                    assertNotContainsOnly(string $type, iterable<string|int, mixed> $haystack[, bool|null $isNativeType = null ][, string $message = '' ]) : void

Parameters

$type : string
$haystack : iterable<string|int, mixed>
$isNativeType : bool|null = null
$message : string = ''

assertCount()

Asserts the number of elements of an array, Countable or Traversable.


    
                    assertCount(int $expectedCount, Countable|iterable<string|int, mixed> $haystack[, string $message = '' ]) : void

Parameters

$expectedCount : int
$haystack : Countable|iterable<string|int, mixed>
$message : string = ''

assertNotCount()

Asserts the number of elements of an array, Countable or Traversable.


    
                    assertNotCount(int $expectedCount, Countable|iterable<string|int, mixed> $haystack[, string $message = '' ]) : void

Parameters

$expectedCount : int
$haystack : Countable|iterable<string|int, mixed>
$message : string = ''

assertEquals()

Asserts that two variables are equal.


    
                    assertEquals(mixed $expected, mixed $actual[, string $message = '' ]) : void

Parameters

$expected : mixed
$actual : mixed
$message : string = ''

assertEqualsCanonicalizing()

Asserts that two variables are equal (canonicalizing).


    
                    assertEqualsCanonicalizing(mixed $expected, mixed $actual[, string $message = '' ]) : void

Parameters

$expected : mixed
$actual : mixed
$message : string = ''

assertEqualsIgnoringCase()

Asserts that two variables are equal (ignoring case).


    
                    assertEqualsIgnoringCase(mixed $expected, mixed $actual[, string $message = '' ]) : void

Parameters

$expected : mixed
$actual : mixed
$message : string = ''

assertEqualsWithDelta()

Asserts that two variables are equal (with delta).


    
                    assertEqualsWithDelta(mixed $expected, mixed $actual, float $delta[, string $message = '' ]) : void

Parameters

$expected : mixed
$actual : mixed
$delta : float
$message : string = ''

assertNotEquals()

Asserts that two variables are not equal.


    
                    assertNotEquals(mixed $expected, mixed $actual[, string $message = '' ]) : void

Parameters

$expected : mixed
$actual : mixed
$message : string = ''

assertNotEqualsCanonicalizing()

Asserts that two variables are not equal (canonicalizing).


    
                    assertNotEqualsCanonicalizing(mixed $expected, mixed $actual[, string $message = '' ]) : void

Parameters

$expected : mixed
$actual : mixed
$message : string = ''

assertNotEqualsIgnoringCase()

Asserts that two variables are not equal (ignoring case).


    
                    assertNotEqualsIgnoringCase(mixed $expected, mixed $actual[, string $message = '' ]) : void

Parameters

$expected : mixed
$actual : mixed
$message : string = ''

assertNotEqualsWithDelta()

Asserts that two variables are not equal (with delta).


    
                    assertNotEqualsWithDelta(mixed $expected, mixed $actual, float $delta[, string $message = '' ]) : void

Parameters

$expected : mixed
$actual : mixed
$delta : float
$message : string = ''

assertObjectEquals()


    
                    assertObjectEquals(object $expected, object $actual[, string $method = 'equals' ][, string $message = '' ]) : void

Parameters

$expected : object
$actual : object
$method : string = 'equals'
$message : string = ''

assertEmpty()

Asserts that a variable is empty.


    
                    assertEmpty(mixed $actual[, string $message = '' ]) : void

Parameters

$actual : mixed
$message : string = ''

assertNotEmpty()

Asserts that a variable is not empty.


    
                    assertNotEmpty(mixed $actual[, string $message = '' ]) : void

Parameters

$actual : mixed
$message : string = ''

assertGreaterThan()

Asserts that a value is greater than another value.


    
                    assertGreaterThan(mixed $expected, mixed $actual[, string $message = '' ]) : void

Parameters

$expected : mixed
$actual : mixed
$message : string = ''

assertGreaterThanOrEqual()

Asserts that a value is greater than or equal to another value.


    
                    assertGreaterThanOrEqual(mixed $expected, mixed $actual[, string $message = '' ]) : void

Parameters

$expected : mixed
$actual : mixed
$message : string = ''

assertLessThan()

Asserts that a value is smaller than another value.


    
                    assertLessThan(mixed $expected, mixed $actual[, string $message = '' ]) : void

Parameters

$expected : mixed
$actual : mixed
$message : string = ''

assertLessThanOrEqual()

Asserts that a value is smaller than or equal to another value.


    
                    assertLessThanOrEqual(mixed $expected, mixed $actual[, string $message = '' ]) : void

Parameters

$expected : mixed
$actual : mixed
$message : string = ''

assertFileEquals()

Asserts that the contents of one file is equal to the contents of another file.


    
                    assertFileEquals(string $expected, string $actual[, string $message = '' ]) : void

Parameters

$expected : string
$actual : string
$message : string = ''

assertFileEqualsCanonicalizing()

Asserts that the contents of one file is equal to the contents of another file (canonicalizing).


    
                    assertFileEqualsCanonicalizing(string $expected, string $actual[, string $message = '' ]) : void

Parameters

$expected : string
$actual : string
$message : string = ''

assertFileEqualsIgnoringCase()

Asserts that the contents of one file is equal to the contents of another file (ignoring case).


    
                    assertFileEqualsIgnoringCase(string $expected, string $actual[, string $message = '' ]) : void

Parameters

$expected : string
$actual : string
$message : string = ''

assertFileNotEquals()

Asserts that the contents of one file is not equal to the contents of another file.


    
                    assertFileNotEquals(string $expected, string $actual[, string $message = '' ]) : void

Parameters

$expected : string
$actual : string
$message : string = ''

assertFileNotEqualsCanonicalizing()

Asserts that the contents of one file is not equal to the contents of another file (canonicalizing).


    
                    assertFileNotEqualsCanonicalizing(string $expected, string $actual[, string $message = '' ]) : void

Parameters

$expected : string
$actual : string
$message : string = ''

assertFileNotEqualsIgnoringCase()

Asserts that the contents of one file is not equal to the contents of another file (ignoring case).


    
                    assertFileNotEqualsIgnoringCase(string $expected, string $actual[, string $message = '' ]) : void

Parameters

$expected : string
$actual : string
$message : string = ''

assertStringEqualsFile()

Asserts that the contents of a string is equal to the contents of a file.


    
                    assertStringEqualsFile(string $expectedFile, string $actualString[, string $message = '' ]) : void

Parameters

$expectedFile : string
$actualString : string
$message : string = ''

assertStringEqualsFileCanonicalizing()

Asserts that the contents of a string is equal to the contents of a file (canonicalizing).


    
                    assertStringEqualsFileCanonicalizing(string $expectedFile, string $actualString[, string $message = '' ]) : void

Parameters

$expectedFile : string
$actualString : string
$message : string = ''

assertStringEqualsFileIgnoringCase()

Asserts that the contents of a string is equal to the contents of a file (ignoring case).


    
                    assertStringEqualsFileIgnoringCase(string $expectedFile, string $actualString[, string $message = '' ]) : void

Parameters

$expectedFile : string
$actualString : string
$message : string = ''

assertStringNotEqualsFile()

Asserts that the contents of a string is not equal to the contents of a file.


    
                    assertStringNotEqualsFile(string $expectedFile, string $actualString[, string $message = '' ]) : void

Parameters

$expectedFile : string
$actualString : string
$message : string = ''

assertStringNotEqualsFileCanonicalizing()

Asserts that the contents of a string is not equal to the contents of a file (canonicalizing).


    
                    assertStringNotEqualsFileCanonicalizing(string $expectedFile, string $actualString[, string $message = '' ]) : void

Parameters

$expectedFile : string
$actualString : string
$message : string = ''

assertStringNotEqualsFileIgnoringCase()

Asserts that the contents of a string is not equal to the contents of a file (ignoring case).


    
                    assertStringNotEqualsFileIgnoringCase(string $expectedFile, string $actualString[, string $message = '' ]) : void

Parameters

$expectedFile : string
$actualString : string
$message : string = ''

assertIsReadable()

Asserts that a file/dir is readable.


    
                    assertIsReadable(string $filename[, string $message = '' ]) : void

Parameters

$filename : string
$message : string = ''

assertIsNotReadable()

Asserts that a file/dir exists and is not readable.


    
                    assertIsNotReadable(string $filename[, string $message = '' ]) : void

Parameters

$filename : string
$message : string = ''

assertNotIsReadable()

Asserts that a file/dir exists and is not readable.


    
                    assertNotIsReadable(string $filename[, string $message = '' ]) : void

Parameters

$filename : string
$message : string = ''

assertIsWritable()

Asserts that a file/dir exists and is writable.


    
                    assertIsWritable(string $filename[, string $message = '' ]) : void

Parameters

$filename : string
$message : string = ''

assertIsNotWritable()

Asserts that a file/dir exists and is not writable.


    
                    assertIsNotWritable(string $filename[, string $message = '' ]) : void

Parameters

$filename : string
$message : string = ''

assertNotIsWritable()

Asserts that a file/dir exists and is not writable.


    
                    assertNotIsWritable(string $filename[, string $message = '' ]) : void

Parameters

$filename : string
$message : string = ''

assertDirectoryExists()

Asserts that a directory exists.


    
                    assertDirectoryExists(string $directory[, string $message = '' ]) : void

Parameters

$directory : string
$message : string = ''

assertDirectoryDoesNotExist()

Asserts that a directory does not exist.


    
                    assertDirectoryDoesNotExist(string $directory[, string $message = '' ]) : void

Parameters

$directory : string
$message : string = ''

assertDirectoryNotExists()

Asserts that a directory does not exist.


    
                    assertDirectoryNotExists(string $directory[, string $message = '' ]) : void

Parameters

$directory : string
$message : string = ''

assertDirectoryIsReadable()

Asserts that a directory exists and is readable.


    
                    assertDirectoryIsReadable(string $directory[, string $message = '' ]) : void

Parameters

$directory : string
$message : string = ''

assertDirectoryIsNotReadable()

Asserts that a directory exists and is not readable.


    
                    assertDirectoryIsNotReadable(string $directory[, string $message = '' ]) : void

Parameters

$directory : string
$message : string = ''

assertDirectoryNotIsReadable()

Asserts that a directory exists and is not readable.


    
                    assertDirectoryNotIsReadable(string $directory[, string $message = '' ]) : void

Parameters

$directory : string
$message : string = ''

assertDirectoryIsWritable()

Asserts that a directory exists and is writable.


    
                    assertDirectoryIsWritable(string $directory[, string $message = '' ]) : void

Parameters

$directory : string
$message : string = ''

assertDirectoryIsNotWritable()

Asserts that a directory exists and is not writable.


    
                    assertDirectoryIsNotWritable(string $directory[, string $message = '' ]) : void

Parameters

$directory : string
$message : string = ''

assertDirectoryNotIsWritable()

Asserts that a directory exists and is not writable.


    
                    assertDirectoryNotIsWritable(string $directory[, string $message = '' ]) : void

Parameters

$directory : string
$message : string = ''

assertFileExists()

Asserts that a file exists.


    
                    assertFileExists(string $filename[, string $message = '' ]) : void

Parameters

$filename : string
$message : string = ''

assertFileDoesNotExist()

Asserts that a file does not exist.


    
                    assertFileDoesNotExist(string $filename[, string $message = '' ]) : void

Parameters

$filename : string
$message : string = ''

assertFileNotExists()

Asserts that a file does not exist.


    
                    assertFileNotExists(string $filename[, string $message = '' ]) : void

Parameters

$filename : string
$message : string = ''

assertFileIsReadable()

Asserts that a file exists and is readable.


    
                    assertFileIsReadable(string $file[, string $message = '' ]) : void

Parameters

$file : string
$message : string = ''

assertFileIsNotReadable()

Asserts that a file exists and is not readable.


    
                    assertFileIsNotReadable(string $file[, string $message = '' ]) : void

Parameters

$file : string
$message : string = ''

assertFileNotIsReadable()

Asserts that a file exists and is not readable.


    
                    assertFileNotIsReadable(string $file[, string $message = '' ]) : void

Parameters

$file : string
$message : string = ''

assertFileIsWritable()

Asserts that a file exists and is writable.


    
                    assertFileIsWritable(string $file[, string $message = '' ]) : void

Parameters

$file : string
$message : string = ''

assertFileIsNotWritable()

Asserts that a file exists and is not writable.


    
                    assertFileIsNotWritable(string $file[, string $message = '' ]) : void

Parameters

$file : string
$message : string = ''

assertFileNotIsWritable()

Asserts that a file exists and is not writable.


    
                    assertFileNotIsWritable(string $file[, string $message = '' ]) : void

Parameters

$file : string
$message : string = ''

assertTrue()

Asserts that a condition is true.


    
                    assertTrue(mixed $condition[, string $message = '' ]) : void

Parameters

$condition : mixed
$message : string = ''

assertNotTrue()

Asserts that a condition is not true.


    
                    assertNotTrue(mixed $condition[, string $message = '' ]) : void

Parameters

$condition : mixed
$message : string = ''

assertFalse()

Asserts that a condition is false.


    
                    assertFalse(mixed $condition[, string $message = '' ]) : void

Parameters

$condition : mixed
$message : string = ''

assertNotFalse()

Asserts that a condition is not false.


    
                    assertNotFalse(mixed $condition[, string $message = '' ]) : void

Parameters

$condition : mixed
$message : string = ''

assertNull()

Asserts that a variable is null.


    
                    assertNull(mixed $actual[, string $message = '' ]) : void

Parameters

$actual : mixed
$message : string = ''

assertNotNull()

Asserts that a variable is not null.


    
                    assertNotNull(mixed $actual[, string $message = '' ]) : void

Parameters

$actual : mixed
$message : string = ''

assertFinite()

Asserts that a variable is finite.


    
                    assertFinite(mixed $actual[, string $message = '' ]) : void

Parameters

$actual : mixed
$message : string = ''

assertInfinite()

Asserts that a variable is infinite.


    
                    assertInfinite(mixed $actual[, string $message = '' ]) : void

Parameters

$actual : mixed
$message : string = ''

assertNan()

Asserts that a variable is nan.


    
                    assertNan(mixed $actual[, string $message = '' ]) : void

Parameters

$actual : mixed
$message : string = ''

assertClassHasAttribute()

Asserts that a class has a specified attribute.


    
                    assertClassHasAttribute(string $attributeName, string $className[, string $message = '' ]) : void

Parameters

$attributeName : string
$className : string
$message : string = ''

assertClassNotHasAttribute()

Asserts that a class does not have a specified attribute.


    
                    assertClassNotHasAttribute(string $attributeName, string $className[, string $message = '' ]) : void

Parameters

$attributeName : string
$className : string
$message : string = ''

assertClassHasStaticAttribute()

Asserts that a class has a specified static attribute.


    
                    assertClassHasStaticAttribute(string $attributeName, string $className[, string $message = '' ]) : void

Parameters

$attributeName : string
$className : string
$message : string = ''

assertClassNotHasStaticAttribute()

Asserts that a class does not have a specified static attribute.


    
                    assertClassNotHasStaticAttribute(string $attributeName, string $className[, string $message = '' ]) : void

Parameters

$attributeName : string
$className : string
$message : string = ''

assertObjectHasAttribute()

Asserts that an object has a specified attribute.


    
                    assertObjectHasAttribute(string $attributeName, object $object[, string $message = '' ]) : void

Parameters

$attributeName : string
$object : object
$message : string = ''

assertObjectNotHasAttribute()

Asserts that an object does not have a specified attribute.


    
                    assertObjectNotHasAttribute(string $attributeName, object $object[, string $message = '' ]) : void

Parameters

$attributeName : string
$object : object
$message : string = ''

assertObjectHasProperty()

Asserts that an object has a specified property.


    
                    assertObjectHasProperty(string $attributeName, object $object[, string $message = '' ]) : void

Parameters

$attributeName : string
$object : object
$message : string = ''

assertObjectNotHasProperty()

Asserts that an object does not have a specified property.


    
                    assertObjectNotHasProperty(string $attributeName, object $object[, string $message = '' ]) : void

Parameters

$attributeName : string
$object : object
$message : string = ''

assertSame()

Asserts that two variables have the same type and value.


    
                    assertSame(mixed $expected, mixed $actual[, string $message = '' ]) : void

Used on objects, it asserts that two variables reference the same object.

Parameters

$expected : mixed
$actual : mixed
$message : string = ''

assertNotSame()

Asserts that two variables do not have the same type and value.


    
                    assertNotSame(mixed $expected, mixed $actual[, string $message = '' ]) : void

Used on objects, it asserts that two variables do not reference the same object.

Parameters

$expected : mixed
$actual : mixed
$message : string = ''

assertInstanceOf()

Asserts that a variable is of a given type.


    
                    assertInstanceOf(string $expected, mixed $actual[, string $message = '' ]) : void

Parameters

$expected : string
$actual : mixed
$message : string = ''

assertNotInstanceOf()

Asserts that a variable is not of a given type.


    
                    assertNotInstanceOf(string $expected, mixed $actual[, string $message = '' ]) : void

Parameters

$expected : string
$actual : mixed
$message : string = ''

assertIsArray()

Asserts that a variable is of type array.


    
                    assertIsArray(mixed $actual[, string $message = '' ]) : void

Parameters

$actual : mixed
$message : string = ''

assertIsBool()

Asserts that a variable is of type bool.


    
                    assertIsBool(mixed $actual[, string $message = '' ]) : void

Parameters

$actual : mixed
$message : string = ''

assertIsFloat()

Asserts that a variable is of type float.


    
                    assertIsFloat(mixed $actual[, string $message = '' ]) : void

Parameters

$actual : mixed
$message : string = ''

assertIsInt()

Asserts that a variable is of type int.


    
                    assertIsInt(mixed $actual[, string $message = '' ]) : void

Parameters

$actual : mixed
$message : string = ''

assertIsNumeric()

Asserts that a variable is of type numeric.


    
                    assertIsNumeric(mixed $actual[, string $message = '' ]) : void

Parameters

$actual : mixed
$message : string = ''

assertIsObject()

Asserts that a variable is of type object.


    
                    assertIsObject(mixed $actual[, string $message = '' ]) : void

Parameters

$actual : mixed
$message : string = ''

assertIsResource()

Asserts that a variable is of type resource.


    
                    assertIsResource(mixed $actual[, string $message = '' ]) : void

Parameters

$actual : mixed
$message : string = ''

assertIsClosedResource()

Asserts that a variable is of type resource and is closed.


    
                    assertIsClosedResource(mixed $actual[, string $message = '' ]) : void

Parameters

$actual : mixed
$message : string = ''

assertIsString()

Asserts that a variable is of type string.


    
                    assertIsString(mixed $actual[, string $message = '' ]) : void

Parameters

$actual : mixed
$message : string = ''

assertIsScalar()

Asserts that a variable is of type scalar.


    
                    assertIsScalar(mixed $actual[, string $message = '' ]) : void

Parameters

$actual : mixed
$message : string = ''

assertIsCallable()

Asserts that a variable is of type callable.


    
                    assertIsCallable(mixed $actual[, string $message = '' ]) : void

Parameters

$actual : mixed
$message : string = ''

assertIsIterable()

Asserts that a variable is of type iterable.


    
                    assertIsIterable(mixed $actual[, string $message = '' ]) : void

Parameters

$actual : mixed
$message : string = ''

assertIsNotArray()

Asserts that a variable is not of type array.


    
                    assertIsNotArray(mixed $actual[, string $message = '' ]) : void

Parameters

$actual : mixed
$message : string = ''

assertIsNotBool()

Asserts that a variable is not of type bool.


    
                    assertIsNotBool(mixed $actual[, string $message = '' ]) : void

Parameters

$actual : mixed
$message : string = ''

assertIsNotFloat()

Asserts that a variable is not of type float.


    
                    assertIsNotFloat(mixed $actual[, string $message = '' ]) : void

Parameters

$actual : mixed
$message : string = ''

assertIsNotInt()

Asserts that a variable is not of type int.


    
                    assertIsNotInt(mixed $actual[, string $message = '' ]) : void

Parameters

$actual : mixed
$message : string = ''

assertIsNotNumeric()

Asserts that a variable is not of type numeric.


    
                    assertIsNotNumeric(mixed $actual[, string $message = '' ]) : void

Parameters

$actual : mixed
$message : string = ''

assertIsNotObject()

Asserts that a variable is not of type object.


    
                    assertIsNotObject(mixed $actual[, string $message = '' ]) : void

Parameters

$actual : mixed
$message : string = ''

assertIsNotResource()

Asserts that a variable is not of type resource.


    
                    assertIsNotResource(mixed $actual[, string $message = '' ]) : void

Parameters

$actual : mixed
$message : string = ''

assertIsNotClosedResource()

Asserts that a variable is not of type resource.


    
                    assertIsNotClosedResource(mixed $actual[, string $message = '' ]) : void

Parameters

$actual : mixed
$message : string = ''

assertIsNotString()

Asserts that a variable is not of type string.


    
                    assertIsNotString(mixed $actual[, string $message = '' ]) : void

Parameters

$actual : mixed
$message : string = ''

assertIsNotScalar()

Asserts that a variable is not of type scalar.


    
                    assertIsNotScalar(mixed $actual[, string $message = '' ]) : void

Parameters

$actual : mixed
$message : string = ''

assertIsNotCallable()

Asserts that a variable is not of type callable.


    
                    assertIsNotCallable(mixed $actual[, string $message = '' ]) : void

Parameters

$actual : mixed
$message : string = ''

assertIsNotIterable()

Asserts that a variable is not of type iterable.


    
                    assertIsNotIterable(mixed $actual[, string $message = '' ]) : void

Parameters

$actual : mixed
$message : string = ''

assertMatchesRegularExpression()

Asserts that a string matches a given regular expression.


    
                    assertMatchesRegularExpression(string $pattern, string $string[, string $message = '' ]) : void

Parameters

$pattern : string
$string : string
$message : string = ''

assertRegExp()

Asserts that a string matches a given regular expression.


    
                    assertRegExp(string $pattern, string $string[, string $message = '' ]) : void

Parameters

$pattern : string
$string : string
$message : string = ''

assertDoesNotMatchRegularExpression()

Asserts that a string does not match a given regular expression.


    
                    assertDoesNotMatchRegularExpression(string $pattern, string $string[, string $message = '' ]) : void

Parameters

$pattern : string
$string : string
$message : string = ''

assertNotRegExp()

Asserts that a string does not match a given regular expression.


    
                    assertNotRegExp(string $pattern, string $string[, string $message = '' ]) : void

Parameters

$pattern : string
$string : string
$message : string = ''

assertSameSize()

Assert that the size of two arrays (or `Countable` or `Traversable` objects) is the same.


    
                    assertSameSize(Countable|iterable<string|int, mixed> $expected, Countable|iterable<string|int, mixed> $actual[, string $message = '' ]) : void

Parameters

$expected : Countable|iterable<string|int, mixed>
$actual : Countable|iterable<string|int, mixed>
$message : string = ''

assertNotSameSize()

Assert that the size of two arrays (or `Countable` or `Traversable` objects) is not the same.


    
                    assertNotSameSize(Countable|iterable<string|int, mixed> $expected, Countable|iterable<string|int, mixed> $actual[, string $message = '' ]) : void

Parameters

$expected : Countable|iterable<string|int, mixed>
$actual : Countable|iterable<string|int, mixed>
$message : string = ''

assertStringMatchesFormat()

Asserts that a string matches a given format string.


    
                    assertStringMatchesFormat(string $format, string $string[, string $message = '' ]) : void

Parameters

$format : string
$string : string
$message : string = ''

assertStringNotMatchesFormat()

Asserts that a string does not match a given format string.


    
                    assertStringNotMatchesFormat(string $format, string $string[, string $message = '' ]) : void

Parameters

$format : string
$string : string
$message : string = ''

assertStringMatchesFormatFile()

Asserts that a string matches a given format file.


    
                    assertStringMatchesFormatFile(string $formatFile, string $string[, string $message = '' ]) : void

Parameters

$formatFile : string
$string : string
$message : string = ''

assertStringNotMatchesFormatFile()

Asserts that a string does not match a given format string.


    
                    assertStringNotMatchesFormatFile(string $formatFile, string $string[, string $message = '' ]) : void

Parameters

$formatFile : string
$string : string
$message : string = ''

assertStringStartsWith()

Asserts that a string starts with a given prefix.


    
                    assertStringStartsWith(string $prefix, string $string[, string $message = '' ]) : void

Parameters

$prefix : string
$string : string
$message : string = ''

assertStringStartsNotWith()

Asserts that a string starts not with a given prefix.


    
                    assertStringStartsNotWith(string $prefix, string $string[, string $message = '' ]) : void

Parameters

$prefix : string
$string : string
$message : string = ''

assertStringContainsString()


    
                    assertStringContainsString(string $needle, string $haystack[, string $message = '' ]) : void

Parameters

$needle : string
$haystack : string
$message : string = ''

assertStringContainsStringIgnoringCase()


    
                    assertStringContainsStringIgnoringCase(string $needle, string $haystack[, string $message = '' ]) : void

Parameters

$needle : string
$haystack : string
$message : string = ''

assertStringNotContainsString()


    
                    assertStringNotContainsString(string $needle, string $haystack[, string $message = '' ]) : void

Parameters

$needle : string
$haystack : string
$message : string = ''

assertStringNotContainsStringIgnoringCase()


    
                    assertStringNotContainsStringIgnoringCase(string $needle, string $haystack[, string $message = '' ]) : void

Parameters

$needle : string
$haystack : string
$message : string = ''

assertStringEndsWith()

Asserts that a string ends with a given suffix.


    
                    assertStringEndsWith(string $suffix, string $string[, string $message = '' ]) : void

Parameters

$suffix : string
$string : string
$message : string = ''

assertStringEndsNotWith()

Asserts that a string ends not with a given suffix.


    
                    assertStringEndsNotWith(string $suffix, string $string[, string $message = '' ]) : void

Parameters

$suffix : string
$string : string
$message : string = ''

assertXmlFileEqualsXmlFile()

Asserts that two XML files are equal.


    
                    assertXmlFileEqualsXmlFile(string $expectedFile, string $actualFile[, string $message = '' ]) : void

Parameters

$expectedFile : string
$actualFile : string
$message : string = ''

assertXmlFileNotEqualsXmlFile()

Asserts that two XML files are not equal.


    
                    assertXmlFileNotEqualsXmlFile(string $expectedFile, string $actualFile[, string $message = '' ]) : void

Parameters

$expectedFile : string
$actualFile : string
$message : string = ''

assertXmlStringEqualsXmlFile()

Asserts that two XML documents are equal.


    
                    assertXmlStringEqualsXmlFile(string $expectedFile, DOMDocument|string $actualXml[, string $message = '' ]) : void

Parameters

$expectedFile : string
$actualXml : DOMDocument|string
$message : string = ''

assertXmlStringNotEqualsXmlFile()

Asserts that two XML documents are not equal.


    
                    assertXmlStringNotEqualsXmlFile(string $expectedFile, DOMDocument|string $actualXml[, string $message = '' ]) : void

Parameters

$expectedFile : string
$actualXml : DOMDocument|string
$message : string = ''

assertXmlStringEqualsXmlString()

Asserts that two XML documents are equal.


    
                    assertXmlStringEqualsXmlString(DOMDocument|string $expectedXml, DOMDocument|string $actualXml[, string $message = '' ]) : void

Parameters

$expectedXml : DOMDocument|string
$actualXml : DOMDocument|string
$message : string = ''

assertXmlStringNotEqualsXmlString()

Asserts that two XML documents are not equal.


    
                    assertXmlStringNotEqualsXmlString(DOMDocument|string $expectedXml, DOMDocument|string $actualXml[, string $message = '' ]) : void

Parameters

$expectedXml : DOMDocument|string
$actualXml : DOMDocument|string
$message : string = ''

assertEqualXMLStructure()

Asserts that a hierarchy of DOMElements matches.


    
                    assertEqualXMLStructure(DOMElement $expectedElement, DOMElement $actualElement[, bool $checkAttributes = false ][, string $message = '' ]) : void

Parameters

$expectedElement : DOMElement
$actualElement : DOMElement
$checkAttributes : bool = false
$message : string = ''

assertThat()

Evaluates a PHPUnit\Framework\Constraint matcher object.


    
                    assertThat(mixed $value, Constraint $constraint[, string $message = '' ]) : void

Parameters

$value : mixed
$constraint : Constraint
$message : string = ''

assertJson()

Asserts that a string is a valid JSON string.


    
                    assertJson(string $actualJson[, string $message = '' ]) : void

Parameters

$actualJson : string
$message : string = ''

assertJsonStringEqualsJsonString()

Asserts that two given JSON encoded objects or arrays are equal.


    
                    assertJsonStringEqualsJsonString(string $expectedJson, string $actualJson[, string $message = '' ]) : void

Parameters

$expectedJson : string
$actualJson : string
$message : string = ''

assertJsonStringNotEqualsJsonString()

Asserts that two given JSON encoded objects or arrays are not equal.


    
                    assertJsonStringNotEqualsJsonString(string $expectedJson, string $actualJson[, string $message = '' ]) : void

Parameters

$expectedJson : string
$actualJson : string
$message : string = ''

assertJsonStringEqualsJsonFile()

Asserts that the generated JSON encoded object and the content of the given file are equal.


    
                    assertJsonStringEqualsJsonFile(string $expectedFile, string $actualJson[, string $message = '' ]) : void

Parameters

$expectedFile : string
$actualJson : string
$message : string = ''

assertJsonStringNotEqualsJsonFile()

Asserts that the generated JSON encoded object and the content of the given file are not equal.


    
                    assertJsonStringNotEqualsJsonFile(string $expectedFile, string $actualJson[, string $message = '' ]) : void

Parameters

$expectedFile : string
$actualJson : string
$message : string = ''

assertJsonFileEqualsJsonFile()

Asserts that two JSON files are equal.


    
                    assertJsonFileEqualsJsonFile(string $expectedFile, string $actualFile[, string $message = '' ]) : void

Parameters

$expectedFile : string
$actualFile : string
$message : string = ''

assertJsonFileNotEqualsJsonFile()

Asserts that two JSON files are not equal.


    
                    assertJsonFileNotEqualsJsonFile(string $expectedFile, string $actualFile[, string $message = '' ]) : void

Parameters

$expectedFile : string
$actualFile : string
$message : string = ''

logicalAnd()


    
                    logicalAnd() : LogicalAnd

Return values

LogicalAnd

logicalOr()


    
                    logicalOr() : LogicalOr

Return values

LogicalOr

logicalNot()


    
                    logicalNot(Constraint $constraint) : LogicalNot

Parameters

$constraint : Constraint

Return values

LogicalNot

logicalXor()


    
                    logicalXor() : LogicalXor

Return values

LogicalXor

anything()


    
                    anything() : IsAnything

Return values

IsAnything

isTrue()


    
                    isTrue() : IsTrue

Return values

IsTrue

callback()


    
                    callback(callable $callback) : Callback

Parameters

$callback : callable

Return values

Callback

isFalse()


    
                    isFalse() : IsFalse

Return values

IsFalse

isJson()


    
                    isJson() : IsJson

Return values

IsJson

isNull()


    
                    isNull() : IsNull

Return values

IsNull

isFinite()


    
                    isFinite() : IsFinite

Return values

IsFinite

isInfinite()


    
                    isInfinite() : IsInfinite

Return values

IsInfinite

isNan()


    
                    isNan() : IsNan

Return values

IsNan

containsEqual()


    
                    containsEqual(mixed $value) : TraversableContainsEqual

Parameters

$value : mixed

Return values

TraversableContainsEqual

containsIdentical()


    
                    containsIdentical(mixed $value) : TraversableContainsIdentical

Parameters

$value : mixed

Return values

TraversableContainsIdentical

containsOnly()


    
                    containsOnly(string $type) : TraversableContainsOnly

Parameters

$type : string

Return values

TraversableContainsOnly

containsOnlyInstancesOf()


    
                    containsOnlyInstancesOf(string $className) : TraversableContainsOnly

Parameters

$className : string

Return values

TraversableContainsOnly

arrayHasKey()


    
                    arrayHasKey(mixed $key) : ArrayHasKey

Parameters

$key : mixed

Return values

ArrayHasKey

equalTo()


    
                    equalTo(mixed $value) : IsEqual

Parameters

$value : mixed

Return values

IsEqual

equalToCanonicalizing()


    
                    equalToCanonicalizing(mixed $value) : IsEqualCanonicalizing

Parameters

$value : mixed

Return values

IsEqualCanonicalizing

equalToIgnoringCase()


    
                    equalToIgnoringCase(mixed $value) : IsEqualIgnoringCase

Parameters

$value : mixed

Return values

IsEqualIgnoringCase

equalToWithDelta()


    
                    equalToWithDelta(mixed $value, float $delta) : IsEqualWithDelta

Parameters

$value : mixed
$delta : float

Return values

IsEqualWithDelta

isEmpty()


    
                    isEmpty() : IsEmpty

Return values

IsEmpty

isWritable()


    
                    isWritable() : IsWritable

Return values

IsWritable

isReadable()


    
                    isReadable() : IsReadable

Return values

IsReadable

directoryExists()


    
                    directoryExists() : DirectoryExists

Return values

DirectoryExists

fileExists()


    
                    fileExists() : FileExists

Return values

FileExists

greaterThan()


    
                    greaterThan(mixed $value) : GreaterThan

Parameters

$value : mixed

Return values

GreaterThan

greaterThanOrEqual()


    
                    greaterThanOrEqual(mixed $value) : LogicalOr

Parameters

$value : mixed

Return values

LogicalOr

classHasAttribute()


    
                    classHasAttribute(string $attributeName) : ClassHasAttribute

Parameters

$attributeName : string

Return values

ClassHasAttribute

classHasStaticAttribute()


    
                    classHasStaticAttribute(string $attributeName) : ClassHasStaticAttribute

Parameters

$attributeName : string

Return values

ClassHasStaticAttribute

objectHasAttribute()


    
                    objectHasAttribute(mixed $attributeName) : ObjectHasAttribute

Parameters

$attributeName : mixed

Return values

ObjectHasAttribute

identicalTo()


    
                    identicalTo(mixed $value) : IsIdentical

Parameters

$value : mixed

Return values

IsIdentical

isInstanceOf()


    
                    isInstanceOf(string $className) : IsInstanceOf

Parameters

$className : string

Return values

IsInstanceOf

isType()


    
                    isType(string $type) : IsType

Parameters

$type : string

Return values

IsType

lessThan()


    
                    lessThan(mixed $value) : LessThan

Parameters

$value : mixed

Return values

LessThan

lessThanOrEqual()


    
                    lessThanOrEqual(mixed $value) : LogicalOr

Parameters

$value : mixed

Return values

LogicalOr

matchesRegularExpression()


    
                    matchesRegularExpression(string $pattern) : RegularExpression

Parameters

$pattern : string

Return values

RegularExpression

matches()


    
                    matches(string $string) : StringMatchesFormatDescription

Parameters

$string : string

Return values

StringMatchesFormatDescription

stringStartsWith()


    
                    stringStartsWith(mixed $prefix) : StringStartsWith

Parameters

$prefix : mixed

Return values

StringStartsWith

stringContains()


    
                    stringContains(string $string[, bool $case = true ]) : StringContains

Parameters

$string : string
$case : bool = true

Return values

StringContains

stringEndsWith()


    
                    stringEndsWith(string $suffix) : StringEndsWith

Parameters

$suffix : string

Return values

StringEndsWith

countOf()


    
                    countOf(int $count) : Count

Parameters

$count : int

Return values

Count

objectEquals()


    
                    objectEquals(object $object[, string $method = 'equals' ]) : ObjectEquals

Parameters

$object : object
$method : string = 'equals'

Return values

ObjectEquals

any()

Returns a matcher that matches when the method is executed zero or more times.


    
                    any() : AnyInvokedCount

Return values

AnyInvokedCount

never()

Returns a matcher that matches when the method is never executed.


    
                    never() : InvokedCount

Return values

InvokedCount

atLeast()

Returns a matcher that matches when the method is executed at least N times.


    
                    atLeast(int $requiredInvocations) : InvokedAtLeastCount

Parameters

$requiredInvocations : int

Return values

InvokedAtLeastCount

atLeastOnce()

Returns a matcher that matches when the method is executed at least once.


    
                    atLeastOnce() : InvokedAtLeastOnce

Return values

InvokedAtLeastOnce

once()

Returns a matcher that matches when the method is executed exactly once.


    
                    once() : InvokedCount

Return values

InvokedCount

exactly()

Returns a matcher that matches when the method is executed exactly $count times.


    
                    exactly(int $count) : InvokedCount

Parameters

$count : int

Return values

InvokedCount

atMost()

Returns a matcher that matches when the method is executed at most N times.


    
                    atMost(int $allowedInvocations) : InvokedAtMostCount

Parameters

$allowedInvocations : int

Return values

InvokedAtMostCount

at()

Returns a matcher that matches when the method is executed at the given index.


    
                    at(int $index) : InvokedAtIndex

Parameters

$index : int

Return values

InvokedAtIndex

returnValue()


    
                    returnValue(mixed $value) : ReturnStub

Parameters

$value : mixed

Return values

ReturnStub

returnValueMap()


    
                    returnValueMap(array<string|int, mixed> $valueMap) : ReturnValueMap

Parameters

$valueMap : array<string|int, mixed>

Return values

ReturnValueMap

returnArgument()


    
                    returnArgument(int $argumentIndex) : ReturnArgument

Parameters

$argumentIndex : int

Return values

ReturnArgument

returnCallback()


    
                    returnCallback(mixed $callback) : ReturnCallback

Parameters

$callback : mixed

Return values

ReturnCallback

returnSelf()

Returns the current object.


    
                    returnSelf() : ReturnSelf

This method is useful when mocking a fluent interface.

Return values

ReturnSelf

throwException()


    
                    throwException(Throwable $exception) : Exception

Parameters

$exception : Throwable

Return values

Exception

onConsecutiveCalls()


    
                    onConsecutiveCalls() : ConsecutiveCalls

Return values

ConsecutiveCalls

pubnubAutoloader()


    
                    pubnubAutoloader(mixed $className) : mixed

Parameters

$className : mixed

getallheaders()

Get all HTTP header key/values as an associative array for the current request.


    
                    getallheaders() : mixed

Return values

mixed —

The HTTP header key/value pairs.

connect()


    
                    connect(string $url[, array<string|int, mixed> $subProtocols = [] ][, array<string|int, mixed> $headers = [] ][, LoopInterface|null $loop = null ]) : PromiseInterface<string|int, WebSocket>

Parameters

$url : string
$subProtocols : array<string|int, mixed> = []
$headers : array<string|int, mixed> = []
$loop : LoopInterface|null = null

Return values

PromiseInterface<string|int, WebSocket>

echoStreamerFactory()


    
                    echoStreamerFactory(mixed $conn[, mixed $permessageDeflateOptions = null ]) : mixed

Parameters

$conn : mixed
$permessageDeflateOptions : mixed = null

getTestCases()


    
                    getTestCases() : mixed

runTest()


    
                    runTest(mixed $case) : mixed

Parameters

$case : mixed

createReport()


    
                    createReport() : mixed

await()

Block waiting for the given `$promise` to be fulfilled.


    
                    await(PromiseInterface<string|int, T> $promise) : T

$result = React\Async\await($promise, $loop);

This function will only return after the given $promise has settled, i.e. either fulfilled or rejected.

While the promise is pending, this function will assume control over the event loop. Internally, it will run() the default loop until the promise settles and then calls stop() to terminate execution of the loop. This means this function is more suited for short-lived promise executions when using promise-based APIs is not feasible. For long-running applications, using promise-based APIs by leveraging chained then() calls is usually preferable.

Once the promise is fulfilled, this function will return whatever the promise resolved to.

Once the promise is rejected, this will throw whatever the promise rejected with. If the promise did not reject with an Exception or Throwable, then this function will throw an UnexpectedValueException instead.

try {
    $result = React\Async\await($promise, $loop);
    // promise successfully fulfilled with $result
    echo 'Result: ' . $result;
} catch (Throwable $e) {
    // promise rejected with $e
    echo 'Error: ' . $e->getMessage();
}

Parameters

$promise : PromiseInterface<string|int, T>

Return values

T —

returns whatever the promise resolves to

delay()

Delay program execution for duration given in `$seconds`.


    
                    delay(float $seconds) : void

React\Async\delay($seconds);

This function will only return after the given number of $seconds have elapsed. If there are no other events attached to this loop, it will behave similar to PHP's sleep() function.

echo 'a';
React\Async\delay(1.0);
echo 'b';

// prints "a" at t=0.0s
// prints "b" at t=1.0s

Unlike PHP's sleep() function, this function may not necessarily halt execution of the entire process thread. Instead, it allows the event loop to run any other events attached to the same loop until the delay returns:

echo 'a';
Loop::addTimer(1.0, function () {
    echo 'b';
});
React\Async\delay(3.0);
echo 'c';

// prints "a" at t=0.0s
// prints "b" at t=1.0s
// prints "c" at t=3.0s

This behavior is especially useful if you want to delay the program execution of a particular routine, such as when building a simple polling or retry mechanism:

try {
    something();
} catch (Throwable $e) {
    // in case of error, retry after a short delay
    React\Async\delay(1.0);
    something();
}

Because this function only returns after some time has passed, it can be considered blocking from the perspective of the calling code. While the delay is running, this function will assume control over the event loop. Internally, it will run() the default loop until the delay returns and then calls stop() to terminate execution of the loop. This means this function is more suited for short-lived promise executions when using promise-based APIs is not feasible. For long-running applications, using promise-based APIs by leveraging chained then() calls is usually preferable.

Internally, the $seconds argument will be used as a timer for the loop so that it keeps running until this timer triggers. This implies that if you pass a really small (or negative) value, it will still start a timer and will thus trigger at the earliest possible time in the future.

Parameters

$seconds : float

coroutine()

Execute a Generator-based coroutine to "await" promises.


    
                    coroutine(callable(A1, A2, A3, A4, A5): Array $function, mixed ...$args) : PromiseInterface<string|int, T>

React\Async\coroutine(function () {
    $browser = new React\Http\Browser();

    try {
        $response = yield $browser->get('https://example.com/');
        assert($response instanceof Psr\Http\Message\ResponseInterface);
        echo $response->getBody();
    } catch (Exception $e) {
        echo 'Error: ' . $e->getMessage() . PHP_EOL;
    }
});

Using Generator-based coroutines is an alternative to directly using the underlying promise APIs. For many use cases, this makes using promise-based APIs much simpler, as it resembles a synchronous code flow more closely. The above example performs the equivalent of directly using the promise APIs:

$browser = new React\Http\Browser();

$browser->get('https://example.com/')->then(function (Psr\Http\Message\ResponseInterface $response) {
    echo $response->getBody();
}, function (Exception $e) {
    echo 'Error: ' . $e->getMessage() . PHP_EOL;
});

The yield keyword can be used to "await" a promise resolution. Internally, it will turn the entire given $function into a Generator. This allows the execution to be interrupted and resumed at the same place when the promise is fulfilled. The yield statement returns whatever the promise is fulfilled with. If the promise is rejected, it will throw an Exception or Throwable.

The coroutine() function will always return a Proimise which will be fulfilled with whatever your $function returns. Likewise, it will return a promise that will be rejected if you throw an Exception or Throwable from your $function. This allows you easily create Promise-based functions:

$promise = React\Async\coroutine(function () {
    $browser = new React\Http\Browser();
    $urls = [
        'https://example.com/alice',
        'https://example.com/bob'
    ];

    $bytes = 0;
    foreach ($urls as $url) {
        $response = yield $browser->get($url);
        assert($response instanceof Psr\Http\Message\ResponseInterface);
        $bytes += $response->getBody()->getSize();
    }
    return $bytes;
});

$promise->then(function (int $bytes) {
    echo 'Total size: ' . $bytes . PHP_EOL;
}, function (Exception $e) {
    echo 'Error: ' . $e->getMessage() . PHP_EOL;
});

The previous example uses a yield statement inside a loop to highlight how this vastly simplifies consuming asynchronous operations. At the same time, this naive example does not leverage concurrent execution, as it will essentially "await" between each operation. In order to take advantage of concurrent execution within the given $function, you can "await" multiple promises by using a single yield together with Promise-based primitives like this:

$promise = React\Async\coroutine(function () {
    $browser = new React\Http\Browser();
    $urls = [
        'https://example.com/alice',
        'https://example.com/bob'
    ];

    $promises = [];
    foreach ($urls as $url) {
        $promises[] = $browser->get($url);
    }

    try {
        $responses = yield React\Promise\all($promises);
    } catch (Exception $e) {
        foreach ($promises as $promise) {
            $promise->cancel();
        }
        throw $e;
    }

    $bytes = 0;
    foreach ($responses as $response) {
        assert($response instanceof Psr\Http\Message\ResponseInterface);
        $bytes += $response->getBody()->getSize();
    }
    return $bytes;
});

$promise->then(function (int $bytes) {
    echo 'Total size: ' . $bytes . PHP_EOL;
}, function (Exception $e) {
    echo 'Error: ' . $e->getMessage() . PHP_EOL;
});

Parameters

$function : callable(A1, A2, A3, A4, A5): Array
$args : mixed: Optional list of additional arguments that will be passed to the given $function as is

Return values

PromiseInterface<string|int, T>

parallel()


    
                    parallel(iterable<string|int, callable(): Array> $tasks) : PromiseInterface<string|int, array<string|int, T>>

Parameters

$tasks : iterable<string|int, callable(): Array>

Return values

PromiseInterface<string|int, array<string|int, T>>

series()


    
                    series(iterable<string|int, callable(): Array> $tasks) : PromiseInterface<string|int, array<string|int, T>>

Parameters

$tasks : iterable<string|int, callable(): Array>

Return values

PromiseInterface<string|int, array<string|int, T>>

waterfall()


    
                    waterfall(iterable<string|int, callable(): Array> $tasks) : PromiseInterface<string|int, mixed>

Parameters

$tasks : iterable<string|int, callable(): Array>

Return values

PromiseInterface<string|int, mixed>

resolve()

Creates a promise for the supplied `$promiseOrValue`.


    
                    resolve(PromiseInterface<string|int, T>|T $promiseOrValue) : PromiseInterface<string|int, T>

If $promiseOrValue is a value, it will be the resolution value of the returned promise.

If $promiseOrValue is a thenable (any object that provides a then() method), a trusted promise that follows the state of the thenable is returned.

If $promiseOrValue is a promise, it will be returned as is.

Parameters

$promiseOrValue : PromiseInterface<string|int, T>|T

Return values

PromiseInterface<string|int, T>

reject()

Creates a rejected promise for the supplied `$reason`.


    
                    reject(Throwable $reason) : PromiseInterface<string|int, never>

If $reason is a value, it will be the rejection value of the returned promise.

If $reason is a promise, its completion value will be the rejected value of the returned promise.

This can be useful in situations where you need to reject a promise without throwing an exception. For example, it allows you to propagate a rejection with the value of another promise.

Parameters

$reason : Throwable

Return values

PromiseInterface<string|int, never>

all()

Returns a promise that will resolve only once all the items in `$promisesOrValues` have resolved. The resolution value of the returned promise will be an array containing the resolution values of each of the items in `$promisesOrValues`.


    
                    all(iterable<string|int, PromiseInterface<string|int, T>|T> $promisesOrValues) : PromiseInterface<string|int, array<string|int, T>>

Parameters

$promisesOrValues : iterable<string|int, PromiseInterface<string|int, T>|T>

Return values

PromiseInterface<string|int, array<string|int, T>>

race()

Initiates a competitive race that allows one winner. Returns a promise which is resolved in the same way the first settled promise resolves.


    
                    race(iterable<string|int, PromiseInterface<string|int, T>|T> $promisesOrValues) : PromiseInterface<string|int, T>

The returned promise will become infinitely pending if $promisesOrValues contains 0 items.

Parameters

$promisesOrValues : iterable<string|int, PromiseInterface<string|int, T>|T>

Return values

PromiseInterface<string|int, T>

any()

Returns a promise that will resolve when any one of the items in `$promisesOrValues` resolves. The resolution value of the returned promise will be the resolution value of the triggering item.


    
                    any(iterable<string|int, PromiseInterface<string|int, T>|T> $promisesOrValues) : PromiseInterface<string|int, T>

The returned promise will only reject if all items in $promisesOrValues are rejected. The rejection value will be an array of all rejection reasons.

The returned promise will also reject with a React\Promise\Exception\LengthException if $promisesOrValues contains 0 items.

Parameters

$promisesOrValues : iterable<string|int, PromiseInterface<string|int, T>|T>

Return values

PromiseInterface<string|int, T>

set_rejection_handler()

Sets the global rejection handler for unhandled promise rejections.


    
                    set_rejection_handler(callable(Throwable): void|null $callback) : callable(Throwable): void|null

Note that rejected promises should always be handled similar to how any exceptions should always be caught in a try + catch block. If you remove the last reference to a rejected promise that has not been handled, it will report an unhandled promise rejection. See also the reject() function for more details.

The ?callable $callback argument MUST be a valid callback function that accepts a single Throwable argument or a null value to restore the default promise rejection handler. The return value of the callback function will be ignored and has no effect, so you SHOULD return a void value. The callback function MUST NOT throw or the program will be terminated with a fatal error.

The function returns the previous rejection handler or null if using the default promise rejection handler.

The default promise rejection handler will log an error message plus its stack trace:

// Unhandled promise rejection with RuntimeException: Unhandled in example.php:2
React\Promise\reject(new RuntimeException('Unhandled'));

The promise rejection handler may be used to use customize the log message or write to custom log targets. As a rule of thumb, this function should only be used as a last resort and promise rejections are best handled with either the then() method, the catch() method, or the finally() method. See also the reject() function for more details.

Parameters

$callback : callable(Throwable): void|null

Return values

callable(Throwable): void|null

trigger_deprecation()

Triggers a silenced deprecation notice.


    
                    trigger_deprecation(string $package, string $version, string $message, mixed ...$args) : void

Parameters

$package : string: The name of the Composer package that is triggering the deprecation
$version : string: The version of the package that introduced the deprecation
$message : string: The message of the deprecation
$args : mixed: Values to insert in the message using printf() formatting

ctype_alnum()


    
                    ctype_alnum(mixed $text) : mixed

Parameters

$text : mixed

ctype_alpha()


    
                    ctype_alpha(mixed $text) : mixed

Parameters

$text : mixed

ctype_cntrl()


    
                    ctype_cntrl(mixed $text) : mixed

Parameters

$text : mixed

ctype_digit()


    
                    ctype_digit(mixed $text) : mixed

Parameters

$text : mixed

ctype_graph()


    
                    ctype_graph(mixed $text) : mixed

Parameters

$text : mixed

ctype_lower()


    
                    ctype_lower(mixed $text) : mixed

Parameters

$text : mixed

ctype_print()


    
                    ctype_print(mixed $text) : mixed

Parameters

$text : mixed

ctype_punct()


    
                    ctype_punct(mixed $text) : mixed

Parameters

$text : mixed

ctype_space()


    
                    ctype_space(mixed $text) : mixed

Parameters

$text : mixed

ctype_upper()


    
                    ctype_upper(mixed $text) : mixed

Parameters

$text : mixed

ctype_xdigit()


    
                    ctype_xdigit(mixed $text) : mixed

Parameters

$text : mixed

ctype_alnum()


    
                    ctype_alnum(mixed $text) : bool

Parameters

$text : mixed

Return values

bool

ctype_alpha()


    
                    ctype_alpha(mixed $text) : bool

Parameters

$text : mixed

Return values

bool

ctype_cntrl()


    
                    ctype_cntrl(mixed $text) : bool

Parameters

$text : mixed

Return values

bool

ctype_digit()


    
                    ctype_digit(mixed $text) : bool

Parameters

$text : mixed

Return values

bool

ctype_graph()


    
                    ctype_graph(mixed $text) : bool

Parameters

$text : mixed

Return values

bool

ctype_lower()


    
                    ctype_lower(mixed $text) : bool

Parameters

$text : mixed

Return values

bool

ctype_print()


    
                    ctype_print(mixed $text) : bool

Parameters

$text : mixed

Return values

bool

ctype_punct()


    
                    ctype_punct(mixed $text) : bool

Parameters

$text : mixed

Return values

bool

ctype_space()


    
                    ctype_space(mixed $text) : bool

Parameters

$text : mixed

Return values

bool

ctype_upper()


    
                    ctype_upper(mixed $text) : bool

Parameters

$text : mixed

Return values

bool

ctype_xdigit()


    
                    ctype_xdigit(mixed $text) : bool

Parameters

$text : mixed

Return values

bool

mb_convert_encoding()


    
                    mb_convert_encoding(mixed $string, mixed $to_encoding[, mixed $from_encoding = null ]) : mixed

Parameters

$string : mixed
$to_encoding : mixed
$from_encoding : mixed = null

mb_decode_mimeheader()


    
                    mb_decode_mimeheader(mixed $string) : mixed

Parameters

$string : mixed

mb_encode_mimeheader()


    
                    mb_encode_mimeheader(mixed $string[, mixed $charset = null ][, mixed $transfer_encoding = null ][, mixed $newline = "
" ][, mixed $indent = 0 ]) : mixed

Parameters

$string : mixed
$charset : mixed = null
$transfer_encoding : mixed = null
$newline : mixed = " "
$indent : mixed = 0

mb_decode_numericentity()


    
                    mb_decode_numericentity(mixed $string, mixed $map[, mixed $encoding = null ]) : mixed

Parameters

$string : mixed
$map : mixed
$encoding : mixed = null

mb_encode_numericentity()


    
                    mb_encode_numericentity(mixed $string, mixed $map[, mixed $encoding = null ][, mixed $hex = false ]) : mixed

Parameters

$string : mixed
$map : mixed
$encoding : mixed = null
$hex : mixed = false

mb_convert_case()


    
                    mb_convert_case(mixed $string, mixed $mode[, mixed $encoding = null ]) : mixed

Parameters

$string : mixed
$mode : mixed
$encoding : mixed = null

mb_internal_encoding()


    
                    mb_internal_encoding([mixed $encoding = null ]) : mixed

Parameters

$encoding : mixed = null

mb_language()


    
                    mb_language([mixed $language = null ]) : mixed

Parameters

$language : mixed = null

mb_list_encodings()


    
                    mb_list_encodings() : mixed

mb_encoding_aliases()


    
                    mb_encoding_aliases(mixed $encoding) : mixed

Parameters

$encoding : mixed

mb_check_encoding()


    
                    mb_check_encoding([mixed $value = null ][, mixed $encoding = null ]) : mixed

Parameters

$value : mixed = null
$encoding : mixed = null

mb_detect_encoding()


    
                    mb_detect_encoding(mixed $string[, mixed $encodings = null ][, mixed $strict = false ]) : mixed

Parameters

$string : mixed
$encodings : mixed = null
$strict : mixed = false

mb_detect_order()


    
                    mb_detect_order([mixed $encoding = null ]) : mixed

Parameters

$encoding : mixed = null

mb_parse_str()


    
                    mb_parse_str(mixed $string[, mixed &$result = [] ]) : mixed

Parameters

$string : mixed
$result : mixed = []

mb_strlen()


    
                    mb_strlen(mixed $string[, mixed $encoding = null ]) : mixed

Parameters

$string : mixed
$encoding : mixed = null

mb_strpos()


    
                    mb_strpos(mixed $haystack, mixed $needle[, mixed $offset = 0 ][, mixed $encoding = null ]) : mixed

Parameters

$haystack : mixed
$needle : mixed
$offset : mixed = 0
$encoding : mixed = null

mb_strtolower()


    
                    mb_strtolower(mixed $string[, mixed $encoding = null ]) : mixed

Parameters

$string : mixed
$encoding : mixed = null

mb_strtoupper()


    
                    mb_strtoupper(mixed $string[, mixed $encoding = null ]) : mixed

Parameters

$string : mixed
$encoding : mixed = null

mb_substitute_character()


    
                    mb_substitute_character([mixed $substitute_character = null ]) : mixed

Parameters

$substitute_character : mixed = null

mb_substr()


    
                    mb_substr(mixed $string, mixed $start[, mixed $length = 2147483647 ][, mixed $encoding = null ]) : mixed

Parameters

$string : mixed
$start : mixed
$length : mixed = 2147483647
$encoding : mixed = null

mb_stripos()


    
                    mb_stripos(mixed $haystack, mixed $needle[, mixed $offset = 0 ][, mixed $encoding = null ]) : mixed

Parameters

$haystack : mixed
$needle : mixed
$offset : mixed = 0
$encoding : mixed = null

mb_stristr()


    
                    mb_stristr(mixed $haystack, mixed $needle[, mixed $before_needle = false ][, mixed $encoding = null ]) : mixed

Parameters

$haystack : mixed
$needle : mixed
$before_needle : mixed = false
$encoding : mixed = null

mb_strrchr()


    
                    mb_strrchr(mixed $haystack, mixed $needle[, mixed $before_needle = false ][, mixed $encoding = null ]) : mixed

Parameters

$haystack : mixed
$needle : mixed
$before_needle : mixed = false
$encoding : mixed = null

mb_strrichr()


    
                    mb_strrichr(mixed $haystack, mixed $needle[, mixed $before_needle = false ][, mixed $encoding = null ]) : mixed

Parameters

$haystack : mixed
$needle : mixed
$before_needle : mixed = false
$encoding : mixed = null

mb_strripos()


    
                    mb_strripos(mixed $haystack, mixed $needle[, mixed $offset = 0 ][, mixed $encoding = null ]) : mixed

Parameters

$haystack : mixed
$needle : mixed
$offset : mixed = 0
$encoding : mixed = null

mb_strrpos()


    
                    mb_strrpos(mixed $haystack, mixed $needle[, mixed $offset = 0 ][, mixed $encoding = null ]) : mixed

Parameters

$haystack : mixed
$needle : mixed
$offset : mixed = 0
$encoding : mixed = null

mb_strstr()


    
                    mb_strstr(mixed $haystack, mixed $needle[, mixed $before_needle = false ][, mixed $encoding = null ]) : mixed

Parameters

$haystack : mixed
$needle : mixed
$before_needle : mixed = false
$encoding : mixed = null

mb_get_info()


    
                    mb_get_info([mixed $type = 'all' ]) : mixed

Parameters

$type : mixed = 'all'

mb_http_output()


    
                    mb_http_output([mixed $encoding = null ]) : mixed

Parameters

$encoding : mixed = null

mb_strwidth()


    
                    mb_strwidth(mixed $string[, mixed $encoding = null ]) : mixed

Parameters

$string : mixed
$encoding : mixed = null

mb_substr_count()


    
                    mb_substr_count(mixed $haystack, mixed $needle[, mixed $encoding = null ]) : mixed

Parameters

$haystack : mixed
$needle : mixed
$encoding : mixed = null

mb_output_handler()


    
                    mb_output_handler(mixed $string, mixed $status) : mixed

Parameters

$string : mixed
$status : mixed

mb_http_input()


    
                    mb_http_input([mixed $type = null ]) : mixed

Parameters

$type : mixed = null

mb_convert_variables()


    
                    mb_convert_variables(mixed $to_encoding, mixed $from_encoding, mixed ...&$vars) : mixed

Parameters

$to_encoding : mixed
$from_encoding : mixed
$vars : mixed

mb_ord()


    
                    mb_ord(mixed $string[, mixed $encoding = null ]) : mixed

Parameters

$string : mixed
$encoding : mixed = null

mb_chr()


    
                    mb_chr(mixed $codepoint[, mixed $encoding = null ]) : mixed

Parameters

$codepoint : mixed
$encoding : mixed = null

mb_scrub()


    
                    mb_scrub(mixed $string[, mixed $encoding = null ]) : mixed

Parameters

$string : mixed
$encoding : mixed = null

mb_str_split()


    
                    mb_str_split(mixed $string[, mixed $length = 1 ][, mixed $encoding = null ]) : mixed

Parameters

$string : mixed
$length : mixed = 1
$encoding : mixed = null

mb_str_pad()


    
                    mb_str_pad(string $string, int $length[, string $pad_string = ' ' ][, int $pad_type = STR_PAD_RIGHT ][, string|null $encoding = null ]) : string

Parameters

$string : string
$length : int
$pad_string : string = ' '
$pad_type : int = STR_PAD_RIGHT
$encoding : string|null = null

Return values

string

mb_convert_encoding()


    
                    mb_convert_encoding(array<string|int, mixed>|string|null $string, string|null $to_encoding[, array<string|int, mixed>|string|null $from_encoding = null ]) : array<string|int, mixed>|string|false

Parameters

$string : array<string|int, mixed>|string|null
$to_encoding : string|null
$from_encoding : array<string|int, mixed>|string|null = null

Return values

array<string|int, mixed>|string|false

mb_decode_mimeheader()


    
                    mb_decode_mimeheader(string|null $string) : string

Parameters

$string : string|null

Return values

string

mb_encode_mimeheader()


    
                    mb_encode_mimeheader(string|null $string[, string|null $charset = null ][, string|null $transfer_encoding = null ][, string|null $newline = "
" ][, int|null $indent = 0 ]) : string

Parameters

$string : string|null
$charset : string|null = null
$transfer_encoding : string|null = null
$newline : string|null = " "
$indent : int|null = 0

Return values

string

mb_decode_numericentity()


    
                    mb_decode_numericentity(string|null $string, array<string|int, mixed> $map[, string|null $encoding = null ]) : string

Parameters

$string : string|null
$map : array<string|int, mixed>
$encoding : string|null = null

Return values

string

mb_encode_numericentity()


    
                    mb_encode_numericentity(string|null $string, array<string|int, mixed> $map[, string|null $encoding = null ][, bool|null $hex = false ]) : string

Parameters

$string : string|null
$map : array<string|int, mixed>
$encoding : string|null = null
$hex : bool|null = false

Return values

string

mb_convert_case()


    
                    mb_convert_case(string|null $string, int|null $mode[, string|null $encoding = null ]) : string

Parameters

$string : string|null
$mode : int|null
$encoding : string|null = null

Return values

string

mb_internal_encoding()


    
                    mb_internal_encoding([string|null $encoding = null ]) : string|bool

Parameters

$encoding : string|null = null

Return values

string|bool

mb_language()


    
                    mb_language([string|null $language = null ]) : string|bool

Parameters

$language : string|null = null

Return values

string|bool

mb_list_encodings()


    
                    mb_list_encodings() : array<string|int, mixed>

Return values

array<string|int, mixed>

mb_encoding_aliases()


    
                    mb_encoding_aliases(string|null $encoding) : array<string|int, mixed>

Parameters

$encoding : string|null

Return values

array<string|int, mixed>

mb_check_encoding()


    
                    mb_check_encoding([array<string|int, mixed>|string|null $value = null ][, string|null $encoding = null ]) : bool

Parameters

$value : array<string|int, mixed>|string|null = null
$encoding : string|null = null

Return values

bool

mb_detect_encoding()


    
                    mb_detect_encoding(string|null $string[, array<string|int, mixed>|string|null $encodings = null ][, bool|null $strict = false ]) : string|false

Parameters

$string : string|null
$encodings : array<string|int, mixed>|string|null = null
$strict : bool|null = false

Return values

string|false

mb_detect_order()


    
                    mb_detect_order([array<string|int, mixed>|string|null $encoding = null ]) : array<string|int, mixed>|bool

Parameters

$encoding : array<string|int, mixed>|string|null = null

Return values

array<string|int, mixed>|bool

mb_parse_str()


    
                    mb_parse_str(string|null $string[, mixed &$result = [] ]) : bool

Parameters

$string : string|null
$result : mixed = []

Return values

bool

mb_strlen()


    
                    mb_strlen(string|null $string[, string|null $encoding = null ]) : int

Parameters

$string : string|null
$encoding : string|null = null

Return values

int

mb_strpos()


    
                    mb_strpos(string|null $haystack, string|null $needle[, int|null $offset = 0 ][, string|null $encoding = null ]) : int|false

Parameters

$haystack : string|null
$needle : string|null
$offset : int|null = 0
$encoding : string|null = null

Return values

int|false

mb_strtolower()


    
                    mb_strtolower(string|null $string[, string|null $encoding = null ]) : string

Parameters

$string : string|null
$encoding : string|null = null

Return values

string

mb_strtoupper()


    
                    mb_strtoupper(string|null $string[, string|null $encoding = null ]) : string

Parameters

$string : string|null
$encoding : string|null = null

Return values

string

mb_substitute_character()


    
                    mb_substitute_character([string|int|null $substitute_character = null ]) : string|int|bool

Parameters

$substitute_character : string|int|null = null

Return values

string|int|bool

mb_substr()


    
                    mb_substr(string|null $string, int|null $start[, int|null $length = null ][, string|null $encoding = null ]) : string

Parameters

$string : string|null
$start : int|null
$length : int|null = null
$encoding : string|null = null

Return values

string

mb_stripos()


    
                    mb_stripos(string|null $haystack, string|null $needle[, int|null $offset = 0 ][, string|null $encoding = null ]) : int|false

Parameters

$haystack : string|null
$needle : string|null
$offset : int|null = 0
$encoding : string|null = null

Return values

int|false

mb_stristr()


    
                    mb_stristr(string|null $haystack, string|null $needle[, bool|null $before_needle = false ][, string|null $encoding = null ]) : string|false

Parameters

$haystack : string|null
$needle : string|null
$before_needle : bool|null = false
$encoding : string|null = null

Return values

string|false

mb_strrchr()


    
                    mb_strrchr(string|null $haystack, string|null $needle[, bool|null $before_needle = false ][, string|null $encoding = null ]) : string|false

Parameters

$haystack : string|null
$needle : string|null
$before_needle : bool|null = false
$encoding : string|null = null

Return values

string|false

mb_strrichr()


    
                    mb_strrichr(string|null $haystack, string|null $needle[, bool|null $before_needle = false ][, string|null $encoding = null ]) : string|false

Parameters

$haystack : string|null
$needle : string|null
$before_needle : bool|null = false
$encoding : string|null = null

Return values

string|false

mb_strripos()


    
                    mb_strripos(string|null $haystack, string|null $needle[, int|null $offset = 0 ][, string|null $encoding = null ]) : int|false

Parameters

$haystack : string|null
$needle : string|null
$offset : int|null = 0
$encoding : string|null = null

Return values

int|false

mb_strrpos()


    
                    mb_strrpos(string|null $haystack, string|null $needle[, int|null $offset = 0 ][, string|null $encoding = null ]) : int|false

Parameters

$haystack : string|null
$needle : string|null
$offset : int|null = 0
$encoding : string|null = null

Return values

int|false

mb_strstr()


    
                    mb_strstr(string|null $haystack, string|null $needle[, bool|null $before_needle = false ][, string|null $encoding = null ]) : string|false

Parameters

$haystack : string|null
$needle : string|null
$before_needle : bool|null = false
$encoding : string|null = null

Return values

string|false

mb_get_info()


    
                    mb_get_info([string|null $type = 'all' ]) : array<string|int, mixed>|string|int|false

Parameters

$type : string|null = 'all'

Return values

array<string|int, mixed>|string|int|false

mb_http_output()


    
                    mb_http_output([string|null $encoding = null ]) : string|bool

Parameters

$encoding : string|null = null

Return values

string|bool

mb_strwidth()


    
                    mb_strwidth(string|null $string[, string|null $encoding = null ]) : int

Parameters

$string : string|null
$encoding : string|null = null

Return values

int

mb_substr_count()


    
                    mb_substr_count(string|null $haystack, string|null $needle[, string|null $encoding = null ]) : int

Parameters

$haystack : string|null
$needle : string|null
$encoding : string|null = null

Return values

int

mb_output_handler()


    
                    mb_output_handler(string|null $string, int|null $status) : string

Parameters

$string : string|null
$status : int|null

Return values

string

mb_http_input()


    
                    mb_http_input([string|null $type = null ]) : array<string|int, mixed>|string|false

Parameters

$type : string|null = null

Return values

array<string|int, mixed>|string|false

mb_convert_variables()


    
                    mb_convert_variables(string|null $to_encoding, array<string|int, mixed>|string|null $from_encoding, mixed &$var, mixed ...&$vars) : string|false

Parameters

$to_encoding : string|null
$from_encoding : array<string|int, mixed>|string|null
$var : mixed
$vars : mixed

Return values

string|false

mb_ord()


    
                    mb_ord(string|null $string[, string|null $encoding = null ]) : int|false

Parameters

$string : string|null
$encoding : string|null = null

Return values

int|false

mb_chr()


    
                    mb_chr(int|null $codepoint[, string|null $encoding = null ]) : string|false

Parameters

$codepoint : int|null
$encoding : string|null = null

Return values

string|false

mb_scrub()


    
                    mb_scrub(string|null $string[, string|null $encoding = null ]) : string

Parameters

$string : string|null
$encoding : string|null = null

Return values

string

mb_str_split()


    
                    mb_str_split(string|null $string[, int|null $length = 1 ][, string|null $encoding = null ]) : array<string|int, mixed>

Parameters

$string : string|null
$length : int|null = 1
$encoding : string|null = null

Return values

array<string|int, mixed>

mb_str_pad()


    
                    mb_str_pad(string $string, int $length[, string $pad_string = ' ' ][, int $pad_type = STR_PAD_RIGHT ][, string|null $encoding = null ]) : string

Parameters

$string : string
$length : int
$pad_string : string = ' '
$pad_type : int = STR_PAD_RIGHT
$encoding : string|null = null

Return values

string

is_countable()


    
                    is_countable(mixed $value) : mixed

Parameters

$value : mixed

hrtime()


    
                    hrtime([mixed $as_number = false ]) : mixed

Parameters

$as_number : mixed = false

array_key_first()


    
                    array_key_first(array<string|int, mixed> $array) : mixed

Parameters

$array : array<string|int, mixed>

array_key_last()


    
                    array_key_last(array<string|int, mixed> $array) : mixed

Parameters

$array : array<string|int, mixed>

fdiv()


    
                    fdiv(float $num1, float $num2) : float

Parameters

$num1 : float
$num2 : float

Return values

float

preg_last_error_msg()


    
                    preg_last_error_msg() : string

Return values

string

str_contains()


    
                    str_contains(string|null $haystack, string|null $needle) : bool

Parameters

$haystack : string|null
$needle : string|null

Return values

bool

str_starts_with()


    
                    str_starts_with(string|null $haystack, string|null $needle) : bool

Parameters

$haystack : string|null
$needle : string|null

Return values

bool

str_ends_with()


    
                    str_ends_with(string|null $haystack, string|null $needle) : bool

Parameters

$haystack : string|null
$needle : string|null

Return values

bool

get_debug_type()


    
                    get_debug_type(mixed $value) : string

Parameters

$value : mixed

Return values

string

get_resource_id()


    
                    get_resource_id(mixed $resource) : int

Parameters

$resource : mixed

Return values

int

array_is_list()


    
                    array_is_list(array<string|int, mixed> $array) : bool

Parameters

$array : array<string|int, mixed>

Return values

bool

enum_exists()


    
                    enum_exists(string $enum[, bool $autoload = true ]) : bool

Parameters

$enum : string
$autoload : bool = true

Return values

bool

autoload()


    
                    autoload(mixed $rootDir) : mixed

Parameters

$rootDir : mixed

Application

Table of Contents

Interfaces

Classes

Traits

Constants

Functions

Constants

AGENT

AGENT

FILTER_VALIDATE_BOOL

HOA

MB_CASE_LOWER

MB_CASE_LOWER

MB_CASE_TITLE

MB_CASE_TITLE

MB_CASE_UPPER

MB_CASE_UPPER

MYSQLI_REFRESH_REPLICA

PUBNUB_LIB_BASE_DIR

Functions

uniqid()

describe_type()

Parameters

Tags

Return values

headers_from_lines()

Parameters

Tags

Return values

debug_resource()

Parameters

Tags

Return values

choose_handler()

Tags

Return values

default_user_agent()

Tags

Return values

default_ca_bundle()

Tags

Return values

normalize_header_keys()

Parameters

Tags

Return values

is_host_in_noproxy()

Parameters

Tags

Return values

json_decode()

Parameters

Tags

Return values

json_encode()

Parameters

Tags

Return values

xcallable()

Parameters

deep_copy()

Parameters

defineCompatibilityTokens()

assertArrayHasKey()

Parameters

Tags

assertArrayNotHasKey()

Parameters

Tags

assertContains()

Parameters

Tags

assertContainsEquals()

Parameters

assertNotContains()

Parameters

Tags

assertNotContainsEquals()

Parameters