AddressPart
        
        extends ParameterPart
    
    
            
            in package
            
        
    
    
    
        
            Holds a single address or name/address pair.
The name part of the address may be mime-encoded, but the email address part can't be mime-encoded. Any whitespace in the email address part is stripped out.
A convenience method, getEmail, is provided for clarity -- but getValue returns the email address as well.
Tags
Table of Contents
- MIME_PART_PATTERN = '=\\?[^?=]+\\?[QBqb]\\?[^\\?]+\\?='
- MIME_PART_PATTERN_NO_QUOTES = '=\\?[^\\?=]+\\?[QBqb]\\?[^\\?"]+\\?='
- $canIgnoreSpacesAfter : bool
- $canIgnoreSpacesBefore : bool
- $charsetConverter : MbWrapper
- $language : string
- $languages : array<string|int, mixed>
- $name : string
- $value : string
- __construct() : mixed
- Performs mime-decoding and initializes the address' name and email.
- __toString() : string
- Returns the value of the part (which is a string).
- getEmail() : string
- Returns the email address.
- getLanguage() : string
- Returns the RFC-1766 (or subset) language tag, if the parameter is a split RFC-2231 part with a language tag set.
- getLanguageArray() : array<string|int, array<string|int, string>>
- Returns an array of parts mapped to languages in the header value, for instance the string:
- getName() : string
- Returns the name of the parameter.
- getValue() : string|null
- Returns the part's value.
- ignoreSpacesAfter() : bool
- Returns true if spaces after this part should be ignored. True is only returned for MimeLiterals if the part ends with a mime-encoded string Tokens if the Token's value is a single space, and for CommentParts.
- ignoreSpacesBefore() : bool
- Returns true if spaces before this part should be ignored. True is only returned for MimeLiterals if the part begins with a mime-encoded string, Tokens if the Token's value is a single space, and for CommentParts.
- addToLanguage() : self
- Adds the passed part into the languages array with the given language.
- convertEncoding() : string
- Ensures the encoding of the passed string is set to UTF-8.
- decodeMime() : string
- Finds and replaces mime parts with their values.
- decodeMatchedEntity() : string
- Decodes a matched mime entity part into a string and returns it, after adding the string into the languages array.
- decodeSplitPart() : string
- Decodes a single mime-encoded entity.
Constants
MIME_PART_PATTERN
    public
        string
    MIME_PART_PATTERN
    = '=\\?[^?=]+\\?[QBqb]\\?[^\\?]+\\?='
    
        regex pattern matching a mime-encoded part
MIME_PART_PATTERN_NO_QUOTES
    public
        string
    MIME_PART_PATTERN_NO_QUOTES
    = '=\\?[^\\?=]+\\?[QBqb]\\?[^\\?"]+\\?='
    
        regex pattern used when parsing parameterized headers
Properties
$canIgnoreSpacesAfter
    protected
        bool
    $canIgnoreSpacesAfter
     = false
    
        set to true to ignore spaces after this part
$canIgnoreSpacesBefore
    protected
        bool
    $canIgnoreSpacesBefore
     = false
    
        set to true to ignore spaces before this part
$charsetConverter
    protected
        MbWrapper
    $charsetConverter
    
    
        the charset converter used for converting strings in HeaderPart::convertEncoding
$language
    protected
        string
    $language
    
    
        the RFC-1766 language tag if set.
$languages
    protected
        array<string|int, mixed>
    $languages
     = []
    
        maintains an array mapping rfc1766 language tags to parts of text in the value.
Each array element is an array containing two elements, one with key 'lang', and another with key 'value'.
$name
    protected
        string
    $name
    
    
        the name of the parameter
$value
    protected
        string
    $value
    
    
        the value of the part
Methods
__construct()
Performs mime-decoding and initializes the address' name and email.
    public
                    __construct(MbWrapper $charsetConverter, string $name, string $email) : mixed
        The passed $name may be mime-encoded. $email is stripped of any whitespace.
Parameters
- $charsetConverter : MbWrapper
- $name : string
- $email : string
Return values
mixed —__toString()
Returns the value of the part (which is a string).
    public
                    __toString() : string
    
    
    
        Return values
string —the value
getEmail()
Returns the email address.
    public
                    getEmail() : string
    
    
    
        Return values
string —The email address.
getLanguage()
Returns the RFC-1766 (or subset) language tag, if the parameter is a split RFC-2231 part with a language tag set.
    public
                    getLanguage() : string
    
    
    
        Return values
string —the language
getLanguageArray()
Returns an array of parts mapped to languages in the header value, for instance the string:
    public
                    getLanguageArray() : array<string|int, array<string|int, string>>
        'Hello and =?UTF-8fr-be?Q?bonjour_?= =?UTF-8it?Q?mi amici?=. Welcome!'
Would be mapped in the returned array as follows:
[
    0 => [ 'lang' => null, 'value' => 'Hello and ' ],
    1 => [ 'lang' => 'fr-be', 'value' => 'bonjour ' ],
    3 => [ 'lang' => 'it', 'value' => 'mi amici' ],
    4 => [ 'lang' => null, 'value' => ' Welcome!' ]
]
Return values
array<string|int, array<string|int, string>> —getName()
Returns the name of the parameter.
    public
                    getName() : string
    
    
    
        Return values
string —The name.
getValue()
Returns the part's value.
    public
                    getValue() : string|null
    
    
    
        Return values
string|null —the value of the part
ignoreSpacesAfter()
Returns true if spaces after this part should be ignored. True is only returned for MimeLiterals if the part ends with a mime-encoded string Tokens if the Token's value is a single space, and for CommentParts.
    public
                    ignoreSpacesAfter() : bool
    
    
    
        Return values
bool —ignoreSpacesBefore()
Returns true if spaces before this part should be ignored. True is only returned for MimeLiterals if the part begins with a mime-encoded string, Tokens if the Token's value is a single space, and for CommentParts.
    public
                    ignoreSpacesBefore() : bool
    
    
    
        Return values
bool —addToLanguage()
Adds the passed part into the languages array with the given language.
    protected
                    addToLanguage(string $part[, string|null $language = null ]) : self
    
        Parameters
- $part : string
- $language : string|null = null
Return values
self —convertEncoding()
Ensures the encoding of the passed string is set to UTF-8.
    protected
                    convertEncoding(string $str[, string $from = 'ISO-8859-1' ][, bool $force = false ]) : string
        The method does nothing if the passed $from charset is UTF-8 already, or if $force is set to false and mb_check_encoding for $str returns true for 'UTF-8'.
Parameters
- $str : string
- $from : string = 'ISO-8859-1'
- $force : bool = false
Return values
string —utf-8 string
decodeMime()
Finds and replaces mime parts with their values.
    protected
                    decodeMime(string $value) : string
        The method splits the token value into an array on mime-part-patterns, either replacing a mime part with its value by calling iconv_mime_decode or converts the encoding on the text part by calling convertEncoding.
Parameters
- $value : string
Return values
string —decodeMatchedEntity()
Decodes a matched mime entity part into a string and returns it, after adding the string into the languages array.
    private
                    decodeMatchedEntity(array<string|int, string> $matches) : string
    
        Parameters
- $matches : array<string|int, string>
Return values
string —decodeSplitPart()
Decodes a single mime-encoded entity.
    private
                    decodeSplitPart(string $entity) : string
        Unfortunately, mb_decode_header fails for many charsets on PHP 5.4 and PHP 5.5 (even if they're listed as supported). iconv_mime_decode doesn't support all charsets.
Parsing out the charset and body of the encoded entity seems to be the way to go to support the most charsets.
Parameters
- $entity : string