CWS-TOOLING: integrate CWS l10ntools

1 files changed, 523 insertions, 0 deletions

diff --git a/l10ntools/java/l10nconv/java/com/sun/star/tooling/converter/Converter.java b/l10ntools/java/l10nconv/java/com/sun/star/tooling/converter/Converter.java
new file mode 100755
index 000000000000..7ec09bcb411a
--- /dev/null
+++ b/l10ntools/java/l10nconv/java/com/sun/star/tooling/converter/Converter.java
@@ -0,0 +1,523 @@
+/*************************************************************************
+ *
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * Copyright 2008 by Sun Microsystems, Inc.
+ *
+ * OpenOffice.org - a multi-platform office productivity suite
+ *
+ * $RCSfile: Converter.java,v $
+ * $Revision: 1.4 $
+ *
+ * This file is part of OpenOffice.org.
+ *
+ * OpenOffice.org is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License version 3
+ * only, as published by the Free Software Foundation.
+ *
+ * OpenOffice.org is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License version 3 for more details
+ * (a copy is included in the LICENSE file that accompanied this code).
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * version 3 along with OpenOffice.org.  If not, see
+ * <http://www.openoffice.org/license.html>
+ * for a copy of the LGPLv3 License.
+ *
+ ************************************************************************/
+/*
+ * Converter.java
+ *
+ * create Source and Target
+ * for converting
+ * TODO maybe a factory would be good here
+ */
+
+package com.sun.star.tooling.converter;
+
+import java.io.BufferedOutputStream;
+import java.io.File;
+import java.io.FileNotFoundException;
+import java.io.FileOutputStream;
+import java.io.IOException;
+import java.io.OutputStream;
+
+import javax.xml.parsers.ParserConfigurationException;
+import javax.xml.parsers.SAXParser;
+import javax.xml.parsers.SAXParserFactory;
+
+import org.xml.sax.EntityResolver;
+import org.xml.sax.SAXException;
+import org.xml.sax.SAXParseException;
+import org.xml.sax.XMLReader;
+import org.xml.sax.helpers.DefaultHandler;
+
+/**
+ *
+ * This class handles the creating of the source to read from,
+ * the target to write to and the appropriate DataHandler
+ *
+ * @author Christian Schmidt 2005
+ */
+public final class Converter {
+
+    /**
+     * the used charset f.e. UTF-8
+     */
+    private final static String         CHARSET        = new String("UTF-8");
+
+    private static final String EMPTY          = new String("");
+
+    /**
+     * The DataHandler use to connect reader and writer
+     */
+    private static DataHandler  handler;
+
+    /**
+     * Counting the lines written by a writer
+     */
+    private static int          lineCounter;
+
+    /**
+     * The target to write to
+     */
+    private static DataWriter   theTargetWriter;
+
+
+    /**
+     * Overwrite existing files
+     */
+    private boolean             overwrite      = false;
+    /**
+     * The source to read from
+     */
+    private Source              reader;
+    /**
+     * The name of the source file
+     */
+    private String              sourceString;
+    /**
+     * the Type of the Source file(SDF,GSI,XLIFF)
+     */
+    private String              sourceType;
+    /**
+     * The name of the target fille
+     */
+    private String              targetString;
+    /**
+     * the Type of the Target file(SDF,GSI,XLIFF)
+     */
+    private String              targetType;
+    /**
+     * The writer that handles the output
+     */
+    private Target              writer;
+
+    /**
+     * The sourceLanguage
+     */
+    String                      sourceLanguage = "en-US";
+
+    /**
+     * The targetLanguage
+     */
+    String                      targetLanguage = "";
+
+    /**
+     * The name of the second source, needed for GSI to SDF merge
+     */
+    private String secondSourceString=EMPTY;
+
+
+    /**
+     * Get the line counter
+     * @return Returns the lineCounter.
+     */
+    public static int getLineCounter() {
+        return lineCounter;
+    }
+
+    /**
+     * increment the lineCounter
+     */
+    final static void countLine() {
+        lineCounter++;
+    }
+
+    /**
+     * Creates a new instance of Converter
+     *
+     * @param sourceType        the type of the sourceFile
+     * @param sourceString      the name of the sourceFile
+     * @param SourceLanguage    the ISO Id of the sourceLanguage
+     * @param targetType        the type of the targetFile
+     * @param targetString      the name of the targetFile
+     * @param TargetLanguage    the ISO Id of the targetLanguage
+     * @param secondSourceString     the name of the second sourceFile (GSI merge only)
+     * @param overwrite         indicates whether overwrite existing files
+     * @throws IOException
+     * @throws Exception
+     */
+    public Converter(String sourceType, String sourceString,
+            String SourceLanguage, String targetType, String targetString,
+            String TargetLanguage,String secondSourceString, boolean overwrite) throws IOException,
+            Exception {
+
+        this.sourceType = sourceType;
+        this.sourceString = sourceString;
+        this.sourceLanguage = SourceLanguage;
+        this.targetType = targetType;
+        this.targetString = targetString;
+        this.targetLanguage = TargetLanguage;
+        this.secondSourceString=secondSourceString;
+        this.overwrite = overwrite;
+
+        handler = new DataHandler();
+
+        if ("sdf".equalsIgnoreCase(sourceType)) {
+            reader = new SDFSource();
+        } else if ("xliff".equalsIgnoreCase(sourceType)||"dbxliff".equalsIgnoreCase(sourceType)) {
+            reader = new XLIFFSource();
+        } else if ("gsi".equalsIgnoreCase(sourceType)) {
+            reader = new GSISource();
+        } else {
+            throw new ConverterException("Unknown Source File Type: '"+sourceType+"'");
+        }
+
+        if ("sdf".equalsIgnoreCase(targetType)) {
+            writer = new SDFTarget();
+        } else if ("xliff".equalsIgnoreCase(targetType)) {
+            writer = new XLIFFTarget();
+        } else if ("gsi".equalsIgnoreCase(targetType)) {
+            writer = new GSITarget();
+        } else {
+            throw new ConverterException("Unknown Target File Type: '"+targetType+"'");
+        }
+
+    }
+
+    /**
+     * Do the converting from the source file format to the target file format
+     *
+     * @throws IOException
+     */
+    public final void convert() throws IOException {
+
+        try {
+
+            reader.convertTo(writer);
+
+            //TODO this belongs in the Target Class
+            theTargetWriter.flush();
+            theTargetWriter.close();
+        } catch (Exception e) {
+            OutputHandler.out(e.getMessage());
+        }
+
+    }
+
+
+    /**
+     *
+     * Encapsulate the reading from an GSI file
+     *
+     * @author Christian Schmidt 2005
+     *
+     */
+    private class GSISource implements Source {
+        DataReader theSourceReader;
+        /**
+         * Create a new Instance of GSISource
+         *
+         * @throws IOException
+         * @throws Exception
+         */
+        public GSISource() throws IOException {
+
+            theSourceReader = new GSIandSDFMerger(new File(sourceString),new File(secondSourceString), sourceLanguage,
+                    targetLanguage, CHARSET);
+        }
+
+        public void convertTo(Target t) {
+
+            try {
+                theTargetWriter = t.getWriter();
+                while (handler.fillDataFrom(theSourceReader)) {
+
+                    theTargetWriter.getDatafrom(handler);
+                    theTargetWriter.writeData();
+                }
+            } catch (IOException e) {
+                OutputHandler.out(e.getMessage());
+
+            } catch (Exception e) {
+                e.printStackTrace();
+            }
+
+        }
+
+    }
+    /**
+     *
+     * Encapsulate to write to a GSI file
+     *
+     * @author Christian Schmidt 2005
+     *
+     */
+    private class GSITarget implements Target {
+
+        File target;
+
+        /**
+         * Create a new Instance of GSITarget
+         *
+         * @throws FileNotFoundException
+         * @throws IOException
+         */
+        public GSITarget() throws FileNotFoundException, IOException {
+
+            target = FileMaker.newFile(targetString, overwrite);
+            theTargetWriter = new GSIWriter(new BufferedOutputStream(
+                    new FileOutputStream(target)), CHARSET);
+        }
+
+        public DataWriter getWriter() {
+
+            return theTargetWriter;
+        }
+
+    }
+    /**
+     *
+     * Encapsulate the reading from an SDF file
+     *
+     * @author Christian Schmidt 2005
+     *
+     */
+    private final class SDFSource implements Source {
+
+        DataReader Source;
+
+        /**
+         * Create a new Instance of SDFSource
+         * @throws IOException
+         * @throws Exception
+         */
+        public SDFSource() throws IOException, Exception {
+
+            Source = new SDFReader(new File(sourceString), sourceLanguage,
+                    targetLanguage, CHARSET);
+        }
+
+        public void convertTo(Target t) {
+            try {
+                theTargetWriter = t.getWriter();
+                while (handler.fillDataFrom(Source)) {
+
+                    theTargetWriter.getDatafrom(handler);
+                    theTargetWriter.writeData();
+                }
+
+            } catch (IOException e) {
+                OutputHandler.out(e.getMessage());
+
+            } catch (Exception e) {
+                e.printStackTrace();
+            }
+
+        }
+
+    }
+    /**
+     * Encapsulate writing to a SDF file
+     *
+     * @author Christian Schmidt 2005
+     *
+     */
+    private class SDFTarget implements Target {
+
+        /**
+         * Create a new Instance of SDFTarget
+         *
+         * @throws IOException
+         */
+        public SDFTarget() throws IOException {
+            File target = FileMaker.newFile(targetString, overwrite);
+            theTargetWriter = new SDFWriter(new BufferedOutputStream(
+                    new FileOutputStream(target)), CHARSET);
+        }
+
+        /* (non-Javadoc)
+         * @see com.sun.star.tooling.converter.Converter.Target#getWriter()
+         */
+        public DataWriter getWriter() {
+
+            return theTargetWriter;
+        }
+
+    }
+
+    /**
+     * The interface for all convertable sources
+     *
+     * @author Christian Schmidt 2005
+     *
+     */
+    private interface Source {
+
+        DataReader Source=null;
+        /**
+         * Convert this. to the designated target
+         * @param target the target of the converting
+         * @throws IOException
+         */
+        abstract void convertTo(Target target) throws IOException;
+    }
+
+    /**
+     * The interface for all creatable targets
+     *
+     * @author Christian Schmidt 2005
+     *
+     */
+    private interface Target {
+        /**
+         * The writer to use
+         */
+        public OutputStream writer = null;
+
+        /**
+         * Get the writer
+         * this target uses to write the
+         * data in the correct format.
+         *
+         * @return the used DataWriter
+         */
+        abstract DataWriter getWriter();
+
+    }
+    /**
+     * Encapsulate the reading from an XLIFF file
+     *
+     * @author Christian Schmidt 2005
+     *
+     */
+    private class XLIFFSource implements Source {
+        File source;
+
+        /**
+         * Create a new Instance of XLIFFSource
+         *
+         *
+         */
+        public XLIFFSource() {
+
+            source = new File(sourceString);
+        }
+
+        public void convertTo(Target t) throws IOException {
+            try {
+                System.setProperty("entityExpansionLimit", "1000000");
+                boolean laden = source.canRead();
+                if (laden) {
+                    DefaultHandler contentHandler=null;
+                    if("dbxliff".equalsIgnoreCase(sourceType)){
+                        contentHandler = new XLIFFReader(handler, t
+                                .getWriter(),false);
+                    }else{
+                        contentHandler = new XLIFFReader(handler, t
+                            .getWriter());
+                    }
+                    SAXParserFactory factory = SAXParserFactory.newInstance();
+                    factory.setNamespaceAware( true );
+                    factory.setValidating( true );
+
+                    SAXParser parser=factory.newSAXParser();
+                    XMLReader xliffreader=parser.getXMLReader();
+
+
+
+//                    XMLReader xliffreader = XMLReaderFactory
+//                            .createXMLReader("org.apache.crimson.parser.XMLReaderImpl");
+                    xliffreader.setErrorHandler(contentHandler);
+                    xliffreader.setContentHandler(contentHandler);
+                    /* one possibility to resolve an extern entity (DTD) */
+                    EntityResolver res = new Resolver();
+                    xliffreader.setEntityResolver(res);
+                    /*
+                     * a second possibility to resolve an extern entity (DTD)
+                     *
+                     * xliffreader.setFeature("xml.org/sax/features/validation",true);
+                     * xliffreader.setEntityResolver(new EntityResolver() {
+                     * public InputSource resolveEntity(java.lang.String
+                     * publicId, java.lang.String systemId) throws SAXException,
+                     * java.io.IOException { if (publicId.equals("-//XLIFF//DTD
+                     * XLIFF//EN")) // this deactivates the open office DTD
+                     * return new InputSource(new ByteArrayInputStream( " <?xml
+                     * version='1.0' encoding='UTF-8'?>" .getBytes())); else
+                     * return null; } });
+                     *
+                     */
+
+                    xliffreader.parse(sourceString);
+
+                } else {
+                    System.out.println("Datei existiert nicht");
+                }
+
+            } catch (SAXParseException e) {
+                try {
+                    theTargetWriter.flush();
+                } catch (IOException e1) {
+
+                    e1.printStackTrace();
+                }
+                OutputHandler.out("PARSE ERROR Zeile " + e.getLineNumber()
+                        + ", " + e.getMessage());
+
+            }catch (SAXException e){
+                try {
+                    theTargetWriter.flush();
+                } catch (IOException e1) {
+
+                    e1.printStackTrace();
+                }
+                OutputHandler.out("PARSE EXCEPTION " +  e.getMessage());
+            } catch (ParserConfigurationException e) {
+                OutputHandler.out("PARSER Configuration failed\n " +  e.getMessage());
+            }
+        }
+
+    }
+    /**
+     * Encapsulate writing to a XLIFF file
+     *
+     * @author Christian Schmidt 2005
+     *
+     */
+    private class XLIFFTarget implements Target {
+        File target;
+
+        /**
+         * Create a new Instance of XLIFFTarget
+         *
+         * @throws FileNotFoundException
+         * @throws IOException
+         */
+        public XLIFFTarget() throws FileNotFoundException, IOException {
+            target = FileMaker.newFile(targetString, overwrite);
+            theTargetWriter = new XLIFFWriter(new BufferedOutputStream(
+                    new FileOutputStream(target)), CHARSET);
+
+        }
+
+        public DataWriter getWriter() {
+
+            return theTargetWriter;
+        }
+    }
+
+
+}
\ No newline at end of file