# Model Behaviors Parameters<no value>
Within the model behaviors XML you will be using many **parameters**. In the context of the behavior XML a parameter is used to store a value that you will want to use later in some function or element. They are created within some specific scopes defined by the following nodes:

1.  [`<Parameters>`](../general-template-xml-properties/#Parameters)
2.  [`<UseParametersFn>`](../general-template-xml-properties/#UseParametersFn)
3.  [`<UseTemplate>`](../general-template-xml-properties/#UseTemplate)
4.  [`<UseInputEvent>`](../general-template-xml-properties/#UseInputEvent)
5.  [`<ReturnParameters>`](../general-template-xml-properties/#ReturnParameters)
6.  [`<SaveParameters>`](../general-template-xml-properties/#saveparams)

 

Components essentially push a scope on the stack of parameters, and parameters defined within a component will be valid for the whole parsing of the elements defined in the same scope or below. Parameters are a fundamental part of using model behaviors, and at their most basic they consist of an **identifier** and a **value**. An identifier can only consist of a combination of the following characters:

-   `0` to `9`
-   `A` to `Z` and `a` to `z`
-   `_` and `-`

for example:

``` xml
<A_PARAMETER>A parameter value</A_PARAMETER>
```

The value of a parameter can be anything *as long as it is written with ASCii characters*, however it should be noted that the value of parameters have to follow the strict XML restrictions, which means that some characters have to be escaped:

 

{{< table-wrapper >}}

| Character            | Escaped character |
|----------------------|-------------------|
| `>` *(greater-than)* | `&#62;` or `&gt;` |
| `<` *(less-than)*    | `&#60;` or `&lt;` |
| `&` *(ampersand)*    | `&#38;`           |

{{< /table-wrapper >}}


 

Once defined a parameter can be used in the scope it was defined in, and referencing a parameter value is done using the `#` symbol, as shown in this example:

``` xml
<Parameters Type="Default">
    <A_PARAMETER>Hello</A_PARAMETER>
</Parameters>
<Parameters Type="Override">
    <A_PARAMETER>#A_PARAMETER#, world!</A_PARAMETER>
</Parameters>

```

 

Note, however, that you cannot use a parameter in the same node that it was defined in, for example, this would give an error:

``` xml
<Parameters Type="Default">
    <A_PARAMETER>Hello</A_PARAMETER>
    <AN_OTHER_PARAMETER>#A_PARAMETER#, world!</AN_OTHER_PARAMETER>
    
</Parameters>
```

 

A parameter can be defined several time with the same identifier, depending on the scope, and when this happens **the parameter value will be overridden**. The only exception to this rule is when using the "Default" override, which ensures that if the parameter was defined before, a redefinition will not override the previous value. This default override rule is only used by the [`<Parameters>`](../general-template-xml-properties/#Parameters) and [`<SaveParameters>`](../general-template-xml-properties/#saveparams) elements and is specified using the `Type` or `Append` attribute. The sample below shows how things work when the `Type` is omitted or set to "Override" for a parameter (save parameters are explained in the section below):

``` xml
<Parameters Type="Default">
    <A_PARAMETER>A value</A_PARAMETER>
</Parameters>
<Parameters Type="Override">
    <A_PARAMETER>An other value</A_PARAMETER>
</Parameters>

<Parameters>
    <A_PARAMETER>A value</A_PARAMETER>
</Parameters>
<Parameters>
    <A_PARAMETER>Another value</A_PARAMETER>
</Parameters>

```

 

And this sample shows what happens when Type is set to "Default":

``` xml
<Parameters Type="Default">
    <A_PARAMETER>A value</A_PARAMETER>
</Parameters>
<Parameters Type="Default">
    <A_PARAMETER>Another value</A_PARAMETER>
</Parameters>

```

 

 

### Save parameters

A parameter save using [`<SaveParameters>`](../general-template-xml-properties/#saveparams) can be defined anywhere [`<Parameters>`](../general-template-xml-properties/#Parameters) can be defined. The save is given a unique identifier value and a list of parameters to save, which are then saved to a stack separate to the main one. For example:

``` xml
<SaveParameters ID="Save_ID">
    <A_PARAM>A Value</A_PARAM>
</SaveParameters>
```

 

At it's most basic, this way of saving parameters is **destructive**, meaning that - unless an `Append` rule is defined - **the save will be reset if it already existed**, and only the new parameters being set for saving will be stored:

``` xml
<SaveParameters ID="My_Saved_Parameters">
    <A_PARAM>A Value</A_PARAM>
</SaveParameters>
<SaveParameters ID="My_Saved_Parameters">
    <B_PARAM>Another Value</B_PARAM>
</SaveParameters>



```

 

Using an `Append` rule will prevent this behavior and give you some control over how any existing parameter values should be handled. Similar to the [`<Parameters>`](../general-template-xml-properties/#Parameters) element, this is done by setting the `Append` attribute, with the "Default" behaviour being to append parameters onto the save stack, as shown in the example below:

``` xml
<SaveParameters ID="My_Saved_Parameters">
    <A_PARAMETER>A value</A_PARAMETER>
</SaveParameters>
<SaveParameters ID="My_Saved_Parameters" Append="Default">
    <B_PARAMETER>An other value</B_PARAMETER>
</SaveParameters>


```

 

The `Append` attribute will also modify how existing parameters will behave when saved to the stack. When set to "Default" and you save a parameter with the same name as one already saved, the parameter will *not* be overridden:

``` xml
<SaveParameters ID="My_Saved_Parameters">
    <A_PARAMETER>A value</A_PARAMETER>
</SaveParameters>
<SaveParameters ID="My_Saved_Parameters" Append="Default">
    <A_PARAMETER>An other value</A_PARAMETER>
    
</SaveParameters>

```

 

However, when the attribute is set to "Override", it will be:

``` xml
<SaveParameters ID="My_Saved_Parameters">
    <A_PARAMETER>A value</A_PARAMETER>
</SaveParameters>
<SaveParameters ID="My_Saved_Parameters" Append="Override">
    <A_PARAMETER>An other value</A_PARAMETER>
    
</SaveParameters>

```

 

 

### Load parameters

The element [`<LoadParameters />`](../general-template-xml-properties/#loadparams) can be used to load a copy of the contents of the given save stack ID onto the current parameter stack. Note that performing a load operation is *not* destructive, and loaded parameters will still exist in the save with the same value. Essentially, the action is always to load a **copy**.

``` xml
<SaveParameters ID="Save_ID">
    <A_PARAM>A Value</A_PARAM>
</SaveParameters>
<LoadParameters ID="Save_ID"/>


```

Note that if a save isn't found for the given ID then the load will simply fail *silently*. The existence of a saved parameter stack can be checked using the [`<Condition>`](../program-template-xml-properties/#Condition) attribute `CheckSavedParameters` where the attribute value is the ID of the save stack to look up.

 

 

### Remove saved parameters

The element [`<RemoveSavedParameters />`](../general-template-xml-properties/#removeparams) can be used to remove a saved stack of parameters.

``` xml
<SaveParameters ID="Save_ID">
    <A_PARAM>A Value</A_PARAM>
</SaveParameters>
<LoadParameters ID="Save_ID"/>
<RemoveSavedParameters ID="Save_ID"/>


```

Similarly to [`<LoadParameters />`](../general-template-xml-properties/#loadparams), if a save isn't found for the given ID, the removal will fail *silently*.

 

 

### Macros

Macros are a kind of a *constant* parameter, where the value of a macro is defined in one place and can then be used anywhere. The lifetime of a macro is the same as the global scope, which is to say the same as the [`<Template>`](../general-template-xml-properties/#Template), [`<InputEvent>`](../general-template-xml-properties/#InputEvent), and [`<ParametersFn>`](../general-template-xml-properties/#ParametersFn) elements. The global scope simply keeps track of which item is defined as a "global" item and maps an identifier to the definition value. In the case of macros, anywhere you'd use the `#PARAMETER#` syntax you can safely use the `@MacroName` syntax, for example:

``` xml
<Macro Name="16K">16384</Macro>
<Parameters Type="Default">
    <A_PARAMETER>@16K</A_PARAMETER>
</Parameters>

```

 

 

### Parameter Attributes

A parameter value can be processed by adding the `Process` attribute to it. Processing a parameter can be used to simplify a calculation or make some simple string operations. Processing will interpret the value as [RPN](../../../../programming-apis/reverse-polish-notation/) and execute it, then the return value will be assigned to the parameter value, overriding its previous contents.

 

<table><thead><tr class="header"><th>Attribute</th><th>Description</th><th>Type</th><th>Required</th></tr></thead><tbody><tr class="odd"><td><code>Process</code></td><td>This processes the contents of the parameter ins a specific way, as explained below.</td><td><p>String:</p><ol><li>"Int"</li><li>"Float"</li><li>"Param"</li><li>"String"</li><li>"Macro"</li></ol></td><td>No</td></tr></tbody></table>

 

The attribute types listed above will do the following:

 

-   ##### Float

    Compute the contents of the element using RPN, with an *float* result of up to 6 decimal places:

    ``` xml
    <Macro Name="16K">16384</Macro>
    <Parameters Type="Default">
        <ONE_TENTH_OF_16K Process="Float">@16K 10 /</ONE_TENTH_OF_16K>
    </Parameters>
    
    ```

##### 

-   ##### Int

    Compute the contents of the element using RPN, with an *integer* result, truncating the decimal part (you can use `near` in the RPN to round the number to avoid unwanted truncation):

    ``` xml
    <Macro Name="16K">16384</Macro>
    <Parameters Type="Default">
        <ONE_TENTH_OF_16K Process="Int">@16K 10 /</ONE_TENTH_OF_16K>
    </Parameters>
    
    ```

##### 

-   ##### Param

    Get the content of a parameter by name when it is not possible to use `#PARAM_NAME#`. What this means is that the `#` parameter will first be evaluated, then it's value will be used to create the parameter within the node. Essentially the value of the parameter will be looked up in the parameter stack for a matching parameter identifier and - if a parameter is found - its value will be copied otherwise the parameter will be declared "empty":

    ``` xml
    <Parameters Type="Default">
        <PARAM_ID>0</PARAM_ID>
        <PARAM_0>A value</PARAM_0>
        <PARAM_1>An other value</PARAM_1>
    </Parameters>
    <Parameters Type="Default">
        <A_PARAM Process="Param">PARAM_#PARAM_ID#</A_PARAM>
    </Parameters>
    
    ```

##### 

-   ##### String

    Allow a parameter to be processed as a string using the RPN [String Operators](../../../../programming-apis/reverse-polish-notation/#String%20Operators):

    ``` xml
    <Parameters Type="Default">
        <HELLO_WORLD_UC Process="String">'Hello, world!' uc</HELLO_WORLD_UC>
    </Parameters>
    
    ```

##### 

-   ##### Macro

    This will look for a [`<Macro>`](../general-template-xml-properties/#Macro) with the provided name and if it exist copy it's value to the parameter. Useful when one wants to programmatically choose one macro. If the macro is not found the parameter will be "empty":

    ``` xml
    <Macro Name="GetMyVar">(L:1:XMLVAR_MY_VAR)</Macro>
    <Macro Name="GetAnotherVar">(L:1:XMLVAR_ANOTHER_VAR)</Macro>
    <Parameters Type="Default">
        <VAR_NAME>MyVar</VAR_NAME>
    </Parameters>
    <Parameters Type="Default">
        <GET_VAR Process="Macro">Get#VAR_NAME#</GET_VAR>
    </Parameters>
    
    ```

 

 

### Conditional Statements

Parameters definition is compatible with conditional statements, ie: a parameter can be defined depending on an other parameter value, as shown in the example below:

``` xml
<Parameters Type="Default">
    <USE_PARAMETER_A>True</USE_PARAMETER_A>
</Parameters>
<Parameters Type="Default">
    <Condition Valid="USE_PARAMETER_A">
        <True>
            <A_PARAMETER/>
        </True>
        <False>
            <B_PARAMETER/>
        </False>
    </Condition>
</Parameters>

```

 

In the case of a [`<Loop>`](../program-template-xml-properties/#Loop) within a parameter definition, the parameters defined within the [`<Do>`](../program-template-xml-properties/#Do) or the [`<Then>`](../program-template-xml-properties/#Then) will be given the scope of the parameter definition the loop is defined in, eg:

``` xml
<Parameters Type="Default">
    <Loop>
        <Setup>
            <Param>PARAM</Param>
            <Value>VALUE</Value>
            <Parameters>
                <PARAM_A>1</PARAM_A>
                <PARAM_B>2</PARAM_B>
                <PARAM_C>3</PARAM_C>
            </Parameters>
        </Setup>
        <Do>
            <#PARAM#>My ID is #VALUE#</#PARAM#>
        </Do>
    </Loop>
</Parameters>



```

You can find more information on conditional statements from the following page:

-   [Program Template XML Properties](../program-template-xml-properties/)