Changeset 8

	7		8
7		7
8	import analyzer.treeModel.*;	8	import analyzer.treeModel.*;
9	import analyzer.wordAnalysis.*;	9	import analyzer.wordAnalysis.*;
		10	import java.awt.Rectangle;
		11	import javax.swing.JProgressBar;
		12	import javax.swing.SwingWorker;
10	//import com.sun.xml.internal.fastinfoset.algorithm.BuiltInEncodingAlgorithm.WordListener;	13	//import com.sun.xml.internal.fastinfoset.algorithm.BuiltInEncodingAlgorithm.WordListener;
11		14
12	/**	15	/**
13	* Trieda reprezentujúca držiteľa štatistických údajov pre projekt. Objekt obsahuje tieto údaje o projekte:	16	* Trieda reprezentujúca držiteľa štatistických údajov pre projekt. Objekt obsahuje tieto údaje o projekte:
14	* Slová vyskytujúce sa v projekte, slová nájdené v databázi, slová nenájdené v databázi, počet všetkých	17	* Slová vyskytujúce sa v projekte, slová nájdené v databázi, slová nenájdené v databázi, počet všetkých
15	* slov, počet slov v databázi, počet slov nenájdených v databázi, počet podst. mien, počet slovies,	18	* slov, počet slov v databázi, počet slov nenájdených v databázi, počet podst. mien, počet slovies,
16	* počet prídavných mien, počet častíc, slová v názvoch premenných, slová v názvoch metód, slová v názvoch	19	* počet prídavných mien, počet častíc, slová v názvoch premenných, slová v názvoch metód, slová v názvoch
17	* tried a počet slovné druhy pre premenné, metódy a triedy.	20	* tried a počet slovné druhy pre premenné, metódy a triedy.
18	* @author Marek Mezei	21	* @author Marek Mezei
19	*/	22	*/
20	public class ProjectStatistics {	23	public class ProjectStatistics extends SwingWorker<Void, Void> {
21		24
22	/** zdrojové súbory v projekte */	25	/** zdrojové súbory v projekte */
		26	private int barNumber = 0;
23	private SourceFile[] sourceFiles;	27	private SourceFile[] sourceFiles;
24	private WordNetControl wordNet;	28	private WordNetControl wordNet;
25	private String projectPath;	29	private String projectPath;
...		...
59	private HashMap<String, Boolean> wordsInDatabaseMap;	63	private HashMap<String, Boolean> wordsInDatabaseMap;
60	/** filter pre slová, ktoré nechceme zahrnúť do najpoužívanejších slov */	64	/** filter pre slová, ktoré nechceme zahrnúť do najpoužívanejších slov */
61	private WordFilter filter;	65	private WordFilter filter;
62		66	private ArrayList<Integer> backup = null;
		67	private String[] sortedAllWords;
		68	private int[] sortedAllWordsCounts;
		69	private String[] unsortedWordsInProject;
63	public ProjectStatistics(SourceFile[] sourceFiles, String path, WordNetControl wordNet) {	70	public ProjectStatistics(SourceFile[] sourceFiles, String path, WordNetControl wordNet) {
64	this.sourceFiles = sourceFiles;	71	this.sourceFiles = sourceFiles;
65	statisticsForSourceFiles = new SourceFileStatistics[sourceFiles.length];	72	statisticsForSourceFiles = new SourceFileStatistics[sourceFiles.length];
...		...
100	/**	107	/**
101	* Vygenerovanie štatistických údajov pre projekt.	108	* Vygenerovanie štatistických údajov pre projekt.
102	*/	109	*/
103	public void generateStatistics() {	110	public void generateStatistics(JProgressBar progressbar) {
		111
104	//slová zo zdrojových súborov postupne pridávame do množiny, aby nevznikli duplikáty	112	//slová zo zdrojových súborov postupne pridávame do množiny, aby nevznikli duplikáty
105	Set<String> wordsSet = new HashSet<String>();	113	Set<String> wordsSet = new HashSet<String>();
106	Set<String> variableWordsSet = new HashSet<String>();	114	Set<String> variableWordsSet = new HashSet<String>();
107	Set<String> methodWordsSet = new HashSet<String>();	115	Set<String> methodWordsSet = new HashSet<String>();
108	Set<String> classWordsSet = new HashSet<String>();	116	Set<String> classWordsSet = new HashSet<String>();
109	Set<String> commentWordsSet = new HashSet<String>();	117	Set<String> commentWordsSet = new HashSet<String>();
		118	double percent = 0.0;
		119	double len = 0.0;
		120
		121
		122
		123
		124	int numberOfFilles = getStatisticsForSourceFiles().length;
110	for (int i = 0; i < getStatisticsForSourceFiles().length; i++) {	125	for (int i = 0; i < getStatisticsForSourceFiles().length; i++) {
		126	if (progressbar != null) {
		127	len = i;
		128	percent = (len / numberOfFilles);
		129	System.out.println("percent" + percent);
		130	System.out.println("number of files" + numberOfFilles);
		131	setBarNumber((int) Math.round(percent * 100 / 10));
		132
		133	progressbar.setValue(barNumber);
		134	Rectangle progressRect = progressbar.getBounds();
		135	progressRect.x = 0;
		136	progressRect.y = 0;
		137	progressbar.paintImmediately(progressRect);
		138
		139	doInBackground();
		140	System.out.println("bar" + barNumber);
		141	}
111	String[] wordsInSourceFile = getStatisticsForSourceFiles()[i].getWordsInSourceFile();	142	String[] wordsInSourceFile = getStatisticsForSourceFiles()[i].getWordsInSourceFile();
112	for (int j = 0; j < wordsInSourceFile.length; j++) {	143	for (int j = 0; j < wordsInSourceFile.length; j++) {
113	wordsSet.add(wordsInSourceFile[j]);	144	wordsSet.add(wordsInSourceFile[j]);
...		...
140	wordsInProject[i] = (String) obj[i];	171	wordsInProject[i] = (String) obj[i];
141	}	172	}
142		173
143	Object[] comObj = commentWordsSet.toArray();	174	Object[] comObj = commentWordsSet.toArray();
144	setCommentWords(new String[comObj.length]);	175	setCommentWords(new String[comObj.length]);
145	for (int i = 0; i < getCommentWords().length; i++) {	176	for (int i = 0; i < getCommentWords().length; i++) {
146	getCommentWords()[i] = (String) comObj[i];	177	getCommentWords()[i] = (String) comObj[i];
...		...
272	//všetkým slovám musíme priradiť slovné druhy	303	//všetkým slovám musíme priradiť slovné druhy
273	System.out.print("Guessing types for words...");	304	System.out.print("Guessing types for words...");
274	for (int i = 0; i < wordsInDatabase.length; i++) {	305	for (int i = 0; i < wordsInDatabase.length; i++) {
		306	if (progressbar != null) {
		307	System.out.println(i);
		308	len = i;
		309	percent = (len / wordsInDatabase.length);
		310	System.out.println("percent" + percent);
		311	System.out.println("words" + wordsInDatabase.length);
		312	setBarNumber((int) Math.round(percent * 100));
		313
		314	if (barNumber > 9) {
		315	progressbar.setValue(barNumber);
		316	}
		317	Rectangle progressRect = progressbar.getBounds();
		318	progressRect.x = 0;
		319	progressRect.y = 0;
		320	progressbar.paintImmediately(progressRect);
		321
		322	doInBackground();
		323	System.out.println("bar" + barNumber);
		324	}
275	String word = wordsInDatabase[i];	325	String word = wordsInDatabase[i];
276	String type;	326	String type;
		327	// ak je oznacena volba bez komentarov nepridava komentare do typov slov
		328	if (filter.isWithoutComments()) {
		329
		330	if (commentWordsSet.contains(word)) {
		331
		332	continue;
		333	}
		334	}
277	if (wordTypesMap.containsKey(word)) {	335	if (wordTypesMap.containsKey(word)) {
278	type = wordTypesMap.get(word);	336	type = wordTypesMap.get(word);
279	} else {	337	} else {
...		...
434	for (int i = 0; i < wordsInProjectUsageCounts.length; i++) {	492	for (int i = 0; i < wordsInProjectUsageCounts.length; i++) {
435	int wordUsageCount = 0;	493	int wordUsageCount = 0;
436	for (int j = 0; j < getStatisticsForSourceFiles().length; j++) {	494	for (int j = 0; j < getStatisticsForSourceFiles().length; j++) {
437	wordUsageCount += getStatisticsForSourceFiles()[j].getWordUsage(wordsInProject[i],true);	495	wordUsageCount += getStatisticsForSourceFiles()[j].getWordUsage(wordsInProject[i], true);
438	}	496	}
439	wordsInProjectUsageCounts[i] = wordUsageCount;	497	wordsInProjectUsageCounts[i] = wordUsageCount;
440	}	498	}
441		499	String[] filteredWordsInProject = null;
442	//filter.setNotAllowedWords(notWantedWords);	500	//filter.setNotAllowedWords(notWantedWords);
443	String[] filteredWordsInProject = filter.filterWords(wordsInProject);	501	if (filter.isOnlyComments()) {
444		502	filteredWordsInProject = filter.filterWords(commentWords);
		503	} else {
		504	filteredWordsInProject = filter.filterWords(wordsInProject);
		505	}
		506	unsortedWordsInProject = filteredWordsInProject;
445	ArrayList<Integer> wordsUsageCountsList = new ArrayList<Integer>();	507	ArrayList<Integer> wordsUsageCountsList = new ArrayList<Integer>();
446	for (int i = 0; i < filteredWordsInProject.length; i++) {	508	for (int i = 0; i < filteredWordsInProject.length; i++) {
447	int wordUsageCount = 0;	509	int wordUsageCount = 0;
448	for (int j = 0; j < getStatisticsForSourceFiles().length; j++) {	510	for (int j = 0; j < getStatisticsForSourceFiles().length; j++) {
449	wordUsageCount += getStatisticsForSourceFiles()[j].getWordUsage(filteredWordsInProject[i],filter.isComment());	511	wordUsageCount += getStatisticsForSourceFiles()[j].getWordUsage(filteredWordsInProject[i], filter.isComment());
450	}	512	}
451	wordsUsageCountsList.add(wordUsageCount);	513	wordsUsageCountsList.add(wordUsageCount);
452	}	514	}
453	//kolekciu ideme zotriediť, preto si musíme spraviť zálohu,	515	//kolekciu ideme zotriediť, preto si musíme spraviť zálohu,
454	//ktorú budeme neskôr potrebovať	516	//ktorú budeme neskôr potrebovať
455	ArrayList<Integer> backup = new ArrayList<Integer>();	517	backup = new ArrayList<Integer>();
456	for (int i = 0; i < wordsUsageCountsList.size(); i++) {	518	for (int i = 0; i < wordsUsageCountsList.size(); i++) {
457	backup.add(wordsUsageCountsList.get(i));	519	backup.add(wordsUsageCountsList.get(i));
458	}	520	}
...		...
494		556
495	//ked odfiltrujem komentare moze byt ze slovo ma 0 vyskytov tak ho odfiltrujem	557	//ked odfiltrujem komentare moze byt ze slovo ma 0 vyskytov tak ho odfiltrujem
496	/* for (int i = 0; i < wordsList.size(); i++) {	558	/* for (int i = 0; i < wordsList.size(); i++) {
497	if (countsList.get(i) == 0) {	559	if (countsList.get(i) == 0) {
498	wordsList.remove(i);	560	wordsList.remove(i);
499	countsList.remove(i);	561	countsList.remove(i);
500		562
501	}
502	}	563	}
503	*/	564	}
		565	*/
504		566
505		567
506		568
...		...
517	}	579	}
518		580
519	mostUsedWords = sortedWords;	581	mostUsedWords = sortedWords;
520	mostUsedWordsCounts = sortedCounts;	582	setMostUsedWordsCounts(sortedCounts);
521	}	583	}
522		584
523	/**	585	/**
...		...
627	float wordsInDatabaseRatio = ((float) wordsInDatabase.length / (float) wordsInProject.length) * 100;	689	float wordsInDatabaseRatio = ((float) wordsInDatabase.length / (float) wordsInProject.length) * 100;
628	int wordsInDatabaseRatioRounded = Math.round(wordsInDatabaseRatio);	690	int wordsInDatabaseRatioRounded = Math.round(wordsInDatabaseRatio);
629		691
630	string.append("Number of words in whole project: " + wordsInProject.length + "\n");	692	if (filter.isWithoutComments()) {
631	string.append("Number of whole words in project: " + wordsInDatabase.length + "(" + wordsInDatabaseRatioRounded + "%)\n");	693	string.append("Number of words in whole project: " + (wordsInProject.length - commentWords.length) + "\n");
632	string.append("Number of not recognized words in project: " + wordsNotInDatabase.length + "(" + (100 - wordsInDatabaseRatioRounded) + "%)\n\n");	694	string.append("Number of whole words in project: " + (wordsInDatabase.length - commentWordsInDatabaseCount) + "(" + ((wordsInDatabase.length - commentWordsInDatabaseCount) / (wordsInProject.length - commentWords.length)) * 100 + "%)\n");
		695	string.append("Number of not recognized words in project: " + (wordsNotInDatabase.length - commentWordsNotInDatabaseCount) + "(" + (100 - Math.round(((wordsInDatabase.length - commentWordsInDatabaseCount) / (wordsInProject.length - commentWords.length)) * 100)) + "%)\n\n");
633		696
		697	} else {
		698	string.append("Number of words in whole project: " + wordsInProject.length + "\n");
		699	string.append("Number of whole words in project: " + wordsInDatabase.length + "(" + wordsInDatabaseRatioRounded + "%)\n");
		700	string.append("Number of not recognized words in project: " + wordsNotInDatabase.length + "(" + (100 - wordsInDatabaseRatioRounded) + "%)\n\n");
		701
		702	}
		703
634	string.append("Number of nouns: " + nounsCount + "\n");	704	string.append("Number of nouns: " + nounsCount + "\n");
635	string.append("Number of verbs: " + verbsCount + "\n");	705	string.append("Number of verbs: " + verbsCount + "\n");
636	string.append("Number of adjectives: " + adjectivesCount + "\n");	706	string.append("Number of adjectives: " + adjectivesCount + "\n");
...		...
656	string.append("\nVerbs: " + variableWordTypesCount[1]);	726	string.append("\nVerbs: " + variableWordTypesCount[1]);
657	string.append("\nAdjectives: " + variableWordTypesCount[2]);	727	string.append("\nAdjectives: " + variableWordTypesCount[2]);
658	string.append("\nAdverbs: " + variableWordTypesCount[3]);	728	string.append("\nAdverbs: " + variableWordTypesCount[3]);
		729	if (!filter.isWithoutComments()) {
		730	string.append("\n\nStatistics for comments: ");
659		731
		732	string.append("\nNouns: " + getCommentWordTypesCount()[0]);
		733	string.append("\nVerbs: " + getCommentWordTypesCount()[1]);
		734	string.append("\nAdjectives: " + getCommentWordTypesCount()[2]);
		735	string.append("\nAdverbs: " + getCommentWordTypesCount()[3]);
		736	}
		737	string.append("\n\nThe most used words: (except these words: ");
		738	String[] notWantedWords = filter.getNotAllowedWords();
		739	for (int i = 0; i < notWantedWords.length; i++) {
		740	string.append(notWantedWords[i] + ", ");
		741	}
		742	string.append(")\n");
		743	for (int i = 0; i < getMostUsedWords().length; i++) {
		744	if (getMostUsedWords()[i] == null) {
		745	continue;
		746	}
		747
		748	string.append((i + 1) + ". Word: \"" + getMostUsedWords()[i] + "\". Used " + getMostUsedWordsCounts()[i] + " times\n");
		749	}
		750
		751	return string.toString();
		752	}
		753
		754	public String generateStatisticsCommentString() {
		755	StringBuilder string = new StringBuilder();
		756	string.append("Project path: " + projectPath + "\n");
		757	string.append("Number of source files in project: " + sourceFiles.length + "\n");
		758
		759	float wordsInDatabaseRatio = ((float) wordsInDatabase.length / (float) wordsInProject.length) * 100;
		760	int wordsInDatabaseRatioRounded = Math.round(wordsInDatabaseRatio);
		761
		762	string.append("Number of words in whole project: " + wordsInProject.length + "\n");
		763	string.append("Number of whole words in project: " + wordsInDatabase.length + "(" + wordsInDatabaseRatioRounded + "%)\n");
		764	string.append("Number of not recognized words in project: " + wordsNotInDatabase.length + "(" + (100 - wordsInDatabaseRatioRounded) + "%)\n\n");
		765
660	string.append("\n\nStatistics for comments: ");	766	string.append("\n\nStatistics for comments: ");
661		767
662	string.append("\nNouns: " + getCommentWordTypesCount()[0]);	768	string.append("\nNouns: " + getCommentWordTypesCount()[0]);
...		...
664	string.append("\nAdjectives: " + getCommentWordTypesCount()[2]);	770	string.append("\nAdjectives: " + getCommentWordTypesCount()[2]);
665	string.append("\nAdverbs: " + getCommentWordTypesCount()[3]);	771	string.append("\nAdverbs: " + getCommentWordTypesCount()[3]);
666		772
667	string.append("\n\nThe most used words: (except these words: ");	773	string.append("\n\nThe most used words in comments: (except these words: ");
668	String[] notWantedWords = filter.getNotAllowedWords();	774	String[] notWantedWords = filter.getNotAllowedWords();
669	for (int i = 0; i < notWantedWords.length; i++) {	775	for (int i = 0; i < notWantedWords.length; i++) {
670	string.append(notWantedWords[i] + ", ");	776	string.append(notWantedWords[i] + ", ");
671	}	777	}
672	string.append(")\n");	778	string.append(")\n");
673	for (int i = 0; i < getMostUsedWords().length; i++) {	779	for (int i = 0; i < getMostUsedWords().length; i++) {
674	if(getMostUsedWords()[i]==null)	780	if (getMostUsedWords()[i] == null) {
675	{
676	continue;	781	continue;
677	}	782	}
678		783
679	string.append((i + 1) + ". Word: \"" + getMostUsedWords()[i] + "\". Used " + mostUsedWordsCounts[i] + " times\n");	784	string.append((i + 1) + ". Word: \"" + getMostUsedWords()[i] + "\". Used " + getMostUsedWordsCounts()[i] + " times\n");
680	}	785	}
681		786
682	return string.toString();	787	return string.toString();
...		...
688	public String[] getWordsInProject() {	793	public String[] getWordsInProject() {
689	return wordsInProject;	794	return wordsInProject;
690	}	795	}
		796	/*
		797	public String[] getNumberWordsInProject(int count) {
		798	String[] stringToReturn = new String[count];
		799	for (int i = 0; i < count; i++) {
		800	stringToReturn[i] = wordsInProject[i];
691		801
		802	}
		803	return stringToReturn;
		804	}
		805	*/
692	/**	806	/**
693	*	807	*
694	* @return Slová, ktoré sa nenašli v databáze.	808	* @return Slová, ktoré sa nenašli v databáze.
...		...
732	public int getVariableWordsCount() {	846	public int getVariableWordsCount() {
733	return variableWords.length;	847	return variableWords.length;
734	}	848	}
735	public int getCommentWordsCount() {	849
		850	public int getCommentWordsCount() {
736	return commentWords.length;	851	return commentWords.length;
737	}	852	}
		853
738	public int getClassWordsInDatabaseCount() {	854	public int getClassWordsInDatabaseCount() {
739	return classWordsInDatabaseCount;	855	return classWordsInDatabaseCount;
740	}	856	}
...		...
758	public int getVariableWordsNotInDatabaseCount() {	874	public int getVariableWordsNotInDatabaseCount() {
759	return variableWordsNotInDatabaseCount;	875	return variableWordsNotInDatabaseCount;
760	}	876	}
761	public int getCommentWordsNotInDatabaseCount() {	877
		878	public int getCommentWordsNotInDatabaseCount() {
762	return commentWordsNotInDatabaseCount;	879	return commentWordsNotInDatabaseCount;
763	}	880	}
		881
764	public int getNounsCount() {	882	public int getNounsCount() {
765	return nounsCount;	883	return nounsCount;
766	}	884	}
...		...
861	public SourceFileStatistics[] getStatisticsForSourceFiles() {	979	public SourceFileStatistics[] getStatisticsForSourceFiles() {
862	return statisticsForSourceFiles;	980	return statisticsForSourceFiles;
863	}	981	}
		982
		983	@Override
		984	protected Void doInBackground() {
		985	int progress = 0;
		986	progress = getBarNumber();
		987	return null;
		988	}
		989
		990	/**
		991	* @return the barNumber
		992	*/
		993	public int getBarNumber() {
		994	return barNumber;
		995	}
		996
		997	/**
		998	* @param barNumber the barNumber to set
		999	*/
		1000	public void setBarNumber(int barNumber) {
		1001	this.barNumber = barNumber;
		1002	}
		1003
		1004	/**
		1005	* @return the mostUsedWordsCounts
		1006	*/
		1007	public int[] getMostUsedWordsCounts() {
		1008	return mostUsedWordsCounts;
		1009	}
		1010
		1011	/**
		1012	* @param mostUsedWordsCounts the mostUsedWordsCounts to set
		1013	*/
		1014	public void setMostUsedWordsCounts(int[] mostUsedWordsCounts) {
		1015	this.mostUsedWordsCounts = mostUsedWordsCounts;
		1016	}
		1017	public void Sort()
		1018	{
		1019	sortForSave(backup,getUnsortedWordsInProject());
		1020	}
		1021
		1022	public void sortForSave(ArrayList<Integer> usageCount, String[] wordsToSort)
		1023	{
		1024
		1025	ArrayList<String> wordsList = new ArrayList<String>();
		1026	ArrayList<Integer> countsList = new ArrayList<Integer>();
		1027
		1028	for (int i = 0; i < wordsToSort.length; i++) {
		1029
		1030	wordsList.add(wordsToSort[i]);
		1031
		1032	countsList.add(usageCount.get(i));
		1033
		1034	}
		1035
		1036	TreeSet<Integer> sortedCountsSet = new TreeSet<Integer>();
		1037	for (int i = 0; i < countsList.size(); i++) {
		1038	sortedCountsSet.add(countsList.get(i));
		1039	}
		1040
		1041	String[] sortedWords = new String[wordsList.size()];
		1042	int[] sortedCounts = new int[countsList.size()];
		1043
		1044	int index = 0;
		1045	Iterator<Integer> countsIterator = sortedCountsSet.descendingIterator();
		1046	while (countsIterator.hasNext()) {
		1047	int count = countsIterator.next();
		1048
		1049	//ked odfiltrujem komentare moze byt ze slovo ma 0 vyskytov tak ho odfiltrujem
		1050	/* for (int i = 0; i < wordsList.size(); i++) {
		1051	if (countsList.get(i) == 0) {
		1052	wordsList.remove(i);
		1053	countsList.remove(i);
		1054
		1055	}
		1056	}
		1057	*/
		1058
		1059
		1060
		1061
		1062
		1063
		1064	for (int i = 0; i < wordsList.size(); i++) {
		1065	if (countsList.get(i) == count) {
		1066	sortedWords[index] = wordsList.get(i);
		1067	sortedCounts[index] = countsList.get(i);
		1068	index++;
		1069	}
		1070	}
		1071	}
		1072
		1073	sortedAllWords = sortedWords;
		1074	sortedAllWordsCounts=sortedCounts;
		1075	}
		1076
		1077	/**
		1078	* @return the sortedAllWords
		1079	*/
		1080	public String[] getSortedAllWords(int count) {
		1081	String[] stringsToReturn = new String[count];
		1082	for (int i = 0; i < count; i++) {
		1083	stringsToReturn[i] = sortedAllWords[i];
		1084
		1085	}
		1086	return stringsToReturn;
		1087
		1088	}
		1089
		1090	/**
		1091	* @return the sortedAllWordsCounts
		1092	*/
		1093	public int[] getSortedAllWordsCounts(int count) {
		1094	int[] countsToReturn = new int[count];
		1095	for (int i = 0; i < count; i++) {
		1096	countsToReturn[i] = sortedAllWordsCounts[i];
		1097
		1098	}
		1099	return countsToReturn;
		1100	}
		1101
		1102	/**
		1103	* @return the unsortedWordsInProject
		1104	*/
		1105	public String[] getUnsortedWordsInProject() {
		1106	return unsortedWordsInProject;
		1107	}
864	}	1108	}

	7		8
1	/*	1	/*
2	* okomentované 2.4.2009	2	* okomentované 2.4.2009
3	*/	3	*/
4		4
5	package analyzer.statistics;	5	package analyzer.statistics;
6		6
7	import analyzer.treeModel.*;	7	import analyzer.treeModel.*;

 package analyzer.Tools;
-import analyzer.statistics.*;
-import analyzer.wordAnalysis.*;
 import analyzer.treeModel.*;
 import analyzer.treeScanner.*;
      * @param wordNet Objekt pre prístup ku slovníku WordNet
      * @return Objekty, ktoré sú držiteľmi štruktúry zdrojového súboru a tabuľky slov.
      */
+    /*
     public static ProjectStatistics generateStatistics(String projectDirectory, WordNetControl wordNet)
     {
         ArrayList<SourceFile> sourceFilesList = new ArrayList<SourceFile>();
         return statistics;
     }
+     * */
 }

	7		8
1	package analyzer.Tools;	1	package analyzer.Tools;
2		2
3	import java.util.*;	3	import java.util.*;
4	import java.io.*;	4	import java.io.*;
5		5

	7		8
1	package analyzer.treeModel;	1	package analyzer.treeModel;
2		2
3	/**	3	/**
4	* Abstraktná trieda predstavujúca časť zdrojového kódu - triedu.	4	* Abstraktná trieda predstavujúca časť zdrojového kódu - triedu.
5	* @author Marek Mezei	5	* @author Marek Mezei

	7		8
4	*/	4	*/
5		5
6	package analyzer.treeModel;	6	package analyzer.treeModel;
7		7
8	/**	8	/**
9	*	9	*
10	* @author LUBOS	10	* @author LUBOS

	7		8
6	*/	6	*/
7	public class GeneralClassNode extends ClassNode	7	public class GeneralClassNode extends ClassNode
8	{	8	{
9	private String packageName;	9	private String packageName;
10		10
11	public GeneralClassNode(String className, int startLine, int endLine, int column, String packageName)	11	public GeneralClassNode(String className, int startLine, int endLine, int column, String packageName)
12	{	12	{

	7		8
4	* Trieda predstavujúca časť zdrojového kódu - vnútornú triedu.	4	* Trieda predstavujúca časť zdrojového kódu - vnútornú triedu.
5	* @author Marek Mezei	5	* @author Marek Mezei
6	*/	6	*/
7		7
8	public class InnerClassNode extends ClassNode	8	public class InnerClassNode extends ClassNode
9	{	9	{
10	public InnerClassNode(String className, int startLine, int endLine, int column)	10	public InnerClassNode(String className, int startLine, int endLine, int column)

	7		8
6	*/	6	*/
7	public class MethodNode extends Node	7	public class MethodNode extends Node
8	{	8	{
9	public MethodNode(String methodName, int startLine, int endLine, int column)	9	public MethodNode(String methodName, int startLine, int endLine, int column)
10	{	10	{
11	this.name = methodName;	11	this.name = methodName;
12	this.startLine = startLine;	12	this.startLine = startLine;

	7		8
8	*/	8	*/
9	public abstract class Node	9	public abstract class Node
10	{	10	{
11	/** rodičovský uzol */	11	/** rodičovský uzol */
12	protected Node parentNode;	12	protected Node parentNode;
13	/** potomkovské uzly */	13	/** potomkovské uzly */
14	protected ArrayList<Node> childNodes = new ArrayList();	14	protected ArrayList<Node> childNodes = new ArrayList();

	7		8
11	*/	11	*/
12	public class SourceFile	12	public class SourceFile
13	{	13	{
14	private GeneralClassNode rootClassNode = null;	14	private GeneralClassNode rootClassNode = null;
15	private WordsTable wordsTable;	15	private WordsTable wordsTable;
16		16
17	public SourceFile()	17	public SourceFile()

	7		8
1	package analyzer.treeModel;	1	package analyzer.treeModel;
2		2
3	/**	3	/**
4	* Trieda predstavujúca časť zdrojového kódu - premennú.	4	* Trieda predstavujúca časť zdrojového kódu - premennú.
5	* @author Marek Mezei	5	* @author Marek Mezei

	7		8
1	/*	1	/*
2	* okomentované 2.4.2009	2	* okomentované 2.4.2009
3	*/	3	*/
		4
4	package analyzer.treeScanner;	5	package analyzer.treeScanner;
5		6
6	import analyzer.treeModel.*;	7	import analyzer.treeModel.*;
...		...
14	/**	15	/**
15	* Trieda pre prechádzanie zdrojového kódu a pre uchovávanie štruktúry a informácií častí kódu.	16	* Trieda pre prechádzanie zdrojového kódu a pre uchovávanie štruktúry a informácií častí kódu.
16	* @author Marek Mezei	17	* @author Marek Mezei
17	*/	18	*/
18	public class MyTreeScanner extends TreeScanner<Void, Void> {	19	public class MyTreeScanner extends TreeScanner<Void, Void>
19		20	{
20	private JCTree.JCCompilationUnit compilationUnit = null;	21	private JCTree.JCCompilationUnit compilationUnit = null;
21	private SourceFile sourceFile;	22	private SourceFile sourceFile;
22		23
23	public MyTreeScanner() {	24	public MyTreeScanner()
		25	{
24	super();	26	super();
25	sourceFile = new SourceFile();	27	sourceFile = new SourceFile();
26	}	28	}
27		29
28	/**	30	/**
29	* Prechod kompilačnej jednotky.	31	* Prechod kompilačnej jednotky.
30	* @param compilationUnit	32	* @param compilationUnit
...		...
32	* @return	34	* @return
33	*/	35	*/
34	@Override	36	@Override
35	public Void visitCompilationUnit(CompilationUnitTree compilationUnit, Void arg) {	37	public Void visitCompilationUnit(CompilationUnitTree compilationUnit, Void arg)
36	this.compilationUnit = (JCTree.JCCompilationUnit) compilationUnit;	38	{
		39	this.compilationUnit = (JCTree.JCCompilationUnit)compilationUnit;
37		40
		41
38		42
39
40	return super.visitCompilationUnit(compilationUnit, arg);	43	return super.visitCompilationUnit(compilationUnit, arg);
41	}	44	}
42		45
43	/**	46	/**
44	* Prechod triedy, získanie informácií a uloženie informácií a štruktúry.	47	* Prechod triedy, získanie informácií a uloženie informácií a štruktúry.
45	* @param classTree	48	* @param classTree
...		...
47	* @return	50	* @return
48	*/	51	*/
49	@Override	52	@Override
50	public Void visitClass(ClassTree classTree, Void arg) {	53	public Void visitClass(ClassTree classTree, Void arg)
51	JCTree.JCClassDecl classDeclaration = (JCTree.JCClassDecl) classTree;	54	{
52		55	JCTree.JCClassDecl classDeclaration = (JCTree.JCClassDecl)classTree;
		56
53	int startLine = compilationUnit.getLineMap().getLineNumber(classDeclaration.getStartPosition());	57	int startLine = compilationUnit.getLineMap().getLineNumber(classDeclaration.getStartPosition());
54	int endLine = compilationUnit.getLineMap().getLineNumber(classDeclaration.getEndPosition(compilationUnit.endPositions));	58	int endLine = compilationUnit.getLineMap().getLineNumber(classDeclaration.getEndPosition(compilationUnit.endPositions));
55	int column;	59	int column;
56	try {	60	try
		61	{
57	column = compilationUnit.getLineMap().getColumnNumber(classDeclaration.getStartPosition());	62	column = compilationUnit.getLineMap().getColumnNumber(classDeclaration.getStartPosition());
58	} catch (Exception e) {
59	column = 0;
60	}	63	}
61		64	catch (Exception e) { column = 0; }
		65
62	String className = classDeclaration.getSimpleName().toString();	66	String className = classDeclaration.getSimpleName().toString();
63		67
64	//ak ešte nebol definovaný koreňový uzol, tak ide o všeobecnú triedu	68	//ak ešte nebol definovaný koreňový uzol, tak ide o všeobecnú triedu
65	if (!sourceFile.isRootClassNodeInitialized()) {	69	if (!sourceFile.isRootClassNodeInitialized())
		70	{
66	String packageName;	71	String packageName;
67	try {	72	try
		73	{
68	packageName = compilationUnit.getPackageName().toString();	74	packageName = compilationUnit.getPackageName().toString();
69	} catch (NullPointerException e) {	75	}
		76	catch(NullPointerException e)
		77	{
70	packageName = "";	78	packageName = "";
71	}	79	}
72		80
73	sourceFile.addRootClassNode(className, startLine, endLine, column, packageName);	81	sourceFile.addRootClassNode(className, startLine, endLine, column, packageName);
74	} //inak ide o vnútornú triedu	82	}
75	else {	83
		84	//inak ide o vnútornú triedu
		85	else
76	sourceFile.addInnerClassNode(className, startLine, endLine, column);	86	sourceFile.addInnerClassNode(className, startLine, endLine, column);
77	}
78		87
79	System.out.println(this.compilationUnit.getSourceFile().getName());	88	// System.out.println(this.compilationUnit.getSourceFile().getName());
80	Iterator iterator = this.compilationUnit.docComments.keySet().iterator();	89	Iterator iterator =this.compilationUnit.docComments.keySet().iterator();
81	Map<JCTree, String> map;	90	Map<JCTree, String> map;
82	while (iterator.hasNext()) {	91	int i=0;
83	JCTree tree = (JCTree) iterator.next();	92	while(iterator.hasNext())
84	System.out.println("Start possition");	93	{
85	System.out.println(tree.getStartPosition());	94	JCTree tree= (JCTree)iterator.next();
86	map = this.compilationUnit.docComments;	95	System.out.println(i);
87	System.out.println("End possition");	96	i++;
88	System.out.println(tree.getStartPosition() + map.get(tree).length());	97	//System.out.println("Start possition");
89	sourceFile.addCommentNode(map.get(tree), tree.getStartPosition(), tree.getStartPosition() + map.get(tree).length(), 1);	98	// System.out.println(tree.getStartPosition());
		99	map =this.compilationUnit.docComments;
		100	// System.out.println("End possition");
		101	// System.out.println(tree.getStartPosition()+ map.get(tree).length());
		102	sourceFile.addCommentNode(map.get(tree), tree.getStartPosition(), tree.getStartPosition()+ map.get(tree).length(), 1);
90	}	103	}
91		104
92		105
93	return super.visitClass(classTree, arg);	106	return super.visitClass(classTree, arg);
94	}	107	}
95		108
96	/**	109	/**
97	* Prechod metódy, získanie informácií a uloženie informácií a štruktúry.	110	* Prechod metódy, získanie informácií a uloženie informácií a štruktúry.
98	* @param methodTree	111	* @param methodTree
...		...
100	* @return	113	* @return
101	*/	114	*/
102	@Override	115	@Override
103	public Void visitMethod(MethodTree methodTree, Void arg) {	116	public Void visitMethod(MethodTree methodTree, Void arg)
104	JCTree.JCMethodDecl methodDeclaration = (JCTree.JCMethodDecl) methodTree;	117	{
		118	JCTree.JCMethodDecl methodDeclaration = (JCTree.JCMethodDecl)methodTree;
105		119
106		120
107		121
...		...
110	int startLine = compilationUnit.getLineMap().getLineNumber(methodDeclaration.getStartPosition());	124	int startLine = compilationUnit.getLineMap().getLineNumber(methodDeclaration.getStartPosition());
111	int endLine = compilationUnit.getLineMap().getLineNumber(methodDeclaration.getEndPosition(compilationUnit.endPositions));	125	int endLine = compilationUnit.getLineMap().getLineNumber(methodDeclaration.getEndPosition(compilationUnit.endPositions));
112	int column;	126	int column;
113	try {	127	try
		128	{
114	column = compilationUnit.getLineMap().getColumnNumber(methodDeclaration.getStartPosition());	129	column = compilationUnit.getLineMap().getColumnNumber(methodDeclaration.getStartPosition());
115	} catch (Exception e) {
116	column = 0;
117	}	130	}
		131	catch (Exception e) { column = 0; }
118	String methodName = methodDeclaration.getName().toString();	132	String methodName = methodDeclaration.getName().toString();
119		133
120	sourceFile.addMethodNode(methodName, startLine, endLine, column);	134	sourceFile.addMethodNode(methodName, startLine, endLine, column);
121		135
122	return super.visitMethod(methodTree, arg);	136	return super.visitMethod(methodTree, arg);
123	}	137	}
124		138
125	/**	139	/**
126	* Prechod premennej, získanie informácií a uloženie informácií a štruktúry.	140	* Prechod premennej, získanie informácií a uloženie informácií a štruktúry.
127	* @param variableTree	141	* @param variableTree
...		...
129	* @return	143	* @return
130	*/	144	*/
131	@Override	145	@Override
132	public Void visitVariable(VariableTree variableTree, Void arg) {	146	public Void visitVariable(VariableTree variableTree, Void arg)
133	JCTree.JCVariableDecl variableDeclaration = (JCTree.JCVariableDecl) variableTree;	147	{
134		148	JCTree.JCVariableDecl variableDeclaration = (JCTree.JCVariableDecl)variableTree;
		149
135	int startLine = compilationUnit.getLineMap().getLineNumber(variableDeclaration.getStartPosition());	150	int startLine = compilationUnit.getLineMap().getLineNumber(variableDeclaration.getStartPosition());
136	int endLine = compilationUnit.getLineMap().getLineNumber(variableDeclaration.getEndPosition(compilationUnit.endPositions));	151	int endLine = compilationUnit.getLineMap().getLineNumber(variableDeclaration.getEndPosition(compilationUnit.endPositions));
137	int column;	152	int column;
138	try {	153	try
		154	{
139	column = compilationUnit.getLineMap().getColumnNumber(variableDeclaration.getStartPosition());	155	column = compilationUnit.getLineMap().getColumnNumber(variableDeclaration.getStartPosition());
140	} catch (Exception e) {
141	column = 0;
142	}	156	}
143		157	catch (Exception e) { column = 0; }
		158
144	String variableName = variableDeclaration.getName().toString();	159	String variableName = variableDeclaration.getName().toString();
145	String variableType = variableDeclaration.getType().toString();	160	String variableType = variableDeclaration.getType().toString();
146		161
147	sourceFile.addVariableNode(variableName, startLine, endLine, column, variableType);	162	sourceFile.addVariableNode(variableName, startLine, endLine, column, variableType);
148	return super.visitVariable(variableTree, arg);	163	return super.visitVariable(variableTree, arg);
149	}	164	}
150		165
151	public SourceFile getSourceFile() {	166	public SourceFile getSourceFile()
		167	{
152	return this.sourceFile;	168	return this.sourceFile;
153	}	169	}
		170
154	}	171	}

	7		8
8	*/	8	*/
9	public class NameProcessor	9	public class NameProcessor
10	{	10	{
11	public static List<String> splitWords(String name)	11	public static List<String> splitWords(String name)
12	{	12	{
13	List<String> list = new ArrayList<String>();	13	List<String> list = new ArrayList<String>();
14	if (name.equals(""))	14	if (name.equals(""))

	7		8
20	*/	20	*/
21	public class Project	21	public class Project
22	{	22	{
23	private String projectDirectory;	23	private String projectDirectory;
24	private WordNetControl wordNet;	24	private WordNetControl wordNet;
25		25
26	private SourceFile[] sourceFiles;	26	private SourceFile[] sourceFiles;

	7		8
12	*/	12	*/
13	public class RelatedWordsDatabase	13	public class RelatedWordsDatabase
14	{	14	{
15	/** mapa váh slov */	15	/** mapa váh slov */
16	private HashMap<String, Integer> wordsWeight;	16	private HashMap<String, Integer> wordsWeight;
17	/** mapa vzťahov príbuzných slov */	17	/** mapa vzťahov príbuzných slov */
18	private HashMap<String, String> wordsRelation;	18	private HashMap<String, String> wordsRelation;

	7		8
13	*/	13	*/
14	public class SourceFileSearchResult	14	public class SourceFileSearchResult
15	{	15	{
16	private String[] keyWords;	16	private String[] keyWords;
17	private KeyWordData[] keyWordsData;	17	private KeyWordData[] keyWordsData;
18	private SourceFile sourceFile;	18	private SourceFile sourceFile;
19		19

	7		8
10	*/	10	*/
11	public interface Weights	11	public interface Weights
12	{	12	{
13	int	13	int
14	SYNONYM = 1,	14	SYNONYM = 1,
15	HYPERNYM = 2,	15	HYPERNYM = 2,
16	HYPONYM = 2,	16	HYPONYM = 2,

	7		8
3	*/	3	*/
4	package analyzer.wordAnalysis;	4	package analyzer.wordAnalysis;
5		5
6
7	import edu.smu.tspell.wordnet.SynsetType;	6	import edu.smu.tspell.wordnet.SynsetType;
		7	import java.awt.Rectangle;
8	import java.util.ArrayList;	8	import java.util.ArrayList;
9	import java.util.HashSet;	9	import java.util.HashSet;
		10	import javax.swing.JProgressBar;
		11	import visualiser.NameAnalysisDialog;
10		12
11
12	/** Trieda pre filtrovanie zoznamu mien. Pri vytvorení nového filtra je filter prednastavený tak, aby každé slovo spĺňalo podmienku.	13	/** Trieda pre filtrovanie zoznamu mien. Pri vytvorení nového filtra je filter prednastavený tak, aby každé slovo spĺňalo podmienku.
13	* Po vytvorení nového filtra je potrebné definovať jeho obmedzujúce podmienky. Obmedzujúce podmienky môžu byť nasledovné:	14	* Po vytvorení nového filtra je potrebné definovať jeho obmedzujúce podmienky. Obmedzujúce podmienky môžu byť nasledovné:
14	* 1. minimálna dĺžka slova,	15	* 1. minimálna dĺžka slova,
...		...
38	/** Množina povolených slovných druhov pre slová nájdené v databáze. */	39	/** Množina povolených slovných druhov pre slová nájdené v databáze. */
39	private HashSet<String> allowedTypes;	40	private HashSet<String> allowedTypes;
40	private boolean comment = true;	41	private boolean comment = true;
		42	private boolean All;
		43	private boolean onlyComments;
		44	private boolean withoutComments;
41		45
42	/** Vytvorenie nového filtra s podmienkami definovanými tak, aby každé slovo prešlo filtrovaním. Následne je možné definovať obmedzujúce podmienky.	46	/** Vytvorenie nového filtra s podmienkami definovanými tak, aby každé slovo prešlo filtrovaním. Následne je možné definovať obmedzujúce podmienky.
43	* @param wordNet	47	* @param wordNet
...		...
58	* @return Zoznam slov zredukovaný o slová, ktoré neprešli filtráciou.	62	* @return Zoznam slov zredukovaný o slová, ktoré neprešli filtráciou.
59	*/	63	*/
60	public String[] filterWords(String[] words) {	64	public String[] filterWords(String[] words) {
		65
61	ArrayList<String> passedWordsList = new ArrayList<String>();	66	ArrayList<String> passedWordsList = new ArrayList<String>();
62	for (int i = 0; i < words.length; i++) {//System.out.println(i);	67	for (int i = 0; i < words.length; i++) {//System.out.println(i);
63	String word = words[i];	68	String word = words[i];
...		...
67	boolean isWordInDatabase = wordNet.isWordInDatabase(word);	72	boolean isWordInDatabase = wordNet.isWordInDatabase(word);
68		73
69	for (int j = 0; j < notAllowedWords.length; j++) {	74	for (int j = 0; j < notAllowedWords.length; j++) {
70	if (word.equals(notAllowedWords[j])) {	75	if (word.equals(notAllowedWords[j])\|\| word.startsWith("@")) {
71	passedWord = false;	76	passedWord = false;
72	break;	77	break;
73	}	78	}
...		...
115		120
116	return passedWords;	121	return passedWords;
117	}	122	}
		123	/** Vykonanie samotnej filtrácie nad určitým zoznamom slov.
		124	* @param words
		125	* @return Zoznam slov zredukovaný o slová, ktoré neprešli filtráciou.
		126	*/
		127	public String[] filterWords(String[] words, JProgressBar progressBar,int dictionaryNumber,int dictionaryCount) {
		128	long numberForOneDict = Math.round((double) (80/dictionaryCount));
		129	ArrayList<String> passedWordsList = new ArrayList<String>();
		130	double percent;
		131	int barNumber;
		132	for (int i = 0; i < words.length; i++) {//System.out.println(i);
		133	String word = words[i];
118		134
		135	percent = (((double)i / words.length)) ;
		136	barNumber = (int) Math.round(numberForOneDict * percent+ (dictionaryNumber*numberForOneDict));
		137	progressBar.setValue(barNumber);
		138	Rectangle progressRect = progressBar.getBounds();
		139	progressRect.x = 0;
		140	progressRect.y = 0;
		141	progressBar.paintImmediately(progressRect);
		142
		143
		144
		145
		146	boolean passedWord = true;
		147	int wordLength = word.length();
		148	if (wordLength >= minimumWordLength && wordLength <= maximumWordLength) {
		149	boolean isWordInDatabase = wordNet.isWordInDatabase(word);
		150
		151	for (int j = 0; j < notAllowedWords.length; j++) {
		152	if (word.equals(notAllowedWords[j])\|\| word.startsWith("@")) {
		153	passedWord = false;
		154	break;
		155	}
		156	}
		157
		158	if (!passedWord) {
		159	continue;
		160	}
		161
		162	if (isWordInDatabase && (!excludeFoundWords)) { //filtrovanie slov, ktoré sa našli v databáze
		163
		164	//vylúčenie nevhodných slovných druhov
		165	if (!allowedTypes.contains(wordNet.getType(word))) {
		166	continue;
		167	}
		168	if( !comment )
		169	{
		170	if((getCount(word,comment)==0))
		171	{
		172	continue;
		173	}
		174	}
		175	passedWordsList.add(word);
		176	} else if (!isWordInDatabase && !excludeNotFoundWords) {
		177
		178	if( !comment )
		179	{
		180	if((getCount(word,comment)==0))
		181	{
		182	continue;
		183	}
		184	}
		185
		186
		187
		188	passedWordsList.add(word);
		189	}
		190	}
		191	}
		192
		193	String[] passedWords = new String[passedWordsList.size()];
		194	for (int i = 0; i < passedWords.length; i++) {
		195	passedWords[i] = passedWordsList.get(i);
		196	}
		197
		198	return passedWords;
		199	}
119	/**	200	/**
120	* Pri začiatku nastavíme všetky slovné druhy ako platné.	201	* Pri začiatku nastavíme všetky slovné druhy ako platné.
121	*/	202	*/
...		...
202		283
203	private int getCount(String word,boolean filter) {	284	private int getCount(String word,boolean filter) {
204	int wordUsageCount = 0;	285	int wordUsageCount = 0;
205	//for (int j = 0; j < NameAnalysisDialog.getStatistics().getStatisticsForSourceFiles().length; j++) {	286	for (int j = 0; j < NameAnalysisDialog.getStatistics().getStatisticsForSourceFiles().length; j++) {
206	// wordUsageCount += NameAnalysisDialog.getStatistics().getStatisticsForSourceFiles()[j].getWordUsage(word,filter);	287	wordUsageCount += NameAnalysisDialog.getStatistics().getStatisticsForSourceFiles()[j].getWordUsage(word,filter);
207	// }	288	}
208	return wordUsageCount;	289	return wordUsageCount;
209		290
210		291
211	}	292	}
		293
		294	/**
		295	* @return the All
		296	*/
		297	public boolean isAll() {
		298	return All;
		299	}
		300
		301	/**
		302	* @param All the All to set
		303	*/
		304	public void setAll(boolean All) {
		305	this.All = All;
		306	}
		307
		308	/**
		309	* @return the onlyComments
		310	*/
		311	public boolean isOnlyComments() {
		312	return onlyComments;
		313	}
		314
		315	/**
		316	* @param onlyComments the onlyComments to set
		317	*/
		318	public void setOnlyComments(boolean onlyComments) {
		319	this.onlyComments = onlyComments;
		320	}
		321
		322	/**
		323	* @return the withoutComments
		324	*/
		325	public boolean isWithoutComments() {
		326	return withoutComments;
		327	}
		328
		329	/**
		330	* @param withoutComments the withoutComments to set
		331	*/
		332	public void setWithoutComments(boolean withoutComments) {
		333	this.withoutComments = withoutComments;
		334	}
212	}	335	}

	7		8
10	*/	10	*/
11	package analyzer.wordAnalysis;	11	package analyzer.wordAnalysis;
12		12
13	import edu.smu.tspell.wordnet.*;	13	import edu.smu.tspell.wordnet.*;
14	import edu.smu.tspell.wordnet.impl.file.DetachmentRules;	14	import edu.smu.tspell.wordnet.impl.file.DetachmentRules;
15	import java.util.*;	15	import java.util.*;
16		16

     /**
      * Pridanie nového uzla do tabuľky. Najprv sa získa meno uzla, meno sa rozdelí na slová. Tieto slová
      * sa uložia do tabuľky a ku každému slovu sa priradí daný uzol.
+     * PRIDAL SOM TRIM
      * @param node Uzol, ktorý má byť uložený do tabuľky.
      */
     public void addNodeToTable(Node node)
         String name = node.getName();
         List<String> words = NameProcessor.splitWords(name);
         for (String word : words)
-            addWordToTable(word.toLowerCase(), node);
+            addWordToTable(word.toLowerCase().trim(), node);
     }
     /**

DataPlugin

Affected files

src/analyzer/statistics/ProjectStatistics.java Download diff

src/analyzer/statistics/SourceFileStatistics.java Download diff

src/analyzer/Tools/Analyzer.java Download diff

src/analyzer/Tools/myXMLFile.xml

src/analyzer/Tools/Tools.java Download diff

src/analyzer/Tools/XMLReader.java

src/analyzer/treeModel/ClassNode.java Download diff

src/analyzer/treeModel/CommentNode.java Download diff

src/analyzer/treeModel/GeneralClassNode.java Download diff

src/analyzer/treeModel/InnerClassNode.java Download diff

src/analyzer/treeModel/MethodNode.java Download diff

src/analyzer/treeModel/Node.java Download diff

src/analyzer/treeModel/SourceFile.java Download diff

src/analyzer/treeModel/VariableNode.java Download diff

src/analyzer/treeScanner/MyTreeScanner.java Download diff

src/analyzer/wordAnalysis/KeyWordData.java Download diff

src/analyzer/wordAnalysis/NameProcessor.java Download diff

src/analyzer/wordAnalysis/Project.java Download diff

src/analyzer/wordAnalysis/RelatedWordsDatabase.java Download diff

src/analyzer/wordAnalysis/Rule.java

src/analyzer/wordAnalysis/SourceFileSearchResult.java Download diff

src/analyzer/wordAnalysis/Weights.java Download diff

src/analyzer/wordAnalysis/WordFilter.java Download diff

src/analyzer/wordAnalysis/WordNetControl.java Download diff

src/analyzer/wordAnalysis/WordsTable.java Download diff

	7		8
1	/*	1	/*
2	* Posledná revízia 2.4.2009	2	* Posledná revízia 2.4.2009
3	*/	3	*/
4
5	package analyzer.wordAnalysis;	4	package analyzer.wordAnalysis;
6		5
7	import edu.smu.tspell.wordnet.Synset;	6	import edu.smu.tspell.wordnet.Synset;
		7	import edu.smu.tspell.wordnet.SynsetType;
8		8
9	/**	9	/**
10	* Slúži pre vytvorenie databázy príbuzných slov pre 1 kľúčové slovo.	10	* Slúži pre vytvorenie databázy príbuzných slov pre 1 kľúčové slovo.
11	*	11	*
12	*/	12	*/
13	public class KeyWordData	13	public class KeyWordData {
14	{	14
15	/** kľúčové slovo */	15	/** kľúčové slovo */
16	private String keyWord;	16	private String keyWord;
17	/** filter príbuzných slov */	17	/** filter príbuzných slov */
18	private boolean[] searchFilter;	18	private boolean[] searchFilter;
19	/** databáza príbuzných slov */	19	/** databáza príbuzných slov */
20	private RelatedWordsDatabase relatedWords;	20	private RelatedWordsDatabase relatedWords;
21		21	//private String [] clazzNamewords;
22	private WordNetControl wordNet;	22	private WordNetControl wordNet;
23		23
24	/**	24	/**
25	*	25	*
26	* @param keyWord Kľúčové slovo.	26	* @param keyWord Kľúčové slovo.
27	* @param wordNet Objekt pre prístup ku funkciám slovníku wordnet.	27	* @param wordNet Objekt pre prístup ku funkciám slovníku wordnet.
28	*/	28	*/
29	public KeyWordData(String keyWord, boolean[] searchFilter, WordNetControl wordNet)	29	public KeyWordData(String keyWord, boolean[] searchFilter, WordNetControl wordNet) {
30	{
31	this.keyWord = keyWord;	30	this.keyWord = keyWord;
32	this.wordNet = wordNet;	31	this.wordNet = wordNet;
33	this.searchFilter = searchFilter;	32	this.searchFilter = searchFilter;
34	relatedWords = new RelatedWordsDatabase();	33	relatedWords = new RelatedWordsDatabase();
35		34
36	fillRelatedWordsDb();	35	fillRelatedWordsDb();
37	}	36	}
38		37
		38	public KeyWordData(String keyWord, String[] clazzNameWords, boolean[] searchFilter, WordNetControl wordNet) {
		39	this.keyWord = keyWord;
		40	this.wordNet = wordNet;
		41	this.searchFilter = searchFilter;
		42	relatedWords = new RelatedWordsDatabase();
		43
		44	fillRelatedWordsDb(clazzNameWords);
		45	}
		46
39	/**	47	/**
40	* Získanie kľúčového slova, ktoré reprezentuje tento objekt.	48	* Získanie kľúčového slova, ktoré reprezentuje tento objekt.
41	* @return Kľúčové slovo reprezentujúce tento objekt.	49	* @return Kľúčové slovo reprezentujúce tento objekt.
42	*/	50	*/
43	public String getKeyWord()	51	public String getKeyWord() {
44	{
45	return keyWord;	52	return keyWord;
46	}	53	}
47		54
48	/**	55	/**
49	* Zístenie váhy príbuzného slova vzhľadom ku kľúčovému slovu.	56	* Zístenie váhy príbuzného slova vzhľadom ku kľúčovému slovu.
50	* @param word Príbuzné slovo, pre ktoré chceme zistiť váhu.	57	* @param word Príbuzné slovo, pre ktoré chceme zistiť váhu.
51	* @return Váha príbuzného slova.	58	* @return Váha príbuzného slova.
52	*/	59	*/
53	public int getWeight(String word)	60	public int getWeight(String word) {
54	{
55	return relatedWords.getWeight(word);	61	return relatedWords.getWeight(word);
56	}	62	}
57		63
58	/**	64	/**
59	* Zistenie typu vzťahu medzi kľúčovým a príbuzným slovom.	65	* Zistenie typu vzťahu medzi kľúčovým a príbuzným slovom.
60	* @param word Príbuzné slovo, pre ktoré chceme zistiť typ vzťahu.	66	* @param word Príbuzné slovo, pre ktoré chceme zistiť typ vzťahu.
61	* @return Vzťah príbuzného slova ku kľúčovému slovu.	67	* @return Vzťah príbuzného slova ku kľúčovému slovu.
62	*/	68	*/
63	public String getRelation(String word)	69	public String getRelation(String word) {
64	{
65	return relatedWords.getRelation(word);	70	return relatedWords.getRelation(word);
66	}	71	}
67		72
68	/**	73	/**
69	* Získanie všetkých príbuzných slov ku kľúčovému slovu utriedených podľa váhy.	74	* Získanie všetkých príbuzných slov ku kľúčovému slovu utriedených podľa váhy.
70	* @return Príbuzné slová utriedené podľa váhy.	75	* @return Príbuzné slová utriedené podľa váhy.
71	*/	76	*/
72	public String[] getSortedRelatedWords()	77	public String[] getSortedRelatedWords() {
73	{
74	return relatedWords.getSortedWords();	78	return relatedWords.getSortedWords();
75	}	79	}
76		80
77	/**	81	/**
78	* Slúži pre naplnenie databázy príbuzných slov. Najprv sa získajú všetky významy(synsets) pomocou slovníka WordNet a následne sa hľadá pre každý význam množina príbuzných slov. Po získaní všetkých príbuzných slov sa tieto triedia na základe váhy od slov s najmenšou váhou po najväčšiu. (pozn. slová s najmenšou váhou sú najdôležitejšie)	82	* Slúži pre naplnenie databázy príbuzných slov. Najprv sa získajú všetky významy(synsets) pomocou slovníka WordNet a následne sa hľadá pre každý význam množina príbuzných slov. Po získaní všetkých príbuzných slov sa tieto triedia na základe váhy od slov s najmenšou váhou po najväčšiu. (pozn. slová s najmenšou váhou sú najdôležitejšie)
79	*/	83	*/
80	private void fillRelatedWordsDb()	84	private void fillRelatedWordsDb() {
81	{
82	Synset[] orderedSynsets = wordNet.getSynsetsSortedByTag(keyWord);	85	Synset[] orderedSynsets = wordNet.getSynsetsSortedByTag(keyWord);
83	for (int i = 0; i < orderedSynsets.length; i++)	86	for (int i = 0; i < orderedSynsets.length; i++) {
84	{
85	String[] words = wordNet.getRelatedWords(orderedSynsets[i], keyWord, searchFilter);	87	String[] words = wordNet.getRelatedWords(orderedSynsets[i], keyWord, searchFilter);
86	for (int j = 0; j < words.length; j = j+2)	88	for (int j = 0; j < words.length; j = j + 2) {
87	{
88	String word = words[j];	89	String word = words[j];
89	String relation = words[j+1];	90	String relation = words[j + 1];
90	int weight = calculateWeight(i, relation);	91	int weight = calculateWeight(i, relation);
91	relatedWords.addRelatedWord(word, relation, weight);	92	relatedWords.addRelatedWord(word, relation, weight);
92	}	93	}
93	}	94	}
94	relatedWords.sortDb();	95	relatedWords.sortDb();
95	}	96	}
96		97
97	/**	98	/**
98	* Slúži pre výpočet váhy slova. Váha slova sa vypočítava na základe 2 priorít:	99	* Slúži pre výpočet váhy slova. Váha slova sa vypočítava na základe 2 priorít:
99	* 1. dôležitosť významu, ku ktorému je slovo vo vzťahu. Dôležitejšie sú významy, v ktorých je kľúčové slovo častejšie používané.	100	* 1. dôležitosť významu, ku ktorému je slovo vo vzťahu. Dôležitejšie sú významy, v ktorých je kľúčové slovo častejšie používané.
...		...
102	* @param relation Typ vzťahu, v ktorom je príbuzné slovo ku kľúčovému.	103	* @param relation Typ vzťahu, v ktorom je príbuzné slovo ku kľúčovému.
103	* @return Vypočítaná váha pre slovo.	104	* @return Vypočítaná váha pre slovo.
104	*/	105	*/
105	private int calculateWeight(int synsetOrder, String relation)	106	private int calculateWeight(int synsetOrder, String relation) {
106	{
107	int synsetWeight, relationWeight;	107	int synsetWeight, relationWeight;
108	synsetWeight = (synsetOrder + 1) * Weights.SYNSETWEIGHTPOSITION;	108	synsetWeight = (synsetOrder + 1) * Weights.SYNSETWEIGHTPOSITION;
109		109
110	if (relation.equals("synonym"))	110	if (relation.equals("synonym")) {
111	relationWeight = Weights.SYNONYM;	111	relationWeight = Weights.SYNONYM;
112	else if (relation.equals("hypernym"))	112	} else if (relation.equals("hypernym")) {
113	relationWeight = Weights.HYPERNYM;	113	relationWeight = Weights.HYPERNYM;
114	else if (relation.equals("hyponym") \|\| relation.equals("instance hyponym"))	114	} else if (relation.equals("hyponym") \|\| relation.equals("instance hyponym")) {
115	relationWeight = Weights.HYPONYM;	115	relationWeight = Weights.HYPONYM;
116	else if (relation.equals("part holonym") \|\| relation.equals("member holonym"))	116	} else if (relation.equals("part holonym") \|\| relation.equals("member holonym")) {
117	relationWeight = Weights.HOLONYM;	117	relationWeight = Weights.HOLONYM;
118	else if (relation.equals("part meronym") \|\| relation.equals("member meronym"))	118	} else if (relation.equals("part meronym") \|\| relation.equals("member meronym")) {
119	relationWeight = Weights.MERONYM;	119	relationWeight = Weights.MERONYM;
120	else if (relation.equals("attribute"))	120	} else if (relation.equals("attribute")) {
121	relationWeight = Weights.ATTRIBUTE;	121	relationWeight = Weights.ATTRIBUTE;
122	else if (relation.equals("topic") \|\| relation.equals("topic member"))	122	} else if (relation.equals("topic") \|\| relation.equals("topic member")) {
123	relationWeight = Weights.TOPIC;	123	relationWeight = Weights.TOPIC;
124	else if (relation.equals("region") \|\| relation.equals("region member"))	124	} else if (relation.equals("region") \|\| relation.equals("region member")) {
125	relationWeight = Weights.REGION;	125	relationWeight = Weights.REGION;
126	else if (relation.equals("usage") \|\| relation.equals("usage member"))	126	} else if (relation.equals("usage") \|\| relation.equals("usage member")) {
127	relationWeight = Weights.USAGE;	127	relationWeight = Weights.USAGE;
128	else if (relation.equals("antonym"))	128	} else if (relation.equals("antonym")) {
129	relationWeight = Weights.ANTONYM;	129	relationWeight = Weights.ANTONYM;
130	else if (relation.equals("similar"))	130	} else if (relation.equals("similar")) {
131	relationWeight = Weights.SIMILAR;	131	relationWeight = Weights.SIMILAR;
132	else if (relation.equals("participle"))	132	} else if (relation.equals("participle")) {
133	relationWeight = Weights.PARTICIPLE;	133	relationWeight = Weights.PARTICIPLE;
134	else if (relation.equals("pertainym"))	134	} else if (relation.equals("pertainym")) {
135	relationWeight = Weights.PERTAINYM;	135	relationWeight = Weights.PERTAINYM;
136	else if (relation.equals("related"))	136	} else if (relation.equals("related")) {
137	relationWeight = Weights.RELATED;	137	relationWeight = Weights.RELATED;
138	else if (relation.equals("troponym"))	138	} else if (relation.equals("troponym")) {
139	relationWeight = Weights.TROPONYM;	139	relationWeight = Weights.TROPONYM;
140	else if (relation.equals("entailment"))	140	} else if (relation.equals("entailment")) {
141	relationWeight = Weights.ENTAILMENT;	141	relationWeight = Weights.ENTAILMENT;
142	else if (relation.equals("outcome"))	142	} else if (relation.equals("outcome")) {
143	relationWeight = Weights.OUTCOME;	143	relationWeight = Weights.OUTCOME;
144	else if (relation.equals("phrase"))	144	} else if (relation.equals("phrase")) {
145	relationWeight = Weights.PHRASE;	145	relationWeight = Weights.PHRASE;
146	else if (relation.equals("verb group"))	146	} else if (relation.equals("verb group")) {
147	relationWeight = Weights.VERBGROUP;	147	relationWeight = Weights.VERBGROUP;
148	else	148	} else {
149	relationWeight = 99;	149	relationWeight = 99;
150		150	}
		151
151	return synsetWeight + relationWeight;	152	return synsetWeight + relationWeight;
152	}	153	}
		154
		155	private void fillRelatedWordsDb(String[] clazzNameWords) {
		156	SynsetType syn;
		157	for (int k = 0; k < clazzNameWords.length; k++) {
		158
		159	Synset[] orderedSynsets = wordNet.getSynsetsSortedByTag(clazzNameWords[k]);
		160	for (int i = 0; i < orderedSynsets.length; i++) {
		161	String s = wordNet.getType(clazzNameWords[k]);
		162	syn = orderedSynsets[i].getType();
		163
		164	String[] words = wordNet.getRelatedWords(orderedSynsets[i], clazzNameWords[k], searchFilter);
		165	for (int j = 0; j < words.length; j = j + 2) {
		166	String word = words[j];
		167	String relation = words[j + 1];
		168	// int weight = calculateWeight(i, relation);
		169	relatedWords.addRelatedWord(word, relation, i + 1);
		170	}
		171	}
		172	}
		173	relatedWords.sortDb();
		174	System.out.println("");
		175	}
153	}	176	}