51    require_once(
"SeqActivity.php");
 
   53    require_once(
"SeqRule.php");
 
   54    require_once(
"SeqRuleset.php");
 
   56    require_once(
"SeqCondition.php");
 
   57    require_once(
"SeqConditionSet.php");
 
   59    require_once(
"SeqObjective.php");
 
   60    require_once(
"SeqObjectiveMap.php");
 
   62    require_once(
"SeqRollupRule.php");
 
   63    require_once(
"SeqRollupRuleset.php");
 
   65    require_once(
"ADLAuxiliaryResource.php");
 
   71            $doc = 
new DomDocument();
 
   76            $default=preg_replace(
'/(%20)+/', 
' ', trim(
$organizations->item(0)->getAttribute(
"default")));
 
   79            $organization = $doc->getElementsByTagName(
"organization");
 
   82            foreach ($organization as $element) {
 
   83                if (preg_replace(
'/(%20)+/', 
' ', trim($element->getAttribute(
"identifier")))==$default) {
 
   84                    $default_organization = $element;
 
   89            $seqCollection = $doc->getElementsByTagName(
"sequencingCollection")->item(0);
 
   91            $root = $this->
buildNode($default_organization, $seqCollection, $doc);
 
   94            $objectivesGlobalToSystem = $default_organization->getAttributeNS(
"http://www.adlnet.org/xsd/adlseq_v1p3", 
"objectivesGlobalToSystem");
 
   96            $org = preg_replace(
'/(%20)+/', 
' ', trim($default_organization->getAttribute(
"identifier")));
 
  101            if ($objectivesGlobalToSystem==
"false") {
 
  106            $dataGlobalToSystem = $default_organization->getAttributeNS(
"http://www.adlnet.org/xsd/adlcp_v1p3", 
"sharedDataGlobalToSystem");
 
  109            $dataglobaltosystem = 1;
 
  111            if ($dataGlobalToSystem==
"false") {
 
  112                $dataglobaltosystem = 0;
 
  116            $c_root[
'_SeqActivity']=$root;
 
  118            $ret[
'global'] = $globaltosystem;
 
  119            $ret[
'dataglobal'] = $dataglobaltosystem;
 
  120            $ret[
'tree'] = $c_root;
 
  134            $act->setID(preg_replace(
'/(%20)+/', 
' ', trim($node->getAttribute(
"identifier"))));
 
  136            $tempVal = preg_replace(
'/(%20)+/', 
' ', trim($node->getAttribute(
"identifierref")));
 
  138                $act->setResourceID($tempVal);
 
  141            $tempVal = $node->getAttribute(
"isvisible");
 
  144                $act->setIsVisible(self::convert_to_bool($tempVal));
 
  150            $children = $node->childNodes;
 
  152            for (
$i = 0; 
$i < $children->length; 
$i++) {
 
  153                $curNode=$children->item(
$i);
 
  156                if ($curNode->nodeType == XML_ELEMENT_NODE) {
 
  158                    if ($curNode->localName == 
"item") {
 
  162                        $nestedAct = $this->
buildNode($curNode, $seq, $doc);
 
  163                        if ($nestedAct != 
null) {
 
  164                            $act->AddChild($nestedAct);
 
  166                    } elseif ($curNode->localName == 
"title") {
 
  168                    } elseif ($curNode->localName == 
"completionThreshold") {
 
  169                        $tempVal = $curNode->getAttribute(
"minProgressMeasure");
 
  172                            $act->setCompletionThreshold($tempVal);
 
  173                        } elseif ($curNode->nodeValue != 
null && $curNode->nodeValue != 
'') {
 
  174                            $act->setCompletionThreshold($curNode->nodeValue);
 
  177                        $tempVal = $curNode->getAttribute(
"progressWeight");
 
  180                            $act->setProgressWeight($tempVal);
 
  182                        $tempVal = $curNode->getAttribute(
"completedByMeasure");
 
  185                            $act->setCompletedByMeasure(self::convert_to_bool($tempVal));
 
  187                    } elseif ($curNode->localName == 
"sequencing") {
 
  190                        $tempVal = preg_replace(
'/(%20)+/', 
' ', trim($curNode->getAttribute(
"IDRef")));
 
  197                            $sequencing = $seq->getElementsByTagName(
"sequencing");
 
  200                            foreach ($sequencing as $element) {
 
  201                                if (preg_replace(
'/(%20)+/', 
' ', trim($element->getAttribute(
"ID")))==$tempVal) {
 
  202                                    $seqGlobal = $element;
 
  207                            $seqInfo = $seqGlobal->cloneNode(
true);
 
  210                            $seqChildren = $curNode->childNodes;
 
  211                            for ($j = 0; $j < $seqChildren->length; $j++) {
 
  213                                $curChild = $seqChildren->item($j);
 
  214                                if ($curChild->nodeType == XML_ELEMENT_NODE) {
 
  217                                    $seqInfo->appendChild($curChild);
 
  229                $item=$children->item(
$i)->nodeValue;
 
  240            $children = $iNode->childNodes;
 
  241            for (
$i = 0; 
$i < $children->length; 
$i++) {
 
  242                $curNode = $children->item(
$i);
 
  243                if ($curNode->nodeType == XML_ELEMENT_NODE) {
 
  244                    if ($curNode->localName == 
"controlMode") {
 
  246                        $tempVal=$curNode->getAttribute(
"choice");
 
  248                            $ioAct->setControlModeChoice(self::convert_to_bool($tempVal));
 
  251                        $tempVal=$curNode->getAttribute(
"choiceExit");
 
  253                            $ioAct->setControlModeChoiceExit(self::convert_to_bool($tempVal));
 
  257                        $tempVal=$curNode->getAttribute(
"flow");
 
  259                            $ioAct->setControlModeFlow(self::convert_to_bool($tempVal));
 
  263                        $tempVal=$curNode->getAttribute(
"forwardOnly");
 
  265                            $ioAct->setControlForwardOnly(self::convert_to_bool($tempVal));
 
  269                        $tempVal=$curNode->getAttribute(
"useCurrentAttemptObjectiveInfo");
 
  271                            $ioAct->setUseCurObjective(self::convert_to_bool($tempVal));
 
  275                        $tempVal=$curNode->getAttribute(
"useCurrentAttemptProgressInfo");
 
  277                            $ioAct->setUseCurProgress(self::convert_to_bool($tempVal));
 
  279                    } elseif ($curNode->localName == 
"sequencingRules") {
 
  281                    } elseif ($curNode->localName == 
"limitConditions") {
 
  283                        $tempVal=$curNode->getAttribute(
"attemptLimit");
 
  285                            $ioAct->setAttemptLimit($tempVal);
 
  289                        $tempVal=$curNode->getAttribute(
"attemptAbsoluteDurationLimit");
 
  291                            $ioAct->setAttemptAbDur($tempVal);
 
  295                        $tempVal=$curNode->getAttribute(
"attemptExperiencedDurationLimit");
 
  297                            $ioAct->setAttemptExDur($tempVal);
 
  301                        $tempVal=$curNode->getAttribute(
"activityAbsoluteDurationLimit");
 
  303                            $ioAct->setActivityAbDur($tempVal);
 
  307                        $tempVal=$curNode->getAttribute(
"activityExperiencedDurationLimit");
 
  309                            $ioAct->setActivityExDur($tempVal);
 
  313                        $tempVal=$curNode->getAttribute(
"beginTimeLimit");
 
  315                            $ioAct->setBeginTimeLimit($tempVal);
 
  319                        $tempVal=$curNode->getAttribute(
"endTimeLimit");
 
  321                            $ioAct->setEndTimeLimit($tempVal);
 
  323                    } elseif ($curNode->localName == 
"auxiliaryResources") {
 
  325                    } elseif ($curNode->localName == 
"rollupRules") {
 
  327                    } elseif ($curNode->localName == 
"objectives" && $curNode->namespaceURI == 
"http://www.imsglobal.org/xsd/imsss") {
 
  329                    } elseif ($curNode->localName == 
"objectives" && $curNode->namespaceURI == 
"http://www.adlnet.org/xsd/adlseq_v1p3") {
 
  331                    } elseif ($curNode->localName == 
"randomizationControls") {
 
  334                        $tempVal=$curNode->getAttribute(
"randomizationTiming");
 
  336                            $ioAct->setRandomTiming($tempVal);
 
  340                        $tempVal=$curNode->getAttribute(
"selectCount");
 
  342                            $ioAct->setSelectCount($tempVal);
 
  346                        $tempVal=$curNode->getAttribute(
"reorderChildren");
 
  348                            $ioAct->setReorderChildren(self::convert_to_bool($tempVal));
 
  352                        $tempVal=$curNode->getAttribute(
"selectionTiming");
 
  354                            $ioAct->setSelectionTiming($tempVal);
 
  356                    } elseif ($curNode->localName == 
"deliveryControls") {
 
  359                        $tempVal=$curNode->getAttribute(
"tracked");
 
  361                            $ioAct->setIsTracked(self::convert_to_bool($tempVal));
 
  365                        $tempVal=$curNode->getAttribute(
"completionSetByContent");
 
  367                            $ioAct->setSetCompletion(self::convert_to_bool($tempVal));
 
  371                        $tempVal=$curNode->getAttribute(
"objectiveSetByContent");
 
  373                            $ioAct->setSetObjective(self::convert_to_bool($tempVal));
 
  375                    } elseif ($curNode->localName == 
"constrainedChoiceConsiderations") {
 
  378                        $tempVal=$curNode->getAttribute(
"preventActivation");
 
  380                            $ioAct->setPreventActivation(self::convert_to_bool($tempVal));
 
  384                        $tempVal=$curNode->getAttribute(
"constrainChoice");
 
  386                            $ioAct->setConstrainChoice(self::convert_to_bool($tempVal));
 
  388                    } elseif ($curNode->localName == 
"rollupConsiderations") {
 
  391                        $tempVal=$curNode->getAttribute(
"requiredForSatisfied");
 
  393                            $ioAct->setRequiredForSatisfied($tempVal);
 
  397                        $tempVal=$curNode->getAttribute(
"requiredForNotSatisfied");
 
  399                            $ioAct->setRequiredForNotSatisfied($tempVal);
 
  403                        $tempVal=$curNode->getAttribute(
"requiredForCompleted");
 
  405                            $ioAct->setRequiredForCompleted($tempVal);
 
  409                        $tempVal=$curNode->getAttribute(
"requiredForIncomplete");
 
  411                            $ioAct->setRequiredForIncomplete($tempVal);
 
  415                        $tempVal=$curNode->getAttribute(
"measureSatisfactionIfActive");
 
  417                            $ioAct->setSatisfactionIfActive(self::convert_to_bool($tempVal));
 
  434            $objectives = array();
 
  435            $children = $iNode->childNodes;
 
  436            for (
$i = 0; 
$i < $children->length; 
$i++) {
 
  437                $curNode=$children->item(
$i);
 
  438                if ($curNode->nodeType == XML_ELEMENT_NODE) {
 
  439                    if ($curNode->localName == 
"primaryObjective" || $curNode->localName == 
"objective") {
 
  441                        if ($curNode->localName == 
"primaryObjective") {
 
  442                            $obj->mContributesToRollup = 
true;
 
  446                        $tempVal = preg_replace(
'/(%20)+/', 
' ', trim($curNode->getAttribute(
"objectiveID")));
 
  448                            $obj->mObjID = $tempVal;
 
  452                        $tempVal = $curNode->getAttribute(
"satisfiedByMeasure");
 
  459                            $obj->mMinMeasure = $tempVal;
 
  469                        $c_obj[
'_SeqObjective'] = $obj;
 
  470                        array_push($objectives, $c_obj);
 
  474            $ioAct->setObjectives($objectives);
 
  481            $objectives = $ioAct->mObjectives;
 
  482            $children = $iNode->childNodes;
 
  483            for (
$i = 0; 
$i < $children->length; 
$i++) {
 
  484                $curNode=$children->item(
$i);
 
  485                if ($curNode->nodeType == XML_ELEMENT_NODE) {
 
  486                    if ($curNode->localName == 
"objective") {
 
  488                        $adlseqobjid = preg_replace(
'/(%20)+/', 
' ', trim($curNode->getAttribute(
"objectiveID")));
 
  492                        for ($j = 0; $j < count($objectives); $j++) {
 
  493                            $seqobj = $objectives[$j][
'_SeqObjective'];
 
  494                            if ($seqobj->mObjID == $adlseqobjid) {
 
  495                                $curseqobj = $seqobj;
 
  496                                $curseqobjindex = $j;
 
  502                        if ($curseqobj != 
null) {
 
  505                            $seqobj = $curseqobj;
 
  506                            $objectives[$curseqobjindex][
'_SeqObjective'] = $seqobj;
 
  513            $ioAct->setObjectives($objectives);
 
  519            if (count($curseqobj->mMaps)==
null) {
 
  520                $curseqobj->mMaps = array();
 
  522            $maps = $curseqobj->mMaps;
 
  524            $children = $iNode->childNodes;
 
  525            for (
$i = 0; 
$i < $children->length; 
$i++) {
 
  526                $curNode=$children->item(
$i);
 
  527                if ($curNode->nodeType == XML_ELEMENT_NODE) {
 
  528                    if ($curNode->localName == 
"mapInfo") {
 
  530                        $curadltargetobjid = preg_replace(
'/(%20)+/', 
' ', trim($curNode->getAttribute(
"targetObjectiveID")));
 
  532                        $matchingmapindex = -1;
 
  533                        for ($j = 0; $j < count($maps); $j++) {
 
  534                            if ($maps[$j][
'_SeqObjectiveMap']->mGlobalObjID == $curadltargetobjid) {
 
  535                                $map = $maps[$j][
'_SeqObjectiveMap'];
 
  536                                $matchingmapindex = $j;
 
  542                        if ($matchingmapindex > -1) {
 
  543                            $c_map[
'_SeqObjectiveMap']=$map;
 
  544                            $maps[$matchingmapindex] = $c_map;
 
  546                            $c_map[
'_SeqObjectiveMap']=$map;
 
  547                            array_push($maps, $c_map);
 
  552            $curseqobj->mMaps = $maps;
 
  558            if ($map->mGlobalObjID == 
null) {
 
  559                $map->mGlobalObjID = preg_replace(
'/(%20)+/', 
' ', trim($iNode->getAttribute(
"targetObjectiveID")));
 
  562            $tempVal = $iNode->getAttribute(
"readRawScore");
 
  567            $tempVal = $iNode->getAttribute(
"readMinScore");
 
  572            $tempVal = $iNode->getAttribute(
"readMaxScore");
 
  577            $tempVal = $iNode->getAttribute(
"readCompletionStatus");
 
  582            $tempVal = $iNode->getAttribute(
"readProgressMeasure");
 
  587            $tempVal = $iNode->getAttribute(
"writeRawScore");
 
  592            $tempVal = $iNode->getAttribute(
"writeMinScore");
 
  597            $tempVal = $iNode->getAttribute(
"writeMaxScore");
 
  602            $tempVal = $iNode->getAttribute(
"writeCompletionStatus");
 
  607            $tempVal = $iNode->getAttribute(
"writeProgressMeasure");
 
  619            $children = $iNode->childNodes;
 
  620            for (
$i = 0; 
$i < $children->length; 
$i++) {
 
  621                $curNode=$children->item(
$i);
 
  622                if ($curNode->nodeType == XML_ELEMENT_NODE) {
 
  623                    if ($curNode->localName == 
"mapInfo") {
 
  627                        $tempVal = preg_replace(
'/(%20)+/', 
' ', trim($curNode->getAttribute(
"targetObjectiveID")));
 
  629                            $map->mGlobalObjID = $tempVal;
 
  633                        $tempVal = $curNode->getAttribute(
"readSatisfiedStatus");
 
  639                        $tempVal = $curNode->getAttribute(
"readNormalizedMeasure");
 
  645                        $tempVal = $curNode->getAttribute(
"writeSatisfiedStatus");
 
  651                        $tempVal = $curNode->getAttribute(
"writeNormalizedMeasure");
 
  656                        $c_map[
'_SeqObjectiveMap']=$map;
 
  657                        array_push($maps, $c_map);
 
  661            if (count($maps)==
null) {
 
  671            $rollupRules = array();
 
  674            $tempVal = $iNode->getAttribute(
"rollupObjectiveSatisfied");
 
  676                $ioAct->setIsObjRolledUp(self::convert_to_bool($tempVal));
 
  680            $tempVal = $iNode->getAttribute(
"objectiveMeasureWeight");
 
  682                $ioAct->setObjMeasureWeight($tempVal);
 
  685            $tempVal = $iNode->getAttribute(
"rollupProgressCompletion");
 
  687                $ioAct->setIsProgressRolledUp(self::convert_to_bool($tempVal));
 
  689            $children = $iNode->childNodes;
 
  690            for (
$i = 0; 
$i < $children->length; 
$i++) {
 
  691                $curNode=$children->item(
$i);
 
  692                if ($curNode->nodeType == XML_ELEMENT_NODE) {
 
  693                    if ($curNode->localName == 
"rollupRule") {
 
  697                        $tempVal=$curNode->getAttribute(
"childActivitySet");
 
  699                            $rule->mChildActivitySet = $tempVal;
 
  702                        $tempVal=$curNode->getAttribute(
"minimumCount");
 
  704                            $rule->mMinCount = $tempVal;
 
  708                        $tempVal=$curNode->getAttribute(
"minimumPercent");
 
  710                            $rule->mMinPercent = $tempVal;
 
  713                        $conditions = array();
 
  714                        $ruleInfo = $curNode->childNodes;
 
  715                        for ($j = 0; $j < $ruleInfo->length; $j++) {
 
  716                            $curRule=$ruleInfo->item($j);
 
  718                            if ($curRule->nodeType == XML_ELEMENT_NODE) {
 
  719                                if ($curRule->localName == 
"rollupConditions") {
 
  720                                    $tempVal = $curRule->getAttribute(
"conditionCombination");
 
  722                                        $rule->mConditions[
'_SeqConditionSet']->mCombination = $tempVal;
 
  726                                    $conds = $curRule->childNodes;
 
  727                                    for ($k = 0; $k < $conds->length; $k++) {
 
  728                                        $con=$conds->item($k);
 
  729                                        if ($con->nodeType == XML_ELEMENT_NODE) {
 
  730                                            if ($con->localName == 
"rollupCondition") {
 
  733                                                $tempVal = $con->getAttribute(
"condition");
 
  735                                                    $cond->mCondition=$tempVal;
 
  738                                                $tempVal = $con->getAttribute(
"operator");
 
  740                                                    if ($tempVal==
'not') {
 
  747                                                $c_cond[
'_SeqCondition'] = $cond;
 
  748                                                array_push($conditions, $c_cond);
 
  752                                } elseif ($curRule->localName == 
"rollupAction") {
 
  753                                    $tempVal = $curRule->getAttribute(
"action");
 
  755                                        $rule->setRollupAction($tempVal);
 
  761                        $rule->mConditions[
'_SeqConditionSet']->mConditions = $conditions;
 
  765                        $c_rule[
'_SeqRollupRule']=
$rule;
 
  766                        array_push($rollupRules, $c_rule);
 
  771            if ($rollupRules != 
null) {
 
  775                $c_rules[
'_SeqRollupRuleset']=$rules;
 
  776                $ioAct->setRollupRules($c_rules);
 
  790            $exitRules = array();
 
  791            $postRules = array();
 
  794            $children = $iNode->childNodes;
 
  797            for (
$i = 0; 
$i < $children->length; 
$i++) {
 
  798                $curNode=$children->item(
$i);
 
  799                if ($curNode->nodeType == XML_ELEMENT_NODE) {
 
  800                    if ($curNode->localName == 
"preConditionRule" || $curNode->localName == 
"exitConditionRule" || $curNode->localName == 
"postConditionRule") {
 
  802                        $ruleInfo = $curNode->childNodes;
 
  803                        for ($j = 0; $j < $ruleInfo->length; $j++) {
 
  804                            $curRule=$ruleInfo->item($j);
 
  806                            if ($curRule->nodeType == XML_ELEMENT_NODE) {
 
  807                                if ($curRule->localName == 
"ruleConditions") {
 
  809                                } elseif ($curRule->localName == 
"ruleAction") {
 
  810                                    $tempVal=$curRule->getAttribute(
"action");
 
  812                                        $rule->mAction = $tempVal;
 
  817                        if (
$rule->mConditions != 
null && 
$rule->mAction != 
null) {
 
  819                            if ($curNode->localName == 
"preConditionRule") {
 
  822                                $c_rule[
'_SeqRule'] = 
$rule;
 
  823                                array_push($preRules, $c_rule);
 
  825                            if ($curNode->localName == 
"exitConditionRule") {
 
  828                                $c_rule[
'_SeqRule'] = 
$rule;
 
  829                                array_push($exitRules, $c_rule);
 
  831                            if ($curNode->localName == 
"postConditionRule") {
 
  834                                $c_rule[
'_SeqRule'] = 
$rule;
 
  835                                array_push($postRules, $c_rule);
 
  842            if (count($preRules) > 0) {
 
  845                $c_rules[
'_SeqRuleset']=$rules;
 
  846                $ioAct->setPreSeqRules($c_rules);
 
  849            if (count($exitRules) > 0) {
 
  852                $c_rules[
'_SeqRuleset']=$rules;
 
  853                $ioAct->setExitSeqRules($c_rules);
 
  855            if (count($postRules) > 0) {
 
  858                $c_rules[
'_SeqRuleset']=$rules;
 
  859                $ioAct->setPostSeqRules($c_rules);
 
  871            $conditions = array();
 
  872            $tempVal=$iNode->getAttribute(
"conditionCombination");
 
  874                $condSet->mCombination=$tempVal;
 
  878            $condInfo = $iNode->childNodes;
 
  879            for (
$i = 0; 
$i < $condInfo->length; 
$i++) {
 
  880                $curCond=$condInfo->item(
$i);
 
  881                if ($curCond->nodeType == XML_ELEMENT_NODE) {
 
  882                    if ($curCond->localName == 
"ruleCondition") {
 
  886                        $tempVal=$curCond->getAttribute(
"condition");
 
  888                            $cond->mCondition = $tempVal;
 
  892                        $tempVal=preg_replace(
'/(%20)+/', 
' ', trim($curCond->getAttribute(
"referencedObjective")));
 
  894                            $cond->mObjID = $tempVal;
 
  898                        $tempVal=$curCond->getAttribute(
"measureThreshold");
 
  900                            $cond->mThreshold = $tempVal;
 
  904                        $tempVal = $curCond->getAttribute(
"operator");
 
  906                            if ($tempVal == 
'not') {
 
  914                        $c_cond[
'_SeqCondition']=$cond;
 
  915                        array_push($conditions, $c_cond);
 
  920            if (count($conditions)>0) {
 
  921                $condSet->mConditions = $conditions;
 
  923                $condSet->mConditions = 
null;
 
  926            $c_condSet[
'_SeqConditionSet']=$condSet;
 
  936            $children = $iNode->childNodes;
 
  939            for (
$i = 0; 
$i < $children->length; 
$i++) {
 
  940                $curNode=$children->item(
$i);
 
  941                if ($curNode->nodeType == XML_ELEMENT_NODE) {
 
  942                    if ($curNode->localName == 
"auxiliaryResource") {
 
  947                        $tempVal=$curNode->getAttribute(
"purpose");
 
  949                            $res->mType = $tempVal;
 
  952                        $tempVal=preg_replace(
'/(%20)+/', 
' ', trim($curNode->getAttribute(
"auxiliaryResourceID")));
 
  954                            $res->mResourceID = $tempVal;
 
  956                        array_push($auxRes, 
$res);
 
  961            $c_auxRes[
'_ADLAuxiliaryResource']=$auxRes;
 
  962            $ioAct->setAuxResources($c_auxRes);
 
  970            if (strtoupper($string)==
"FALSE") {
 
  984            if ($iNode != 
null && $iElement != 
null) {
 
  985                $children = $iNode->childNodes;
 
  986                for (
$i = 0; 
$i < $children->length; 
$i++) {
 
  987                    $curNode = $children->item(
$i);
 
  988                    if (($curNode->nodeType == XML_ELEMENT_NODE)) {
 
  989                        if ($curNode->localName == $iElement) {
 
  994                if ($curNode != 
null) {
 
  995                    $comp = $curNode->localName;
 
  997                        if ($comp != $iElement) {
 
 1009            if ($curNode != 
null) {
 
 1010                $children = $curNode->childNodes;
 
 1011                if ($children != 
null) {
 
 1012                    for (
$i = 0; 
$i < $children->length; 
$i++) {
 
 1013                        $curNode = $children->item(
$i);
 
 1015                        if (($curNode->nodeType == XML_TEXT_NODE) ||($curNode->nodeType == XML_CDATA_SECTION_NODE)) {
 
 1016                            $value = $value . $curNode->nodeValue;
 
An exception for terminatinating execution or to throw for unit testing.
static getADLSEQObjectives($iNode, $ioAct)
static getObjectiveMaps($iNode)
buildNode($node, $seq, $doc)
static getSequencingRules($iNode, $ioAct)
static getADLSeqMaps($iNode, $curseqobj)
static getAuxResources($iNode, $ioAct)
extractSeqInfo($iNode, $ioAct)
static fillinADLSeqMaps($iNode, $map)
static convert_to_bool($string)
static getObjectives($iNode, $ioAct)
static extractSeqRuleConditions($iNode)
static getRollupRules($iNode, $ioAct)
static lookupElement($iNode, $iElement)
if($source===NULL) $organizations
if(!file_exists("$old.txt")) if( $old===$new) if(file_exists("$new.txt")) $file
foreach($_POST as $key=> $value) $res