Documentation

EmphasisDelimiterProcessor
in package
implements CacheableDelimiterProcessorInterface, ConfigurationAwareInterface

FinalYes

Table of Contents

Interfaces

CacheableDelimiterProcessorInterface
Special marker interface for delimiter processors that return dynamic values from getDelimiterUse()
ConfigurationAwareInterface
Implement this class to facilitate setter injection of the configuration where needed

Properties

$char  : string
$config  : ConfigurationInterface

Methods

__construct()  : mixed
getCacheKey()  : string
Returns a cache key of the factors that determine the number of characters to use.
getClosingCharacter()  : string
Returns the character that marks the ending of a delimited node.
getDelimiterUse()  : int
Determine how many (if any) of the delimiter characters should be used.
getMinLength()  : int
Minimum number of delimiter characters that are needed to active this.
getOpeningCharacter()  : string
Returns the character that marks the beginning of a delimited node.
process()  : void
Process the matched delimiters, e.g. by wrapping the nodes between opener and closer in a new node, or appending a new node after the opener.
setConfiguration()  : void

Properties

Methods

__construct()

public __construct(string $char) : mixed
Parameters
$char : string

The emphasis character to use (typically '*' or '_')

getCacheKey()

Returns a cache key of the factors that determine the number of characters to use.

public getCacheKey(DelimiterInterface $closer) : string

In order to guarantee linear performance of delimiter processing, the delimiter stack must be able to cache the lower bound when searching for a matching opener. This lower bound is usually quite simple; for example, with quotes, it's just the last opener with that characted. However, this gets complicated for delimiter processors that use a dynamic number of characters (like with emphasis and its "multiple of 3" rule), because the delimiter length being considered may change during processing because of that dynamic logic in getDelimiterUse(). Therefore, we cannot safely cache the lower bound for these dynamic processors without knowing the factors that determine the number of characters to use.

At a minimum, this should include the delimiter character, plus any other factors used to determine the result of getDelimiterUse(). The format of the string is not important so long as it is unique (compared to other processors) and consistent for a given set of factors.

If getDelimiterUse() always returns the same hard-coded value, this method should return just the delimiter character.

Parameters
$closer : DelimiterInterface
Return values
string

getClosingCharacter()

Returns the character that marks the ending of a delimited node.

public getClosingCharacter() : string

This must not clash with any other processors being added to the environment.

Note that for a symmetric delimiter such as "*", this is the same as the opening.

Return values
string

getDelimiterUse()

Determine how many (if any) of the delimiter characters should be used.

public getDelimiterUse(DelimiterInterface $opener, DelimiterInterface $closer) : int

This allows implementations to decide how many characters to be used based on the properties of the delimiter runs. An implementation can also return 0 when it doesn't want to allow this particular combination of delimiter runs.

IMPORTANT: Unless this method returns the same hard-coded value in all cases, you MUST implement the CacheableDelimiterProcessorInterface interface instead.

Parameters
$opener : DelimiterInterface

The opening delimiter run

$closer : DelimiterInterface

The closing delimiter run

Return values
int

getMinLength()

Minimum number of delimiter characters that are needed to active this.

public getMinLength() : int

Must be at least 1.

Return values
int

getOpeningCharacter()

Returns the character that marks the beginning of a delimited node.

public getOpeningCharacter() : string

This must not clash with any other processors being added to the environment.

Return values
string

process()

Process the matched delimiters, e.g. by wrapping the nodes between opener and closer in a new node, or appending a new node after the opener.

public process(AbstractStringContainer $opener, AbstractStringContainer $closer, int $delimiterUse) : void

Note that removal of the delimiter from the delimiter nodes and detaching them is done by the caller.

Parameters
$opener : AbstractStringContainer

The node that contained the opening delimiter

$closer : AbstractStringContainer

The node that contained the closing delimiter

$delimiterUse : int

The number of delimiters that were used


        

        
    




    

    

                                

                

                                
    

        On this page

        
    


                

                            

            

    

        

            
Search results