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 implements Comparable<DataFormatEntry>{ 009 /** Column position from 0 to n-1, where n is number of columns in the data format. */ 010 private int position; 011 /** Column name */ 012 private String dataFormatEntryName; 013 /** Column category (INPUT, HEAD or OUTPUT) */ 014 private String category; 015 /** Column type (STRING, INTEGER, BOOLEAN, ECHO or IGNORE) */ 016 private String type; 017 /** Default output for a ignore column */ 018 private String defaultOutput; 019 /** Cache the hash code for the data format entry */ 020 private int cachedHash; 021 /** 022 * Creates a data format entry 023 * 024 * @param position column position 025 * @param dataFormatEntryName column name 026 * @param category column category 027 * @param type column type 028 * @param defaultOutput default output for a ignore column 029 */ 030 public DataFormatEntry(int position, String dataFormatEntryName, String category, String type, String defaultOutput) { 031 setPosition(position); 032 setDataFormatEntryName(dataFormatEntryName); 033 setCategory(category); 034 setType(type); 035 setDefaultOutput(defaultOutput); 036 } 037 038 /** 039 * Returns the column position 040 * 041 * @return the column position 042 */ 043 public int getPosition() { 044 return position; 045 } 046 047 /** 048 * Sets the column position 049 * 050 * @param position column position 051 */ 052 public void setPosition(int position) { 053 this.position = position; 054 } 055 056 /** 057 * Returns the column name 058 * @return the column name 059 */ 060 public String getDataFormatEntryName() { 061 return dataFormatEntryName; 062 } 063 064 /** 065 * Sets the column name 066 * @param dataFormatEntryName column name 067 */ 068 public void setDataFormatEntryName(String dataFormatEntryName) { 069 this.dataFormatEntryName = dataFormatEntryName.toUpperCase(); 070 } 071 072 /** 073 * Returns the column category 074 * 075 * @return the column category 076 */ 077 public String getCategory() { 078 return category; 079 } 080 081 /** 082 * Sets the column category 083 * 084 * @param category the column category 085 */ 086 public void setCategory(String category) { 087 this.category = category.toUpperCase(); 088 } 089 090 /** 091 * Return the column type 092 * 093 * @return the column type 094 */ 095 public String getType() { 096 return type; 097 } 098 099 /** 100 * Sets the column type 101 * 102 * @param type the column type 103 */ 104 public void setType(String type) { 105 this.type = type.toUpperCase(); 106 } 107 108 /* (non-Javadoc) 109 * @see java.lang.Comparable#compareTo(java.lang.Object) 110 */ 111 public int compareTo(DataFormatEntry obj) { 112 if (this.position == obj.position) { 113 return 0; 114 } else if (this.position < obj.position) { 115 return -1; 116 } else { 117 return 1; 118 } 119 } 120 121 /** 122 * Returns the default output of an ignore column 123 * 124 * @return the default output of an ignore column 125 */ 126 public String getDefaultOutput() { 127 return defaultOutput; 128 } 129 130 /** 131 * Sets the default output of an ignore column 132 * 133 * @param defaultOutput the default output of an ignore column 134 */ 135 public void setDefaultOutput(String defaultOutput) { 136 this.defaultOutput = defaultOutput; 137 } 138 139 public boolean equals(Object obj) { 140 if (this == obj) 141 return true; 142 if (obj == null) 143 return false; 144 if (getClass() != obj.getClass()) 145 return false; 146 DataFormatEntry objC = (DataFormatEntry)obj; 147 return ((dataFormatEntryName == null) ? objC.dataFormatEntryName == null : dataFormatEntryName.equals(objC.dataFormatEntryName)) && 148 ((type == null) ? objC.type == null : type.equals(objC.type)) && 149 ((category == null) ? objC.category == null : category.equals(objC.category)) && 150 ((defaultOutput == null) ? objC.defaultOutput == null : defaultOutput.equals(objC.defaultOutput)); 151 } 152 153 public int hashCode() { 154 if (cachedHash == 0) { 155 int hash = 7; 156 hash = 31 * hash + (null == dataFormatEntryName ? 0 : dataFormatEntryName.hashCode()); 157 hash = 31 * hash + (null == type ? 0 : type.hashCode()); 158 hash = 31 * hash + (null == category ? 0 : category.hashCode()); 159 hash = 31 * hash + (null == defaultOutput ? 0 : defaultOutput.hashCode()); 160 cachedHash = hash; 161 } 162 return cachedHash; 163 } 164 165 public String toString() { 166 final StringBuilder sb = new StringBuilder(); 167 sb.append(position); 168 sb.append("\t"); 169 sb.append(dataFormatEntryName); 170 sb.append("\t"); 171 sb.append(category); 172 sb.append("\t"); 173 sb.append(type); 174 if (defaultOutput != null) { 175 sb.append("\t"); 176 sb.append(defaultOutput); 177 } 178 return sb.toString(); 179 } 180 }