redef fun collect(mmodules) do
		for mmodule in mmodules do
			values[mmodule] = mmodule.in_importation.greaters.length - 1
		end
	end

	redef fun collect(mmodules) do
		for mmodule in mmodules do
			values[mmodule] = mmodule.in_importation.direct_greaters.length
		end
	end

	redef fun collect(mmodules) do
		for mmodule in mmodules do
			values[mmodule] = mmodule.in_importation.direct_smallers.length
		end
	end

	redef fun collect(mmodules) do
		for mmodule in mmodules do
			values[mmodule] = mmodule.in_importation.smallers.length - 1
		end
	end

	redef fun collect(mmodules) do
		for mmodule in mmodules do
			values[mmodule] = mmodule.in_importation.depth
		end
	end

	redef fun collect(mmodules) do
		for mmodule in mmodules do
			values[mmodule] = 0
			for a in mmodule.collect_ancestors(mainmodule, filter) do
				values[mmodule] += a.intro_mclasses.length
			end
		end
	end

	redef fun collect(mmodules) do
		for mmodule in mmodules do
			values[mmodule] = mmodule.intro_mclasses.length
		end
	end

	redef fun collect(mmodules) do
		for mmodule in mmodules do
			var value = 0
			for mclassdef in mmodule.mclassdefs do
				if not mclassdef.is_intro then value += 1
			end
			values[mmodule] = value
		end
	end

	redef fun collect(mmodules) do
		for mmodule in mmodules do
			var value = 0
			for mclassdef in mmodule.mclassdefs do
				if mclassdef.mclass.kind == concrete_kind then value += 1
			end
			values[mmodule] = value
		end
	end

	redef fun collect(mmodules) do
		for mmodule in mmodules do
			var value = 0
			for mclassdef in mmodule.mclassdefs do
				if mclassdef.mclass.kind == abstract_kind then value += 1
			end
			values[mmodule] = value
		end
	end

	redef fun collect(mmodules) do
		for mmodule in mmodules do
			var value = 0
			for mclassdef in mmodule.mclassdefs do
				if mclassdef.mclass.kind == interface_kind then value += 1
			end
			values[mmodule] = value
		end
	end

	redef fun collect(mmodules) do
		for mmodule in mmodules do
			var value = 0
			for mclassdef in mmodule.mclassdefs do
				if mclassdef.mclass.kind == enum_kind then value += 1
			end
			values[mmodule] = value
		end
	end

	redef fun collect(mclasses) do
		for mclass in mclasses do
			values[mclass] = mclass.in_hierarchy(mainmodule).greaters.length - 1
		end
	end

	redef fun collect(mclasses) do
		for mclass in mclasses do
			values[mclass] = mclass.in_hierarchy(mainmodule).direct_greaters.length
		end
	end

	redef fun collect(mclasses) do
		for mclass in mclasses do
			values[mclass] = mclass.in_hierarchy(mainmodule).direct_smallers.length
		end
	end

	redef fun collect(mclasses) do
		for mclass in mclasses do
			values[mclass] = mclass.in_hierarchy(mainmodule).smallers.length - 1
		end
	end

	redef fun collect(mclasses) do
		for mclass in mclasses do
			values[mclass] = mclass.in_hierarchy(mainmodule).depth
		end
	end

	redef fun collect(mclasses) do
		for mclass in mclasses do
			values[mclass] = mclass.collect_accessible_mproperties(mainmodule, filter).length
		end
	end

	redef fun collect(mclasses) do
		for mclass in mclasses do
			values[mclass] = mclass.collect_accessible_mattributes(mainmodule, filter).length
		end
	end

	redef fun collect(mclasses) do
		for mclass in mclasses do
			values[mclass] = mclass.collect_accessible_mmethods(mainmodule, filter).length
		end
	end

	redef fun collect(mclasses) do
		for mclass in mclasses do
			values[mclass] = mclass.collect_accessible_inits(mainmodule, filter).length
		end
	end

	redef fun collect(mclasses) do
		for mclass in mclasses do
			values[mclass] = mclass.collect_accessible_vts(mainmodule, filter).length
		end
	end

	redef fun collect(mclasses) do
		for mclass in mclasses do
			values[mclass] = mclass.collect_intro_mproperties(filter).length
		end
	end

	redef fun collect(mclasses) do
		for mclass in mclasses do
			values[mclass] = mclass.collect_redef_mproperties(filter).length
		end
	end

	redef fun collect(mclasses) do
		for mclass in mclasses do
			values[mclass] = mclass.collect_inherited_mproperties(mainmodule, filter).length
		end
	end

	redef fun collect(mclasses) do
		for mclass in mclasses do
			values[mclass] = mclass.collect_local_mproperties(filter).length
		end
	end

	redef fun collect(mclasses) do
		for mclass in mclasses do
			var totc = mclass.collect_accessible_mproperties(mainmodule, filter).length
			var ditc = mclass.in_hierarchy(mainmodule).depth
			values[mclass] = totc.to_f / (ditc + 1).to_f
		end
	end

	redef fun collect(mmodules) do
		for mmodule in mmodules do
			var totc = mmodule.collect_intro_mclassdefs(filter).length
			totc += mmodule.collect_redef_mclassdefs(filter).length
			var ditc = mmodule.in_importation.depth
			values[mmodule] = totc.to_f / (ditc + 1).to_f
		end
	end

	redef fun collect(mclasses) do
		var cbms = new CBMS(model, mainmodule, filter)
		for mclass in mclasses do
			# compute branch mean size
			var parents = mclass.in_hierarchy(mainmodule).direct_greaters
			if parents.length > 0 then
				cbms.clear
				cbms.collect(new HashSet[MClass].from(parents))
				# compute class novelty index
				var locc = mclass.collect_accessible_mproperties(mainmodule, filter).length
				values[mclass] = locc.to_f / cbms.avg
			else
				values[mclass] = 0.0
			end
		end
	end

	redef fun collect(mmodules) do
		var mbms = new MBMS(model, mainmodule, filter)
		for mmodule in mmodules do
			# compute branch mean size
			var parents = mmodule.in_importation.direct_greaters
			if parents.length > 0 then
				mbms.clear
				mbms.collect(new HashSet[MModule].from(parents))
				# compute module novelty index
				var locc = mmodule.collect_intro_mclassdefs(filter).length
				locc += mmodule.collect_redef_mclassdefs(filter).length
				values[mmodule] = locc.to_f / mbms.avg
			else
				values[mmodule] = 0.0
			end
		end
	end

	redef fun collect(mclasses) do
		var cnvi = new CNVI(model, mainmodule, filter)
		cnvi.collect(mclasses)
		for mclass in mclasses do
			var locc = mclass.collect_local_mproperties(filter).length
			values[mclass] = cnvi.values[mclass] * locc.to_f
		end
	end

	redef fun collect(mmodules) do
		var mnvi = new MNVI(model, mainmodule, filter)
		mnvi.collect(mmodules)
		for mmodule in mmodules do
			var locc = mmodule.collect_intro_mclassdefs(filter).length
			locc += mmodule.collect_redef_mclassdefs(filter).length
			values[mmodule] = mnvi.values[mmodule] * locc.to_f
		end
	end

	redef fun collect(mmodules) do
		for mmodule in mmodules do
			var count = 0
			for mclass in mmodule.intro_mclasses do
				if mclass.in_hierarchy(mainmodule).greaters.length > 2 then count += 1
			end
			if mmodule.intro_mclasses.is_empty then
				values[mmodule] = 0.0
			else
				values[mmodule] = count.to_f / mmodule.intro_mclasses.length.to_f
			end
		end
	end

	redef fun collect(mmodules) do
		for mmodule in mmodules do
			var count = 0
			var nb = 0
			for mclass in mmodule.intro_mclasses do
				if mclass.kind == abstract_kind or mclass.kind == concrete_kind or mclass.kind == extern_kind then
					if mclass.in_hierarchy(mainmodule).greaters.length > 2 then count += 1
				end
				nb += 1
			end
			if mmodule.intro_mclasses.is_empty then
				values[mmodule] = 0.0
			else
				values[mmodule] = count.to_f / nb.to_f
			end
		end
	end

	redef fun collect(mmodules) do
		for mmodule in mmodules do
			var count = 0
			var nb = 0
			for mclass in mmodule.intro_mclasses do
				if mclass.kind == interface_kind then
					if mclass.in_hierarchy(mainmodule).greaters.length > 2 then count += 1
				end
				nb += 1
			end
			if mmodule.intro_mclasses.is_empty then
				values[mmodule] = 0.0
			else
				values[mmodule] = count.to_f / nb.to_f
			end
		end
	end

	redef fun collect(mmodules) do
		for mmodule in mmodules do
			var count = 0
			for mclass in mmodule.intro_mclasses do
				if mclass.in_hierarchy(mainmodule).direct_smallers.length > 0 then count += 1
			end
			if mmodule.intro_mclasses.is_empty then
				values[mmodule] = 0.0
			else
				values[mmodule] = count.to_f / mmodule.intro_mclasses.length.to_f
			end
		end
	end

	redef fun collect(mmodules) do
		for mmodule in mmodules do
			var count = 0
			var nb = 0
			for mclass in mmodule.intro_mclasses do
				if mclass.kind == abstract_kind or mclass.kind == concrete_kind or mclass.kind == extern_kind then
					if mclass.in_hierarchy(mainmodule).direct_smallers.length > 0 then count += 1
				end
				nb += 1
			end
			if mmodule.intro_mclasses.is_empty then
				values[mmodule] = 0.0
			else
				values[mmodule] = count.to_f / nb.to_f
			end
		end
	end

	redef fun collect(mmodules) do
		for mmodule in mmodules do
			var count = 0
			var nb = 0
			for mclass in mmodule.intro_mclasses do
				if mclass.kind == interface_kind then
					if mclass.in_hierarchy(mainmodule).direct_smallers.length > 0 then count += 1
				end
				nb += 1
			end
			if mmodule.intro_mclasses.is_empty then
				values[mmodule] = 0.0
			else
				values[mmodule] = count.to_f / nb.to_f
			end
		end
	end

	redef fun collect(mclasses) do
		for mclass in mclasses do
			var count = 0
			for parent in mclass.in_hierarchy(mainmodule).greaters do
				if parent == mclass then continue
				if parent.kind == abstract_kind or parent.kind == concrete_kind or parent.kind == extern_kind then
					count += 1
				end
			end
			values[mclass] = count
		end
	end

	redef fun collect(mclasses) do
		for mclass in mclasses do
			var count = 0
			for parent in mclass.in_hierarchy(mainmodule).direct_greaters do
				if parent == mclass then continue
				if parent.kind == abstract_kind or parent.kind == concrete_kind or parent.kind == extern_kind then
					count += 1
				end
			end
			values[mclass] = count
		end
	end

	redef fun collect(mclasses) do
		for mclass in mclasses do
			var count = 0
			for parent in mclass.in_hierarchy(mainmodule).direct_smallers do
				if parent == mclass then continue
				if parent.kind == abstract_kind or parent.kind == concrete_kind or parent.kind == extern_kind then
					count += 1
				end
			end
			values[mclass] = count
		end
	end

	redef fun collect(mclasses) do
		for mclass in mclasses do
			var count = 0
			for parent in mclass.in_hierarchy(mainmodule).smallers do
				if parent == mclass then continue
				if parent.kind == abstract_kind or parent.kind == concrete_kind or parent.kind == extern_kind then
					count += 1
				end
			end
			values[mclass] = count
		end
	end

	redef fun collect(mclasses) do
		for mclass in mclasses do
			var count = 0
			for parent in mclass.in_hierarchy(mainmodule).greaters do
				if parent == mclass then continue
				if parent.kind == abstract_kind then
					count += 1
				end
			end
			values[mclass] = count
		end
	end

	redef fun collect(mclasses) do
		for mclass in mclasses do
			var count = 0
			for parent in mclass.in_hierarchy(mainmodule).greaters do
				if parent == mclass then continue
				if parent.kind == interface_kind then
					count += 1
				end
			end
			values[mclass] = count
		end
	end

	redef fun collect(mclasses) do
		for mclass in mclasses do
			var count = 0
			for parent in mclass.in_hierarchy(mainmodule).direct_greaters do
				if parent == mclass then continue
				if parent.kind == interface_kind then
					count += 1
				end
			end
			values[mclass] = count
		end
	end

	redef fun collect(mclasses) do
		for mclass in mclasses do
			var count = 0
			for parent in mclass.in_hierarchy(mainmodule).direct_smallers do
				if parent == mclass then continue
				if parent.kind == interface_kind then
					count += 1
				end
			end
			values[mclass] = count
		end
	end

	redef fun collect(mclasses) do
		for mclass in mclasses do
			var count = 0
			for parent in mclass.in_hierarchy(mainmodule).smallers do
				if parent == mclass then continue
				if parent.kind == interface_kind then
					count += 1
				end
			end
			values[mclass] = count
		end
	end

	redef fun collect(mclasses) do
		for mclass in mclasses do
			values[mclass] = mclass.ditc(mainmodule)
		end
	end

	redef fun collect(mclasses) do
		for mclass in mclasses do
			values[mclass] = mclass.diti(mainmodule)
		end
	end

	redef fun collect(mclasses) do
		for mclass in mclasses do
			var all = mclass.collect_accessible_mattributes(mainmodule, filter)
			for mattr in all do
				if mattr.is_nullable then values.inc(mclass)
			end
		end
	end

	redef fun collect(mclasses) do end

	redef fun collect(mclasses) do end

	redef fun collect(mtypes) do end

	redef fun collect(mtypes) do end

	redef fun collect(mtypes) do
		for mtype in mtypes do
			if mtype isa MGenericType then
				values[mtype] = mtype.arguments.length
			else
				values[mtype] = 0
			end
		end
	end

	redef fun collect(mtypes) do
		for mtype in mtypes do
			values[mtype] = mtype.signature_depth
		end
	end

	redef fun collect(mainmodules) do
		for mainmodule in mainmodules do
			var analysis = new MetricsRapidTypeAnalysis(modelbuilder, mainmodule)
			analysis.run_analysis
			values[mainmodule] = analysis.tnli.sum
		end
	end

	redef fun collect(mainmodules) do
		for mainmodule in mainmodules do
			var analysis = new MetricsRapidTypeAnalysis(modelbuilder, mainmodule)
			analysis.run_analysis
			values[mainmodule] = analysis.live_types.length
		end
	end

	redef fun collect(mainmodules) do
		for mainmodule in mainmodules do
			var analysis = new MetricsRapidTypeAnalysis(modelbuilder, mainmodule)
			analysis.run_analysis
			values[mainmodule] = analysis.live_cast_types.length
		end
	end

	redef fun collect(mainmodules) do
		for mainmodule in mainmodules do
			var live = new HashSet[MClass]
			var analysis = new MetricsRapidTypeAnalysis(modelbuilder, mainmodule)
			analysis.run_analysis
			for mtype in analysis.live_types do
				live.add(mtype.mclass)
			end
			values[mainmodule] = live.length
		end
	end

	redef fun collect(mainmodules) do
		for mainmodule in mainmodules do
			var analysis = new MetricsRapidTypeAnalysis(modelbuilder, mainmodule)
			analysis.run_analysis
			values[mainmodule] = analysis.live_methods.length
		end
	end

	redef fun collect(mainmodules) do
		for mainmodule in mainmodules do
			var analysis = new MetricsRapidTypeAnalysis(modelbuilder, mainmodule)
			analysis.run_analysis
			values[mainmodule] = analysis.live_methoddefs.length
		end
	end

	redef fun collect(mainmodules) do
		for mainmodule in mainmodules do
			var dead = 0
			var analysis = new MetricsRapidTypeAnalysis(modelbuilder, mainmodule)
			analysis.run_analysis
			for mmethod in analysis.live_methods do
				for mdef in mmethod.mpropdefs do
					if analysis.live_methoddefs.has(mdef) or mdef.is_abstract then continue
					dead += 1
				end
			end
			values[mainmodule] = dead
		end
	end