MailMimeParser
Interfaces, Classes, Traits and Enums
- IConsumerService
- Interface defining a consumer service class.
- IHeader
- A mime email header line consisting of a name and value.
- IHeaderPart
- Represents a single parsed part of a header line's value.
- IErrorBag
- Defines an object that may contain a set of errors, and optionally perform additional validation.
- IMessage
- An interface representing an email message.
- IMessagePart
- An interface representing a single part of an email.
- IMimePart
- An interface representation of any MIME email part.
- IMultiPart
- An interface representing a message part that contains children.
- IUUEncodedPart
- An interface representing a non-mime uuencoded part.
- IParserService
- Interface defining a message part parser.
- Error
- Holds information about an error or notice that happened on a specific object.
- ErrorBag
- Provides a top-level abstract implementation of IErrorBag.
- AbstractHeader
- Abstract base class representing a mime email's header.
- AddressHeader
- A header containing one or more email addresses and/or groups of addresses.
- AbstractConsumerService
- Abstract base class for all header token consumers.
- AbstractGenericConsumerService
- A minimal implementation of AbstractConsumerService splitting tokens by whitespace.
- AddressBaseConsumerService
- Serves as a base-consumer for recipient/sender email address headers (like From and To).
- AddressConsumerService
- Parses a single part of an address header.
- AddressEmailConsumerService
- Parses the Address portion of an email address header, for an address part that contains both a name and an email address, e.g. "name" <email@tld.com>.
- AddressGroupConsumerService
- Parses a single group of addresses (as a named-group part of an address header).
- CommentConsumerService
- Consumes all tokens within parentheses as comments.
- DateConsumerService
- Parses a date header into a Part\DatePart taking care of comment and quoted parts as necessary.
- GenericConsumerMimeLiteralPartService
- GenericConsumerMimeLiteralPartService uses a MimeTokenPartFactory instead of a HeaderPartFactory.
- GenericConsumerService
- The base GenericConsumerService is a consumer with CommentConsumerService and QuotedStringConsumerService as sub-consumers, and splitting tokens by whitespace.
- IdBaseConsumerService
- Serves as a base-consumer for ID headers (like Message-ID and Content-ID).
- IdConsumerService
- Parses a single ID from an ID header. Begins consuming on a '<' char, and ends on a '>' char.
- ParameterConsumerService
- Reads headers separated into parameters consisting of an optional main value, and subsequent name/value pairs - for example text/html; charset=utf-8.
- QuotedStringConsumerService
- Represents a quoted part of a header value starting at a double quote, and ending at the next double quote.
- DomainConsumerService
- Parses a so-called "extended-domain" (from and by) part of a Received header.
- GenericReceivedConsumerService
- Consumes simple literal strings for parts of a Received header.
- ReceivedDateConsumerService
- Parses the date portion of a Received header into a DatePart.
- ReceivedConsumerService
- Parses a Received header into ReceivedParts, ReceivedDomainParts, a DatePart, and CommentParts.
- SubjectConsumerService
- Extends AbstractGenericConsumerService to use a MimeTokenPartFactory, and to preserve all whitespace and escape sequences as-is (unlike other headers subject headers don't have escape chars such as '\\' for a backslash).
- DateHeader
- Reads a DatePart value header in either RFC 2822 or RFC 822 format.
- GenericHeader
- Reads a generic header.
- HeaderConsts
- List of header name constants.
- HeaderFactory
- Constructs various IHeader types depending on the type of header passed.
- IdHeader
- Represents a Content-ID, Message-ID, In-Reply-To or References header.
- MimeEncodedHeader
- Allows a header to be mime-encoded and be decoded with a consumer after decoding.
- ParameterHeader
- Represents a header containing an optional main value part and subsequent name/value pairs.
- AddressGroupPart
- Holds a group of addresses and a group name.
- AddressPart
- Holds a single address or name/address pair.
- CommentPart
- Represents a mime header comment -- text in a structured mime header value existing within parentheses.
- DatePart
- Represents the value of a date header, parsing the date into a \DateTime object.
- HeaderPart
- Abstract base class representing a single part of a parsed header.
- HeaderPartFactory
- Constructs and returns IHeaderPart objects.
- ParameterPart
- Represents a name/value parameter part of a header.
- ReceivedDomainPart
- Holds extra information about a parsed Received header part, for FROM and BY parts, namely: ehlo name, hostname, and address.
- ReceivedPart
- Represents one parameter in a parsed 'Received' header, e.g. the FROM or VIA part.
- Token
- Holds a string value token that will require additional processing by a consumer prior to returning to a client.
- ReceivedHeader
- Represents a Received header.
- SubjectHeader
- Reads a subject header.
- MailMimeParser
- Parses a MIME message into an {@see IMessage} object.
- IMessagePartFactory
- Abstract factory for subclasses of IMessagePart.
- IMimePartFactory
- Responsible for creating IMimePart instances.
- IUUEncodedPartFactory
- Responsible for creating UUEncodedPart instances.
- PartChildrenContainerFactory
- Creates PartChildrenContainer instances.
- PartHeaderContainerFactory
- Creates PartHeaderContainer instances.
- PartStreamContainerFactory
- Creates PartStreamContainer instances.
- AbstractHelper
- Base class for message helpers.
- GenericHelper
- Provides common Message helper routines for Message manipulation.
- MultipartHelper
- Provides various routines to manipulate and create multipart messages from an existing message (e.g. to make space for attachments in a message, or to change a simple message to a multipart/alternative one, etc...)
- PrivacyHelper
- Provides routines to set or retrieve the signature part of a signed message.
- MessagePart
- Most basic representation of a single part of an email.
- MimePart
- A mime email message part.
- MultiPart
- A message part that contains children.
- NonMimePart
- Represents part of a non-mime message.
- PartChildrenContainer
- Container of IMessagePart items for a parent IMultiPart.
- PartFilter
- Collection of static methods that return callables for common IMultiPart child filters.
- PartHeaderContainer
- Maintains a collection of headers for a part.
- PartStreamContainer
- Holds the stream and content stream objects for a part.
- UUEncodedPart
- Implementation of a non-mime message's uuencoded attachment part.
- Message
- An email message.
- AbstractParserService
- Provides basic implementations for: - IParser::setParserManager - IParser::getParserMessageProxyFactory (returns $this->parserMessageProxyFactory which can be set via the default constructor) - IParser::getParserPartProxyFactory (returns $this->parserPartProxyFactory which can be set via the default constructor)
- CompatibleParserNotFoundException
- Exception thrown if the ParserManagerService doesn't contain a parser that can handle a given type of part. The default configuration of MailMimeParser uses NonMimeParserService that is a 'catch-all', so this would indicate a configuration error.
- HeaderParserService
- Reads headers from an input stream, adding them to a PartHeaderContainer.
- MessageParserService
- Parses a mail mime message into its component parts. To invoke, call {@see MailMimeParser::parse()}.
- MimeParserService
- Parses content and children of MIME parts.
- NonMimeParserService
- Parses content for non-mime messages and uu-encoded child parts.
- ParserManagerService
- Manages a prioritized list of IParser objects for parsing messages and parts and creating proxied parts.
- ParserPartChildrenContainer
- A child container that proxies calls to a parser when attempting to access child parts.
- ParserPartChildrenContainerFactory
- Creates ParserPartChildrenContainer instances.
- ParserPartStreamContainer
- A part stream container that proxies requests for content streams to a parser to read the content.
- ParserPartStreamContainerFactory
- Creates ParserPartStreamContainer instances.
- UUEncodedPartHeaderContainer
- Header container representing the start line of a uu-encoded part.
- UUEncodedPartHeaderContainerFactory
- Creates UUEncodedPartHeaderContainer instances.
- PartBuilder
- Holds generic/all purpose information about a part while it's being parsed.
- PartBuilderFactory
- Responsible for creating PartBuilder instances.
- ParserMessageProxy
- A bi-directional parser-to-part proxy for IMessage objects created by MimeParser.
- ParserMessageProxyFactory
- Responsible for creating proxied IMessage instances wrapped in a ParserMessageProxy.
- ParserMimePartProxy
- A bi-directional parser-to-part proxy for MimeParser and IMimeParts.
- ParserMimePartProxyFactory
- Responsible for creating proxied IMimePart instances wrapped in a ParserMimePartProxy with a MimeParser.
- ParserNonMimeMessageProxy
- A bi-directional parser-to-part proxy for IMessage objects created by NonMimeParser.
- ParserNonMimeMessageProxyFactory
- Responsible for creating proxied IMessage instances wrapped in a ParserNonMimeMessageProxy for NonMimeParser.
- ParserPartProxy
- Proxy between a MessagePart and a Parser.
- ParserPartProxyFactory
- Base class for factories creating ParserPartProxy classes.
- ParserUUEncodedPartProxy
- A bi-directional parser-to-part proxy for NonMimeParser and IUUEncodedParts.
- ParserUUEncodedPartProxyFactory
- Responsible for creating proxied IUUEncodedPart instances wrapped in a ParserUUEncodedPartProxy and used by NonMimeParser.
- HeaderStream
- Psr7 stream decorator implementation providing a readable stream for a part's headers.
- MessagePartStream
- Provides a readable stream for a MessagePart.
- StreamFactory
- Factory class for Psr7 stream decorators used in MailMimeParser.
- ParameterNameValueConsumerService
- Parses an individual part of a parameter header.
- ParameterValueConsumerService
- Starts processing tokens after a '=' character is found, indicating the 'value' portion of a name/value pair in a parameter header.
- QuotedStringMimeLiteralPartConsumerService
- Allows for mime-encoded parts inside a quoted part.
- ContainerPart
- Base HeaderPart for a part that consists of other parts.
- MimeToken
- Represents a single mime header part token, with the possibility of it being MIME-Encoded as per RFC-2047.
- MimeTokenPartFactory
- Extends HeaderPartFactory to instantiate MimeTokens for its newInstance method.
- NameValuePart
- Represents a name/value pair part of a header.
- QuotedLiteralPart
- A quoted literal header string part. The value of the part is stripped of CR and LF characters, and whitespace between two adjacent MimeTokens is removed.
- SplitParameterPart
- Holds a running value for an RFC-2231 split header parameter.
- SubjectToken
- Specialized token for subjects that preserves whitespace, except for new lines.
- MessagePartStreamDecorator
- Provides a readable stream for a MessagePart.
- MessagePartStreamReadException
- Thrown for exceptions on MessagePartStream::read so a $part can be used to determine where the exception occurred.
- QuotedStringMimeLiteralPartTokenSplitPatternTrait
- Provides a getTokenSplitPattern for consumers that could have quoted parts that are mime-header-encoded.