Coverage Report

Coverage Report - de.glossmaker.bib.datastructure.BibItems

Classes in this File

Line Coverage

Branch Coverage

Complexity

BibItems

95%

145/152

93%

57/61

3,158

BibItems$1

100%

1/1

N/A

3,158

 package de.glossmaker.bib.datastructure;
 
 import java.io.BufferedReader;
 import java.io.FileInputStream;
 import java.io.FileNotFoundException;
 import java.io.FileOutputStream;
 import java.io.IOException;
 import java.io.InputStreamReader;
 import java.io.OutputStreamWriter;
 import java.util.ArrayList;
 import java.util.StringTokenizer;
 import java.util.TreeSet;
 import java.util.regex.Matcher;
 import java.util.regex.Pattern;
 
 import org.apache.log4j.Logger;
 
 import de.glossmaker.common.io.UnicodeInputStream;
 import de.glossmaker.gloss.datastructure.IItem;
 import de.glossmaker.gloss.datastructure.IItems;
 
 /**
  * 
  * @author Markus Flingelli
  *
  */
 public class BibItems implements IItems {
         private static final Logger mLogger = Logger.getLogger(BibItems.class);
         private static final String ISO_8859_1_ENCODING = "ISO-8859-1";
         private TreeSet<IItem> mBibItems = null;
         private String mFileName = null;
         private String mFileEncoding;
         
         public BibItems() {
                 mBibItems = new TreeSet<IItem>();
                 mFileEncoding = "ISO-8859-1";
         }
         
         /**
          * If the fileName not equals null then the file will be read.
          * @param fileName File name
          */
         public BibItems(String fileName) {
                 this();
                 if (fileName != null) {
                         readFromFile(fileName);
                 }
         }
         
         @Override
         public void clear() {
                 mBibItems.clear();
         }
 
         @Override
         public int size() {
                 return mBibItems.size();
         }
 
         @Override
         public IItem getItem(int index) {
                 IItem result = null;
                 int i = 0;
                 for(IItem item : mBibItems) {
                         result = item;
                         i++;
                         if (i > index) {
                                 break;
                         }
                 }
                 return result;
         }
 
         @Override
         public boolean add(IItem item) {
                 return mBibItems.add(item);
         }
 
         @Override
         public boolean remove(IItem item) {
                 if (item != null) {
                         return mBibItems.remove(item);
                 } else {
                         return false;
                 }
         }
         
         private String getValue(String key, String zeile) {
                 String result = null;
                 Pattern p = null;
                 Matcher m = null;
                 p = Pattern.compile(key + "[ |\t]*=[ |\t]*[{](.*)[}]");
             m = p.matcher(zeile);
             if (m.find()) {
                     result = m.group(1);
                     result = result.substring(0, result.length()).trim();
             }
                 return result;
         }
         
         private String getKeyValue(String bibType, String zeile) {
                 Pattern p = null;
                 Matcher m = null;
                 String result = null;
                 String pattern = "";
                 for(int i = 0; i < bibType.length(); i++) {
                         pattern += "[" +
                                 Character.toLowerCase(bibType.charAt(i)) + "|" + 
                                 Character.toUpperCase(bibType.charAt(i)) + "|" +
                                 "]";
                 }
                 p = Pattern.compile("^" + pattern + "[ |\t]*\\{([^,.]*)[,]");
             m = p.matcher(zeile);
             if (m.find()) {
                     result = m.group(1);
             }
             
             return result;
         }
         
         private void addItems(StringBuffer buffer) {
                 String key = null;
                 String value = null;
                 StringTokenizer st = new StringTokenizer(buffer.toString(), "@");          
             while (st.hasMoreTokens()) { 
                     String zeile = st.nextToken();         
                     for(EBibTeXReference reference : EBibTeXReference.values()) {
                             key = getKeyValue(reference.toString(), zeile);
                             if (key != null) {
                                     ABibItem item = null;
                                     switch(reference) {
                                     case ARTICLE:
                                             item = new Article(key, reference);
                                             break;
                                     case BOOK:
                                             item = new Book(key, reference);
                                             break;
                                     case BOOKLET:
                                             item = new Booklet(key, reference);
                                             break;
                                     case CONFERENCE:
                                             item = new Conference(key, reference);
                                             break;
                                     case INBOOK:
                                             item = new InBook(key, reference);
                                             break;
                                     case INCOLLECTION:
                                             item = new InCollection(key, reference);
                                             break;
                                     case INPROCEEDINGS:
                                             item = new InProceedings(key, reference);
                                             break;
                                     case MANUAL:
                                             item = new Manual(key, reference);
                                             break;
                                     case MASTERSTHESIS:
                                             item = new Mastersthesis(key, reference);
                                             break;
                                     case MISC:
                                             item = new Misc(key, reference);
                                             break;
                                     case PHDTHESIS:
                                             item = new Phdthesis(key, reference);
                                             break;
                                     case PROCEEDINGS:
                                             item = new Proceedings(key, reference);
                                             break;
                                     case TECHREPORT:
                                             item = new TechReport(key, reference);
                                             break;
                                     case UNPUBLISHED:
                                             item = new Unpublished(key, reference);
                                     }
                                     
                                     for(EBibTeXFields field : EBibTeXFields.values()) {
                                             value = getValue(field.toString().toLowerCase(), zeile);
                                             if (value != null) {
                                                     item.setItem(field, value);
                                             }
                                     }
                                     mBibItems.add(item);
                             }
                     }                            
             }
         }
 
         @Override
         public StringBuffer readFromFile(String fileName) {
                 mBibItems.clear();
                 FileInputStream fis = null; 
                 try {
                         fis = new FileInputStream(fileName);
                         UnicodeInputStream uis = new UnicodeInputStream(fis, ISO_8859_1_ENCODING);
                         mFileEncoding = uis.getEncoding();
                 } catch (FileNotFoundException e) {
                         mLogger.error(e);
                 }
                 StringBuffer result = new StringBuffer();
                 try {
                         BufferedReader in = new BufferedReader(new InputStreamReader(
                                         new FileInputStream(fileName), mFileEncoding));
                         String zeile = null;
                         while ((zeile = in.readLine()) != null) {
                                 result.append(zeile);
                                 result.append(System.getProperty("line.separator"));
                         }
                         in.close();
                         mFileName = fileName;
                 } catch (IOException e) {
                         mLogger.error(e);
                 }
                 addItems(result);
 
                 return result;
         }
 
         @Override
         public void writeToFile(String fileName) {
                 try {
                         FileOutputStream fileOutputStream = new FileOutputStream(fileName);
                         OutputStreamWriter out = new OutputStreamWriter(fileOutputStream, mFileEncoding);
                         for(IItem item : mBibItems) {
                                 out.append(item.toString() + "\n");
                         }
                         out.close();
                 } catch (IOException e){
                         mLogger.error(e);
                 }
         }
 
         public IItem getItem(String key) {
                 IItem result = null;
                 for(IItem item : mBibItems) {
                         if (item.getKey().equals(key)) {
                                 result = item;
                                 break;
                         }
                 }
                 
                 return result;
         }
         
         public int count(EBibTeXReference reference) {
                 int result = 0;
                 for(IItem item : mBibItems) {
                         ABibItem bibItem = (ABibItem) item;
                         if (bibItem.getBibTeXReference() == reference) {
                                 result++;
                         }
                 }
                 
                 return result;
         }
         
         public ArrayList<IItem> getItems(EBibTeXReference reference) {
                 ArrayList<IItem> result = new ArrayList<IItem>();
                 for(IItem item : mBibItems) {
                         ABibItem bibItem = (ABibItem) item;
                         if (bibItem.getBibTeXReference() == reference) {
                                 result.add(bibItem);
                         }
                 }
                 
                 return result;
         }
         
         public boolean existsKey(String key) {
                 boolean result = false;
                 for(IItem item : mBibItems) {
                         result = item.getKey().equals(key);
                         if (result == true) {
                                 break;
                         }
                 }
                 
                 return result;
         }
         
         public void save() {
                 if (mFileName != null) {
                         writeToFile(mFileName);
                 }
         }
         
         public String getFileName() {
                 return mFileName;
         }
         
         public void setFileName(String fileName) {
                 mFileName = fileName;
         }
 }

1		package de.glossmaker.bib.datastructure;
2
3		import java.io.BufferedReader;
4		import java.io.FileInputStream;
5		import java.io.FileNotFoundException;
6		import java.io.FileOutputStream;
7		import java.io.IOException;
8		import java.io.InputStreamReader;
9		import java.io.OutputStreamWriter;
10		import java.util.ArrayList;
11		import java.util.StringTokenizer;
12		import java.util.TreeSet;
13		import java.util.regex.Matcher;
14		import java.util.regex.Pattern;
15
16		import org.apache.log4j.Logger;
17
18		import de.glossmaker.common.io.UnicodeInputStream;
19		import de.glossmaker.gloss.datastructure.IItem;
20		import de.glossmaker.gloss.datastructure.IItems;
21
22		/**
23		*
24		* @author Markus Flingelli
25		*
26		*/
27		public class BibItems implements IItems {
28	5	private static final Logger mLogger = Logger.getLogger(BibItems.class);
29		private static final String ISO_8859_1_ENCODING = "ISO-8859-1";
30	78	private TreeSet<IItem> mBibItems = null;
31	78	private String mFileName = null;
32		private String mFileEncoding;
33
34	78	public BibItems() {
35	78	mBibItems = new TreeSet<IItem>();
36	78	mFileEncoding = "ISO-8859-1";
37	78	}
38
39		/**
40		* If the fileName not equals null then the file will be read.
41		* @param fileName File name
42		*/
43		public BibItems(String fileName) {
44	1	this();
45	1	if (fileName != null) {
46	1	readFromFile(fileName);
47		}
48	1	}
49
50		@Override
51		public void clear() {
52	2	mBibItems.clear();
53	2	}
54
55		@Override
56		public int size() {
57	14	return mBibItems.size();
58		}
59
60		@Override
61		public IItem getItem(int index) {
62	8	IItem result = null;
63	8	int i = 0;
64	8	for(IItem item : mBibItems) {
65	8	result = item;
66	8	i++;
67	8	if (i > index) {
68	8	break;
69		}
70		}
71	8	return result;
72		}
73
74		@Override
75		public boolean add(IItem item) {
76	26	return mBibItems.add(item);
77		}
78
79		@Override
80		public boolean remove(IItem item) {
81	3	if (item != null) {
82	2	return mBibItems.remove(item);
83		} else {
84	1	return false;
85		}
86		}
87
88		private String getValue(String key, String zeile) {
89	20358	String result = null;
90	20358	Pattern p = null;
91	20358	Matcher m = null;
92	20358	p = Pattern.compile(key + "[ \|\t]=[ \|\t][{](.*)[}]");
93	20358	m = p.matcher(zeile);
94	20358	if (m.find()) {
95	7202	result = m.group(1);
96	7202	result = result.substring(0, result.length()).trim();
97		}
98	20358	return result;
99		}
100
101		private String getKeyValue(String bibType, String zeile) {
102	9828	Pattern p = null;
103	9828	Matcher m = null;
104	9828	String result = null;
105	9828	String pattern = "";
106	96174	for(int i = 0; i < bibType.length(); i++) {
107	86346	pattern += "[" +
108		Character.toLowerCase(bibType.charAt(i)) + "\|" +
109		Character.toUpperCase(bibType.charAt(i)) + "\|" +
110		"]";
111		}
112	9828	p = Pattern.compile("^" + pattern + "[ \|\t]\\{([^,.])[,]");
113	9828	m = p.matcher(zeile);
114	9828	if (m.find()) {
115	702	result = m.group(1);
116		}
117
118	9828	return result;
119		}
120
121		private void addItems(StringBuffer buffer) {
122	51	String key = null;
123	51	String value = null;
124	51	StringTokenizer st = new StringTokenizer(buffer.toString(), "@");
125	753	while (st.hasMoreTokens()) {
126	702	String zeile = st.nextToken();
127	10530	for(EBibTeXReference reference : EBibTeXReference.values()) {
128	9828	key = getKeyValue(reference.toString(), zeile);
129	9828	if (key != null) {
130	702	ABibItem item = null;
131	702	switch(reference) {
132		case ARTICLE:
133	50	item = new Article(key, reference);
134	50	break;
135		case BOOK:
136	50	item = new Book(key, reference);
137	50	break;
138		case BOOKLET:
139	50	item = new Booklet(key, reference);
140	50	break;
141		case CONFERENCE:
142	50	item = new Conference(key, reference);
143	50	break;
144		case INBOOK:
145	50	item = new InBook(key, reference);
146	50	break;
147		case INCOLLECTION:
148	50	item = new InCollection(key, reference);
149	50	break;
150		case INPROCEEDINGS:
151	50	item = new InProceedings(key, reference);
152	50	break;
153		case MANUAL:
154	50	item = new Manual(key, reference);
155	50	break;
156		case MASTERSTHESIS:
157	50	item = new Mastersthesis(key, reference);
158	50	break;
159		case MISC:
160	52	item = new Misc(key, reference);
161	52	break;
162		case PHDTHESIS:
163	50	item = new Phdthesis(key, reference);
164	50	break;
165		case PROCEEDINGS:
166	50	item = new Proceedings(key, reference);
167	50	break;
168		case TECHREPORT:
169	50	item = new TechReport(key, reference);
170	50	break;
171		case UNPUBLISHED:
172	50	item = new Unpublished(key, reference);
173		}
174
175	21060	for(EBibTeXFields field : EBibTeXFields.values()) {
176	20358	value = getValue(field.toString().toLowerCase(), zeile);
177	20358	if (value != null) {
178	7202	item.setItem(field, value);
179		}
180		}
181	702	mBibItems.add(item);
182		}
183		}
184	702	}
185	51	}
186
187		@Override
188		public StringBuffer readFromFile(String fileName) {
189	51	mBibItems.clear();
190	51	FileInputStream fis = null;
191		try {
192	51	fis = new FileInputStream(fileName);
193	51	UnicodeInputStream uis = new UnicodeInputStream(fis, ISO_8859_1_ENCODING);
194	51	mFileEncoding = uis.getEncoding();
195	0	} catch (FileNotFoundException e) {
196	0	mLogger.error(e);
197	51	}
198	51	StringBuffer result = new StringBuffer();
199		try {
200	51	BufferedReader in = new BufferedReader(new InputStreamReader(
201		new FileInputStream(fileName), mFileEncoding));
202	51	String zeile = null;
203	8657	while ((zeile = in.readLine()) != null) {
204	8606	result.append(zeile);
205	8606	result.append(System.getProperty("line.separator"));
206		}
207	51	in.close();
208	51	mFileName = fileName;
209	0	} catch (IOException e) {
210	0	mLogger.error(e);
211	51	}
212	51	addItems(result);
213
214	51	return result;
215		}
216
217		@Override
218		public void writeToFile(String fileName) {
219		try {
220	26	FileOutputStream fileOutputStream = new FileOutputStream(fileName);
221	25	OutputStreamWriter out = new OutputStreamWriter(fileOutputStream, mFileEncoding);
222	25	for(IItem item : mBibItems) {
223	350	out.append(item.toString() + "\n");
224		}
225	25	out.close();
226	0	} catch (IOException e){
227	0	mLogger.error(e);
228	25	}
229	25	}
230
231		public IItem getItem(String key) {
232	18	IItem result = null;
233	18	for(IItem item : mBibItems) {
234	144	if (item.getKey().equals(key)) {
235	17	result = item;
236	17	break;
237		}
238		}
239
240	18	return result;
241		}
242
243		public int count(EBibTeXReference reference) {
244	14	int result = 0;
245	14	for(IItem item : mBibItems) {
246	196	ABibItem bibItem = (ABibItem) item;
247	196	if (bibItem.getBibTeXReference() == reference) {
248	14	result++;
249		}
250	196	}
251
252	14	return result;
253		}
254
255		public ArrayList<IItem> getItems(EBibTeXReference reference) {
256	14	ArrayList<IItem> result = new ArrayList<IItem>();
257	14	for(IItem item : mBibItems) {
258	196	ABibItem bibItem = (ABibItem) item;
259	196	if (bibItem.getBibTeXReference() == reference) {
260	14	result.add(bibItem);
261		}
262	196	}
263
264	14	return result;
265		}
266
267		public boolean existsKey(String key) {
268	2	boolean result = false;
269	2	for(IItem item : mBibItems) {
270	24	result = item.getKey().equals(key);
271	24	if (result == true) {
272	1	break;
273		}
274		}
275
276	2	return result;
277		}
278
279		public void save() {
280	1	if (mFileName != null) {
281	0	writeToFile(mFileName);
282		}
283	1	}
284
285		public String getFileName() {
286	1	return mFileName;
287		}
288
289		public void setFileName(String fileName) {
290	1	mFileName = fileName;
291	1	}
292		}