
WrapperExecuter.java


/*

 * 作成日: 2004/05/22

 * License Apache 2.0

 * この生成されたコメントの挿入されるテンプレートを変更するため

 * ウィンドウ > 設定 > Java > コード生成 > コードとコメント

 */

package org.jpn.xucker.commons.swt.series.wfs;



import java.io.File;

import java.io.IOException;

import java.io.InputStream;

import java.util.Hashtable;

import java.util.List;

import java.util.Vector;



import org.apache.commons.lang.ArrayUtils;

import org.jpn.xucker.commons.swt.series.ResultData;



/**

 * @author ak License Apache 2.0

 * 

 * この生成されたコメントの挿入されるテンプレートを変更するため ウィンドウ > 設定 > Java > コード生成 > コードとコメント

 */

public abstract class WrapperExecuter {

    



    protected File output;



    protected List fileList = new Vector();



    protected String commandPath = "";



    protected String allowExtension[];



    protected String outputExtension;









    protected List resultVector = new Vector();



    protected boolean isDebug;

    protected boolean isPrint;

    protected boolean isShowOnly;

    public boolean isDebug() {

        return isDebug;

    }

    public void setDebug(boolean isDebug) {

        this.isDebug = isDebug;

    }

    public boolean isPrint() {

        return isPrint;

    }

    public void setPrint(boolean isPrint) {

        this.isPrint = isPrint;

    }

    public boolean isShowOnly() {

        return isShowOnly;

    }

    public void setShowOnly(boolean isShowOnly) {

        this.isShowOnly = isShowOnly;

    }

    protected Hashtable valueHash=new Hashtable();



    protected String[] resultLabel;

    

    public void setValue(String name,String value){

        valueHash.put(name,value);

    }

    public void setValue(String name,int value){

        valueHash.put(name,""+value);

    }

    public String getValue(String name){

        return (String)valueHash.get(name);

    }

    public String getCommandPath() {

        return commandPath;

    }



    public void setCommandPath(String commandPath) {

        this.commandPath = commandPath;

    }



    

   



    public void addFile(String path) {

        fileList.add(path);

    }



    public void execute() throws IOException {

        if (commandPath==null) {

            throw new IOException("command file not exsits :" + commandPath);



        }

        File f = new File(commandPath);

        if (!f.exists()) {

            throw new IOException("command file not exsits :" + commandPath);

            //should call dialog.

        }



        String paths[] = (String[]) fileList

                .toArray(new String[fileList.size()]);

        for (int i = 0; i < paths.length; i++) {

            preExecute(new File(paths[i]));

        }



    }



    /**

     * @param file

     */

    private void preExecute(File file) {

        //System.out.println("pre "+file.getAbsolutePath());

        if (output != null) {

            String rootFolder = toEndsWithFileSeparator(file.getParent());

            doExecute(rootFolder, output, file);

        } else {

            //output same folder.

            doExecute(null, null, file);

        }

    }



    /**

     * @param parent

     * @return

     */

    private String toEndsWithFileSeparator(String parent) {

        if(!parent.endsWith(System.getProperty("file.separator"))){

            return parent+System.getProperty("file.separator");

        }else{

            return parent;

        }

    }



    /**

     * @param rootFolder

     * @param output2

     * @param file

     */

    protected void doExecute(String rootFolder, File outputDir, File file) {

        if(!file.exists()){

            //if file not found do nothing.

            return;

        }

        if (file.isDirectory()) {

            String list[] = file.list();

            if(list!=null){

            for (int i = 0; i < list.length; i++) {

                File listFile = new File(file, list[i]);

                if (listFile.isDirectory() || isTargetExtensionFile(listFile)) {

                    doExecute(rootFolder, outputDir, listFile);

                }

            }

            }

        } else {



            File outputFile = null;

            if (outputDir != null) {

               

                outputFile = toOutputFile(new File(outputDir, getRelativePath(file,rootFolder)));



            } else {

                outputFile = toOutputFile(file);

            }

            

            callCommand(file,outputFile);

            



            ResultData result = new ResultData();

            

            setResultValue(result,rootFolder,outputDir,file,outputFile);

            

            if(result.isValid()){

             

                resultVector.add(result);

            }

        }



    }

    

    public ResultData[] getResultData(){

        return (ResultData[])resultVector.toArray(new ResultData[resultVector.size()]);

    }

    

    protected abstract void setResultValue(ResultData result,String rootPath,File outputDir,File input,File output);



    /**

     * @param file

     * @param outputDir

     * @return

     */

    protected String getRelativePath(File file, String basePath) {

        if(!file.getAbsolutePath().startsWith(basePath)){

            throw new RuntimeException("not start basePath");

        }

        if(!basePath.endsWith(System.getProperty("file.separator"))){

            throw new RuntimeException("basepath not ends with file separator");

        }

        if(file.isDirectory()){

            throw new RuntimeException("file is must file");

        }

        return file.getAbsolutePath().substring(basePath.length());

    }



    public File toOutputFile(File file) {

        if(outputExtension==null){

            return file;

        }

        String extension=outputExtension;

        if(!extension.startsWith(".")){

            extension="."+extension;

        }

        File resultFile = null;

        int index = file.getName().lastIndexOf(".");

        if (index != -1) {

            resultFile = new File(file.getParent(), file.getName().substring(0,

                    index)

                    + extension);

        }



        return resultFile;

    }



    /**

     * @param tmp

     * @return

     */

    protected boolean isTargetExtensionFile(File tmp) {

        if(allowExtension==null){

            return true;

        }

        for (int i = 0; i < allowExtension.length; i++) {

            if (tmp.getName().toLowerCase().endsWith(allowExtension[i])) {

                return true;

            }

        }

        // TODO Auto-generated method stub

        return false;

    }



    /**

     * @param inputFile

     * @param outputFile

     * @param level

     */

    protected void callCommand(File inputFile, File outputFile) {



        Runtime runtime = Runtime.getRuntime();

        if(!outputFile.exists()){

            outputFile.getParentFile().mkdirs();

        }

        

        String args[]=createArgs(inputFile,outputFile);

        



        try {



            if(isPrint==true){

                printArgs(args);

            }

            

            if(!isShowOnly){

                Process process = runtime.exec(args);



                

                if(isDebug){

                    System.out.println("[log]");

                    System.out.println(readAll(process.getInputStream()));

                }

                process.waitFor();

            }

            

            



        } catch (Exception e) {

            e.printStackTrace();

        }

        

    }



    /**

     * @param inputFile

     * @param outputFile

     * @return

     */

    protected abstract String []createArgs(File inputFile, File outputFile);

    

    public static String readAll(InputStream reader) {

        StringBuffer text = new StringBuffer();

        int c;



        try {

            while ((c = reader.read()) != -1) {

                //System.out.println((char) c);

                text.append((char) c);

            }

        } catch (IOException e) {

            // TODO 自動生成された catch ブロック

            e.printStackTrace();

        }

        return text.toString();

    }

    protected boolean isTrueValue(String key){

        if(valueHash.get(key)!=null){

            String value=(String)valueHash.get(key);

            if(value.equals("true")){

                return true;

            }

        }

        return false;

    }



    /**

     * @return

     */

    public File getOutput() {

        return output;

    }



    /**

     * @param file

     */

    public void setOutput(File file) {

        output = file;

    }

    /**

     * @param labels

     */

    public void setResultLabel(String[] labels) {

        this.resultLabel=(String[])ArrayUtils.clone(labels);

    }



    public String[] getAllowExtension() {

        return (String[])ArrayUtils.clone(allowExtension);

    }

    public void setAllowExtension(String[] allowExtension) {

        this.allowExtension = (String[])ArrayUtils.clone(allowExtension);

    }

    public String getOutputExtension() {

        return outputExtension;

    }

    public void setOutputExtension(String outputExtension) {

        this.outputExtension = outputExtension;

    }

    public String[] getResultLabel() {

        return (String[])ArrayUtils.clone(resultLabel);

    }

    /**

     * @param args

     */

    protected void printArgs(String[] args) {

        

        for(int i=0;i<args.length;i++){

            System.out.print(args[i]+" ");

        }System.out.println();

    }

}