static void generateDimensionSetRules_Job(Args _args)
{
    #define.DimSetId('Dept-cc')
    #define.DimSetCollectionId('AccColl')
    #define.AccNum(1)
    #define.Dept(2)
    #define.CC(3)
    #define.HierarchyId('H')

    container                   inputData;
    int                         conLength;
    int                         idx;
    container                   accData;
    Set                         ccSet;
    Map                         dimHierMap;
    SysDim                      deptNum;
    SysDim                      ccNum;
    container                   simulationResult;
    DimensionsAccountCriteria   aCriteria;
    DimensionCriteria           dCriteria;
    LedgerRowDefLine            ledgerRowDefLine;
    MapEnumerator               mapEnumerator;
    MapEnumerator               dimHierMapEnumerator;
    SetEnumerator               setEnumerator;
    LineNum                     lineNum;
    RefRecId                    parentRecId;
    DimensionSetCombination     dimensionSetCombination;
    LedgerRowDef                ledgerRowDef;
    DimensionSetRuleCollection  dimensionSetRuleCollection;
    DimensionSetRuleTable       dimensionSetRuleTable;
    Map                         accMap;
    LedgerAccount               accountNumber;
    Map                         packedDimHier2HierarchyIdMap;
    int                         hierarchyNumber;
    DimensionSetHierarchyId     hierarchyId;
    Map                         accountNum2HierarchyIdMap;
    container                   packedMap;
    ;

    inputData += [['10510', '49', '0']];
    inputData += [['10511', '49', '3']];
    inputData += [['10600', '49', '0']];
    inputData += [['10600', '49', '6']];
    inputData += [['10600', '50', '0']];
    inputData += [['10651', '49', '0']];
    inputData += [['10651', '50', '0']];
    inputData += [['10800', '49', '0']];
    inputData += [['10811', '49', '0']];
    inputData += [['10900', '49', '0']];

    // Transform the input data to a Map object (begin) -->
    accMap = new Map(Types::String, Types::Class);

    conLength = conLen(inputData);
    for (idx = 1; idx <= conLength; idx++)
    {
        accData = conPeek(inputData, idx);
        accountNumber = conPeek(accData, #AccNum);
        if (!accMap.exists(accountNumber))
        {
            accMap.insert(accountNumber, new Map(Types::String, Types::Class));
        }

        dimHierMap = accMap.lookup(accountNumber);
        deptNum = conPeek(accData, #Dept);
        if (!dimHierMap.exists(deptNum))
        {
            dimHierMap.insert(deptNum, new Set(Types::String));
        }

        ccSet = dimHierMap.lookup(deptNum);
        ccSet.add(conPeek(accData, #CC));
    }

    /*
    accMap object contents:

    ["10510"-> Map: ["49"-> Set: {"0"}],
     "10511"-> Map: ["49"-> Set: {"3"}],
     "10600"-> Map: ["49"-> Set: {"0", "6"}, "50"-> Set: {"0"}],
     "10651"-> Map: ["49"-> Set: {"0"}, "50"-> Set: {"0"}],
     "10800"-> Map: ["49"-> Set: {"0"}],
     "10811"-> Map: ["49"-> Set: {"0"}],
     "10900"-> Map: ["49"-> Set: {"0"}]]
    */
    // <-- Transform the input data to a Map object (end)

    // Generate a list of hierarchies (begin) -->
    packedDimHier2HierarchyIdMap = new Map(Types::Container, Types::String);
    accountNum2HierarchyIdMap = new Map(Types::String, Types::String);
    hierarchyNumber = 1;

    mapEnumerator = accMap.getEnumerator();
    while (mapEnumerator.moveNext())
    {
        accountNumber = mapEnumerator.currentKey();
        dimHierMap = mapEnumerator.currentValue();
        packedMap = dimHierMap.pack();

        if (packedDimHier2HierarchyIdMap.exists(packedMap))
        {
            hierarchyId = packedDimHier2HierarchyIdMap.lookup(packedMap);
        }
        else
        {
            hierarchyId = #HierarchyId + int2str(hierarchyNumber);
            hierarchyNumber++;
            packedDimHier2HierarchyIdMap.insert(packedMap, hierarchyId);
        }

        accountNum2HierarchyIdMap.insert(accountNumber, hierarchyId);
    }

    /*
    This is what packedDimHier2HierarchyIdMap map looks like

    [Packed Map: ["49"-> Set: {"0"}]                            -> "H1",
     Packed Map: ["49"-> Set: {"3"}]                            -> "H2",
     Packed Map: ["49"-> Set: {"0", "6"}, "50"-> Set: {"0"}]    -> "H3",
     Packed Map: ["49"-> Set: {"0"}, "50"-> Set: {"0"}]         -> "H4"]

    and this is the contents of accountNum2HierarchyIdMap map:

    ["10510"->"H1",
     "10511"->"H2",
     "10600"->"H3",
     "10651"->"H4",
     "10800"->"H1",
     "10811"->"H1",
     "10900"->"H1"]

     As four of the accounts have the same validation rules, they will be assigned the same hierarchy "H1" in their dimension set rules.
    */
    // <-- Generate a list of hierarchies (end)

    ttsbegin;

    // Generate hierarchies (begin) -->

    delete_from ledgerRowDef
        where ledgerRowDef.MainFocus == #DimSetId
           && ledgerRowDef.Hierarchy == NoYes::Yes;

    mapEnumerator = packedDimHier2HierarchyIdMap.getEnumerator();
    while (mapEnumerator.moveNext())
    {
        packedMap = mapEnumerator.currentKey();
        dimHierMap = Map::create(packedMap);

        hierarchyId = mapEnumerator.currentValue();

        ledgerRowDef.clear();
        ledgerRowDef.initValue();
        ledgerRowDef.RowDefinition = hierarchyId;
        ledgerRowDef.Name = hierarchyId;
        ledgerRowDef.MainFocus = #DimSetId;
        ledgerRowDef.Hierarchy = NoYes::Yes;
        ledgerRowDef.insert();

        delete_from ledgerRowDefLine
            where ledgerRowDefLine.RowDefinition == hierarchyId;

        lineNum = 0;

        dimHierMapEnumerator = dimHierMap.getEnumerator();

        // Generate hierarchy lines (begin) -->
        while (dimHierMapEnumerator.moveNext())
        {
            deptNum = dimHierMapEnumerator.currentKey();

            lineNum++;

            ledgerRowDefLine.clear();
            ledgerRowDefLine.initValue();
            ledgerRowDefLine.RowDefinition = hierarchyId;
            ledgerRowDefLine.Name = deptNum;
            ledgerRowDefLine.Txt = '';
            ledgerRowDefLine.initFromDimensions(Dimensions::find(SysDimension::Department, deptNum));
            ledgerRowDefLine.LineNum = lineNum;
            ledgerRowDefLine.DimensionCriteria[Dimensions::code2ArrayIdx(SysDimension::Department)] = deptNum;
            ledgerRowDefLine.Priority = 1;
            ledgerRowDefLine.insert();

            parentRecId = ledgerRowDefLine.RecId;

            ccSet = dimHierMapEnumerator.currentValue();

            setEnumerator = ccSet.getEnumerator();
            while (setEnumerator.moveNext())
            {
                ccNum = setEnumerator.current();

                lineNum++;

                ledgerRowDefLine.clear();
                ledgerRowDefLine.initValue();
                ledgerRowDefLine.RowDefinition = hierarchyId;
                ledgerRowDefLine.Name = ccNum;
                ledgerRowDefLine.Txt = '';
                ledgerRowDefLine.initFromDimensions(Dimensions::find(SysDimension::Center, ccNum));
                ledgerRowDefLine.LineNum = lineNum;
                ledgerRowDefLine.DimensionCriteria[Dimensions::code2ArrayIdx(SysDimension::Center)] = ccNum;
                ledgerRowDefLine.ParentRecId = parentRecId;
                ledgerRowDefLine.Priority = 2;
                ledgerRowDefLine.insert();
            }
        }
        // <-- Generate hierarchy lines (end)

        // Generate dimension combinations (begin) -->
        delete_from dimensionSetCombination
            where dimensionSetCombination.SetId == #DimSetId
               && dimensionSetCombination.HierarchyId == hierarchyId;

        simulationResult = LedgerRowDef::constructMainLinesListRowDef(hierarchyId, aCriteria /*empty*/, dCriteria /*empty*/);
        LedgerRowDefDesignerCtrl::updateDimensionSetCombinationsDB(hierarchyId,
                                                                   simulationResult);

        ledgerRowDef = LedgerRowDef::find(hierarchyId, true);
        ledgerRowDef.Approved = NoYes::Yes;
        ledgerRowDef.update();
        // <-- Generate dimension combinations (end)
    }

    // <-- Generate hierarchies (end)

    // Generate dimension set rules (begin) -->
    
    // Generate a dimension set rule collection:
    delete_from dimensionSetRuleCollection
        where dimensionSetRuleCollection.SetId == #DimSetId
           && dimensionSetRuleCollection.CollectionId == #DimSetCollectionId;

    dimensionSetRuleCollection.clear();
    dimensionSetRuleCollection.SetId = #DimSetId;
    dimensionSetRuleCollection.CollectionId = #DimSetCollectionId;
    dimensionSetRuleCollection.insert();

    // Generate detailed dimension set rules:
    delete_from dimensionSetRuleTable
        where dimensionSetRuleTable.SetId == #DimSetId
           && dimensionSetRuleTable.CollectionId == #DimSetCollectionId;

    mapEnumerator = accountNum2HierarchyIdMap.getEnumerator();
    while (mapEnumerator.moveNext())
    {
        dimensionSetRuleTable.clear();
        dimensionSetRuleTable.SetId = #DimSetId;
        dimensionSetRuleTable.CollectionId = #DimSetCollectionId;
        dimensionSetRuleTable.HierarchyId = mapEnumerator.currentValue();
        dimensionSetRuleTable.RuleObjectType = DimensionSetRuleObjectType::LedgerAccount;
        dimensionSetRuleTable.RefLedgerAccount = mapEnumerator.currentKey();
        dimensionSetRuleTable.insert();
    }
    // <-- Generate dimension set rules (end)

    ttscommit;
}