Documentation

Application

Interfaces

DataInterface
VersionMissingExceptionInterface
ConverterInterface: Interface for a service which converts content from one format (like Markdown) to another (like HTML).
DelimiterInterface
CacheableDelimiterProcessorInterface: Special marker interface for delimiter processors that return dynamic values from getDelimiterUse()
DelimiterProcessorCollectionInterface
DelimiterProcessorInterface: Interface for a delimiter processor
EnvironmentAwareInterface
EnvironmentBuilderInterface: Interface for building the Environment with any extensions, parsers, listeners, etc. that it may need
EnvironmentInterface: Interface for a service which provides a readable configuration object
CommonMarkException: Marker interface for all exceptions thrown by this library.
ConfigurableExtensionInterface
EmbedAdapterInterface: Interface for a service which updates the embed code(s) for the given array of embeds
ExtensionInterface
FrontMatterDataParserInterface
FrontMatterParserInterface
FrontMatterProviderInterface
MentionGeneratorInterface
NormalizerStrategyInterface
TableOfContentsGeneratorInterface
MarkdownInputInterface
MarkdownConverterInterface: Interface for a service which converts Markdown to HTML.
TightBlockInterface
DelimitedInterface
ExpressionInterface
RawMarkupContainerInterface: Interface for a node which contains raw, unprocessed markup (like HTML)
StringContainerInterface: Interface for a node which directly contains line(s) of text
TextNormalizerInterface: Creates a normalized version of the given input text
UniqueSlugNormalizerInterface: Creates a normalized version of the given input text
RenderedContentInterface
BlockContinueParserInterface: Interface for a block continuation parser
BlockContinueParserWithInlinesInterface: Interface for a block continuation parser
BlockStartParserInterface: Interface for a block parser which identifies block starts.
InlineParserInterface
InlineParserEngineInterface: Parser for inline content (text, links, emphasized text, etc).
MarkdownParserInterface
MarkdownParserStateInterface
ReferenceableInterface
ReferenceInterface: Link reference
ReferenceMapInterface: A collection of references
ChildNodeRendererInterface: Renders multiple nodes by delegating to the individual node renderers and adding spacing where needed
DocumentRendererInterface: Renders a parsed Document AST
MarkdownRendererInterface: Renders a parsed Document AST
NodeRendererInterface
XmlNodeRendererInterface
ConfigurationAwareInterface: Implement this class to facilitate setter injection of the configuration where needed
ConfigurationBuilderInterface: An interface that provides the ability to set both the schema and configuration values
ConfigurationInterface: Interface for reading configuration values
ConfigurationProviderInterface: Interface for a service which provides a readable configuration object
ConfigurationExceptionInterface: Marker interface for any/all exceptions thrown by this library
MutableConfigurationInterface: Interface for setting/merging user-defined configuration values into the configuration object
SchemaBuilderInterface: Interface that allows new schemas to be added to a configuration
ByteSequence: Defines constants for common BOM sequences.
Predicate: Enable filtering a record based on its value and/or its offset.
PredicateCombinator: Enable filtering a record based on its value and/or its offset.
Sort: Enable sorting a record based on its value.
SortCombinator: Enable sorting a record based on its value.
SerializationFailed
TypeCasting
TabularData
TabularDataProvider
TabularDataReader: Represents a Tabular data.
TabularDataWriter: A class to insert records into a CSV Document.
UnableToProcessCsv
CanOverwriteFiles: Adapters that implement this interface let the Filesystem know that files can be overwritten using the write functions and don't need the update function to be called. This can help improve performance when asserts are disabled.
AdapterInterface
FilesystemException
FilesystemInterface
PluginInterface
ReadInterface
ExtensionLookup
ExtensionToMimeTypeMap
MimeTypeDetector
Exception: Marker interface for all Tactician exceptions
CommandNameExtractor: Extract the name from a command so that the name can be determined by the context better than simply the class name
HandlerLocator: Service locator for handler objects
MethodNameInflector: Deduce the method name to call on the command handler based on the command and handler instances.
Middleware: Middleware are the plugins of Tactician. They receive each command that's given to the CommandBus and can take any action they choose. Middleware can continue the Command processing by passing the command they receive to the $next callable, which is essentially the "next" Middleware in the chain.
NamedCommand: Exposes a name for a command
AuthorityInterface
Conditionable
DataPathInterface
DomainHostInterface
FragmentDirective
FragmentInterface
HostInterface
IpHostInterface
PathInterface
PortInterface
QueryInterface
SegmentedPathInterface
Transformable
UriAccess
UriComponentInterface
UriException
UriInterface
UserInfoInterface
Calculator
InstructionProcessor: Provide an processor to handle embedded instructions.
EventHandler: Standard events for HTML5.
InputStream: Interface for stream readers.
RulesInterface: To create a new rule set for writing output the RulesInterface needs to be implemented.
FormatterInterface: Interface for formatters
ActivationStrategyInterface: Interface for activation strategies for the FingersCrossedHandler.
FormattableHandlerInterface: Interface to describe loggers that have a formatter
HandlerInterface: Interface that all Monolog Handlers must implement
ProcessableHandlerInterface: Interface to describe loggers that have processors
LogRecord: Monolog log record interface for forward compatibility with Monolog 3.0
ProcessorInterface: An optional interface to allow labelling Monolog processors.
ResettableInterface: Handler or Processor implementing this interface will be reset when Logger::reset() is called.
DynamicParameter
Schema
IHtmlString
ITranslator: Translator adapter.
HtmlStringable
Translator: Translator adapter.
Builder
ErrorHandler
FunctionLike
Node
NodeTraverserInterface
NodeVisitor
Parser
PrettyPrinter
ParseResult
Stream: Represents an input stream. This allows us to have different types of input, each with their own optimizations.
Boolean_
Exception
Requirement
VersionConstraint
Exception
FilesystemInterface
FileSystem
SpecificationFactoryInterface: Interface for Specifications used to filter the FileSystem.
StorageAttributes
PrunableInterface: Interface PrunableInterface
SpecificationInterface: Interface for FlyFinder specifications
CompilerContextInterface
CompilerPass
NodeTransformer
NodeTransformerFactory
MarkupLanguageParser
Target
NodeRenderer
NodeRendererFactory
NodeRendererFactoryAware
PreNodeRenderer
CrossReferenceNode: A cross-reference node is a link node that can reference targets outside of the current document.
InlineNodeInterface
LinkInlineNode
LinkTargetNode
MultipleLinkTargetsNode
Node
OptionalLinkTargetsNode: Makes the implementing node an optional link target. If Noindex is true no references are generated, there is no entry in the objects index and no warning about duplicate ids.
PrefixedLinkTargetNode
AnchorNormalizer: Normalizes raw data used to generate anchors.
DocumentNameResolverInterface
InventoryLoader
InventoryRepository
ReferenceResolver
TypeRenderer
TypeRendererFactory
UrlGeneratorInterface
TemplateRenderer
DiagramRenderer
ParserInterface
Parser
CodeNodeOptionMapper: The directives `code-block` and `literalinclude` both create a CodeNode with the same possible options.
InterlinkParser
FieldListItemRule
CachableInlineRule
InlineRule
Rule
TextRole
TextRoleFactory
Expression
PathNode
QueryNode
Product: Contract between products.
Expression
PathNode
QueryNode
CompilableSubject
CompilerPassInterface: Represents a single pass / business rule to be executed by the Compiler.
DocumentationSetBuilder
Normalizable
Upgradable
MiddlewareInterface
AssemblerInterface
AssemblerReducer: A step in creating descriptors from reflection elements
Descriptor: Base class for descriptors containing the most used options.
Filterable: Interface to determine which elements can be filtered and to provide a way to set errors on the descriptor.
FilterInterface
ArgumentInterface: Describes the public interface for a descriptor of an Argument.
AttributedInterface
AttributeInterface
ChildInterface: Describes the public interface for any descriptor that is the child is another.
ClassInterface: Common interface representing the description of a class.
ConstantInterface: Descriptor representing a constant on a class, trait, property or file.
ContainerInterface: Interface representing the common interface for all elements that can contain sub-elements.
DocblockInterface
ElementInterface: Represents the public interface to which all descriptors should be held.
EnumCaseInterface: Represents the public interface to which all descriptors should be held.
EnumInterface: Common interface representing the description of a class.
FileInterface: Describes the public interface for a description of a File.
FunctionInterface: Descriptor representing a global function in a file.
InheritsFromElement
InterfaceInterface: Represents the public interface for an interface descriptor.
MetadataAwareInterface
MethodInterface: Describes the public interface of the description for a method.
NamespaceInterface: Describes the public interface for the description of a namespace.
PackageInterface: Describes the public interface for a package descriptor.
ProjectInterface: Describes the public interface for the description of a project.
PropertyHookInterface
PropertyInterface: Descriptor representing a property on a class or trait.
TracksErrors
TraitInterface: Public interface definition for object representing traits.
TypeInterface
VisibilityInterface
IsTyped
WithCustomSettings: Declares that the service implementing this interface yields its own settings.
Equals
ExtensionLoader
FileCollector
FileSystemFactory: Interface for FileSystem factories.
SpecificationFactoryInterface: Interface for Specifications used to filter the FileSystem.
PipelineInterface
Processor
Generator
Initializable
ExtensionInterface: An interface shared by all Twig interfaces intended for phpDocumentor.
LinkRendererInterface: Renders an HTML anchor pointing to the location of the provided element.
Metadata
MetaDataContainer
Command: Commands are used by Middleware
Middleware: Middleware can be uses to perform extra steps during the parsing process.
AttributeContainer
Reducer
ProjectFactoryStrategy: Interface for strategies used by the project factory to build Elements out of nodes.
StrategyContainer: Interface for strategy containers.
Packing: This file is part of phpDocumentor.
Valued: Any class implementing this interface has an associated price.
Packing: This file is part of phpDocumentor.
Element: Interface for Api Elements
File: Interface for files processed by the ProjectFactory
Project: Interface for project. Since the definition of a project can be different per factory this interface will be small.
ProjectFactory: Interface for project factories. A project factory shall convert a set of files into an object implementing the Project interface.
Tag
TagFactory
Factory
PHPStanFactory
StaticMethod
Formatter
Reference: Interface for references in {@see \phpDocumentor\Reflection\DocBlock\Tags\See}
DocBlockFactoryInterface
PseudoType
Type
OAuthTokenProvider: OAuthTokenProvider - OAuth2 token provider interface.
ConstExprNode
Node
NodeVisitor: Inspired by https://github.com/nikic/PHP-Parser/tree/36a6dcd04e7b0285e8f0868f44bd4927802f7df1
PhpDocChildNode
PhpDocTagValueNode
TypeNode
CacheException: Exception interface for all exceptions thrown by an Implementing Library.
CacheItemInterface: CacheItemInterface defines an interface for interacting with objects inside a cache.
CacheItemPoolInterface: CacheItemPoolInterface generates CacheItemInterface objects.
InvalidArgumentException: Exception interface for invalid cache arguments.
ClockInterface
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.
EventDispatcherInterface: Defines a dispatcher for events.
ListenerProviderInterface: Mapper from an event to the listeners that are applicable to that event.
StoppableEventInterface: An Event whose processing may be interrupted when the event has been handled.
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.
AdapterInterface: Interface for adapters managing instances of Symfony's CacheItem.
TagAwareAdapterInterface: Interface for invalidating cached items using tags.
MarshallerInterface: Serializes/unserializes PHP values.
PruneableInterface: Interface extends psr-6 and psr-16 caches to allow for pruning (deletion) of all expired cache items.
ResettableInterface: Resets a pool's local state.
ClockInterface
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.
ConfigurableInterface
ConfigurationInterface: Configuration interface.
NodeInterface: Common Interface among all nodes.
PrototypeNodeInterface: This interface must be implemented by nodes which can be used as prototypes.
FileLocatorInterface
DirectoryAwareLoaderInterface: A loader that can be scoped to a given filesystem directory.
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.
SignalableCommandInterface: Interface for command reacting to signal.
CommandLoaderInterface
CompletionOutputInterface: Transforms the {@see CompletionSuggestions} object into output readable by the shell completion.
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.
CacheInterface: Covers most simple to advanced caching needs.
CallbackInterface: Computes and returns the cached value of an item.
ItemInterface: Augments PSR-6's CacheItemInterface with support for tags and metadata.
NamespacedPoolInterface: Enables namespace-based invalidation by prefixing keys with backend-native namespace separators.
TagAwareCacheInterface: Allows invalidating cached items using tags.
EventDispatcherInterface: Allows providing hooks on domain-specific lifecycles by dispatching events.
ChunkInterface: The interface of chunks returned by ResponseStreamInterface::current().
ClientExceptionInterface: When a 4xx response is returned.
DecodingExceptionInterface: When a content-type cannot be decoded to the expected representation.
ExceptionInterface: The base interface for all exceptions in the contract.
HttpExceptionInterface: Base interface for HTTP-related exceptions.
RedirectionExceptionInterface: When a 3xx response is returned and the "max_redirects" option has been reached.
ServerExceptionInterface: When a 5xx response is returned.
TimeoutExceptionInterface: When an idle timeout occurs.
TransportExceptionInterface: When any error happens at the transport level.
HttpClientInterface: Provides flexible methods for requesting HTTP resources synchronously or asynchronously.
ResponseInterface: A (lazily retrieved) HTTP response.
ResponseStreamInterface: Yields response chunks, returned by HttpClientInterface::stream().
ResetInterface: Provides a way to reset an object to its initial state.
ServiceCollectionInterface: A ServiceProviderInterface that is also countable and iterable.
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.
LocaleAwareInterface
TranslatableInterface
TranslatorInterface
ArgumentInterface: Represents a complex argument containing nested values.
CompilerPassInterface: Interface that must be implemented by compilation passes.
ContainerAwareInterface: ContainerAwareInterface should be implemented by classes that depends on a Container.
ContainerInterface: ContainerInterface is the interface implemented by service container classes.
DumperInterface: DumperInterface is the interface implemented by service container dumper classes.
EnvVarLoaderInterface: EnvVarLoaderInterface objects return key/value pairs that are added to the list of available env vars.
EnvVarProcessorInterface: The EnvVarProcessorInterface is implemented by objects that manage environment-like variables.
ExceptionInterface: Base ExceptionInterface for Dependency Injection component.
ConfigurableExtensionInterface
ConfigurationExtensionInterface: ConfigurationExtensionInterface is the interface implemented by container extension classes.
ExtensionInterface: ExtensionInterface is the interface implemented by container extension classes.
PrependExtensionInterface
InstantiatorInterface: Lazy proxy instantiator, capable of instantiating a proxy given a container, the service definitions and a callback that produces the real service instance.
DumperInterface: Lazy proxy dumper capable of generating the instantiation logic PHP code for proxied services.
ContainerBagInterface: ContainerBagInterface is the interface implemented by objects that manage service container parameters.
ParameterBagInterface: ParameterBagInterface is the interface implemented by objects that manage service container parameters.
TaggedContainerInterface: TaggedContainerInterface is the interface implemented when a container knows how to deals with tags.
ExceptionInterface: Interface for exceptions.
EventDispatcherInterface: The EventDispatcherInterface is the central point of Symfony's event listener system.
EventSubscriberInterface: An EventSubscriber knows itself what events it is interested in.
ExpressionFunctionProviderInterface
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.
HtmlSanitizerInterface: Sanitizes an untrusted HTML input for safe insertion into a document's DOM.
ParserInterface: Transforms an untrusted HTML input string into a DOM tree.
AttributeSanitizerInterface: Implements attribute-specific sanitization logic.
NodeInterface: Represents the sanitized version of a DOM node in the sanitized tree.
StreamableInterface
RetryStrategyInterface
Stringable
ExceptionInterface: Marker Interface for the Process Component.
ExceptionInterface: Marker interface for the PropertyAccess component.
PropertyAccessorInterface: Writes and reads values to/from an object/array graph.
PropertyPathInterface: A sequence of property names or array indices.
PropertyPathIteratorInterface
ConstructorArgumentTypeExtractorInterface: Infers the constructor argument type.
PropertyAccessExtractorInterface: Guesses if the property can be accessed or mutated.
PropertyDescriptionExtractorInterface: Guesses the property's human readable description.
PropertyDocBlockExtractorInterface: Extract a property's doc block.
PropertyInfoExtractorInterface: Gets info about PHP class properties.
PropertyInitializableExtractorInterface: Guesses if the property can be initialized through the constructor.
PropertyListExtractorInterface: Extracts the list of properties available for the given class.
PropertyReadInfoExtractorInterface: Extract read information for the property of a class.
PropertyTypeExtractorInterface: Type Extractor Interface.
PropertyWriteInfoExtractorInterface: Extract write information for the property of a class.
ExceptionInterface: ExceptionInterface.
ConfigurableRequirementsInterface: ConfigurableRequirementsInterface must be implemented by URL generators that can be configured whether an exception should be generated when the parameters do not match the requirements. It is also possible to disable the requirements check for URL generation completely.
GeneratorDumperInterface: GeneratorDumperInterface is the interface that all generator dumper classes must implement.
UrlGeneratorInterface: UrlGeneratorInterface is the interface that all URL generator classes must implement.
MatcherDumperInterface: MatcherDumperInterface is the interface that all matcher dumper classes must implement.
RedirectableUrlMatcherInterface: RedirectableUrlMatcherInterface knows how to redirect the user.
RequestMatcherInterface: RequestMatcherInterface is the interface that all request matcher classes must implement.
UrlMatcherInterface: UrlMatcherInterface is the interface that all URL matcher classes must implement.
RequestContextAwareInterface
RouteCompilerInterface: RouteCompilerInterface is the interface that all RouteCompiler classes must implement.
RouterInterface: RouterInterface is the interface that all Router classes must implement.
ExceptionInterface
InflectorInterface
SluggerInterface: Creates a URL-friendly slug from a given string.
ExceptionInterface
CompositeTypeInterface: Represents a type composed of several other types.
WrappingTypeInterface: Represents a type wrapping another type.
TypeResolverInterface: Resolves type for a given subject.
ExceptionInterface
LazyObjectInterface
ExceptionInterface: Exception interface for all exceptions thrown by the component.
CacheInterface: Interface implemented by cache classes.
RemovableCacheInterface
ExpressionParserDescriptionInterface
ExpressionParserInterface
InfixExpressionParserInterface
PrefixExpressionParserInterface
ExtensionInterface: Interface implemented by extension classes.
GlobalsInterface: Allows Twig extensions to add globals to the context.
LastModifiedExtensionInterface: Interface implemented by extension classes.
RuntimeExtensionInterface
LoaderInterface: Interface all loaders must implement.
OperatorEscapeInterface: Interface implemented by n-ary operators for n > 1.
ReturnArrayInterface
ReturnBoolInterface
ReturnNumberInterface
ReturnPrimitiveTypeInterface
ReturnStringInterface
SupportDefinedTestInterface: Interface implemented by expressions that support the defined test.
NodeCaptureInterface: Represents a node that captures any nested displayable nodes.
NodeOutputInterface: Represents a displayable node in the AST.
NodeVisitorInterface: Interface for node visitor classes.
RuntimeLoaderInterface: Creates runtime implementations for Twig elements (filters/functions/tests).
SecurityPolicyInterface: Interface that all security policy classes must implements.
SourcePolicyInterface: Interface for a class that can optionally enable the sandbox mode based on a template's Twig\Source.
TokenParserInterface: Interface implemented by token parsers.
TwigCallableInterface
ExceptionInterface
LoaderInterface
ParserInterface
AdapterInterface
ReaderInterface
WriterInterface
RepositoryInterface
StoreInterface

Classes

Controller: Základní třída Controller.
Controller_Admin: Kontroler pro administrátorskou sekci.
Controller_Garage: Kontroler zajišťující správu virtuální garáže uživatele i administrátora.
Controller_Security: Kontroler zajišťující bezpečnostní mechanismy aplikace.
Controller_User: Kontroler pro správu uživatelských účtů.
Model: Třída Model zajišťuje veškerou komunikaci s MySQL databází.
Router: Třída Router zajišťuje směrování (routing) v aplikaci.
ComposerAutoloaderInit2185d2f99bcd56787481d9357a5972d3
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
Data
DataException: Base runtime exception type thrown by this library
InvalidPathException: Thrown when trying to access an invalid path in the data array
MissingPathException: Thrown when trying to access a path that does not exist
Util
Deprecation: Manages Deprecation logging in different ways.
AbstractLexer: Base class for writing simple lexers, i.e. for creating small DSLs.
Token
Error
Result
Success
ProvidedPackageException
ReplacedPackageException
PrettyVersions
Version
CommonMarkConverter: Converts CommonMark-compatible Markdown to HTML.
Bracket
Delimiter
DelimiterStack
DelimiterProcessorCollection
Environment
AbstractEvent: Base class for classes containing event data.
DocumentParsedEvent: Event dispatched when the document has been fully parsed
DocumentPreParsedEvent: Event dispatched when the document is about to be parsed
DocumentPreRenderEvent: Event dispatched just before rendering begins
DocumentRenderedEvent: Base class for classes containing event data.
AlreadyInitializedException
InvalidArgumentException
IOException
LogicException
MissingDependencyException
UnexpectedEncodingException
AttributesExtension
AttributesListener
Attributes: Block-level element
AttributesInline
AttributesBlockContinueParser: Base class for a block parser
AttributesBlockStartParser
AttributesInlineParser
AutolinkExtension
EmailAutolinkParser
UrlAutolinkParser
CommonMarkCoreExtension
EmphasisDelimiterProcessor
BlockQuote: Block-level element
FencedCode: Block-level element
Heading: Block-level element
HtmlBlock: Block-level element
IndentedCode: Block-level element
ListBlock: Block-level element
ListData
ListItem: Block-level element
ThematicBreak: Block-level element
AbstractWebResource
Code
Emphasis
HtmlInline
Image
Link
Strong
BlockQuoteParser: Base class for a block parser
BlockQuoteStartParser
FencedCodeParser: Base class for a block parser
FencedCodeStartParser
HeadingParser: Base class for a block parser
HeadingStartParser
HtmlBlockParser: Base class for a block parser
HtmlBlockStartParser
IndentedCodeParser: Base class for a block parser
IndentedCodeStartParser
ListBlockParser: Base class for a block parser
ListBlockStartParser
ListItemParser: Base class for a block parser
ThematicBreakParser: Base class for a block parser
ThematicBreakStartParser
AutolinkParser
BacktickParser
BangParser
CloseBracketParser
EntityParser
EscapableParser
HtmlInlineParser
OpenBracketParser
BlockQuoteRenderer
FencedCodeRenderer
HeadingRenderer
HtmlBlockRenderer
IndentedCodeRenderer
ListBlockRenderer
ListItemRenderer
ThematicBreakRenderer
CodeRenderer
EmphasisRenderer
HtmlInlineRenderer
ImageRenderer
LinkRenderer
StrongRenderer
ApplyDefaultAttributesProcessor
DefaultAttributesExtension
DescriptionListExtension
ConsecutiveDescriptionListMerger
LooseDescriptionHandler
Description: Block-level element
DescriptionList: Block-level element
DescriptionTerm: Block-level element
DescriptionContinueParser: Base class for a block parser
DescriptionListContinueParser: Base class for a block parser
DescriptionStartParser
DescriptionTermContinueParser: Base class for a block parser
DescriptionListRenderer
DescriptionRenderer
DescriptionTermRenderer
DisallowedRawHtmlExtension
DisallowedRawHtmlRenderer
OscaroteroEmbedAdapter
DomainFilteringAdapter
Embed: Block-level element
EmbedExtension
EmbedParser
EmbedProcessor
EmbedRenderer
EmbedStartParser
ExternalLinkExtension
ExternalLinkProcessor
AnonymousFootnotesListener
FixOrphanedFootnotesAndRefsListener
GatherFootnotesListener
NumberFootnotesListener
FootnoteExtension
Footnote: Block-level element
FootnoteBackref: Link from the footnote on the bottom of the document back to the reference
FootnoteContainer: Block-level element
FootnoteRef
AnonymousFootnoteRefParser
FootnoteParser: Base class for a block parser
FootnoteRefParser
FootnoteStartParser
FootnoteBackrefRenderer
FootnoteContainerRenderer
FootnoteRefRenderer
FootnoteRenderer
LibYamlFrontMatterParser
SymfonyYamlFrontMatterParser
InvalidFrontMatterException
FrontMatterExtension
FrontMatterParser
MarkdownInputWithFrontMatter
FrontMatterPostRenderListener
FrontMatterPreParser
RenderedContentWithFrontMatter
GithubFlavoredMarkdownExtension
HeadingPermalink: Represents an anchor link within a heading
HeadingPermalinkExtension: Extension which automatically anchor links to heading elements
HeadingPermalinkProcessor: Searches the Document for Heading elements and adds HeadingPermalinks to each one
HeadingPermalinkRenderer: Renders the HeadingPermalink elements
HighlightExtension
Mark
MarkDelimiterProcessor
MarkRenderer
ChildRenderer: Simply renders child elements as-is, adding newlines as needed.
InlinesOnlyExtension
CallbackGenerator
StringTemplateLinkGenerator
Mention
MentionExtension
MentionParser
DashParser
EllipsesParser
Quote
QuoteParser
QuoteProcessor
ReplaceUnpairedQuotesListener: Identifies any lingering Quote nodes that were missing pairs and converts them into Text nodes
SmartPunctExtension
Strikethrough
StrikethroughDelimiterProcessor
StrikethroughExtension
StrikethroughRenderer
Table: Block-level element
TableCell: Block-level element
TableCellRenderer
TableExtension
TableParser: Base class for a block parser
TableRenderer
TableRow: Block-level element
TableRowRenderer
TableSection: Block-level element
TableSectionRenderer
TableStartParser
TableOfContents: Block-level element
TableOfContentsPlaceholder: Block-level element
AsIsNormalizerStrategy
FlatNormalizerStrategy
RelativeNormalizerStrategy
TableOfContentsBuilder
TableOfContentsExtension
TableOfContentsGenerator
TableOfContentsPlaceholderParser: Base class for a block parser
TableOfContentsPlaceholderRenderer
TableOfContentsRenderer
TaskListExtension
TaskListItemMarker
TaskListItemMarkerParser
TaskListItemMarkerRenderer
GithubFlavoredMarkdownConverter: Converts GitHub Flavored Markdown to HTML.
MarkdownInput
MarkdownConverter
AbstractBlock: Block-level element
Document: Block-level element
Paragraph: Block-level element
AbstractInline
AbstractStringContainer
Newline
Text
Node
NodeIterator
NodeWalker
NodeWalkerEvent
Query
StringContainerHelper
SlugNormalizer: Creates URL-friendly strings based on the given string input
TextNormalizer
UniqueSlugNormalizer
RenderedContent
AbstractBlockContinueParser: Base class for a block parser
BlockContinue: Result object for continuing parsing of a block; see static methods for constructors.
BlockStart: Result object for starting parsing of a block; see static methods for constructors
DocumentBlockParser: Parser implementation which ensures everything is added to the root-level Document
ParagraphParser: Base class for a block parser
Cursor
InlineParserMatch
NewlineParser
InlineParserContext
MarkdownParser
ParserLogicException
MemoryLimitedReferenceMap
Reference
ReferenceMap: A collection of references, indexed by label
ReferenceParser
DocumentRenderer
ParagraphRenderer
HtmlDecorator
HtmlRenderer
NewlineRenderer
TextRenderer
NoMatchingRendererException
Html5EntityDecoder
HtmlElement
HtmlFilter
LinkParserHelper
RegexHelper: Provides regular expressions and utilities for parsing Markdown
SpecReader: Reads in a CommonMark spec document and extracts the input/output examples for testing against them
UrlEncoder
Xml: Utility class for handling/generating XML and HTML
MarkdownToXmlConverter
XmlRenderer
Configuration
InvalidConfigurationException
UnknownOptionException
ValidationException
ReadOnlyConfiguration: Provides read-only access to a given Configuration object
AbstractCsv: An abstract class to enable CSV document loading.
Buffer
CallbackStreamFilter
CannotInsertRecord: Thrown when a data is not added to the Csv Document.
CharsetConverter: Converts resource stream or tabular data content charset.
ColumnConsistency: Validates column consistency when inserting records into a CSV document.
EncloseField: A stream filter to improve enclosure character usage.
EnumFormatter: Formatting strategies (exclusive): - Name (UnitEnum::name) - Value (BackedEnum::value) - JSON (JsonSerializable) - callback
EscapeFormula: A Formatter to tackle CSV Formula Injection.
Exception: League Csv Base Exception.
FragmentFinder: EXPERIMENTAL WARNING! This class implementation will change in the next major point release.
FragmentNotFound
HTMLConverter: Converts tabular data into an HTML Table string.
Info
InvalidArgument: InvalidArgument Exception.
JsonConverter: Converts and store tabular data into a JSON string.
Column: Enable filtering a record based on the value of a one of its cell.
Criteria
Offset: Enable filtering a record based on its offset.
TwoColumns: Enable filtering a record by comparing the values of two of its column.
Limit
Column: Enable sorting a record based on the value of a one of its cell.
MultiSort: Enable sorting a record based on multiple column.
QueryException
Row
RdbmsResult
Reader: A class to parse and read records from a CSV document.
ResultSet: Represents the result set of a {@link Reader} processed by a {@link Statement}.
RFC4180Field: A stream filter to conform the CSV field to RFC4180.
AfterMapping
CastToArray
CastToBool
CastToDate
CastToEnum
CastToFloat
CastToInt
CastToString
DenormalizationFailed
Denormalizer
MapCell
MappingFailed
MapRecord
TypeCastingFailed
TypeCastingInfo
Statement: Criteria to filter a {@link TabularData} object.
StreamFilter
SwapDelimiter
SyntaxError: SyntaxError Exception.
UnavailableFeature: StreamFilterSupportMissing Exception.
UnavailableStream: League Csv Base Exception.
Writer: A class to insert records into a CSV Document.
XMLConverter: Converts tabular data into a DOMDocument object.
AbstractAdapter
AbstractFtpAdapter
Ftp
Ftpd
Local
NullAdapter
SynologyFtp
Config
ConnectionErrorException
ConnectionRuntimeException
CorruptedPathDetected
Directory
Exception
File
FileExistsException
FileNotFoundException
Filesystem
FilesystemNotFoundException: Thrown when the MountManager cannot find a filesystem.
Handler
InvalidRootException
MountManager: Class MountManager.
NotSupportedException
AbstractPlugin
EmptyDir
ForcedCopy
ForcedRename
GetWithMetadata
ListFiles
ListPaths
ListWith
PluginNotFoundException
RootViolationException
SafeStorage
UnreadableFileException
StreamHasher
Util
EmptyExtensionToMimeTypeMap
ExtensionMimeTypeDetector
FinfoMimeTypeDetector
GeneratedExtensionToMimeTypeMap
OverridingExtensionToMimeTypeMap
CommandBus: Receives a command and sends it through a chain of middleware for processing.
CanNotDetermineCommandNameException: Thrown when a CommandNameExtractor cannot determine the command's name
CanNotInvokeHandlerException: Thrown when a specific handler object can not be used on a command object.
InvalidCommandException: Thrown when the command bus is given an non-object to use as a command.
InvalidMiddlewareException: Thrown when the CommandBus was instantiated with an invalid middleware object
MissingHandlerException: No handler could be found for the given command.
CommandHandlerMiddleware: The "core" CommandBus. Locates the appropriate handler and executes command.
ClassNameExtractor: Extract the name from the class
CallableLocator: This locator loads Handlers from a provided callable.
InMemoryLocator: Fetch handler instances from an in-memory collection.
ClassNameInflector: Assumes the method is only the last portion of the class name.
HandleClassNameInflector: Assumes the method is handle + the last portion of the class name.
HandleClassNameWithoutSuffixInflector: Returns a method name that is handle + the last portion of the class name but also without a given suffix, typically "Command". This allows you to handle multiple commands on a single object but with slightly less annoying method names.
HandleInflector: Handle command by calling the "handle" method.
InvokeInflector: Handle command by calling the __invoke magic method. Handy for single use classes or closures.
LockingMiddleware: If another command is already being executed, locks the command bus and queues the new incoming commands until the first has completed.
NamedCommandExtractor: Extract the name from a NamedCommand
QuickStart: Builds a working command bus with minimum fuss.
BaseUri
Builder
Http
HttpFactory
Uri
UriInfo
UriResolver
TemplateCanNotBeExpanded
Urn
Encoder
ConversionFailed
MissingFeature
OffsetOutOfBounds
SyntaxError
FeatureDetection: Allow detecting features needed to make the packages work.
HostRecord
Converter
Option
Result
BCMathCalculator
Converter
GMPCalculator
NativeCalculator
Converter
Converter
QueryString: A class to parse the URI query string.
Elements: This class provides general information about HTML5 elements, including syntactic and semantic issues.
Entities: Entity lookup tables.
Exception: The base exception for the HTML5 project.
CharacterReference: Manage entity references.
DOMTreeBuilder: Create an HTML5 DOM tree from events.
FileInputStream: The FileInputStream loads a file to be parsed.
ParseError: Emit when the parser has an error.
Scanner: The scanner scans over a given data input to react appropriately to characters.
StringInputStream
Tokenizer: The HTML5 tokenizer.
TreeBuildingRules: Handles special-case rules for the DOM tree builder.
UTF8Utils
HTML5Entities: A mapping of entities to their html5 representation.
OutputRules: Generate the output html5 based on element rules.
Traverser: Traverser for walking a DOM tree.
HTML5: This class offers convenience methods for parsing and serializing HTML5.
AsMonologProcessor: A reusable attribute to help configure a class or a method as a processor.
DateTimeImmutable: Overrides default json encoding of date time objects
ErrorHandler: Monolog error handler
ChromePHPFormatter: Formats a log message according to the ChromePHP array format
ElasticaFormatter: Format a log message into an Elastica Document
ElasticsearchFormatter: Format a log message into an Elasticsearch record
FlowdockFormatter: formats the record to be used in the FlowdockHandler
FluentdFormatter: Class FluentdFormatter
GelfMessageFormatter: Serializes a log message to GELF
GoogleCloudLoggingFormatter: Encodes message information into JSON in a format compatible with Cloud logging.
HtmlFormatter: Formats incoming records into an HTML table
JsonFormatter: Encodes whatever record data is passed to it as json
LineFormatter: Formats incoming records into a one-line string
LogglyFormatter: Encodes message information into JSON in a format compatible with Loggly.
LogmaticFormatter: Encodes message information into JSON in a format compatible with Logmatic.
LogstashFormatter: Serializes a log message to Logstash Event Format
MongoDBFormatter: Formats a record for use with the MongoDBHandler.
NormalizerFormatter: Normalizes incoming records to remove objects/resources so it's easier to dump to various targets
ScalarFormatter: Formats data into an associative array of scalar values.
WildfireFormatter: Serializes a log message according to Wildfire's header requirements
AbstractHandler: Base Handler class providing basic level/bubble support
AbstractProcessingHandler: Base Handler class providing the Handler structure, including processors and formatters
AbstractSyslogHandler: Common syslog functionality
AmqpHandler: Base Handler class providing the Handler structure, including processors and formatters
BrowserConsoleHandler: Handler sending logs to browser's javascript console with no browser extension required
BufferHandler: Buffers all records until closing the handler and then pass them as batch.
ChromePHPHandler: Handler sending logs to the ChromePHP extension (http://www.chromephp.com/)
CouchDBHandler: CouchDB handler
CubeHandler: Logs to Cube.
DeduplicationHandler: Simple handler wrapper that deduplicates log records across multiple requests
DoctrineCouchDBHandler: CouchDB handler for Doctrine CouchDB ODM
DynamoDbHandler: Amazon DynamoDB handler (http://aws.amazon.com/dynamodb/)
ElasticaHandler: Elastic Search handler
ElasticsearchHandler: Elasticsearch handler
ErrorLogHandler: Stores to PHP error_log() handler.
FallbackGroupHandler: Forwards records to at most one handler
FilterHandler: Simple handler wrapper that filters records based on a list of levels
ChannelLevelActivationStrategy: Channel and Error level based monolog activation strategy. Allows to trigger activation based on level per channel. e.g. trigger activation on level 'ERROR' by default, except for records of the 'sql' channel; those should trigger activation on level 'WARN'.
ErrorLevelActivationStrategy: Error level based activation strategy.
FingersCrossedHandler: Buffers all records until a certain level is reached
FirePHPHandler: Simple FirePHP Handler (http://www.firephp.org/), which uses the Wildfire protocol.
FleepHookHandler: Sends logs to Fleep.io using Webhook integrations
FlowdockHandler: Sends notifications through the Flowdock push API
GelfHandler: Handler to send messages to a Graylog2 (http://www.graylog2.org) server
GroupHandler: Forwards records to multiple handlers
Handler: Base Handler class providing basic close() support as well as handleBatch
HandlerWrapper: This simple wrapper class can be used to extend handlers functionality.
IFTTTHandler: IFTTTHandler uses cURL to trigger IFTTT Maker actions
InsightOpsHandler: Inspired on LogEntriesHandler.
LogEntriesHandler: Stores to any socket - uses fsockopen() or pfsockopen().
LogglyHandler: Sends errors to Loggly.
LogmaticHandler: Stores to any socket - uses fsockopen() or pfsockopen().
MailHandler: Base class for all mail handlers
MandrillHandler: MandrillHandler uses cURL to send the emails to the Mandrill API
MissingExtensionException: Exception can be thrown if an extension for a handler is missing
MongoDBHandler: Logs to a MongoDB database.
NativeMailerHandler: NativeMailerHandler uses the mail() function to send the emails
NewRelicHandler: Class to record a log on a NewRelic application.
NoopHandler: No-op
NullHandler: Blackhole
OverflowHandler: Handler to only pass log messages when a certain threshold of number of messages is reached.
PHPConsoleHandler: Monolog handler for Google Chrome extension "PHP Console"
ProcessHandler: Stores to STDIN of any process, specified by a command.
PsrHandler: Proxies log messages to an existing PSR-3 compliant logger.
PushoverHandler: Sends notifications through the pushover api to mobile phones
RedisHandler: Logs to a Redis key using rpush
RedisPubSubHandler: Sends the message to a Redis Pub/Sub channel using PUBLISH
RollbarHandler: Sends errors to Rollbar
RotatingFileHandler: Stores logs to files that are rotated every day and a limited number of files are kept.
SamplingHandler: Sampling handler
SendGridHandler: SendGridrHandler uses the SendGrid API v2 function to send Log emails, more information in https://sendgrid.com/docs/API_Reference/Web_API/mail.html
SlackRecord: Slack record utility helping to log to Slack webhooks or API.
SlackHandler: Sends notifications through Slack API
SlackWebhookHandler: Sends notifications through Slack Webhooks
SocketHandler: Stores to any socket - uses fsockopen() or pfsockopen().
SqsHandler: Writes to any sqs queue.
StreamHandler: Stores to any stream resource
SwiftMailerHandler: SwiftMailerHandler uses Swift_Mailer to send the emails
SymfonyMailerHandler: SymfonyMailerHandler uses Symfony's Mailer component to send the emails
SyslogHandler: Logs to syslog service.
UdpSocket
SyslogUdpHandler: A Handler for logging to a remote syslogd server.
TelegramBotHandler: Handler send logs to Telegram using Telegram Bot API.
TestHandler: Used for testing purposes.
WhatFailureGroupHandler: Forwards records to multiple handlers suppressing failures of each handler and continuing through to give every handler a chance to succeed.
ZendMonitorHandler: Handler sending logs to Zend Monitor
Logger: Monolog log channel
GitProcessor: Injects Git branch and Git commit SHA in all records
HostnameProcessor: Injects value of gethostname in all records
IntrospectionProcessor: Injects line/file:class/function where the log message came from
MemoryPeakUsageProcessor: Injects memory_get_peak_usage in all records
MemoryProcessor: Some methods that are common for all memory processors
MemoryUsageProcessor: Injects memory_get_usage in all records
MercurialProcessor: Injects Hg branch and Hg revision number in all records
ProcessIdProcessor: Adds value of getmypid into records
PsrLogMessageProcessor: Processes a record's message according to PSR-3 rules
TagProcessor: Adds a tags array into record
UidProcessor: Adds a unique identifier into records
WebProcessor: Injects url/method and remote IP of the current web request in all records
Registry: Monolog log registry
SignalHandler: Monolog POSIX signal handler
Utils
Context
AnyOf
Structure
Type
Expect: Schema generator.
Message
Processor: Schema validator.
ValidationException: Validation error.
ArgumentOutOfRangeException: The value is outside the allowed range.
InvalidStateException: The object is in a state that does not allow the requested operation.
NotImplementedException: The requested feature is not implemented.
NotSupportedException: The requested operation is not supported.
DeprecatedException: The requested feature is deprecated and no longer available.
MemberAccessException: Cannot access the requested class property or method.
IOException: Failed to read from or write to a file or stream.
FileNotFoundException: The requested file does not exist.
DirectoryNotFoundException: The requested directory does not exist.
InvalidArgumentException: The provided argument has invalid type or format.
OutOfRangeException: The requested array or collection index does not exist.
UnexpectedValueException: The returned value has unexpected type or format.
ShouldNotHappenException: Houston, we have a problem.
CachingIterator: Smarter caching iterator.
Mapper
ArrayHash: Provides objects to work as array.
ArrayList: Provides the base class for a generic list (items can be accessed by index).
Arrays: Array tools library.
Callback: PHP callable tools.
DateTime: DateTime.
ImageException: An error occurred while working with the image.
UnknownImageFileException: The image file is invalid or in an unsupported format.
JsonException: JSON encoding or decoding failed.
RegexpException: Regular expression pattern or execution failed.
AssertionException: Type validation failed. The value doesn't match the expected type constraints.
FileSystem: File system tool.
Finder: Finder allows searching through directory trees using iterator.
Floats: Floating-point numbers comparison.
Helpers
Html: HTML helper.
Image: Basic manipulation with images. Supported types are JPEG, PNG, GIF, WEBP, AVIF and BMP.
ImageColor: Represent RGB color (0..255) with opacity (0..1).
ImageType: Type of image file.
Iterables: Utilities for iterables.
Json: JSON encoder and decoder.
Paginator: Paginating math.
Random: Secure random string generator.
Reflection: PHP reflection helpers.
Strings: String tools library.
Type: PHP type reflection.
Validators: Validation utilities.
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
AsymmetricVisibilityTokenEmulator
AttributeEmulator
EnumTokenEmulator
ExplicitOctalEmulator
KeywordEmulator
MatchTokenEmulator
NullsafeTokenEmulator
PipeOperatorEmulator
PropertyTokenEmulator
ReadonlyFunctionTokenEmulator
ReadonlyTokenEmulator
ReverseEmulator: Reverses emulation direction of the inner emulator.
VoidCastEmulator
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
ArrayItem: For classmap-authoritative support.
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
Pipe
Plus
Pow
ShiftLeft
ShiftRight
Smaller
SmallerOrEqual
Spaceship
BinaryOp
BitwiseNot
BooleanNot
CallLike
Array_
Bool_
Double
Int_
Object_
String_
Unset_
Void_
Cast
ClassConstFetch
Clone_
Closure
ClosureUse: For classmap-authoritative support.
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
PropertyHook
PropertyItem
DNumber: For classmap-authoritative support.
Encapsed: For classmap-authoritative support.
EncapsedStringPart: For classmap-authoritative support.
Float_
Int_
InterpolatedString
LNumber: For classmap-authoritative support.
Class_
Dir
File
Function_
Line
Method
Namespace_
Property
Trait_
MagicConst
String_
Scalar
StaticVar
Block
Break_
Case_
Catch_
Class_
ClassConst
ClassLike
ClassMethod
Const_
Continue_
Declare_
DeclareDeclare: For classmap-authoritative support.
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
PropertyProperty: For classmap-authoritative support.
Return_
Static_
StaticVar: For classmap-authoritative support.
Switch_
Trait_
TraitUse
Alias
Precedence
TraitUseAdaptation
TryCatch
Unset_
Use_
UseUse: For classmap-authoritative support.
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.
JsonType
TokenType
Json
JSONBench
ManyBench
Placeholder: This class is created simply to define a special type for the placeholder. As defining a constant, even a random one, could collide with other values.
EndOfStream
Position: File, line, and column position of the parser.
JSON: JSON parser and utility parsers
Parser: A parser is any function that takes a string input and returns a {@see ParseResult}. The Parser class is a wrapper around such functions. The {@see Parser::make()} static constructor takes a callable that does the actual parsing.
ParserHasFailed
StringStream
assembleTest
charactersTest
combinatorsTest
CurryTest
TestSubject
BooleanExpressionsTest
True_
False_
Not_
And_
Or_
CalculatorTest: Parse expressions and calculate the result
ExcelTest
Cell
Range
Intersection
Sum
Ampersand
SimpleDateTest
ExpressionsTest
CurryTest
FoldrTest
PositionTest
StringStreamTest
GH26_Test: https://github.com/mathiasverraes/parsica/issues/6
ArrayTest
JSONTest
NumberTest
ObjectTest
StringLiteralTest
TokenTest
WhitespaceTest
numericTest
AlternativeTest
AppendTest
NotASemigroup
ApplicativeTest
FunctorTest
MyType1
SimpleEur
LabelTest
MonadTest
ParserTest
RunningParsersTest
unicodeTest
AppendTest
ErrorReportingTest
FunctorTest
ParseResultTest
ParserTestCaseTest
MyType
PolishNotationTest
predicatesTest
primitivesTest
recursionTest
sideEffectsTest
Cache
spaceTest
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
FileNotFoundException
Exclude
SpecificationFactory: Factory class to build Specification used by FlyFinder when reading files to process.
FlySystemAdapter
FlysystemV1
StorageAttributes
FileAttributes
FlysystemV3
MethodNotAllowedException
Path: Value Object for paths.
Finder: Flysystem plugin to add file finding capabilities to the filesystem entity.
Path: Value Object for paths.
AndSpecification: Base class for specifications, allows for combining specifications
CompositeSpecification: Base class for specifications, allows for combining specifications
Glob: Glob specification class
HasExtension: Files and directories meet the specification if they have the given extension
InPath: Files *and directories* meet the specification if they are in the given path.
IsHidden: Files or directories meet the specification if they are hidden
NotSpecification: Base class for specifications, allows for combining specifications
OrSpecification: Base class for specifications, allows for combining specifications
FindHiddenFilesTest: Integration test against examples/01-find-hidden-files.php
FindOnMultipleCriteriaTest: Integration test against examples/02-find-on-multiple-criteria.php
FindOnSamplePhpdocLayoutTest: Integration test against examples/03-sample-phpdoc-layout.php
FindOnSamplePhpdocLayoutUsingGlobTest: Integration test against examples/04-sample-phpdoc-layout-using-glob.php
FinderTest: Test case for Finder
PathTest: Test case for Path
AndSpecificationTest: Test case for AndSpecification
CompositeSpecificationTest: Test case for CompositeSpecification
GlobTest
HasExtensionTest: Test case for HasExtension
InPathTest: Test case for InPath
IsHiddenTest: Test case for IsHidden
NotSpecificationTest: Test case for NotSpecification
OrSpecificationTest: Test case for OrSpecification
Attribute: Class representing a single GraphViz attribute.
AttributeNotFound: Class representing an exception in this GraphViz component.
Edge: Class representing an edge (arrow, line).
Exception: Class representing an exception in this GraphViz component.
Graph: Class representing a graph; this may be a main graph but also a subgraph.
Node: Class representing a node / element in a graph.
AttributeGetterMethodReflection
AttributeSetterMethodReflection
GraphNodeReflectionExtension
MethodReflectionExtension
AttributeTest: Test for the the class representing a GraphViz attribute.
EdgeTest: Test for the the class representing a GraphViz edge (vertex).
GraphTest: Test for the the class representing a GraphViz graph.
NodeTest: Test for the the class representing a GraphViz node.
MethodReflectionExtensionTest
Compiler
CompilerContext: Context class used in compiler passes to store the state of the nodes.
DocumentNodeTraverser
CitationInlineNodeTransformer
CitationTargetTransformer
ClassNodeTransformer
CollectLinkTargetsTransformer
CustomNodeTransformerFactory
DocumentBlockNodeTransformer
DocumentEntryRegistrationTransformer
FootNodeNamedTransformer
FootNodeNumberedTransformer
FootnoteInlineNodeTransformer
ListNodeTransformer
AbstractMenuEntryNodeTransformer
ContentsMenuEntryNodeTransformer
ExternalMenuEntryNodeTransformer
GlobMenuEntryNodeTransformer
InternalMenuEntryNodeTransformer
SubInternalMenuEntryNodeTransformer
TocNodeReplacementTransformer
TocNodeTransformer
ToctreeSortingTransformer
MoveAnchorTransformer
RawNodeEscapeTransformer
SectionCreationTransformer
SectionEntryRegistrationTransformer
TransformerPass: The TransformerPass is a special kind of CompilerPass that traverses all documents and Calls the DocumentNodeTraverser for each.
VariableInlineNodeTransformer
AutomaticMenuPass
GlobalMenuPass
ImplicitHyperlinkTargetPass: Resolves the hyperlink target for each section in the document.
ToctreeValidationPass
TreeNode
CommandLocator
NodeRendererPass
ParserRulesPass
RendererPass
GuidesExtension: Provides useful features shared by many extensions.
TestExtension: Provides useful features shared by many extensions.
ModifyDocumentEntryAdditionalData
PostCollectFilesForParsingEvent: This event is called after all files have been collected for parsing But before the actual parsing begins.
PostParseDocument: This event is called after the parsing of each document is completed by the responsible extension.
PostParseProcess: This event is dispatched right after the overall parsing process is finished, Before the compiler passes, including the node transformers are called.
PostProjectNodeCreated
PostRenderDocument: This event is called after the rendering of each document.
PostRenderProcess: This event is called once after each rendering method after all documents have been rendered.
PreParseDocument: This event is called before the parsing of each document is passed to the responsible extension.
PreParseProcess: This event is dispatched right before the overall parsing process is started.
PreRenderDocument: This event is called before the rendering of each document.
PreRenderProcess: This event is called once before each rendering method after all documents have been parsed and all compiler passes (including node transformers have been called.)
LoadSettingsFromComposer
DocumentEntryNotFound
DuplicateLinkAnchorException
InvalidTableStructure
FileCollector
Files
CompileDocumentsCommand
CompileDocumentsHandler
LoadCacheCommand
LoadCacheHandler
ParseDirectoryCommand
ParseDirectoryHandler
ParseFileCommand
ParseFileHandler
PersistCacheCommand
PersistCacheHandler
RenderCommand
RenderDocumentCommand
RenderDocumentHandler
RenderHandler
AnnotationTarget
CitationTarget
ExternalTarget
FootnoteTarget
InternalTarget
DefaultNodeRenderer
DelegatingNodeRenderer
AdmonitionNodeRenderer
BreadCrumbNodeRenderer
DocumentNodeRenderer
MenuEntryRenderer
MenuNodeRenderer
TableNodeRenderer
InMemoryNodeRendererFactory
TableNodeRenderer
TitleNodeRenderer
TocNodeRenderer
LazyNodeRendererFactory
OutputAwareDelegatingNodeRenderer
PreNodeRendererFactory: Decorator to add pre-rendering logic to node renderers.
PreRenderer
TemplateNodeRenderer
AbstractNode
AdmonitionNode
AnchorNode
AnnotationListNode: Defines a list of footnotes or citations
AnnotationNode: Defines a footnote or citation
AuthorNode: The author element holds the name of the author of a document, section or code-block
BreadCrumbNode
CitationNode: Defines a citation that can be referenced by an CitationInlineNode
ClassNode
CodeNode
CollectionNode: A collection node is a node that renders all its children without adding a wrap. It is used by directives, that change sub-nodes without having an output of their own, like the class-directive.
CompoundNode
ConfigurationBlockNode
ConfigurationTab
DefinitionListNode
DefinitionListItemNode
DefinitionNode
DocumentBlockNode
DocumentNode
DocumentEntryNode
EntryNode
ExternalEntryNode
SectionEntryNode
EmbeddedFrame
FieldListNode
FieldListItemNode
FigureNode
FootnoteNode: Defines a footnote that can be referenced by an FootnoteInlineNode
GenericNode: Any Directive not explicitly modeled.
ImageNode
AbbreviationInlineNode
AbstractLinkInlineNode
AnnotationInlineNode: This node an annotation, for example citation or footnote
CitationInlineNode: This node represents a citation inline a text
DocReferenceNode: Represents a link to document
EmphasisInlineNode
FootnoteInlineNode: This node represents a footnote inline a text
GenericTextRoleInlineNode
HyperLinkNode: Represents a link to an external source or email
ImageInlineNode: In some Markup languages like Markdown Images are always considered inline. They can appear anywhere in a paragraph.
InlineNode
LiteralInlineNode
NewlineInlineNode
PlainTextInlineNode
ReferenceNode: CrossReferences are references outside a document. As parsing is file based normal references are in document, refering to other documents.
StrongInlineNode
VariableInlineNode
WhitespaceInlineNode
InlineCompoundNode
InvalidLink
Link
ListItemNode: Represents a single item of a bullet or enumerated list.
ListNode
ListItem
LiteralBlockNode
MainNode
MathNode
ContentMenuNode
ExternalMenuEntryNode
GlobMenuEntryNode: Represents a menu entry that can be replaced by multiple InternalMenuEntryNodes during compilation. The url contains a string here. It cannot be rendered.
InternalMenuEntryNode
MenuDefinitionLineNode: This node contains the result of parsing the menu entries for a menu.
MenuEntryNode
MenuNode
NavMenuNode
SectionMenuEntryNode
TocNode
AddressNode: The address element holds the surface mailing address information for the author (individual or group) of the document, or a third-party contact address. Its structure is identical to that of the literal_block element: whitespace is significant, especially newlines.
AuthorNode: The author element holds the name of the author of the document.
AuthorsNode: The authors element is a container for author information for documents with multiple authors.
ContactNode: The contact element holds contact information for the author (individual or group) of the document, or a third-party contact. It is typically used for an email or web address.
CopyrightNode: The copyright element contains the document's copyright statement.
DateNode: The date node contains the date of publication, release, or last modification of the document.
MetadataNode
MetaNode
NavigationTitleNode: The organization element contains the name of document author's organization, or the organization responsible for the document.
NoCommentsNode: If set, the web application won’t display a comment form for a page generated from this source file
NoSearchNode: If set, full text search for this file is disabled.
OrganizationNode: The organization element contains the name of document author's organization, or the organization responsible for the document.
OrphanNode: If set, warnings about this file not being included in any toctree will be suppressed.
RevisionNode: The revision element contains the revision number of the document. It can be used alone or in conjunction with version.
TocDepthNode: The maximum depth for a table of contents of this file.
TopicNode: The topic element is a nonrecursive section-like construct which may occur at the top level of a section wherever a body element (list, table, etc.) is allowed. In other words, topic elements cannot nest inside body elements, so you can't have a topic inside a table or a list, or inside another topic.
VersionNode: The version element contains the version number of the document. It can be used alone or in conjunction with revision.
ParagraphNode
ProjectNode
QuoteNode
RawNode
ReplacementNode
SectionNode
SeparatorNode
SpanNode
TableColumn
TableRow
TableNode
TextNode
TitleNode
Parser: Determines the correct markup language parser to use based on the input and output format and with it, and parses the file contents.
ParserContext
AnchorHyperlinkResolver: Resolves references with an anchor URL.
AnchorReferenceResolver: Resolves references with an anchor URL.
DelegatingReferenceResolver: Resolves the URL for all inline link nodes using reference resolvers.
DocReferenceResolver
DocumentNameResolver
EmailReferenceResolver: Resolves references with an embedded email address
ExternalReferenceResolver: Resolves references with an embedded external URL.
ImageReferenceResolverPreRender
DefaultInventoryLoader
DefaultInventoryRepository
InvalidInventoryLink
Inventory
InventoryGroup
InventoryLink
JsonLoader
InterlinkReferenceResolver
InternalReferenceResolver
Message
Messages
NullAnchorNormalizer
PageHyperlinkResolver: Resolves named and anonymous references to source files
ReferenceResolverPreRender
SluggerAnchorNormalizer
TitleReferenceResolver: Resolves references with an anchor URL.
RenderContext
BaseTypeRenderer
DocumentListIterator
HtmlRenderer
InMemoryRendererFactory
InterlinkObjectsRenderer
LatexRenderer
AbsoluteUrlGenerator
AbstractUrlGenerator
ConfigurableUrlGenerator
RelativeUrlGenerator
ComposerSettingsLoader
ProjectSettings
SettingsManager
AssetsExtension
EnvironmentBuilder
GlobalMenuExtension
ThemeConfig
ThemeManager
TrimFilesystemLoader: A file system loader that trims the last line ending from the template content.
TwigTemplateRenderer
UriFactory
Configuration
GraphsExtension: Provides useful features shared by many extensions.
UmlDirective: Renders a uml diagram, example:
UmlNode
PlantumlRenderer
PlantumlServerRenderer
TestRenderer
UmlExtension
MarkdownExtension: Provides useful features shared by many extensions.
MarkupLanguageParser
NullNode
ParserException
AbstractBlockParser
BlockQuoteParser
CodeBlockParser
AuthorParser
TitleParser
FrontMatterParser
HeaderParser
HtmlParser
AbstractInlineParser
AbstractInlineTextDecoratorParser
EmphasisParser
InlineCodeParser
InlineImageParser
LinkParser
NewLineParser
PlainTextParser
StrongParser
ListBlockParser
ListItemParser
ParagraphParser
SeparatorParser
TableParser
TextRolePass
ReStructuredTextExtension: Provides useful features shared by many extensions.
AbstractAdmonitionDirective: A directive that parses the sub block and call the processSub that can be overloaded, like :
AbstractVersionChangeDirective: A directive that parses the sub block and call the processSub that can be overloaded, like :
ActionDirective: Extend this class to create a directive that does some actions, for example on the parser context, without creating a node.
AdmonitionDirective: A generic admonition.
AttentionDirective: Directive to create an attention admonition.
BaseDirective: A directive is like a function you can call or apply to a block It looks like:
BreadcrumbDirective: The "breadcrumb" directive displays a breadcrumb of the current. It does not exist in Sphinx or the reST standard yet.
CautionDirective: Directive to create a caution admonition.
ClassDirective: A directive that parses the sub block and call the processSub that can be overloaded, like :
CodeBlockDirective: Renders a code block, example:
ConfigurationBlockDirective: A directive that parses the sub block and call the processSub that can be overloaded, like :
ConfvalDirective: The confval directive configuration values.
ContainerDirective: Divs a sub document in a div with a given class or set of classes.
ContentsDirective: Standarad rst `contents` directive
CsvTableDirective: Render csv file as table
DangerDirective: Directive to create a danger admonition.
DefaultRoleDirective: sets the default interpreted text role, the role that is used for interpreted text without an explicit role.
DeprecatedDirective: A directive that parses the sub block and call the processSub that can be overloaded, like :
DocumentBlockDirective: A directive that parses the sub block and call the processSub that can be overloaded, like :
EpigraphDirective: An epigraph is an apposite (suitable, apt, or pertinent) short inscription, often a quotation or poem, at the beginning of a document or section.
ErrorDirective: Directive to create a error admonition.
FigureDirective: Renders an image, example :
GeneralDirective: A catch-all directive, the content is treated as content, the options passed on
HighlightDirective: https://www.sphinx-doc.org/en/master/usage/restructuredtext/directives.html#directive-highlight
HighlightsDirective: Highlights summarize the main points of a document or section, often consisting of a list.
HintDirective: Directive to create a hint admonition.
ImageDirective: Renders an image, example :
ImportantDirective: Directive to create a important admonition.
IncludeDirective: A directive is like a function you can call or apply to a block It looks like:
IndexDirective: A directive that parses the sub block and call the processSub that can be overloaded, like :
LaTeXMain: Marks the document as LaTeX main
ListTableDirective: A directive that parses the sub block and call the processSub that can be overloaded, like :
LiteralincludeDirective: A directive is like a function you can call or apply to a block It looks like:
MathDirective: Renders a code block, example:
MenuDirective: A menu directives displays a menu in the page. In opposition to a toctree directive the menu is for display only. It does not change the position of document in the document tree and can therefore be included all pages as navigation.
MetaDirective: Add a meta information:
NoteDirective: Directive to create a note admonition.
OptionDirective: Describes a command line argument or switch. Option argument names should be enclosed in angle brackets.
DefaultCodeNodeOptionMapper: The directives `code-block` and `literalinclude` both create a CodeNode with the same possible options.
PullQuoteDirective: A pull-quote is a small selection of text "pulled out and quoted", typically in a larger typeface. Pull-quotes are used to attract attention, especially in long articles.
RawDirective: Renders a raw block, example:
ReplaceDirective: The Replace directive will set the variables for the spans
RoleDirective: The "role" directive dynamically creates a custom interpreted text role and registers it with the parser.
SectionauthorDirective: A directive is like a function you can call or apply to a block It looks like:
SeeAlsoDirective: Directive to create a seealso admonition.
SidebarDirective: Divs a sub document in a div with a given class or set of classes.
SubDirective: A directive that parses the sub block and call the processSub that can be overloaded, like :
TableDirective: Applies more options to a table
TestLoggerDirective: Divs a sub document in a div with a given class or set of classes.
TipDirective: Directive to create a tip admonition.
TitleDirective: Add a meta title to the document
ToctreeDirective: Sphinx based Toctree directive.
TodoDirective: Todo directives are treated as comments, omitting all content or options
VersionAddedDirective: A directive that parses the sub block and call the processSub that can be overloaded, like :
VersionChangedDirective: A directive that parses the sub block and call the processSub that can be overloaded, like :
WarningDirective: Directive to create a warning admonition.
YoutubeDirective: This directive is used to embed a youtube video in the document.
MarkupLanguageParser
AdmonitionNodeRenderer
CollectionNodeRenderer
ContainerNodeRenderer
GeneralDirectiveNodeRenderer
SidebarNodeRenderer
TopicNodeRenderer
GeneralDirectiveNodeRenderer
AdmonitionNode
ConfvalNode: The confval directive configuration values.
ContainerNode
GeneralDirectiveNode: A catch-all directive Node containing all information about the original directive in rst.
OptionNode: Describes a command line argument or switch. Option argument names should be enclosed in angle brackets.
SidebarNode
TopicNode
VersionChangeNode
AnnotationUtility
BlockContext: Our document parser contains
Buffer
Directive: Represents the data contained in an arbitrary directive
DirectiveOption
DocumentParserContext: Our document parser contains
DocumentParserContextFactory
InlineLexer: Base class for writing simple lexers, i.e. for creating small DSLs.
DefaultInterlinkParser
InterlinkData
LineChecker
LinesIterator
AnnotationRule
BlockQuoteRule
CommentRule
DefinitionListRule
DirectiveContentRule
DirectiveRule
DocumentRule
EnumeratedListRule
AbstractFieldListItemRule
AddressFieldListItemRule
AuthorFieldListItemRule
AuthorsFieldListItemRule
ContactFieldListItemRule
CopyrightFieldListItemRule
DateFieldListItemRule
DedicationFieldListItemRule
NavigationTitleFieldListItemRule
NocommentsFieldListItemRule
NosearchFieldListItemRule
OrganizationFieldListItemRule
OrphanFieldListItemRule
ProjectFieldListItemRule
RevisionFieldListItemRule
TocDepthFieldListItemRule
VersionFieldListItemRule
FieldListRule
GridTableRule
InlineMarkupRule: The Inline markup produces inline nodes
AbstractInlineRule
AnnotationRoleRule: Rule to parse for text roles such as ``:ref:`something` `
AnonymousPhraseRule: Rule to parse for anonymous references
AnonymousReferenceRule: Rule to parse for simple anonymous references
DefaultTextRoleRule: Rule to parse for default text roles such as `something`
EmphasisRule: Rule to parse for default text roles such as `something`
EscapeRule: Rule to escape characters with a backslash
InternalReferenceRule
LiteralRule: Rule for literals such as ``something``
NamedPhraseRule: Rule to parse for named references
NamedReferenceRule: Rule to parse for simple named references
NbspRule: Rule to parse for non-breaking spaces: a~b
PlainTextRule
ReferenceRule
StandaloneEmailRule: Rule for standalone hyperlinks
StandaloneHyperlinkRule: Rule for standalone hyperlinks
StrongRule: Rule to parse for default text roles such as `something`
TextRoleRule: Rule to parse for text roles such as ``:ref:`something` `
VariableInlineRule: Rule to parse for inline variables such as |replace_me|
LineBlockRule
LinkRule
ListRule
LiteralBlockRule
ParagraphRule
RuleContainer
SectionRule
SimpleTableRule
GridTableBuilder
ParserContext
TableSeparatorLineConfig
TitleRule
TransitionRule
ReferenceData
ReferenceData
AbbreviationTextRole: Role to create an abbreviation.
AbstractReferenceTextRole
ApiClassTextRole
BaseTextRole
DefaultTextRoleFactory
DocReferenceTextRole: Role to create a reference to a document.
GenericLinkProvider: Role to create references to link targets.
GenericReferenceTextRole
GenericTextRole
LiteralTextRole: Role to create a literal block.
MathTextRole: Role to create a math block.
NbspTextRole: Role for inserting a non-breaking space.
ReferenceTextRole
SpanTextRole
GlobSearcher
ToctreeBuilder
Comparison
CurrentNode
FieldAccess
FieldName
FilterNode
FunctionCall
Path
RootNode
Value
Wildcard
Executor
ParserBuilder
Parser
Query
ExecutorTest
Book
Commic
Store
ParserBuilderTest
Oven
Base: Did you see this explanation?
Sauce
Topping
Pepperoni
Pizzeria: Entrypoint for this pizza ordering application.
PizzeriaTest
Comparison
CurrentNode
FieldAccess
FieldName
FilterNode
FunctionCall
Path
RootNode
Value
Wildcard
Executor
ParserBuilder
Parser
Query
ExecutorTest
Book
Commic
Store
ParserBuilderTest
Finder: This file is part of phpDocumentor.
Application: Application class for phpDocumentor.
AutoloaderLocator
ApiDocumentationPass
DescriptorRepository
Linker: The linker contains all rules to replace FQSENs in the ProjectDescriptor with aliases to objects.
Debug: This class is responsible for sending statistical information to the log.
ElementsIndexBuilder: This class constructs the index 'elements' and populates it with all Structural Elements.
FilterEmptyNamespaces
MarkerFromTagsExtractor: This index builder collects all markers from tags and inserts them into the marker index.
NamespaceTreeBuilder: Rebuilds the namespace tree from the elements found in files.
PackageTreeBuilder: Rebuilds the package tree from the elements found in files.
RemoveSourcecode
ResolveInlineMarkers
UsedByBuilder
VarTagModifier
DescriptorRepository
GuidesCompiler
SetVersionPass
ApiSetBuilder
GuideSetBuilder
TableOfContentsBuilder
ApiSpecification
CommandlineOptionsMiddleware
Configuration
ConfigurationFactory: The ConfigurationFactory converts the configuration xml from a Uri into an array.
Version2
Version3
InvalidConfigPathException
UnsupportedConfigVersionException
UpgradeFailedException
GuideSpecification
PathNormalizingMiddleware
ProvideTemplateOverridePathMiddleware: Determines the path where the general template overrides are.
Source
SymfonyConfigFactory
VersionSpecification
Application: An Application is the container for a collection of commands.
ListSettingsCommand: Base class for all commands.
RunCommand: Parse and transform the given directory (-d|-f) to the given location (-t).
ConsoleLogHandler
ContainerFactory
ApplicationExtension: Provides useful features shared by many extensions.
GuidesCommandsPass
ReflectionProjectFactoryStrategyPass: Custom Compiler pass to help symfony to construct the ProjectFactoryStrategies
ApiSetDescriptor
AttributeDescriptor
AssemblerAbstract: Base class for all assemblers.
AssemblerFactory: Attempts to retrieve an Assembler for the provided criteria.
AssemblerMatcher
Matcher
ArgumentAssembler: Assembles an ArgumentDescriptor using an ArgumentReflector and ParamDescriptors.
AssemblerAbstract: Base class for all assemblers.
ClassAssembler: Assembles an ClassDescriptor using an ClassReflector.
ConstantAssembler: Assembles a ConstantDescriptor from a ConstantReflector.
DescriptionAssemblerReducer: Base class for all assemblers.
EnumAssembler: Assembles an EnumDescriptor using an ClassReflector.
EnumCaseAssembler: Assembles an EnumCaseDescriptor.
FileAssembler: Assembles an FileDescriptor using an FileReflector and ParamDescriptors.
FunctionAssembler: Assembles a FunctionDescriptor from a FunctionReflector.
InterfaceAssembler: Assembles an InterfaceDescriptor using an InterfaceReflector.
MethodAssembler: Assembles a MethodDescriptor from a MethodReflector.
NamespaceAssembler: Base class for all assemblers.
PropertyAssembler: Assembles a PropertyDescriptor from a PropertyReflector.
PropertyHookAssembler: Assembles a PropertyDescriptor from a PropertyReflector.
AttributeReducer
MetadataReducer
VisibilityReducer
AuthorAssembler: Constructs a new descriptor from the Reflector for an `@author` tag.
BaseTagAssembler: Base class for all assemblers.
DeprecatedAssembler: Constructs a new descriptor from the Reflector for an `{@}deprecated` tag.
ExampleAssembler: This class collects data from the example tag definition of the Reflection library, tries to find the correlating example file on disk and creates a complete Descriptor from that.
GenericTagAssembler: Base class for all assemblers.
InvalidTagAssembler: Base class for all assemblers.
LinkAssembler: Constructs a new descriptor from the Reflector for an `@link` tag.
MethodAssembler: Constructs a new descriptor from the Reflector for an `@method` tag.
ParamAssembler: Constructs a new descriptor from the Reflector for an `@param` tag.
PropertyAssembler: Constructs a new descriptor from the Reflector for an `@property` tag.
ReturnAssembler: Constructs a new descriptor from the Reflector for an `@return` tag.
SeeAssembler: Constructs a new Descriptor from a Reflector object for the `@see` tag.
SinceAssembler: Constructs a new descriptor from the Reflector for an `@since` tag.
ThrowsAssembler: Constructs a new descriptor from the Reflector for an `@throws` tag.
UsedByAssembler: Base class for all assemblers.
UsesAssembler: Base class for all assemblers.
VarAssembler: Constructs a new descriptor from the Reflector for an `@var` tag.
VersionAssembler: Constructs a new descriptor from the Reflector for an `@version` tag.
TraitAssembler: Assembles an TraitDescriptor using an TraitReflector.
ProjectDescriptorMapper: Maps a projectDescriptor to and from a cache instance.
Collection: Represents an easily accessible collection of elements.
DescriptorAbstract: Base class for descriptors containing the most used options.
DescriptionDescriptor
DocumentationSetDescriptor
DocumentDescriptor
Finder: Class used to find an example file's location based on a given ExampleDescriptor.
MissingDependencyException: This exception is thrown when a required dependency is not included.
Filter: Filter used to manipulate a descriptor after being build.
FilterPayload
StripIgnore: Strips any Descriptor if the ignore tag is present with that element.
StripIgnoredTags
StripInternal: Filters a Descriptor when the @internal inline tag, or normal tag, is used.
StripOnVisibility: Strips any Descriptor if their visibility is allowed according to the ProjectDescriptorBuilder.
GuideSetDescriptor
ProjectAnalyzer: Analyzes a Project Descriptor and collects key information.
Settings: Contains the Settings for the current Project.
ProjectDescriptorBuilder: Builds a Project Descriptor and underlying tree.
PropertyHookDescriptor
Engine
Entry
TypedAbstract: Base descriptor for tags that have a type associated with them.
TypedVariableAbstract: Abstract class for Descriptors with a type and variable name.
TocDescriptor
Error: Struct to record a validation error.
CallArgument
Deprecation
IsApplicable
Visibility
VersionDescriptor
Dsn: Data Source Name (DSN), a reference to a path on a local or remote system with the ability to add parameters.
EventAbstract: Abstract class representing the base elements of a phpDocumentor event.
DirectoryLoader
Extension: Provides useful features shared by many extensions.
ExtensionHandler
ExtensionInfo
PackageLoader
PharLoader
Validator
DescriptorAwareCompilerContext: Context class used in compiler passes to store the state of the nodes.
ClassDiagramNodeTransformer
ClassListNodeTransformer
PHPReferenceNodeTransformer
DocumentCollector
PHPReferenceNode
ClassDiagram
ClassList
DescriptorNode
ElementDescription
ElementName
ElementSummary
UrlGenerator
ClassDiagram: A directive is like a function you can call or apply to a block It looks like:
PHPClassList: A directive that parses the sub block and call the processSub that can be overloaded, like :
PHPElementDescription: A directive is like a function you can call or apply to a block It looks like:
PHPElementName: A directive is like a function you can call or apply to a block It looks like:
PHPElementSummary: A directive is like a function you can call or apply to a block It looks like:
PHPReference
FilesystemAdapter
Locator: Locates the cache folder and ensures that the Symfony Cache is routed to that folder.
PreFileEvent: Event thrown before the parsing of an individual file.
PreParsingEvent: Event thrown before the parsing all files.
FilesNotFoundException: Exception that is thrown when the parser expects files but is unable to find them.
FileFactory
FlySystemCollector
FlySystemFactory
FlySystemFile
CacheMiddleware
EmittingMiddleware
ErrorHandlingMiddleware
ReEncodingMiddleware
StopwatchMiddleware
Parser: Class responsible for parsing the given file or files to the intermediate structure file.
ReEncodedFile
SpecificationFactory: Factory class to build Specification used by FlyFinder when reading files to process.
Path: Value Object for paths.
Stage
FingersCrossedProcessor
InterruptibleProcessor
Pipeline
PipelineBuilder
PipelineFactory
GarbageCollectCache
LoadGuidesFromCache
LoadProjectDescriptorFromCache
PurgeCachesWhenForced
StoreGuidesToCache
StoreProjectDescriptorToCache
Compile: Compiles and links the ast objects into the full ast
DocumentationSetCompiler
Configure
InitializeBuilderFromConfig
ParseApiDocumentationSets
ApiSetPayload
CollectFiles
ParseFiles
ParseGuides
Payload
TimedStageDecorator
Transform: Transforms the structure file into the specified output format
TransformToPayload
PostTransformationEvent: Event that happens after each individual transformation.
PostTransformEvent: Event happen right after all transformations have completed.
PreTransformationEvent: Event happening prior to each individual transformation.
PreTransformEvent: Event that happens prior to the execution of all transformations.
WriterInitializationEvent: Abstract class representing the base elements of a phpDocumentor event.
Exception: Provides the basic exception for the parser package.
ClassBasedFqsenUrlGenerator: Generates a relative URL with properties for use in the generated HTML documentation.
Router
Collection: Contains a collection of Templates that may be queried.
Factory
Parameter: Model representing a parameter in a template or transformation.
TemplateNotFound
Template: Model representing a template.
Transformation: Class representing a single Transformation.
Transformer: Core class responsible for transforming the cache file to a set of artifacts.
Collection: A collection of Writer objects.
RequirementMissing: This exception should be thrown by a Writer when it is missing one of its requirements.
FileIo: Writer containing file system operations.
PlantumlClassDiagram
Graph: Writer responsible for generating various graphs.
PathGenerator
RenderGuide: Base class for the actual transformation business logic (writers).
Sourcecode: Sourcecode transformation writer; generates syntax highlighted source files in a destination's subfolder.
CommonMarkFactory
EnvironmentFactory
Extension: Basic extension adding phpDocumentor specific functionality for Twig templates.
FlySystemLoader
AbstractListAdapter
ArrayOfTypeAdapter: Converts an array with types into a string-based representation of these types.
CallableAdapter
HtmlFormatter
IterableAdapter
LinkAdapter: Renders most of the links to elements, urls and urls with virtual schemes.
NullableAdapter
Target: The target of a link and how it should be presented.
UrlGenerator: Url generator for rendering links in the twig templates.
LinkRenderer: Renders an HTML anchor pointing to the location of the provided element.
PathBuilder
RelativePathToRootConverter
Twig: A specialized writer which uses the Twig templating engine to convert templates to HTML output.
WriterAbstract: Base class for the actual transformation business logic (writers).
Element
ClassDiagram
PlantumlRenderer
UriFactory
Version
Modifiers: Modifiers used (as a bit mask) by various flags subnodes, for example on classes, functions, properties and constants.
Exception: An exception specifically originating from the Reflection component.
LocalFile: Represents a local file on the file system.
ChainFactory
ElementNameResolver
FindingVisitor: This visitor can be used to find the first node satisfying some criterion determined by a filter callback.
Argument: Descriptor representing a single Argument of a method or function.
AsymmetricVisibility: Value object for visibility values of classes, properties, ect.
Attribute
CallArgument: Represents an argument in a function or method call.
Class_: Descriptor representing a Class.
Constant: Descriptor representing a constant
Enum_: Descriptor representing an Enum.
EnumCase: Represents a case in an Enum.
ExpressionPrinter
Expression: Represents an expression with a define statement, constant, property, enum case and any other location.
AbstractFactory
Class_: Strategy to create a ClassElement including all sub elements.
ClassConstant: Strategy to convert ClassConstantIterator to ConstantElement
ClassConstantIterator: This class acts like a combination of a ClassConst and Const_ to be able to create constant descriptors using a normal strategy.
ConstructorPromotion
ContextStack
Define: Strategy to convert `define` expressions to ConstantElement
Enum_
EnumCase
CreateCommand: File Create command is used by the File Factory Strategy.
File: Strategy to create File element from the provided filename.
Function_: Strategy to convert Function_ to FunctionDescriptor
GlobalConstant: Strategy to convert GlobalConstantIterator to ConstantElement
GlobalConstantIterator
IfStatement
Interface_: Strategy to create a InterfaceElement including all sub elements.
Method: Strategy to create MethodDescriptor and arguments when applicable.
Namespace_
Noop
Property: Strategy to convert PropertyIterator to PropertyDescriptor
PropertyIterator: This class acts like a combination of a PropertyNode and PropertyProperty to be able to create property descriptors using a normal strategy.
Attribute
Parameter
Trait_
TraitUse
Type
File: Represents a file in the project.
Function_: Descriptor representing a function
Interface_: Descriptor representing an Interface.
Method: Descriptor representing a Method in a Class, Interface or Trait.
Namespace_: Represents a namespace and its children for a project.
NodesFactory: Factory to create a array of nodes from a provided file.
Project: Represents the entire project with its files, namespaces and indexes.
ProjectFactory: Factory class to transform files into a project description.
ProjectFactoryStrategies
Property: Descriptor representing a property.
PropertyHook
Trait_: Descriptor representing a Trait.
Visibility: Value object for visibility values of classes, properties, ect.
NamespaceNodeToContext
Assert: A set of assertion methods.
ProjectFactoryBench
AsymmetricAccessorTest
ClassesTest
EnumConsumer
Foo
Pizza: Pizza base class
StyleFactory
ConstructorPromotion
MixedType
StaticType
UnionTypes
AsymmetricAccessor
AsymmetricPropertyPromotion
PropertyHook
PropertyHook
PropertyHook
PropertyHookVirtual
Pizza: Pizza base class
EnumTest
FileDocblockTest: Integration tests to check the correct working of processing a namespace into a project.
myHookUsingClass
Hook
HookStrategy
MetadataTest
ConstructorPromotionTest
MixedTypeTest
StaticTypeTest
UnionTypesTest
ProjectCreationTest: Integration tests to check the correct working of processing a file into a project.
ProjectNamespaceTest: Integration tests to check the correct working of processing a namespace into a project.
PropertyHookTest
LocalFileTest
ChainFactoryTest
ElementNameResolverTest
ArgumentTest: Tests the functionality for the Argument class.
Class_Test: Base test case for all elements.
ConstantTest: Base test case for all elements.
Enum_Test: Base test case for all elements.
EnumCaseTest
ExpressionPrinterTest
ExpressionTest
Class_Test: Base test case for all strategies, to be sure that they check if the can handle objects before handeling them.
ClassConstantIteratorTest
ClassConstantTest: Base test case for all strategies, to be sure that they check if the can handle objects before handeling them.
ConstructorPromotionTest: Base test case for all strategies, to be sure that they check if the can handle objects before handeling them.
ContextStackTest
DefineTest: Base test case for all strategies, to be sure that they check if the can handle objects before handeling them.
DummyFactoryStrategy: Stub for test purpose only.
Enum_Test: Base test case for all strategies, to be sure that they check if the can handle objects before handeling them.
EnumCaseTest: Base test case for all strategies, to be sure that they check if the can handle objects before handeling them.
CreateCommandTest
FileTest: Base test case for all strategies, to be sure that they check if the can handle objects before handeling them.
Function_Test: Base test case for all strategies, to be sure that they check if the can handle objects before handeling them.
GlobalConstantIteratorTest
GlobalConstantTest: Base test case for all strategies, to be sure that they check if the can handle objects before handeling them.
Interface_Test: Base test case for all strategies, to be sure that they check if the can handle objects before handeling them.
MethodTest: Base test case for all strategies, to be sure that they check if the can handle objects before handeling them.
Namespace_Test: Base test case for all strategies, to be sure that they check if the can handle objects before handeling them.
PropertyBuilderTest
PropertyIteratorTest
PropertyTest: Base test case for all strategies, to be sure that they check if the can handle objects before handeling them.
TestCase: Base test case for all strategies, to be sure that they check if the can handle objects before handeling them.
Trait_Test: Base test case for all strategies, to be sure that they check if the can handle objects before handeling them.
TraitUseTest: Base test case for all strategies, to be sure that they check if the can handle objects before handeling them.
TypeTest
FileTest
Function_Test: Base test case for all elements.
Interface_Test: Base test case for all elements.
MetadataStub
MethodTest: Base test case for all elements.
Namespace_Test: Tests the functionality for the Namespace_ class.
NodesFactoryTest
ProjectFactoryStrategiesTest: Test case for ProjectFactoryStrategies
ProjectFactoryTest
ProjectTest: Tests the functionality for the Project class.
PropertyTest: Tests the functionality for the Property class.
TestCase: Base test case for all elements.
Trait_Test: Base test case for all elements.
ConstantEvaluatorTest
VisibilityTest: Test case for Visibility
NamespaceNodeToContextTest
Fqsen: Value Object for Fqsen.
Location: The location where an element occurs within a file.
Description: Object representing to description for a DocBlock.
DescriptionFactory: Creates a new Description object given a body of text.
ExampleFinder: Class used to find an example file's location based on a given ExampleDescriptor.
Serializer: Converts a DocBlock back from an object to a complete DocComment including Asterisks.
StandardTagFactory: Creates a Tag object given the contents of a tag.
Author: Reflection class for an {@}author tag in a Docblock.
BaseTag: Parses a tag definition for a DocBlock.
Covers: Reflection class for a @covers tag in a Docblock.
Deprecated: Reflection class for a {@}deprecated tag in a Docblock.
Example: Reflection class for a {@}example tag in a Docblock.
Extends_: Reflection class for a {@}extends tag in a Docblock.
AlignFormatter
PassthroughFormatter
Generic: Parses a tag definition for a DocBlock.
Implements_: Reflection class for a {@}implements tag in a Docblock.
InvalidTag: This class represents an exception during the tag creation
Link: Reflection class for a {@}link tag in a Docblock.
Method: Reflection class for an {@}method in a Docblock.
MethodParameter
Mixin: Reflection class for a {@}mixin tag in a Docblock.
Param: Reflection class for the {@}param tag in a Docblock.
Property: Reflection class for a {@}property tag in a Docblock.
PropertyRead: Reflection class for a {@}property-read tag in a Docblock.
PropertyWrite: Reflection class for a {@}property-write tag in a Docblock.
Fqsen: Fqsen reference used by {@see \phpDocumentor\Reflection\DocBlock\Tags\See}
Url: Url reference used by {@see \phpDocumentor\Reflection\DocBlock\Tags\See}
Return_: Reflection class for a {@}return tag in a Docblock.
See: Reflection class for an {@}see tag in a Docblock.
Since: Reflection class for a {@}since tag in a Docblock.
Source: Reflection class for a {@}source tag in a Docblock.
TagWithType: Parses a tag definition for a DocBlock.
Template: Reflection class for a {@}template tag in a Docblock.
TemplateCovariant: Reflection class for a {@}template-covariant tag in a Docblock.
TemplateExtends: Reflection class for a {@}template-extends tag in a Docblock.
TemplateImplements: Reflection class for a {@}template-implements tag in a Docblock.
Throws: Reflection class for a {@}throws tag in a Docblock.
Uses: Reflection class for a {@}uses tag in a Docblock.
Var_: Reflection class for a {@}var tag in a Docblock.
Version: Reflection class for a {@}version tag in a Docblock.
DocBlock
DocBlockFactory
PcreException
Utils
FqsenResolver: Resolver for Fqsen using Context information
ArrayShape
ArrayShapeItem
CallableString: Value Object representing the type 'string'.
Conditional: Value Object representing the conditional type.
ConditionalForParameter: Value Object representing the conditional type for parameter.
ConstExpression
False_: Value Object representing the PseudoType 'False', which is a Boolean type.
FloatValue
HtmlEscapedString: Value Object representing the type 'string'.
IntegerRange: Value Object representing the type 'int'.
IntegerValue
IntMask: Value Object representing the `int-mask` type.
IntMaskOf: Value Object representing the `int-mask-of` type.
KeyOf: Value Object representing the `key-of` type.
List_: Value Object representing the type 'list'.
ListShape
ListShapeItem
LiteralString: Value Object representing the type 'string'.
LowercaseString: Value Object representing the type 'string'.
NegativeInteger: Value Object representing the type 'int'.
NonEmptyArray: Value Object representing the type 'non-empty-array'.
NonEmptyList: Value Object representing the type 'non-empty-list'.
NonEmptyLowercaseString: Value Object representing the type 'string'.
NonEmptyString: Value Object representing the type 'string'.
Numeric_: Value Object representing the 'numeric' pseudo-type, which is either a numeric-string, integer or float.
NumericString: Value Object representing the type 'string'.
ObjectShape
ObjectShapeItem
OffsetAccess: Value Object representing the offset access type.
PositiveInteger: Value Object representing the type 'int'.
ShapeItem
StringValue
TraitString: Value Object representing the type 'string'.
True_: Value Object representing the PseudoType 'False', which is a Boolean type.
ValueOf: Value Object representing the `value-of` type.
TypeResolver
AbstractList: Represents a list of values. This is an abstract class for Array_ and Collection.
AggregatedType: Base class for aggregated types like Compound and Intersection
Array_: Represents an array type as described in the PSR-5, the PHPDoc Standard.
ArrayKey: Value Object representing a array-key Type.
Boolean: Value Object representing a Boolean type.
Callable_: Value Object representing a Callable type.
CallableParameter: Value Object representing a Callable parameters.
ClassString: Value Object representing the type 'string'.
Collection: Represents a collection type as described in the PSR-5, the PHPDoc Standard.
Compound: Value Object representing a Compound Type.
Context: Provides information about the Context in which the DocBlock occurs that receives this context.
ContextFactory: Convenience class to create a Context for DocBlocks when not using the Reflection Component of phpDocumentor.
Expression: Represents an expression type as described in the PSR-5, the PHPDoc Standard.
Float_: Value Object representing a Float.
Integer: Value object representing Integer type
InterfaceString: Value Object representing the type 'string'.
Intersection: Value Object representing a Compound Type.
Iterable_: Value Object representing iterable type
Mixed_: Value Object representing an unknown, or mixed, type.
Never_: Value Object representing the return-type 'never'.
Null_: Value Object representing a null value or type.
Nullable: Value Object representing a nullable type. The real type is wrapped.
Object_: Value Object representing an object.
Parent_: Value Object representing the 'parent' type.
Resource_: Value Object representing the 'resource' Type.
Scalar: Value Object representing the 'scalar' pseudo-type, which is either a string, integer, float or boolean.
Self_: Value Object representing the 'self' type.
Static_: Value Object representing the 'static' type.
String_: Value Object representing the type 'string'.
This: Value Object representing the '$this' pseudo-type.
Void_: Value Object representing the return-type 'void'.
DSNConfigurator: Configure PHPMailer with DSN string.
Exception: PHPMailer exception handler.
OAuth: OAuth - OAuth2 authentication wrapper class.
PHPMailer: PHPMailer - PHP email creation and transport class.
POP3: PHPMailer POP-Before-SMTP Authentication Class.
SMTP: PHPMailer RFC821 SMTP email transport class.
LazyOption
None
Option
Some
AbstractNodeVisitor: Inspired by https://github.com/nikic/PHP-Parser/tree/36a6dcd04e7b0285e8f0868f44bd4927802f7df1
Attribute
Comment
ConstExprArrayItemNode
ConstExprArrayNode
ConstExprFalseNode
ConstExprFloatNode
ConstExprIntegerNode
ConstExprNullNode
ConstExprStringNode
ConstExprTrueNode
ConstFetchNode
DoctrineConstExprStringNode
NodeTraverser: Inspired by https://github.com/nikic/PHP-Parser/tree/36a6dcd04e7b0285e8f0868f44bd4927802f7df1
CloningVisitor: Inspired by https://github.com/nikic/PHP-Parser/tree/36a6dcd04e7b0285e8f0868f44bd4927802f7df1
AssertTagMethodValueNode
AssertTagPropertyValueNode
AssertTagValueNode
DeprecatedTagValueNode
DoctrineAnnotation
DoctrineArgument
DoctrineArray
DoctrineArrayItem
DoctrineTagValueNode
ExtendsTagValueNode
GenericTagValueNode
ImplementsTagValueNode
InvalidTagValueNode
MethodTagValueNode
MethodTagValueParameterNode
MixinTagValueNode
ParamClosureThisTagValueNode
ParamImmediatelyInvokedCallableTagValueNode
ParamLaterInvokedCallableTagValueNode
ParamOutTagValueNode
ParamTagValueNode
PhpDocNode
PhpDocTagNode
PhpDocTextNode
PropertyTagValueNode
PureUnlessCallableIsImpureTagValueNode
RequireExtendsTagValueNode
RequireImplementsTagValueNode
ReturnTagValueNode
SealedTagValueNode
SelfOutTagValueNode
TemplateTagValueNode
ThrowsTagValueNode
TypeAliasImportTagValueNode
TypeAliasTagValueNode
TypelessParamTagValueNode
UsesTagValueNode
VarTagValueNode
ArrayShapeItemNode
ArrayShapeNode
ArrayShapeUnsealedTypeNode
ArrayTypeNode
CallableTypeNode
CallableTypeParameterNode
ConditionalTypeForParameterNode
ConditionalTypeNode
ConstTypeNode
GenericTypeNode
IdentifierTypeNode
IntersectionTypeNode
InvalidTypeNode
NullableTypeNode
ObjectShapeItemNode
ObjectShapeNode
OffsetAccessTypeNode
ThisTypeNode
UnionTypeNode
Lexer: Implementation based on Nette Tokenizer (New BSD License; https://github.com/nette/tokenizer)
ConstExprParser
ParserException
PhpDocParser
StringUnescaper
TokenIterator
TypeParser
ParserConfig
Printer: Inspired by https://github.com/nikic/PHP-Parser/tree/36a6dcd04e7b0285e8f0868f44bd4927802f7df1
AbstractLogger: This is a simple Logger implementation that other Loggers can inherit from.
InvalidArgumentException
LogLevel: Describes log levels.
NullLogger: This Logger can be used to avoid conditional log calls.
LoggerInterfaceTest: Provides a base test class for ensuring compliance with the LoggerInterface.
TestLogger: Used for testing purposes.
AbstractAdapter
ApcuAdapter
ArrayAdapter: An in-memory cache storage.
ChainAdapter: Chains several adapters together.
CouchbaseBucketAdapter
CouchbaseCollectionAdapter
DoctrineDbalAdapter
FilesystemAdapter
FilesystemTagAwareAdapter: Stores tag id <> cache id relationship as a symlink, and lookup on invalidation calls.
MemcachedAdapter
NullAdapter
ParameterNormalizer
PdoAdapter
PhpArrayAdapter: Caches items at warm up time using a PHP array that is stored in shared memory by OPCache since PHP 7.0.
PhpFilesAdapter
ProxyAdapter
Psr16Adapter: Turns a PSR-16 cache into a PSR-6 one.
RedisAdapter
RedisTagAwareAdapter: Stores tag id <> cache id relationship as a Redis Set.
TagAwareAdapter: Implements simple and robust tag-based invalidation suitable for use with volatile caches.
TraceableAdapter: An adapter that collects data about all cache calls.
TraceableTagAwareAdapter: An adapter that collects data about all cache calls.
CacheItem
CacheDataCollector
CacheCollectorPass: Inject a data collector to all the cache services to be able to get detailed statistics.
CachePoolClearerPass
CachePoolPass
CachePoolPrunerPass
CacheException
InvalidArgumentException
LogicException
LockRegistry: LockRegistry is used internally by existing adapters to protect against cache stampede.
DefaultMarshaller: Serializes/unserializes values using igbinary_serialize() if available, serialize() otherwise.
DeflateMarshaller: Compresses values using gzdeflate().
SodiumMarshaller: Encrypt/decrypt values using Libsodium.
TagAwareMarshaller: A marshaller optimized for data structures generated by AbstractTagAwareAdapter.
EarlyExpirationDispatcher: Sends the computation of cached values to a message bus.
EarlyExpirationHandler: Computes cached values sent to a message bus.
EarlyExpirationMessage: Conveys a cached value that needs to be computed.
Psr16Cache: Turns a PSR-6 cache into a PSR-16 one.
Clock: A global clock.
DatePoint: An immmutable DateTime with stricter error handling and return types than the native one.
MockClock: A clock that always returns the same date, suitable for testing time-sensitive logic.
MonotonicClock: A monotonic clock suitable for performance profiling.
NativeClock: A clock that relies the system time.
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.
Configuration
DefinitionConfigurator
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.
DefinitionFileLoader: DefinitionFileLoader loads config definitions from a PHP file.
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.
AsCommand: Service tag to autoconfigure commands.
GithubActionReporter: Utility class for Github actions.
Color
Command: Base class for all commands.
CompleteCommand: Responsible for providing the values to the shell completion.
DumpCompletionCommand: Dumps the completion script for the current shell.
HelpCommand: HelpCommand displays the help for a given command.
LazyCommand: Base class for all commands.
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.
CompletionInput: An input specialized for shell completion.
CompletionSuggestions: Stores all completion suggestions for the current input.
BashCompletionOutput
FishCompletionOutput
ZshCompletionOutput
Suggestion: Represents a single suggested value.
ConsoleEvents: Contains all events dispatched by an Application.
Cursor
AddConsoleCommandPass: Registers console commands.
ReStructuredTextDescriptor
ConsoleCommandEvent: Allows to do things before the command is executed, like skipping the command or executing code before the command is going to be executed.
ConsoleErrorEvent: Allows to handle throwables thrown while running a command.
ConsoleEvent: Allows to inspect input and output of a command.
ConsoleSignalEvent: 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.
RunCommandFailedException
RuntimeException
NullOutputFormatter
NullOutputFormatterStyle
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.
OutputWrapper: Simple output wrapper for "tagged outputs" instead of wordwrap(). This solution is based on a StackOverflow answer: https://stackoverflow.com/a/20434776/1476819 from user557597 (alias SLN).
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
TableCellStyle
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.
RunCommandContext
RunCommandMessage
RunCommandMessageHandler
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.
SignalMap
SignalRegistry
SingleCommandApplication: Base class for all commands.
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.
CommandCompletionTester: Eases the testing of command completion.
CommandTester: Eases the testing of console commands.
CommandIsSuccessful
Event: Event is the base class for classes containing event data.
HttpClientTestCase: A reference test suite for HttpClientInterface implementations.
TestHttpServer
Required: A required dependency.
SubscribedService: For use as the return value for {@see ServiceSubscriberInterface}.
ServiceLocatorTest
ServiceLocatorTestCase
CacheTraitTest
TestPool
LegacyParentTestService
LegacyTestService
LegacyChildTestService
LegacyParentWithMagicCall
LegacyService3
LegacyParentTestService2
ServiceMethodsSubscriberTraitTest
ParentTestService
TestService
ChildTestService
ParentWithMagicCall
Service1
Service2
Service3
ParentTestService2
TestService2
ServiceSubscriberTraitTest
TranslatorTest: Test should cover all languages mentioned on http://translate.sourceforge.net/wiki/l10n/pluralforms and Plural forms mentioned on http://www.gnu.org/software/gettext/manual/gettext.html#Plural-forms.
Alias
AbstractArgument: Represents an abstract service argument, which have to be set by a compiler pass or a DI extension.
BoundArgument
IteratorArgument: Represents a collection of values to lazily iterate over.
ServiceClosureArgument: Represents a service wrapped in a memoizing closure.
ServiceLocatorArgument: Represents a closure acting as a service locator.
TaggedIteratorArgument: Represents a collection of services found by tag name to lazily iterate over.
AsAlias: An attribute to tell under which alias a service should be registered or to use the implemented interface if no parameter is given.
AsDecorator
AsTaggedItem: An attribute to tell under which index and priority a service class should be found in tagged iterators/locators.
Autoconfigure: An attribute to tell how a base type should be autoconfigured.
AutoconfigureTag: An attribute to tell how a base type should be tagged.
Autowire: Attribute to tell a parameter how to be autowired.
AutowireCallable: Attribute to tell which callable to give to an argument of type Closure.
AutowireDecorated
AutowireIterator: Autowires an iterator of services based on a tag name.
AutowireLocator: Autowires a service locator based on a tag name or an explicit list of key => service-type pairs.
AutowireServiceClosure: Attribute to wrap a service in a closure that returns it.
Exclude: An attribute to tell the class should not be registered as service.
MapDecorated
TaggedIterator: Autowires an iterator of services based on a tag name.
TaggedLocator: Autowires a service locator based on a tag name or an explicit list of key => service-type pairs.
Target: An attribute to tell how a dependency is used and hint named autowiring aliases.
When: An attribute to tell under which environment this class should be registered as a service.
ChildDefinition: This definition extends another definition.
AbstractRecursivePass
AliasDeprecatedPublicServicesPass
AnalyzeServiceReferencesPass: Run this pass before passes that need to know more about the relation of your services.
AttributeAutoconfigurationPass
AutoAliasServicePass: Sets a service to be an alias of another one, given a format pattern.
AutowireAsDecoratorPass: Reads #[AsDecorator] attributes on definitions that are autowired and don't have the "container.ignore_attributes" tag.
AutowirePass: Inspects existing service definitions and wires the autowired ones using the type hints of their classes.
AutowireRequiredMethodsPass: Looks for definitions with autowiring enabled and registers their corresponding "#[Required]" methods as setters.
AutowireRequiredPropertiesPass: Looks for definitions with autowiring enabled and registers their corresponding "#[Required]" properties.
CheckArgumentsValidityPass: Checks if arguments of methods are properly configured.
CheckCircularReferencesPass: Checks your services for circular references.
CheckDefinitionValidityPass: This pass validates each definition individually only taking the information into account which is contained in the definition itself.
CheckExceptionOnInvalidReferenceBehaviorPass: Checks that all references are pointing to a valid service.
CheckReferenceValidityPass: Checks the validity of references.
CheckTypeDeclarationsPass: Checks whether injected parameters are compatible with type declarations.
Compiler: This class is used to remove circular dependencies between individual passes.
DecoratorServicePass: Overwrites a service but keeps the overridden one.
DefinitionErrorExceptionPass: Throws an exception for any Definitions that have errors and still exist.
ExtensionCompilerPass: A pass to automatically process extensions if they implement CompilerPassInterface.
InlineServiceDefinitionsPass: Inline service definitions where this is possible.
MergeExtensionConfigurationPass: Merges extension configs into the container builder.
PassConfig: Compiler Pass Configuration.
RegisterAutoconfigureAttributesPass: Reads #[Autoconfigure] attributes on definitions that are autoconfigured and don't have the "container.ignore_attributes" tag.
RegisterEnvVarProcessorsPass: Creates the container.env_var_processors_locator service.
RegisterReverseContainerPass
RegisterServiceSubscribersPass: Compiler pass to register tagged services that require a service locator.
RemoveAbstractDefinitionsPass: Removes abstract Definitions.
RemoveBuildParametersPass
RemovePrivateAliasesPass: Remove private aliases from the container. They were only used to establish dependencies between services, and these dependencies have been resolved in one of the previous passes.
RemoveUnusedDefinitionsPass: Removes unused service definitions from the container.
ReplaceAliasByActualDefinitionPass: Replaces aliases with actual service definitions, effectively removing these aliases.
ResolveBindingsPass
ResolveChildDefinitionsPass: This replaces all ChildDefinition instances with their equivalent fully merged Definition instance.
ResolveClassPass
ResolveDecoratorStackPass
ResolveEnvPlaceholdersPass: Replaces env var placeholders by their current values.
ResolveFactoryClassPass
ResolveHotPathPass: Propagate "container.hot_path" tags to referenced services.
ResolveInstanceofConditionalsPass: Applies instanceof conditionals to definitions.
ResolveInvalidReferencesPass: Emulates the invalid behavior if the reference is not found within the container.
ResolveNamedArgumentsPass: Resolves named arguments to their corresponding numeric index.
ResolveNoPreloadPass: Propagate the "container.no_preload" tag.
ResolveParameterPlaceHoldersPass: Resolves all parameter placeholders "%somevalue%" to their real values.
ResolveReferencesToAliasesPass: Replaces all references to aliases with references to the actual service.
ResolveServiceSubscribersPass: Compiler pass to inject their service locator to service subscribers.
ResolveTaggedIteratorArgumentPass: Resolves all TaggedIteratorArgument arguments.
ServiceLocatorTagPass: Applies the "container.service_locator" tag by wrapping references into ServiceClosureArgument instances.
ServiceReferenceGraph: This is a directed graph of your services.
ServiceReferenceGraphEdge: Represents an edge in your service graph.
ServiceReferenceGraphNode: Represents a node in your service graph.
ValidateEnvPlaceholdersPass: Validates environment variable placeholders used in extension configuration with dummy values.
ContainerParametersResource: Tracks container parameters.
ContainerParametersResourceChecker
Container: Container is a dependency injection container.
ContainerBuilder: ContainerBuilder is a DI container that provides an API to easily describe services.
Definition: Definition represents a service definition.
Dumper: Dumper is the abstract class for all built-in dumpers.
GraphvizDumper: GraphvizDumper dumps a service container as a graphviz file.
PhpDumper: PhpDumper dumps a service container as a PHP class.
Preloader
XmlDumper: XmlDumper dumps a service container as an XML string.
YamlDumper: YamlDumper dumps a service container as a YAML string.
EnvVarProcessor
AutowiringFailedException: Thrown when a definition cannot be autowired.
BadMethodCallException: Base BadMethodCallException for Dependency Injection component.
EnvNotFoundException: This exception is thrown when an environment variable is not found.
EnvParameterException: This exception wraps exceptions whose messages contain a reference to an env parameter.
InvalidArgumentException: Base InvalidArgumentException for Dependency Injection component.
InvalidParameterTypeException: Thrown when trying to inject a parameter into a constructor/method with an incompatible type.
LogicException: Base LogicException for Dependency Injection component.
OutOfBoundsException: Base OutOfBoundsException for Dependency Injection component.
ParameterCircularReferenceException: This exception is thrown when a circular reference in a parameter is detected.
ParameterNotFoundException: This exception is thrown when a non-existent parameter is used.
RuntimeException: Base RuntimeException for Dependency Injection component.
ServiceCircularReferenceException: This exception is thrown when a circular reference is detected.
ServiceNotFoundException: This exception is thrown when a non-existent service is requested.
ExpressionLanguage: Adds some function to the default ExpressionLanguage.
ExpressionLanguageProvider: Define some ExpressionLanguage functions.
AbstractExtension: An Extension that provides configuration hooks.
Extension: Provides useful features shared by many extensions.
LazyServiceInstantiator
RealServiceInstantiator: Noop proxy instantiator - produces the real service instead of a proxy instance.
LazyServiceDumper
NullDumper: Null dumper, negates any proxy code generation for any given service definition.
ProxyHelper
ClosureLoader: ClosureLoader loads service definitions from a PHP closure.
AbstractConfigurator
AbstractServiceConfigurator
AliasConfigurator
ClosureReferenceConfigurator
ContainerConfigurator
DefaultsConfigurator
EnvConfigurator: Placeholder for a parameter.
FromCallableConfigurator
InlineServiceConfigurator
InstanceofConfigurator
ParametersConfigurator
PrototypeConfigurator
ReferenceConfigurator
ServiceConfigurator
ServicesConfigurator
DirectoryLoader: DirectoryLoader is a recursive loader to go through directories.
FileLoader: FileLoader is the abstract class used by all built-in loaders that are file based.
GlobFileLoader: GlobFileLoader loads files from a glob pattern.
IniFileLoader: IniFileLoader loads parameters from INI files.
PhpFileLoader: PhpFileLoader loads service definitions from a PHP file.
XmlFileLoader: XmlFileLoader loads XML files service definitions.
YamlFileLoader: YamlFileLoader loads YAML files service definitions.
Parameter: Parameter represents a parameter reference.
ContainerBag: Holds read-only parameters.
EnvPlaceholderParameterBag: Holds parameters.
FrozenParameterBag: Holds read-only parameters.
ParameterBag: Holds parameters.
Reference: Reference represents a service reference.
ReverseContainer: Turns public and "container.reversible" services back to their ids.
ServiceLocator
TypedReference: Represents a PHP type-hinted service reference.
Variable: Represents a variable.
AbstractUriElement: Any HTML element that can link to an URI.
Crawler: Crawler eases navigation of a list of \DOMNode objects.
ChoiceFormField: ChoiceFormField represents a choice form field.
FileFormField: FileFormField represents a file form field (an HTML file input tag).
FormField: FormField is the abstract class for all form fields.
InputFormField: InputFormField represents an input form field (an HTML input tag).
TextareaFormField: TextareaFormField represents a textarea form field (an HTML textarea tag).
Form: Form represents an HTML form.
Image: Image represents an HTML image (an HTML img tag).
Link: Link represents an HTML link (an HTML a, area or link tag).
CrawlerAnySelectorTextContains
CrawlerAnySelectorTextSame
CrawlerSelectorAttributeValueSame
CrawlerSelectorCount
CrawlerSelectorExists
CrawlerSelectorTextContains
CrawlerSelectorTextSame
UriResolver: The UriResolver class takes an URI (relative, absolute, fragment, etc.) and turns it into an absolute URI against another given base URI.
DebugCommand: A console command to debug current dotenv files with variables and values.
DotenvDumpCommand: A console command to compile .env files into a PHP-optimized file called .env.local.php.
Dotenv: Manages .env files.
FormatException: Thrown when a file has a syntax error.
FormatExceptionContext
PathException: Thrown when a file does not exist or is not readable.
AsEventListener: Service tag to autoconfigure event listeners.
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.
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.
Compiler: Compiles a node to PHP code.
Expression: Represents an expression.
ExpressionFunction: Represents a function that can be used in an expression.
ExpressionLanguage: Allows to compile and evaluate expressions written in your own DSL.
Lexer: Lexes an expression.
Node: Represents a node in the AST.
ParsedExpression: Represents an already parsed expression.
Parser: Parsers a token stream.
SerializedParsedExpression: Represents an already parsed expression.
SyntaxError
Token: Represents a Token.
TokenStream: Represents a token stream.
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
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.
VcsIgnoredFilterIterator
SplFileInfo: Extends \SplFileInfo to support relative paths.
HtmlSanitizer
HtmlSanitizerConfig
MastermindsParser
NativeParser: Parser using PHP 8.4's new Dom API.
UrlAttributeSanitizer
BlockedNode
DocumentNode
Node
TextNode
AmpHttpClient: A portable implementation of the HttpClientInterface contracts based on Amp's HTTP client.
CachingHttpClient: Adds caching on top of an HTTP client (per RFC 9111).
ServerSentEvent
CurlHttpClient: A performant implementation of the HttpClientInterface contracts based on the curl extension.
HttpClientDataCollector
HttpClientPass
EventSourceHttpClient
ChunkCacheItemNotFoundException
ClientException: Represents a 4xx response.
EventSourceException
InvalidArgumentException
JsonException: Thrown by responses' toArray() method when their content cannot be JSON-decoded.
RedirectionException: Represents a 3xx response.
ServerException: Represents a 5xx response.
TimeoutException
TransportException
HttpClient: A factory to instantiate the best possible HTTP client for the runtime.
HttplugClient: An adapter to turn a Symfony HttpClientInterface into an Httplug client.
HttpOptions: A helper providing autocompletion for available options.
PingWebhookMessage
PingWebhookMessageHandler
MockHttpClient: A test-friendly HttpClient that doesn't make actual HTTP requests.
NativeHttpClient: A portable implementation of the HttpClientInterface contracts based on PHP stream wrappers.
NoPrivateNetworkHttpClient: Decorator that blocks requests to private networks by default.
Psr18Client: An adapter to turn a Symfony HttpClientInterface into a PSR-18 ClientInterface.
AsyncContext: A DTO to work with AsyncResponse.
AsyncResponse: Provides a single extension point to process a response's content stream.
JsonMockResponse: A test-friendly response.
MockResponse: A test-friendly response.
ResponseStream
StreamWrapper: Allows turning ResponseInterface instances to PHP streams.
GenericRetryStrategy: Decides to retry the request when HTTP status codes belong to the given list of codes.
RetryableHttpClient: Automatically retries failing HTTP requests.
ScopingHttpClient: Auto-configure the default options based on the requested URL.
HarFileResponseFactory: See: https://w3c.github.io/web-performance/specs/HAR/Overview.html.
ThrottlingHttpClient: Limits the number of requests within a certain period.
TraceableHttpClient
UriTemplateHttpClient
Normalizer
Attribute
PhpToken
UnhandledMatchError
ValueError
DateError
DateException
DateInvalidOperationException
DateInvalidTimeZoneException
DateMalformedIntervalStringException
DateMalformedPeriodStringException
DateMalformedStringException
DateObjectError
DateRangeError
Override
SQLite3Exception
Deprecated
ReflectionConstant
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.
RunProcessFailedException: RuntimeException for the Process Component.
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.
RunProcessContext
RunProcessMessage
RunProcessMessageHandler
PhpExecutableFinder: An executable finder specifically designed for the PHP executable.
PhpProcess: PhpProcess runs a PHP script in an independent process.
PhpSubprocess: PhpSubprocess runs a PHP command as a subprocess while keeping the original php.ini settings.
Process: Process is a thin wrapper around proc_* functions to easily start independent PHP processes.
ProcessUtils: ProcessUtils is a bunch of utility methods.
AccessException: Thrown when a property path is not available.
InvalidArgumentException: Base InvalidArgumentException for the PropertyAccess component.
InvalidPropertyPathException: Thrown when a property path is malformed.
InvalidTypeException: Thrown when a type of given value does not match an expected type.
NoSuchIndexException: Thrown when an index cannot be found.
NoSuchPropertyException: Thrown when a property cannot be found.
OutOfBoundsException: Base OutOfBoundsException for the PropertyAccess component.
RuntimeException: Base RuntimeException for the PropertyAccess component.
UnexpectedTypeException: Thrown when a value does not match an expected type.
UninitializedPropertyException: Thrown when a property is not initialized.
PropertyAccess: Entry point of the PropertyAccess component.
PropertyAccessor: Default implementation of {@link PropertyAccessorInterface}.
PropertyAccessorBuilder: A configurable builder to create a PropertyAccessor.
PropertyPath: Default implementation of {@link PropertyPathInterface}.
PropertyPathBuilder
PropertyPathIterator: Traverses a property path and provides additional methods to find out information about the current element.
PropertyInfoConstructorPass: Adds extractors to the property_info.constructor_extractor service.
PropertyInfoPass: Adds extractors to the property_info service.
ConstructorExtractor: Extracts the constructor argument type using ConstructorArgumentTypeExtractorInterface implementations.
PhpDocExtractor: Extracts data using a PHPDoc parser.
PhpStanExtractor: Extracts data using PHPStan parser.
ReflectionExtractor: Extracts data using the reflection API.
SerializerExtractor: Lists available properties using Symfony Serializer Component metadata.
PropertyInfoCacheExtractor: Adds a PSR-6 cache layer on top of an extractor.
PropertyInfoExtractor: Default {@see PropertyInfoExtractorInterface} implementation.
PropertyReadInfo: The property read info tells how a property can be read.
PropertyWriteInfo: The write mutator defines how a property can be written.
Type: Type value object (immutable).
PhpDocTypeHelper: Transforms a php doc type to a {@link Type} instance.
Alias
Route: Annotation class for @Route().
Route: Annotation class for @Route().
CompiledRoute: CompiledRoutes are returned by the RouteCompiler class.
AddExpressionLanguageProvidersPass: Registers the expression language providers.
RoutingResolverPass: Adds tagged routing.loader services to routing.resolver service.
InvalidArgumentException
InvalidParameterException: Exception thrown when a parameter is not valid.
MethodNotAllowedException: The resource was found but the request method is not allowed.
MissingMandatoryParametersException: Exception thrown when a route cannot be generated because of missing mandatory parameters.
NoConfigurationException: Exception thrown when no routes are configured.
ResourceNotFoundException: The resource was not found.
RouteCircularReferenceException
RouteNotFoundException: Exception thrown when a route does not exist.
RuntimeException
CompiledUrlGenerator: Generates URLs based on rules dumped by CompiledUrlGeneratorDumper.
CompiledUrlGeneratorDumper: CompiledUrlGeneratorDumper creates a PHP array to be used with CompiledUrlGenerator.
GeneratorDumper: GeneratorDumper is the base class for all built-in generator dumpers.
UrlGenerator: UrlGenerator can generate a URL or a path for any route in the RouteCollection based on the passed parameters.
AnnotationClassLoader: AttributeClassLoader loads routing information from a PHP class and its methods.
AnnotationDirectoryLoader: AttributeDirectoryLoader loads routing information from attributes set on PHP classes and methods.
AnnotationFileLoader: AttributeFileLoader loads routing information from attributes set on a PHP class and its methods.
AttributeClassLoader: AttributeClassLoader loads routing information from a PHP class and its methods.
AttributeDirectoryLoader: AttributeDirectoryLoader loads routing information from attributes set on PHP classes and methods.
AttributeFileLoader: AttributeFileLoader loads routing information from attributes set on a PHP class and its methods.
ClosureLoader: ClosureLoader loads routes from a PHP closure.
AliasConfigurator
CollectionConfigurator
ImportConfigurator
RouteConfigurator
RoutingConfigurator
ContainerLoader: A route loader that executes a service from a PSR-11 container to load the routes.
DirectoryLoader: FileLoader is the abstract class used by all built-in loaders that are file based.
GlobFileLoader: GlobFileLoader loads files from a glob pattern.
ObjectLoader: A route loader that calls a method on an object to load the routes.
PhpFileLoader: PhpFileLoader loads routes from a PHP file.
Psr4DirectoryLoader: A loader that discovers controller classes in a directory that follows PSR-4.
XmlFileLoader: XmlFileLoader loads XML routing files.
YamlFileLoader: YamlFileLoader loads Yaml routing files.
CompiledUrlMatcher: Matches URLs based on rules dumped by CompiledUrlMatcherDumper.
CompiledUrlMatcherDumper: CompiledUrlMatcherDumper creates PHP arrays to be used with CompiledUrlMatcher.
MatcherDumper: MatcherDumper is the abstract class for all built-in matcher dumpers.
ExpressionLanguageProvider: Exposes functions defined in the request context to route conditions.
RedirectableUrlMatcher: UrlMatcher matches URL based on a set of routes.
TraceableUrlMatcher: TraceableUrlMatcher helps debug path info matching by tracing the match.
UrlMatcher: UrlMatcher matches URL based on a set of routes.
RequestContext: Holds information about the current request.
EnumRequirement
Route: A Route describes a route and its parameters.
RouteCollection: A RouteCollection represents a set of Route instances.
RouteCompiler: RouteCompiler compiles Route instances to CompiledRoute instances.
Router: The Router class is an example of the integration of all pieces of the routing system for easier use.
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.
AbstractString: Represents a string of abstract characters.
AbstractUnicodeString: Represents a string of abstract Unicode characters.
ByteString: Represents a binary-safe string of bytes.
CodePointString: Represents a string of Unicode code points encoded as UTF-8.
InvalidArgumentException
RuntimeException
EnglishInflector
FrenchInflector: French inflector.
LazyString: A string whose value is computed lazily by a callback.
AsciiSlugger
UnicodeString: Represents a string of Unicode grapheme clusters encoded as UTF-8.
InvalidArgumentException
LogicException
RuntimeException
UnsupportedException
ArrayShapeType: Represents the exact shape of an array.
BackedEnumType
BuiltinType
CollectionType: Represents a key/value collection type.
EnumType
GenericType: Represents a generic type, which is a type that holds variable parts.
IntersectionType
NullableType
ObjectType
TemplateType: Represents a template placeholder, such as "T" in "Collection<T>".
UnionType
Type
TypeContext: Type resolving context.
TypeContextFactory: Creates a type resolving context.
PhpDocAwareReflectionTypeResolver: Resolves type on reflection prioriziting PHP documentation.
ReflectionParameterTypeResolver: Resolves type for a given parameter reflection.
ReflectionPropertyTypeResolver: Resolves type for a given property reflection.
ReflectionReturnTypeResolver: Resolves return type for a given function reflection.
ReflectionTypeResolver: Resolves type for a given type reflection.
StringTypeResolver: Resolves type for a given string.
TypeResolver: Resolves type for a given subject by delegating resolving to nested type resolvers.
ClassNotFoundException
LogicException
NotInstantiableTypeException
Hydrator: Utility class to hydrate the properties of an object.
Instantiator: A utility class to create objects without calling their constructor.
ProxyHelper
VarExporter: Exports serializable PHP values to PHP code.
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.
AbstractTwigCallable
AsTwigFilter: Registers a method as template filter.
AsTwigFunction: Registers a method as template function.
AsTwigTest: Registers a method as template test.
FirstClassTwigCallableReady: Marks nodes that are ready to accept a TwigCallable instead of its name.
YieldReady: Marks nodes that are ready for using "yield" instead of "echo" or "print()" for rendering.
ChainCache: Chains several caches together.
FilesystemCache: Implements a cache on the filesystem.
NullCache: Implements a no-cache strategy.
ReadOnlyFilesystemCache: Implements a cache on the filesystem that can only be read, not written to.
Compiler
DeprecatedCallableInfo
Environment: Stores the Twig configuration and renders templates.
Error: Twig base exception.
LoaderError: Exception thrown when an error occurs during template loading.
RuntimeError: Exception thrown when an error occurs at runtime.
SyntaxError: \Exception thrown when a syntax error occurs during lexing or parsing of a template.
AbstractExpressionParser
PrecedenceChange: Represents a precedence change.
ExpressionParser: Parses expressions.
AbstractExtension
AttributeExtension: Define Twig filters, functions, and tests with PHP attributes.
CoreExtension
DebugExtension
EscaperExtension
OptimizerExtension
ProfilerExtension
SandboxExtension
StringLoaderExtension
FileExtensionEscapingStrategy: Default autoescaping strategy based on file names.
Lexer
ArrayLoader: Loads a template from an array.
ChainLoader: Loads templates from other loaders.
FilesystemLoader: Loads template from the filesystem.
Markup: Marks a content as safe.
AutoEscapeNode: Represents an autoescape node.
BlockNode: Represents a block node.
BlockReferenceNode: Represents a block call node.
BodyNode: Represents a body node.
CaptureNode: Represents a node for which we need to capture the output.
CheckSecurityCallNode: Represents a node in the AST.
CheckSecurityNode: Represents a node in the AST.
CheckToStringNode: Checks if casting an expression to __toString() is allowed by the sandbox.
DeprecatedNode: Represents a deprecated node.
DoNode: Represents a do node.
EmbedNode: Represents an embed node.
EmptyNode: Represents an empty node.
AbstractExpression: Abstract class for all nodes that represents an expression.
ArrayExpression: Abstract class for all nodes that represents an expression.
ArrowFunctionExpression: Represents an arrow function.
AssignNameExpression: Abstract class for all nodes that represents an expression.
AbstractBinary: Abstract class for all nodes that represents an expression.
AddBinary: Abstract class for all nodes that represents an expression.
AndBinary: Abstract class for all nodes that represents an expression.
BitwiseAndBinary: Abstract class for all nodes that represents an expression.
BitwiseOrBinary: Abstract class for all nodes that represents an expression.
BitwiseXorBinary: Abstract class for all nodes that represents an expression.
ConcatBinary: Abstract class for all nodes that represents an expression.
DivBinary: Abstract class for all nodes that represents an expression.
ElvisBinary: Abstract class for all nodes that represents an expression.
EndsWithBinary: Abstract class for all nodes that represents an expression.
EqualBinary: Abstract class for all nodes that represents an expression.
FloorDivBinary: Abstract class for all nodes that represents an expression.
GreaterBinary: Abstract class for all nodes that represents an expression.
GreaterEqualBinary: Abstract class for all nodes that represents an expression.
HasEveryBinary: Abstract class for all nodes that represents an expression.
HasSomeBinary: Abstract class for all nodes that represents an expression.
InBinary: Abstract class for all nodes that represents an expression.
LessBinary: Abstract class for all nodes that represents an expression.
LessEqualBinary: Abstract class for all nodes that represents an expression.
MatchesBinary: Abstract class for all nodes that represents an expression.
ModBinary: Abstract class for all nodes that represents an expression.
MulBinary: Abstract class for all nodes that represents an expression.
NotEqualBinary: Abstract class for all nodes that represents an expression.
NotInBinary: Abstract class for all nodes that represents an expression.
NullCoalesceBinary: Abstract class for all nodes that represents an expression.
OrBinary: Abstract class for all nodes that represents an expression.
PowerBinary: Abstract class for all nodes that represents an expression.
RangeBinary: Abstract class for all nodes that represents an expression.
SpaceshipBinary: Abstract class for all nodes that represents an expression.
StartsWithBinary: Abstract class for all nodes that represents an expression.
SubBinary: Abstract class for all nodes that represents an expression.
XorBinary: Abstract class for all nodes that represents an expression.
BlockReferenceExpression: Represents a block call node.
CallExpression: Abstract class for all nodes that represents an expression.
ConditionalExpression: Abstract class for all nodes that represents an expression.
ConstantExpression: Abstract class for all nodes that represents an expression.
DefaultFilter: Returns the value or the default value when it is undefined or empty.
RawFilter: Abstract class for all nodes that represents an expression.
FilterExpression: Abstract class for all nodes that represents an expression.
FunctionExpression: Abstract class for all nodes that represents an expression.
EnumCasesFunction: Abstract class for all nodes that represents an expression.
EnumFunction: Abstract class for all nodes that represents an expression.
GetAttrExpression: Abstract class for all nodes that represents an expression.
ListExpression: Abstract class for all nodes that represents an expression.
MacroReferenceExpression: Represents a macro call node.
MethodCallExpression: Abstract class for all nodes that represents an expression.
NameExpression: Abstract class for all nodes that represents an expression.
NullCoalesceExpression: Abstract class for all nodes that represents an expression.
ParentExpression: Represents a parent node.
TempNameExpression: Abstract class for all nodes that represents an expression.
ConditionalTernary: Abstract class for all nodes that represents an expression.
ConstantTest: Checks if a variable is the exact same value as a constant.
DefinedTest: Checks if a variable is defined in the current context.
DivisiblebyTest: Checks if a variable is divisible by a number.
EvenTest: Checks if a number is even.
NullTest: Checks that an expression is null.
OddTest: Checks if a number is odd.
SameasTest: Checks if a variable is the same as another one (=== in PHP).
TrueTest: Checks that an expression is true.
TestExpression: Abstract class for all nodes that represents an expression.
AbstractUnary: Abstract class for all nodes that represents an expression.
NegUnary: Abstract class for all nodes that represents an expression.
NotUnary: Abstract class for all nodes that represents an expression.
PosUnary: Abstract class for all nodes that represents an expression.
SpreadUnary: Abstract class for all nodes that represents an expression.
StringCastUnary: Abstract class for all nodes that represents an expression.
AssignContextVariable: Abstract class for all nodes that represents an expression.
AssignTemplateVariable: Abstract class for all nodes that represents an expression.
ContextVariable: Abstract class for all nodes that represents an expression.
LocalVariable: Abstract class for all nodes that represents an expression.
TemplateVariable: Abstract class for all nodes that represents an expression.
VariadicExpression: Abstract class for all nodes that represents an expression.
FlushNode: Represents a flush node.
ForElseNode: Represents an else node in a for loop.
ForLoopNode: Internal node used by the for node.
ForNode: Represents a for node.
IfNode: Represents an if node.
ImportNode: Represents an import node.
IncludeNode: Represents an include node.
MacroNode: Represents a macro node.
ModuleNode: Represents a module node.
NameDeprecation: Represents a deprecation for a named node or attribute on a Node.
Node: Represents a node in the AST.
Nodes: Represents a list of nodes.
PrintNode: Represents a node that outputs an expression.
SandboxNode: Represents a sandbox node.
SetNode: Represents a set node.
TextNode: Represents a text node.
TypesNode: Represents a types node.
WithNode: Represents a nested "with" scope.
NodeTraverser: A node traverser.
AbstractNodeVisitor: Used to make node visitors compatible with Twig 1.x and 2.x.
OperatorPrecedenceChange: Represents a precedence change.
Parser
BaseDumper
BlackfireDumper
HtmlDumper
TextDumper
EnterProfileNode: Represents a profile enter node.
LeaveProfileNode: Represents a profile leave node.
ProfilerNodeVisitor
Profile
EscaperRuntime
ContainerRuntimeLoader: Lazily loads Twig runtime implementations from a PSR-11 container.
FactoryRuntimeLoader: Lazy loads the runtime implementations for a Twig element.
SecurityError: Exception thrown when a security error occurs at runtime.
SecurityNotAllowedFilterError: Exception thrown when a not allowed filter is used in a template.
SecurityNotAllowedFunctionError: Exception thrown when a not allowed function is used in a template.
SecurityNotAllowedMethodError: Exception thrown when a not allowed class method is used in a template.
SecurityNotAllowedPropertyError: Exception thrown when a not allowed class property is used in a template.
SecurityNotAllowedTagError: Exception thrown when a not allowed tag is used in a template.
SecurityPolicy: Represents a security policy which need to be enforced when sandbox mode is enabled.
Source: Holds information about a non-compiled Twig template.
TemplateWrapper: Exposes a template to userland.
IntegrationTestCase: Integration test helper.
NodeTestCase
Token
AbstractTokenParser: Base class for all token parsers.
TokenStream: Represents a token stream.
TwigFilter: Represents a template filter.
TwigFunction: Represents a template function.
TwigTest: Represents a template test.
DeprecationCollector
TemplateDirIterator
Dotenv
InvalidEncodingException
InvalidFileException
InvalidPathException
ValidationException
Loader
Resolver
Entry
EntryParser
Lexer
Lines
Parser
Value
ApacheAdapter
ArrayAdapter
EnvConstAdapter
GuardedWriter
ImmutableWriter
MultiReader
MultiWriter
PutenvAdapter
ReplacingWriter
ServerConstAdapter
AdapterRepository
RepositoryBuilder
FileStore
StoreBuilder
StringStore
Validator
Assert: Efficient assertions to validate the input/output of your methods.
InvalidArgumentException

Traits

VerifyDeprecations
NotSupportingVisibilityTrait
StreamedCopyTrait
StreamedReadingTrait: A helper for adapters that only handle strings to provide read streams.
StreamedTrait
StreamedWritingTrait
PluggableTrait
FormattableHandlerTrait: Helper trait for implementing FormattableInterface
ProcessableHandlerTrait: Helper trait for implementing ProcessableInterface
WebRequestRecognizerTrait
SmartObject: Strict class for better experience.
StaticClass: Static class.
ParserAssertions: Convenience assertion methods. When writing tests for your own parsers, extend from this instead of PHPUnit's TestCase.
Attributes
MenuEntryManagement
SubSectionHierarchyHandler
BCInlineNodeBehavior
EmbeddedReferenceParser
PizzaSauceTrait: PizzaSauceTrait provides basic saucing functionality for pizzas.
PizzaToppingTrait: PizzaToppingTrait demonstrates a trait that uses another trait.
SharedTrait: Trait that all pizza's could share.
LegacyArrayAccess
BelongsToClassTraitOrInterface
BelongsToMethod
CanBeAbstract
CanBeByReference
CanBeDeprecated
CanBeFinal
CanBeVariadic
CanHaveADefaultValue
CanHaveAType
ExtendsClass
HasAttributes
HasConstants
HasDescription: This file is part of phpDocumentor.
HasErrors: This file is part of phpDocumentor.
HasFqsen
HasInheritance
HasMetadata
HasMethods
HasName
HasNamespace
HasPackage
HasProperties
HasSummary
HasTags
HasVisibility
ImplementsInterfaces
IsInFile
UsesTraits
IoTrait
HasAttributes
ExampleNestedTrait
MetadataContainerTestHelper
NodeAttributes
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.
ClockAwareTrait: A trait to help write time-sensitive classes.
ClockSensitiveTrait: Helps with mocking the time in your test cases.
LockableTrait: Basic lock feature for commands.
TesterTrait
CacheTrait: An implementation of CacheInterface for PSR-6 CacheItemPoolInterface classes.
ServiceLocatorTrait: A trait to help implement ServiceProviderInterface.
ServiceMethodsSubscriberTrait: Implementation of ServiceSubscriberInterface that determines subscribed services from methods that have the #[SubscribedService] attribute.
ServiceSubscriberTrait: Implementation of ServiceSubscriberInterface that determines subscribed services from methods that have the #[SubscribedService] attribute.
TranslatorTrait: A trait to help implement TranslatorInterface and LocaleAwareInterface.
ReferenceSetArgumentTrait
PriorityTaggedServiceTrait: Trait that allows a generic method to find and sort service by priority option in the tag.
ContainerAwareTrait: ContainerAware trait.
ExtensionTrait
AbstractTrait
ArgumentTrait
AutoconfigureTrait
AutowireTrait
BindTrait
CallTrait
ClassTrait
ConfiguratorTrait
ConstructorTrait
DecorateTrait
DeprecateTrait
FactoryTrait
FileTrait
FromCallableTrait
LazyTrait
ParentTrait
PropertyTrait
PublicTrait
ShareTrait
SyntheticTrait
TagTrait
AsyncDecoratorTrait: Eases with processing responses while streaming them.
DecoratorTrait: Eases with writing decorators.
HttpClientTrait: Provides the common logic from writing HttpClientInterface implementations.
AddTrait
RouteTrait
TypeFactoryTrait: Helper trait to create any type easily.
LazyGhostTrait
LazyProxyTrait
ArgumentsTrait
SupportDefinedTestTrait
Mixin: This trait provides nullOr*, all* and allNullOr* variants of assertion base methods.

Enums

Bom
JsonFormat
Comparison
ArrayShape
Type
TypeCastingTargetType
SchemeType
UriScheme
HostFormat
HostType
Error
QueryComposeMode
QueryExtractMode
StringCoercionMode
UriComparisonMode
UrnComparisonMode
UnindentStrategy
Delivery: This is an enum example
VisibilityModifier
MyBackedEnum
MyEnum
MyEnumWithConstant
AnsiColorMode
HtmlSanitizerAction
Requirement
TypeIdentifier: Identifier of a PHP native type.
InfixAssociativity

Constants

_OUTSIDE_OVEN_TEMPERATURE = 9002
CURL_HTTP_VERSION_3 = 30
CURL_HTTP_VERSION_3ONLY = 31
FILTER_VALIDATE_BOOL = \FILTER_VALIDATE_BOOLEAN
GRAPHEME_EXTR_COUNT = 0
GRAPHEME_EXTR_COUNT = 0
GRAPHEME_EXTR_MAXBYTES = 1
GRAPHEME_EXTR_MAXBYTES = 1
GRAPHEME_EXTR_MAXCHARS = 2
GRAPHEME_EXTR_MAXCHARS = 2
HIGHER_OVEN_TEMPERATURE = 9002
IDNA_ALLOW_UNASSIGNED = 1
IDNA_ALLOW_UNASSIGNED = 1
IDNA_CHECK_BIDI = 4
IDNA_CHECK_BIDI = 4
IDNA_CHECK_CONTEXTJ = 8
IDNA_CHECK_CONTEXTJ = 8
IDNA_DEFAULT = 0
IDNA_DEFAULT = 0
IDNA_ERROR_BIDI = 2048
IDNA_ERROR_BIDI = 2048
IDNA_ERROR_CONTEXTJ = 4096
IDNA_ERROR_CONTEXTJ = 4096
IDNA_ERROR_DISALLOWED = 128
IDNA_ERROR_DISALLOWED = 128
IDNA_ERROR_DOMAIN_NAME_TOO_LONG = 4
IDNA_ERROR_DOMAIN_NAME_TOO_LONG = 4
IDNA_ERROR_EMPTY_LABEL = 1
IDNA_ERROR_EMPTY_LABEL = 1
IDNA_ERROR_HYPHEN_3_4 = 32
IDNA_ERROR_HYPHEN_3_4 = 32
IDNA_ERROR_INVALID_ACE_LABEL = 1024
IDNA_ERROR_INVALID_ACE_LABEL = 1024
IDNA_ERROR_LABEL_HAS_DOT = 512
IDNA_ERROR_LABEL_HAS_DOT = 512
IDNA_ERROR_LABEL_TOO_LONG = 2
IDNA_ERROR_LABEL_TOO_LONG = 2
IDNA_ERROR_LEADING_COMBINING_MARK = 64
IDNA_ERROR_LEADING_COMBINING_MARK = 64
IDNA_ERROR_LEADING_HYPHEN = 8
IDNA_ERROR_LEADING_HYPHEN = 8
IDNA_ERROR_PUNYCODE = 256
IDNA_ERROR_PUNYCODE = 256
IDNA_ERROR_TRAILING_HYPHEN = 16
IDNA_ERROR_TRAILING_HYPHEN = 16
IDNA_NONTRANSITIONAL_TO_ASCII = 16
IDNA_NONTRANSITIONAL_TO_ASCII = 16
IDNA_NONTRANSITIONAL_TO_UNICODE = 32
IDNA_NONTRANSITIONAL_TO_UNICODE = 32
IDNA_USE_STD3_RULES = 2
IDNA_USE_STD3_RULES = 2
IN_FUNCTION_OVEN_TEMPERATURE = 9003
INTL_IDNA_VARIANT_2003 = 0
INTL_IDNA_VARIANT_UTS46 = 1
INTL_IDNA_VARIANT_UTS46 = 1
MAX_OVEN_TEMPERATURE = 9002
MAX_OVEN_TEMPERATURE = 9002
MB_CASE_LOWER = 1
MB_CASE_LOWER = 1
MB_CASE_TITLE = 2
MB_CASE_TITLE = 2
MB_CASE_UPPER = 0
MB_CASE_UPPER = 0
OUTSIDE_OVEN_TEMPERATURE = 9002
OVEN_TEMPERATURE = 9001
OVEN_TEMPERATURE = 9001
OVEN_TEMPERATURE = 9001: This needs a docblock to separate from file docblock
SYMFONY_GRAPHEME_CLUSTER_RX = ((float) \PCRE_VERSION < 10 ? (float) \PCRE_VERSION >= 8.32 : (float) \PCRE_VERSION >= 10.39) ? '\X' : \Symfony\Polyfill\Intl\Grapheme\Grapheme::GRAPHEME_CLUSTER_RX
T_NAME_FULLY_QUALIFIED = 10002
T_NAME_QUALIFIED = 10001
U_IDNA_ACE_PREFIX_ERROR = 66564
U_IDNA_ACE_PREFIX_ERROR = 66564
U_IDNA_CHECK_BIDI_ERROR = 66562
U_IDNA_CHECK_BIDI_ERROR = 66562
U_IDNA_DOMAIN_NAME_TOO_LONG_ERROR = 66568
U_IDNA_DOMAIN_NAME_TOO_LONG_ERROR = 66568
U_IDNA_ERROR_LIMIT = 66569
U_IDNA_ERROR_LIMIT = 66569
U_IDNA_ERROR_START = 66560
U_IDNA_ERROR_START = 66560
U_IDNA_LABEL_TOO_LONG_ERROR = 66566
U_IDNA_LABEL_TOO_LONG_ERROR = 66566
U_IDNA_PROHIBITED_ERROR = 66560
U_IDNA_PROHIBITED_ERROR = 66560
U_IDNA_STD3_ASCII_RULES_ERROR = 66563
U_IDNA_STD3_ASCII_RULES_ERROR = 66563
U_IDNA_UNASSIGNED_ERROR = 66561
U_IDNA_UNASSIGNED_ERROR = 66561
U_IDNA_VERIFICATION_ERROR = 66565
U_IDNA_VERIFICATION_ERROR = 66565
U_IDNA_ZERO_LENGTH_LABEL_ERROR = 66567
U_IDNA_ZERO_LENGTH_LABEL_ERROR = 66567
U_STRINGPREP_CHECK_BIDI_ERROR = 66562
U_STRINGPREP_CHECK_BIDI_ERROR = 66562
U_STRINGPREP_PROHIBITED_ERROR = 66560
U_STRINGPREP_PROHIBITED_ERROR = 66560
U_STRINGPREP_UNASSIGNED_ERROR = 66561
U_STRINGPREP_UNASSIGNED_ERROR = 66561

Functions

autoload() : void: Funkce pro automatické načítání tříd ze složky classes.
encodep() : string: Encodes a UML text description into a special encoding.
encode64() : string
append3bytes() : string
encode6bit() : string
bom_match() : string: DEPRECATION WARNING! This namespace function will be removed in the next major point release.
delimiter_detect() : array<string, int>: DEPRECATION WARNING! This namespace function will be removed in the next major point release.
defineCompatibilityTokens() : void
char() : Parser: Parse a single character.
charI() : Parser: Parse a single character, case-insensitive and case-preserving. On success, it returns the string cased as the actually parsed input.
controlChar() : Parser: Parse a control character (a non-printing character of the Latin-1 subset of Unicode).
upperChar() : Parser: Parse an uppercase character A-Z.
lowerChar() : Parser: Parse a lowercase character a-z.
alphaChar() : Parser: Parse an uppercase or lowercase character A-Z, a-z.
alphaNumChar() : Parser: Parse an alpha or numeric character A-Z, a-z, 0-9.
printChar() : Parser: Parse a printable ASCII char.
punctuationChar() : Parser: Parse a single punctuation character !"#$%&'()*+,-./:;<=>?@[\]^_`{|}~
digitChar() : Parser: Parse 0-9. Returns the digit as a string. Use ->map('intval') or similar to cast it to a numeric type.
binDigitChar() : Parser: Parse a binary character 0 or 1.
octDigitChar() : Parser: Parse an octodecimal character 0-7.
hexDigitChar() : Parser: Parse a hexadecimal numeric character 0123456789abcdefABCDEF.
identity() : Parser: Identity parser, returns the Parser as is.
pure() : Parser: A parser that will have the argument as its output, no matter what the input was. It doesn't consume any input.
optional() : Parser: Optionally parse something, but still succeed if the thing is not there
bind() : Parser: Create a parser that takes the output from the first parser (if successful) and feeds it to the callable. The callable must return another parser. If the first parser fails, the first parser is returned.
apply() : Parser: Sequential application. Given a parser which outputs a callable, return a new parser that applies the callable on the output of the second parser.
sequence() : Parser: Parse something, then follow by something else. Ignore the result of the first parser and return the result of the second parser.
keepFirst() : Parser: Sequence two parsers, and return the output of the first one.
keepSecond() : Parser: Sequence two parsers, and return the output of the second one.
either() : Parser: Either parse the first thing or the second thing
append() : Parser: Combine the parser with another parser of the same type, which will cause the results to be appended.
assemble() : Parser: Append all the passed parsers.
collect() : Parser: Parse into an array that consists of the results of all parsers.
any() : Parser: Tries each parser one by one, returning the result of the first one that succeeds.
choice() : Parser: Tries each parser one by one, returning the result of the first one that succeeds.
atLeastOne() : Parser: One or more repetitions of Parser, with the outputs appended.
zeroOrMore() : Parser: Zero or more repetitions of Parser, with the outputs appended.
repeat() : Parser: Parse something exactly n times
repeatList() : Parser: Parse something exactly n times and return as an array
some() : Parser: Parse something one or more times, and output an array of the successful outputs.
many() : Parser: Parse something zero or more times, and output an array of the successful outputs.
between() : Parser: Parse $open, followed by $middle, followed by $close, and return the result of $middle. Useful for eg. "(value)".
sepBy() : Parser: Parses zero or more occurrences of $parser, separated by $separator. Returns a list of values.
sepBy1() : Parser: Parses one or more occurrences of $parser, separated by $separator. Returns a list of values.
sepBy2() : Parser: Parses 2 or more occurrences of $parser, separated by $separator. Returns a list of values.
notFollowedBy() : Parser: notFollowedBy only succeeds when $parser fails. It never consumes any input.
map() : Parser: Map a function over the parser (which in turn maps it over the result).
lookAhead() : Parser: If $parser succeeds (either consuming input or not), lookAhead behaves like $parser succeeded without consuming anything. If $parser fails, lookAhead has no effect, i.e. it will fail to consume input if $parser fails consuming input.
curry() : callable
curry_right() : callable
_curry_array_args() : callable
__() : Placeholder: Gets a special placeholder value used to specify "gaps" within curried functions, allowing partial application of any combination of arguments, regardless of their positions. Should be used only for required arguments.
expression() : Parser: Build an expression parser from a term parser and an expression table.
binaryOperator() : BinaryOperator: A binary operator in an expression. The operands of the expression will be passed into $transform to produce the output of the expression parser.
unaryOperator() : UnaryOperator<TSymbol, TExpressionAST>: A unary operator in an expression. The operands of the expression will be passed into $transform to produce the output of the expression parser.
leftAssoc() : LeftAssoc
rightAssoc() : RightAssoc
nonAssoc() : NonAssoc
prefix() : Prefix
postfix() : Postfix
integer() : Parser: Parse an integer and return it as a string. Use ->map('intval') or similar to cast it to a numeric type.
float() : Parser: Parse a float and return it as a string. Use ->map('floatval') or similar to cast it to a numeric type.
isEqual() : callable: Creates an equality predicate
notPred() : callable: Negates a predicate.
andPred() : callable: Boolean And predicate.
orPred() : callable: Boolean Or predicate.
isCharCode() : callable: Predicate that checks if a character is in an array of character codes.
isSpace() : callable: Returns true for a space character, and the control characters \t, \n, \r, \f, \v.
isHSpace() : callable: Like 'isSpace', but does not accept newlines and carriage returns.
isDigit() : callable: True for 0-9
isControl() : callable: Control character predicate (a non-printing character of the Latin-1 subset of Unicode).
isBlank() : callable: Returns true for a space or a tab character
isWhitespace() : callable: Returns true for a space character, and \t, \n, \r, \f, \v.
isUpper() : callable: Returns true for an uppercase character A-Z.
isLower() : mixed: Returns true for a lowercase character a-z.
isAlpha() : callable: Returns true for an uppercase or lowercase character A-Z, a-z.
isAlphaNum() : callable: Returns true for an alpha or numeric character A-Z, a-z, 0-9.
isHexDigit() : callable: Returns true if the given character is a hexadecimal numeric character 0123456789abcdefABCDEF.
isPrintable() : callable: Returns true if the given character is a printable ASCII char.
isPunctuation() : callable: Returns true if the given character is a punctuation character !"#$%&'()*+,-./:;<=>?@[\]^_`{|}~
satisfy() : Parser: A parser that satisfies a predicate on a single token. Useful as a building block for writing things like char(), digit().
skipWhile() : Parser: Skip 0 or more characters as long as the predicate holds.
skipWhile1() : Parser: Skip 1 or more characters as long as the predicate holds.
takeWhile() : Parser: Keep parsing 0 or more characters as long as the predicate holds.
takeWhile1() : Parser: Keep parsing 1 or more characters as long as the predicate holds.
anySingle() : Parser: Parse and return a single character of anything.
anything() : Parser: Parse and return a single character of anything.
anySingleBut() : Parser: Match any character but the given one.
oneOf() : Parser: Succeeds if the current character is in the supplied list of characters. Returns the parsed character.
oneOfS() : Parser: A compact form of 'oneOf'.
noneOf() : Parser: The dual of 'oneOf'. Succeeds if the current character is not in the supplied list of characters. Returns the parsed character.
noneOfS() : Parser: A compact form of 'noneOf'.
takeRest() : Parser: Consume the rest of the input and return it as a string. This parser never fails, but may return the empty string.
nothing() : Parser: Parse nothing, but still succeed.
everything() : Parser: Parse everything; that is, consume the rest of the input until the end.
succeed() : Parser: Always succeed, no matter what the input was.
fail() : Parser: Always fail, no matter what the input was.
eof() : Parser: Parse the end of the input
recursive() : Parser: Create a recursive parser. Used in combination with Parser#recurse().
emit() : Parser: If the parser is successful, call the $receiver function with the output of the parser. The resulting parser behaves identical to the original one. This combinator is useful for expressing side effects during the parsing process. It can be hooked into existing event publishing libraries by using $receiver as an adapter for those. Other use cases are logging, caching, performing an action whenever a value is matched in a long-running input stream, .
space() : Parser: Parse a single space character.
tab() : Parser: Parse a single tab character.
blank() : Parser: Parse a space or tab.
whitespace() : Parser: Parse a space character, and \t, \n, \r, \f, \v.
newline() : Parser: Parse a newline character.
crlf() : Parser: Parse a carriage return character and a newline character. Return the two characters. {\r\n}
eol() : Parser: Parse a newline or a crlf.
skipSpace() : Parser: Skip zero or more white space characters.
skipHSpace() : Parser: Like 'skipSpace', but does not accept newlines and carriage returns.
skipSpace1() : Parser: Skip one or more white space characters.
skipHSpace1() : Parser: Like 'skipSpace1', but does not accept newlines and carriage returns.
string() : Parser: Parse a non-empty string.
stringI() : Parser: Parse a non-empty string, case-insensitive, and case-preserving. On success, it returns the string cased as the actually parsed input.
templateArray() : array<string|int, Node>, file: string, format: string}>: Helper function to configure multiple templates.
template() : Node>, file: string, format: string}: Helper function to configure templates.
heatOven() : mixed
coolOven() : bool
turnOffOven() : void
populateTemperature() : void
h() : mixed
i() : mixed
j() : mixed
a() : mixed
libAutoload() : void: autoloader function.
in_function_define() : mixed
simpleFunction() : void
now() : DatePoint
trigger_deprecation() : void: Triggers a silenced deprecation notice.
param() : ParamConfigurator: Creates a parameter.
service() : ReferenceConfigurator: Creates a reference to a service.
inline_service() : InlineServiceConfigurator: Creates an inline service.
service_locator() : ServiceLocatorArgument: Creates a service locator.
iterator() : IteratorArgument: Creates a lazy iterator.
tagged_iterator() : TaggedIteratorArgument: Creates a lazy iterator by tag name.
tagged_locator() : ServiceLocatorArgument: Creates a service locator by tag name.
expr() : Expression: Creates an expression.
abstract_arg() : AbstractArgument: Creates an abstract argument.
env() : EnvConfigurator: Creates an environment variable reference.
service_closure() : ClosureReferenceConfigurator: Creates a closure service reference.
closure() : InlineServiceConfigurator: Creates a closure.
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
grapheme_extract() : mixed
grapheme_stripos() : mixed
grapheme_stristr() : mixed
grapheme_strlen() : mixed
grapheme_strpos() : mixed
grapheme_strripos() : mixed
grapheme_strrpos() : mixed
grapheme_strstr() : mixed
grapheme_substr() : mixed
grapheme_str_split() : mixed
grapheme_str_split() : array<string|int, mixed>|false
grapheme_extract() : string|false
grapheme_stripos() : int|false
grapheme_stristr() : string|false
grapheme_strlen() : int|false|null
grapheme_strpos() : int|false
grapheme_strripos() : int|false
grapheme_strrpos() : int|false
grapheme_strstr() : string|false
grapheme_substr() : string|false
idn_to_ascii() : mixed
idn_to_utf8() : mixed
idn_to_ascii() : string|false
idn_to_utf8() : string|false
normalizer_is_normalized() : mixed
normalizer_normalize() : mixed
normalizer_is_normalized() : bool
normalizer_normalize() : string|false
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_ucfirst() : string
mb_lcfirst() : string
mb_trim() : string
mb_ltrim() : string
mb_rtrim() : 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|null
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
mb_ucfirst() : string
mb_lcfirst() : string
mb_trim() : string
mb_ltrim() : string
mb_rtrim() : string
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
json_validate() : bool
mb_str_pad() : string
stream_context_set_options() : bool
str_increment() : string
str_decrement() : string
ldap_exop_sync() : bool
ldap_connect_wallet() : mixed
ldap_exop_sync() : bool
ldap_connect_wallet() : Connection|false
array_find() : mixed
array_find_key() : mixed
array_any() : bool
array_all() : bool
fpow() : float
mb_ucfirst() : string
mb_lcfirst() : string
mb_trim() : string
mb_ltrim() : string
mb_rtrim() : string
bcdivmod() : array<string|int, mixed>|null
grapheme_str_split() : mixed
grapheme_str_split() : array<string|int, mixed>|false
u() : UnicodeString
b() : ByteString
s() : UnicodeString|ByteString

_OUTSIDE_OVEN_TEMPERATURE


    public
        mixed
    _OUTSIDE_OVEN_TEMPERATURE
    = 9002

CURL_HTTP_VERSION_3


    public
        mixed
    CURL_HTTP_VERSION_3
    = 30

CURL_HTTP_VERSION_3ONLY


    public
        mixed
    CURL_HTTP_VERSION_3ONLY
    = 31

FILTER_VALIDATE_BOOL


    public
        mixed
    FILTER_VALIDATE_BOOL
    = \FILTER_VALIDATE_BOOLEAN

GRAPHEME_EXTR_COUNT


    public
        mixed
    GRAPHEME_EXTR_COUNT
    = 0

GRAPHEME_EXTR_COUNT


    public
        mixed
    GRAPHEME_EXTR_COUNT
    = 0

GRAPHEME_EXTR_MAXBYTES


    public
        mixed
    GRAPHEME_EXTR_MAXBYTES
    = 1

GRAPHEME_EXTR_MAXBYTES


    public
        mixed
    GRAPHEME_EXTR_MAXBYTES
    = 1

GRAPHEME_EXTR_MAXCHARS


    public
        mixed
    GRAPHEME_EXTR_MAXCHARS
    = 2

GRAPHEME_EXTR_MAXCHARS


    public
        mixed
    GRAPHEME_EXTR_MAXCHARS
    = 2

HIGHER_OVEN_TEMPERATURE


    public
        mixed
    HIGHER_OVEN_TEMPERATURE
    = 9002

IDNA_ALLOW_UNASSIGNED


    public
        mixed
    IDNA_ALLOW_UNASSIGNED
    = 1

IDNA_ALLOW_UNASSIGNED


    public
        mixed
    IDNA_ALLOW_UNASSIGNED
    = 1

IDNA_CHECK_BIDI


    public
        mixed
    IDNA_CHECK_BIDI
    = 4

IDNA_CHECK_BIDI


    public
        mixed
    IDNA_CHECK_BIDI
    = 4

IDNA_CHECK_CONTEXTJ


    public
        mixed
    IDNA_CHECK_CONTEXTJ
    = 8

IDNA_CHECK_CONTEXTJ


    public
        mixed
    IDNA_CHECK_CONTEXTJ
    = 8

IDNA_DEFAULT


    public
        mixed
    IDNA_DEFAULT
    = 0

IDNA_DEFAULT


    public
        mixed
    IDNA_DEFAULT
    = 0

IDNA_ERROR_BIDI


    public
        mixed
    IDNA_ERROR_BIDI
    = 2048

IDNA_ERROR_BIDI


    public
        mixed
    IDNA_ERROR_BIDI
    = 2048

IDNA_ERROR_CONTEXTJ


    public
        mixed
    IDNA_ERROR_CONTEXTJ
    = 4096

IDNA_ERROR_CONTEXTJ


    public
        mixed
    IDNA_ERROR_CONTEXTJ
    = 4096

IDNA_ERROR_DISALLOWED


    public
        mixed
    IDNA_ERROR_DISALLOWED
    = 128

IDNA_ERROR_DISALLOWED


    public
        mixed
    IDNA_ERROR_DISALLOWED
    = 128

IDNA_ERROR_DOMAIN_NAME_TOO_LONG


    public
        mixed
    IDNA_ERROR_DOMAIN_NAME_TOO_LONG
    = 4

IDNA_ERROR_DOMAIN_NAME_TOO_LONG


    public
        mixed
    IDNA_ERROR_DOMAIN_NAME_TOO_LONG
    = 4

IDNA_ERROR_EMPTY_LABEL


    public
        mixed
    IDNA_ERROR_EMPTY_LABEL
    = 1

IDNA_ERROR_EMPTY_LABEL


    public
        mixed
    IDNA_ERROR_EMPTY_LABEL
    = 1

IDNA_ERROR_HYPHEN_3_4


    public
        mixed
    IDNA_ERROR_HYPHEN_3_4
    = 32

IDNA_ERROR_HYPHEN_3_4


    public
        mixed
    IDNA_ERROR_HYPHEN_3_4
    = 32

IDNA_ERROR_INVALID_ACE_LABEL


    public
        mixed
    IDNA_ERROR_INVALID_ACE_LABEL
    = 1024

IDNA_ERROR_INVALID_ACE_LABEL


    public
        mixed
    IDNA_ERROR_INVALID_ACE_LABEL
    = 1024

IDNA_ERROR_LABEL_HAS_DOT


    public
        mixed
    IDNA_ERROR_LABEL_HAS_DOT
    = 512

IDNA_ERROR_LABEL_HAS_DOT


    public
        mixed
    IDNA_ERROR_LABEL_HAS_DOT
    = 512

IDNA_ERROR_LABEL_TOO_LONG


    public
        mixed
    IDNA_ERROR_LABEL_TOO_LONG
    = 2

IDNA_ERROR_LABEL_TOO_LONG


    public
        mixed
    IDNA_ERROR_LABEL_TOO_LONG
    = 2

IDNA_ERROR_LEADING_COMBINING_MARK


    public
        mixed
    IDNA_ERROR_LEADING_COMBINING_MARK
    = 64

IDNA_ERROR_LEADING_COMBINING_MARK


    public
        mixed
    IDNA_ERROR_LEADING_COMBINING_MARK
    = 64

IDNA_ERROR_LEADING_HYPHEN


    public
        mixed
    IDNA_ERROR_LEADING_HYPHEN
    = 8

IDNA_ERROR_LEADING_HYPHEN


    public
        mixed
    IDNA_ERROR_LEADING_HYPHEN
    = 8

IDNA_ERROR_PUNYCODE


    public
        mixed
    IDNA_ERROR_PUNYCODE
    = 256

IDNA_ERROR_PUNYCODE


    public
        mixed
    IDNA_ERROR_PUNYCODE
    = 256

IDNA_ERROR_TRAILING_HYPHEN


    public
        mixed
    IDNA_ERROR_TRAILING_HYPHEN
    = 16

IDNA_ERROR_TRAILING_HYPHEN


    public
        mixed
    IDNA_ERROR_TRAILING_HYPHEN
    = 16

IDNA_NONTRANSITIONAL_TO_ASCII


    public
        mixed
    IDNA_NONTRANSITIONAL_TO_ASCII
    = 16

IDNA_NONTRANSITIONAL_TO_ASCII


    public
        mixed
    IDNA_NONTRANSITIONAL_TO_ASCII
    = 16

IDNA_NONTRANSITIONAL_TO_UNICODE


    public
        mixed
    IDNA_NONTRANSITIONAL_TO_UNICODE
    = 32

IDNA_NONTRANSITIONAL_TO_UNICODE


    public
        mixed
    IDNA_NONTRANSITIONAL_TO_UNICODE
    = 32

IDNA_USE_STD3_RULES


    public
        mixed
    IDNA_USE_STD3_RULES
    = 2

IDNA_USE_STD3_RULES


    public
        mixed
    IDNA_USE_STD3_RULES
    = 2

IN_FUNCTION_OVEN_TEMPERATURE


    public
        mixed
    IN_FUNCTION_OVEN_TEMPERATURE
    = 9003

INTL_IDNA_VARIANT_2003


    public
        mixed
    INTL_IDNA_VARIANT_2003
    = 0

INTL_IDNA_VARIANT_UTS46


    public
        mixed
    INTL_IDNA_VARIANT_UTS46
    = 1

INTL_IDNA_VARIANT_UTS46


    public
        mixed
    INTL_IDNA_VARIANT_UTS46
    = 1

MAX_OVEN_TEMPERATURE


    public
        mixed
    MAX_OVEN_TEMPERATURE
    = 9002

MAX_OVEN_TEMPERATURE


    public
        mixed
    MAX_OVEN_TEMPERATURE
    = 9002

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

OUTSIDE_OVEN_TEMPERATURE


    public
        mixed
    OUTSIDE_OVEN_TEMPERATURE
    = 9002

OVEN_TEMPERATURE


    public
        mixed
    OVEN_TEMPERATURE
    = 9001

OVEN_TEMPERATURE


    public
        mixed
    OVEN_TEMPERATURE
    = 9001

OVEN_TEMPERATURE

This needs a docblock to separate from file docblock


    public
        mixed
    OVEN_TEMPERATURE
    = 9001

SYMFONY_GRAPHEME_CLUSTER_RX


    public
        mixed
    SYMFONY_GRAPHEME_CLUSTER_RX
    = ((float) \PCRE_VERSION < 10 ? (float) \PCRE_VERSION >= 8.32 : (float) \PCRE_VERSION >= 10.39) ? '\X' : \Symfony\Polyfill\Intl\Grapheme\Grapheme::GRAPHEME_CLUSTER_RX

T_NAME_FULLY_QUALIFIED


    public
        mixed
    T_NAME_FULLY_QUALIFIED
    = 10002

T_NAME_QUALIFIED


    public
        mixed
    T_NAME_QUALIFIED
    = 10001

U_IDNA_ACE_PREFIX_ERROR


    public
        mixed
    U_IDNA_ACE_PREFIX_ERROR
    = 66564

U_IDNA_ACE_PREFIX_ERROR


    public
        mixed
    U_IDNA_ACE_PREFIX_ERROR
    = 66564

U_IDNA_CHECK_BIDI_ERROR


    public
        mixed
    U_IDNA_CHECK_BIDI_ERROR
    = 66562

U_IDNA_CHECK_BIDI_ERROR


    public
        mixed
    U_IDNA_CHECK_BIDI_ERROR
    = 66562

U_IDNA_DOMAIN_NAME_TOO_LONG_ERROR


    public
        mixed
    U_IDNA_DOMAIN_NAME_TOO_LONG_ERROR
    = 66568

U_IDNA_DOMAIN_NAME_TOO_LONG_ERROR


    public
        mixed
    U_IDNA_DOMAIN_NAME_TOO_LONG_ERROR
    = 66568

U_IDNA_ERROR_LIMIT


    public
        mixed
    U_IDNA_ERROR_LIMIT
    = 66569

U_IDNA_ERROR_LIMIT


    public
        mixed
    U_IDNA_ERROR_LIMIT
    = 66569

U_IDNA_ERROR_START


    public
        mixed
    U_IDNA_ERROR_START
    = 66560

U_IDNA_ERROR_START


    public
        mixed
    U_IDNA_ERROR_START
    = 66560

U_IDNA_LABEL_TOO_LONG_ERROR


    public
        mixed
    U_IDNA_LABEL_TOO_LONG_ERROR
    = 66566

U_IDNA_LABEL_TOO_LONG_ERROR


    public
        mixed
    U_IDNA_LABEL_TOO_LONG_ERROR
    = 66566

U_IDNA_PROHIBITED_ERROR


    public
        mixed
    U_IDNA_PROHIBITED_ERROR
    = 66560

U_IDNA_PROHIBITED_ERROR


    public
        mixed
    U_IDNA_PROHIBITED_ERROR
    = 66560

U_IDNA_STD3_ASCII_RULES_ERROR


    public
        mixed
    U_IDNA_STD3_ASCII_RULES_ERROR
    = 66563

U_IDNA_STD3_ASCII_RULES_ERROR


    public
        mixed
    U_IDNA_STD3_ASCII_RULES_ERROR
    = 66563

U_IDNA_UNASSIGNED_ERROR


    public
        mixed
    U_IDNA_UNASSIGNED_ERROR
    = 66561

U_IDNA_UNASSIGNED_ERROR


    public
        mixed
    U_IDNA_UNASSIGNED_ERROR
    = 66561

U_IDNA_VERIFICATION_ERROR


    public
        mixed
    U_IDNA_VERIFICATION_ERROR
    = 66565

U_IDNA_VERIFICATION_ERROR


    public
        mixed
    U_IDNA_VERIFICATION_ERROR
    = 66565

U_IDNA_ZERO_LENGTH_LABEL_ERROR


    public
        mixed
    U_IDNA_ZERO_LENGTH_LABEL_ERROR
    = 66567

U_IDNA_ZERO_LENGTH_LABEL_ERROR


    public
        mixed
    U_IDNA_ZERO_LENGTH_LABEL_ERROR
    = 66567

U_STRINGPREP_CHECK_BIDI_ERROR


    public
        mixed
    U_STRINGPREP_CHECK_BIDI_ERROR
    = 66562

U_STRINGPREP_CHECK_BIDI_ERROR


    public
        mixed
    U_STRINGPREP_CHECK_BIDI_ERROR
    = 66562

U_STRINGPREP_PROHIBITED_ERROR


    public
        mixed
    U_STRINGPREP_PROHIBITED_ERROR
    = 66560

U_STRINGPREP_PROHIBITED_ERROR


    public
        mixed
    U_STRINGPREP_PROHIBITED_ERROR
    = 66560

U_STRINGPREP_UNASSIGNED_ERROR


    public
        mixed
    U_STRINGPREP_UNASSIGNED_ERROR
    = 66561

U_STRINGPREP_UNASSIGNED_ERROR


    public
        mixed
    U_STRINGPREP_UNASSIGNED_ERROR
    = 66561

autoload()

Funkce pro automatické načítání tříd ze složky classes.


    
                    autoload(string $trida) : void

Odstraňuje nutnost ručního vkládání souborů pomocí require_once.

@param string $trida Název volané třídy

Parameters

$trida : string

encodep()

Encodes a UML text description into a special encoding.


    
                    encodep(string $puml) : string

Parameters

$puml : string: PlantUml diagram code, expected to be UTF-8.

Return values

string —

Encoded string

encode64()


    
                    encode64(string $compressed) : string

Parameters

$compressed : string: Compressed string

Return values

string —

Encoded string

append3bytes()


    
                    append3bytes(int $b1, int $b2, int $b3) : string

Parameters

$b1 : int: First byte
$b2 : int: Second byte
$b3 : int: Third byte

Return values

string

encode6bit()


    
                    encode6bit(int $b) : string

Parameters

$b : int

Return values

string

bom_match()

DEPRECATION WARNING! This namespace function will be removed in the next major point release.

since version 9.7.0


    
                    bom_match(string $str) : string

Parameters

$str : string

Return values

string

delimiter_detect()

DEPRECATION WARNING! This namespace function will be removed in the next major point release.

since version 9.7.0


    
                    delimiter_detect(Reader $csv, array<string|int, string> $delimiters[, int<-1, max> $limit = 1 ]) : array<string, int>

Parameters

$csv : Reader
$delimiters : array<string|int, string>
$limit : int<-1, max> = 1

Return values

array<string, int>

defineCompatibilityTokens()


    
                    defineCompatibilityTokens() : void

char()

Parse a single character.


    
                    char(string $c) : Parser

Parameters

$c : string

Return values

Parser

charI()

Parse a single character, case-insensitive and case-preserving. On success, it returns the string cased as the actually parsed input.


    
                    charI(string $c) : Parser

eg charI('a'')->run("ABC") will succeed with "A", not "a".

Parameters

$c : string

Return values

Parser

controlChar()

Parse a control character (a non-printing character of the Latin-1 subset of Unicode).


    
                    controlChar() : Parser

Return values

Parser

upperChar()

Parse an uppercase character A-Z.


    
                    upperChar() : Parser

Return values

Parser

lowerChar()

Parse a lowercase character a-z.


    
                    lowerChar() : Parser

Return values

Parser

alphaChar()

Parse an uppercase or lowercase character A-Z, a-z.


    
                    alphaChar() : Parser

Return values

Parser

alphaNumChar()

Parse an alpha or numeric character A-Z, a-z, 0-9.


    
                    alphaNumChar() : Parser

Return values

Parser

printChar()

Parse a printable ASCII char.


    
                    printChar() : Parser

Return values

Parser

punctuationChar()

Parse a single punctuation character !"#$%&'()*+,-./:;<=>?@[\]^_`{|}~


    
                    punctuationChar() : Parser

Return values

Parser

digitChar()

Parse 0-9. Returns the digit as a string. Use ->map('intval') or similar to cast it to a numeric type.


    
                    digitChar() : Parser

Return values

Parser

binDigitChar()

Parse a binary character 0 or 1.


    
                    binDigitChar() : Parser

Return values

Parser

octDigitChar()

Parse an octodecimal character 0-7.


    
                    octDigitChar() : Parser

Return values

Parser

hexDigitChar()

Parse a hexadecimal numeric character 0123456789abcdefABCDEF.


    
                    hexDigitChar() : Parser

Return values

Parser

identity()

Identity parser, returns the Parser as is.


    
                    identity(Parser $parser) : Parser

Parameters

$parser : Parser

Return values

Parser

pure()

A parser that will have the argument as its output, no matter what the input was. It doesn't consume any input.


    
                    pure(mixed $output) : Parser

Parameters

$output : mixed

Return values

Parser

optional()

Optionally parse something, but still succeed if the thing is not there


    
                    optional(Parser $parser) : Parser

Parameters

$parser : Parser

Return values

Parser

bind()

Create a parser that takes the output from the first parser (if successful) and feeds it to the callable. The callable must return another parser. If the first parser fails, the first parser is returned.


    
                    bind(Parser $parser, callable $f) : Parser

This is a monadic bind aka flatmap.

Parameters

$parser : Parser
$f : callable

Return values

Parser

apply()

Sequential application. Given a parser which outputs a callable, return a new parser that applies the callable on the output of the second parser.


    
                    apply(Parser $parser1, Parser $parser2) : Parser

The first parser must be of type Parser<callable(T1):T2>. pure() can be used to wrap a callable in a Parser.

Callables with more than 1 argument need to be curried: pure(curry(fn($x, $y)))->apply($parser2)->apply($parser3)

Parameters

$parser1 : Parser
$parser2 : Parser

Return values

Parser

sequence()

Parse something, then follow by something else. Ignore the result of the first parser and return the result of the second parser.


    
                    sequence(Parser $first, Parser $second) : Parser

Parameters

$first : Parser
$second : Parser

Return values

Parser

keepFirst()

Sequence two parsers, and return the output of the first one.


    
                    keepFirst(Parser $first, Parser $second) : Parser

Parameters

$first : Parser
$second : Parser

Return values

Parser

keepSecond()

Sequence two parsers, and return the output of the second one.


    
                    keepSecond(Parser $first, Parser $second) : Parser

Parameters

$first : Parser
$second : Parser

Return values

Parser

either()

Either parse the first thing or the second thing


    
                    either(Parser $first, Parser $second) : Parser

Parameters

$first : Parser
$second : Parser

Return values

Parser

append()

Combine the parser with another parser of the same type, which will cause the results to be appended.


    
                    append(Parser $left, Parser $right) : Parser

Parameters

$left : Parser
$right : Parser

Return values

Parser

assemble()

Append all the passed parsers.


    
                    assemble(Parser ...$parsers) : Parser

Parameters

$parsers : Parser

Return values

Parser

collect()

Parse into an array that consists of the results of all parsers.


    
                    collect(Parser ...$parsers) : Parser

Parameters

$parsers : Parser

Return values

Parser

any()

Tries each parser one by one, returning the result of the first one that succeeds.


    
                    any(Parser ...$parsers) : Parser

Parameters

$parsers : Parser

Return values

Parser

choice()

Tries each parser one by one, returning the result of the first one that succeeds.


    
                    choice(Parser ...$parsers) : Parser

Alias for any()

Parameters

$parsers : Parser

Return values

Parser

atLeastOne()

One or more repetitions of Parser, with the outputs appended.


    
                    atLeastOne(Parser $parser) : Parser

Parameters

$parser : Parser

Return values

Parser

zeroOrMore()

Zero or more repetitions of Parser, with the outputs appended.


    
                    zeroOrMore(Parser $parser) : Parser

Parameters

$parser : Parser

Return values

Parser

repeat()

Parse something exactly n times


    
                    repeat(int $n, Parser $parser) : Parser

Parameters

$n : int
$parser : Parser

Return values

Parser

repeatList()

Parse something exactly n times and return as an array


    
                    repeatList(int $n, Parser $parser) : Parser

Parameters

$n : int
$parser : Parser

Return values

Parser

some()

Parse something one or more times, and output an array of the successful outputs.


    
                    some(Parser $parser) : Parser

Parameters

$parser : Parser

Return values

Parser

many()

Parse something zero or more times, and output an array of the successful outputs.


    
                    many(Parser $parser) : Parser

Parameters

$parser : Parser

Return values

Parser

between()

Parse $open, followed by $middle, followed by $close, and return the result of $middle. Useful for eg. "(value)".


    
                    between(Parser $open, Parser $close, Parser $middle) : Parser

Parameters

$open : Parser
$close : Parser
$middle : Parser

Return values

Parser

sepBy()

Parses zero or more occurrences of $parser, separated by $separator. Returns a list of values.


    
                    sepBy(Parser $separator, Parser $parser) : Parser

The sepBy parser always succeed, even if it doesn't find anything. Use sepBy1() if you want it to find at least one value.

Parameters

$separator : Parser
$parser : Parser

Return values

Parser

sepBy1()

Parses one or more occurrences of $parser, separated by $separator. Returns a list of values.


    
                    sepBy1(Parser $separator, Parser $parser) : Parser

Parameters

$separator : Parser
$parser : Parser

Return values

Parser

sepBy2()

Parses 2 or more occurrences of $parser, separated by $separator. Returns a list of values.


    
                    sepBy2(Parser $separator, Parser $parser) : Parser

Parameters

$separator : Parser
$parser : Parser

Return values

Parser

notFollowedBy()

notFollowedBy only succeeds when $parser fails. It never consumes any input.


    
                    notFollowedBy(Parser $parser) : Parser

Example:

string("print") will also match "printXYZ"

keepFirst(string("print"), notFollowedBy(alphaNumChar())) will match "print something" but not "printXYZ something"

Parameters

$parser : Parser

Return values

Parser

map()

Map a function over the parser (which in turn maps it over the result).


    
                    map(Parser $parser, callable $transform) : Parser

Parameters

$parser : Parser
$transform : callable

Return values

Parser

lookAhead()

If $parser succeeds (either consuming input or not), lookAhead behaves like $parser succeeded without consuming anything. If $parser fails, lookAhead has no effect, i.e. it will fail to consume input if $parser fails consuming input.


    
                    lookAhead(Parser $parser) : Parser

Parameters

$parser : Parser

Return values

Parser

curry()


    
                    curry(callable $callable) : callable

Parameters

$callable : callable

Return values

callable

curry_right()


    
                    curry_right(callable $callable) : callable

Parameters

$callable : callable

Return values

callable

_curry_array_args()


    
                    _curry_array_args(callable $callable, array<string|int, mixed> $args[, bool $left = true ]) : callable

Parameters

$callable : callable
$args : array<string|int, mixed>
$left : bool = true

Return values

callable

__()

Gets a special placeholder value used to specify "gaps" within curried functions, allowing partial application of any combination of arguments, regardless of their positions. Should be used only for required arguments.


    
                    __() : Placeholder

When used, optional arguments must be at the end of the argument list.

Return values

Placeholder

expression()

Build an expression parser from a term parser and an expression table.


    
                    expression(Parser $term, array<string|int, mixed> $expressionTable) : Parser

Parameters

$term : Parser
$expressionTable : array<string|int, mixed>

Return values

Parser

binaryOperator()

A binary operator in an expression. The operands of the expression will be passed into $transform to produce the output of the expression parser.


    
                    binaryOperator(Parser $symbol, callable $transform[, string $label = "" ]) : BinaryOperator

Parameters

$symbol : Parser
$transform : callable
$label : string = ""

Return values

BinaryOperator

unaryOperator()

A unary operator in an expression. The operands of the expression will be passed into $transform to produce the output of the expression parser.


    
                    unaryOperator(Parser $symbol, callable $transform[, string $label = "" ]) : UnaryOperator<TSymbol, TExpressionAST>

Parameters

$symbol : Parser
$transform : callable
$label : string = ""

Return values

UnaryOperator<TSymbol, TExpressionAST>

leftAssoc()


    
                    leftAssoc(BinaryOperator ...$operators) : LeftAssoc

Parameters

$operators : BinaryOperator

Return values

LeftAssoc

rightAssoc()


    
                    rightAssoc(BinaryOperator ...$operators) : RightAssoc

Parameters

$operators : BinaryOperator

Return values

RightAssoc

nonAssoc()


    
                    nonAssoc(BinaryOperator $operator) : NonAssoc

Parameters

$operator : BinaryOperator

Return values

NonAssoc

prefix()


    
                    prefix(UnaryOperator ...$operators) : Prefix

Parameters

$operators : UnaryOperator

Return values

Prefix

postfix()


    
                    postfix(UnaryOperator ...$operators) : Postfix

Parameters

$operators : UnaryOperator

Return values

Postfix

integer()

Parse an integer and return it as a string. Use ->map('intval') or similar to cast it to a numeric type.


    
                    integer() : Parser

Example: "-123"

Return values

Parser

float()

Parse a float and return it as a string. Use ->map('floatval') or similar to cast it to a numeric type.


    
                    float() : Parser

Example: -123.456E-789

Return values

Parser

isEqual()

Creates an equality predicate


    
                    isEqual(string $x) : callable

Parameters

$x : string

Return values

callable

notPred()

Negates a predicate.


    
                    notPred(callable $predicate) : callable

Parameters

$predicate : callable

Return values

callable

andPred()

Boolean And predicate.


    
                    andPred(callable $first, callable $second) : callable

Parameters

$first : callable
$second : callable

Return values

callable

orPred()

Boolean Or predicate.


    
                    orPred(callable $first, callable $second) : callable

Parameters

$first : callable
$second : callable

Return values

callable

isCharCode()

Predicate that checks if a character is in an array of character codes.


    
                    isCharCode(array<string|int, mixed> $chars) : callable

Parameters

$chars : array<string|int, mixed>

Return values

callable

isSpace()

Returns true for a space character, and the control characters \t, \n, \r, \f, \v.


    
                    isSpace() : callable

Return values

callable

isHSpace()

Like 'isSpace', but does not accept newlines and carriage returns.


    
                    isHSpace() : callable

Return values

callable

isDigit()

True for 0-9


    
                    isDigit() : callable

Return values

callable

isControl()

Control character predicate (a non-printing character of the Latin-1 subset of Unicode).


    
                    isControl() : callable

Return values

callable

isBlank()

Returns true for a space or a tab character


    
                    isBlank() : callable

Return values

callable

isWhitespace()

Returns true for a space character, and \t, \n, \r, \f, \v.


    
                    isWhitespace() : callable

Return values

callable

isUpper()

Returns true for an uppercase character A-Z.


    
                    isUpper() : callable

Return values

callable

isLower()

Returns true for a lowercase character a-z.


    
                    isLower() : mixed

isAlpha()

Returns true for an uppercase or lowercase character A-Z, a-z.


    
                    isAlpha() : callable

Return values

callable

isAlphaNum()

Returns true for an alpha or numeric character A-Z, a-z, 0-9.


    
                    isAlphaNum() : callable

Return values

callable

isHexDigit()

Returns true if the given character is a hexadecimal numeric character 0123456789abcdefABCDEF.


    
                    isHexDigit() : callable

Return values

callable

isPrintable()

Returns true if the given character is a printable ASCII char.


    
                    isPrintable() : callable

Return values

callable

isPunctuation()

Returns true if the given character is a punctuation character !"#$%&'()*+,-./:;<=>?@[\]^_`{|}~


    
                    isPunctuation() : callable

Return values

callable

satisfy()

A parser that satisfies a predicate on a single token. Useful as a building block for writing things like char(), digit().


    
                    satisfy(callable $predicate) : Parser

Parameters

$predicate : callable

Return values

Parser

skipWhile()

Skip 0 or more characters as long as the predicate holds.


    
                    skipWhile(callable $predicate) : Parser

Parameters

$predicate : callable

Return values

Parser

skipWhile1()

Skip 1 or more characters as long as the predicate holds.


    
                    skipWhile1(callable $predicate) : Parser

Parameters

$predicate : callable

Return values

Parser

takeWhile()

Keep parsing 0 or more characters as long as the predicate holds.


    
                    takeWhile(callable $predicate) : Parser

Parameters

$predicate : callable

Return values

Parser

takeWhile1()

Keep parsing 1 or more characters as long as the predicate holds.


    
                    takeWhile1(callable $predicate) : Parser

Parameters

$predicate : callable

Return values

Parser

anySingle()

Parse and return a single character of anything.


    
                    anySingle() : Parser

Return values

Parser

anything()

Parse and return a single character of anything.


    
                    anything() : Parser

Return values

Parser

anySingleBut()

Match any character but the given one.


    
                    anySingleBut(string $x) : Parser

Parameters

$x : string

Return values

Parser

oneOf()

Succeeds if the current character is in the supplied list of characters. Returns the parsed character.


    
                    oneOf(array<string|int, mixed> $chars) : Parser

Parameters

$chars : array<string|int, mixed>

Return values

Parser

oneOfS()

A compact form of 'oneOf'.


    
                    oneOfS(string $chars) : Parser

oneOfS("abc") == oneOf(['a', 'b', 'c'])

Parameters

$chars : string

Return values

Parser

noneOf()

The dual of 'oneOf'. Succeeds if the current character is not in the supplied list of characters. Returns the parsed character.


    
                    noneOf(array<string|int, mixed> $chars) : Parser

Parameters

$chars : array<string|int, mixed>

Return values

Parser

noneOfS()

A compact form of 'noneOf'.


    
                    noneOfS(string $chars) : Parser

noneOfS("abc") == noneOf(['a', 'b', 'c'])

Parameters

$chars : string

Return values

Parser

takeRest()

Consume the rest of the input and return it as a string. This parser never fails, but may return the empty string.


    
                    takeRest() : Parser

Return values

Parser

nothing()

Parse nothing, but still succeed.


    
                    nothing() : Parser

This serves as the zero parser in append() operations.

Return values

Parser

everything()

Parse everything; that is, consume the rest of the input until the end.


    
                    everything() : Parser

Return values

Parser

succeed()

Always succeed, no matter what the input was.


    
                    succeed() : Parser

Return values

Parser

fail()

Always fail, no matter what the input was.


    
                    fail(string $label) : Parser

Parameters

$label : string

Return values

Parser

eof()

Parse the end of the input


    
                    eof() : Parser

Return values

Parser

recursive()

Create a recursive parser. Used in combination with Parser#recurse().


    
                    recursive() : Parser

Return values

Parser

emit()

If the parser is successful, call the $receiver function with the output of the parser. The resulting parser behaves identical to the original one. This combinator is useful for expressing side effects during the parsing process. It can be hooked into existing event publishing libraries by using $receiver as an adapter for those. Other use cases are logging, caching, performing an action whenever a value is matched in a long-running input stream, .


    
                    emit(Parser $parser, callable $receiver) : Parser

Parameters

$parser : Parser
$receiver : callable

Return values

Parser

space()

Parse a single space character.


    
                    space() : Parser

Return values

Parser

tab()

Parse a single tab character.


    
                    tab() : Parser

Return values

Parser

blank()

Parse a space or tab.


    
                    blank() : Parser

Return values

Parser

whitespace()

Parse a space character, and \t, \n, \r, \f, \v.


    
                    whitespace() : Parser

Return values

Parser

newline()

Parse a newline character.


    
                    newline() : Parser

Return values

Parser

crlf()

Parse a carriage return character and a newline character. Return the two characters. {\r\n}


    
                    crlf() : Parser

Return values

Parser

eol()

Parse a newline or a crlf.


    
                    eol() : Parser

Return values

Parser

skipSpace()

Skip zero or more white space characters.


    
                    skipSpace() : Parser

Return values

Parser

skipHSpace()

Like 'skipSpace', but does not accept newlines and carriage returns.


    
                    skipHSpace() : Parser

Return values

Parser

skipSpace1()

Skip one or more white space characters.


    
                    skipSpace1() : Parser

Return values

Parser

skipHSpace1()

Like 'skipSpace1', but does not accept newlines and carriage returns.


    
                    skipHSpace1() : Parser

Return values

Parser

string()

Parse a non-empty string.


    
                    string(string $str) : Parser

Parameters

$str : string

Return values

Parser

stringI()

Parse a non-empty string, case-insensitive, and case-preserving. On success, it returns the string cased as the actually parsed input.


    
                    stringI(string $str) : Parser

eg stringI("foobar")->tryString("foObAr") will succeed with "foObAr"

Parameters

$str : string

Return values

Parser

templateArray()

Helper function to configure multiple templates.


    
                    templateArray(array<Node>, string> $input[, string $format = 'html' ]) : array<string|int, Node>, file: string, format: string}>

This function is used to configure the templates in the configuration file.

Parameters

$input : array<Node>, string>
$format : string = 'html'

Return values

array<string|int, Node>, file: string, format: string}>

template()

Helper function to configure templates.


    
                    template(Node> $node, string $template[, string $format = 'html' ]) : Node>, file: string, format: string}

This function is used to configure the templates in the configuration file.

Parameters

$node : Node>
$template : string
$format : string = 'html'

Return values

Node>, file: string, format: string}

heatOven()


    
                    heatOven() : mixed

coolOven()


    
                    coolOven([int $degrees = 42 ]) : bool

Parameters

$degrees : int = 42

Return values

bool —

whether cooling succeeded.

turnOffOven()


    
                    turnOffOven([int $timeout = 0 ]) : void

Parameters

$timeout : int = 0

populateTemperature()


    
                    populateTemperature(int &$temperature) : void

Parameters

$temperature : int

h()


    
                    h() : mixed

i()


    
                    i() : mixed

j()


    
                    j() : mixed

a()


    
                    a() : mixed

libAutoload()

autoloader function.


    
                    libAutoload(string $class) : void

Function long description goes here.

Parameters

$class : string: Namespaced class name

in_function_define()


    
                    in_function_define() : mixed

simpleFunction()


    
                    simpleFunction([array<string|int, mixed> $options = [] ]) : void

Parameters

$options : array<string|int, mixed> = []

now()


    
                    now([string $modifier = 'now' ]) : DatePoint

Parameters

$modifier : string = 'now'

Return values

DatePoint

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

param()

Creates a parameter.


    
                    param(string $name) : ParamConfigurator

Parameters

$name : string

Return values

ParamConfigurator

service()

Creates a reference to a service.


    
                    service(string $serviceId) : ReferenceConfigurator

Parameters

$serviceId : string

Return values

ReferenceConfigurator

inline_service()

Creates an inline service.


    
                    inline_service([string|null $class = null ]) : InlineServiceConfigurator

Parameters

$class : string|null = null

Return values

InlineServiceConfigurator

service_locator()

Creates a service locator.


    
                    service_locator(array<string|int, ReferenceConfigurator|InlineServiceConfigurator> $values) : ServiceLocatorArgument

Parameters

$values : array<string|int, ReferenceConfigurator|InlineServiceConfigurator>

Return values

ServiceLocatorArgument

iterator()

Creates a lazy iterator.


    
                    iterator(array<string|int, ReferenceConfigurator> $values) : IteratorArgument

Parameters

$values : array<string|int, ReferenceConfigurator>

Return values

IteratorArgument

tagged_iterator()

Creates a lazy iterator by tag name.


    
                    tagged_iterator(string $tag[, string|null $indexAttribute = null ][, string|null $defaultIndexMethod = null ][, string|null $defaultPriorityMethod = null ][, string|array<string|int, mixed> $exclude = [] ][, bool $excludeSelf = true ]) : TaggedIteratorArgument

Parameters

$tag : string
$indexAttribute : string|null = null
$defaultIndexMethod : string|null = null
$defaultPriorityMethod : string|null = null
$exclude : string|array<string|int, mixed> = []
$excludeSelf : bool = true

Return values

TaggedIteratorArgument

tagged_locator()

Creates a service locator by tag name.


    
                    tagged_locator(string $tag[, string|null $indexAttribute = null ][, string|null $defaultIndexMethod = null ][, string|null $defaultPriorityMethod = null ][, string|array<string|int, mixed> $exclude = [] ][, bool $excludeSelf = true ]) : ServiceLocatorArgument

Parameters

$tag : string
$indexAttribute : string|null = null
$defaultIndexMethod : string|null = null
$defaultPriorityMethod : string|null = null
$exclude : string|array<string|int, mixed> = []
$excludeSelf : bool = true

Return values

ServiceLocatorArgument

expr()

Creates an expression.


    
                    expr(string $expression) : Expression

Parameters

$expression : string

Return values

Expression

abstract_arg()

Creates an abstract argument.


    
                    abstract_arg(string $description) : AbstractArgument

Parameters

$description : string

Return values

AbstractArgument

env()

Creates an environment variable reference.


    
                    env(string $name) : EnvConfigurator

Parameters

$name : string

Return values

EnvConfigurator

service_closure()

Creates a closure service reference.


    
                    service_closure(string $serviceId) : ClosureReferenceConfigurator

Parameters

$serviceId : string

Return values

ClosureReferenceConfigurator

closure()

Creates a closure.


    
                    closure(string|array<string|int, mixed>|ReferenceConfigurator|Expression $callable) : InlineServiceConfigurator

Parameters

$callable : string|array<string|int, mixed>|ReferenceConfigurator|Expression

Return values

InlineServiceConfigurator

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

grapheme_extract()


    
                    grapheme_extract(mixed $haystack, mixed $size[, mixed $type = 0 ][, mixed $start = 0 ][, mixed &$next = 0 ]) : mixed

Parameters

$haystack : mixed
$size : mixed
$type : mixed = 0
$start : mixed = 0
$next : mixed = 0

grapheme_stripos()


    
                    grapheme_stripos(mixed $haystack, mixed $needle[, mixed $offset = 0 ]) : mixed

Parameters

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

grapheme_stristr()


    
                    grapheme_stristr(mixed $haystack, mixed $needle[, mixed $beforeNeedle = false ]) : mixed

Parameters

$haystack : mixed
$needle : mixed
$beforeNeedle : mixed = false

grapheme_strlen()


    
                    grapheme_strlen(mixed $input) : mixed

Parameters

$input : mixed

grapheme_strpos()


    
                    grapheme_strpos(mixed $haystack, mixed $needle[, mixed $offset = 0 ]) : mixed

Parameters

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

grapheme_strripos()


    
                    grapheme_strripos(mixed $haystack, mixed $needle[, mixed $offset = 0 ]) : mixed

Parameters

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

grapheme_strrpos()


    
                    grapheme_strrpos(mixed $haystack, mixed $needle[, mixed $offset = 0 ]) : mixed

Parameters

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

grapheme_strstr()


    
                    grapheme_strstr(mixed $haystack, mixed $needle[, mixed $beforeNeedle = false ]) : mixed

Parameters

$haystack : mixed
$needle : mixed
$beforeNeedle : mixed = false

grapheme_substr()


    
                    grapheme_substr(mixed $string, mixed $offset[, mixed $length = null ]) : mixed

Parameters

$string : mixed
$offset : mixed
$length : mixed = null

grapheme_str_split()


    
                    grapheme_str_split(mixed $string[, mixed $length = 1 ]) : mixed

Parameters

$string : mixed
$length : mixed = 1

grapheme_str_split()


    
                    grapheme_str_split(string $string[, int $length = 1 ]) : array<string|int, mixed>|false

Parameters

$string : string
$length : int = 1

Return values

array<string|int, mixed>|false

grapheme_extract()


    
                    grapheme_extract(string|null $haystack, int|null $size[, int|null $type = GRAPHEME_EXTR_COUNT ][, int|null $offset = 0 ][, mixed &$next = null ]) : string|false

Parameters

$haystack : string|null
$size : int|null
$type : int|null = GRAPHEME_EXTR_COUNT
$offset : int|null = 0
$next : mixed = null

Return values

string|false

grapheme_stripos()


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

Parameters

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

Return values

int|false

grapheme_stristr()


    
                    grapheme_stristr(string|null $haystack, string|null $needle[, bool|null $beforeNeedle = false ]) : string|false

Parameters

$haystack : string|null
$needle : string|null
$beforeNeedle : bool|null = false

Return values

string|false

grapheme_strlen()


    
                    grapheme_strlen(string|null $string) : int|false|null

Parameters

$string : string|null

Return values

int|false|null

grapheme_strpos()


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

Parameters

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

Return values

int|false

grapheme_strripos()


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

Parameters

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

Return values

int|false

grapheme_strrpos()


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

Parameters

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

Return values

int|false

grapheme_strstr()


    
                    grapheme_strstr(string|null $haystack, string|null $needle[, bool|null $beforeNeedle = false ]) : string|false

Parameters

$haystack : string|null
$needle : string|null
$beforeNeedle : bool|null = false

Return values

string|false

grapheme_substr()


    
                    grapheme_substr(string|null $string, int|null $offset[, int|null $length = null ]) : string|false

Parameters

$string : string|null
$offset : int|null
$length : int|null = null

Return values

string|false

idn_to_ascii()


    
                    idn_to_ascii(mixed $domain[, mixed $flags = 0 ][, mixed $variant = INTL_IDNA_VARIANT_UTS46 ][, mixed &$idna_info = null ]) : mixed

Parameters

$domain : mixed
$flags : mixed = 0
$variant : mixed = INTL_IDNA_VARIANT_UTS46
$idna_info : mixed = null

idn_to_utf8()


    
                    idn_to_utf8(mixed $domain[, mixed $flags = 0 ][, mixed $variant = INTL_IDNA_VARIANT_UTS46 ][, mixed &$idna_info = null ]) : mixed

Parameters

$domain : mixed
$flags : mixed = 0
$variant : mixed = INTL_IDNA_VARIANT_UTS46
$idna_info : mixed = null

idn_to_ascii()


    
                    idn_to_ascii(string|null $domain[, int|null $flags = IDNA_DEFAULT ][, int|null $variant = INTL_IDNA_VARIANT_UTS46 ][, mixed &$idna_info = null ]) : string|false

Parameters

$domain : string|null
$flags : int|null = IDNA_DEFAULT
$variant : int|null = INTL_IDNA_VARIANT_UTS46
$idna_info : mixed = null

Return values

string|false

idn_to_utf8()


    
                    idn_to_utf8(string|null $domain[, int|null $flags = IDNA_DEFAULT ][, int|null $variant = INTL_IDNA_VARIANT_UTS46 ][, mixed &$idna_info = null ]) : string|false

Parameters

$domain : string|null
$flags : int|null = IDNA_DEFAULT
$variant : int|null = INTL_IDNA_VARIANT_UTS46
$idna_info : mixed = null

Return values

string|false

normalizer_is_normalized()


    
                    normalizer_is_normalized(mixed $string[, mixed $form = Normalizer::FORM_C ]) : mixed

Parameters

$string : mixed
$form : mixed = Normalizer::FORM_C

normalizer_normalize()


    
                    normalizer_normalize(mixed $string[, mixed $form = Normalizer::FORM_C ]) : mixed

Parameters

$string : mixed
$form : mixed = Normalizer::FORM_C

normalizer_is_normalized()


    
                    normalizer_is_normalized(string|null $string[, int|null $form = Normalizer::FORM_C ]) : bool

Parameters

$string : string|null
$form : int|null = Normalizer::FORM_C

Return values

bool

normalizer_normalize()


    
                    normalizer_normalize(string|null $string[, int|null $form = Normalizer::FORM_C ]) : string|false

Parameters

$string : string|null
$form : int|null = Normalizer::FORM_C

Return values

string|false

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 = "\r\n" ][, mixed $indent = 0 ]) : mixed

Parameters

$string : mixed
$charset : mixed = null
$transfer_encoding : mixed = null
$newline : mixed = "\r\n"
$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_ucfirst()


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

Parameters

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

Return values

string

mb_lcfirst()


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

Parameters

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

Return values

string

mb_trim()


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

Parameters

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

Return values

string

mb_ltrim()


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

Parameters

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

Return values

string

mb_rtrim()


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

Parameters

$string : string
$characters : string|null = null
$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 = "\r\n" ][, int|null $indent = 0 ]) : string

Parameters

$string : string|null
$charset : string|null = null
$transfer_encoding : string|null = null
$newline : string|null = "\r\n"
$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|null

Parameters

$type : string|null = 'all'

Return values

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

mb_ucfirst()


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

Parameters

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

Return values

string

mb_lcfirst()


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

Parameters

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

Return values

string

mb_trim()


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

Parameters

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

Return values

string

mb_ltrim()


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

Parameters

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

Return values

string

mb_rtrim()


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

Parameters

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

Return values

string

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

json_validate()


    
                    json_validate(string $json[, int $depth = 512 ][, int $flags = 0 ]) : bool

Parameters

$json : string
$depth : int = 512
$flags : int = 0

Return values

bool

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

stream_context_set_options()


    
                    stream_context_set_options(mixed $context, array<string|int, mixed> $options) : bool

Parameters

$context : mixed
$options : array<string|int, mixed>

Return values

bool

str_increment()


    
                    str_increment(string $string) : string

Parameters

$string : string

Return values

string

str_decrement()


    
                    str_decrement(string $string) : string

Parameters

$string : string

Return values

string

ldap_exop_sync()


    
                    ldap_exop_sync(mixed $ldap, string $request_oid[, string|null $request_data = null ][, array<string|int, mixed>|null $controls = null ][, mixed &$response_data = null ][, mixed &$response_oid = null ]) : bool

Parameters

$ldap : mixed
$request_oid : string
$request_data : string|null = null
$controls : array<string|int, mixed>|null = null
$response_data : mixed = null
$response_oid : mixed = null

Return values

bool

ldap_connect_wallet()


    
                    ldap_connect_wallet(string|null $uri, string $wallet, string $password[, int $auth_mode = GSLC_SSL_NO_AUTH ]) : mixed

Parameters

$uri : string|null
$wallet : string
$password : string
$auth_mode : int = GSLC_SSL_NO_AUTH

ldap_exop_sync()


    
                    ldap_exop_sync(Connection $ldap, string $request_oid[, string|null $request_data = null ][, array<string|int, mixed>|null $controls = null ][, mixed &$response_data = null ][, mixed &$response_oid = null ]) : bool

Parameters

$ldap : Connection
$request_oid : string
$request_data : string|null = null
$controls : array<string|int, mixed>|null = null
$response_data : mixed = null
$response_oid : mixed = null

Return values

bool

ldap_connect_wallet()


    
                    ldap_connect_wallet(string|null $uri, string $wallet, string $password[, int $auth_mode = GSLC_SSL_NO_AUTH ]) : Connection|false

Parameters

$uri : string|null
$wallet : string
$password : string
$auth_mode : int = GSLC_SSL_NO_AUTH

Return values

Connection|false

array_find()


    
                    array_find(array<string|int, mixed> $array, callable $callback) : mixed

Parameters

$array : array<string|int, mixed>
$callback : callable

array_find_key()


    
                    array_find_key(array<string|int, mixed> $array, callable $callback) : mixed

Parameters

$array : array<string|int, mixed>
$callback : callable

array_any()


    
                    array_any(array<string|int, mixed> $array, callable $callback) : bool

Parameters

$array : array<string|int, mixed>
$callback : callable

Return values

bool

array_all()


    
                    array_all(array<string|int, mixed> $array, callable $callback) : bool

Parameters

$array : array<string|int, mixed>
$callback : callable

Return values

bool

fpow()


    
                    fpow(float $num, float $exponent) : float

Parameters

$num : float
$exponent : float

Return values

float

mb_ucfirst()


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

Parameters

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

Return values

string

mb_lcfirst()


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

Parameters

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

Return values

string

mb_trim()


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

Parameters

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

Return values

string

mb_ltrim()


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

Parameters

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

Return values

string

mb_rtrim()


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

Parameters

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

Return values

string

bcdivmod()


    
                    bcdivmod(string $num1, string $num2[, int|null $scale = null ]) : array<string|int, mixed>|null

Parameters

$num1 : string
$num2 : string
$scale : int|null = null

Return values

array<string|int, mixed>|null

grapheme_str_split()


    
                    grapheme_str_split(string $string[, int $length = 1 ]) : mixed

Parameters

$string : string
$length : int = 1

grapheme_str_split()


    
                    grapheme_str_split(string $string[, int $length = 1 ]) : array<string|int, mixed>|false

Parameters

$string : string
$length : int = 1

Return values

array<string|int, mixed>|false

u()


    
                    u([string|null $string = '' ]) : UnicodeString

Parameters

$string : string|null = ''

Return values

UnicodeString

b()


    
                    b([string|null $string = '' ]) : ByteString

Parameters

$string : string|null = ''

Return values

ByteString

s()


    
                    s([string|null $string = '' ]) : UnicodeString|ByteString

Parameters

$string : string|null = ''

Return values

UnicodeString|ByteString

Application

Table of Contents

Interfaces

Classes

Traits

Enums

Constants

Functions

Constants

_OUTSIDE_OVEN_TEMPERATURE

CURL_HTTP_VERSION_3

CURL_HTTP_VERSION_3ONLY

FILTER_VALIDATE_BOOL

GRAPHEME_EXTR_COUNT

GRAPHEME_EXTR_COUNT

GRAPHEME_EXTR_MAXBYTES

GRAPHEME_EXTR_MAXBYTES

GRAPHEME_EXTR_MAXCHARS

GRAPHEME_EXTR_MAXCHARS

HIGHER_OVEN_TEMPERATURE

IDNA_ALLOW_UNASSIGNED

IDNA_ALLOW_UNASSIGNED

IDNA_CHECK_BIDI

IDNA_CHECK_BIDI

IDNA_CHECK_CONTEXTJ

IDNA_CHECK_CONTEXTJ

IDNA_DEFAULT

IDNA_DEFAULT

IDNA_ERROR_BIDI

IDNA_ERROR_BIDI

IDNA_ERROR_CONTEXTJ

IDNA_ERROR_CONTEXTJ

IDNA_ERROR_DISALLOWED

IDNA_ERROR_DISALLOWED

IDNA_ERROR_DOMAIN_NAME_TOO_LONG

IDNA_ERROR_DOMAIN_NAME_TOO_LONG

IDNA_ERROR_EMPTY_LABEL

IDNA_ERROR_EMPTY_LABEL

IDNA_ERROR_HYPHEN_3_4

IDNA_ERROR_HYPHEN_3_4

IDNA_ERROR_INVALID_ACE_LABEL

IDNA_ERROR_INVALID_ACE_LABEL

IDNA_ERROR_LABEL_HAS_DOT

IDNA_ERROR_LABEL_HAS_DOT

IDNA_ERROR_LABEL_TOO_LONG

IDNA_ERROR_LABEL_TOO_LONG

IDNA_ERROR_LEADING_COMBINING_MARK

IDNA_ERROR_LEADING_COMBINING_MARK

IDNA_ERROR_LEADING_HYPHEN

IDNA_ERROR_LEADING_HYPHEN

IDNA_ERROR_PUNYCODE

IDNA_ERROR_PUNYCODE

IDNA_ERROR_TRAILING_HYPHEN

IDNA_ERROR_TRAILING_HYPHEN

IDNA_NONTRANSITIONAL_TO_ASCII

IDNA_NONTRANSITIONAL_TO_ASCII

IDNA_NONTRANSITIONAL_TO_UNICODE

IDNA_NONTRANSITIONAL_TO_UNICODE

IDNA_USE_STD3_RULES

IDNA_USE_STD3_RULES

IN_FUNCTION_OVEN_TEMPERATURE

INTL_IDNA_VARIANT_2003

INTL_IDNA_VARIANT_UTS46

INTL_IDNA_VARIANT_UTS46

MAX_OVEN_TEMPERATURE

MAX_OVEN_TEMPERATURE

MB_CASE_LOWER

MB_CASE_LOWER

MB_CASE_TITLE

MB_CASE_TITLE

MB_CASE_UPPER

MB_CASE_UPPER

OUTSIDE_OVEN_TEMPERATURE

OVEN_TEMPERATURE

OVEN_TEMPERATURE

OVEN_TEMPERATURE

SYMFONY_GRAPHEME_CLUSTER_RX

T_NAME_FULLY_QUALIFIED

T_NAME_QUALIFIED

U_IDNA_ACE_PREFIX_ERROR