MailMimeParser 3.0

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 MimeLiteralPartFactory 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 MimeLiteralPartFactory, 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 an optional 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
Parses a header into a DateTime object.
HeaderPart
Abstract base class representing a single part of a parsed header.
HeaderPartFactory
Constructs and returns IHeaderPart objects.
LiteralPart
A literal header string part. The value of the part is stripped of CR and LF characters, but otherwise not transformed or changed in any way.
MimeLiteralPart
Represents a single mime header part token, with the possibility of it being MIME-Encoded as per RFC-2047.
MimeLiteralPartFactory
Extends HeaderPartFactory to instantiate MimeLiteralParts for its newInstance function.
ParameterPart
Represents a name/value pair 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.
SplitParameterToken
Holds a running value for an RFC-2231 split header parameter.
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.

Search results