* Simple identifier constant (value <code>"migrationHelpers"</code>)

	 * for the migration helpers extension point.

	 * 

	 */	

	public static final String PT_MIGRATION_HELPERS = "migrationHelpers"; //$NON-NLS-1$

	/**

migrationHelpers=Migration Helpers

   <extension-point id="migrationHelpers" name="%migrationHelpers" schema="schema/migrationHelpers.exsd"/>

   <extension

         point="org.eclipse.core.filesystem.filesystems">

      <filesystem

            scheme="snapfs">

         <run

               class="org.eclipse.core.internal.resources.projectmigration.SFSFileSystem">

         </run>

      </filesystem>

   </extension>

   <extension

         point="org.eclipse.core.resources.migrationHelpers">

      <migrationHelperNatures

            nature="+">

      </migrationHelperNatures>

      <migrationHelperClass

            class="org.eclipse.core.internal.resources.projectmigration.PlatformProjectMigrationHelper">

      </migrationHelperClass>

   </extension>

 org.eclipse.core.internal.resources.projectmigration,

 org.eclipse.core.resources.projectmigration,

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

<!-- Schema file written by PDE -->

<schema targetNamespace="org.eclipse.core.resources" xmlns="http://www.w3.org/2001/XMLSchema">

<annotation>

      <appinfo>

         <meta.schema plugin="org.eclipse.core.resources" id="migrationHelpers" name="%migrationHelpers"/>

      </appinfo>

      <documentation>

         This extension point allows contributors to assist with Project Migrations. Contributors get two chances to help. 

The first is on the export of the Project information. Contributors can create files that should be included in the zip file that is copied to the new directory. Contributors can also identify files that should be copied from the source directory to the new directory. At this stage, contributors are only called for projects with a nature that matches one in the list of natures that the contributor knows about.

The second opportunity is when the Project Migration is actually happening. The contributors are called for each file that is copied from the original source directory. The contributor can change the copied file in order to reflect the new project name or other changes.

A contributor makes a class that extends ProjectMigrationHelper.

      </documentation>

   </annotation>

   <element name="extension">

      <annotation>

         <appinfo>

            <meta.element />

         </appinfo>

      </annotation>

      <complexType>

         <sequence>

            <element ref="migrationHelperNatures" minOccurs="1" maxOccurs="unbounded"/>

            <element ref="migrationHelperClass"/>

         </sequence>

         <attribute name="point" type="string" use="required">

            <annotation>

               <documentation>

               </documentation>

            </annotation>

         </attribute>

         <attribute name="id" type="string">

            <annotation>

               <documentation>

               </documentation>

            </annotation>

         </attribute>

         <attribute name="name" type="string">

            <annotation>

               <documentation>

               </documentation>

               <appinfo>

                  <meta.attribute translatable="true"/>

               </appinfo>

            </annotation>

         </attribute>

      </complexType>

   </element>

   <element name="migrationHelperNatures">

      <annotation>

         <documentation>

            These elements specify the "natures" that this extension knows about. Multiple natures can be specified.

         </documentation>

      </annotation>

      <complexType>

         <attribute name="nature" type="string" use="required">

            <annotation>

               <documentation>

                  Identifies the project nature. Projects with the specified nature can be helped by this particular migrationHelper.

               </documentation>

            </annotation>

         </attribute>

      </complexType>

   </element>

   <element name="migrationHelperClass">

      <complexType>

         <attribute name="class" type="string" use="required">

            <annotation>

               <documentation>

                  This must be a class that extends org.eclipse.core.resources.projectmigration.ProjectMigrationHelper.

               </documentation>

               <appinfo>

                  <meta.attribute kind="java" basedOn="org.eclipse.core.resources.projectmigration.ProjectMigrationHelper:"/>

               </appinfo>

            </annotation>

         </attribute>

      </complexType>

   </element>

   <annotation>

      <appinfo>

         <meta.section type="since"/>

      </appinfo>

      <documentation>

         3.5

      </documentation>

   </annotation>

   <annotation>

      <appinfo>

         <meta.section type="examples"/>

      </appinfo>

      <documentation>

         For CDT, the provided class provides the following functions:

createExportFiles(): This function exports the PDOM (much like the Team Shared Index) and identifies the ".cproject" file to be copied at the time of the migration.

migrateFile(): This function changes the .cproject file so that instances of the old project name are changed to the new name. A possible improvement is to use the old and new linked prefixes to make changes to the include paths specified.

The removeExportFiles() is not provide because the default implementation which just removes all files like the exported PDOM is the desired behavior.

      </documentation>

   </annotation>

   <annotation>

      <appinfo>

         <meta.section type="apiinfo"/>

      </appinfo>

      <documentation>

         When the Project Migration information is being exported, the function "createExportFiles" is called. This allows the contributor to create temporary files to be included in the migration zip file. (these files will be deleted later on by a call to "removeExportFiles". For each file created, the contributor should call "addExportZipFile". The contributor can override removeExportFiles if the files added via addExportZipFile should not all be deleted.

In addition to creating temporary files to be included in the migration zip file, the contributor can also indicate files to be copied from the project source directory to the migration destination directory. These files should be in the project directory. (i.e. not a file in a sub-directory.) This list of files is added through calls to "addFileToMigrate".

When the Project Migration is being performed, the function "migrateFile" is called so the contributor has a chance to change the destination file.

      </documentation>

   </annotation>

   <annotation>

      <appinfo>

         <meta.section type="implementation"/>

      </appinfo>

      <documentation>

         An example of this extension is included with CDT.

      </documentation>

   </annotation>

</schema>

/*******************************************************************************

 * Copyright (c) 2009 IBM Corporation and others.

 * All rights reserved. This program and the accompanying materials

 * are made available under the terms of the Eclipse Public License v1.0

 * which accompanies this distribution, and is available at

 * http://www.eclipse.org/legal/epl-v10.html

 * 

 * Contributors:

 *     Wind River Systems Inc.- initial API and implementation

 *******************************************************************************/

package org.eclipse.core.internal.resources.projectmigration;

import java.io.File;

import java.net.URI;

import java.net.URISyntaxException;

import org.eclipse.core.internal.resources.projectmigration.Messages;

import org.eclipse.core.resources.IProjectDescription;

import org.eclipse.core.resources.ResourcesPlugin;

import org.eclipse.core.runtime.IPath;

import org.eclipse.core.runtime.IProgressMonitor;

import org.eclipse.core.runtime.IStatus;

import org.eclipse.core.runtime.Status;

import org.eclipse.core.runtime.SubProgressMonitor;

/**

 * 

 */

public class SFSUtilities {

		public static void exportRefreshInfo( IProjectDescription desc, File tmpfile, IProgressMonitor monitor) {

			URI projectURI = desc.getLocationURI();

			SnapInfoStore refreshInfo = new SnapInfoStore(projectURI.getPath(),

				tmpfile);

			monitor.subTask(Messages.getString("SFSUtilities.0")); //$NON-NLS-1$

			refreshInfo.write(new SubProgressMonitor(monitor, 100));

			monitor.done();

		}

		public static void startUsingRefreshInfo( IProjectDescription description, IPath destPath, String snap_name, int numberOfLocals) {

			URI uri = description.getLocationURI();

			URI projURI = null;

			try {

				projURI = new URI(SFSFileSystem.SCHEME, uri.getAuthority(), "/", //$NON-NLS-1$

						destPath.toString(), snap_name);

			} catch (URISyntaxException e) {

				ResourcesPlugin.getPlugin().getLog().log(new Status(IStatus.ERROR, ResourcesPlugin.PI_RESOURCES, "uri", //$NON-NLS-1$

						e));

				return;

			}

			SFSFileSystem.setRootPath(destPath.toString(),  numberOfLocals);

			description.setLocationURI(projURI);

		}

		public static void addRootLocalFile( String fileName ) {

			SFSFileSystem.setRootLocalFile( fileName );

		}

		public static void stopUsingRefreshInfo( ) {

			SFSFileSystem.stopUsingRefreshInfo();

		}

}

/*******************************************************************************

 * Copyright (c) 2009 IBM Corporation and others.

 * All rights reserved. This program and the accompanying materials

 * are made available under the terms of the Eclipse Public License v1.0

 * which accompanies this distribution, and is available at

 * http://www.eclipse.org/legal/epl-v10.html

 *

 * Contributors:

 *     Wind River Systems, Inc. - initial API and implementation

 *******************************************************************************/

package org.eclipse.core.resources.projectmigration;

import org.eclipse.core.runtime.*;

import org.eclipse.core.runtime.IExecutableExtension;

import org.eclipse.core.internal.resources.projectmigration.Messages;

import java.io.File;

import java.io.FileInputStream;

import java.io.FileNotFoundException;

import java.io.FileOutputStream;

import java.io.InputStream;

import java.io.IOException;

import java.io.OutputStream;

import java.util.ArrayList;

import java.util.Enumeration;

import java.util.List;

import java.util.NoSuchElementException;

import java.util.zip.ZipEntry;

import java.util.zip.ZipException;

import java.util.zip.ZipFile;

import org.eclipse.core.resources.IProject;

import org.eclipse.core.resources.IProjectDescription;

import org.eclipse.core.resources.IResource;

import org.eclipse.core.resources.IWorkspace;

import org.eclipse.core.resources.ResourcesPlugin;

import org.eclipse.core.runtime.IPath;

import org.eclipse.core.runtime.IProgressMonitor;

import org.eclipse.core.runtime.IStatus;

import org.eclipse.core.runtime.NullProgressMonitor;

import org.eclipse.core.runtime.OperationCanceledException;

import org.eclipse.core.runtime.Platform;

import org.eclipse.core.runtime.Status;

import org.eclipse.core.runtime.SubProgressMonitor;

//import org.eclipse.core.internal.resources.projectmigration.PlatformProjectMigrationHelper;

import org.eclipse.core.internal.resources.projectmigration.SFSUtilities;

/**

 * An operation which does the actual work of migrating a project from one

 * directory to another.

 * <p>

 * This class may be instantiated; it is not intended to be subclassed.

 * </p>

 */

public class ProjectMigration    {

	public static final String SNAP_NAME = ".projdir.snap"; //$NON-NLS-1$

	public static final String MIGRATION_ZIP_NAME = ".projmig.zip"; //$NON-NLS-1$

	private IPath sourcePath;

	private IPath destinationPath;

	private String projectName;

	private String newProjectName;

	private String oldLinkedPathPrefix;

	private String newLinkedPathPrefix;

	/**

	 * Specifies a project migration that performs a "trusted import" of the

	 * specified project from the source directory to the destination directory.

	 * This means that the file refresh information and other files from the source

	 * project are to be imported and trusted, i.e., not verified.

	 * <p>

	 * The <code>sourcePath</code> parameter represents the directory containing

	 * the project to import.

	 * </p>

	 *  

	 * @param destinationPath

	 *            full path of destination directory

	 * @param sourcePath

	 *            full path of source directory, containing a project

	 * @param newName

	 *            new name of project (empty if no rename)

	 */

	public ProjectMigration( IPath sourcePath, String newName, IPath destinationPath){

		super();

		this.projectName = "uninitialized_project_name"; //$NON-NLS-1$

		this.sourcePath = sourcePath;

		this.destinationPath = destinationPath;

		this.newProjectName = newName;

		this.oldLinkedPathPrefix = ""; //$NON-NLS-1$

		this.newLinkedPathPrefix = ""; //$NON-NLS-1$

	}

	/**

	 * Sets the linked directory path prefix.

	 * 

	 * @param oldLinkedPathPrefix

	 *            linked to the old directory path prefix

	 * @param newLinkedPathPrefix

	 *            linked to the new directory path prefix

	 */

	public void setLinkedPathPrefix(String oldLinkedPathPrefix, String newLinkedPathPrefix) {

		this.oldLinkedPathPrefix = oldLinkedPathPrefix;

		this.newLinkedPathPrefix = newLinkedPathPrefix;

	}

	/*

	 * Method declared on WorkbenchModifyOperation. Imports the specified

	 * project from the file system.

	 * 

	 * @param progressMonitor IProgressMonitor object

	 */

	public void execute(IProgressMonitor progressMonitor) throws Exception {

		/* TODO: remove this?

		 * Check the cdt debug activity settings. If on, print a message to

		 * stdout announcing that the Project migration is starting. This makes

		 * timing the migration easier. Please note that the hard-coded

		 * references to the plugin and activity names is a bit of a kludge. It

		 * would not be needed if the project migration API were actually part

		 * of CDT instead of in a separate plugin.

		 */

		String option = "org.eclipse.cdt.core/debug/indexer/activity"; //$NON-NLS-1$

		String trace = Platform.getDebugOption(option);

		boolean internallyActivated = Boolean.getBoolean(option);

		boolean showActivity = internallyActivated || (trace != null && trace.equalsIgnoreCase("true")); //$NON-NLS-1$

		if (showActivity == true) {

			System.out.println(Messages.getString("ProjectMigration.0")); //$NON-NLS-1$

		}

		IProgressMonitor monitor = progressMonitor;

		if( monitor == null ) {

			monitor = new NullProgressMonitor();

		}

		monitor.beginTask("", 100 ); //$NON-NLS-1$

		if (sourcePath.equals(destinationPath)) {

			throw new Exception(Messages.getString("ProjectMigration.1")); //$NON-NLS-1$

		}

		try {

			{

				IPath path  = sourcePath.append(IProjectDescription.DESCRIPTION_FILE_NAME);

				final IWorkspace workspace = ResourcesPlugin.getWorkspace();

				IProjectDescription description = workspace.loadProjectDescription(path);

				this.projectName = description.getName();

			}

			extractMigrationFiles(sourcePath, destinationPath);

			File[] projectFiles = getProjectFiles(sourcePath);

			if (projectFiles.length == 0) {

				throw new Exception(Messages.getString("ProjectMigration.2")); //$NON-NLS-1$

			}

			int i = 0;

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

				File file = projectFiles[i];

				if (file != null) {

					if (!copyRecursively(file, destinationPath, new SubProgressMonitor( monitor, 20/projectFiles.length))) {

						throw new Exception(Messages.getString("ProjectMigration.4")); //$NON-NLS-1$

					}

				}

			}

			IPath path = destinationPath;

			/*

			 * Let the project migration helpers have a chance at changing the copied files.

			 */

			changeCopiedFiles( projectFiles, new SubProgressMonitor( monitor, 20 ) );

//	PlatformProjectMigrationHelper projFile = new PlatformProjectMigrationHelper(path, projectFiles, newProjectName, oldLinkedPathPrefix, newLinkedPathPrefix);

//			projFile.performProjectRenaming(new SubProgressMonitor(monitor,20));

			path = destinationPath.append(IProjectDescription.DESCRIPTION_FILE_NAME);

			final IWorkspace workspace = ResourcesPlugin.getWorkspace();

			IProjectDescription description = workspace.loadProjectDescription(path);

			String projName = description.getName();

			final IProject project = workspace.getRoot().getProject(projName);

			File importFile = destinationPath.append(ProjectMigration.SNAP_NAME).toFile();

			if (importFile.exists()) {

				SFSUtilities.startUsingRefreshInfo(description, destinationPath, ProjectMigration.SNAP_NAME, projectFiles.length);

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

					SFSUtilities.addRootLocalFile(projectFiles[i].getName()); 

				}

			}

			project.create(description, new SubProgressMonitor( monitor, 10 ));

			// open the project and perform the refresh before returning

			project.open(IResource.NONE, new SubProgressMonitor( monitor, 40 ) );

		}

		finally {

			// now turn off the use of the snapshot file, if active

			SFSUtilities.stopUsingRefreshInfo();

		}

		monitor.done();

	}

	private void changeCopiedFiles(File[] projectFiles, IProgressMonitor monitor) {

		IExecutableExtension[] extensions = getMigrationHelpers();

		if( extensions.length == 0 ) {

			monitor.done();

			return;

		}			

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

			/*

			 * Ask the helpers to migrate files that are copied.

			 */

			for( int j = 0; j < extensions.length; j ++ ) {

				if (extensions[j] instanceof ProjectMigrationHelper) {

					ProjectMigrationHelper helper = (ProjectMigrationHelper) extensions[j];

					IPath filePath = destinationPath.append( projectFiles[i].getName());

					helper.migrateFile( filePath, projectName, newProjectName, oldLinkedPathPrefix, newLinkedPathPrefix);

				}

			}

			monitor.worked(1);

		}

	}

	/*

	 * Get the set of migration helpers. We don't match on the natures since no

	 * projects are actually open. Instead, the migration helper must "know" which

	 * files it can help migrate.

	 */

	private IExecutableExtension[] getMigrationHelpers() {

		List helpers = new ArrayList();

		try {

	        IExtensionPoint extension = Platform.getExtensionRegistry().getExtensionPoint(ResourcesPlugin.PI_RESOURCES, ResourcesPlugin.PT_MIGRATION_HELPERS);

			if (extension != null) {

				IExtension[] extensions = extension.getExtensions();

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

					IExtension extension2 = extensions[i]; 

					IConfigurationElement[] configElements = extension2.getConfigurationElements();

					for ( int j = 0; j < configElements.length; j ++ ) {

						IConfigurationElement configElement = configElements[j];

						if( configElement.getAttribute( "class" ) != null ) { //$NON-NLS-1$

							helpers.add( configElement.createExecutableExtension("class")); //$NON-NLS-1$

						}

					}

				}

			}

		} catch (CoreException e) {

			ResourcesPlugin.getPlugin().getLog().log(new Status( IStatus.ERROR, ResourcesPlugin.PI_RESOURCES, Messages.getString("ExportProjectMigrationInfo.4"), e));  //$NON-NLS-1$

		}

		return (IExecutableExtension[]) helpers.toArray(new IExecutableExtension[0]);

	}

		private void readEntry(ZipFile zip, ZipEntry entry, File tmpFile)

				throws IOException {

			InputStream stream = zip.getInputStream(entry);

			OutputStream outEntry = new FileOutputStream(tmpFile);

			try {

				byte[] buffer = new byte[2048];

				int read;

				while ((read = stream.read(buffer)) >= 0) {

					outEntry.write(buffer, 0, read);

				}

			} finally {

				close(outEntry);

			}

		}

		private void close(OutputStream out) {

			try {

				if (out != null) {

					out.close();

				}

			} catch (IOException e) {

				ResourcesPlugin.getPlugin().getLog().log( new Status(IStatus.ERROR, ResourcesPlugin.PI_RESOURCES, IStatus.ERROR, Messages.getString("ExportProjectMigrationInfo.2"), e)); //$NON-NLS-1$

			}

		}

	/**

	 * Copies the specified file system object recursively into the destination

	 * If the import fails, adds a status object to the list to be returned by

	 * <code>getStatus</code>.

	 * 

	 * @param file

	 *            the file system object to be imported

	 * @exception OperationCanceledException

	 *                if canceled

	 */

	private boolean copyRecursively(File file, IPath destPath, IProgressMonitor monitor) {

		if (monitor.isCanceled()) {

			throw new OperationCanceledException();

		}

		if (!file.isDirectory()) {

			return copyFile(file, destPath, monitor);

		}

		IPath folderPath = destPath.addTrailingSeparator();

		folderPath = folderPath.append(file.getName());

		boolean success = new File(folderPath.toOSString()).mkdir();

		if (!success) {

			monitor.done();

			return false;

		}

		File[] contents = file.listFiles();

		monitor.beginTask("", contents.length); //$NON-NLS-1$

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

			if (!copyRecursively(contents[i], folderPath, new SubProgressMonitor( monitor, 1 ) )) {

				monitor.done();

				return false;

			}

		}

		monitor.done();

		return true;

	}

	/**

	 * Copies the specified file system object into the destination. If the copy

	 * fails, returns false.

	 */

	private boolean copyFile(File file, IPath dPath, IProgressMonitor monitor) {

		String filePath = file.getAbsolutePath();

		monitor.subTask(filePath);

		// assume that the source and target are not the same

		try {

			FileInputStream from = null;

			try {

				from = new FileInputStream(file);

			} catch (FileNotFoundException e) {

				// file was not found. null case is handled.

			}

			if (from == null) {

				monitor.done();

				return false;

			}

			IPath destPath = dPath.addTrailingSeparator();

			destPath = destPath.append(file.getName());

			FileOutputStream to = null;

			try {

				to = new FileOutputStream(destPath.toString());

			} catch (FileNotFoundException e) {

				from.close();

				monitor.done();

				return false;

			}

			try {

				byte[] buffer = new byte[4096];

				int bytesRead;

				while ((bytesRead = from.read(buffer)) != -1)

					to.write(buffer, 0, bytesRead); // write

			} finally {

				try {

					from.close();

				} catch (IOException e) {

					ResourcesPlugin.getPlugin().getLog().log(new Status(IStatus.ERROR, ResourcesPlugin.PI_RESOURCES, IStatus.ERROR, Messages.getString("ProjectMigration.6"), e)); //$NON-NLS-1$

				}

				try {

					to.close();

				} catch (IOException e) {

					ResourcesPlugin.getPlugin().getLog().log(new Status(IStatus.ERROR, ResourcesPlugin.PI_RESOURCES, IStatus.ERROR, Messages.getString("ProjectMigration.7"), e)); //$NON-NLS-1$

				}

			}

			monitor.done();

			return true;

		} catch (IOException e) {

			monitor.done();

			return false;

		}

	}

	/**

	 * Get the list of files that need to be copied from this directory. This

	 * includes  any 0-length entries in the zip file. The 0-length

	 * entries are used to capture the names of files that the migration helper

	 * extensions wanted to have copied.

	 */

	private File[] getProjectFiles(IPath importSourcePath) {

		/*

		 * Look for the Migration zip file

		 */

		File zipFile = importSourcePath.append(ProjectMigration.MIGRATION_ZIP_NAME).toFile();

		if( !zipFile.exists() ) {

			return new File[0];

		}

		/*

		 * Open the zip file and get the list of names for the entries that are 0 length. This

		 * should be a list of files to copy. Verify that the names are in the contents.

		 */

		List files = new ArrayList();

		try {

			ZipFile zip = new ZipFile(zipFile);

			Enumeration zipEntriesList = zip.entries();

			try {

				while (true) {

					ZipEntry entry;

					entry = (ZipEntry) zipEntriesList.nextElement();

					if (entry.getSize() == 0) {

						File entryFile = importSourcePath.append(entry.getName()).toFile();

						if( entryFile.exists() ) {

							files.add( entryFile );

						}

					}

				}

			} catch (NoSuchElementException e) {

				// done with all entries

			} finally {

				zip.close();

			}

		} catch (ZipException e) {

			ResourcesPlugin.getPlugin().getLog().log(new Status(IStatus.ERROR, ResourcesPlugin.PI_RESOURCES, IStatus.ERROR, Messages.getString("ProjectMigration.8"), e)); //$NON-NLS-1$

		} catch (IOException e) {

			ResourcesPlugin.getPlugin().getLog().log(new Status(IStatus.ERROR, ResourcesPlugin.PI_RESOURCES, IStatus.ERROR, Messages.getString("ProjectMigration.9"), e)); //$NON-NLS-1$

		}

		return (File[]) files.toArray(new File[0]);

	}

	/**

	 * Extract all non-zero length files from the zip file into the destination directory.

	 */

	private void extractMigrationFiles(IPath importSourcePath, IPath dPath) {

		/*

		 * Look for the Migration zip file

		 */

		File zipFile = importSourcePath.append(ProjectMigration.MIGRATION_ZIP_NAME).toFile();

		if( !zipFile.exists() ) {

			return;

		}

		try {

			ZipFile zip = new ZipFile(zipFile);

			Enumeration zipEntriesList = zip.entries();

			try {

				while (true) {

					ZipEntry entry;

					entry = (ZipEntry) zipEntriesList.nextElement();

					if (entry.getSize() != 0 /*&& entry.getName().equals(ProjectMigration.SNAP_NAME)*/) {

						File tmpFile = dPath.append(entry.getName()).toFile();

						readEntry( zip, entry, tmpFile);

					}

				}

			} catch (NoSuchElementException e) {

				// done with all entries

			} finally {

				zip.close();

			}

		} catch (ZipException e) {

			ResourcesPlugin.getPlugin().getLog().log(new Status(IStatus.ERROR, ResourcesPlugin.PI_RESOURCES, IStatus.ERROR, Messages.getString("ProjectMigration.8"), e)); //$NON-NLS-1$

		} catch (IOException e) {

			ResourcesPlugin.getPlugin().getLog().log(new Status(IStatus.ERROR, ResourcesPlugin.PI_RESOURCES, IStatus.ERROR, Messages.getString("ProjectMigration.9"), e)); //$NON-NLS-1$

		}

		return ;

	}

}

/*******************************************************************************

 * Copyright (c) 2009 IBM Corporation and others.

 * All rights reserved. This program and the accompanying materials

 * are made available under the terms of the Eclipse Public License v1.0

 * which accompanies this distribution, and is available at

 * http://www.eclipse.org/legal/epl-v10.html

 * 

 * Contributors:

 *     IBM Corporation - initial API and implementation

 *******************************************************************************/

package org.eclipse.core.resources.projectmigration;

import java.io.FileInputStream;

import java.io.FileOutputStream;

import java.io.File;

import java.util.ArrayList;

import java.util.List;

import org.eclipse.core.resources.IProject;

import org.eclipse.core.runtime.CoreException;

import org.eclipse.core.runtime.IConfigurationElement;

import org.eclipse.core.runtime.IExecutableExtension;

import org.eclipse.core.runtime.IPath;

import org.eclipse.core.runtime.IProgressMonitor;

/**

 * This is the base class for ProjectMigration Extensions.

 * The extension has two parts to contribute:

 * 

 *  1. At the time of Export, the extension can:

 *  	- create files that will be included in the zip file

 *  		created as the output of the export.

 *  	- specify files that should be copied from the source

 *  		project directory to the new project directory.

 *     When the export is called, the createExportFiles() is called.

 *     This function can create files as needed and then make calls to

 *     addExportZipFile() and addFilesToMigrate() to specify files to

 *     include in the zip file and files to be copied respectively.

 *     

 *     After the zip file is created, a call is made to removeExportFiles()

 *     to remove the files that were added to the zip file. The assumption is 

 *     that they were all temporary files. If this assumption is not true, then

 *     override the removeExportFiles() and do your own thing.

 *     

 *     At the time of the export, the extension only comes into play if the

 *     "nature" specified with the extension matches one of the natures in the project.

 *     

 *  2. At the time of the migration, the extension can offer assistance with changing

 *  	any files that are copied over from the source project to the destination project.

 *  	This is done through calls to migrateFile(). This function is called for each file.

 *  	The extension can change the contents as needed. Typically, the project name is

 *  	changed so references to the old name must be changed to the new name.

 *  

 *     At the time of the migration, all extensions are called, regardless of the nature.

 *     The extension will need to look at the name of the file and if the file is not

 *     special to the extension, then it should not do anything to the file.

 */

public class ProjectMigrationHelper implements IExecutableExtension {

	/*

	 * This is the project that this instance is for. This field is only

	 * populated for the export operation. It is not populated at the time

	 * of the migration.

	 */

	private IProject fProject;

	/*

	 * This local class contains the file and entry name for a file that should be

	 * added to the zip file.

	 */

	public class ExportZipFileEntryInfo {

		private File fFile;

		private String fName;

		public ExportZipFileEntryInfo( File file, String name ) {

			fFile = file;

			fName = name;

		}

		public File getFile() {

			return fFile;

		}

		public String getName() {

			return fName;

		}

	}

	/*

	 * This is the list of files to be added to the zip file. Each entry

	 * is an ExportZipFileEntryInfo object.

	 */

	public List fExportZipFiles = new ArrayList();

	/*

	 * This is the list of files to be copied at the time of the migration.

	 * Each entry is a String. You can really only copy files or directories that are in

	 * the root of the project directory. 

	 */

	private List fFilesToMigrate = new ArrayList();

	/*

	 * Public Methods

	 */

	/*

	 * Plain constructor. Extensions must have one of these.

	 */

	public ProjectMigrationHelper() {

		return;

	}

	/**

	 * This function should create any files that should be included in

	 * the zip file representing the exported migration information.

	 * 

	 * The function should create the files and make a call to addExportZipFile()

	 * for each file created.

	 * 

	 * Files that should be copied at the time of the migration (but 

	 * not included in the zip file) should be added through calls to addFileToMigrate()

	 * 

	 * @param monitor - progress monitor for this function.

	 * @throws CoreException

	 */

	public void createExportFiles(IProgressMonitor monitor) throws CoreException {

		/*

		 * This function should be in the sub-class if there really are files

		 * that need to be copied and migrated.

		 */

	}

	/*

	 * This function removes files created by createExportFiles().

	 * It is assumed that all files created are temporary files and should be

	 * deleted. If this is the case, then this default implementation is sufficient.

	 * If this is not the case, then the extension should override this function

	 * and determine the proper disposal of the files created in createExportFiles.

	 */

	public void removeExportFiles() {

		for( int i = 0; i < fExportZipFiles.size(); i++) {

			ExportZipFileEntryInfo exportFile = (ExportZipFileEntryInfo) fExportZipFiles.get(i);

			File file = exportFile.getFile();

			file.delete();

		}

		fExportZipFiles = null;

	}

	/**

	 * This function is called for each file that is copied from the source project directory. The Extension

	 * has an opportunity to change the contents of the file.

	 * 

	 * The function is called after the file has been copied. The extension should only change the destination

	 * file. (filePath)

	 * @param filePath - path of the copied file

	 * @param oldname - name of the original project

	 * @param newname - name of the migrated project

	 * @param fromLinked - A prefix for linked folders or other paths

	 * @param toLinked - What the fromLinked prefix should be changed to

	 * @return true if file is modified, else return false.

	 */

	public boolean migrateFile( IPath filePath, String oldname, String newname, String fromLinked, String toLinked ) {

		return false;

	}

	/* (non-Javadoc)

	 * @see org.eclipse.core.runtime.IExecutableExtension#setInitializationData(org.eclipse.core.runtime.IConfigurationElement, java.lang.String, java.lang.Object)

	 * 

	 * 

	 * Override this function if you have added other extension elements and want to do something with that data.

	 */

	/**

	 * @throws CoreException  

	 */

	public void setInitializationData(IConfigurationElement config, String propertyName, Object data) throws CoreException {

		/*

		 * This function will get any properties and values associated with the extension point. 

		 * The sub-class should have its own version if it wants to save the properties and do something

		 * with them.

		 */

	}

	/**

	 * Set the project that this extension is associated with. 

	 * This will be null during the actual migration itself since

	 * neither the source nor the destination projects are actually

	 * open.

	 * 

	 * @param project

	 */

	public final void setProject( IProject project ) {

		fProject = project;

	}

	/*

	 * Return the project (could be null) associated with this extension.

	 */

	public final IProject getProject( ) {

		return fProject;

	}

	public final void addExportZipFile( File file, String entryName ) {

		ExportZipFileEntryInfo info = new ExportZipFileEntryInfo( file, entryName );

		fExportZipFiles.add( info );

	}

	public final List getExportZipFiles() {

		return fExportZipFiles;

	}

	public final List getFilesToMigrate() {

		return fFilesToMigrate;

	}

	public void addFileToMigrate(String name) {

		fFilesToMigrate.add(name);

	}

	/*

	 * Utility Functions

	 */

	/**

	 * Read a file into a String class.

	 * 

	 * @param filepath

	 *            path to the file to read *@return file contents as a string

	 */

	public String readFileIntoString(String filepath) throws Exception {

		FileInputStream fis = new FileInputStream(filepath);

		int x = fis.available();

		byte b[] = new byte[x];

		fis.read(b);

		fis.close();

		return new String(b);

	}

	/**

	 * Write the string to a file.

	 * 

	 * @param filepath

	 *            path to the file to write to

	 * @param data

	 *            string containing the data to write

	 */

	public void writeStringIntoFile(String filepath, String data)

			throws Exception {

		FileOutputStream fos = new FileOutputStream(filepath);

		byte b[] = data.getBytes();

		fos.write(b);

		fos.close();

	}

}

/*******************************************************************************

 * Copyright (c) 2000, 2006, 2008 IBM Corporation and others.

 * All rights reserved. This program and the accompanying materials

 * are made available under the terms of the Eclipse Public License v1.0

 * which accompanies this distribution, and is available at

 * http://www.eclipse.org/legal/epl-v10.html

 *

 * Contributors:

 *     Wind River Systems, Inc. - initial API and implementation

 *******************************************************************************/

package org.eclipse.core.internal.resources.projectmigration;

import org.eclipse.core.filesystem.EFS;

import org.eclipse.core.filesystem.provider.FileInfo;

public class SnapInfo extends FileInfo {

	// same as FileInfo.ATTRIBUTE_DRECTORY which is unfortunately private

	static int ATTRIBUTE_DIRECTORY = 1 << 0;

	int nextIndex;

	int parentIndex;

	int childIndex;

	public SnapInfo(String name) {

		super(name);

		nextIndex = 0;

		parentIndex = 0;

		childIndex = 0;

	}

	public void setAttributes(int attributes) {

		if ((attributes & EFS.ATTRIBUTE_READ_ONLY) != 0) {

			setAttribute(EFS.ATTRIBUTE_READ_ONLY, true);

		}

		if ((attributes & EFS.ATTRIBUTE_EXECUTABLE) != 0) {

			setAttribute(EFS.ATTRIBUTE_EXECUTABLE, true);

		}

		if ((attributes & EFS.ATTRIBUTE_ARCHIVE) != 0) {

			setAttribute(EFS.ATTRIBUTE_ARCHIVE, true);

		}

		if ((attributes & EFS.ATTRIBUTE_HIDDEN) != 0) {

			setAttribute(EFS.ATTRIBUTE_HIDDEN, true);

		}

		if ((attributes & ATTRIBUTE_DIRECTORY) != 0) {

			setDirectory(true);

		}

	}

	//@Override

	public boolean exists() {

		return true; // we always act as if the file exists

	}

	//@Override

	public void setExists(boolean value) {

		// ignore attempts to change this

	}

	//@Override

	public String getStringAttribute(int attribute) {

		// all symbolic links are resolved in the snapshot

		return null;

	}

	//@Override

	public void setStringAttribute(int attribute, String value) {

		// ignore attempts to change this

	}

	public int getNextIndex() {

		return nextIndex;

	}

	public void setNextIndex(int x) {

		nextIndex = x;

	}

	public int getParentIndex() {

		return parentIndex;

	}

	public void setParentIndex(int x) {

		parentIndex = x;

	}

	public int getChildIndex() {

		return childIndex;

	}

	public void setChildIndex(int x) {

		childIndex = x;

	}

}

/*******************************************************************************

 * Copyright (c) 2009 IBM Corporation and others.

 * All rights reserved. This program and the accompanying materials

 * are made available under the terms of the Eclipse Public License v1.0

 * which accompanies this distribution, and is available at

 * http://www.eclipse.org/legal/epl-v10.html

 * 

 * Contributors:

 *     IBM Corporation - initial API and implementation

 *******************************************************************************/

package org.eclipse.core.internal.resources.projectmigration;

import java.util.MissingResourceException;

import java.util.ResourceBundle;

/**

 * 

 */

public class Messages {

	private static final String BUNDLE_NAME = "org.eclipse.core.internal.resources.projectmigration.messages"; //$NON-NLS-1$

	private static final ResourceBundle RESOURCE_BUNDLE = ResourceBundle.getBundle(BUNDLE_NAME);

	private Messages() {

		/*

		 * no initialization needed

		 */

	}

	public static String getString(String key) {

		try {

			return RESOURCE_BUNDLE.getString(key);

		} catch (MissingResourceException e) {

			return '!' + key + '!';

		}

	}

}

ExportProjectMigrationInfo.0=Error creating temporary file

ExportProjectMigrationInfo.1=Error closing input stream

ExportProjectMigrationInfo.2=Error closing output stream

ExportProjectMigrationInfo.3=Error writing entries to zip file

ExportProjectMigrationInfo.4=Exception received trying to get extensions

ExportProjectMigrationInfo.5=Preparing Files

ExportProjectMigrationInfo.6=Storing Files

PlatformProjectMigrationHelper.0=Exception trying to migrate file: 

ProjectMigration.0=Starting Project Migration.

ProjectMigration.1=Destination same as source directory

ProjectMigration.2=No project files present

ProjectMigration.3=No files other than project files found

ProjectMigration.4=Error copying .project, etc.

ProjectMigration.5=Error closing the zip file

ProjectMigration.6=Error closing file

ProjectMigration.7=Error closing file

ProjectMigration.8=Error accessing migration Zipfile

ProjectMigration.9=I/O Error accessing migration Zipfile

SFSUtilities.0=Writing Project Migration Information

/*******************************************************************************

 * Copyright (c) 2000, 2006, 2008 IBM Corporation and others.

 * All rights reserved. This program and the accompanying materials

 * are made available under the terms of the Eclipse Public License v1.0

 * which accompanies this distribution, and is available at

 * http://www.eclipse.org/legal/epl-v10.html

 *

 * Contributors:

 *     Wind River Systems, Inc. - initial API and implementation

 *******************************************************************************/

package org.eclipse.core.internal.resources.projectmigration;

import org.eclipse.core.runtime.Status;

import org.eclipse.core.runtime.IStatus;

import org.eclipse.core.runtime.CoreException;

import org.eclipse.core.runtime.IProgressMonitor;

import javax.xml.transform.OutputKeys;

import javax.xml.transform.Transformer;

import javax.xml.transform.TransformerFactory;

import javax.xml.transform.stream.StreamResult;

import javax.xml.transform.dom.DOMSource;

import java.io.File;

import javax.xml.parsers.DocumentBuilder;

import javax.xml.parsers.DocumentBuilderFactory;

import org.eclipse.core.resources.IProjectDescription;

import org.eclipse.core.resources.projectmigration.ProjectMigrationHelper;

import org.eclipse.core.resources.ResourcesPlugin;

import org.eclipse.core.runtime.IPath;

import org.w3c.dom.Document;

import org.w3c.dom.Element;

import org.w3c.dom.Node;

import org.w3c.dom.NodeList;

/**

 * An operation which does the actual work of renaming the project name in the

 * .project file and using extension points to modify other files.

 * <p>

 * This class may be instantiated; it is not intended to be subclassed.

 * </p>

 */

/*

 * public class ProjectMigrationExtension extends ProjectMigrationHelper {

	@Override

	private void checkMonitor(IProgressMonitor monitor) {

		if (monitor.isCanceled()) {

			throw new OperationCanceledException();

		}

	}

	@ Override

	public boolean migrateFile( IPath filePath, String oldname, String newname, String fromLinked, String toLinked ) {

		if( filePath.toFile().getName().equals(".cproject") )  { //$NON-NLS-1$

			try {

				// process the .cproject file

				String data = readFileIntoString(filePath.toString());

				String new_data = data

						.replaceAll("\\b" + oldname + "\\b", newname); //$NON-NLS-1$ //$NON-NLS-2$

				if (!data.equals(new_data)) {

					writeStringIntoFile(filePath.toString(), new_data);

				}

			} catch (Exception e) {

				CCorePlugin.log( Messages.ProjectMigrationExtension_2, e );

			}

		}

		return true;

	}

}

*/

public class PlatformProjectMigrationHelper extends ProjectMigrationHelper {

	public PlatformProjectMigrationHelper() {

		super();

	}

	/**

	 * @throws CoreException  

	 */

	public void createExportFiles(IProgressMonitor monitor) throws CoreException {

		monitor.beginTask("", 100); //$NON-NLS-1$

		addFileToMigrate( IProjectDescription.DESCRIPTION_FILE_NAME );

		monitor.done();

	}

	/**

	 * Specifies a project rename operation. This means that the project name in

	 * the .project files are renamed.

	 */

	/*

	public PlatformProjectMigrationHelper(IPath path, File[] projFiles, String newProjectName,

			String oldLinkPathPrefix, String newLinkPathPrefix) {

		projectPath = path;

		IPath projPath = path;

		projectFiles = projFiles;

		projPath = projPath.addTrailingSeparator();

		projPath = projPath.append(IProjectDescription.DESCRIPTION_FILE_NAME);

		this.projectFile = projPath.toString();

		this.newProjectName = newProjectName;

		this.oldLinkPathPrefix = oldLinkPathPrefix;

		this.newLinkPathPrefix = newLinkPathPrefix;

		this.modified = false;

	}

	*/

	public boolean migrateFile( IPath filePath, String oldname, String newname, String fromLinked, String toLinked ) {

		if( filePath.toFile().getName().equals(IProjectDescription.DESCRIPTION_FILE_NAME) )  {

			try {

				Document dom = parseProjectFile(filePath);

				if ( processLinkedResources(dom, fromLinked, toLinked) == true ) {

					saveProjectFile(filePath, dom);

				}

				// process the .project file

				String data = readFileIntoString(filePath.toString());

				String new_data = data

						.replaceAll("\\b" + oldname + "\\b", newname); //$NON-NLS-1$ //$NON-NLS-2$

				if (!data.equals(new_data)) {

					writeStringIntoFile(filePath.toString(), new_data);

				}

			} catch (Exception e) {

				ResourcesPlugin.getPlugin().getLog().log( new Status( IStatus.ERROR, ResourcesPlugin.PI_RESOURCES, Messages.getString("PlatformProjectMigrationHelper.0") + filePath.toString(), e) ); //$NON-NLS-1$

			}

		}

		return true;

	}

	/**

	 * Parse the xml project files.

	 * 

	 * @return true if successful otherwise false

	 */

	private Document parseProjectFile(IPath filePath) throws Exception {

		// get the factory

		DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance();

		// Using factory get an instance of document builder

		DocumentBuilder db = dbf.newDocumentBuilder();

		// parse using builder to get DOM representation of the XML file

		return db.parse(filePath.toFile());

	}

	/**

	 * Process the linked resource directories that is in the .project file.

	 * 

	 * @param oldPath

	 *            prefix to the old path

	 * @param newPath

	 *            prefix to the new path

	 */

	private boolean processLinkedResources(Document dom, String oldPath, String newPath) {

		// get the root element

		Element docEle = dom.getDocumentElement();

		boolean changed = false;

		Node last = docEle.getLastChild();

		Node curr = docEle.getFirstChild(); // get the root element

		boolean found = false;

		while (curr != last) {

			if (curr.getNodeName().equals("linkedResources")) { //$NON-NLS-1$

				found = true;

				break;

			}

			curr = curr.getNextSibling();

		}

		if (!found)

			return changed;

		// get the root element

		NodeList listOfLinkedResources = curr.getChildNodes();

		if (listOfLinkedResources == null)

			return changed;

		int totalResources = listOfLinkedResources.getLength();

		for (int s = 0; s < totalResources; s++) {

			Node linkLinkedResourcesNode = listOfLinkedResources.item(s);

			if (linkLinkedResourcesNode.getNodeType() == Node.ELEMENT_NODE) {

				Element linkLinkedResourcesElement = (Element) linkLinkedResourcesNode;

				// -------

				NodeList locationNameList = linkLinkedResourcesElement

						.getElementsByTagName("location"); //$NON-NLS-1$

				if (locationNameList == null)

					return changed;

				Element locationNameElement = (Element) locationNameList

						.item(0);

				NodeList textFNList = locationNameElement.getChildNodes();

				String val = textFNList.item(0).getNodeValue();

				if (val.startsWith(oldPath)) {

					val = newPath + val.substring(oldPath.length());

					textFNList.item(0).setNodeValue(val);

					changed = true;

				}

			}// end of if clause

		}// end of for loop with s var

		return changed;

	}

	/**

	 * Get the project name in the .project xml file.

	 * 

	 * @return the project name

	 */

/*	private String getProjectName() {

		// get the root element

		Element docEle = dom.getDocumentElement();

		Node first = docEle.getFirstChild();

		Node last = docEle.getLastChild();

		Node curr = first;

		while (curr != last) {

			if (curr.getNodeName().equals("name")) { //$NON-NLS-1$

				return curr.getTextContent();

			}

			curr = curr.getNextSibling();

		}

		return null;

	}

*/

	/**

	 * Save the .profile file.

	 * 

	 * @return true if successful otherwise false

	 */

	private boolean saveProjectFile(IPath filePath, Document dom) throws Exception {

		// Serialization through Transform.

		File filename = filePath.toFile();

		DOMSource domSource = new DOMSource(dom);

		StreamResult streamResult = new StreamResult(filename);

		TransformerFactory tf = TransformerFactory.newInstance();

		Transformer serializer = tf.newTransformer();

		serializer.setOutputProperty(OutputKeys.ENCODING, "UTF-8"); //$NON-NLS-1$

		serializer.setOutputProperty(OutputKeys.INDENT, "yes"); //$NON-NLS-1$

		serializer.transform(domSource, streamResult);

		return true;

	}

	/*

	 * Performs the project renaming operation. The project name in the .project

	 * files are renamed and any linked directory resources are

	 * remapped.

	 * 

	 * @return true if successful otherwise false

	 */

/*	public boolean performProjectRenaming(IProgressMonitor monitor) throws Exception {

		monitor.beginTask( "", projectFiles.length ); //$NON-NLS-1$

		if (parseProjectFile()) {

			String projName;

			// get the project name in the .project file

			projName = getProjectName();

			if (projName == null) {

				monitor.done();

				return false;

			}

			// handle the linked directories in the .project file

			if (oldLinkPathPrefix != null && newLinkPathPrefix != null

					&& !oldLinkPathPrefix.equals("")) { //$NON-NLS-1$

				if ( processLinkedResources(oldLinkPathPrefix, newLinkPathPrefix) == true ) {

					saveProjectFile();

				}

			}

			// rename the project name in the .project 

			String data;

			String new_data;

			// process the .project file

			data = readFileIntoString(projectFile);

			new_data = data

					.replaceAll("\\b" + projName + "\\b", newProjectName);  //$NON-NLS-1$//$NON-NLS-2$

			if (!data.equals(new_data)) {

				writeStringIntoFile(projectFile, new_data);

			}

			monitor.worked(1);

			IExecutableExtension[] extensions = getMigrationHelpers();

			if( extensions.length == 0 ) {

				monitor.done();

				return true;

			}			

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

				if( projectFiles[i].getName().equals(IProjectDescription.DESCRIPTION_FILE_NAME) ) {

					continue;

				}

				for( int j = 0; j < extensions.length; j ++ ) {

					if (extensions[j] instanceof ProjectMigrationHelper) {

						ProjectMigrationHelper helper = (ProjectMigrationHelper) extensions[j];

						IPath filePath = projectPath.append( projectFiles[i].getName());

						helper.migrateFile( filePath, projName, newProjectName, oldLinkPathPrefix, newLinkPathPrefix);

					}

				}

				monitor.worked(1);

			}

		}

		monitor.done();

		return true;

	}

	*/

	/*

	 * Get the set of migration helpers. We don't match on the natures since no

	 * projects are actually open. Instead, the migration helper must "know" which

	 * files it can help migrate.

	 */

	/*

	private IExecutableExtension[] getMigrationHelpers() {

		List helpers = new ArrayList();

		try {

	        IExtensionPoint extension = Platform.getExtensionRegistry().getExtensionPoint(ResourcesPlugin.PI_RESOURCES, ResourcesPlugin.PT_MIGRATION_HELPERS);

			if (extension != null) {

				IExtension[] extensions = extension.getExtensions();

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

					IExtension extension2 = extensions[i]; 

					IConfigurationElement[] configElements = extension2.getConfigurationElements();

					for ( int j = 0; j < configElements.length; j ++ ) {

						IConfigurationElement configElement = configElements[j];

						if( configElement.getAttribute( "class" ) != null ) { //$NON-NLS-1$

							helpers.add( configElement.createExecutableExtension("class")); //$NON-NLS-1$

						}

					}

				}

			}

		} catch (CoreException e) {

			ResourcesPlugin.getPlugin().getLog().log(new Status( IStatus.ERROR, ResourcesPlugin.PI_RESOURCES, Messages.getString("ExportProjectMigrationInfo.4"), e));  //$NON-NLS-1$

		}

		return (IExecutableExtension[]) helpers.toArray(new IExecutableExtension[0]);

	}

*/	

}

/*******************************************************************************

 * Copyright (c) 2000, 2006, 2008 IBM Corporation and others.

 * All rights reserved. This program and the accompanying materials

 * are made available under the terms of the Eclipse Public License v1.0

 * which accompanies this distribution, and is available at

 * http://www.eclipse.org/legal/epl-v10.html

 *

 * Contributors:

 *     Wind River Systems, Inc. - initial API and implementation

 *******************************************************************************/

package org.eclipse.core.internal.resources.projectmigration;

import java.io.*;

import java.util.*;

import org.eclipse.core.filesystem.*;

import org.eclipse.core.runtime.*;

/**

 * This class writes and reads a file which represent a snapshot of a particular

 * directory and all of its contained files

 */

public class SnapInfoStore {

	String rootPath; // the root directory for the snapshot

	File storeFile; // the file to write to or read from

	int fileCount; // total number of files in the store

	int rootLocals; // number of spaces reserved for local

	List excludeCheckPathList;	// list containing the canonical paths of symlinks and 

								// their immediate parents

	// pass-through files in the root directory

	public SnapInfoStore(String rootPath, File storeFile, int rootLocals) {

		this.rootPath = rootPath;

		this.storeFile = storeFile;

		this.rootLocals = rootLocals;

	}

	public SnapInfoStore(String rootPath, File storeFile) {

		this.rootPath = rootPath;

		this.storeFile = storeFile;

		this.rootLocals = 0;

	}

	public boolean write(IProgressMonitor monitor) {

		boolean ret = false;

		if (!rootPath.equals("")) { //$NON-NLS-1$

			IFileStore rootStore = EFS.getLocalFileSystem().getStore(

					new Path(rootPath));

			IFileInfo info = rootStore.fetchInfo();

			if (info != null && info.exists()) {

				try {

					storeFile.delete();

					fileCount = 1;

					RandomAccessFile out = new RandomAccessFile(storeFile, "rw"); //$NON-NLS-1$

					out.writeInt(0); // will be rewritten with total file count

					// write dummy record for root directory

					out.writeInt(SnapInfo.ATTRIBUTE_DIRECTORY);

					out.writeLong(0);

					out.writeLong(0);

					IPath path = new Path(rootPath);

					String name = path.lastSegment();

					out.writeUTF(name != null ? name : ""); //$NON-NLS-1$

					ret = writeChildren(monitor, out, rootStore);

					out.seek(0);

					out.writeInt(fileCount);

					out.close();

				} catch (IOException e) {

					return false;

				}

			}

		}

		return ret;

	}

	public SnapInfo[] read(IProgressMonitor monitor) {

		try {

			if (storeFile.exists()) {

				RandomAccessFile in = new RandomAccessFile(storeFile, "r"); //$NON-NLS-1$

				int totalCount = in.readInt();

				if (totalCount != 0) {

					SnapInfo[] infos = new SnapInfo[totalCount + rootLocals];

					fileCount = 0;

					SnapInfo snap = readInfo(in); // read root entry

					infos[0] = snap;

					fileCount = rootLocals + 1; // reserve for root locals

					snap = readChildren(in, 0, infos);

					snap.setNextIndex(0); // end of root dir entries

					return infos;

				}

			}

		} catch (IOException e) {

			return null;

		}

		return null;

	}

	private boolean writeChildren(IProgressMonitor monitor,

			RandomAccessFile out, IFileStore parent) {

		try {

			Set childrenToExclude = new HashSet();

			if(excludeCheckPathList == null)

			{

				excludeCheckPathList = new ArrayList();

				excludeCheckPathList.add(rootPath);

			}

			IFileStore[] fileStores = parent.childStores(EFS.NONE, monitor);

			String parentCanonicalPath = parent.toLocalFile(EFS.NONE, monitor).getCanonicalPath();

			boolean parentAdded = false;

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

			{

				File file = fileStores[i].toLocalFile(EFS.NONE, monitor);

				// Check if the file is a symlinked directory.

				if(parentCanonicalPath != null && file != null)

				{

					String fileAbsPath = file.getAbsolutePath();

					String fileCanonicalPath = file.getCanonicalPath();					

					boolean childToExcludeFound = false; 

					if(file.isDirectory() && (!fileAbsPath.equals(fileCanonicalPath)))

					{

						// Check to see if the symlinked child canonical path is a substring of parent path or

						// in other words, check if the parent path starts with the child canonical path.

						if (parentCanonicalPath.startsWith(fileCanonicalPath))

						{

							childrenToExclude.add(file.getName());

//							System.out.println("Recursion detected, excluding - [" + fileAbsPath + "] , [" + fileCanonicalPath + "]"); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$

//							System.out.println("Symlink refers to an ancestor of this path - " + parentCanonicalPath); //$NON-NLS-1$

							continue;

						}

						// Check if any of the collected paths starts with this child symlink cannonical path.

						// or in other words check if child symlink canonical path is a substring of parent canonical path.

						Iterator iter = excludeCheckPathList.iterator();						

						while(iter.hasNext())

						{

							String excludeCheckPathListStr = (String) iter.next();

							if(excludeCheckPathListStr.startsWith(fileCanonicalPath))

							{

								childrenToExclude.add(file.getName());

								childToExcludeFound = true;

//								System.out.println("Recursion detected, excluding - [" + file.getAbsolutePath() + "] , [" + file.getCanonicalPath() + "]"); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$

//								System.out.println("Recursion detected against a previously included parent's path - " + excludeCheckPathListStr); //$NON-NLS-1$

								break;

							}

						}

						if(childToExcludeFound)

						{

							continue;

						}

						if (!parentAdded)

						{

							excludeCheckPathList.add(parentCanonicalPath);

							parentAdded = true;

						}

						excludeCheckPathList.add(fileCanonicalPath);						

					}

				}

				else

				{

//					System.out.println("File is null - " + fileStores[i].getName());  //$NON-NLS-1$

				}

			}			

			String[] children = parent.childNames(EFS.NONE, monitor);			

			List childrenWithoutRecursiveLinksList = new ArrayList();			

			// exclude the recursive links from children from the collected set of files.

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

			{

				if(!childrenToExclude.contains(children[i]))

				{

					childrenWithoutRecursiveLinksList.add(children[i]);					

				}						

			}			

			String[] childrenWithoutRecursiveLinks = (String[]) childrenWithoutRecursiveLinksList.toArray(new String[childrenWithoutRecursiveLinksList.size()]);			

			out.writeInt(childrenWithoutRecursiveLinks.length);

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

				IFileStore store = parent.getChild(childrenWithoutRecursiveLinks[i]);

				// possible speedup if following line calls fetchInfo()?

				IFileInfo info = store.fetchInfo(EFS.NONE, monitor);

				if (!writeInfo(out, info))

					return false;

				if (info.isDirectory() && !writeChildren(monitor, out, store))

					return false;

			}

			return true;

		} catch (CoreException e) {

			return false;

		} catch (IOException e) {

			return false;

		}

	}

	private boolean writeInfo(RandomAccessFile out, IFileInfo info) {

		try {

			int attributes = 0;

			if (info.getAttribute(EFS.ATTRIBUTE_ARCHIVE))

				attributes |= EFS.ATTRIBUTE_ARCHIVE;

			if (info.getAttribute(EFS.ATTRIBUTE_EXECUTABLE))

				attributes |= EFS.ATTRIBUTE_EXECUTABLE;

			if (info.getAttribute(EFS.ATTRIBUTE_HIDDEN))

				attributes |= EFS.ATTRIBUTE_HIDDEN;

			// if (info.getAttribute(EFS.ATTRIBUTE_SYMLINK))

			// attributes |= EFS.ATTRIBUTE_SYMLINK;

			if (info.getAttribute(EFS.ATTRIBUTE_READ_ONLY))

				attributes |= EFS.ATTRIBUTE_READ_ONLY;

			if (info.isDirectory())

				attributes |= SnapInfo.ATTRIBUTE_DIRECTORY;

			out.writeInt(attributes);

			// if ((attributes & EFS.ATTRIBUTE_SYMLINK) != 0) {

			// String link = info.getStringAttribute(EFS.ATTRIBUTE_LINK_TARGET);

			// out.writeUTF(link);

			// }

			out.writeLong(info.getLastModified());

			out.writeLong(info.getLength());

			out.writeUTF(info.getName());

			++fileCount;

			return true;

		} catch (IOException e) {

			return false;

		}

	}

	private SnapInfo readChildren(RandomAccessFile in, int parentIndex,

			SnapInfo[] infos) throws IOException {

		SnapInfo snap = null;

		int nChildren = in.readInt();

		for (int i = 0; i < nChildren; i++) {

			snap = readInfo(in);

			infos[fileCount++] = snap;

			if (snap.isDirectory()) {

				snap.setChildIndex(fileCount); // assume non-empty

				SnapInfo last = readChildren(in, fileCount - 1, infos);

				if (last != null)

					last.setNextIndex(0); // end of this directory

				else

					snap.setChildIndex(0); // directory was empty

			}

			snap.setNextIndex(fileCount);

			snap.setParentIndex(parentIndex);

		}

		return snap;

	}

	private SnapInfo readInfo(RandomAccessFile in) throws IOException {

		int attributes = in.readInt();

		long lastModified = in.readLong();

		long length = in.readLong();

		String name = in.readUTF();

		SnapInfo snap = new SnapInfo(name);

		snap.setAttributes(attributes);

		snap.setLastModified(lastModified);

		snap.setLength(length);

		return snap;

	}

}

/*******************************************************************************

 * Copyright (c) 2009 IBM Corporation and others.

 * All rights reserved. This program and the accompanying materials

 * are made available under the terms of the Eclipse Public License v1.0

 * which accompanies this distribution, and is available at

 * http://www.eclipse.org/legal/epl-v10.html

 * 

 * Contributors:

 *     Wind River Systems, Inc. - initial API and implementation

 *******************************************************************************/

package org.eclipse.core.resources.projectmigration;

import org.eclipse.core.internal.resources.projectmigration.Messages;

import java.io.File;

import java.io.FileInputStream;

import java.io.FileOutputStream;

import java.io.InputStream;

import java.io.IOException;

import java.io.OutputStream;

import java.util.ArrayList;

import java.util.List;

import java.util.zip.Deflater;

import java.util.zip.ZipEntry;

import java.util.zip.ZipOutputStream;

//import org.eclipse.core.resources.IFile;

import org.eclipse.core.resources.IProject;

import org.eclipse.core.resources.IProjectDescription;

import org.eclipse.core.resources.IWorkspaceRunnable;

import org.eclipse.core.resources.ResourcesPlugin;

import org.eclipse.core.runtime.CoreException;

import org.eclipse.core.runtime.IConfigurationElement;

import org.eclipse.core.runtime.IExecutableExtension;

import org.eclipse.core.runtime.IExtension;

import org.eclipse.core.runtime.IExtensionPoint;

import org.eclipse.core.runtime.IProgressMonitor;

import org.eclipse.core.runtime.IStatus;

//import org.eclipse.core.runtime.NullProgressMonitor;

import org.eclipse.core.runtime.OperationCanceledException;

//import org.eclipse.core.runtime.Path;

import org.eclipse.core.runtime.Platform;

import org.eclipse.core.runtime.Status;

import org.eclipse.core.runtime.SubProgressMonitor;

import org.eclipse.core.internal.resources.projectmigration.SFSUtilities;

/**

 * 

 */

public class ExportProjectMigrationInfo implements IWorkspaceRunnable {

	private IProject fProject;		// project that is being exported