trace/tracebuilder/com.nokia.tracebuilder/src/com/nokia/tracebuilder/file/FileUtils.java
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/trace/tracebuilder/com.nokia.tracebuilder/src/com/nokia/tracebuilder/file/FileUtils.java Wed Jun 23 14:35:40 2010 +0300
@@ -0,0 +1,302 @@
+/*
+* Copyright (c) 2008 Nokia Corporation and/or its subsidiary(-ies).
+* All rights reserved.
+* This component and the accompanying materials are made available
+* under the terms of "Eclipse Public License v1.0"
+* which accompanies this distribution, and is available
+* at the URL "http://www.eclipse.org/legal/epl-v10.html".
+*
+* Initial Contributors:
+* Nokia Corporation - initial contribution.
+*
+* Contributors:
+*
+* Description:
+*
+* File utility functions
+*
+*/
+package com.nokia.tracebuilder.file;
+
+import java.io.BufferedOutputStream;
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.FileNotFoundException;
+import java.io.FileOutputStream;
+import java.io.IOException;
+import java.io.OutputStream;
+import java.net.URI;
+
+import org.eclipse.core.runtime.IPath;
+
+import com.nokia.tracebuilder.source.SourceConstants;
+
+/**
+ * File utility functions
+ *
+ */
+public final class FileUtils {
+
+ /**
+ * File copy buffer size
+ */
+ private static final int COPY_BUFFER_SIZE = 4096; // CodForChk_Dis_Magic
+
+ /**
+ * cpp extension
+ */
+ public final static String CPP_EXTENSION = "cpp"; //$NON-NLS-1$
+
+ /**
+ * c extension
+ */
+ public final static String C_EXTENSION = "c"; //$NON-NLS-1$
+
+ /**
+ * Allowed files
+ */
+ private final static String[] FILE_FILTERS = { ".cpp", //$NON-NLS-1$
+ ".c", //$NON-NLS-1$
+ ".inl", //$NON-NLS-1$
+ ".h" //$NON-NLS-1$
+ };
+
+ /**
+ * MMP file extension
+ */
+ public static final String MMP = ".mmp"; //$NON-NLS-1$
+
+ /**
+ * Creates a file output stream. This creates directories and overwriting
+ * possible read-only flag
+ *
+ * @param file
+ * the file
+ * @return the file output stream
+ * @throws FileNotFoundException
+ * if file cannot be created
+ */
+ public static OutputStream createOutputStream(File file)
+ throws FileNotFoundException {
+ File parent = file.getParentFile();
+ if (!parent.exists()) {
+ parent.mkdirs();
+ }
+ FileOutputStream fos;
+ try {
+ fos = new FileOutputStream(file);
+ } catch (IOException e) {
+ if (file.exists()) {
+ file.delete();
+ }
+ fos = new FileOutputStream(file);
+ }
+ return new BufferedOutputStream(fos);
+ }
+
+ /**
+ * Creates a copy of a file
+ *
+ * @param source
+ * the source file
+ * @param target
+ * the target file
+ * @return true if written successfully
+ */
+ public static boolean copyFile(File source, File target) {
+ boolean backup = true;
+ try {
+ byte[] buf = new byte[COPY_BUFFER_SIZE];
+ FileInputStream fis = new FileInputStream(source);
+ OutputStream fos = createOutputStream(target);
+ int len;
+ do {
+ len = fis.read(buf);
+ if (len > 0) {
+ fos.write(buf, 0, len);
+ }
+ } while (len > 0);
+ fis.close();
+ fos.close();
+ } catch (Exception e) {
+ backup = false;
+ }
+ return backup;
+ }
+
+ /**
+ * Converts file separator characters
+ *
+ * @param separator
+ * separator to be used
+ * @param path
+ * string to be converted
+ * @param addLast
+ * true if the converted string should end with a separator
+ * @return the converted string
+ */
+ public static String convertSeparators(char separator, String path,
+ boolean addLast) {
+ path = path.replace(SourceConstants.FORWARD_SLASH_CHAR, separator);
+ path = path.replace(SourceConstants.BACKSLASH_CHAR, separator);
+ String sepStr = String.valueOf(separator);
+ if (addLast && !path.endsWith(sepStr)) {
+ path += separator;
+ } else if (!addLast && path.endsWith(sepStr)) {
+ path = path.substring(0, path.length() - 1);
+ }
+ return path;
+ }
+
+ /**
+ * Gets the relative path from source to target
+ *
+ * @param source
+ * the source file
+ * @param target
+ * the target file
+ * @return the relative path without file name
+ */
+ public static String getRelativePath(String source, String target) {
+ try {
+ source = new File(source).getCanonicalPath();
+ target = new File(target).getCanonicalPath();
+ } catch (IOException e) {
+ }
+ source = convertSeparators(SourceConstants.FORWARD_SLASH_CHAR, source,
+ false);
+ target = convertSeparators(SourceConstants.FORWARD_SLASH_CHAR, target,
+ false);
+ int len = Math.min(source.length(), target.length());
+ int start = -1;
+ for (int i = 0; i < len && start == -1; i++) {
+ if (source.charAt(i) != target.charAt(i)) {
+ start = i;
+ }
+ }
+ String retval;
+ if (start == -1) {
+ retval = getRelativePathSub(source, target);
+ } else {
+ retval = getRelativePathUnrelated(source, target, start);
+ }
+ return retval;
+ }
+
+ /**
+ * Gets the relative path from source to target when either one is a
+ * sub-directory of another
+ *
+ * @param source
+ * the source
+ * @param target
+ * the target
+ * @return the relative path
+ */
+ private static String getRelativePathSub(String source, String target) {
+ StringBuffer sb = new StringBuffer();
+ if (source.length() > target.length()) {
+ // Source is in sub-directory of target
+ for (int i = target.length(); i < source.length(); i++) {
+ if (source.charAt(i) == SourceConstants.FORWARD_SLASH_CHAR) {
+ sb.append(SourceConstants.PATH_UP);
+ }
+ }
+ } else if (target.length() > source.length()) {
+ // Target is in sub-directory of source
+ int lastIndex;
+ if (source.endsWith(String
+ .valueOf(SourceConstants.FORWARD_SLASH_CHAR))) {
+ lastIndex = source.length();
+ } else {
+ lastIndex = source.length() + 1;
+ }
+ for (int i = source.length(); i < target.length(); i++) {
+ if (target.charAt(i) == SourceConstants.FORWARD_SLASH_CHAR) {
+ sb.append(target.substring(lastIndex, i + 1));
+ lastIndex = i + 1;
+ }
+ }
+ if (new File(target).isDirectory() && lastIndex < target.length()) {
+ sb.append(target.substring(lastIndex));
+ }
+ } else {
+ // Paths were equal
+ sb.append(SourceConstants.THIS_PATH);
+ }
+ return sb.toString();
+ }
+
+ /**
+ * Gets the relative path between two unrelated directories
+ *
+ * @param source
+ * the source
+ * @param target
+ * the target
+ * @param start
+ * the start index where the paths differ
+ * @return the relative path
+ */
+ private static String getRelativePathUnrelated(String source,
+ String target, int start) {
+ String retval;
+ StringBuffer sb = new StringBuffer();
+ File f = new File(target);
+ // If target is absolute path and there is nothing in common between the
+ // paths, the target absolute path is returned as such
+ if (f.isAbsolute() && start == 0) {
+ int lastIndex = target
+ .lastIndexOf(SourceConstants.FORWARD_SLASH_CHAR) + 1;
+ sb.append(target.substring(0, lastIndex));
+ } else {
+ for (int i = start; i < source.length(); i++) {
+ if (source.charAt(i) == SourceConstants.FORWARD_SLASH_CHAR) {
+ sb.append(SourceConstants.PATH_UP);
+ }
+ }
+ int lastIndex;
+ // The previous directory separator is used as the root between the
+ // two paths.
+ lastIndex = target.lastIndexOf(SourceConstants.FORWARD_SLASH_CHAR,
+ start - 1) + 1;
+ for (int i = start; i < target.length(); i++) {
+ if (target.charAt(i) == SourceConstants.FORWARD_SLASH_CHAR) {
+ sb.append(target.substring(lastIndex, i + 1));
+ lastIndex = i + 1;
+ }
+ }
+ }
+ retval = sb.toString();
+ return retval;
+ }
+
+ /**
+ * Checks if given file is allowed to be opened into TraceBuilder
+ *
+ * @param fileName
+ * the file to be checked
+ * @return true if filtered, false if not
+ */
+ public static boolean isFileAllowed(String fileName) {
+ boolean allowed = false;
+ fileName = fileName.toLowerCase();
+ for (String filter : FILE_FILTERS) {
+ if (fileName.endsWith(filter)) {
+ allowed = true;
+ break;
+ }
+ }
+ return allowed;
+ }
+
+ /**
+ * Creates URI from given IPath instance.
+ * @param path
+ * @return URI from given IPath instance
+ */
+ public static URI makeURI(IPath path) {
+ File file = path.toFile();
+ return file.toURI();
+ }
+}