---------------------------------------------------------------------------------------------
aswil.technologies.getPrerequisites(technology_name)

Return the prerequisites table of the technology with the name given in the argument,
if the technology doesn't exist, return an empty table
---------------------------------------------------------------------------------------------
---------------------------------------------------------------------------------------------
aswil.technologies.hasPrerequisite(technology_name, prerequisite_name)

Return if a technology have a given prerequisite, true if hava it, false otherwise
---------------------------------------------------------------------------------------------
---------------------------------------------------------------------------------------------
aswil.technologies.getEffects(technology_name)

Return the effects table of the technology with the name given in the argument,
if the technology doesn't exist, return an empty table
---------------------------------------------------------------------------------------------
---------------------------------------------------------------------------------------------
aswil.technologies.getTechnologyThatUnlockRecipe(recipe_name)

Return the name of technology that unlock the recipe with the name given in the argument,
if the technology doesn't exist, return an empty table
---------------------------------------------------------------------------------------------

---------------------------------------------------------------------------------------------
aswil.technologies.getResearchUnitIngredients(technology_name)

Return the research unit ingredients table of the technology with the name given in the argument,
if the technology doesn't exist, return an empty table
---------------------------------------------------------------------------------------------
---------------------------------------------------------------------------------------------
aswil.technologies.getResearchUnitCount(technology_name)

Return the research unit ingredients table of the technology with the name given in the argument,
if the technology doesn't exist, return 1 bt default
---------------------------------------------------------------------------------------------

---------------------------------------------------------------------------------------------
aswil.technologies.exist(technology_name)

Is a wrapper function of aswil.technologies.exist(technology_name), return a boolean instead,
if the technology isn't empty return true, false otherwise

---------------------------------------------------------------------------------------------
---------------------------------------------------------------------------------------------
aswil.technologies.getTechnologyFromName(technology_name)

Return the technology (the whole table) called with the name given in the argument, 
if the technology doesn't exist, return nil

---------------------------------------------------------------------------------------------

---------------------------------------------------------------------------------------------
aswil.technologies.removePrerequisite(technology_name, prerequisite_name_to_remove)

Remove the prerequisite given in the arguments from the technology with that name if in the 
prerequisite is present in technology prerequisites, and if technology exist.
Return true (boolean) if prerequisite_name_to_remove has been removed, false otherwise.
---------------------------------------------------------------------------------------------
---------------------------------------------------------------------------------------------
aswil.technologies.removePrerequisites(technology_name, prerequisite_names_to_remove)

For each string in prerequisite_names_to_remove (that must be a table)
Remove the prerequisite given in the arguments from the technology with that name if in the 
prerequisite is present in technology prerequisites, and if technology exist.
Return true (boolean) if prerequisite_name_to_remove has been removed, false otherwise.
---------------------------------------------------------------------------------------------
---------------------------------------------------------------------------------------------
aswil.technologies.addPrerequisite(technology_name, prerequisite_name, check_circular_dependency)

Add the prerequisite given in the arguments to the technology
with that name if technology exist.
Return true (boolean) if prerequisite_name has been added, false otherwise.

check_circular_dependency is an optional attribute, if given will check if the
added prerequisite create a circular dependency, in that case will be not added
---------------------------------------------------------------------------------------------
---------------------------------------------------------------------------------------------
aswil.technologies.addPrerequisites(technology_name, prerequisite_names, check_circular_dependency)

For each string in prerequisite_names (that must be a table)
Add the prerequisite given in the arguments to the technology
with that name if technology exist.
Return true (boolean) if prerequisite_name has been added, false otherwise.

check_circular_dependency is an optional attribute, if given will check if the
added prerequisite create a circular dependency, in that case will be not added
---------------------------------------------------------------------------------------------
---------------------------------------------------------------------------------------------
aswil.technologies.convertPrerequisite(technology_name, old_prerequisite_name, new_prerequisite_name)

Convert one prerequisite to another technology, only if technology_name refer an existing 
technology and if the old prerequisite is required from that technology
---------------------------------------------------------------------------------------------
---------------------------------------------------------------------------------------------
aswil.technologies.convertPrerequisiteFromAllTechnologies(old_prerequisite_name, new_prerequisite_name)

Call convertPrerequisite(technology_name, old_prerequisite_name, new_prerequisite_name) 
on all loaded technologies and return te count of conversion
---------------------------------------------------------------------------------------------

---------------------------------------------------------------------------------------------
aswil.technologies.removeEffect(technology_name, to_remove_effect)

Remove the effect given in the arguments from the technology with that name if in the 
effect is present in technology effects, and if technology exist.
Return true (boolean) if to_remove_effect has been removed, false otherwise.

Will return the result of the operation (boolean)
---------------------------------------------------------------------------------------------
---------------------------------------------------------------------------------------------
aswil.technologies.removeEffects(technology_name, to_remove_effects)

For each effect entry in to_remove_effects (that must be a table of effects)
Remove the effect given in the arguments from the technology with that name if in the 
effect is present in technology effects, and if technology exist.
Return true (boolean) if to_remove_effect has been removed, false otherwise.

Will return the result of the operation (boolean)
---------------------------------------------------------------------------------------------
---------------------------------------------------------------------------------------------
aswil.technologies.removeEffectFromAllTechnologies(to_remove_effect)

Remove from all technologies the unlocking of the given effect

Will return the result of the operation (counter -> integer)
---------------------------------------------------------------------------------------------
---------------------------------------------------------------------------------------------
aswil.technologies.removeAllEffectType(technology_name, to_remove_effect_type)

Will remove from indicated technology all effect that is of the type indicated

Will return the result of the operation (boolean)
---------------------------------------------------------------------------------------------
---------------------------------------------------------------------------------------------
aswil.technologies.addEffect(technology_name, new_effect)

Add the effect given in the arguments to the technology
with that name if technology exist. The effect also not added if is malformed or the
modifier isn't unknow (see the factorio mod documentation for the modifiers list)
Return true (boolean) if new_effect has been added, false otherwise.

Will return the result of the operation (boolean)
---------------------------------------------------------------------------------------------
---------------------------------------------------------------------------------------------
aswil.technologies.addEffects(technology_name, new_effects)

For each effect entry in new_effects (that must be a table of effects)
Add the effect given in the arguments to the technology
with that name if technology exist. The effect also not added if is malformed or the
modifier isn't unknow (see the factorio mod documentation for the modifiers list)
Return true (boolean) if new_effect has been added, false otherwise.

Will return the result of the operation (boolean)
---------------------------------------------------------------------------------------------
---------------------------------------------------------------------------------------------
aswil.technologies.removeUnlockRecipe(technology_name, recipe_name)

Remove from the technology the unlock effect of that recipe, if the technology exist,
and if the technology unlock that recipe

Will return the result of the operation (boolean)
---------------------------------------------------------------------------------------------
---------------------------------------------------------------------------------------------
aswil.technologies.removeUnlockRecipes(technology_name, recipe_names)

For each recipe in the list(table) in recipe_names
Remove from the technology the unlock effect of that recipe, if the technology exist,
and if the technology unlock that recipe

Will return the result of the operation (boolean)
---------------------------------------------------------------------------------------------
---------------------------------------------------------------------------------------------
aswil.technologies.addUnlockRecipe(technology_name, recipe_name)

If the technology exist, and the recipe exist will add to that technology the effect of
unlock that recipe

Will return the result of the operation (boolean)
---------------------------------------------------------------------------------------------
---------------------------------------------------------------------------------------------
aswil.technologies.addUnlockRecipes(technology_name, recipe_names)

For each recipe in the list(table) in recipe_names
If the technology exist, and the recipe exist will add to that technology the effect of
unlock that recipe

Will return the result of the operation (boolean)
---------------------------------------------------------------------------------------------
---------------------------------------------------------------------------------------------
aswil.technologies.removeUnlockRecipeFromAllTechnologies(recipe_name)

Remove from all technologies the unlocking of the given recipe

Will return the result of the operation (counter -> integer)
---------------------------------------------------------------------------------------------

---------------------------------------------------------------------------------------------
aswil.technologies.removeResearchUnitIngredient(technology_name, science_pack_name)	

Remove the science pack given in the arguments from the technology with that name if in the 
science pack is present in technology research unit ingredients, and if technology exist.
Also, will remove that science pack from the prerequisites of technology
Return true (boolean) if the science pack has been removed, false otherwise.
---------------------------------------------------------------------------------------------
---------------------------------------------------------------------------------------------
aswil.technologies.addResearchUnitIngredient(technology_name, science_pack_name, count)

Add the effect science pack in the arguments to the technology
with that name if technology exist. The science pack will be added
in the research unit ingredients with that count if isn't already present, if is present
that count will be sum to the old count. Also, the science pack will be added
in the prerequisite if exist a technology for that science pack.
Return true (boolean) if the science pack has been added, false otherwise.
---------------------------------------------------------------------------------------------

---------------------------------------------------------------------------------------------
aswil.technologies.setResearchUnitCount(technology_name, count)

Set a new number for the research unit count for a technology by name,
if the technology exist.
---------------------------------------------------------------------------------------------

---------------------------------------------------------------------------------------------
isaCircularDependency(tech, to_add_prerequisite, already_checked)

If a technology has one or more prerequistes
for each prerequisites check if that technology will create a circual dependency if require "tech"
and do recusively this check for his prerequistes, until reach technologies that haven't prerequisites

already_checked attribute must be nil or not given, if is initalited and given,
must be a table that have one boolean value for each technology with true on technologies
when skip the checking
---------------------------------------------------------------------------------------------
---------------------------------------------------------------------------------------------
aswil.technologies.addSciencePackCollection(science_pack_collection_name, science_pack_collection)

Given a table that rappresent a collection of new science packs 
belonging one mod, will add it to this library for be computed in future.
@ science_pack_collection_name, the name of the collection
@ science_pack_collection, the table that contains all science pack names
---------------------------------------------------------------------------------------------
---------------------------------------------------------------------------------------------
aswil.technologies.sanitizeUnitsOfAllTechnologiesInPacks(science_pack_collection_name, with_vanilla)

Given a string which represents a name of a collection of science packs of one mod,
previously added by the method addSciencePack(science_pack)
will looking for technologies that have science pack from this collection and another mixed,
and will remove from them all science pack that isn't in.
If other technologies have; other science packs, mixed science packs collection not related with
the one in function argument, that technologies will be leave untouched.
@ science_pack_name, a table of strings
@ if given science_pack is compatible with vanilla science_pack
---------------------------------------------------------------------------------------------

---------------------------------------------------------------------------------------------
aswil.recipes.findNotUnlockableTechnologies()

Return a table with the name of the technologies
that is unreachable or unlockable in the game.
---------------------------------------------------------------------------------------------

---------------------------------------------------------------------------------------------
aswil.technologies.enable(technology_name)

Enable the technology.
---------------------------------------------------------------------------------------------
---------------------------------------------------------------------------------------------
aswil.technologies.disable(technology_name, remove_prerequisites)

Disable the technology.

If remove_prerequisites is setted to true(boolean), will also remove all prerequisites
from this technology and this technology in prerequisites of other technologies
---------------------------------------------------------------------------------------------
