001    package org.maltparser.core.io.dataformat;
002    
003    import java.util.Iterator;
004    import java.util.Map;
005    import java.util.SortedMap;
006    import java.util.SortedSet;
007    import java.util.TreeMap;
008    import java.util.TreeSet;
009    
010    import org.maltparser.core.exception.MaltChainedException;
011    import org.maltparser.core.symbol.SymbolTable;
012    import org.maltparser.core.symbol.SymbolTableHandler;
013    
014    /**
015     *  
016     *
017     * @author Johan Hall
018     * @since 1.0
019    **/
020    public class DataFormatInstance implements Iterable<ColumnDescription> {
021            private final SortedSet<ColumnDescription> columnDescriptions;
022            private SortedMap<String,ColumnDescription> headColumnDescriptions;
023            private SortedMap<String,ColumnDescription> dependencyEdgeLabelColumnDescriptions;
024            private SortedMap<String,ColumnDescription> phraseStructureEdgeLabelColumnDescriptions;
025            private SortedMap<String,ColumnDescription> phraseStructureNodeLabelColumnDescriptions;
026            private SortedMap<String,ColumnDescription> secondaryEdgeLabelColumnDescriptions;
027            private SortedMap<String,ColumnDescription> inputColumnDescriptions;
028            private SortedMap<String,ColumnDescription> ignoreColumnDescriptions;
029            
030            private SortedSet<ColumnDescription> headColumnDescriptionSet;
031            private SortedSet<ColumnDescription> dependencyEdgeLabelColumnDescriptionSet;
032            private SortedSet<ColumnDescription> phraseStructureEdgeLabelColumnDescriptionSet;
033            private SortedSet<ColumnDescription> phraseStructureNodeLabelColumnDescriptionSet;
034            private SortedSet<ColumnDescription> secondaryEdgeLabelColumnDescriptionSet;
035            private SortedSet<ColumnDescription> inputColumnDescriptionSet;
036            private SortedSet<ColumnDescription> ignoreColumnDescriptionSet;
037            
038            private SortedMap<String,SymbolTable> dependencyEdgeLabelSymbolTables;
039            private SortedMap<String,SymbolTable> phraseStructureEdgeLabelSymbolTables;
040            private SortedMap<String,SymbolTable> phraseStructureNodeLabelSymbolTables;
041            private SortedMap<String,SymbolTable> secondaryEdgeLabelSymbolTables;
042            private SortedMap<String,SymbolTable> inputSymbolTables;
043            
044            // Internal
045            private SortedMap<String,ColumnDescription> internalColumnDescriptions;
046            private SortedSet<ColumnDescription> internalColumnDescriptionSet;
047            
048            private SymbolTableHandler symbolTables;
049            private DataFormatSpecification dataFormarSpec;
050            
051            public DataFormatInstance(Map<String, DataFormatEntry> entries, SymbolTableHandler symbolTables, String nullValueStrategy, DataFormatSpecification spec) throws MaltChainedException {
052                    columnDescriptions = new TreeSet<ColumnDescription>();
053                    this.symbolTables = symbolTables;
054                    createColumnDescriptions(entries, nullValueStrategy);
055                    setDataFormarSpec(spec);
056            }
057    
058            public ColumnDescription addInternalColumnDescription(String name, String category, String type,  String nullValueStrategy) throws MaltChainedException {
059                    if (internalColumnDescriptions == null) {
060                            internalColumnDescriptions = new TreeMap<String,ColumnDescription>();
061                            internalColumnDescriptionSet = new TreeSet<ColumnDescription>();
062                    }
063                    
064                    if (!internalColumnDescriptions.containsKey(name)) {
065                            ColumnDescription internalColumn = new ColumnDescription(name, category, type, "", symbolTables, nullValueStrategy, true);
066                            internalColumnDescriptions.put(name, internalColumn);
067                            internalColumnDescriptionSet.add(internalColumn);
068                            return internalColumn;
069                    } else {
070                            return internalColumnDescriptions.get(name);
071                    }
072                    
073                    
074            }
075            
076            public ColumnDescription addInternalColumnDescription(String name, ColumnDescription parentColumn) throws MaltChainedException {
077                    if (internalColumnDescriptions == null) {
078                            internalColumnDescriptions = new TreeMap<String,ColumnDescription>();
079                            internalColumnDescriptionSet = new TreeSet<ColumnDescription>();
080                    }
081                    
082                    if (!internalColumnDescriptions.containsKey(name)) {
083                            ColumnDescription internalColumn = new ColumnDescription(name, parentColumn.getCategory(), parentColumn.getType(), parentColumn.getDefaultOutput(), symbolTables, parentColumn.getNullValueStrategy(), true);
084                            internalColumnDescriptions.put(name, internalColumn);
085                            internalColumnDescriptionSet.add(internalColumn);
086                            return internalColumn;
087                    } else {
088                            return internalColumnDescriptions.get(name);
089                    }
090                    
091                    
092            }
093            
094            private void createColumnDescriptions(Map<String, DataFormatEntry> entries, String nullValueStrategy) throws MaltChainedException {
095                    for (DataFormatEntry entry : entries.values()) {
096                            columnDescriptions.add(new ColumnDescription(entry.getDataFormatEntryName(), entry.getCategory(), entry.getType(), entry.getDefaultOutput(), symbolTables, nullValueStrategy, false));
097                    }
098            }
099            
100            public ColumnDescription getColumnDescriptionByName(String name) {
101                    for (ColumnDescription column : columnDescriptions) {
102                            if (column.getName().equals(name)) {
103                                    return column;
104                            }
105                    }
106                    if (internalColumnDescriptionSet != null) {
107                            for (ColumnDescription internalColumn : internalColumnDescriptionSet) {
108                                    if (internalColumn.getName().equals(name)) {
109                                            return internalColumn;
110                                    }
111                            }
112                    }
113                    return null;
114            }
115    
116    //      public int getNumberOfColumnDescriptions() {
117    //              return columnDescriptions.size();
118    //      }
119            
120            public Iterator<ColumnDescription> iterator() {
121                    return columnDescriptions.iterator();
122            }
123            
124            public DataFormatSpecification getDataFormarSpec() {
125                    return dataFormarSpec;
126            }
127    
128            private void setDataFormarSpec(DataFormatSpecification dataFormarSpec) {
129                    this.dataFormarSpec = dataFormarSpec;
130            }
131    
132            protected void createHeadColumnDescriptions() {
133                    headColumnDescriptions = new TreeMap<String,ColumnDescription>();
134                    for (ColumnDescription column : columnDescriptions) {
135                            if (column.getCategory() == ColumnDescription.HEAD) {
136                                    headColumnDescriptions.put(column.getName(), column);
137                            }
138                    }
139            }
140            
141            public ColumnDescription getHeadColumnDescription() {
142                    if (headColumnDescriptions == null) {
143                            createHeadColumnDescriptions();
144                    }
145                    return headColumnDescriptions.get(headColumnDescriptions.firstKey());
146            }
147            
148            public SortedMap<String,ColumnDescription> getHeadColumnDescriptions() {
149                    if (headColumnDescriptions == null) {
150                            createHeadColumnDescriptions();
151                    }
152                    return headColumnDescriptions;
153            }
154            
155            protected void createDependencyEdgeLabelSymbolTables() {
156                    dependencyEdgeLabelSymbolTables = new TreeMap<String,SymbolTable>();
157                    for (ColumnDescription column : columnDescriptions) {
158                            if (column.getCategory() == ColumnDescription.DEPENDENCY_EDGE_LABEL) { 
159                                    dependencyEdgeLabelSymbolTables.put(column.getSymbolTable().getName(), column.getSymbolTable());
160                            }
161                    }
162            }
163            
164            public SortedMap<String,SymbolTable> getDependencyEdgeLabelSymbolTables() {
165                    if (dependencyEdgeLabelSymbolTables == null) {
166                            createDependencyEdgeLabelSymbolTables();
167                    }
168                    return dependencyEdgeLabelSymbolTables;
169            }
170            
171            protected void createDependencyEdgeLabelColumnDescriptions() {
172                    dependencyEdgeLabelColumnDescriptions = new TreeMap<String,ColumnDescription>();
173                    for (ColumnDescription column : columnDescriptions) {
174                            if (column.getCategory() == ColumnDescription.DEPENDENCY_EDGE_LABEL) { 
175                                    dependencyEdgeLabelColumnDescriptions.put(column.getName(), column);
176                            }
177                    }
178            }
179            
180            public SortedMap<String,ColumnDescription> getDependencyEdgeLabelColumnDescriptions() {
181                    if (dependencyEdgeLabelColumnDescriptions == null) {
182                            createDependencyEdgeLabelColumnDescriptions();
183                    }
184                    return dependencyEdgeLabelColumnDescriptions;
185            }
186    
187    
188            
189            protected void createPhraseStructureEdgeLabelSymbolTables() {
190                    phraseStructureEdgeLabelSymbolTables = new TreeMap<String, SymbolTable>();
191                    for (ColumnDescription column : columnDescriptions) {
192                            if (column.getCategory() == ColumnDescription.PHRASE_STRUCTURE_EDGE_LABEL) { 
193                                    phraseStructureEdgeLabelSymbolTables.put(column.getSymbolTable().getName(), column.getSymbolTable());
194                            }
195                    }
196            }
197            
198            public SortedMap<String,SymbolTable> getPhraseStructureEdgeLabelSymbolTables() {
199                    if (phraseStructureEdgeLabelSymbolTables == null) {
200                            createPhraseStructureEdgeLabelSymbolTables();
201                    }
202                    return phraseStructureEdgeLabelSymbolTables;
203            }
204            
205            protected void createPhraseStructureEdgeLabelColumnDescriptions() {
206                    phraseStructureEdgeLabelColumnDescriptions = new TreeMap<String,ColumnDescription>();
207                    for (ColumnDescription column : columnDescriptions) {
208                            if (column.getCategory() == ColumnDescription.PHRASE_STRUCTURE_EDGE_LABEL) {
209                                    phraseStructureEdgeLabelColumnDescriptions.put(column.getName(), column);
210                            }
211                    }
212            }
213            
214            public SortedMap<String,ColumnDescription> getPhraseStructureEdgeLabelColumnDescriptions() {
215                    if (phraseStructureEdgeLabelColumnDescriptions == null) {
216                            createPhraseStructureEdgeLabelColumnDescriptions();
217                    }
218                    return phraseStructureEdgeLabelColumnDescriptions;
219            }
220    
221            protected void createPhraseStructureNodeLabelSymbolTables() {
222                    phraseStructureNodeLabelSymbolTables = new TreeMap<String,SymbolTable>();
223                    for (ColumnDescription column : columnDescriptions) {
224                            if (column.getCategory() == ColumnDescription.PHRASE_STRUCTURE_NODE_LABEL) { 
225                                    phraseStructureNodeLabelSymbolTables.put(column.getSymbolTable().getName(), column.getSymbolTable());
226                            }
227                    }
228            }
229            
230            public SortedMap<String,SymbolTable> getPhraseStructureNodeLabelSymbolTables() {
231                    if (phraseStructureNodeLabelSymbolTables == null) {
232                            createPhraseStructureNodeLabelSymbolTables();
233                    }
234                    return phraseStructureNodeLabelSymbolTables;
235            }
236            
237            protected void createPhraseStructureNodeLabelColumnDescriptions() {
238                    phraseStructureNodeLabelColumnDescriptions = new TreeMap<String,ColumnDescription>();
239                    for (ColumnDescription column : columnDescriptions) {
240                            if (column.getCategory() == ColumnDescription.PHRASE_STRUCTURE_NODE_LABEL) { 
241                                    phraseStructureNodeLabelColumnDescriptions.put(column.getName(), column);
242                            }
243                    }
244            }
245            
246            public SortedMap<String,ColumnDescription> getPhraseStructureNodeLabelColumnDescriptions() {
247                    if (phraseStructureNodeLabelColumnDescriptions == null) {
248                            createPhraseStructureNodeLabelColumnDescriptions();
249                    }
250                    return phraseStructureNodeLabelColumnDescriptions;
251            }
252            
253            protected void createSecondaryEdgeLabelSymbolTables() {
254                    secondaryEdgeLabelSymbolTables = new TreeMap<String,SymbolTable>();
255                    for (ColumnDescription column : columnDescriptions) {
256                            if (column.getCategory() == ColumnDescription.PHRASE_STRUCTURE_EDGE_LABEL) { 
257                                    secondaryEdgeLabelSymbolTables.put(column.getSymbolTable().getName(), column.getSymbolTable());
258                            }
259                    }
260            }
261            
262            public SortedMap<String,SymbolTable> getSecondaryEdgeLabelSymbolTables() {
263                    if (secondaryEdgeLabelSymbolTables == null) {
264                            createSecondaryEdgeLabelSymbolTables();
265                    }
266                    return secondaryEdgeLabelSymbolTables;
267            }
268            
269            protected void createSecondaryEdgeLabelColumnDescriptions() {
270                    secondaryEdgeLabelColumnDescriptions = new TreeMap<String,ColumnDescription>();
271                    for (ColumnDescription column : columnDescriptions) {
272                            if (column.getCategory() == ColumnDescription.PHRASE_STRUCTURE_EDGE_LABEL) {  
273                                    secondaryEdgeLabelColumnDescriptions.put(column.getName(), column);
274                            }
275                    }
276            }
277            
278            public SortedMap<String,ColumnDescription> getSecondaryEdgeLabelColumnDescriptions() {
279                    if (secondaryEdgeLabelColumnDescriptions == null) {
280                            createSecondaryEdgeLabelColumnDescriptions();
281                    }
282                    return secondaryEdgeLabelColumnDescriptions;
283            }
284            
285            protected void createInputSymbolTables() {
286                    inputSymbolTables = new TreeMap<String,SymbolTable>();
287                    for (ColumnDescription column : columnDescriptions) {
288                            if (column.getCategory() == ColumnDescription.INPUT) { 
289                                    inputSymbolTables.put(column.getSymbolTable().getName(), column.getSymbolTable());
290                            }
291                    }
292            }
293            
294            public SortedMap<String,SymbolTable> getInputSymbolTables() {
295                    if (inputSymbolTables == null) {
296                            createInputSymbolTables();
297                    }
298                    return inputSymbolTables;
299            }
300            
301            protected void createInputColumnDescriptions() {
302                    inputColumnDescriptions = new TreeMap<String,ColumnDescription>();
303                    for (ColumnDescription column : columnDescriptions) {
304                            if (column.getCategory() == ColumnDescription.INPUT) { 
305                                    inputColumnDescriptions.put(column.getName(), column);
306                            }
307                    }
308            }
309            
310            public SortedMap<String,ColumnDescription> getInputColumnDescriptions() {
311                    if (inputColumnDescriptions == null) {
312                            createInputColumnDescriptions();
313                    }
314                    return inputColumnDescriptions;
315            }
316            
317            protected void createIgnoreColumnDescriptions() {
318                    ignoreColumnDescriptions = new TreeMap<String,ColumnDescription>();
319                    for (ColumnDescription column : columnDescriptions) {
320                            if (column.getCategory() == ColumnDescription.IGNORE) { 
321    //                      if (column.getType() == ColumnDescription.IGNORE) { 
322                                    ignoreColumnDescriptions.put(column.getName(), column);
323                            }
324                    }
325            }
326            
327            public SortedMap<String,ColumnDescription> getIgnoreColumnDescriptions() {
328                    if (ignoreColumnDescriptions == null) {
329                            createIgnoreColumnDescriptions();
330                    }
331                    return ignoreColumnDescriptions;
332            }
333            
334            public SortedSet<ColumnDescription> getHeadColumnDescriptionSet() {
335                    if (headColumnDescriptionSet == null) {
336                            headColumnDescriptionSet = new TreeSet<ColumnDescription>();
337                            for (ColumnDescription column : columnDescriptions) {
338                                    if (column.getCategory() == ColumnDescription.HEAD) { 
339                                            headColumnDescriptionSet.add(column);
340                                    }
341                            }
342                    }
343                    return headColumnDescriptionSet;
344            }
345            
346            public SortedSet<ColumnDescription> getDependencyEdgeLabelColumnDescriptionSet() {
347                    if (dependencyEdgeLabelColumnDescriptionSet == null) {
348                            dependencyEdgeLabelColumnDescriptionSet = new TreeSet<ColumnDescription>();
349                            for (ColumnDescription column : columnDescriptions) {
350                                    if (column.getCategory() == ColumnDescription.DEPENDENCY_EDGE_LABEL) { 
351                                            dependencyEdgeLabelColumnDescriptionSet.add(column);
352                                    }
353                            }
354                    }
355                    return dependencyEdgeLabelColumnDescriptionSet;
356            }
357            
358            public SortedSet<ColumnDescription> getPhraseStructureEdgeLabelColumnDescriptionSet() {
359                    if (phraseStructureEdgeLabelColumnDescriptionSet == null) {
360                            phraseStructureEdgeLabelColumnDescriptionSet = new TreeSet<ColumnDescription>();
361                            for (ColumnDescription column : columnDescriptions) {
362                                    if (column.getCategory() == ColumnDescription.PHRASE_STRUCTURE_EDGE_LABEL) {  
363                                            phraseStructureEdgeLabelColumnDescriptionSet.add(column);
364                                    }
365                            }
366                    }
367                    return phraseStructureEdgeLabelColumnDescriptionSet;
368            }
369            
370            public SortedSet<ColumnDescription> getPhraseStructureNodeLabelColumnDescriptionSet() {
371                    if (phraseStructureNodeLabelColumnDescriptionSet == null) {
372                            phraseStructureNodeLabelColumnDescriptionSet = new TreeSet<ColumnDescription>();
373                            for (ColumnDescription column : columnDescriptions) {
374                                    if (column.getCategory() == ColumnDescription.PHRASE_STRUCTURE_NODE_LABEL) { 
375                                            phraseStructureNodeLabelColumnDescriptionSet.add(column);
376                                    }
377                            }
378                    }
379                    return phraseStructureNodeLabelColumnDescriptionSet;
380            }
381            
382            public SortedSet<ColumnDescription> getSecondaryEdgeLabelColumnDescriptionSet() {
383                    if (secondaryEdgeLabelColumnDescriptionSet == null) {
384                            secondaryEdgeLabelColumnDescriptionSet = new TreeSet<ColumnDescription>();
385                            for (ColumnDescription column : columnDescriptions) {
386                                    if (column.getCategory() == ColumnDescription.SECONDARY_EDGE_LABEL) { 
387                                            secondaryEdgeLabelColumnDescriptionSet.add(column);
388                                    }
389                            }
390                    }
391                    return secondaryEdgeLabelColumnDescriptionSet;
392            }
393            
394            public SortedSet<ColumnDescription> getInputColumnDescriptionSet() {
395                    if (inputColumnDescriptionSet == null) {
396                            inputColumnDescriptionSet = new TreeSet<ColumnDescription>();
397                            for (ColumnDescription column : columnDescriptions) {
398                                    if (column.getCategory() == ColumnDescription.INPUT) { 
399                                            inputColumnDescriptionSet.add(column);
400                                    }
401                            }
402                    }
403                    return inputColumnDescriptionSet;
404            }
405            
406            public SortedSet<ColumnDescription> getIgnoreColumnDescriptionSet() {
407                    if (ignoreColumnDescriptionSet == null) {
408                            ignoreColumnDescriptionSet = new TreeSet<ColumnDescription>();
409                            for (ColumnDescription column : columnDescriptions) {
410                                    if (column.getCategory() == ColumnDescription.IGNORE) { 
411                                            ignoreColumnDescriptionSet.add(column);
412                                    }
413                            }
414                    }
415                    return ignoreColumnDescriptionSet;
416            }
417            
418            public SymbolTableHandler getSymbolTables() {
419                    return symbolTables;
420            }
421            
422            public String toString() {
423                    final StringBuilder sb = new StringBuilder();
424                    for (ColumnDescription column : columnDescriptions) {
425                            sb.append(column);
426                            sb.append('\n');
427                    }
428                    return sb.toString();
429            }
430    }