wow/dependencyloader: DependencyLoader/Tree.lua comparison

comparison DependencyLoader/Tree.lua @ 10:e0a4a8b5b389

lots more modifications...

author	mckenziemc
date	Sun, 05 Dec 2010 03:10:07 -0800
parents	5362e308c3eb
children	b230b94d4487

comparison

equal deleted inserted replaced

-:5362e308c3eb
+:e0a4a8b5b389
 local addonName, addonTable = ...
---	TODO: prevent infinite loops in the recursive functions
+--	FIXME: prevent infinite loops in the recursive functions
 local Tree, tree = addonTable:NewClass("Tree")
 Tree.trees = {}
 --	internal
 --	Creates a new tree object
 --	@param	root	Name, index, or Addon object of the root addon.
 function Tree:New(root)
 	return bitfield
 end
---	Checks if the tree rooted at the specified addon can be force-loaded.
+---	Checks if this tree can be force-loaded.
---	@param	root	The name or index of the root addon.
+--	Does not check user settings nor if force-loading is actually available.
-function core:CanForceLoadTree(root)
+--	@return	canForceLoad	True if this tree can be force loaded, false otherwise
-	--	TODO: if some addons have already loaded, we have to check
+function tree:CanForceLoad()
-	--	forceafter for those and forcebefore for the others
+	if self.root:IsLoaded() then
-	return false
+		return true
+	end
+	if not self.root:CanForceLoad() then
+		return false
+	end
+	--	now check dependencies recursively
+	local dependencies = {self.root:GetDependencies()}
+	for i, depName in pairs(dependencies) do
+		local depTree = Tree:Get(depName)
+		if not depTree:CanForceLoad() then
+			return false
+		end
+	end
+	return
 end
 --	NOTE: any tree that can be loaded on demand is also eligible for force-loading
---	Checks if the tree rooted at the specified addon can be loaded on demand.
+--	Checks if the tree can be loaded on demand.
---	@param	root	The name or index of the root addon.
+function tree:CanLoD()
-function core:CanLoDTree(root)
-	local bitfield = self:GetLoadBitfield()
-	root = self:GetAddon(root)
-	assert(root)
 	--	since this will be used recursively, return true if
 	--	this is already loaded.
-	if root:IsLoaded() then
+	if self.root:IsLoaded() then
 		return true
 	end
 	--	true if all dependencies are loaded or LoD
-	if not root:CanLoD() then
+	if not self.root:CanLoD() then
 		return false
 	end
 	--	now check dependencies recursively
 	local dependencies = {root:GetDependencies()}
 	for i, depName in pairs(dependencies) do
-		local dep = self:GetAddon(depName)
+		local depTree = Tree:Get(depName)
-		if not dep then
+		if not depTree:CanLoD() then
-			return false		--	missing
+			return false
-		end
-		if not dep:IsLoaded() then
-			if not self:CanLoDTree(depName) then
-				return false
-			end
 		end
 	end
 	return true
 end
 --	Checks if the tree rooted at the specified addon
 --	can be loaded if all dependencies are enabled
 --	the UI is reloaded.
 --	Basically makes sure all dependencies are installed.
-function core:CanReloadTree(root)
+function tree:CanLoad()
-	--	convert root to an Addon object
+	if self.root:IsLoaded() then
-	root = self:GetAddon(root)
-	assert(root)
-	if root:IsLoaded() then
 		return true
 		--	FIXME: 	deps may have been disabled
 	end
 	--	TODO: make sure the root isn't incompatible
 	--	now check dependencies recursively
 	--	FIXME: prevent infinite recursion
-	local dependencies = {root:GetDependencies()}
+	local dependencies = {self.root:GetDependencies()}
 	for i, depName in pairs(dependencies) do
-		local dep = self:GetAddon(depName)
+		local depTree = Tree:Get(depName)
-		if dep == nil then
+		if not depTree:CanLoad() then
 			return false		--	missing dependency
 		end
 		--	TODO: make sure it's compatible
 	end
 	return true
 end
+--[[
 --	Loads the tree rooted at the specified addon.
 --	FIXME: load the root too or not?
 --	Supports both LoD addons and those that require force-loading.
-function core:LoadTree(addon)
+function tree:Load(addon)
 	--	don't check if the tree can actually be loaded.
 	--	external code should do that itself to check if it
 	--	should even call this at all.
 	if self:ForceLoadAvailable() then
 		self:ForceLoadTree(addon)
 	else
 		self:LoadLoDTree(addon)
 	end
 end
+]]
 --	load the root too, since it may actually be a leaf
-function core:ForceLoadTree(root)
+function tree:ForceLoad()
-	root = self:GetAddon(root)
-	assert(root)
 	--	load dependencies
-	local dependencies = {root:GetDependencies(addon)}
+	local dependencies = {self.root:GetDependencies()}
 	for i, depName in pairs(dependencies) do
-		self:ForceLoadTree(depName)
+		local depTree = Tree:Get(depName)
+		depTree:ForceLoad()
 	end
 	--	load embeds, if they are available separately
-	local embeds = {root:GetEmbeds(addon)}
+	local embeds = {self.root:GetEmbeds()}
 	for i, embedName in pairs(embeds) do
-		if Addon:Exists(embedName) then
+		local embedTree = Tree:Get(embedName)
-			self:ForceLoadTree(embedName)
+		embedTree:ForceLoad()
-		end
 	end
 	root:ForceLoad()
 end
+--[[	don't think i need this
 function core:LoadLoDTree(root)
 	root = self:GetAddon(root)
 	assert(root)
 	--	load dependencies
 		end
 	end
 	root:LoD()
 end
+]]
 --	I think the problem this solves is a major issue with
 --	migrating to separate libs. think about it more and document
 --	here and in project description
-function core:PrepareLoDTree(root)
+function tree:PrepareForLoD()
-	root = self:GetAddon(root)
-	assert(root)
 	--	assume root is LoD
 	--	check dependencies
 	local dependencies = {root:GetDependencies(addon)}
 	for i, depName in pairs(dependencies) do
-		local dep = self:GetAddon(depName)
+		local depTree = Tree:Get(depName)
+		depTree:PrepareForLoD()
-		--	assume external code made sure it exists
+		--[[
 		if dep:CanLoD() then
 			--	don't load it now but make sure its dependencies are prepared
 			self:PrepareLoDTree(depName)
 		else
 			--	FIXME: if it's already loaded
 			--	force-load it now so we can load the parent on demand
 			self:ForceLoadTree(depName)
 		end
+		]]
 	end
 	--	prepare embeds, if they are available separately
 	local embeds = {root:GetEmbeds(addon)}	--	FIXME: addon?
 	for i, embedName in pairs(embeds) do
-		local embed = self:GetAddon(embedName)
+		local embedTree = Tree:Get(embedName)
+		embedTree:PrepareForLoD()
+		--[[
 		if embed then
 			if embed:CanLoD() then
 				--	don't load it now but make sure its dependencies are prepared
 				self:PrepareLoDTree(embedName)
 			else
 				--	FIXME: if it's already loaded
 				--	force-load it now so we can load the parent on demand
 				self:ForceLoadTree(depName)
 			end
 		end
-	end
+		]]
-end
+	end
+end
-function Core:PrepareReloadTree(addon)
-	root = self:GetAddon(root)
+function tree:PrepareForReload()
-	assert(root)
+	self.root:Enable()
-	root:Enable()
 	--	check dependencies
-	local dependencies = {root:GetDependencies()}
+	local dependencies = {self.root:GetDependencies()}
 	for i, depName in pairs(dependencies) do
-		self:PrepareReloadTree(depName)
+		Tree:Get(depName):PrepareForReload()
 	end
 	--	prepare embeds, if they are available separately
-	local embeds = {root:GetEmbeds(addon)}
+	local embeds = {self.root:GetEmbeds(addon)}
 	for i, embedName in pairs(embeds) do
-		local embed = self:GetAddon(embedName)
+		Tree:Get(embedName):PrepareForReload()
+	end
-		if embed then
+end
-			self:PrepareReloadTree(embedName)
-		end
-	end
-end
-function Core:ForceLoadAvailable()
-	return true
-	--	FIXME: use field and a frame registered for PLAYER_LOGIN
-end

Mercurial > wow > dependencyloader

comparison DependencyLoader/Tree.lua @ 10:e0a4a8b5b389