AsciiParser

java.lang.Object
- org.das2.qds.util.AsciiParser

```
public class AsciiParser
extends java.lang.Object
```
Class for reading ASCII tables into a QDataSet. This parses a file by breaking it up into records, and passing the record off to a delegate record parser. The record parser then breaks up the record into fields, and each field is parsed by a delegate field parser. Each column of the table has a Unit, field name, and field label associated with it. Examples of record parsers include DelimParser, which splits the record by a delimiter such as a tab or comma, RegexParser, which processes each record with a regular expression to get the fields, and FixedColumnsParser, which splits the record by character positions. Example of field parsers include DOUBLE_PARSER which parses the value as a double, and UNITS_PARSER, which uses the Unit attached to the column to interpret the value. When the first record with the correct number of fields is found but is not parseable, we look for field labels and units. The skipLines property tells the parser to skip a given number of header lines before attempting to parse the record. Also, commentPrefix identifies lines to be ignored. In either the header or in comments, we look for propertyPattern, and if a property is matched, then the builder property is set. Two Patterns are provided NAME_COLON_VALUE_PATTERN and NAME_EQUAL_VALUE_PATTERN for convenience. Adapted to QDataSet model, Jeremy, May 2007.

Nested Class Summary

Nested Classes
Modifier and Type	Class and Description
`class`	`AsciiParser.DelimParser` DelimParser splits the line on a regex (like "," or "\\s+") to create the fields.
`static interface`	`AsciiParser.FieldParser` A FieldParser takes character data and returns a number representing the data.
`class`	`AsciiParser.FixedColumnsParser` Record parser looks at fixed column positions for each record.
`static interface`	`AsciiParser.RecordParser`
`static class`	`AsciiParser.RegexParser` parser uses a regular expression to match each record.

Field Summary

Fields
Modifier and Type	Field and Description
`static java.lang.String`	`DELIM_COMMA`
`static java.lang.String`	`DELIM_TAB`
`static java.lang.String`	`DELIM_WHITESPACE`
`static AsciiParser.FieldParser`	`DOUBLE_PARSER` parses the field using Double.parseDouble, Java's double parser.
`AsciiParser.FieldParser`	`ENUMERATION_PARSER` uses the EnumerationUnits for the field to create a Datum.
`protected java.lang.String`	`headerDelimiter`
`static java.util.regex.Pattern`	`NAME_COLON_VALUE_PATTERN` pattern for name:value.
`static java.util.regex.Pattern`	`NAME_EQUAL_VALUE_PATTERN` pattern for name=value.
`static java.lang.String`	`PROP_HEADERDELIMITER`
`static java.lang.String`	`PROP_VALIDMAX`
`static java.lang.String`	`PROP_VALIDMIN`
`static java.lang.String`	`PROPERTY_FIELD_NAMES`
`static java.lang.String`	`PROPERTY_FIELD_PARSER`
`static java.lang.String`	`PROPERTY_FILE_HEADER`
`static java.lang.String`	`PROPERTY_FIRST_RECORD`
`static Units`	`UNIT_UTC` Convenient unit for parsing UTC times.
`AsciiParser.FieldParser`	`UNITS_PARSER` delegates to the unit object set for this field to parse the data.
`protected double`	`validMax`
`protected double`	`validMin`

Constructor Summary

Constructors
Constructor and Description

AsciiParser()
Creates a new instance.

Constructors
Constructor and Description
`AsciiParser()` Creates a new instance.

Method Summary

All Methods Static Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`void`	`addPropertyChangeListener(java.beans.PropertyChangeListener l)` Adds a PropertyChangeListener to the listener list.
`AsciiParser.DelimParser`	`getDelimParser(int fieldCount, java.lang.String delim)` provide more control to external codes by providing a way to assert that an N-column delim parser should be used.
`int`	`getFieldCount()` return the number of fields in each record.
`int`	`getFieldIndex(java.lang.String string)` returns the index of the field.
`java.lang.String[]`	`getFieldLabels()` return the labels found for each field.
`java.lang.String[]`	`getFieldNames()` return the name of each field.
`java.lang.String[]`	`getFieldUnits()` return the units that were associated with the field.
`double`	`getFillValue()` return the fillValue.
`java.lang.String`	`getHeaderDelimiter()` get the header delimiter
`AsciiParser.RecordParser`	`getRecordParser()` Getter for property recordParser.
`static java.lang.String`	`getRegexForFormat(java.lang.String format)` Convert FORTRAN (F77) style format to C-style format specifiers.
`AsciiParser.RegexParser`	`getRegexParser(java.lang.String regex)` return a regex parser for the given regular expression.
`AsciiParser.RegexParser`	`getRegexParserForFormat(java.lang.String format)` see `private TimeParser(String formatString, Map<String,FieldHandler> fieldHandlers)</tt>`, which is very similar. "%5d%5d%9f%s" "d5,d5,f9,a"
`java.util.Map<java.lang.String,java.lang.String>`	`getRichFields()` returns the high rank rich fields in a map from NAME to LABEL.
`Units`	`getUnits(int index)` Indexed getter for property units.
`double`	`getValidMax()` get the maximum value for any field.
`double`	`getValidMin()` get the minimum valid value for any field.
`AsciiParser.DelimParser`	`guessDelimParser(java.lang.String line)`
`AsciiParser.DelimParser`	`guessDelimParser(java.lang.String line, int lineNumber)` read in the first record, then guess the delimiter and possibly the column headers.
`static int`	`guessFieldCount(java.lang.String filename)` return the field count that would result in the largest number of records parsed.
`static int`	`guessLengthForFormat(java.lang.String format)` return the length of the format specifier.
`AsciiParser.DelimParser`	`guessSkipAndDelimParser(java.lang.String filename)` read in records, allowing for a header of non-records before guessing the delim parser.
`int`	`guessSkipLines(java.lang.String filename, AsciiParser.RecordParser recParser)` try to figure out how many lines to skip by looking for the line where the number of fields becomes stable.
`boolean`	`isHeader(int iline, java.lang.String lastLine, java.lang.String thisLine, int recCount)` returns true if the line is a header or comment.
`boolean`	`isIso8601Time(java.lang.String s)` quick-n-dirty check to see if a string appears to be an ISO8601 time.
`boolean`	`isKeepFileHeader()` Getter for property keepHeader.
`boolean`	`isRichHeader()` return true if the parsed file provided a rich ascii header.
`static boolean`	`isRichHeader(java.lang.String header)` return true if the header appears to contain JSON code which could be interpreted as a "Rich Header" (a.k.a.
`static AsciiParser`	`newParser(int fieldCount)` creates a parser with @param fieldCount fields, named "field0,...,fieldN"
`static AsciiParser`	`newParser(java.lang.String[] fieldNames)` creates a parser with the named fields.
`WritableDataSet`	`readFile(java.lang.String filename, ProgressMonitor mon)` Parse the file using the current settings.
`java.lang.String`	`readFirstParseableRecord(java.lang.String filename)` returns the first record that the record parser parses successfully.
`java.lang.String`	`readFirstRecord(java.io.BufferedReader reader)` return the first line of the freshly opened file.
`java.lang.String`	`readFirstRecord(java.lang.String filename)` return the first record that the parser would parse.
`WritableDataSet`	`readStream(java.io.Reader in, ProgressMonitor mon)` Parse the stream using the current settings.
`WritableDataSet`	`readStream(java.io.Reader in, java.lang.String firstRecord, ProgressMonitor mon)` read in the stream, including the first record if non-null.
`WritableDataSet`	`readString(java.lang.String str, ProgressMonitor mon)`
`void`	`removePropertyChangeListener(java.beans.PropertyChangeListener l)` Removes a PropertyChangeListener from the listener list.
`void`	`setCommentPrefix(java.lang.String comment)` Records starting with this are not processed as data, for example "#".
`AsciiParser.DelimParser`	`setDelimParser(java.io.Reader in, java.lang.String delimRegex)` The DelimParser splits each record into fields using a delimiter like "," or "\\s+".
`AsciiParser.DelimParser`	`setDelimParser(java.lang.String filename, java.lang.String delimRegex)` The DelimParser splits each record into fields using a delimiter like "," or "\\s+".
`AsciiParser.DelimParser`	`setDelimParser(java.lang.String line, java.lang.String delimRegex, int expectedColumnCount)` The DelimParser splits each record into fields using a delimiter like "," or "\\s+".
`void`	`setFieldParser(int field, AsciiParser.FieldParser fp)` set the special parser for a field.
`void`	`setFillValue(double fillValue)` numbers that parse to this value are considered to be fill.
`AsciiParser.FixedColumnsParser`	`setFixedColumnsParser(int[] columnOffsets, int[] columnWidths, AsciiParser.FieldParser[] parsers)` set the record parser to be a fixed columns parser
`AsciiParser.FixedColumnsParser`	`setFixedColumnsParser(java.io.Reader in, java.lang.String delim)` looks at the first line after skipping, and splits it to calculate where the columns are.
`AsciiParser.FixedColumnsParser`	`setFixedColumnsParser(java.lang.String filename, java.lang.String delim)` looks at the first line after skipping, and splits it to calculate where the columns are.
`void`	`setHeaderDelimiter(java.lang.String headerDelimiter)` set the delimiter which explicitly separates header from the data.
`void`	`setKeepFileHeader(boolean keepHeader)` Setter for property keepHeader.
`void`	`setPropertyPattern(java.util.regex.Pattern propertyPattern)` specify the Pattern used to recognize properties.
`void`	`setRecordCountLimit(int recordCountLimit)` limit the number of records read.
`void`	`setRecordParser(AsciiParser.RecordParser recordParser)` Setter for property recordParser.
`void`	`setRecordStart(int recordStart)` set the number of records to skip before accumulating the result.
`AsciiParser.RecordParser`	`setRegexParser(java.lang.String[] fieldNames)` The regex parser is a slow parser, but gives precise control.
`void`	`setSkipLines(int skipLines)` skip a number of lines before trying to parse anything.
`void`	`setUnits(int index, Units units)` Indexed setter for property units.
`void`	`setUnits(Units... u)` Set all the units at once.
`void`	`setValidMax(double validMax)` set the maximum value for any field.
`void`	`setValidMin(double validMin)` set the minimum valid value for any field.
`void`	`setWhereConstraint(java.lang.String sparm, java.lang.String op, java.lang.String sval)` allow constraint for where condition is true.

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

- Field Detail
  - NAME_COLON_VALUE_PATTERN
```
public static final java.util.regex.Pattern NAME_COLON_VALUE_PATTERN
```
    pattern for name:value.
  - NAME_EQUAL_VALUE_PATTERN
```
public static final java.util.regex.Pattern NAME_EQUAL_VALUE_PATTERN
```
    pattern for name=value.
  - PROPERTY_FIELD_NAMES
```
public static final java.lang.String PROPERTY_FIELD_NAMES
```
    See Also:
    
    Constant Field Values
  - PROPERTY_FILE_HEADER
```
public static final java.lang.String PROPERTY_FILE_HEADER
```
    See Also:
    
    Constant Field Values
  - PROPERTY_FIRST_RECORD
```
public static final java.lang.String PROPERTY_FIRST_RECORD
```
    See Also:
    
    Constant Field Values
  - PROPERTY_FIELD_PARSER
```
public static final java.lang.String PROPERTY_FIELD_PARSER
```
    See Also:
    
    Constant Field Values
  - DELIM_COMMA
```
public static final java.lang.String DELIM_COMMA
```
    See Also:
    
    Constant Field Values
  - DELIM_TAB
```
public static final java.lang.String DELIM_TAB
```
    See Also:
    
    Constant Field Values
  - DELIM_WHITESPACE
```
public static final java.lang.String DELIM_WHITESPACE
```
    See Also:
    
    Constant Field Values
  - UNIT_UTC
```
public static final Units UNIT_UTC
```
    Convenient unit for parsing UTC times.
  - headerDelimiter
```
protected java.lang.String headerDelimiter
```
  - PROP_HEADERDELIMITER
```
public static final java.lang.String PROP_HEADERDELIMITER
```
    See Also:
    
    Constant Field Values
  - DOUBLE_PARSER
```
public static final AsciiParser.FieldParser DOUBLE_PARSER
```
    parses the field using Double.parseDouble, Java's double parser.
  - UNITS_PARSER
```
public final AsciiParser.FieldParser UNITS_PARSER
```
    delegates to the unit object set for this field to parse the data.
  - ENUMERATION_PARSER
```
public final AsciiParser.FieldParser ENUMERATION_PARSER
```
    uses the EnumerationUnits for the field to create a Datum.
  - validMin
```
protected double validMin
```
  - PROP_VALIDMIN
```
public static final java.lang.String PROP_VALIDMIN
```
    See Also:
    
    Constant Field Values
  - validMax
```
protected double validMax
```
  - PROP_VALIDMAX
```
public static final java.lang.String PROP_VALIDMAX
```
    See Also:
    
    Constant Field Values
- Constructor Detail
  - AsciiParser
```
public AsciiParser()
```
    Creates a new instance. This is created and then configured before any files can be parsed.
- Method Detail
  - isHeader
```
public final boolean isHeader(int iline,
                              java.lang.String lastLine,
                              java.lang.String thisLine,
                              int recCount)
```
    returns true if the line is a header or comment.
    
    Parameters:
    
    iline - the line number in the file, starting with 0.
    
    lastLine - the last line read.
    
    thisLine - the line we are testing.
    
    recCount - the number of records successfully read.
    
    Returns:
    
    true if the line is a header line.
  - isIso8601Time
```
public final boolean isIso8601Time(java.lang.String s)
```
    quick-n-dirty check to see if a string appears to be an ISO8601 time. minimally 2000-002T00:00, but also 2000-01-01T00:00:00Z etc. Note that an external code may explicitly indicate that the field is a time, This is just to catch things that are obviously times.
    
    Parameters:
    
    s -
    
    Returns:
    
    true if this is clearly an ISO time.
  - readFirstRecord
```
public java.lang.String readFirstRecord(java.lang.String filename)
                                 throws java.io.IOException
```
    return the first record that the parser would parse. If skipLines is more than the total number of lines, or all lines are comments, then null is returned.
    
    Parameters:
    
    filename -
    
    Returns:
    
    the first line after skip lines and comment lines.
    
    Throws:
    
    java.io.IOException
  - readFirstRecord
```
public java.lang.String readFirstRecord(java.io.BufferedReader reader)
                                 throws java.io.IOException
```
    return the first line of the freshly opened file. The reader is closed.
    
    Parameters:
    
    reader -
    
    Returns:
    
    Throws:
    
    java.io.IOException
  - readFirstParseableRecord
```
public java.lang.String readFirstParseableRecord(java.lang.String filename)
                                          throws java.io.IOException
```
    returns the first record that the record parser parses successfully. The recordParser should be set and configured enough to identify the fields. If no records can be parsed, then null is returned. The first record should be in the first 1000 lines.
    
    Parameters:
    
    filename -
    
    Returns:
    
    the first parseable line, or null if no such line exists.
    
    Throws:
    
    java.io.IOException
  - guessSkipLines
```
public int guessSkipLines(java.lang.String filename,
                          AsciiParser.RecordParser recParser)
                   throws java.io.IOException
```
    try to figure out how many lines to skip by looking for the line where the number of fields becomes stable.
    
    Parameters:
    
    filename -
    
    recParser -
    
    Returns:
    
    Throws:
    
    java.io.IOException
  - guessSkipAndDelimParser
```
public AsciiParser.DelimParser guessSkipAndDelimParser(java.lang.String filename)
                                                throws java.io.IOException
```
    read in records, allowing for a header of non-records before guessing the delim parser. This will return a reference to the DelimParser and set skipLines. DelimParser header field is set as well. One must set the record parser explicitly.
    
    Parameters:
    
    filename -
    
    Returns:
    
    the record parser to use, or null if no records are found.
    
    Throws:
    
    java.io.IOException
  - guessDelimParser
```
public AsciiParser.DelimParser guessDelimParser(java.lang.String line)
                                         throws java.io.IOException
```
    Throws:
    
    java.io.IOException
  - guessDelimParser
```
public AsciiParser.DelimParser guessDelimParser(java.lang.String line,
                                                int lineNumber)
                                         throws java.io.IOException
```
    read in the first record, then guess the delimiter and possibly the column headers.
    
    Parameters:
    
    line - a single record to attempt parsing.
    
    lineNumber, - useful for debugging.
    
    Returns:
    
    RecordParser object that can be queried.
    
    Throws:
    
    java.io.IOException
  - setDelimParser
```
public AsciiParser.DelimParser setDelimParser(java.lang.String filename,
                                              java.lang.String delimRegex)
                                       throws java.io.IOException
```
    The DelimParser splits each record into fields using a delimiter like "," or "\\s+".
    
    Parameters:
    
    filename - filename to read in.
    
    delimRegex - the delimiter, such as "," or "\t" or "\s+"
    
    Returns:
    
    the record parser that will split each line into fields
    
    Throws:
    
    java.io.IOException
  - setDelimParser
```
public AsciiParser.DelimParser setDelimParser(java.lang.String line,
                                              java.lang.String delimRegex,
                                              int expectedColumnCount)
                                       throws java.io.IOException
```
    The DelimParser splits each record into fields using a delimiter like "," or "\\s+".
    
    Parameters:
    
    line - a single record to read
    
    delimRegex - the delimiter, such as "," or "\t" or "\s+"
    
    expectedColumnCount - -1 or the number of columns we expect to see.
    
    Returns:
    
    the record parser that will split each line into fields
    
    Throws:
    
    java.io.IOException
    
    java.lang.IllegalArgumentException - if the positive expectedColumnCount doesn't match the result.
  - setDelimParser
```
public AsciiParser.DelimParser setDelimParser(java.io.Reader in,
                                              java.lang.String delimRegex)
                                       throws java.io.IOException
```
    The DelimParser splits each record into fields using a delimiter like "," or "\\s+".
    
    Parameters:
    
    in -
    
    delimRegex - the delimiter, such as "," or "\t" or "\s+"
    
    Returns:
    
    the record parser that will split each line into fields
    
    Throws:
    
    java.io.IOException
  - setRegexParser
```
public final AsciiParser.RecordParser setRegexParser(java.lang.String[] fieldNames)
```
    The regex parser is a slow parser, but gives precise control.
    
    Parameters:
    
    fieldNames -
    
    Returns:
    
    the parser for each record.
  - setFixedColumnsParser
```
public AsciiParser.FixedColumnsParser setFixedColumnsParser(java.lang.String filename,
                                                            java.lang.String delim)
                                                     throws java.io.IOException
```
    looks at the first line after skipping, and splits it to calculate where the columns are. The FixedColumnsParser is the fastest of the three parsers.
    
    Parameters:
    
    filename - filename to read in.
    
    delim - regex to split the initial line into the fixed columns.
    
    Returns:
    
    the record parser that will split each line.
    
    Throws:
    
    java.io.IOException
  - setFixedColumnsParser
```
public AsciiParser.FixedColumnsParser setFixedColumnsParser(java.io.Reader in,
                                                            java.lang.String delim)
                                                     throws java.io.IOException
```
    looks at the first line after skipping, and splits it to calculate where the columns are.
    
    Parameters:
    
    in - the Reader to get lines from.
    
    delim - regex to split the initial line into the fixed columns.
    
    Returns:
    
    the record parser that will split each line.
    
    Throws:
    
    java.io.IOException
  - guessFieldCount
```
public static int guessFieldCount(java.lang.String filename)
                           throws java.io.FileNotFoundException,
                                  java.io.IOException
```
    return the field count that would result in the largest number of records parsed. The entire file is scanned, and for each line the number of decimal fields is counted. At the end of the scan, the fieldCount with the highest record count is returned.
    
    Parameters:
    
    filename - the file name, a local file opened with a FileReader
    
    Returns:
    
    the apparent field count.
    
    Throws:
    
    java.io.FileNotFoundException
    
    java.io.IOException
  - setFieldParser
```
public void setFieldParser(int field,
                           AsciiParser.FieldParser fp)
```
    set the special parser for a field.
    
    Parameters:
    
    field - the field number, 0 is the first column.
    
    fp - the parser
  - newParser
```
public static AsciiParser newParser(int fieldCount)
```
    creates a parser with @param fieldCount fields, named "field0,...,fieldN"
    
    Parameters:
    
    fieldCount - the number of fields
    
    Returns:
    
    the file parser
  - newParser
```
public static AsciiParser newParser(java.lang.String[] fieldNames)
```
    creates a parser with the named fields.
    
    Parameters:
    
    fieldNames - the names for each field
    
    Returns:
    
    the file parser
  - setSkipLines
```
public void setSkipLines(int skipLines)
```
    skip a number of lines before trying to parse anything. This can be set to point at the first valid line, and the RecordParser will be configured using that line.
    
    Parameters:
    
    skipLines -
  - setRecordCountLimit
```
public void setRecordCountLimit(int recordCountLimit)
```
    limit the number of records read. parsing will stop once this number of records is read into the result. This is Integer.MAX_VALUE by default.
    
    Parameters:
    
    recordCountLimit -
  - setRecordStart
```
public void setRecordStart(int recordStart)
```
    set the number of records to skip before accumulating the result.
    
    Parameters:
    
    recordStart -
  - setPropertyPattern
```
public void setPropertyPattern(java.util.regex.Pattern propertyPattern)
```
    specify the Pattern used to recognize properties. Note property values are not parsed, they are provided as Strings. This is a regular expression with two groups for the property name and value. For example, (.+)=(.+)
    
    Parameters:
    
    propertyPattern - regular expression Pattern with two groups.
  - setCommentPrefix
```
public void setCommentPrefix(java.lang.String comment)
```
    Records starting with this are not processed as data, for example "#". This is initially "#". Setting this to null disables this check.
    
    Parameters:
    
    comment - the prefix
  - getHeaderDelimiter
```
public java.lang.String getHeaderDelimiter()
```
    get the header delimiter
    
    Returns:
    
    the header delimiter.
  - setHeaderDelimiter
```
public void setHeaderDelimiter(java.lang.String headerDelimiter)
```
    set the delimiter which explicitly separates header from the data. For example "-------" could be used. Normally the parser just looks at the number of fields and this is sufficient.
    
    Parameters:
    
    headerDelimiter -
  - readStream
```
public WritableDataSet readStream(java.io.Reader in,
                                  ProgressMonitor mon)
                           throws java.io.IOException
```
    Parse the stream using the current settings.
    
    Parameters:
    
    in - the input stream
    
    mon -
    
    Returns:
    
    Throws:
    
    java.io.IOException
  - readString
```
public WritableDataSet readString(java.lang.String str,
                                  ProgressMonitor mon)
                           throws java.io.IOException
```
    Parameters:
    
    str - the data, encoded in a UTF-8 string
    
    mon - null or a progress monitor
    
    Returns:
    
    the data
    
    Throws:
    
    java.io.IOException
  - readStream
```
public WritableDataSet readStream(java.io.Reader in,
                                  java.lang.String firstRecord,
                                  ProgressMonitor mon)
                           throws java.io.IOException
```
    read in the stream, including the first record if non-null.
    
    Parameters:
    
    in - the stream, which is not closed.
    
    firstRecord, - if non-null, parse this record first. This allows information to be extracted about the records, then fed into this loop.
    
    mon - null or a progress monitor
    
    Returns:
    
    the dataset.
    
    Throws:
    
    java.io.IOException
  - isRichHeader
```
public static boolean isRichHeader(java.lang.String header)
```
    return true if the header appears to contain JSON code which could be interpreted as a "Rich Header" (a.k.a. JSONHeadedASCII). This is a very simple test, simply looking for #{ and #} with a colon contained within.
    
    Parameters:
    
    header - string containing the commented header.
    
    Returns:
    
    true if parsing as a Rich Header should be attempted.
    
    See Also:
    
    https://github.com/JSONheadedASCII/examples
  - isRichHeader
```
public boolean isRichHeader()
```
    return true if the parsed file provided a rich ascii header. Presently this is the header defined in http://autoplot.org/richAscii. This must be called after the file is parsed.
    
    Returns:
    
    true if the parsed file provided a rich ascii header.
  - getRichFields
```
public java.util.Map<java.lang.String,java.lang.String> getRichFields()
```
    returns the high rank rich fields in a map from NAME to LABEL. NAME:>fieldX< or NAME:>fieldX-fieldY<
    
    Returns:
    
    the high rank rich fields in a map from NAME to LABEL.
  - setWhereConstraint
```
public void setWhereConstraint(java.lang.String sparm,
                               java.lang.String op,
                               java.lang.String sval)
```
    allow constraint for where condition is true. This doesn't need the data to be interpreted for "eq", string equality is checked for nominal data. Note sval is compared after trimming outside spaces.
    
    Parameters:
    
    sparm - column name, such as "field4"
    
    op - constraint, one of eq gt ge lt le ne
    
    sval - String value. For nominal columns, String equality is used.
  - getDelimParser
```
public AsciiParser.DelimParser getDelimParser(int fieldCount,
                                              java.lang.String delim)
```
    provide more control to external codes by providing a way to assert that an N-column delim parser should be used.
    
    Parameters:
    
    fieldCount -
    
    delim - the delimiter pattern, such as "," or "\s+"
    
    Returns:
    
    the DelimParser.
  - guessLengthForFormat
```
public static int guessLengthForFormat(java.lang.String format)
```
    return the length of the format specifier. %30d -> 30 %30d%5f -> 35. TODO: consider String.format(format,1) or String.format(format,1.0).
    
    Parameters:
    
    format -
    
    Returns:
  - getRegexForFormat
```
public static java.lang.String getRegexForFormat(java.lang.String format)
```
    Convert FORTRAN (F77) style format to C-style format specifiers.
    
    Parameters:
    
    format - for example "%5d%5d%9f%s"
    
    Returns:
    
    for example "d5,d5,f9,a"
    
    See Also:
    
    MetadataUtil.normalizeFormatSpecifier(java.lang.String)
  - getRegexParserForFormat
```
public AsciiParser.RegexParser getRegexParserForFormat(java.lang.String format)
```
    see private TimeParser(String formatString, Map<String,FieldHandler> fieldHandlers)</tt>, which is very similar.
    - "%5d%5d%9f%s"
    - "d5,d5,f9,a"
    Parameters:
    
    format -
    
    Returns:
    
    See Also:
    
    TimeParser
  - getRegexParser
```
public AsciiParser.RegexParser getRegexParser(java.lang.String regex)
```
    return a regex parser for the given regular expression. Groups are used for the fields, for example getRegexParser( 'X (\d+) (\d+)' ) would parse lines like "X 00005 00006".
    
    Parameters:
    
    regex -
    
    Returns:
    
    the regex parser
  - setFixedColumnsParser
```
public AsciiParser.FixedColumnsParser setFixedColumnsParser(int[] columnOffsets,
                                                            int[] columnWidths,
                                                            AsciiParser.FieldParser[] parsers)
```
    set the record parser to be a fixed columns parser
    
    Parameters:
    
    columnOffsets - the start of each column
    
    columnWidths - the width of each column
    
    parsers - the parser for each column.
    
    Returns:
    
    the FixedColumnsParser
  - getFieldCount
```
public int getFieldCount()
```
    return the number of fields in each record. Note the RecordParsers also have a fieldCount, which should be equal to this. This allows them to be independent of the parser.
    
    Returns:
  - getFieldNames
```
public java.lang.String[] getFieldNames()
```
    return the name of each field. field0, field1, ... are the default names when names are not discovered in the table. Changing the array will not affect internal representation.
    
    Returns:
  - getFieldLabels
```
public java.lang.String[] getFieldLabels()
```
    return the labels found for each field. If a label wasn't found, then the name is returned.
    
    Returns:
  - getFieldUnits
```
public java.lang.String[] getFieldUnits()
```
    return the units that were associated with the field. This might also be the channel label for spectrograms. In "field0(str)" or "field0[str]" this is str. elements may be null if not found.
    
    Returns:
  - readFile
```
public WritableDataSet readFile(java.lang.String filename,
                                ProgressMonitor mon)
                         throws java.io.IOException
```
    Parse the file using the current settings.
    
    Parameters:
    
    filename - the file to read
    
    mon - a monitor
    
    Returns:
    
    a rank 2 dataset.
    
    Throws:
    
    java.io.IOException
  - addPropertyChangeListener
```
public void addPropertyChangeListener(java.beans.PropertyChangeListener l)
```
    Adds a PropertyChangeListener to the listener list.
    
    Parameters:
    
    l - The listener to add.
  - removePropertyChangeListener
```
public void removePropertyChangeListener(java.beans.PropertyChangeListener l)
```
    Removes a PropertyChangeListener from the listener list.
    
    Parameters:
    
    l - The listener to remove.
  - isKeepFileHeader
```
public boolean isKeepFileHeader()
```
    Getter for property keepHeader.
    
    Returns:
    
    Value of property keepHeader.
  - setKeepFileHeader
```
public void setKeepFileHeader(boolean keepHeader)
```
    Setter for property keepHeader. By default false but if true, the file header ignored by skipLines is put into the property PROPERTY_FILE_HEADER.
    
    Parameters:
    
    keepHeader - New value of property keepHeader.
  - getRecordParser
```
public AsciiParser.RecordParser getRecordParser()
```
    Getter for property recordParser.
    
    Returns:
    
    Value of property recordParser.
  - setRecordParser
```
public void setRecordParser(AsciiParser.RecordParser recordParser)
```
    Setter for property recordParser.
    
    Parameters:
    
    recordParser - New value of property recordParser.
  - getUnits
```
public Units getUnits(int index)
```
    Indexed getter for property units.
    
    Parameters:
    
    index - Index of the property.
    
    Returns:
    
    Value of the property at index.
  - setUnits
```
public void setUnits(int index,
                     Units units)
```
    Indexed setter for property units. This now sets the field parser for the field to be a UNITS_PARSER if it is the default DOUBLE_PARSER.
    
    Parameters:
    
    index - Index of the property.
    
    units - New value of the property at index.
  - setUnits
```
public void setUnits(Units... u)
```
    Set all the units at once. This now sets the field parser for each field to be a UNITS_PARSER if it is the default DOUBLE_PARSER.
    
    Parameters:
    
    u - array (or varargs) of units to be applied to the 0,1,2nd,... fields.
  - getFieldIndex
```
public int getFieldIndex(java.lang.String string)
```
    returns the index of the field. Supports the name, or field0, or 0, etc. returns -1 when the column is not identified.
    
    Parameters:
    
    string - the label for the field, such as "field2" or "time"
    
    Returns:
    
    -1 or the index of the field.
  - getFillValue
```
public double getFillValue()
```
    return the fillValue. numbers that parse to this value are considered to be fill. Note validMin and validMax may be used as well.
    
    Returns:
    
    Value of property fillValue.
  - setFillValue
```
public void setFillValue(double fillValue)
```
    numbers that parse to this value are considered to be fill.
    
    Parameters:
    
    fillValue - New value of property fillValue.
  - getValidMin
```
public double getValidMin()
```
    get the minimum valid value for any field.
    
    Returns:
    
    validMin
  - setValidMin
```
public void setValidMin(double validMin)
```
    set the minimum valid value for any field. Values less than this are to be considered invalid.
    
    Parameters:
    
    validMin -
  - getValidMax
```
public double getValidMax()
```
    get the maximum value for any field.
    
    Returns:
    
    the validMax
  - setValidMax
```
public void setValidMax(double validMax)
```
    set the maximum value for any field. Values above this are to be considered invalid.
    
    Parameters:
    
    validMax -

Class AsciiParser

Nested Class Summary

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

NAME_COLON_VALUE_PATTERN

NAME_EQUAL_VALUE_PATTERN

PROPERTY_FIELD_NAMES

PROPERTY_FILE_HEADER

PROPERTY_FIRST_RECORD

PROPERTY_FIELD_PARSER

DELIM_COMMA

DELIM_TAB

DELIM_WHITESPACE

UNIT_UTC

headerDelimiter

PROP_HEADERDELIMITER

DOUBLE_PARSER

UNITS_PARSER

ENUMERATION_PARSER

validMin

PROP_VALIDMIN

validMax

PROP_VALIDMAX

Constructor Detail

AsciiParser

Method Detail

isHeader

isIso8601Time

readFirstRecord

readFirstRecord

readFirstParseableRecord

guessSkipLines

guessSkipAndDelimParser

guessDelimParser

guessDelimParser

setDelimParser

setDelimParser

setDelimParser

setRegexParser

setFixedColumnsParser

setFixedColumnsParser

guessFieldCount

setFieldParser

newParser

newParser

setSkipLines

setRecordCountLimit

setRecordStart

setPropertyPattern

setCommentPrefix

getHeaderDelimiter

setHeaderDelimiter

readStream

readString

readStream

isRichHeader

isRichHeader

getRichFields

setWhereConstraint

getDelimParser

guessLengthForFormat

getRegexForFormat

getRegexParserForFormat

getRegexParser

setFixedColumnsParser

getFieldCount

getFieldNames

getFieldLabels

getFieldUnits

readFile

addPropertyChangeListener

removePropertyChangeListener

isKeepFileHeader

setKeepFileHeader

getRecordParser

setRecordParser

getUnits