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
 
 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  
 }