    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    }