privateAll

Description

Disables the implicit inheritance of local variables, as defined in the parent scope.

By default, any local variables defined in a parent scope are available to the lower scope code.

After using privateAll, parent scope variables can no longer be accessed implicitly. However, it is still possible to explicitly access parent scope variables using the import command.

Syntax

privateAll

Returns: Nothing

Examples

Example 1

_a = 1;
_b = 2;
_c = 3;
4 call {
    // _a, _b and _c from the parent scope are accessible at this point
    systemChat str [_a, _b, _c];             // prints [1, 2, 3]
    privateAll;                             // _a, _b and _c from the parent scope can no longer be accessed
    systemChat str [_a, _b, _c];             // prints [Any, Any, Any]
    import ["_a", "_b"];                     // _a and _b are now defined as private variables in the current scope; _c is still not defined
    systemChat str [_a, _b, _c, _this];     // prints [1, 2, Any, 4]
    _a = _a + 1;                             // changes the private _a variable in the current scope, but doesn't change the parent scope _a
};
systemChat str _a; // _a is still 1

Example 2

private _a = /* ... */;
private _b = /* ... */;
private _c = /* ... */;

{
    _x call {
        privateAll;
        import ["_a", "_b"];
        call _this;
    };
} forEach CustomEventHandlers;

1. Because of the import-statement, code from CustomEventHandlers can use _a and _b without using params (even if _a and _b were provided via _this, which is not the case here).
2. Code from CustomEventHandlers can only see _a and _b, but no other variables such as _c, _x or _forEachIndex.
3. Code from CustomEventHandlers can modify _a and _b (e.g. _a = _b / 2), but only within its own scope (i.e. CustomEventHandlers # (n + 1) will not see any changes that CustomEventHandlers # n may have made to _a and _b).
4. The values of _a, _b and _c after the forEach-loop are guaranteed to be the same as before the forEach-loop.

Important

There is one important exception to points 3 and 4: Modifications by reference (e.g. _a pushBack 123 where _a is an Array) are applied in all scopes. This can be avoided by copying _a before calling the CustomEventHandlers code:

private _a = [/* ... */]; // Note that _a is an array.
private _b = /* ... */;
private _c = /* ... */;

{
    _x call {
        privateAll;
        import ["_a", "_b"];
        _a = +_a; // Copy the array so that the code from CustomEventHandlers can no longer modify the original array.
        call _this;
    };
} forEach CustomEventHandlers;

See also

import · private · Variables