What approach to use for parsing a file with fixed length records, when the record layout isn't known until runtime?

I want to parse a file based on a record layout provided in another file.

Basically there will be a definition file, which is a comma delimited list of fields and their respective lengths. There will be many of these, a new one will be loaded each time I run the program.

firstName,text,20
middleInitial,text,1
lastName,text,20
salary,number,10

Then I will display a blank table with the supplied column headings, and开发者_StackOverflow中文版 an option to add data by clicking a button or whatever - I haven't decided yet.

I also want to have an option to both load data from a file, or save data to a file, with the file matching the format described in the definition file.

For example, a file to load (or one produced by the save function) for the above definition file might look like this.

Adam                DSmith               50000
Brent               GWilliams            45000
Harry               TThompson            47500

What kind of patterns could be useful here, and can anyone give me pointers of a rough guide on how to structure the way data is internally stored and modeled.

I would like to think I can find my way around the java documentation alright, but if anyone can point me at somewhere to start looking, it would be greatly appreciated!

Thanks

So it sounds like to me that you have a howToParse file and infoToParse file with the directions of how to parse information and the information to parse in these files respectively.

First, I would read in the howToParse file and create some sort of dynamic Parser object. It looks like each line in this file is a different ParsingStep object. Then you just need to read the line which will be stored as a String object and just split the ParsingStep into its 3 parts: field name, type of data, length of data.

// Create new parser to hold parsing steps.
Parser dynamicParser = new Parser();

// Create new scanner to read through parse file.
Scanner parseFileScanner = new Scanner(howToParseFileName);

// *** Add exception handling as necessary *** this is just an example    

// Read till end of file.
while (parseFileScanner.hasNext()) {
    String line = parseFileScanner.nextLine(); // Get next line in file.

    String[] lineSplit = line.split(","); // Split on comma
    String fieldName   = lineSplit[0];
    String dataType    = lineSplit[1];
    String dataLength  = lineSplit[2];  // Convert to Integer with Integer.parseInt();

    ParsingStep step = new ParsingStep(fieldName, dataType, dataLength);
    dynamicParser.addStep(step);
}

parseFileScanner.close();

Then you would have how to parse a line, then you just need to parse through the other file and store the information from that file, probably in an array.

// Open infoToParse file and start reading.
Scanner infoScanner = new Scanner(infoToParseFileName);

// Add exception handling.
while (infoScanner.hasNext()) {
    String line = infoScanner.nextLine();

    // Parse line and return a Person object or maybe just a Map of field names to values
    Map<String,String> personMap = dynamicParser.parse(line);
} 

infoScanner.close();

Then the only other code is just making sure the parser is parsing in the correct order.

public class Parser {
    private ArrayList<ParsingStep> steps;

    public Parser() {
        steps = new ArrayList<ParsingStep>();
    }

    public void addStep(ParsingStep step) {
        steps.add(step);
    }

    public Map<String,String> parse(String line) {
        String remainingLine = line;

        for (ParsingStep step : steps) {
            remainingLine = step.parse(remainingLine);
        }

        return map; // Somehow convert to map.
    }
}

Personally, I would add some error checking in the parse steps just in case the infoToParse file is not in the proper format.

Hope this helps.