old-town / old-town-workflow

        // set up validators -- OPTIONAL

        $v = XMLUtil::getChildElement($action, 'validators');

        if (null !== $v) {

            $validators = XMLUtil::getChildElements($v, 'validator');

            foreach ($validators as $validator) {

                $validatorDescriptor = DescriptorFactory::getFactory()->createValidatorDescriptor($validator);

                $validatorDescriptor->setParent($this);

                $this->validators->attach($validatorDescriptor);

            }

        }

        // set up pre-functions -- OPTIONAL

        $pre = XMLUtil::getChildElement($action, 'pre-functions');

        // set up pre-functions -- OPTIONAL

        $pre = XMLUtil::getChildElement($action, 'pre-functions');

        if (null !== $pre) {

            $preFunctions = XMLUtil::getChildElements($pre, 'function');

            foreach ($preFunctions as $preFunction) {

                $functionDescriptor = DescriptorFactory::getFactory()->createFunctionDescriptor($preFunction);

                $functionDescriptor->setParent($this);

                $this->preFunctions->attach($functionDescriptor);

            }

        }

        // set up results - REQUIRED

        $resultsElement = XMLUtil::getChildElement($action, 'results');

        // set up post-functions - OPTIONAL

        $post = XMLUtil::getChildElement($action, 'post-functions');

        if (null !== $post) {

            $postFunctions = XMLUtil::getChildElements($post, 'function');

            foreach ($postFunctions as $postFunction) {

                $functionDescriptor = DescriptorFactory::getFactory()->createFunctionDescriptor($postFunction);

                $functionDescriptor->setParent($this);

                $this->postFunctions->attach($functionDescriptor);

            }

        }

        // set up restrict-to - OPTIONAL

        $restrictElement = XMLUtil::getChildElement($action, 'restrict-to');

        // set up validators -- OPTIONAL

        $v = XMLUtil::getChildElement($result, 'validators');

        if (null !== $v) {

            $validators = XMLUtil::getChildElements($v, 'validator');

            foreach ($validators as $validator) {

                $validatorDescriptor = DescriptorFactory::getFactory()->createValidatorDescriptor($validator);

                $validatorDescriptor->setParent($this);

                $this->validators->attach($validatorDescriptor);

            }

        }

        // set up pre-functions -- OPTIONAL

        $pre = XMLUtil::getChildElement($result, 'pre-functions');

        // set up pre-functions -- OPTIONAL

        $pre = XMLUtil::getChildElement($result, 'pre-functions');

        if (null !== $pre) {

            $preFunctions = XMLUtil::getChildElements($pre, 'function');

            foreach ($preFunctions as $preFunction) {

                $functionDescriptor = DescriptorFactory::getFactory()->createFunctionDescriptor($preFunction);

                $functionDescriptor->setParent($this);

                $this->preFunctions->attach($functionDescriptor);

            }

        }

        // set up post-functions - OPTIONAL

        $post = XMLUtil::getChildElement($result, 'post-functions');

        // set up post-functions - OPTIONAL

        $post = XMLUtil::getChildElement($result, 'post-functions');

        if (null !== $post) {

            $postFunctions = XMLUtil::getChildElements($post, 'function');

            foreach ($postFunctions as $postFunction) {

                $functionDescriptor = DescriptorFactory::getFactory()->createFunctionDescriptor($postFunction);

                $functionDescriptor->setParent($this);

                $this->postFunctions->attach($functionDescriptor);

            }

        }

    }

    /**

        // set up pre-functions -- OPTIONAL

        $pre = XMLUtil::getChildElement($step, 'pre-functions');

        if (null !== $pre) {

            $preFunctions = XMLUtil::getChildElements($pre, 'function');

            foreach ($preFunctions as $preFunction) {

                $functionDescriptor = DescriptorFactory::getFactory()->createFunctionDescriptor($preFunction);

                $functionDescriptor->setParent($this);

                $this->preFunctions->attach($functionDescriptor);

            }

        }

        // set up permissions - OPTIONAL

        $p = XMLUtil::getChildElement($step, 'external-permissions');

        // set up permissions - OPTIONAL

        $p = XMLUtil::getChildElement($step, 'external-permissions');

        if (null !== $p) {

            $permissions = XMLUtil::getChildElements($p, 'permission');

            foreach ($permissions as $permission) {

                $permissionDescriptor = DescriptorFactory::getFactory()->createPermissionDescriptor($permission);

                $permissionDescriptor->setParent($this);

                $this->permissions->attach($permissionDescriptor);

            }

        }

        // set up actions - OPTIONAL

        $a = XMLUtil::getChildElement($step, 'actions');

        // set up post-functions - OPTIONAL

        $post = XMLUtil::getChildElement($step, 'post-functions');

        if (null !== $post) {

            $postFunctions = XMLUtil::getChildElements($post, 'function');

            foreach ($postFunctions as $postFunction) {

                $functionDescriptor = DescriptorFactory::getFactory()->createFunctionDescriptor($postFunction);

                $functionDescriptor->setParent($this);

                $this->postFunctions->attach($functionDescriptor);

            }

        }

    }

    /**

        // handle registers - OPTIONAL

        $r = XmlUtil::getChildElement($root, 'registers');

        if (null !== $r) {

            $registers = XMLUtil::getChildElements($r, 'register');

            foreach ($registers as $register) {

                $registerDescriptor = DescriptorFactory::getFactory()->createRegisterDescriptor($register);

                $registerDescriptor->setParent($this);

                $this->registers->attach($registerDescriptor);

            }

        }

        // handle global-conditions - OPTIONAL

        $globalConditionsElement = XMLUtil::getChildElement($root, 'global-conditions');

        // handle global-actions - OPTIONAL

        $globalActionsElement = XMLUtil::getChildElement($root, 'global-actions');

        if (null !== $globalActionsElement) {

            $globalActions = XMLUtil::getChildElements($globalActionsElement, 'action');

            foreach ($globalActions as $globalAction) {

                $actionDescriptor = DescriptorFactory::getFactory()->createActionDescriptor($globalAction);

                $actionDescriptor->setParent($this);

                $this->addGlobalAction($actionDescriptor);

            }

        }

        // handle common-actions - OPTIONAL

        //      any common actions into local references.

        $commonActionsElement = XMLUtil::getChildElement($root, 'common-actions');

        if (null !== $commonActionsElement) {

            $commonActions = XMLUtil::getChildElements($commonActionsElement, 'action');

            foreach ($commonActions as $commonAction) {

                $actionDescriptor = DescriptorFactory::getFactory()->createActionDescriptor($commonAction);

                $actionDescriptor->setParent($this);

                $this->addCommonAction($actionDescriptor);

            }

        }

        // handle timer-functions - OPTIONAL

        // handle splits - OPTIONAL:

        $splitsElement = XMLUtil::getChildElement($root, 'splits');

        if (null !== $splitsElement) {

            $split = XMLUtil::getChildElements($splitsElement, 'split');

            foreach ($split as $s) {

                $splitDescriptor = DescriptorFactory::getFactory()->createSplitDescriptor($s);

                $splitDescriptor->setParent($this);

                $this->addSplit($splitDescriptor);

            }

        }

        // handle joins - OPTIONAL:

        // handle joins - OPTIONAL:

        $joinsElement = XMLUtil::getChildElement($root, 'joins');

        if (null !== $joinsElement) {

            $join = XMLUtil::getChildElements($joinsElement, 'join');

            foreach ($join as $s) {

                $joinDescriptor = DescriptorFactory::getFactory()->createJoinDescriptor($s);

                $joinDescriptor->setParent($this);

                $this->addJoin($joinDescriptor);

            }

        }

    }

    /**