src/dochelper/FileRecordSet.java

Go to the documentation of this file.

/*
 * FileRecordSet.java
 *
 * Created on November 12, 2008, 2:52 PM
 *
 * Copyright 2009 Online Nederland Breedband B.V.
 * See the COPYRIGHT file for redistribution and use restrictions.
 * Authors: Guillermo Christen <guillermo.christen@is.online.nl>
 */
package dochelper;

import java.io.File;
import java.io.IOException;
import java.util.ArrayList;
import java.util.HashMap;

import dochelper.exceptions.IllegalParamterTypeException;
import dochelper.exceptions.InitializationException;
import dochelper.exceptions.InvalidValueException;
import dochelper.exceptions.MissingArgumentException;
import dochelper.exceptions.ResourceUnavailableException;
import dochelper.util.FileUtils;

public class FileRecordSet implements RecordSet {

    protected static final String PATH = "path";

    protected static final String RECUR = "recursive";

    protected static final String GLOB = "glob";

    private String name;

    protected HashMap<String, Object> params = new HashMap<String, Object>();
    
    protected ArrayList<Record> rsfiles;

    //The patterns that should be matched to the records for this record set
    private ArrayList<DocPattern> patterns;

    public void setParam(String paramName, Object value) throws IllegalParamterTypeException {

        if (value instanceof String || value instanceof DocumentSection)
            params.put(paramName, value);
        else
            throw new IllegalParamterTypeException(paramName);
    }

    public void checkParams() throws InvalidValueException, MissingArgumentException, ResourceUnavailableException {

        //Validate the path is set
        if (!params.containsKey(PATH))
            throw new MissingArgumentException(PATH);

        //Validate the glob is set
        if (!params.containsKey(GLOB))
            throw new MissingArgumentException(GLOB);

        //Validate the glob is set
        if (!params.containsKey(RECUR))
            throw new MissingArgumentException(RECUR);

    //Check path exists
    }

    public void init() throws InitializationException, ResourceUnavailableException {

        //Init the files arraylist
        setRsfiles(new ArrayList<Record>());

        //we need to convert the glob to a regexp
        String filter = FileUtils.globToRE((String)params.get(GLOB));

        try {
            //Get the path. Check the path from the CAnonical Path returned by Canonical Path
            String canonicalPath = new File((String)params.get(PATH)).getCanonicalPath();

            //the poulate the recordset with the list of files
            //TODO: this should be re - implemented to be usable on multiple platforms
            _listDirectory(new ArrayList<String>(), rsfiles, canonicalPath, filter, "true".equals(((String)params.get(RECUR)).toLowerCase()));

        }
        catch (Exception e) {
            InitializationException ie = new InitializationException(e.getMessage());
            e.printStackTrace();
            throw ie;
        }
    }

    public ResultNode execute(ResultNode doc) throws ResourceUnavailableException {

        //Make the RecordSet Node
        ResultNode result = new ResultNode(null, params, this.getName());

        //Loop through all the records for this record set
        for (Record record : rsfiles) {
            //add the subtree created by executing this record
            result.addChild(record.execute(patterns));
        }

        doc.addChild(result);

        return doc;
    }

    //TODO: Replace native util regexp with optimized version : GNU
    //TODO: Add GNU license and mention that code is modification of the Search from Jedit.
    protected void _listDirectory(ArrayList stack, ArrayList files, String directory, String glob, boolean recursive) throws IOException {

        if (stack.contains(directory)) {
            //LOG?
            return;
        }
        else
            stack.add(directory);

        File[] _files = FileUtils._listDirectory(directory);

        if (_files == null || _files.length == 0)
            return;

        for (int i = 0;i < _files.length;i++) {
            File file = _files[i];

            if (file.isDirectory()) {

                if (recursive) {
                    // resolve symlinks to avoid loops
                    String canonPath = file.getCanonicalPath();

                    _listDirectory(stack, files, canonPath, glob, recursive);
                }
            }
            else {
                //TODO: Change so that the regexp is not compiled for every check
                if (!java.util.regex.Pattern.matches(glob, file.getName()))
                    continue;

                //Make a new file record with the specified document section,
                //this should be a clone.
                files.add(new FileRecord(file, this.getName() + "Record"));
            }
        }

    }

    public ArrayList<Record> getRsfiles() {
        return rsfiles;
    }

    public void setRsfiles(ArrayList<Record> rsfiles) {
        this.rsfiles = rsfiles;
    }

    public ArrayList<DocPattern> getPatterns() {
        return patterns;
    }

    public void setPatterns(ArrayList<DocPattern> patterns) {
        this.patterns = patterns;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public void addPattern(DocPattern pattern) {

        if (this.patterns == null)
            this.patterns = new ArrayList<DocPattern>();

        this.patterns.add(pattern);
    }

    public void clearPatterns() {
        this.patterns = new ArrayList<DocPattern>();
    }

    public String toString() {

        String out = "";
        //Show the files
        out += "File Record Set: [" + this.getName() + ", Files Count : " + rsfiles.size() + "]";

        //show the patterns
        return out;
    }
}

---