Laboratoire ICAR » Plateforme TXM

<?xml version="1.0" encoding="UTF-8"?>

<projectDescription>

	<name>org.txm.utils.core</name>

	<comment></comment>

	<projects>

	</projects>

	<buildSpec>

		<buildCommand>

			<name>org.eclipse.jdt.core.javabuilder</name>

			<arguments>

			</arguments>

		</buildCommand>

		<buildCommand>

			<name>org.eclipse.pde.ManifestBuilder</name>

			<arguments>

			</arguments>

		</buildCommand>

		<buildCommand>

			<name>org.eclipse.pde.SchemaBuilder</name>

			<arguments>

			</arguments>

		</buildCommand>

	</buildSpec>

	<natures>

		<nature>org.eclipse.pde.PluginNature</nature>

		<nature>org.eclipse.jdt.core.javanature</nature>

	</natures>

</projectDescription>

package org.txm.utils;

import java.io.File;

import java.io.IOException;

import java.util.LinkedHashMap;

import org.mozilla.universalchardet.CharsetListener;

import org.mozilla.universalchardet.UniversalDetector;

import org.txm.utils.io.IOUtils;

public class CharsetDetector {

	public static int MINIMALSIZE = 2000;

	String encoding = System.getProperty("file.encoding"); //$NON-NLS-1$

	LinkedHashMap<String, Integer> encodings = new LinkedHashMap<String, Integer>();

	public CharsetDetector(File file) {

		if (file.isDirectory())

			processDirectory(file);

		else

			try {

				processFile(file);

			} catch (IOException e) {

				// TODO Auto-generated catch block

				org.txm.utils.logger.Log.printStackTrace(e);

			}

	}

	private void processDirectory(File dir) {

		for (File file : dir.listFiles(IOUtils.HIDDENFILE_FILTER)) {

			if (file.isFile()) {

				try {

					processFile(file);

				} catch (IOException e) {

					// TODO Auto-generated catch block

					org.txm.utils.logger.Log.printStackTrace(e);

				}

			}

		}

	}

	String guessedCharset = System.getProperty("file.encoding"); //$NON-NLS-1$

	private void processFile(File file) throws IOException {

		guessedCharset = System.getProperty("file.encoding"); //$NON-NLS-1$

		UniversalDetector detector = new UniversalDetector(new CharsetListener() {

			@Override

			public void report(String name) {

				guessedCharset = name;

			}

		});

		byte[] buf = new byte[4096];

		java.io.FileInputStream fis = new java.io.FileInputStream(file);

		int nread;

		while ((nread = fis.read(buf)) > 0 && !detector.isDone()) {

			detector.handleData(buf, 0, nread);

		}

		detector.dataEnd();

		if (!encodings.containsKey(guessedCharset))

			encodings.put(guessedCharset, 0);

		encodings.put(guessedCharset, encodings.get(guessedCharset) + 1);

		fis.close();

	}

	public String getEncoding() {

		int max = 0;

		for (String s : encodings.keySet()) {

			if (max < encodings.get(s)) {

				max = encodings.get(s);

				encoding = s;

			}

		}

		return encoding;

	}

	public LinkedHashMap<String, Integer> getEncodings() {

		return encodings;

	}

	public static void main(String[] args) {

		CharsetDetector detector = new CharsetDetector(new File("/home/mdecorde/Bureau/testencoding")); //$NON-NLS-1$

		System.out.println(detector.getEncodings());

	}

}

package org.txm.utils;

import java.util.Date;

import org.txm.utils.messages.UtilsCoreMessages;

public class ExecTimer {

	static long startTime = 0, endTime = 0;

	static String message = ""; //$NON-NLS-1$

	public static void start() {

		startTime = new Date().getTime();

	}

	public static String stop() {

		endTime = new Date().getTime();

		return setMessage(endTime - startTime);

	}

	static float t;

	private static String setMessage(float time) {

		t = time;

		if (t < 1000) {

			message = "" + ((int) t) + UtilsCoreMessages.ExecTimer_0; //$NON-NLS-1$

		} else {

			t = t / 1000;

			if (t < 3) {

				message = "" + t; //$NON-NLS-1$

				message = "" + (message.substring(0, 3)) + UtilsCoreMessages.ExecTimer_1; //$NON-NLS-1$

			} else if (t < 60)

				message = "" + ((int) t) + UtilsCoreMessages.ExecTimer_1; //$NON-NLS-1$

			else if (t < 3600)

				message = "" + ((int) t / 60) + UtilsCoreMessages.ExecTimer_2 + ((int) t % 60) + UtilsCoreMessages.ExecTimer_1; //$NON-NLS-1$

			else

				message = "" + ((int) t / 3600) + UtilsCoreMessages.ExecTimer_3 + ((int) (t % 3600) / 60) + UtilsCoreMessages.ExecTimer_2 + ((int) (t % 3600) % 60) + UtilsCoreMessages.ExecTimer_1; //$NON-NLS-1$

		}

		return message + " (" + (int) time + " ms)"; //$NON-NLS-1$ //$NON-NLS-2$

	}

	public static String getMessage() {

		return message;

	}

}

package org.txm.utils;

/*

 * $Log: DiffPrint.java,v $

 * Revision 1.10  2009/04/20 18:53:29  stuart

 * Make print_header public.

 *

 * Revision 1.9  2009/01/19 03:05:26  stuart

 * Fix StackOverflow bug with heuristic on reported by Jimmy Han.

 *

 * Revision 1.8  2007/12/20 05:04:21  stuart

 * Can no longer import from default package.

 *

 * Revision 1.7  2007/12/20 04:29:53  stuart

 * Fix setupOutput permission.  Thanks to Sargon Benjamin

 *

 * Revision 1.6  2005/04/27 02:13:40  stuart

 * Add Str.dup()

 *

 * Revision 1.5  2004/01/29 02:35:35  stuart

 * Test for out of bounds exception in UnifiedPrint.print_hunk.

 * Add setOutput() to DiffPrint.Base.

 *

 * Revision 1.4  2003/04/22  01:50:47  stuart

 * add Unified format diff

 *

 * Revision 1.3  2003/04/22  01:00:32  stuart

 * added context diff format

 *

 * Revision 1.2  2000/03/02  16:59:54  stuart

 * add GPL

 *

 */

import java.io.*;

import java.util.Vector;

import java.util.Date;

interface UnaryPredicate {

	boolean execute(Object obj);

}

/**

 * A simple framework for printing change lists produced by <code>Diff</code>.

 * 

 * @see bmsi.util.Diff

 * @author Stuart D. Gathman Copyright (C) 2000 Business Management Systems,

 *         Inc.

 *         <p>

 *         This program is free software; you can redistribute it and/or modify

 *         it under the terms of the GNU General Public License as published by

 *         the Free Software Foundation; either version 1, or (at your option)

 *         any later version.

 *         <p>

 *         This program 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

 *         General Public License for more details.

 *         <p>

 *         You should have received a copy of the GNU General Public License

 *         along with this program; if not, write to the Free Software

 *         Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.

 */

public class DiffPrint {

	/**

	 * A Base class for printing edit scripts produced by Diff. This class divides

	 * the change list into "hunks", and calls <code>print_hunk</code> for each

	 * hunk. Various utility methods are provided as well.

	 */

	public static abstract class Base {

		protected PrintWriter outfile;

		public void setOutput(Writer wtr) {

			outfile = new PrintWriter(wtr);

		}

		protected void setupOutput() {

			if (outfile == null)

				outfile = new PrintWriter(new OutputStreamWriter(System.out));

		}

		protected Base(Object[] a, Object[] b) {

			file0 = a;

			file1 = b;

		}

		/**

		 * Set to ignore certain kinds of lines when printing an edit script. For

		 * example, ignoring blank lines or comments.

		 */

		protected UnaryPredicate ignore = null;

		/**

		 * Set to the lines of the files being compared.

		 */

		protected Object[] file0, file1;

		/**

		 * Divide SCRIPT into pieces by calling HUNKFUN and print each piece with

		 * PRINTFUN. Both functions take one arg, an edit script.

		 * 

		 * PRINTFUN takes a subscript which belongs together (with a null link at the

		 * end) and prints it.

		 */

		public void print_script(Diff.change script) {

			setupOutput();

			Diff.change next = script;

			while (next != null) {

				Diff.change t, end;

				/* Find a set of changes that belong together. */

				t = next;

				end = hunkfun(next);

				/*

				 * Disconnect them from the rest of the changes, making them a hunk, and

				 * remember the rest for next iteration.

				 */

				next = end.link;

				end.link = null;

				// if (DEBUG)

				// debug_script(t);

				/* Print this hunk. */

				print_hunk(t);

				/* Reconnect the script so it will all be freed properly. */

				end.link = next;

			}

			outfile.flush();

		}

		/**

		 * Called with the tail of the script and returns the last link that belongs

		 * together with the start of the tail.

		 */

		protected Diff.change hunkfun(Diff.change hunk) {

			return hunk;

		}

		protected int first0, last0, first1, last1, deletes, inserts;

		/**

		 * Look at a hunk of edit script and report the range of lines in each file that

		 * it applies to. HUNK is the start of the hunk, which is a chain of `struct

		 * change'. The first and last line numbers of file 0 are stored in *FIRST0 and

		 * *LAST0, and likewise for file 1 in *FIRST1 and *LAST1. Note that these are

		 * internal line numbers that count from 0.

		 * 

		 * If no lines from file 0 are deleted, then FIRST0 is LAST0+1.

		 * 

		 * Also set *DELETES nonzero if any lines of file 0 are deleted and set *INSERTS

		 * nonzero if any lines of file 1 are inserted. If only ignorable lines are

		 * inserted or deleted, both are set to 0.

		 */

		protected void analyze_hunk(Diff.change hunk) {

			int f0, l0 = 0, f1, l1 = 0, show_from = 0, show_to = 0;

			int i;

			Diff.change next;

			boolean nontrivial = (ignore == null);

			show_from = show_to = 0;

			f0 = hunk.line0;

			f1 = hunk.line1;

			for (next = hunk; next != null; next = next.link) {

				l0 = next.line0 + next.deleted - 1;

				l1 = next.line1 + next.inserted - 1;

				show_from += next.deleted;

				show_to += next.inserted;

				for (i = next.line0; i <= l0 && !nontrivial; i++)

					if (!ignore.execute(file0[i]))

						nontrivial = true;

				for (i = next.line1; i <= l1 && !nontrivial; i++)

					if (!ignore.execute(file1[i]))

						nontrivial = true;

			}

			first0 = f0;

			last0 = l0;

			first1 = f1;

			last1 = l1;

			/*

			 * If all inserted or deleted lines are ignorable, tell the caller to ignore

			 * this hunk.

			 */

			if (!nontrivial)

				show_from = show_to = 0;

			deletes = show_from;

			inserts = show_to;

		}

		/**

		 * Called to print the script header which identifies the files compared. The

		 * default does nothing (except set output to system.out if not otherwise set).

		 * Derived style classes can override to print the files compared in the format

		 * for that style.

		 */

		public void print_header(String filea, String fileb) {

			setupOutput();

		}

		protected abstract void print_hunk(Diff.change hunk);

		protected void print_1_line(String pre, Object linbuf) {

			outfile.println(pre + linbuf.toString());

		}

		/**

		 * Print a pair of line numbers with SEPCHAR, translated for file FILE. If the

		 * two numbers are identical, print just one number.

		 * 

		 * Args A and B are internal line numbers. We print the translated (real) line

		 * numbers.

		 */

		protected void print_number_range(char sepchar, int a, int b) {

			/*

			 * Note: we can have B < A in the case of a range of no lines. In this case, we

			 * should print the line number before the range, which is B.

			 */

			if (++b > ++a)

				outfile.print("" + a + sepchar + b);

			else

				outfile.print(b);

		}

		public static char change_letter(int inserts, int deletes) {

			if (inserts == 0)

				return 'd';

			else if (deletes == 0)

				return 'a';

			else

				return 'c';

		}

	}

	/**

	 * Print a change list in the standard diff format.

	 */

	public static class NormalPrint extends Base {

		public NormalPrint(Object[] a, Object[] b) {

			super(a, b);

		}

		/**

		 * Print a hunk of a normal diff. This is a contiguous portion of a complete

		 * edit script, describing changes in consecutive lines.

		 */

		protected void print_hunk(Diff.change hunk) {

			/* Determine range of line numbers involved in each file. */

			analyze_hunk(hunk);

			if (deletes == 0 && inserts == 0)

				return;

			/* Print out the line number header for this hunk */

			print_number_range(',', first0, last0);

			outfile.print(change_letter(inserts, deletes));

			print_number_range(',', first1, last1);

			outfile.println();

			/* Print the lines that the first file has. */

			if (deletes != 0)

				for (int i = first0; i <= last0; i++)

					print_1_line("< ", file0[i]);

			if (inserts != 0 && deletes != 0)

				outfile.println("---");

			/* Print the lines that the second file has. */

			if (inserts != 0)

				for (int i = first1; i <= last1; i++)

					print_1_line("> ", file1[i]);

		}

	}

	/**

	 * Prints an edit script in a format suitable for input to <code>ed</code>. The

	 * edit script must be generated with the reverse option to be useful as actual

	 * <code>ed</code> input.

	 */

	public static class EdPrint extends Base {

		public EdPrint(Object[] a, Object[] b) {

			super(a, b);

		}

		/** Print a hunk of an ed diff */

		protected void print_hunk(Diff.change hunk) {

			/* Determine range of line numbers involved in each file. */

			analyze_hunk(hunk);

			if (deletes == 0 && inserts == 0)

				return;

			/* Print out the line number header for this hunk */

			print_number_range(',', first0, last0);

			outfile.println(change_letter(inserts, deletes));

			/* Print new/changed lines from second file, if needed */

			if (inserts != 0) {

				boolean inserting = true;

				for (int i = first1; i <= last1; i++) {

					/* Resume the insert, if we stopped. */

					if (!inserting)

						outfile.println(i - first1 + first0 + "a");

					inserting = true;

					/*

					 * If the file's line is just a dot, it would confuse `ed'. So output it with a

					 * double dot, and set the flag LEADING_DOT so that we will output another

					 * ed-command later to change the double dot into a single dot.

					 */

					if (".".equals(file1[i])) {

						outfile.println("..");

						outfile.println(".");

						/* Now change that double dot to the desired single dot. */

						outfile.println(i - first1 + first0 + 1 + "s/^\\.\\././");

						inserting = false;

					} else

						/* Line is not `.', so output it unmodified. */

						print_1_line("", file1[i]);

				}

				/* End insert mode, if we are still in it. */

				if (inserting)

					outfile.println(".");

			}

		}

	}

	/**

	 * Prints an edit script in context diff format. This and its 'unified'

	 * variation is used for source code patches.

	 */

	public static class ContextPrint extends Base {

		protected int context = 3;

		public ContextPrint(Object[] a, Object[] b) {

			super(a, b);

		}

		protected void print_context_label(String mark, File inf, String label) {

			setupOutput();

			if (label != null)

				outfile.println(mark + ' ' + label);

			else if (inf.lastModified() > 0)

				// FIXME: use DateFormat to get precise format needed.

				outfile.println(mark + ' ' + inf.getPath() + '\t' + new Date(inf.lastModified()));

			else

				/* Don't pretend that standard input is ancient. */

				outfile.println(mark + ' ' + inf.getPath());

		}

		public void print_header(String filea, String fileb) {

			print_context_label("***", new File(filea), filea);

			print_context_label("---", new File(fileb), fileb);

		}

		/** If function_regexp defined, search for start of function. */

		private String find_function(Object[] lines, int start) {

			return null;

		}

		protected void print_function(Object[] file, int start) {

			String function = find_function(file0, first0);

			if (function != null) {

				outfile.print(" ");

				outfile.print((function.length() < 40) ? function : function.substring(0, 40));

			}

		}

		protected void print_hunk(Diff.change hunk) {

			/* Determine range of line numbers involved in each file. */

			analyze_hunk(hunk);

			if (deletes == 0 && inserts == 0)

				return;

			/* Include a context's width before and after. */

			first0 = Math.max(first0 - context, 0);

			first1 = Math.max(first1 - context, 0);

			last0 = Math.min(last0 + context, file0.length - 1);

			last1 = Math.min(last1 + context, file1.length - 1);

			outfile.print("***************");

			/*

			 * If we looked for and found a function this is part of, include its name in

			 * the header of the diff section.

			 */

			print_function(file0, first0);

			outfile.println();

			outfile.print("*** ");

			print_number_range(',', first0, last0);

			outfile.println(" ****");

			if (deletes != 0) {

				Diff.change next = hunk;

				for (int i = first0; i <= last0; i++) {

					/*

					 * Skip past changes that apply (in file 0) only to lines before line I.

					 */

					while (next != null && next.line0 + next.deleted <= i)

						next = next.link;

					/* Compute the marking for line I. */

					String prefix = " ";

					if (next != null && next.line0 <= i)

						/*

						 * The change NEXT covers this line. If lines were inserted here in file 1, this

						 * is "changed". Otherwise it is "deleted".

						 */

						prefix = (next.inserted > 0) ? "!" : "-";

					print_1_line(prefix, file0[i]);

				}

			}

			outfile.print("--- ");

			print_number_range(',', first1, last1);

			outfile.println(" ----");

			if (inserts != 0) {

				Diff.change next = hunk;

				for (int i = first1; i <= last1; i++) {

					/*

					 * Skip past changes that apply (in file 1) only to lines before line I.

					 */

					while (next != null && next.line1 + next.inserted <= i)

						next = next.link;

					/* Compute the marking for line I. */

					String prefix = " ";

					if (next != null && next.line1 <= i)

						/*

						 * The change NEXT covers this line. If lines were deleted here in file 0, this

						 * is "changed". Otherwise it is "inserted".

						 */

						prefix = (next.deleted > 0) ? "!" : "+";

					print_1_line(prefix, file1[i]);

				}

			}

		}

	}

	/**

	 * Prints an edit script in context diff format. This and its 'unified'

	 * variation is used for source code patches.

	 */

	public static class UnifiedPrint extends ContextPrint {

		public UnifiedPrint(Object[] a, Object[] b) {

			super(a, b);

		}

		public void print_header(String filea, String fileb) {

			print_context_label("---", new File(filea), filea);

			print_context_label("+++", new File(fileb), fileb);

		}

		private void print_number_range(int a, int b) {

			// translate_range (file, a, b, &trans_a, &trans_b);

			/*

			 * Note: we can have B < A in the case of a range of no lines. In this case, we

			 * should print the line number before the range, which is B.

			 */

			if (b < a)

				outfile.print(b + ",0");

			else

				super.print_number_range(',', a, b);

		}

		protected void print_hunk(Diff.change hunk) {

			/* Determine range of line numbers involved in each file. */

			analyze_hunk(hunk);

			if (deletes == 0 && inserts == 0)

				return;

			/* Include a context's width before and after. */

			first0 = Math.max(first0 - context, 0);

			first1 = Math.max(first1 - context, 0);

			last0 = Math.min(last0 + context, file0.length - 1);

			last1 = Math.min(last1 + context, file1.length - 1);

			outfile.print("@@ -");

			print_number_range(first0, last0);

			outfile.print(" +");

			print_number_range(first1, last1);

			outfile.print(" @@");

			/*

			 * If we looked for and found a function this is part of, include its name in

			 * the header of the diff section.

			 */

			print_function(file0, first0);

			outfile.println();

			Diff.change next = hunk;

			int i = first0;

			int j = first1;

			while (i <= last0 || j <= last1) {

				/* If the line isn't a difference, output the context from file 0. */

				if (next == null || i < next.line0) {

					if (i < file0.length) {

						outfile.print(' ');

						print_1_line("", file0[i++]);

					}

					j++;

				} else {

					/* For each difference, first output the deleted part. */

					int k = next.deleted;

					while (k-- > 0) {

						outfile.print('-');

						print_1_line("", file0[i++]);

					}

					/* Then output the inserted part. */

					k = next.inserted;

					while (k-- > 0) {

						outfile.print('+');

						print_1_line("", file1[j++]);

					}

					/* We're done with this hunk, so on to the next! */

					next = next.link;

				}

			}

		}

	}

	/**

	 * Read a text file into an array of String. This provides basic diff

	 * functionality. A more advanced diff utility will use specialized objects to

	 * represent the text lines, with options to, for example, convert sequences of

	 * whitespace to a single space for comparison purposes.

	 */

	static String[] slurp(String file) throws IOException {

		BufferedReader rdr = new BufferedReader(new FileReader(file));

		Vector s = new Vector();

		for (;;) {

			String line = rdr.readLine();

			if (line == null)

				break;

			s.addElement(line);

		}

		String[] a = new String[s.size()];

		s.copyInto(a);

		rdr.close();

		return a;

	}

	public static void main(String[] argv) throws IOException {

		String filea = argv[argv.length - 2];

		String fileb = argv[argv.length - 1];

		String[] a = slurp(filea);

		String[] b = slurp(fileb);

		Diff d = new Diff(a, b);

		char style = 'n';

		d.heuristic = false;

		for (int i = 0; i < argv.length - 2; ++i) {

			String f = argv[i];

			if (f.startsWith("-")) {

				for (int j = 1; j < f.length(); ++j) {

					switch (f.charAt(j)) {

					case 'H': // heuristic on

						d.heuristic = true;

						break;

					case 'e': // Ed style

						style = 'e';

						break;

					case 'c': // Context diff

						style = 'c';

						break;

					case 'u':

						style = 'u';

						break;

					}

				}

			}

		}

		boolean reverse = style == 'e';

		Diff.change script = d.diff_2(reverse);

		if (script == null)

			System.err.println("No differences");

		else {

			Base p;

			switch (style) {

			case 'e':

				p = new EdPrint(a, b);

				break;

			case 'c':

				p = new ContextPrint(a, b);

				break;

			case 'u':

				p = new UnifiedPrint(a, b);

				break;

			default:

				p = new NormalPrint(a, b);

			}

			p.print_header(filea, fileb);

			p.print_script(script);

		}

	}

}

package org.txm.utils.io;

import java.io.BufferedOutputStream;

import java.io.BufferedReader;

import java.io.File;

import java.io.FileFilter;

import java.io.FileInputStream;

import java.io.FileNotFoundException;

import java.io.FileOutputStream;

import java.io.IOException;

import java.io.InputStream;

import java.io.InputStreamReader;

import java.io.OutputStream;

import java.io.OutputStreamWriter;

import java.io.PrintWriter;

import java.io.UnsupportedEncodingException;

import java.net.MalformedURLException;

import java.net.URL;

import java.net.URLConnection;

import java.util.ArrayList;

import java.util.regex.Matcher;

import java.util.regex.Pattern;

import org.eclipse.osgi.util.NLS;

import org.txm.utils.FileUtils;

import org.txm.utils.i18n.DetectBOM;

import org.txm.utils.logger.Log;

public class IOUtils {

	public static final String UTF8 = "UTF-8"; //$NON-NLS-1$

	public static ArrayList<String> findWithGroup(File file, String pattern) throws IOException {

		return findWithGroup(file, UTF8, pattern, false);

	}

	public static ArrayList<String> findWithGroup(File file, String pattern, boolean normalizeSeparators) throws IOException {

		return findWithGroup(file, UTF8, pattern, normalizeSeparators);

	}

	public static ArrayList<String> findWithGroup(File file, String encoding, String pattern) throws IOException {

		return findWithGroup(file, encoding, pattern, false);

	}

	/**

	 * select only files not hidden @deprecated

	 */

	public static final FileFilter HIDDENFILE_FILTER = FileUtils.HIDDENFILE_FILTER;

	public static ArrayList<String> findWithGroup(File file, String encoding, String pattern, boolean normalizeSeparators) throws IOException {

		ArrayList<String> matches = new ArrayList<String>();

		String text = IOUtils.getText(file, encoding);

		if (normalizeSeparators) {

			text = text.replaceAll("\\s", " "); //$NON-NLS-1$

			text = text.replaceAll("\\t", " "); //$NON-NLS-1$

			text = text.replaceAll("\\n", " "); //$NON-NLS-1$

			text = text.replaceAll("[ ]+", " "); //$NON-NLS-1$

		}

		Pattern test = Pattern.compile(pattern);

		Matcher m = test.matcher(text);

		while (m.find()) {

			matches.add(m.group(1));

		}

		return matches;

	}

	public static ArrayList<String> find(File file, String pattern) throws IOException {

		return find(file, UTF8, pattern, false);

	}

	public static ArrayList<String> find(File file, String pattern, boolean normalizeSeparators) throws IOException {

		return findWithGroup(file, UTF8, pattern, normalizeSeparators);

	}

	public static ArrayList<String> find(File file, String encoding, String pattern) throws IOException {

		return find(file, encoding, pattern, false);

	}

	public static ArrayList<String> find(File file, String encoding, String pattern, boolean normalizeSeparators) throws IOException {

		ArrayList<String> matches = new ArrayList<String>();

		String text = IOUtils.getText(file, encoding);

		// System.out.println(text);

		if (normalizeSeparators) {

			text = text.replaceAll("\\s", " "); //$NON-NLS-1$ //$NON-NLS-2$

			text = text.replaceAll("\\t", " "); //$NON-NLS-1$ //$NON-NLS-2$

			text = text.replaceAll("\\n", " "); //$NON-NLS-1$ //$NON-NLS-2$

			text = text.replaceAll("[ ]+", " "); //$NON-NLS-1$ //$NON-NLS-2$

		}

		Pattern test = Pattern.compile(pattern);

		Matcher m = test.matcher(text);

		while (m.find()) {

			matches.add(m.group());

		}

		return matches;

	}

	public static BufferedReader getReader(File file) throws UnsupportedEncodingException, FileNotFoundException {

		return getReader(file, UTF8);

	}

	/**

	 * 

	 * @param file

	 * @param encoding

	 *            if null the "UTF-8" encoding is used

	 * @return

	 * @throws UnsupportedEncodingException

	 * @throws FileNotFoundException

	 */

	public static BufferedReader getReader(File file, String encoding) throws UnsupportedEncodingException, FileNotFoundException {

		if (encoding == null) {

			encoding = UTF8; // prevent null exception

		}

		FileInputStream input = new FileInputStream(file);

		DetectBOM db = new DetectBOM(file);

		for (int ibom = 0; ibom < db.getBOMSize(); ibom++) {

			try {

				input.read();

			} catch (IOException e) {

				e.printStackTrace();

			}

		}

		return new BufferedReader(new InputStreamReader(input, encoding));

	}

	public static BufferedReader getReader(String file) throws UnsupportedEncodingException, FileNotFoundException {

		return getReader(new File(file), UTF8);

	}

	public static BufferedReader getReader(URL url) throws IOException {

		return getReader(url, UTF8);

	}

	public static BufferedReader getReader(URL url, String encoding) throws IOException {

		if (encoding == null) {

			encoding = UTF8; // prevent null exception

		}

		URLConnection conn = url.openConnection();

		InputStream inputStream = conn.getInputStream();

		return new BufferedReader(new InputStreamReader(inputStream, encoding));

	}

	public static void setText(File file, String text, String encoding) throws IOException {

		PrintWriter writer = getWriter(file, encoding);

		writer.print(text);

		writer.close();

	}

	public static String getText(URL url, String encoding) throws IOException {

		BufferedReader reader = getReader(url, encoding);

		StringBuilder builder = new StringBuilder();

		try {

			String line = reader.readLine();

			while (line != null) {

				builder.append(line);

				line = reader.readLine();

				if (line != null)

					builder.append("\n"); //$NON-NLS-1$

			}

		} finally {

			reader.close();

		}

		return builder.toString();

	}

	public static String getText(File file) throws IOException {

		return getText(file, UTF8);

	}

	public static String getText(File file, String encoding) throws IOException {

		BufferedReader reader = getReader(file, encoding);

		StringBuilder builder = new StringBuilder();

		try {

			String line = reader.readLine();

			while (line != null) {

				builder.append(line);

				line = reader.readLine();

				if (line != null)

					builder.append("\n"); //$NON-NLS-1$

			}

		} finally {

			reader.close();

		}

		return builder.toString();

	}

	public static PrintWriter getWriter(File file) throws UnsupportedEncodingException, FileNotFoundException {

		return getWriter(file, UTF8);

	}

	public static PrintWriter getWriter(File file, String encoding) throws UnsupportedEncodingException, FileNotFoundException {

		return getWriter(file, encoding, false);

	}

	public static PrintWriter getWriter(File file, boolean append) throws UnsupportedEncodingException, FileNotFoundException {

		return getWriter(file, UTF8, append);

	}

	public static PrintWriter getWriter(File file, String encoding, boolean append) throws UnsupportedEncodingException, FileNotFoundException {

		if (encoding == null) {

			encoding = UTF8; // prevent null exception

		}

		return new PrintWriter(new OutputStreamWriter(new BufferedOutputStream(new FileOutputStream(file, append)), encoding));

	}

	public static PrintWriter getWriter(String file) throws UnsupportedEncodingException, FileNotFoundException {

		return getWriter(new File(file), UTF8);

	}

	public static boolean write(File file, String str) {

		PrintWriter writer = null;

		try {

			writer = getWriter(file);

			writer.write(str);

		} catch(Exception e) {

			Log.warning(NLS.bind("Error while writing the {0} file: {1}", file, e));

			return false;

		} finally {

			if (writer != null) {

				writer.close();

			}

		}

		return true;

	}

	public static ArrayList<String> getLines(File file, String encoding) {

		ArrayList<String> lines = new ArrayList<String>();

		try {

			BufferedReader reader = IOUtils.getReader(file, encoding);

			String line = reader.readLine();

			while (line != null) {

				lines.add(line);

				line = reader.readLine();

			}

			reader.close();

		} catch (Exception e) {

			System.err.println(NLS.bind("Error while getting lines: {0}.", e.getLocalizedMessage()));

		}

		return lines;

	}

	/**

	 * 

	 * @param manifest

	 * @return an InputStream, dont forget to close it

	 * @throws MalformedURLException

	 * @throws IOException

	 */

	public static InputStream getInput(File file) throws MalformedURLException, IOException {

		return file.toURI().toURL().openStream();

	}

	public static OutputStream getOutputStream(File file) throws FileNotFoundException {

		return new BufferedOutputStream(new FileOutputStream(file, false));

	}

	public static OutputStream getOutputStream(File file, boolean append) throws FileNotFoundException {

		return new BufferedOutputStream(new FileOutputStream(file, append));

	}

	public static void replace(File file, String oldString, String newString) throws IOException {

		String text = getText(file, UTF8);

		text = text.replace(oldString, newString);

		IOUtils.write(file, text);

	}

	public static void replaceAll(File file, Pattern regex, String newString) throws IOException {

		String text = getText(file, UTF8);

		text = regex.matcher(text).replaceAll(newString);

		IOUtils.write(file, text);

	}

	public static String firstLine(File file) {

		try {

			BufferedReader reader = getReader(file);

			String line = reader.readLine();

			reader.close();

			return line;

		} catch (Exception e) {

			return null;

		}

	}

}

// Copyright © 2010-2020 ENS de Lyon., University of Franche-Comté

// Copyright © 2007-2010 ENS de Lyon, CNRS, INRP, University of

// Lyon 2, University of Franche-Comté, University of Nice

// Sophia Antipolis, University of Paris 3.

// 

// The TXM platform is free software: you can redistribute it

// and/or modify it under the terms of the GNU General Public

// License as published by the Free Software Foundation,

// either version 2 of the License, or (at your option) any

// later version.

// 

// The TXM platform 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 General Public License for more

// details.

// 

// You should have received a copy of the GNU General

// Public License along with the TXM platform. If not, see

// http://www.gnu.org/licenses.

// 

// 

// 

// $LastChangedDate: 2016-11-17 17:01:31 +0100 (Thu, 17 Nov 2016) $

// $LastChangedRevision: 3341 $

// $LastChangedBy: mdecorde $ 

//

package org.txm.utils.io;

import java.io.BufferedOutputStream;

import java.io.File;

import java.io.FileInputStream;

import java.io.FileOutputStream;

import java.io.IOException;

import java.nio.MappedByteBuffer;

import java.nio.channels.FileChannel;

import java.nio.file.Files;

import java.nio.file.Path;

import org.txm.utils.messages.UtilsCoreMessages;

/**

 * File copy methods

 */

public class FileCopy {

	private static final boolean isWindows = System.getProperty("os.name").contains("Windows");

	/**

	 * replace the file if it exists

	 * 

	 * @param source

	 * @param dest

	 * @return

	 * @throws IOException

	 */

	public static boolean copy(File source, File dest) throws IOException {

		return copy(source, dest, true);

	}

	/**

	 * copy one file with nio package to accelerate the copy

	 * 

	 * !!! on windows : max size = 64mo !!!.

	 * 

	 * resolve symbolic links

	 *

	 * @param source

	 *            the source

	 * @param dest

	 *            the dest

	 * @return true, if successful

	 * @throws IOException

	 *             Signals that an I/O exception has occurred.

	 */

	public static boolean copy(File source, File dest, boolean replace) throws IOException {

		if (dest.exists() && !replace)

			return true; // don't replace file

		if (isWindows || source.length() >= Integer.MAX_VALUE) {

			// System.out.println("COPY BIG FILE");

			FileInputStream instream = null;

			BufferedOutputStream outstream = null;

			try {

				// Open a stream of bytes to read the file bytes into the program

				instream = new FileInputStream(source);

				// A stream of bytes from the program to the destination

				outstream = new BufferedOutputStream(new FileOutputStream(dest));

				byte[] buffer = new byte[4096];

				int bytesRead;

				// Write the bytes from the inputstream to the outputstream

				while ((bytesRead = instream.read(buffer)) != -1) {

					outstream.write(buffer, 0, bytesRead);

				}

			} catch (Exception e) {

				org.txm.utils.logger.Log.printStackTrace(e);

				return false;

			} finally {

				if (instream != null)

					instream.close();

				if (outstream != null)

					outstream.close();

				instream = null;

				outstream = null;

			}

		} else {

			// System.out.println("COPY NORMAL FILE");

			FileChannel in = null, out = null;

			FileInputStream fis = null;

			FileOutputStream fos = null;

			try {

				fis = new FileInputStream(source);

				fos = new FileOutputStream(dest);

				in = fis.getChannel();

				out = fos.getChannel();

				long size = in.size();

				MappedByteBuffer buf = in.map(FileChannel.MapMode.READ_ONLY, 0, size);

				out.write(buf);

			} catch (Exception e) {

				org.txm.utils.logger.Log.printStackTrace(e);

				if (fis != null)

					fis.close();

				if (fos != null)

					fos.close();

				if (in != null)

					in.close();

				if (out != null)

					out.close();

				return false;

			} finally {

				if (fis != null)

					fis.close();

				if (fos != null)

					fos.close();

				if (in != null)

					in.close();

				if (out != null)

					out.close();

			}

		}

		return true;

	}

	/**

	 * Copy files. Don't erase the destination directory and replace files if they

	 * already exists

	 * 

	 * warning: Symbolic links are not resolved and the link file is recreated

	 *

	 * @param src

	 *            the src directory

	 * @param dest

	 *            the dest directory

	 * @throws IOException

	 *             Signals that an I/O exception has occurred.

	 */

	public static void copyFiles(File src, File dest) throws IOException {

		copyFiles(src, dest, true);

	}

	/**

	 * Copy files. Don't erase the destination directory and replace files if they

	 * already exists

	 *

	 * warning: Symbolic links are not resolved and the link file is recreated

	 *

	 * @param src

	 *            the src directory

	 * @param dest

	 *            the dest directory

	 * @param replace

	 *            replace files if true

	 * @throws IOException

	 *             Signals that an I/O exception has occurred.

	 */

	public static void copyFiles(File src, File dest, boolean replace) throws IOException {

		// Check to ensure that the source is valid...

		if (!src.exists()) {

			throw new IOException(UtilsCoreMessages.FileCopy_0 + src.getAbsolutePath() + "."); //$NON-NLS-1$

		} else if (!src.canRead()) { // check to ensure we have rights to the

			// source...

			throw new IOException(UtilsCoreMessages.FileCopy_2 + src.getAbsolutePath() + "."); //$NON-NLS-1$

		}

		if (Files.isSymbolicLink(src.toPath())) { // copy symbolic links

			Path target = Files.readSymbolicLink(src.toPath());

			Files.createSymbolicLink(dest.toPath(), target);

		} else if (src.isDirectory()) { // is it a directory ?

			if (!dest.exists()) { // does the destination already exist?

				// if not create the file hierarchy

				dest.mkdirs();

				if (!dest.exists()) {

					throw new IOException(UtilsCoreMessages.FileCopy_4 + dest.getAbsolutePath() + "."); //$NON-NLS-1$

				}

			}

			// get a listing of files...

			String list[] = src.list();

			// copy all the files in the list.

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

				File dest1 = new File(dest, list[i]);

				File src1 = new File(src, list[i]);

				copyFiles(src1, dest1);

			}

		} else {

			// This was not a directory, so lets just copy the file

			copy(src, dest, replace);

		}

	}

	public static void main(String[] args) throws IOException {

		// File test1 = File.createTempFile("source", ".large"); //$NON-NLS-1$

		// //$NON-NLS-2$

		// File test2 = File.createTempFile("source", ".verylarge"); //$NON-NLS-1$

		// //$NON-NLS-2$

		//

		// System.out.println("write "+test1); //$NON-NLS-1$

		// writeBigFile(test1, Integer.MAX_VALUE / 2, 1);

		// System.out.println("write "+test2); //$NON-NLS-1$

		// writeBigFile(test2, Integer.MAX_VALUE / 2, 3);

		//

		// System.out.println("test1: "+test1+" : "+test1.length()); //$NON-NLS-1$

		// //$NON-NLS-2$

		// System.out.println("test2: "+test2+" : "+test2.length()); //$NON-NLS-1$

		// //$NON-NLS-2$

		//

		// File copy1 = File.createTempFile("copy", ".large"); //$NON-NLS-1$

		// //$NON-NLS-2$

		// File copy2 = File.createTempFile("copy", ".verylarge"); //$NON-NLS-1$

		// //$NON-NLS-2$

		//

		// System.out.println("Copy1 "+copy1); //$NON-NLS-1$

		// FileCopy.copy(test1, copy1);

		// System.out.println("Copy2 "+copy2); //$NON-NLS-1$

		// FileCopy.copy(test2, copy2);

		//

		// System.out.println("copy1: "+copy1+" : "+copy1.length()); //$NON-NLS-1$

		// //$NON-NLS-2$

		// System.out.println("copy2: "+copy2+" : "+copy2.length()); //$NON-NLS-1$

		// //$NON-NLS-2$

		//

		// System.out.println("delete 1 "+test1.delete()); //$NON-NLS-1$

		// System.out.println("delete 2 "+test2.delete()); //$NON-NLS-1$

		// System.out.println("delete c1 "+copy1.delete()); //$NON-NLS-1$

		// System.out.println("delete c2 "+copy2.delete()); //$NON-NLS-1$

		File dir1 = new File("/home/mdecorde/TEMP/copydir");

		File dir2 = new File("/home/mdecorde/TEMP/copydir3");

		FileCopy.copyFiles(dir1, dir2);

	}

}

package org.txm.utils;

public interface MessagePrinter {

	public void println(String message);

	public void print(String message);

}

// Copyright © 2010-2020 ENS de Lyon., University of Franche-Comté

// Copyright © 2007-2010 ENS de Lyon, CNRS, INRP, University of

// Lyon 2, University of Franche-Comté, University of Nice

// Sophia Antipolis, University of Paris 3.

// 

// The TXM platform is free software: you can redistribute it

// and/or modify it under the terms of the GNU General Public

// License as published by the Free Software Foundation,

// either version 2 of the License, or (at your option) any

// later version.

// 

// The TXM platform 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 General Public License for more

// details.

//