content_process()

Note: You can change the way of parsing by customizing the markers constructor array. You can change the resulting output by customizing the other constructor arrays.

zone_process()

Since it is called first, and just after the creation of each new zone object, this is a very powerful method that allows you to manage the output generation before any other process. With this method you can even bypass or change the way of calling the other processes.

As other process methods, this process simply calls in turn all the handlers in the "zone_handlers" constructor array until some handler returns a true value: change the "zone_handlers" to change this process (see "zone_handlers" in Template::Magic).

lookup([identifier])

If identifier is omitted, it will use the zone id. Pass an identifier to lookup values from other zones.

This method looks up first in the containers found values, then in the lookups locations. You can customize the lookup by changing the items in the "lookups" constructor array.

lookup_process()

Note: it works only IF the zone value property is undefined.

value_process()

As other process methods, this process simply calls in turn all the handlers in the "value_handlers" constructor array until some handler returns a true value: change the "value_handlers" to change this process (see "value_handlers" in Template::Magic).

Note: it works only IF the zone value property is defined.

text_process()

As other process methods, this process simply calls in turn all the handlers in the "text_handlers" constructor array until some handler returns a true value: change the "zone_handlers" to change this process (see "text_handlers" in Template::Magic).

Note: If the "text_handlers" constructor array is undefined (as it is by default) the text will be processed by the "output_process()" instead. Use this method only if you need to process the text coming from the template in some special way, different by the text coming from the code.

output_process()

As other process methods, this process simply calls in turn all the handlers in the "output_handlers" constructor array until some handler returns a true value: change the "zone_handlers" to change this process (see "output_handlers" in Template::Magic).

post_process()

As other process methods, this process simply calls in turn all the handlers in the "post_handlers" constructor array until some handler returns a true value: change the "zone_handlers" to change this process (see "post_handlers" in Template::Magic).

include_template( template )

AUTOLOAD()

All the properties are "lvalue" methods, that means that you can use the property as a left value :

    # to set classical way (it works anyway)
    $z->value('whatever')   ;
    
    # to set new way (lvalue type)
    $z->value  = 'whatever' ;
    
    $the_value = $z->value  ; # to retrive

If you plan to customize the behaviours of Template::Magic, you will find useful the "AUTOLOAD" method. You can automatically set and retrieve your own properties by just using them. The following example shows how you can add a custom 'my_attributes' property to the zone object

In the template zone 'my_zone':

    text {my_zone attr1 attr2 attr3} content {/my_zone} text

These are the properties right after the parsing:

    $zone->id is set to the string 'my_zone'
    $zone->attributes is set to the string ' attr1 attr2 attr3'
    $zone->content is set to the string ' content '

If you want to have your own 'my_attributes' property, structured as you want, you could do this:

    # creates a 'my_attributes' property
    # and set it to an array ref containing one word per element
    $zone->my_attributes = [ split /\s+/,  substr( $zone->attributes, 1) ]

From now on you can retrieve the attributes your way:

    # retrieves the second attribute
    print $zone->my_attributes->[1]
    
    # would print
    attr2

tm

Note: this is a read only property.

mt

id

Note: this is a read only property.

attributes

Note: this is a read only property.

content

Note: this is a read only property.

param

container

Note: this is a read only property.

level

location

Usually you don't need to set this property, but you could find it very useful, for example, to access the object methods of a lookup element from inside an extension. (more documentation to come)

value

It's important to understand that the "value_process()" implies a recursive assignation to this property (not to mention that other processes could set the property as well). That means that the "value" property will return different values in different part of that process. For example: if you have this simple template:

    text {my_id_label} text

and this simple code where Template::Magic is looking up:

    $scalar = 'I am a simple string';
    $reference = \$scalar;
    $my_id_label = $reference;

At the beginning of the process, the "value" property will return a reference, then (after passing through the other value handlers) it will be dereferenced and so the "value" property, at that point, will return 'I am a simple string'.

Note: In order to make it work, if the found value is a SCALAR or a REFERENCE it must be set the "value" property 'as is'; if it is anything else, it must be set as a reference. For example:

    found values          value of $zone->value
    ------------------------------------
    'SCALAR'              'SCALAR'
    (1..5)                [1..5]
    [1..5]                [1..5]
    (key=>'value')        {key=>'value'}
    {key=>'value'}        {key=>'value'}
    ------------------------------------

output

is_main

Note: this is a read only property.

_t

_s

_e