001    package org.maltparser.core.io.dataformat;
002    /**
003     *  DataFormatEntry is used for storing information about one column in a data format. 
004     *
005     * @author Johan Hall
006     * @since 1.0
007    **/
008    public class DataFormatEntry {
009            /** Column name */
010            private String dataFormatEntryName;
011            /** Column category (INPUT, HEAD, DEPENDENCY_EDGE_LABEL, PHRASE_STRUCTURE_EDGE_LABEL, PHRASE_STRUCTURE_NODE_LABEL, SECONDARY_EDGE_LABEL, IGNORE and INTERNAL) */
012            private String category;
013            /** Column type (STRING, INTEGER, BOOLEAN, REAL) */
014            private String type;
015            /** Default output for a ignore column */
016            private String defaultOutput;
017            /** Cache the hash code for the data format entry */
018            private int cachedHash;
019            /**
020             * Creates a data format entry
021             * 
022             * @param dataFormatEntryName column name
023             * @param category      column category
024             * @param type  column type
025             * @param defaultOutput default output for a ignore column
026             */
027            public DataFormatEntry(String dataFormatEntryName, String category, String type, String defaultOutput) {
028                    setDataFormatEntryName(dataFormatEntryName);
029                    setCategory(category);
030                    setType(type);
031                    setDefaultOutput(defaultOutput);
032            }
033    
034            /**
035             * Returns the column name
036             * @return      the column name
037             */
038            public String getDataFormatEntryName() {
039                    return dataFormatEntryName;
040            }
041    
042            /**
043             * Sets the column name
044             * @param dataFormatEntryName   column name
045             */
046            public void setDataFormatEntryName(String dataFormatEntryName) {
047                    this.dataFormatEntryName = dataFormatEntryName.toUpperCase();
048            }
049    
050            /**
051             * Returns the column category
052             * 
053             * @return      the column category
054             */
055            public String getCategory() {
056                    return category;
057            }
058    
059            /**
060             * Sets the column category
061             * 
062             * @param category      the column category
063             */
064            public void setCategory(String category) {
065                    this.category = category.toUpperCase();
066            }
067    
068            /**
069             * Return the column type
070             * 
071             * @return      the column type
072             */
073            public String getType() {
074                    return type;
075            }
076    
077            /**
078             * Sets the column type
079             * 
080             * @param type  the column type
081             */
082            public void setType(String type) {
083                    this.type = type.toUpperCase();
084            }
085    
086            /**
087             * Returns the default output of an ignore column
088             * 
089             * @return the default output of an ignore column
090             */
091            public String getDefaultOutput() {
092                    return defaultOutput;
093            }
094    
095            /**
096             * Sets the default output of an ignore column
097             * 
098             * @param defaultOutput  the default output of an ignore column
099             */
100            public void setDefaultOutput(String defaultOutput) {
101                    this.defaultOutput = defaultOutput;
102            }
103            
104            public boolean equals(Object obj) {
105                    if (this == obj)
106                            return true;
107                    if (obj == null)
108                            return false;
109                    if (getClass() != obj.getClass())
110                            return false;
111                    DataFormatEntry objC = (DataFormatEntry)obj;
112                    return ((dataFormatEntryName == null) ? objC.dataFormatEntryName == null : dataFormatEntryName.equals(objC.dataFormatEntryName)) &&
113                                    ((type == null) ? objC.type == null : type.equals(objC.type)) &&
114                                    ((category == null) ? objC.category == null : category.equals(objC.category)) && 
115                                    ((defaultOutput == null) ? objC.defaultOutput == null : defaultOutput.equals(objC.defaultOutput));
116            }
117    
118            public int hashCode() {
119                    if (cachedHash == 0) {
120                            int hash = 7;
121                            hash = 31 * hash + (null == dataFormatEntryName ? 0 : dataFormatEntryName.hashCode());
122                            hash = 31 * hash + (null == type ? 0 : type.hashCode());
123                            hash = 31 * hash + (null == category ? 0 : category.hashCode());
124                            hash = 31 * hash + (null == defaultOutput ? 0 : defaultOutput.hashCode());
125                            cachedHash = hash;
126                    }
127                    return cachedHash;
128            }
129            
130            public String toString() {
131                    final StringBuilder sb = new StringBuilder();
132                    sb.append(dataFormatEntryName);
133                    sb.append("\t");
134                    sb.append(category);
135                    sb.append("\t");
136                    sb.append(type);
137                    if (defaultOutput != null) {
138                            sb.append("\t");
139                            sb.append(defaultOutput);
140                    }
141                    return sb.toString();
142            }
143    }