Merge pull request #915 from Azaezel/alpha402/sortSorting

correct the moduleDependencySort callback

Engine/source/module/moduleManager.cpp

@@ -74,23 +74,29 @@ S32 QSORT_CALLBACK moduleDefinitionVersionIdSort( const void* a, const void* b )
    return versionId1 > versionId2 ? -1 : versionId1 < versionId2 ? 1 : 0;
 }
 
-S32 QSORT_CALLBACK moduleDependencySort(const void* a, const void* b)
+S32 ModuleManager::moduleDependencySort(ModuleDefinition* const* a, ModuleDefinition* const* b)
 {
-   // Fetch module definitions.
+   // if A depends on B move A down the list
-   ModuleDefinition* pDefinition1 = *(ModuleDefinition * *)a;
+   ModuleDefinition::typeModuleDependencyVector moduleDependencies = (*a)->getDependencies();
-   ModuleDefinition* pDefinition2 = *(ModuleDefinition * *)b;
-
-   // Fetch version Ids.
-   ModuleDefinition::typeModuleDependencyVector moduleDependencies = pDefinition1->getDependencies();
-   bool foundDependant = false;
    for (ModuleDefinition::typeModuleDependencyVector::const_iterator dependencyItr = moduleDependencies.begin(); dependencyItr != moduleDependencies.end(); ++dependencyItr)
    {
-      if (String::compare(dependencyItr->mModuleId, pDefinition2->getModuleId())
+      if ((String::compare(dependencyItr->mModuleId, (*b)->getModuleId()) == 0)
-         && (dependencyItr->mVersionId == pDefinition2->getVersionId()))
+         && (dependencyItr->mVersionId == (*b)->getVersionId()))
-            foundDependant = true;
+         return 1;
    }
 
-   return foundDependant ? 1 : -1;
+   //If B depends on A, move A up the list
+   ModuleDefinition::typeModuleDependencyVector moduleDependencies2 = (*b)->getDependencies();
+   for (ModuleDefinition::typeModuleDependencyVector::const_iterator dependencyItr2 = moduleDependencies2.begin(); dependencyItr2 != moduleDependencies2.end(); ++dependencyItr2)
+   {
+      if ((String::compare(dependencyItr2->mModuleId, (*a)->getModuleId()) == 0)
+         && (dependencyItr2->mVersionId == (*a)->getVersionId()))
+         return -1;
+   }
+   //didn't find any explicit dependencies between the two, so sort by which has more
+   if (moduleDependencies.size() > moduleDependencies2.size()) return 1;
+   if (moduleDependencies.size() < moduleDependencies2.size()) return -1;
+   return 0;
 }
 
 //-----------------------------------------------------------------------------
@@ -1066,39 +1072,49 @@ ModuleDefinition* ModuleManager::findLoadedModule( const char* pModuleId )
 
 //-----------------------------------------------------------------------------
 
-void ModuleManager::findModules( const bool loadedOnly, typeConstModuleDefinitionVector& moduleDefinitions )
+void ModuleManager::findModules(const bool loadedOnly, typeModuleDefinitionVector& moduleDefinitions)
 {
-    // Iterate module Ids.
+   if (loadedOnly)
-    for( typeModuleIdDatabaseHash::iterator moduleIdItr = mModuleIdDatabase.begin(); moduleIdItr != mModuleIdDatabase.end(); ++moduleIdItr )
+   {
-    {
+      for (U32 i = 0; i < mModulesLoaded.size(); i++)
-        // Fetch module definition entry.
+      {
-        ModuleDefinitionEntry* pModuleDefinitionEntry = moduleIdItr->value;
+         moduleDefinitions.push_back(mModulesLoaded[i].mpModuleDefinition);
+      }
+   }
+   else
+   {
+      // Iterate module Ids.
+      for (typeModuleIdDatabaseHash::iterator moduleIdItr = mModuleIdDatabase.begin(); moduleIdItr != mModuleIdDatabase.end(); ++moduleIdItr)
+      {
+         // Fetch module definition entry.
+         ModuleDefinitionEntry* pModuleDefinitionEntry = moduleIdItr->value;
 
-        // Iterate module definitions.
+         // Iterate module definitions.
-        for ( typeModuleDefinitionVector::iterator moduleDefinitionItr = pModuleDefinitionEntry->begin(); moduleDefinitionItr != pModuleDefinitionEntry->end(); ++moduleDefinitionItr )
+         for (typeModuleDefinitionVector::iterator moduleDefinitionItr = pModuleDefinitionEntry->begin(); moduleDefinitionItr != pModuleDefinitionEntry->end(); ++moduleDefinitionItr)
-        {
+         {
             // Fetch module definition.
             ModuleDefinition* pModuleDefinition = *moduleDefinitionItr;
 
             // Are we searching for loaded modules only?
-            if ( loadedOnly )
+            if (loadedOnly)
             {
-                // Yes, so skip if the module is not loaded.
+               // Yes, so skip if the module is not loaded.
-                if ( pModuleDefinition->getLoadCount() == 0 )
+               if (pModuleDefinition->getLoadCount() == 0)
-                    continue;
+                  continue;
 
-                // Use module definition.
+               // Use module definition.
-                moduleDefinitions.push_back( pModuleDefinition );
+               moduleDefinitions.push_back(pModuleDefinition);
 
-                // Finish iterating module definitions as only a single module in this entry can be loaded concurrently.
+               // Finish iterating module definitions as only a single module in this entry can be loaded concurrently.
-                break;
+               break;
             }
 
             // use module definition.
-            moduleDefinitions.push_back( pModuleDefinition );
+            moduleDefinitions.push_back(pModuleDefinition);
-        }
+         }
-    }
+      }
-    dQsort(moduleDefinitions.address(), moduleDefinitions.size(), sizeof(ModuleDefinition*), moduleDependencySort);
+      moduleDefinitions.sort(&moduleDependencySort);
+   }
 }
 
 //-----------------------------------------------------------------------------
@@ -1571,7 +1587,7 @@ bool ModuleManager::synchronizeDependencies( ModuleDefinition* pRootModuleDefini
     }
 
     // Find any target modules left, These are orphaned modules not depended upon by any other module.
-    typeConstModuleDefinitionVector orphanedTargetModules;
+    typeModuleDefinitionVector orphanedTargetModules;
     targetModuleManager.findModules( false, orphanedTargetModules );
 
     // Iterate module definitions.
@@ -1619,7 +1635,7 @@ bool ModuleManager::canMergeModules( const char* pMergeSourcePath )
     mergeModuleManager.scanModules( pMergeSourcePath );
 
     // Find all the merge modules.
-    typeConstModuleDefinitionVector mergeModules;
+    typeModuleDefinitionVector mergeModules;
     mergeModuleManager.findModules( false, mergeModules );
 
     // Iterate found merge module definitions.
@@ -1708,7 +1724,7 @@ bool ModuleManager::mergeModules( const char* pMergeTargetPath, const bool remov
     sourceModuleManager.scanModules( mergeSourcePath );
 
     // Find all the source modules.
-    typeConstModuleDefinitionVector sourceModules;
+    typeModuleDefinitionVector sourceModules;
     sourceModuleManager.findModules( false, sourceModules );
 
     // Iterate found merge module definitions.

Engine/source/module/moduleManager.h

@@ -61,7 +61,8 @@ public:
     /// Module definitions.
     typedef Vector<ModuleDefinition*> typeModuleDefinitionVector;
     typedef Vector<const ModuleDefinition*> typeConstModuleDefinitionVector;
-
+protected:
+    static S32 moduleDependencySort(ModuleDefinition* const* a, ModuleDefinition* const* b);
 private:
     /// Database locking.
     struct LockDatabase
@@ -175,7 +176,7 @@ public:
     ModuleDefinition* findModule( const char* pModuleId, const U32 versionId );
     ModuleDefinition* findModuleByFilePath(StringTableEntry filePath);
     ModuleDefinition* findLoadedModule( const char* pModuleId );
-    void findModules( const bool loadedOnly, typeConstModuleDefinitionVector& moduleDefinitions );
+    void findModules( const bool loadedOnly, typeModuleDefinitionVector& moduleDefinitions );
     void findModuleTypes( const char* pModuleType, const bool loadedOnly, typeConstModuleDefinitionVector& moduleDefinitions );
 
     /// Module synchronization.

Engine/source/module/moduleManager_ScriptBinding.h

@@ -151,13 +151,13 @@ DefineEngineMethod(ModuleManager, findModuleByFilePath, String, (const char* fil
 
 //-----------------------------------------------------------------------------
 
-DefineEngineMethod(ModuleManager, findModules, String, (bool loadedOnly), (false),
+DefineEngineMethod(ModuleManager, findModules, String, (bool loadedOnly), (true),
    "Find all the modules registered with the specified loaded state.\n"
    "@param loadedOnly Whether to return only modules that are loaded or not.\n"
    "@return A list of space - separated module definition object Ids.\n")
 {
     // Find module type definitions.
-    Vector<const ModuleDefinition*> moduleDefinitions;
+    Vector<ModuleDefinition*> moduleDefinitions;
 
     // Find modules.
     object->findModules( loadedOnly, moduleDefinitions );

Templates/BaseGame/game/core/utility/scripts/module.tscript

@@ -1,3 +1,4 @@
+$reportModuleOrder = false;
 $traceModuleCalls=false;
 $reportModuleFileConflicts=true;
 if (!isObject(ExecFilesList))
@@ -9,11 +10,12 @@ function callOnModules(%functionName, %moduleGroup, %var0, %var1, %var2, %var3,
    %execArray = new ArrayObject("callOn" @ %functionName @ "_" @ %moduleGroup);
    ExecFilesList.push_back(%execArray);
    //Get our modules so we can exec any specific client-side loading/handling
-   %modulesList = ModuleDatabase.findModules(false);
+   %modulesList = ModuleDatabase.findModules();
+   %modlist = "modlist:";
    for(%i=0; %i < getWordCount(%modulesList); %i++)
    {
       %module = getWord(%modulesList, %i);
-      
+      %modlist = %modlist SPC %module.ModuleId;
       if(%moduleGroup !$= "")
       {
          if(%module.group !$= %moduleGroup)
@@ -23,6 +25,8 @@ function callOnModules(%functionName, %moduleGroup, %var0, %var1, %var2, %var3,
       if(isObject(%module.scopeSet) && %module.scopeSet.isMethod(%functionName))
         %module.scopeSet.call(%functionName, %var0, %var1, %var2, %var3, %var4, %var5, %var6);
    }
+   if ($reportModuleOrder)
+      warn(%modlist);
    
    %execFilecount = %execArray.count();