Attachment #83202 for bug #209434

Some Eclipse Foundation services are deprecated, or will be soon. Please ensure you've read this important communication.




/**
 * <copyright> 
 *
 * Copyright (c) 2004-2005 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 - Initial API and implementation
 *
 * </copyright>
 *
 * $Id$
 */
package org.eclipse.emf.common.archive;

import java.io.IOException;
import java.io.InputStream;
import java.net.URL;
import java.net.URLConnection;
import java.net.URLStreamHandler;

/**
 * A URL stream handler that can be {@link #register() registered} to support archive access protocol.
 * It uses {@link ArchiveURLConnection} to implement the connection.
 */
public class Handler extends URLStreamHandler
{
  /**
   * Registers this class.
   * A handler for protocol "xyz" is registered 
   * by providing a class named Handler implementing {@link URLStreamHandler}
   * in a package called named xyz in a package of your choosing,
   * and then registering that chosen prefix package name 
   * in the system property for <code>"java.protocol.handler.pkgs"</code>,
   * which is an "|" separated list of package prefixes to search for handlers.
   */
  public static void register()
  {
    String javaProtocolHandlerPkgs = System.getProperty("java.protocol.handler.pkgs");
    if (javaProtocolHandlerPkgs == null || javaProtocolHandlerPkgs.length() == 0)
    {
      javaProtocolHandlerPkgs = "org.eclipse.emf.common";
    }
    else
    {
      javaProtocolHandlerPkgs += "|org.eclipse.emf.common";
    }
    System.setProperty("java.protocol.handler.pkgs", javaProtocolHandlerPkgs); 
  }
  
  /**
   * Registers this handler and interprets each argument as URL to be opened, read in, and written out to System.out.
   * @param args URLs to open, read, and write to System.out
   * @throws IOException if there are problems opening or reading from the URLs, or writing to System.out.
   */
  public static void main(String[] args) throws IOException
  {
    register();
    
    for (int i = 0; i < args.length; ++i)
    {
      InputStream inputStream = new URL(args[i]).openStream();
      byte [] bytes = new byte [4048];
      for (int size; (size = inputStream.read(bytes, 0, bytes.length)) > -1; )
      {
        System.out.write(bytes, 0, size);
      }
    }
  }
  
  /**
   *  Creates an instance.
   */
  public Handler()
  {
    super();
  }
  
  /**
   * Overrides parsing the URL to validate constraints on well formed archive syntax.
   * @see URLStreamHandler#parseURL(java.net.URL, java.lang.String, int, int)
   */
  protected void parseURL(URL url, String specification, int start, int limit)
  {
    super.parseURL(url, specification, start, limit);
      
    // There needs to be another URL protocol right after the archive protocol, and not a "/".
    //
    if (start > limit || specification.charAt(start) == '/')
    {
      throw 
        new IllegalArgumentException
          ("archive protocol must be immediately followed by another URL protocol " + specification);
    }
    
    // There must be at least one archive path.
    //
    int archiveSeparator = specification.indexOf("!/", start);
    if (archiveSeparator < 0)
    {
      throw new IllegalArgumentException("missing archive separators " + specification.substring(start, limit));
    }
          
    // Parse to count the archive paths that must will be delegated to the nested URL based on the number of schemes at the start.
    //
    for (int i = start, end = specification.indexOf('/', start) - 1; (i = specification.indexOf(':', i)) < end; ++i)
    {
      // There should be at least one archive separator per scheme.
      //
      archiveSeparator = specification.indexOf("!/", archiveSeparator + 2);
      if (archiveSeparator < 0)
      {
        throw new IllegalArgumentException("too few archive separators " + specification);
      }
    }
  }
  
  /**
   *  Returns a new {@link ArchiveURLConnection}.
   */
  protected URLConnection openConnection(URL url) throws IOException
  {
    return new ArchiveURLConnection(url);
  }
}




<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
    "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml">
<head>
<meta name="generator" content="HTML Tidy, see www.w3.org" />
<meta http-equiv="Content-Type"
content="text/html; charset=ISO-8859-1" /><!--
/**
 * <copyright>
 *
 * Copyright (c) 2005 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 - Initial API and implementation
 *
 * </copyright>
 *
 * $Id$
 */




/**
 * <copyright> 
 *
 * Copyright (c) 2004-2005 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 - Initial API and implementation
 *
 * </copyright>
 *
 * $Id$
 */
package org.eclipse.emf.common.archive;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.FilterInputStream;
import java.io.FilterOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.MalformedURLException;
import java.net.URL;
import java.net.URLConnection;
import java.util.zip.ZipEntry;
import java.util.zip.ZipFile;
import java.util.zip.ZipInputStream;
import java.util.zip.ZipOutputStream;

/**
 * A connection that can access an entry in an archive, and then recursively an entry in that archive, and so on.
 * For example, it can be used just like jar: or zip:, only the archive paths can repeat, e.g.,
 *<pre>
 *  archive:file:///c:/temp/example.zip!/org/example/nested.zip!/org/example/deeply-nested.html
 *</pre>
 * The general recursive pattern is
 *<pre>
 *  archive:$nestedURL${/!$archivePath$}+
 *</pre>
 * So the nested URL for the example above is
 *<pre>
 *  file:///c:/temp/example.zip
 *</pre>
 * 
 * <p>
 * Since the nested URL may itself contain archive schemes,
 * the subsequence of the archive paths that should be associated with the nested URL 
 * is determined by finding the nth archive separator, i.e., the nth !/, 
 * where n is the number of ":"s before the first "/" of the nested URL, i.e., the number of nested schemes.
 * For example, for a more complex case where the nested URL is itself an archive-based scheme, e.g.,
 *<pre>
 *  archive:jar:file:///c:/temp/example.zip!/org/example/nested.zip!/org/example/deeply-nested.html
 *</pre>
 * the nested URL is correctly parsed to skip to the second archive separator as
 *<pre>
 *  jar:file:///c:/temp/example.zip!/org/example/nested.zip
 *</pre>
 * </p>
 *
 * <p>
 * The logic for accessing archives can be tailored and reused independant from its usage as a URL connection.
 * This is normally done by using the constructor {@link #ArchiveURLConnection(String)}
 * and overriding {@link #createInputStream(String)} and {@link #createOutputStream(String)}.
 * The behavior can be tailored by overriding {@link #emulateArchiveScheme()} and {@link #useZipFile()}.
 * </p>
 */
public class ArchiveURLConnection extends URLConnection
{
  /**
   * The cached string version of the {@link #url URL}.
   */
  protected String urlString;
  
  /**
   * Constructs a new connection for the URL.
   * @param url the URL of this connection.
   */
  public ArchiveURLConnection(URL url)
  {
    super(url);
    urlString = url.toString();
  }
  
  /**
   * Constructs a new archive accessor.
   * This constructor forwards a null URL to be super constructor, 
   * so an instance built with this constructor <b>cannot</b> be used as a URLConnection.
   * The logic for accessing archives and for delegating to the nested URL can be reused in other applications,
   * without creating an URLs.
   * @param url the URL of the archive.
   */
  protected ArchiveURLConnection(String url)
  {
    super(null);
    urlString = url;
  }
  
  /**
   * </p>
   * Returns whether the implementation will handle all the archive accessors directly.
   * For example, whether
   *<pre>
   *  archive:jar:file:///c:/temp/example.zip!/org/example/nested.zip!/org/example/deeply-nested.html
   *</pre>
   * will be handled as if it were specified as
   *<pre>
   *  archive:file:///c:/temp/example.zip!/org/example/nested.zip!/org/example/deeply-nested.html
   *</pre>
   * Override this only if you are reusing the logic of retrieving an input stream into an archive 
   * and hence are likely to be overriding createInputStream, 
   * which is the point of delegation to the nested URL for recursive stream creation.
   * </p>
   * @return whether the implementation will handle all the archive accessors directly.
   */
  protected boolean emulateArchiveScheme()
  {
    return false;
  }
  
  /**
   * Returns whether to handle the special case of a nested URL with file: schema using a {@link ZipFile}.
   * This gives more efficient direct access to the root entry, e.g., 
   *<pre>
   *  archive:file:///c:/temp/example.zip!/org/example/nested.html
   *</pre>
   * @return whether to handle the special case of a nested URL with file: schema using a ZipFile.
   */
  protected boolean useZipFile()
  {
    return false;
  }
        
  /**
   * Record that this is connected.
   */
  public void connect() throws IOException
  {
    connected = true;
  }
  
  /**
   * Creates the input stream for the URL.
   * @return the input stream for the URL.
   */
  public InputStream getInputStream() throws IOException 
  {
    // There must be at least one archive path.
    //
    int archiveSeparator = urlString.indexOf("!/");
    if (archiveSeparator < 0)
    {
      throw new MalformedURLException("missing archive separators " + urlString);
    }
    
    // There needs to be another URL protocol right after the archive protocol, and not a "/".
    //
    int start = urlString.indexOf(':') + 1;
    if (start > urlString.length() || urlString.charAt(start) == '/')
    {
      throw 
        new IllegalArgumentException
          ("archive protocol must be immediately followed by another URL protocol " + urlString);
    }
    
    // Parse to extract the archives that will be delegated to the nested URL based on the number of schemes at the start.
    //
    for (int i = start, end = urlString.indexOf("/") - 1; (i = urlString.indexOf(":", i)) < end; )
    {
      if (emulateArchiveScheme())
      {
        // Skip a scheme for the achive accessor to be handled directly here.
        //
        start = ++i;
      }
      else
      {
        // Skip an archive accessor to be handled by delegation to the scheme in nested URL.
        //
        archiveSeparator = urlString.indexOf("!/", archiveSeparator + 2);
        if (archiveSeparator < 0)
        {
          throw new MalformedURLException("too few archive separators " + urlString);
        }
        ++i;
      }
    }
          
    // System.out.println("archive: " + urlString.substring(start, archiveSeparator) + " -> " + urlString.substring(archiveSeparator + 2));
          
    // Create the delegate URL.
    //
    String nestedURL = urlString.substring(start, archiveSeparator);
          
    // The cutoff point to the next archive.
    //
    int nextArchiveSeparator = urlString.indexOf("!/", archiveSeparator + 2);
          
    // Construct the input stream in a special efficient way for case of a file scheme.
    //
    InputStream inputStream;
    if (!useZipFile() || !nestedURL.startsWith("file:"))
    {
      // Just get the stream from the URL.
      //
      inputStream =  createInputStream(nestedURL);
    }
    else
    {
      // The name to be used for the entry.
      //
      String entry = 
         nextArchiveSeparator < 0 ?
           urlString.substring(archiveSeparator + 2) :
           urlString.substring(archiveSeparator + 2, nextArchiveSeparator);
                 
      // Skip over this archive path to the next one, since we are handling this one special.
      //
      archiveSeparator = nextArchiveSeparator;
      nextArchiveSeparator = urlString.indexOf("!/", archiveSeparator + 2);
            
      // Go directly to the right entry in the zip file, 
      // get the stream, 
      // and wrap it so that closing it closes the zip file.
      //
      final ZipFile zipFile = new ZipFile(nestedURL.substring(5));
      ZipEntry zipEntry = zipFile.getEntry(entry);
      if (zipEntry == null)
      {
        throw new IOException("archive entry not found " + entry);
      }
      inputStream = 
        new FilterInputStream(zipFile.getInputStream(zipEntry))
        {
          public void close() throws IOException
          {
            super.close();
            zipFile.close();
          }
        };
    }
          
    // Loop over the archive paths.
    //
    LOOP:
    while (archiveSeparator > 0)
    {
      // The entry name to be matched.
      //
      String entry = 
         nextArchiveSeparator < 0 ?
           urlString.substring(archiveSeparator + 2) :
           urlString.substring(archiveSeparator + 2, nextArchiveSeparator);
            
      // Wrap the input stream as a zip stream to scan it's contents for a match.
      //
      ZipInputStream zipInputStream = new ZipInputStream(inputStream);
      while (zipInputStream.available() >= 0)
      {
        ZipEntry zipEntry = zipInputStream.getNextEntry();
        if (zipEntry == null)
        {
          break;
        }
        else if (entry.equals(zipEntry.getName()))
        {
          inputStream = zipInputStream;
                  
          // Skip to the next archive path and continue the loop.
          //
          archiveSeparator = nextArchiveSeparator;
          nextArchiveSeparator = urlString.indexOf("!/", archiveSeparator + 2);
          continue LOOP;
        }
      }
            
      // Unless we matched an entry, we're done.
      //
      break;
    }
          
    return inputStream;
  }
  
  /**
   * Creates an input stream for the nested URL by calling {@link URL#openStream()opening} a stream on it.
   * @param nestedURL the nested URL for which a stream is required.
   * @return the open stream of the nested URL.
   */
  protected InputStream createInputStream(String nestedURL) throws IOException
  {
    return new URL(nestedURL).openStream();
  }
  
  /**
   * Creates the output stream for the URL.
   * @return the output stream for the URL.
   */
  public OutputStream getOutputStream() throws IOException
  {
    // There must be at least one archive separator.
    //
    int archiveSeparator = urlString.indexOf("!/");
    if (archiveSeparator < 0)
    {
      throw new MalformedURLException("missing archive separator in " + urlString);
    }
    
    // There needs to be another URL protocol right after the archive protocol, and not a "/".
    //
    int start = urlString.indexOf(':') + 1;
    if (start > urlString.length() || urlString.charAt(start) == '/')
    {
      throw 
        new IllegalArgumentException
          ("archive protocol must be immediately followed by another URL protocol " + urlString);
    }
    
    // Parse the URI to extract the nested/delegate URI based on preference and the number of schemes at the start.
    //
    for (int i = start, end = urlString.indexOf("/") - 1; (i = urlString.indexOf(":", i)) < end; )
    {
      if (emulateArchiveScheme())
      {
        // Skip a scheme for the achive accessor to be handled directly here.
        //
        start = ++i;
      }
      else
      {
        // Skip an archive accessor to be handled by delegation to the scheme in nested URI.
        //
        archiveSeparator = urlString.indexOf("!/", archiveSeparator + 2);
        if (archiveSeparator < 0)
        {
          throw new MalformedURLException("too few archive separators in " + urlString);
        }
        ++i;
      }
    }
    
    // System.out.println("archive: -> " + urlString.substring(start, archiveSeparator) + " -> " + urlString.substring(archiveSeparator + 2));
    
    // Create the delegate URL
    //
    final String nestedURL = urlString.substring(start, archiveSeparator);
    
    // Create a temporary file where the existing contents of the archive can be written 
    // before the new contents are added.
    //
    final File tempFile = File.createTempFile("Archive", "zip");
    
    // Record the input and output streams for closing in case of failure so that handles are not left open.
    //
    InputStream sourceInputStream =  null;
    OutputStream tempOutputStream = null;
    try
    {
      // Create the output stream to the temporary file and the input stream for the delegate URL.
      //
      tempOutputStream = new FileOutputStream(tempFile);
      try
      {
        sourceInputStream =  createInputStream(nestedURL);
      }
      catch (IOException exception)
      {
        // Continue processing if the file doesn't exist so that we try create a new empty one.
      }
      
      // Record them as generic streams to record state during the loop that emulates recursion.
      //
      OutputStream outputStream = tempOutputStream;
      InputStream inputStream =  sourceInputStream;
      
      // The cutoff point to the next archive.
      //
      int nextArchiveSeparator = urlString.indexOf("!/", archiveSeparator + 2);
      
      // The most deeply nested output stream that will be returned wrapped as the result.
      //
      ZipOutputStream zipOutputStream;
      
      // A buffer for transferring archive contents.
      //
      final byte [] bytes = new byte [4096];
              
      // We expect there to be at least one archive path.
      //
      do
      {
        // The name that will be used as the archive entry.
        //
        String entry = 
           nextArchiveSeparator < 0 ?
             urlString.substring(archiveSeparator + 2) :
             urlString.substring(archiveSeparator + 2, nextArchiveSeparator);
             
        // Wrap the current result as a zip stream, and record it for loop-based recursion.
        //
        zipOutputStream =  new ZipOutputStream(outputStream);
        outputStream = zipOutputStream;
        
        // Wrap the current input as a zip stream, and record it for loop-based recursion.
        //
        ZipInputStream zipInputStream = inputStream == null ? null : new ZipInputStream(inputStream);
        inputStream = zipInputStream;
        
        // Loop over the entries in the zip stream.
        //
        while (zipInputStream != null && zipInputStream.available() >= 0)
        {
          // If this entry isn't the end marker 
          // and isn't the matching one that we are replacing...
          //
          ZipEntry zipEntry = zipInputStream.getNextEntry();
          if (zipEntry == null)
          {
            break;
          }
          else if (!entry.equals(zipEntry.getName()))
          {
            // Transfer the entry and its contents.
            //
            zipOutputStream.putNextEntry(zipEntry);
            for (int size; (size = zipInputStream.read(bytes, 0, bytes.length)) > -1; )
            {
              zipOutputStream.write(bytes, 0, size);
            }
          }
        }
        
        // Create a new or replaced entry.
        //
        zipOutputStream.putNextEntry(new ZipEntry(entry));
        
        // Find the next archive path and continue "recursively" if there is one.
        //
        archiveSeparator = nextArchiveSeparator;
        nextArchiveSeparator = urlString.indexOf("!/", archiveSeparator + 2);
      }
      while (archiveSeparator > 0);
      
      // Ensure that it won't be closed in the finally block.
      //
      tempOutputStream = null;
      
      // Wrap the deepest result so that on close, the results are finally transferred.
      //
      final boolean deleteRequired = sourceInputStream != null;
      return
        new FilterOutputStream(zipOutputStream)
        {
          protected boolean isClosed;
          
          public void close() throws IOException
          {
            // Make sure we close only once.
            //
            if (!isClosed)
            {
              isClosed = true;
              
              // Close for real so that the temporary file is ready to be read.
              //
              super.close();
              
              boolean useRenameTo = nestedURL.startsWith("file:");
              
              // If the delegate URI can be handled as a file, 
              // we'll hope that renaming it will be really efficient.
              //
              if (useRenameTo)
              {
                File targetFile = new File(nestedURL.substring(5));
                if (deleteRequired && !targetFile.delete())
                {
                  throw new IOException("cannot delete " + targetFile.getPath());
                }
                else if (!tempFile.renameTo(targetFile))
                {
                  useRenameTo = false;
                }
              }
              if (!useRenameTo)
              {
                // Try to transfer it by reading the contents of the temporary file 
                // and writing them to the output stream of the delegate.
                //
                InputStream inputStream = null;
                OutputStream outputStream = null;
                try
                {
                  inputStream = new FileInputStream(tempFile);
                  outputStream = createOutputStream(nestedURL);
                  for (int size; (size = inputStream.read(bytes, 0, bytes.length)) > -1; )
                  {
                    outputStream.write(bytes, 0, size);
                  }
                }
                finally
                {
                  // Make sure they are closed no matter what bad thing happens.
                  //
                  if (inputStream != null) 
                  {
                    inputStream.close();
                  }
                  if (outputStream != null) 
                  {
                    outputStream.close();
                  }
                }
              }
            }
          }
       };
    }
    finally
    {
      // Close in case of failure to complete.
      //
      if (tempOutputStream != null)
      {
        tempOutputStream.close();
      }
      
      // Close if we created this.
      //
      if (sourceInputStream != null)
      {
        sourceInputStream.close();
      }
    }
  }
  
  /**
   * Creates an input stream for the nested URL by calling {@link URL#openStream()opening} a stream on it.
   * @param nestedURL the nested URL for which a stream is required.
   * @return the open stream of the nested URL.
   */
  protected OutputStream createOutputStream(String nestedURL) throws IOException
  {
    URL url = new URL(nestedURL.toString());
    URLConnection urlConnection = url.openConnection();
    urlConnection.setDoOutput(true);
    return urlConnection.getOutputStream(); 
  }
}

Lines 1-7 Link Here

(-).classpath (-4 / +4 lines)
1	<?xml version="1.0" encoding="UTF-8"?>	1	<?xml version="1.0" encoding="UTF-8"?>
2	<classpath>	2	<classpath>
3	<classpathentry kind="src" path="src/"/>	3	<classpathentry kind="src" path="src"/>
4	<classpathentry kind="con" path="org.eclipse.pde.core.requiredPlugins"/>	4	<classpathentry kind="con" path="org.eclipse.pde.core.requiredPlugins"/>
5	<classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER"/>	5	<classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER"/>
6	<classpathentry kind="output" path="bin"/>	6	<classpathentry kind="output" path="bin"/>
7	</classpath>	7	</classpath>

Lines 17-27 Link Here

(-)src/org/eclipse/emf/common/util/BasicEList.java (-51 / +63 lines)
17	package org.eclipse.emf.common.util;	17	package org.eclipse.emf.common.util;
18		18
19		19
20	import java.io.IOException;	20	//XXX GWT CHANGE
21	import java.io.ObjectInputStream;	21	//import java.io.IOException;
22	import java.io.ObjectOutputStream;	22	//import java.io.ObjectInputStream;
		23	//import java.io.ObjectOutputStream;
23	import java.io.Serializable;	24	import java.io.Serializable;
24	import java.lang.reflect.Array;	25	//import java.lang.reflect.Array;
25	import java.util.AbstractList;	26	import java.util.AbstractList;
26	import java.util.Collection;	27	import java.util.Collection;
27	import java.util.ConcurrentModificationException;	28	import java.util.ConcurrentModificationException;
Lines 47-52 Link Here
47	*/	48	*/
48	protected transient Object data[];	49	protected transient Object data[];
49		50
		51	//XXX GWT CHANGE (modcount not available in upstream GWT maybe a feature request
		52	// should be raised)
		53	protected transient int modCount = 0;
		54
50	/**	55	/**
51	* Creates an empty instance with no initial capacity.	56	* Creates an empty instance with no initial capacity.
52	* The data storage will be null.	57	* The data storage will be null.
Lines 444-450 Link Here
444	{	449	{
445	if (array.length < size)	450	if (array.length < size)
446	{	451	{
447	array = (Object[])Array.newInstance(array.getClass().getComponentType(), size);	452	//FIXME GWT CHANGE DO WE NEED TO FIX THIS?
		453	array = new Object[size];
		454	// array = (Object[])Array.newInstance(array.getClass().getComponentType(), size);
448	}	455	}
449		456
450	System.arraycopy(data, 0, array, 0, size);	457	System.arraycopy(data, 0, array, 0, size);
Lines 1071-1114 Link Here
1071	}	1078	}
1072	}	1079	}
1073		1080
1074	private synchronized void writeObject(ObjectOutputStream objectOutputStream) throws IOException	1081	//XXX GWT CHANGE Serialization not available
1075	{	1082	// private synchronized void writeObject(ObjectOutputStream objectOutputStream) throws IOException
1076	objectOutputStream.defaultWriteObject();	1083	// {
1077	if (data == null)	1084	// objectOutputStream.defaultWriteObject();
1078	{	1085	// if (data == null)
1079	objectOutputStream.writeInt(0);	1086	// {
1080	}	1087	// objectOutputStream.writeInt(0);
1081	else	1088	// }
1082	{	1089	// else
1083	objectOutputStream.writeInt(data.length);	1090	// {
1084	for (int i = 0; i < size; ++i)	1091	// objectOutputStream.writeInt(data.length);
1085	{	1092	// for (int i = 0; i < size; ++i)
1086	objectOutputStream.writeObject(data[i]);	1093	// {
1087	}	1094	// objectOutputStream.writeObject(data[i]);
1088	}	1095	// }
1089	}	1096	// }
1090		1097	// }
1091	private synchronized void readObject(ObjectInputStream objectInputStream) throws IOException, ClassNotFoundException	1098	//
1092	{	1099	// private synchronized void readObject(ObjectInputStream objectInputStream) throws IOException, ClassNotFoundException
1093	objectInputStream.defaultReadObject();	1100	// {
1094	int arrayLength = objectInputStream.readInt();	1101	// objectInputStream.defaultReadObject();
1095	if (arrayLength > 0)	1102	// int arrayLength = objectInputStream.readInt();
1096	{	1103	// if (arrayLength > 0)
1097	try	1104	// {
1098	{	1105	// try
1099	data = newData(arrayLength);	1106	// {
1100	}	1107	// data = newData(arrayLength);
1101	catch (Throwable exception)	1108	// }
1102	{	1109	// catch (Throwable exception)
1103	data = new Object[arrayLength];	1110	// {
1104	}	1111	// data = new Object[arrayLength];
1105		1112	// }
1106	for (int i = 0; i < size; ++i)	1113	//
1107	{	1114	// for (int i = 0; i < size; ++i)
1108	didAdd(i, assign(i, objectInputStream.readObject()));	1115	// {
1109	}	1116	// didAdd(i, assign(i, objectInputStream.readObject()));
1110	}	1117	// }
1111	}	1118	// }
		1119	// }
1112		1120
1113	/**	1121	/**
1114	* Returns a shallow copy of this list.	1122	* Returns a shallow copy of this list.
Lines 1116-1124 Link Here
1116	*/	1124	*/
1117	public Object clone()	1125	public Object clone()
1118	{	1126	{
1119	try	1127	//FIXME GWT CHANGE .clone is not supported by GWT
1120	{	1128	// but creating a new list is not 100% the same!
1121	BasicEList clone = (BasicEList)super.clone();	1129	// Should we raise a bug against GWT and ask for clone-support for lists?
		1130	// try
		1131	// {
		1132	// BasicEList clone = (BasicEList)super.clone();
		1133	BasicEList clone = new BasicEList(this);
1122	if (size > 0)	1134	if (size > 0)
1123	{	1135	{
1124	clone.size = size;	1136	clone.size = size;
Lines 1126-1136 Link Here
1126	System.arraycopy(data, 0, clone.data, 0, size);	1138	System.arraycopy(data, 0, clone.data, 0, size);
1127	}	1139	}
1128	return clone;	1140	return clone;
1129	}	1141	// }
1130	catch (CloneNotSupportedException exception)	1142	// catch (CloneNotSupportedException exception)
1131	{	1143	// {
1132	throw new InternalError();	1144	// throw new InternalError();
1133	}	1145	// }
1134	}	1146	}
1135		1147
1136	/**	1148	/**




/**
 * <copyright> 
 *
 * Copyright (c) 2002-2004 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 - Initial API and implementation
 *
 * </copyright>
 *
 * $Id: ResourceLocator.java,v 1.3 2005/06/08 06:19:08 nickb Exp $
 */
package org.eclipse.emf.common.util;

public interface ResourceLocator {

	String getString(String string, Object[] objects);


/**
 * A locator of Java resources.
 */
public interface ResourceLocator
{
  /** 
   * Returns the URL from which all resources are based.
   * @return the URL from which all resources are based.
   */
  URL getBaseURL();

  /**
   * Returns the description that can be used to create the image resource associated with the key.
   * The description will typically be in the form of a URL to the image data.
   * Creation of an actual image depends on the GUI environment;
   * within Eclipse, org.eclipse.emf.edit.ui.provider.ExtendedImageRegistry can be used.
   * @param key the key of the image resource.
   * @return the description on the image resource.
   */
  Object getImage(String key);

  /**
   * Returns the string resource associated with the key.
   * @param key the key of the string resource.
   * @return the string resource associated with the key.
   */
  String getString(String key);

  /**
   * Returns the string resource associated with the key.
   * @param key the key of the string resource.
   * @param translate whether the result is to be translated to the current locale.
   * @return the string resource associated with the key.
   */
  String getString(String key, boolean translate);

  /**
   * Returns a string resource associated with the key, and peforms substitutions.
   * @param key the key of the string.
   * @param substitutions the message substitutions.
   * @return a string resource associated with the key.
   * @see #getString(String)
   * @see java.text.MessageFormat#format(String, Object[])
   */
  String getString(String key, Object [] substitutions);

  /**
   * Returns a string resource associated with the key, and peforms substitutions.
   * @param key the key of the string.
   * @param substitutions the message substitutions.
   * @param translate whether the result is to be translated to the current locale.
   * @return a string resource associated with the key.
   * @see #getString(String)
   * @see java.text.MessageFormat#format(String, Object[])
   */
  String getString(String key, Object [] substitutions, boolean translate);
}




/**
 * <copyright>
 *
 * Copyright (c) 2005 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 - Initial API and implementation
 *
 * </copyright>
 *
 * $Id: BasicMonitor.java,v 1.1 2005/11/18 12:01:19 emerks Exp $
 */
package org.eclipse.emf.common.util;

import java.io.PrintStream;

import org.eclipse.core.runtime.IProgressMonitor;
import org.eclipse.core.runtime.IProgressMonitorWithBlocking;
import org.eclipse.core.runtime.IStatus;
import org.eclipse.core.runtime.SubProgressMonitor;


/**
 * The most basic implementation of a task monitor.
 */
public class BasicMonitor implements Monitor 
{
  private boolean isCanceled;
  
  private Diagnostic blockedReason;
  
  public BasicMonitor()
  {
  }

  public boolean isCanceled()
  {
    return isCanceled;
  }

  public void setCanceled(boolean isCanceled)
  {
    this.isCanceled = isCanceled;
  }
  
  /**
   * Returns the current reason for task being blocked, or <code>null</code>.
   */
  public Diagnostic getBlockedReason()
  {
    return blockedReason;
  }
  
  public void setBlocked(Diagnostic reason)
  {
    this.blockedReason = reason;
  }

  public void clearBlocked()
  {
    this.blockedReason = null;
  }
 
  public void beginTask(String name, int totalWork)
  {
  }
  
  public void setTaskName(String name)
  {
  }

  public void subTask(String name)
  {
  }

  public void worked(int work)
  {
  }
  
  public void internalWorked(double work)
  {
  }
    
  public void done()
  {
  }
  
  /**
   * A simple monitor that delegates to another monitor.
   */
  public static class Delegating
  {
    protected Monitor monitor;
    
    public Delegating(Monitor monitor)
    {
      this.monitor = monitor; 
    }
    
    public boolean isCanceled()
    {
      return monitor.isCanceled();
    }

    public void setCanceled(boolean value)
    {
      monitor.setCanceled(value);
    }

    public void setBlocked(Diagnostic reason)
    {
      monitor.setBlocked(reason);
    }
    
    public void clearBlocked()
    {
      monitor.clearBlocked();
    }

    public void beginTask(String name, int totalWork)
    {
      monitor.beginTask(name, totalWork);
    }

    public void setTaskName(String name)
    {
      monitor.setTaskName(name);
    }

    public void subTask(String name)
    {
      monitor.subTask(name);
    }

    public void worked(int work)
    {
      monitor.worked(work);
    }
    
    public void internalWorked(double work)
    {
      monitor.internalWorked(work);
    }

    public void done()
    {
      monitor.done();
    }
    
    /**
     * A simple monitor that delegates to another monitor, and implements the Eclipse API
     */
    private static class Eclipse extends Delegating implements IProgressMonitorWithBlocking
    {
      public Eclipse(Monitor monitor)
      {
        super(monitor);
      }
      
      public void setBlocked(IStatus reason)
      {
        setBlocked
          (new BasicDiagnostic
              (reason.getSeverity(), 
               reason.getPlugin(), 
               reason.getCode(), 
               reason.getMessage(), 
               null));
      }
  
      public static IProgressMonitorWithBlocking createIProgressMonitorWithBlocking(Monitor monitor)
      {
        if (monitor instanceof IProgressMonitorWithBlocking)
        {
          return (IProgressMonitorWithBlocking)monitor;
        }
        else
        {
          return new Eclipse(monitor);
        }
      }
      
      public static IProgressMonitor createIProgressMonitor(Monitor monitor)
      {
        if (monitor instanceof IProgressMonitor)
        {
          return (IProgressMonitor)monitor;
        }
        else
        {
          return new Eclipse(monitor);
        }
      }
    }
  }
  
  /**
   * Creates a delegating wrapper that allows the monitor to be used 
   * in a context requiring an instance implementing the Eclipse API.
   */
  public static IProgressMonitor toIProgressMonitor(Monitor monitor)
  {
    return Delegating.Eclipse.createIProgressMonitor(monitor);
  }
  
  /**
   * Creates a delegating wrapper that allows the monitor to be used 
   * in a context requiring an instance implementing the Eclipse API.
   */
  public static IProgressMonitorWithBlocking toIProgressMonitorWithBlocking(Monitor monitor)
  {
    return Delegating.Eclipse.createIProgressMonitorWithBlocking(monitor);
  }
  
  /**
   * A simple monitor that delegates to another Eclipse monitor.
   */
  private static class EclipseDelegating implements Monitor
  {
    protected IProgressMonitor progressMonitor;
    protected IProgressMonitorWithBlocking progressMonitorWithBlocking;
    
    public EclipseDelegating(IProgressMonitor progressMonitor)
    {
      this.progressMonitor = progressMonitor; 
      if (progressMonitor instanceof IProgressMonitorWithBlocking)
      {
        this.progressMonitorWithBlocking = (IProgressMonitorWithBlocking)progressMonitor;
      }
    }
    
    public EclipseDelegating(IProgressMonitorWithBlocking progressMonitorWithBlocking)
    {
      this.progressMonitor = progressMonitorWithBlocking; 
      this.progressMonitorWithBlocking = progressMonitorWithBlocking; 
    }
    
    public boolean isCanceled()
    {
      return progressMonitor.isCanceled();
    }

    public void setCanceled(boolean value)
    {
      progressMonitor.setCanceled(value);
    }

    public void setBlocked(Diagnostic reason)
    {
      if (progressMonitorWithBlocking != null)
      {
        progressMonitorWithBlocking.setBlocked(BasicDiagnostic.toIStatus(reason));
      }
    }

    public void clearBlocked()
    {
      if (progressMonitorWithBlocking != null)
      {
        progressMonitorWithBlocking.clearBlocked();
      }
    }

    public void beginTask(String name, int totalWork)
    {
      progressMonitor.beginTask(name, totalWork);
    }
    
    public void setTaskName(String name)
    {
      progressMonitor.setTaskName(name);
    }

    public void subTask(String name)
    {
      progressMonitor.subTask(name);
    }

    public void worked(int work)
    {
      progressMonitor.worked(work);
    }
    
    public void internalWorked(double work)
    {
      progressMonitor.internalWorked(work);
    }

    public void done()
    {
      progressMonitor.done();
    }
  }
  
  /**
   * Creates a delegating wrapper that allows the Eclipse progress monitor to be used 
   * in a context requiring an instance implementing the monitor API.
   */
  public static Monitor toMonitor(IProgressMonitorWithBlocking progressMonitor)
  {
    return new EclipseDelegating(progressMonitor);
  }
  
  /**
   * Creates a delegating wrapper that allows the Eclipse progress monitor to be used 
   * in a context requiring an instance implementing the monitor API.
   */
  public static Monitor toMonitor(IProgressMonitor progressMonitor)
  {
    return new EclipseDelegating(progressMonitor);
  }
  
  /**
   * An Eclipse subprogress monitor that directly implements the monitor API.
   */
  public static class EclipseSubProgress extends SubProgressMonitor implements Monitor
  {
    public EclipseSubProgress(IProgressMonitor monitor, int ticks)
    {
      super(monitor, ticks);
    }

    public EclipseSubProgress(IProgressMonitor monitor, int ticks, int style)
    {
      super(monitor, ticks, style);
    }

    public void setBlocked(Diagnostic reason)
    {
      super.setBlocked(BasicDiagnostic.toIStatus(reason));
    }
  }
  
  /**
   * A simple monitor that prints progress to a print stream.
   */
  public static class Printing extends BasicMonitor
  {
    protected PrintStream printStream;

    public Printing(PrintStream printStream)
    {
      this.printStream = printStream;
    }

    public void beginTask(String name, int totalWork)
    {
      if (name != null && name.length() != 0)
      {
        printStream.println(">>> " + name);
      }
    }

    public void setTaskName(String name)
    {
      if (name != null && name.length() != 0)
      {
        printStream.println("<>> " + name);
      }
    }

    public void subTask(String name)
    {
      if (name != null && name.length() != 0)
      {
        printStream.println(">>  " + name);
      }
    }
    
    public void setBlocked(Diagnostic reason)
    {
      super.setBlocked(reason);
      printStream.println("#>  " + reason.getMessage());
    }
  
    public void clearBlocked()
    {
      printStream.println("=>  " + getBlockedReason().getMessage());
      super.clearBlocked();
    }
  }
}




/**
 * <copyright>
 *
 * Copyright (c) 2002-2005 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 - Initial API and implementation
 *
 * </copyright>

 */
package org.eclipse.emf.common.util;

//import java.io.File;
//import java.lang.ref.WeakReference;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.HashMap;
import java.util.HashSet;
//import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Set;

 * can be used, in which a non-null <code>device</code> parameter can be
 * specified.
 *
 * <p><a name="archive_explanation">
 * The other enhancement provides support for the almost-hierarchical
 * form used for files within archives, such as the JAR scheme, defined
 * for the Java Platform in the documentation for {@link

 * createURI(String) createURI} to have parsed them correctly from a single
 * URI string.  If necessary in the future, these tests may be made more
 * strict, to better coform to the RFC.
 *
 * <p>Another group of static methods, whose names begin with "encode", use
 * percent escaping to encode any characters that are not permitted in the
 * various URI components. Another static method is provided to {@link

  private final boolean absolutePath;
  private final String[] segments; // empty last segment -> trailing separator
  private final String query;
  private static final char File_separatorChar = '/';

  // A cache of URIs, keyed by the strings from which they were created.
  // The fragment of any URI is removed before caching it here, to minimize
  // the size of the cache in the usual case where most URIs only differ by
  // the fragment.
  private static final Map uriCache =
    new HashMap()
//    {
//      static final int MIN_LIMIT = 1000;
//      int count;
//      int limit = MIN_LIMIT;
//
//      public synchronized Object get(Object key)
//      {
//        WeakReference reference = (WeakReference)super.get(key);
//        return reference == null ? null : reference.get();
//      }
//
//      public synchronized Object put(Object key, Object value)
//      {
//        super.put(key, new WeakReference(value));
//        if (++count > limit)
//        {
//          cleanGCedValues();
//        }
//
//        // The return value is not used.
//        return null;
//      }
//
//      private void cleanGCedValues()
//      {
//        for (Iterator i = entrySet().iterator(); i.hasNext(); )
//        {
//          Map.Entry entry = (Map.Entry)i.next();
//          WeakReference reference = (WeakReference)entry.getValue();
//          if (reference.get() == null)
//          {
//            i.remove();
//          }
//        }
//        count = 0;
//        limit = Math.max(MIN_LIMIT, size() / 2);
//      }
//    }
  ;

  // The lower-cased schemes that will be used to identify archive URIs.
  private static final Set archiveSchemes;

  private static final long ALPHANUM_LO = ALPHA_LO | DIGIT_LO;
  private static final long HEX_HI = DIGIT_HI | highBitmask('A', 'F') | highBitmask('a', 'f');
  private static final long HEX_LO = DIGIT_LO | lowBitmask('A', 'F')  | lowBitmask('a', 'f');
  private static final long UNRESERVED_HI = ALPHANUM_HI | highBitmask("-_.!~*'()");
  private static final long UNRESERVED_LO = ALPHANUM_LO | lowBitmask("-_.!~*'()");
  private static final long RESERVED_HI = highBitmask(";/?:@&=+$,");
  private static final long RESERVED_LO = lowBitmask(";/?:@&=+$,");

  private static final long URIC_LO = RESERVED_LO | UNRESERVED_LO;

  // Additional useful character classes, including characters valid in certain
  // URI components and separators used in parsing them out of a string.
  //
  private static final long SEGMENT_CHAR_HI = UNRESERVED_HI | highBitmask(";:@&=+$,");  // | ucschar | escaped
  private static final long SEGMENT_CHAR_LO = UNRESERVED_LO | lowBitmask(";:@&=+$,");

  private static final long SEGMENT_END_HI = highBitmask("/?#");
  private static final long SEGMENT_END_LO = lowBitmask("/?#");

  // We can't want to do encoding of platform resource URIs by default yet.
  //
  private static final boolean ENCODE_PLATFORM_RESOURCE_URIS =
//    System.getProperty("org.eclipse.emf.common.util.URI.encodePlatformResourceURIs") != null &&
//    !"false".equalsIgnoreCase(System.getProperty("org.eclipse.emf.common.util.URI.encodePlatformResourceURIs"));
	  false;

  // Static initializer for archiveSchemes.
  static
  {
    Set set = new HashSet();
//    String propertyValue = System.getProperty("org.eclipse.emf.common.util.URI.archiveSchemes");
    String propertyValue = null;
    if (propertyValue == null)
    {
      set.add(SCHEME_JAR);

      set.add(SCHEME_ARCHIVE);
    }
    else
    {
      for (StringTokenizer t = new StringTokenizer(propertyValue); t.hasMoreTokens(); )
      {
        set.add(t.nextToken().toLowerCase());
      }
    }

    archiveSchemes = Collections.unmodifiableSet(set);
  }


  /**
   * Static factory method for a hierarchical URI with absolute path.
   * The URI will be relative if <code>scheme</code> is non-null, and
   * absolute otherwise.
   *
   * @param segments an array of non-null strings, each representing one
   * segment of the path.  As an absolute path, it is automatically
   * preceeded by a <code>/</code> separator.  If desired, a trailing
   * separator should be represented by an empty-string segment as the last
   * element of the array.
   *
   * @exception java.lang.IllegalArgumentException if <code>scheme</code> is
   * an <a href="#archive_explanation">archive URI</a> scheme and
   * <code>device</code> is non-null, or if <code>scheme</code>,
   * <code>authority</code>, <code>device</code>, <code>segments</code>,
   * <code>query</code>, or <code>fragment</code> is not valid according to

   * empty-string segment at the end of the array.
   *
   * @exception java.lang.IllegalArgumentException if <code>segments</code>,
   * <code>query</code>, or <code>fragment</code> is not valid according to
   * {@link #validSegments validSegments}, {@link #validQuery validQuery}, or
   * {@link #validFragment validFragment}, respectively.
   */

  // immutability.
  private static String[] fix(String[] segments)
  {
//    return segments == null ? NO_SEGMENTS : (String[])segments.clone();
    return segments == null ? NO_SEGMENTS : clone(segments);
  }

  private static String[] clone(String[] s) {
	  String[] rv = new String[s.length];
	  for( int i = 0; i < s.length; i++ ) {
		  rv[i] = s[i];
	  }

	  return rv;
  }

  /**
   * Static factory method based on parsing a URI string, with
   * <a href="#device_explanation">explicit device support</a> and handling
   * for <a href="#archive_explanation">archive URIs</a> enabled. The
   * specified string is parsed as described in <a

   */
  public static URI createURI(String uri)
  {
    return createURIWithCache(uri);
  }

  /**

   * Appropriate encoding is performed for each component of the URI.
   * If more than one <code>#</code> is in the string, the last one is
   * assumed to be the fragment's separator, and any others are encoded.
   *
   * @param ignoreEscaped <code>true</code> to leave <code>%</code> characters
   * unescaped if they already begin a valid three-character escape sequence;
   * <code>false</code> to encode all <code>%</code> characters.  Note that
   * if a <code>%</code> is not followed by 2 hex digits, it will always be
   * escaped.
   *
   * @exception java.lang.IllegalArgumentException if any component parsed
   * from <code>uri</code> is not valid according to {@link #validScheme

   * the fragment separator, and any others should be encoded.
   * @see #createURI(String, boolean, int)
   */
  public static final int FRAGMENT_LAST_SEPARATOR = 2;

  /**
   * Static factory method that encodes and parses the given URI string.
   * Appropriate encoding is performed for each component of the URI.
   * Control is provided over which, if any, <code>#</code> should be
   * taken as the fragment separator and which should be encoded.
   *
   * @param ignoreEscaped <code>true</code> to leave <code>%</code> characters
   * unescaped if they already begin a valid three-character escape sequence;
   * <code>false</code> to encode all <code>%</code> characters.  Note that
   * if a <code>%</code> is not followed by 2 hex digits, it will always be
   * escaped.
   *
   * @param fragmentLocationStyle one of {@link #FRAGMENT_NONE},
   * {@link #FRAGMENT_FIRST_SEPARATOR}, or {@link #FRAGMENT_LAST_SEPARATOR},
   * indicating which, if any, of the <code>#</code> characters should be

  }

  /**
   * Static factory method based on parsing a URI string, with
   * <a href="#device_explanation">explicit device support</a> enabled.
   * Note that validity testing is not a strict as in the RFC; essentially,
   * only separator characters are considered.  So, for example, non-Latin
   * alphabet characters appearing in the scheme would not be considered an

  // by string-parsing factory methods, instead of parseIntoURI() directly.
  /**
   * This method was included in the public API by mistake.
   *
   * @deprecated Please use {@link #createURI createURI} instead.
   */
  public static URI createURIWithCache(String uri)

    {
      j = find(uri, i + 1, SEGMENT_END_HI, SEGMENT_END_LO);
      String s = uri.substring(i + 1, j);

      if (s.length() > 0 && s.charAt(s.length() - 1) == DEVICE_IDENTIFIER)
      {
        device = s;

   *
   * <p>A relative path with a specified device (something like
   * <code>C:myfile.txt</code>) cannot be expressed as a valid URI.
   *
   * @exception java.lang.IllegalArgumentException if <code>pathName</code>
   * specifies a device and a relative path, or if any component of the path
   * is not valid according to {@link #validAuthority validAuthority}, {@link

   */
  public static URI createFileURI(String pathName)
  {
//    File file = new File(pathName);
    String uri = File_separatorChar != '/' ? pathName.replace(File_separatorChar, SEGMENT_SEPARATOR) : pathName;
    uri = encode(uri, PATH_CHAR_HI, PATH_CHAR_LO, false);
//    if (file.isAbsolute())
//    {
//      URI result = createURI((uri.charAt(0) == SEGMENT_SEPARATOR ? "file:" : "file:/") + uri);
//      return result;
//    }
//    else
    {
      URI result = createURI(uri);
      if (result.scheme() != null)

   * stand-alone EMF.
   *
   * <p>Path encoding is performed only if the
   * <code>org.eclipse.emf.common.util.URI.encodePlatformResourceURIs</code>
   * system property is set to "true". Decoding can be performed with the
   * static {@link #decode(String) decode} method.
   *
   * @exception java.lang.IllegalArgumentException if any component parsed
   * from the path is not valid according to {@link #validDevice validDevice},
   * {@link #validSegments validSegments}, {@link #validQuery validQuery}, or

   * and other characters disallowed in URIs, as well as <code>?</code>,
   * which would delimit a path from a query.  Decoding can be performed with
   * the static {@link #decode(String) decode} method.
   *
   * @exception java.lang.IllegalArgumentException if any component parsed
   * from the path is not valid according to {@link #validDevice validDevice},
   * {@link #validSegments validSegments}, {@link #validQuery validQuery}, or

   */
  public static URI createPlatformResourceURI(String pathName, boolean encode)
  {
    if (File_separatorChar != SEGMENT_SEPARATOR)
    {
      pathName = pathName.replace(File_separatorChar, SEGMENT_SEPARATOR);
    }

    if (encode)

    URI result = createURI((pathName.charAt(0) == SEGMENT_SEPARATOR ? "platform:/resource" : "platform:/resource/") + pathName);
    return result;
  }

  // Private constructor for use of static factory methods.
  private URI(boolean hierarchical, String scheme, String authority,
              String device, boolean absolutePath, String[] segments,

    this.hashCode = hashCode;
    //this.iri = iri;
    this.hierarchical = hierarchical;
    this.scheme = scheme == null ? null : new String(scheme);
    this.authority = authority;
    this.device = device;
    this.absolutePath = absolutePath;

    this.query = query;
    this.fragment = fragment;
  }

  // Validates all of the URI components.  Factory methods should call this
  // before using the constructor, though they must ensure that the
  // inter-component requirements described in their own Javadocs are all

   */
  public static boolean validScheme(String value)
  {
    return value == null || !contains(value, MAJOR_SEPARATOR_HI, MAJOR_SEPARATOR_LO);

  // <p>A valid scheme may be null, or consist of a single letter followed
  // by any number of letters, numbers, and the following characters:


  // <p>A valid opaque part must be non-null and non-empty. It may contain
  // any allowed URI characters, but its first character may not be
  // <code>/</code>

    //return value != null && value.length() != 0 &&
    //  value.charAt(0) != SEGMENT_SEPARATOR &&

   * URI</a>. This method has been replaced by {@link #validArchiveAuthority
   * validArchiveAuthority} since the same form of URI is now supported
   * for schemes other than "jar". This now simply calls that method.
   *
   * @deprecated As of EMF 2.0, replaced by {@link #validArchiveAuthority
   * validArchiveAuthority}.
   */

   * character must be <code>:</code>
   */
  public static boolean validDevice(String value)
  {
    if (value == null) return true;
    int len = value.length();
    return len > 0 && value.charAt(len - 1) == DEVICE_IDENTIFIER &&

    return value != null && !contains(value, SEGMENT_END_HI, SEGMENT_END_LO);

  // <p>A valid path segment must be non-null and may contain any allowed URI
  // characters except for the following: <code>/ ?</code>

    //return value != null && validate(value, SEGMENT_CHAR_HI, SEGMENT_CHAR_LO, true, true);
  }


  // Returns null if the specicied value is null or would be a valid path
  // segment array of a URI; otherwise, the value of the first invalid
  // segment.
  private static String firstInvalidSegment(String[] value)
  {
    if (value == null) return null;

                                     boolean allowNonASCII, boolean allowEscaped)
  {
    for (int i = 0, len = value.length(); i < len; i++)
    {
      char c = value.charAt(i);

      if (matches(c, highBitmask, lowBitmask)) continue;


  /**
   * Returns <code>true</code> if this is a hierarcical URI with an authority
   * component; <code>false</code> otherwise.
   */
  public boolean hasAuthority()
  {


  /**
   * Returns <code>true</code> if this is a hierarchical URI with an empty
   * relative path; <code>false</code> otherwise.
   *
   * <p>Note that <code>!hasEmpty()</code> does <em>not</em> imply that this
   * URI has any path segments; however, <code>hasRelativePath &&

    // By default, "jar", "zip", and "archive" are considered archives.
    return value != null && archiveSchemes.contains(value.toLowerCase());
  }

  /**
   * Returns the hash code.
   */

      equals(scheme, uri.scheme(), true) &&
      equals(authority, hierarchical ? uri.authority() : uri.opaquePart()) &&
      equals(device, uri.device()) &&
      equals(query, uri.query()) &&
      equals(fragment, uri.fragment()) &&
      segmentsEqual(uri);
  }

   * user info portion, returns it; <code>null</code> otherwise.
   */
  public String userInfo()
  {
    if (!hasAuthority()) return null;

    int i = authority.indexOf(USER_INFO_SEPARATOR);
    return i < 0 ? null : authority.substring(0, i);
  }

  public String host()
  {
    if (!hasAuthority()) return null;

    int i = authority.indexOf(USER_INFO_SEPARATOR);
    int j = authority.indexOf(PORT_SEPARATOR);
    return j < 0 ? authority.substring(i + 1) : authority.substring(i + 1, j);

   */
  public String[] segments()
  {
	  return clone(segments);
  }

  /**


  /**
   * If this is a hierarchical URI with a path, returns a string
   * representation of the path, including the authority and the
   * <a href="#device_explanation">device component</a>;
   * <code>null</code> otherwise.
   *
   * <p>If there is no authority, the format of this string is:
   * <pre>

      throw new IllegalArgumentException(
        "invalid query portion: " + query);
    }
    return new URI(hierarchical, scheme, authority, device, absolutePath, segments, query, fragment);
  }

  /**

    }
    else
    {
      return new URI(hierarchical, scheme, authority, device, absolutePath, segments, null, fragment);
    }
  }


      throw new IllegalArgumentException(
        "invalid fragment portion: " + fragment);
    }
    URI result = new URI(hierarchical, scheme, authority, device, absolutePath, segments, query, fragment);

    if (!hasFragment())
    {

    }
    else if (cachedTrimFragment == null)
    {
      cachedTrimFragment = new URI(hierarchical, scheme, authority, device, absolutePath, segments, query, null);
    }

    return cachedTrimFragment;

    String newQuery = query;
    // note: it's okay for two URIs to share a segments array, since
    // neither will ever modify it

    if (authority == null)
    {
      // no authority: use base's

        {
          // relative path: merge with base and keep query (note: if the
          // base has no path and this a non-empty relative path, there is
          // an implied root in the resulting path)
          newAbsolutePath = base.hasAbsolutePath() || !hasEmptyPath();
          newSegments = newAbsolutePath ? mergePath(base, preserveRootParents)
            : NO_SEGMENTS;

      // else keep device, path, and query
    }
    // else keep authority, device, path, and query

    // always keep fragment, even if null, and use scheme from base;
    // no validation needed since all components are from existing URIs
    return new URI(true, base.scheme(), newAuthority, newDevice,

      sp = accumulate(stack, sp, segments[i], preserveRootParents);
    }

    // if the relative path is empty or ends in an empty segment, a parent
    // reference, or a self referenfce, add a trailing separator to a
    // non-empty path
    if (sp > 0 &&  (segmentCount == 0 ||

  /**
   * Finds the shortest relative or, if necessary, the absolute URI that,
   * when resolved against the given <code>base</code> absolute hierarchical
   * URI using {@link #resolve(URI) resolve}, will yield this absolute URI.
   *
   * @exception java.lang.IllegalArgumentException if <code>base</code> is
   * non-hierarchical or is relative.


    // note: these assertions imply that neither this nor the base URI has a
    // relative path; thus, both have either an absolute path or no path

    // different scheme: need complete, absolute URI
    if (!scheme.equalsIgnoreCase(base.scheme())) return this;


    if (sp > 0 && (SEGMENT_EMPTY.equals(segments[segmentCount - 1]) ||
                   SEGMENT_PARENT.equals(segments[segmentCount - 1]) ||
                   SEGMENT_SELF.equals(segments[segmentCount - 1])))
    {
      stack[sp++] = SEGMENT_EMPTY;
    }


   * non-hierarchical URI, this looks like:
   * <pre>
   *   scheme:opaquePart#fragment</pre>
   *
   * <p>For a hierarchical URI, it looks like:
   * <pre>
   *   scheme://authority/device/pathSegment1/pathSegment2...?query#fragment</pre>


  /**
   * If this URI may refer directly to a locally accessible file, as
   * determined by {@link #isFile isFile}, {@link decode decodes} and formats
   * the URI as a pathname to that file; returns null otherwise.
   *
   * <p>If there is no authority, the format of this string is:

   * <p>If there is an authority, it is:
   * <pre>
   *   //authority/device/pathSegment1/pathSegment2...</pre>
   *
   * <p>However, the character used as a separator is system-dependant and
   * obtained from {@link java.io.File#separatorChar}.
   */

    if (!isFile()) return null;

    StringBuffer result = new StringBuffer();
    char separator = File_separatorChar;

    if (hasAuthority())
    {

    if (!isHierarchical()) return this;

    // absolute path or no path -> absolute path
    boolean newAbsolutePath = !hasRelativePath();

    int len = this.segments.length;
    int segmentsCount = segments.length;
    String[] newSegments = new String[len + segmentsCount];
    System.arraycopy(this.segments, 0, newSegments, 0, len);
    System.arraycopy(segments, 0, newSegments, len, segmentsCount);

    return new URI(true, scheme, authority, device, newAbsolutePath,
                   newSegments, query, fragment);
  }

   *
   * <p>Note that if all segments are trimmed from an absolute path, the
   * root absolute path remains.
   *
   * @param i the number of segments to be trimmed in the returned URI.  If
   * less than 1, this URI is returned unchanged; if equal to or greater
   * than the number of segments in this URI's path, all segments are
   * trimmed.
   */
  public URI trimSegments(int i)
  {

   */
  public boolean hasTrailingPathSeparator()
  {
    return segments.length > 0 &&
      SEGMENT_EMPTY.equals(segments[segments.length - 1]);
  }


    String[] newSegments = new String[len];
    System.arraycopy(segments, 0, newSegments, 0, len - 1);
    newSegments[len - 1] = newLastSegment.toString();

    // note: segments.length > 0 -> hierarchical
    return new URI(true, scheme, authority, device, absolutePath,
                   newSegments, query, fragment);
  }

  /**


    // note: segments.length > 0 -> hierarchical
    return new URI(true, scheme, authority, device, absolutePath,
                   newSegments, query, fragment);
  }

  /**

    {
      return NO_SEGMENTS;
    }

    // Otherwise, the path needs only the remaining segments.
    String[] newSegments = new String[segments.length - i];
    System.arraycopy(segments, i, newSegments, 0, newSegments.length);

   * Encodes a string so as to produce a valid opaque part value, as defined
   * by the RFC.  All excluded characters, such as space and <code>#</code>,
   * are escaped, as is <code>/</code> if it is the first character.
   *
   * @param ignoreEscaped <code>true</code> to leave <code>%</code> characters
   * unescaped if they already begin a valid three-character escape sequence;
   * <code>false</code> to encode all <code>%</code> characters.  Note that
   * if a <code>%</code> is not followed by 2 hex digits, it will always be
   * escaped.
   */
  public static String encodeOpaquePart(String value, boolean ignoreEscaped)
  {

   * Encodes a string so as to produce a valid authority, as defined by the
   * RFC.  All excluded characters, such as space and <code>#</code>,
   * are escaped, as are <code>/</code> and <code>?</code>
   *
   * @param ignoreEscaped <code>true</code> to leave <code>%</code> characters
   * unescaped if they already begin a valid three-character escape sequence;
   * <code>false</code> to encode all <code>%</code> characters.  Note that
   * if a <code>%</code> is not followed by 2 hex digits, it will always be
   * escaped.
   */
  public static String encodeAuthority(String value, boolean ignoreEscaped)
  {

   * Encodes a string so as to produce a valid segment, as defined by the
   * RFC.  All excluded characters, such as space and <code>#</code>,
   * are escaped, as are <code>/</code> and <code>?</code>
   *
   * @param ignoreEscaped <code>true</code> to leave <code>%</code> characters
   * unescaped if they already begin a valid three-character escape sequence;
   * <code>false</code> to encode all <code>%</code> characters.  Note that
   * if a <code>%</code> is not followed by 2 hex digits, it will always be
   * escaped.
   */
  public static String encodeSegment(String value, boolean ignoreEscaped)
  {

  /**
   * Encodes a string so as to produce a valid query, as defined by the RFC.
   * Only excluded characters, such as space and <code>#</code>, are escaped.
   *
   * @param ignoreEscaped <code>true</code> to leave <code>%</code> characters
   * unescaped if they already begin a valid three-character escape sequence;
   * <code>false</code> to encode all <code>%</code> characters.  Note that
   * if a <code>%</code> is not followed by 2 hex digits, it will always be
   * escaped.
   */
  public static String encodeQuery(String value, boolean ignoreEscaped)
  {

   * Encodes a string so as to produce a valid fragment, as defined by the
   * RFC.  Only excluded characters, such as space and <code>#</code>, are
   * escaped.
   *
   * @param ignoreEscaped <code>true</code> to leave <code>%</code> characters
   * unescaped if they already begin a valid three-character escape sequence;
   * <code>false</code> to encode all <code>%</code> characters.  Note that
   * if a <code>%</code> is not followed by 2 hex digits, it will always be
   * escaped.
   */
  public static String encodeFragment(String value, boolean ignoreEscaped)
  {

      result.append(scheme);
      result.append(SCHEME_SEPARATOR);
    }

    int j =
      fragmentLocationStyle == FRAGMENT_FIRST_SEPARATOR ? uri.indexOf(FRAGMENT_SEPARATOR) :
        fragmentLocationStyle == FRAGMENT_LAST_SEPARATOR ? uri.lastIndexOf(FRAGMENT_SEPARATOR) : -1;

      String sspart = uri.substring(++i);
      result.append(encode(sspart, URIC_HI, URIC_LO, ignoreEscaped));
    }

    return result.toString();
  }



    for (int i = 0, len = value.length(); i < len; i++)
    {
      if (isEscaped(value, i))
      {
        if (result == null)
        {

   * Returns <code>true</code> if this URI contains non-ASCII characters;
   * <code>false</code> otherwise.
   *
   * This unused code is included for possible future use...
   */
/*
  public boolean isIRI()
  {
    return iri;
  }

  // Returns true if the given string contains any non-ASCII characters;

      {
        eSegments[i] = encodeAsASCII(segments[i]);
      }
      cachedASCIIURI = new URI(hierarchical, scheme, eAuthority, eDevice, absolutePath, eSegments, eQuery, eFragment);

    }
    return cachedASCIIURI;

Lines 32-37 Link Here

(-)src/org/eclipse/emf/common/util/DelegatingEList.java (+3 lines)
32	*/	32	*/
33	public abstract class DelegatingEList extends AbstractList implements EList, Cloneable, Serializable	33	public abstract class DelegatingEList extends AbstractList implements EList, Cloneable, Serializable
34	{	34	{
		35	//FIXME GWT CHANGE modCount not available, file bug against GWT?
		36	protected transient int modCount = 0;
		37
35	/**	38	/**
36	* Creates an empty instance.	39	* Creates an empty instance.
37	*/	40	*/




package  org.eclipse.emf.common.util;


//import java.io.IOException;
//import java.io.ObjectInputStream;
//import java.io.ObjectOutputStream;
import java.io.Serializable;
import java.util.AbstractCollection;
import java.util.AbstractSet;

/**
 * A highly extensible map implementation.
 */
public class BasicEMap implements EMap, Cloneable, Serializable
{
  /**
   * An extended implementation interface for caching hash values
   * and for upating an entry that may be manufactured as a uninitialized instance by a factory.
   * No client is expected to use this interface,
   * other than to implement it in conjunction with a map implementation.
   */
  public interface Entry extends Map.Entry

  /**
   * Creates an empty instance.
   */
  public BasicEMap()
  {
    initializeDelegateEList();
  }

  /**
   * Initializes the {@link #delegateEList}.
   * This implementation illustrates the precise pattern that is used to
   * delegate a list implementation's callback methods to the map implementation.
   */
  protected void initializeDelegateEList()
  {
    delegateEList =

   * Creates an instance that is a copy of the map.
   * @param map the initial contents of the map.
   */
  public BasicEMap(Map map)
  {
    this();
    int mapSize = map.size();

  }

  /**
   * Ensures that the entry data is created
   * and is populated with contents of the delegate list.
   */
  protected void ensureEntryDataExists()

  /*
   * Javadoc copied from interface.
   */
  public int indexOfKey(Object key)
  {
    if (useEqualsForKey() && key != null)
    {

  /*
   * Javadoc copied from interface.
   */
  public boolean containsKey(Object key)
  {
    if (size > 0)
    {

  /*
   * Javadoc copied from interface.
   */
  public boolean containsValue(Object value)
  {
    if (size > 0)
    {
      ensureEntryDataExists();

      if (useEqualsForValue() && value != null)
      {
        for (int i = 0; i < entryData.length; ++i)
        {

          }
        }
      }
      else
      {
        for (int i = 0; i < entryData.length; ++i)
        {

  /*
   * Javadoc copied from interface.
   */
  public Object get(Object key)
  {
    if (size > 0)
    {

  /*
   * Javadoc copied from interface.
   */
  public Object put(Object key, Object value)
  {
    ensureEntryDataExists();


  /*
   * Javadoc copied from source.
   */
  public Object removeKey(Object key)
  {
    ensureEntryDataExists();


    return entry.getValue();
  }

  /*
   * Javadoc copied from interface.
   */
  public void putAll(Map map)
  {
    for (Iterator i = map.entrySet().iterator(); i.hasNext(); )
    {
      Map.Entry entry = (Map.Entry)i.next();
      put(entry.getKey(), entry.getValue());
    }
  }

  /*
   * Javadoc copied from interface.
   */
  public void putAll(EMap map)
  {
    for (Iterator i = map.iterator(); i.hasNext(); )
    {
      Map.Entry entry = (Map.Entry)i.next();
      put(entry.getKey(), entry.getValue());

  /**
   * Clears the map.
   */
  protected void doClear()
  {
    if (entryData == null)
    {

  /**
   * Increments the modification count.
   */
  protected void doMove(Entry entry)
  {
    ++modCount;
  }

   * Returns a shallow copy of this map.
   * @return a shallow copy of this map.
   */
  public Object clone()
  {
//FIXME GWT CHANGE .clone is not supported by GWT
// but creating a new list is not 100% the same!
// Should we raise a bug against GWT and ask for clone-support for lists?
//    try
//    {
//      BasicEMap result = (BasicEMap)super.clone();
      BasicEMap result = new BasicEMap();
      if (entryData != null)
      {
        result.entryData = newEntryData(entryData.length);

      result.view = null;
      result.modCount = 0;
      return result;
//    }
//    catch (CloneNotSupportedException exception)
//    {
//      throw new InternalError();
//    }
  }

  protected class DelegatingMap implements EMap.InternalMapView

  /*
   * Javadoc copied from interface.
   */
  public Set keySet()
  {
    if (view == null)
    {
      view = new View();
    }
    if (view.keySet == null)
    {
      view.keySet =
        new AbstractSet()
        {
          public Iterator iterator()
          {
            return BasicEMap.this.size == 0 ? ECollections.EMPTY_ELIST.iterator() : new BasicEMap.BasicEMapKeyIterator();
          }

          public int size()
          {
            return BasicEMap.this.size;
          }

          public boolean contains(Object key)
          {
            return BasicEMap.this.containsKey(key);
          }

          public boolean remove(Object key)
          {
            int oldSize = BasicEMap.this.size;
            BasicEMap.this.removeKey(key);
            return BasicEMap.this.size != oldSize;
          }

          public void clear()
          {
            BasicEMap.this.clear();
          }

  /*
   * Javadoc copied from interface.
   */
  public Collection values()
  {
    if (view == null)
    {
      view = new View();
    }
    if (view.values == null)
    {
      view.values =
        new AbstractCollection()
        {
          public Iterator iterator()
          {
            return BasicEMap.this.size == 0 ? ECollections.EMPTY_ELIST.iterator() : new BasicEMap.BasicEMapValueIterator();
          }
          public int size()
          {
            return size;
          }
          public boolean contains(Object value)
          {
            return containsValue(value);
          }
          public void clear()
          {
            BasicEMap.this.clear();
          }

  /*
   * Javadoc copied from interface.
   */
  public Set entrySet()
  {
    if (view == null)
    {
      view = new View();
    }
    if (view.entrySet == null)
    {
      view.entrySet = new AbstractSet()
      {
        public int size()
        {
          return BasicEMap.this.size;
        }

        public boolean contains(Object object)
        {
          if (BasicEMap.this.size > 0 && object instanceof Map.Entry)
          {
            BasicEMap.this.ensureEntryDataExists();
            Map.Entry otherEntry = (Map.Entry)object;
            Object key = otherEntry.getKey();

            int hash = key == null ? 0 : key.hashCode();
            int index = BasicEMap.this.indexOf(hash);
            BasicEList eList = entryData[index];

          return false;
        }

        public boolean remove(Object object)
        {
          if (BasicEMap.this.size > 0 && object instanceof Map.Entry)
          {

              for (int j = 0; j < size; ++j)
              {
                Entry entry = entries[j];
                if (entry.getHash() == hash && entry.equals(otherEntry))
                {
                  // BasicEMap.this.removeEntry(index, j);
                  remove(otherEntry);

          return false;
        }

        public void clear()
        {
          BasicEMap.this.clear();
        }

        public Iterator iterator()
        {
          return BasicEMap.this.size == 0 ? ECollections.EMPTY_ELIST.iterator() : new BasicEMap.BasicEMapIterator();
        }

  /**
   * A simple and obvious entry implementation.
   */
  protected class EntryImpl implements Entry
  {
    /**
     * The cached hash code of the key.

     * The value.
     */
    protected Object value;

    /**
     * Creates a fully initialized instance.
     * @param hash the hash code of the key.

     * Returns a new entry just like this one.
     * @return a new entry just like this one.
     */
    protected Object clone()
    {
      return newEntry(hash, key, value);
    }

    public int getHash()
    {
      return hash;
    }

    public void setHash(int hash)
    {
      this.hash = hash;
    }

    public Object getKey()
    {
      return key;
    }

    public void setKey(Object key)
    {
      throw new RuntimeException();
    }

    public Object getValue()
    {
      return value;
    }

      return oldValue;
    }

    public boolean equals(Object object)
    {
      if (object instanceof Map.Entry)
      {
        Map.Entry entry = (Map.Entry)object;

        return
          (BasicEMap.this.useEqualsForKey() && key != null ? key.equals(entry.getKey()) : key == entry.getKey())  &&
          (BasicEMap.this.useEqualsForValue() && value != null ? value.equals(entry.getValue()) : value == entry.getValue());
      }

      }
    }

    public int hashCode()
    {
      return hash ^ (value == null ? 0 : value.hashCode());
    }

    public String toString()
    {
      return key + "->" + value;
    }

  /**
   * An iterator over the map entry data.
   */
  protected class BasicEMapIterator implements Iterator
  {
    /**
     * The cursor in the entry data.

     * Returns whether there are more objects.
     * @return whether there are more objects.
     */
    public boolean hasNext()
    {
      return entryCursor != -1;
    }

     * @return the next object.
     * @exception NoSuchElementException if the iterator is done.
     */
    public Object next()
    {
      if (BasicEMap.this.modCount != expectedModCount)
      {

     * if <code>next</code> has not yet been called,
     * or <code>remove</code> has already been called after the last call to <code>next</code>.
     */
    public void remove()
    {
      if (modCount != expectedModCount)
      {

    BasicEList eList = entryData[index];
    if (eList != null)
    {
      //FIXME GWT CHANGE => Needed because BasicEList#toArray(Object[] array not working)
      Object [] entries = eList.data;
      int size = eList.size;
      if (useEqualsForKey() && key != null)
      {
        for (int j = 0; j < size; ++j)
        {
          Entry entry = (Entry) entries[j];
          if (entry.getHash() == hash && key.equals(entry.getKey()))
          {
            return entry;
          }
        }
      }
      else
      {
        for (int j = 0; j < size; ++j)
        {
          Entry entry = (Entry) entries[j];
          if (entry.getKey() == key)
          {
            return entry;
          }

   */
  protected int entryIndexForKey(int index, int hash, Object key)
  {
    if (useEqualsForKey() && key != null)
    {
      BasicEList eList = entryData[index];
      if (eList != null)

        for (int j = 0; j < size; ++j)
        {
          Entry entry = entries[j];
          if (entry.getHash() == hash && key.equals(entry.getKey()))
          {
            return j;
          }
        }
      }
    }
    else
    {
      BasicEList eList = entryData[index];
      if (eList != null)

        for (int j = 0; j < size; ++j)
        {
          Entry entry = entries[j];
          if (entry.getKey() == key)
          {
            return j;
          }

   * Grows the capacity of the map
   * to ensure that no additional growth is needed until the size exceeds the specified minimun capacity.
   */
  protected boolean grow(int minimumCapacity)
  {
    ++modCount;
    int oldCapacity = entryData == null ? 0 : entryData.length;

        BasicEList oldEList = oldEntryData[i];
        if (oldEList != null)
        {
          //FIXME GWT CHANGE => Needed because BasicEList#toArray(Object[] array not working)
          Object [] entries = oldEList.data;
          int size = oldEList.size;
          for (int j = 0; j < size; ++j)
          {
            Entry entry = (Entry) entries[j];
            int index = indexOf(entry.getHash());
            BasicEList eList = entryData[index];
            if (eList == null)

      return false;
    }
  }
//XXX GWT CHANGE Serialization not available
//  private void writeObject(ObjectOutputStream objectOutputStream) throws IOException
//  {
//    objectOutputStream.defaultWriteObject();
//
//    if (entryData == null)
//    {
//      objectOutputStream.writeInt(0);
//    }
//    else
//    {
//      // Write the capacity.
//      //
//      objectOutputStream.writeInt(entryData.length);
//
//      // Write all the entryData; there will be size of them.
//      //
//      for (int i = 0; i < entryData.length; ++i)
//      {
//        BasicEList eList = entryData[i];
//        if (eList != null)
//        {
//          Entry [] entries = (Entry [])eList.data;
//          int size = eList.size;
//          for (int j = 0; j < size; ++j)
//          {
//            Entry entry = entries[j];
//            objectOutputStream.writeObject(entry.getKey());
//            objectOutputStream.writeObject(entry.getValue());
//          }
//        }
//      }
//    }
//  }
//
//  private void readObject(ObjectInputStream objectInputStream) throws IOException, ClassNotFoundException
//  {
//    objectInputStream.defaultReadObject();
//
//    // Restore the capacity, if there was any.
//    //
//    int capacity = objectInputStream.readInt();
//    if (capacity > 0)
//    {
//      entryData = newEntryData(capacity);
//
//      // Read all size number of entryData.
//      //
//      for (int i = 0; i < size; ++i)
//      {
//        Object key = objectInputStream.readObject();
//        Object value = objectInputStream.readObject();
//        put(key, value);
//      }
//    }
//  }

  /**
   * Delegates to {@link #delegateEList}.




/**
 * <copyright> 
 *
 * Copyright (c) 2002-2004 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 - Initial API and implementation
 *
 * </copyright>
 *
 * $Id: CommonPlugin.java,v 1.11 2006/02/14 18:14:43 marcelop Exp $
 */
package org.eclipse.emf.common;

public class CommonPlugin {

	public static final CommonPlugin INSTANCE = new CommonPlugin();

	public static Class loadClass(String string, String string2) {
		throw new UnsupportedOperationException();
	}

	public String getString(String string, String[] strings) {
		return string;
	}

	public String getString(String string) {
		return string;
	}

	public void log(Throwable fillInStackTrace) {
		System.err.println(fillInStackTrace.toString());
	}

import org.eclipse.core.runtime.Platform;
import org.eclipse.emf.common.util.ResourceLocator;
import org.eclipse.emf.common.util.URI;


/**
 * The <b>Plugin</b> for the model EMF.Common library.
 * EMF must run 
 * within an Eclipse workbench,
 * within a headless Eclipse workspace,
 * or just stand-alone as part of some other application.
 * To support this, all resource access should be directed to the resource locator,
 * which can redirect the service as appopriate to the runtime.
 * During stand-alone invocation no plugin initialization takes place.
 * In this case, common.resources.jar must be on the CLASSPATH.
 * @see #INSTANCE
 */
public final class CommonPlugin extends EMFPlugin 
{
  /**
   * The singleton instance of the plugin.
   */
  public static final CommonPlugin INSTANCE = new CommonPlugin();

  /**
   * The one instance of this class.
   */
  private static Implementation plugin;

  /**
   * Creates the singleton instance.
   */
  private CommonPlugin()
  {
    super(new ResourceLocator[] {});
  }

  /*
   * Javadoc copied from base class.
   */
  public ResourceLocator getPluginResourceLocator()
  {
    return plugin;
  }

  /**
   * Returns the singleton instance of the Eclipse plugin.
   * @return the singleton instance.
   */
  public static Implementation getPlugin()
  {
    return plugin;
  }

  /**
   * Use the platform, if available, to convert to a local URI.
   */
  public static URI asLocalURI(URI uri)
  {
    return plugin == null ? uri : Implementation.asLocalURI(uri);
  }

  /**
   * Use the platform, if available, to resolve the URI.
   */
  public static URI resolve(URI uri)
  {
    return plugin == null ? uri : Implementation.resolve(uri);
  }

  /**
   * Use the platform, if available, to load the named class using the right class loader.
   */
  public static Class loadClass(String pluginID, String className) throws ClassNotFoundException
  {
    return plugin == null ? Class.forName(className) : Implementation.loadClass(pluginID, className);
  }

  /**
   * The actual implementation of the Eclipse <b>Plugin</b>.
   */
  public static class Implementation extends EclipsePlugin 
  {
    /**
     * Creates an instance.
     */
    public Implementation()
    {
      super();

      // Remember the static instance.
      //
      plugin = this;
    }

    /**
     * Use the platform to convert to a local URI.
     */
    protected static URI asLocalURI(URI uri)
    {
      try
      {
        String fragment = uri.fragment();
        URL url = Platform.asLocalURL(new URL(uri.trimFragment().toString()));
        return fix(url, fragment);
      }
      catch (IOException exception)
      {
      }
      return uri;
    }

    /**
     * Use the platform to convert to a local URI.
     */
    protected static URI resolve(URI uri)
    {
      String fragment = uri.fragment();
      URI uriWithoutFragment = uri.trimFragment();
      String uriWithoutFragmentToString = uriWithoutFragment.toString();
      
      URL url = null;
      try
      {
        url = Platform.resolve(new URL(uriWithoutFragmentToString));
      }
      catch (IOException exception1)
      {
        // Platform.resolve() doesn't work if the project is encoded.
        //
        try
        {
          uriWithoutFragmentToString = URI.decode(uriWithoutFragmentToString);
          url = Platform.resolve(new URL(uriWithoutFragmentToString));
        }
        catch (IOException exception2)
        {
        }
      }
      if (url != null)
      {
        try
        {
          return fix(url, fragment);
        }
        catch (IOException exception)
        {
        }
      }
      
      return uri;
    }

    protected static URI fix(URL url, String fragment) throws IOException
    {
      // Only file-scheme URIs will be re-encoded. If a URI was decoded in the workaround
      // above, and Platform.resolve() didn't return a file-scheme URI, then this will return
      // an decoded URI.
      //
      URI result = 
        "file".equalsIgnoreCase(url.getProtocol()) ?
          URI.createFileURI(URI.decode(url.getFile())) :
          URI.createURI(url.toString());
      if (fragment != null)
      {
        result = result.appendFragment(fragment);
      }
      return result;
    }
    
    /**
     * Use the platform to load the named class using the right class loader.
     */
    public static Class loadClass(String pluginID, String className) throws ClassNotFoundException
    {
      return Platform.getBundle(pluginID).loadClass(className);
    }
  }
}




/**
 * <copyright> 
 *
 * Copyright (c) 2002-2006 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 - Initial API and implementation
 *
 * </copyright>
 *
 * $Id: EMFPlugin.java,v 1.15 2006/09/13 18:58:14 emerks Exp $
 */
package org.eclipse.emf.common;

public class EMFPlugin {

	public static boolean IS_ECLIPSE_RUNNING = false;
import java.io.InputStream;
import java.net.MalformedURLException;
import java.net.URL;
import java.text.MessageFormat;
import java.util.HashMap;
import java.util.Map;
import java.util.MissingResourceException;
import java.util.PropertyResourceBundle;
import java.util.ResourceBundle;
import java.util.jar.Manifest;

import org.osgi.framework.Bundle;

import org.eclipse.core.runtime.ILog;
import org.eclipse.core.runtime.IStatus;
import org.eclipse.core.runtime.Platform;
import org.eclipse.core.runtime.Plugin;
import org.eclipse.core.runtime.Status;

import org.eclipse.emf.common.util.Logger;
import org.eclipse.emf.common.util.ResourceLocator;
import org.eclipse.emf.common.util.URI;
import org.eclipse.emf.common.util.WrappedException;


/**
 * EMF must run 
 * within an Eclipse workbench,
 * within a headless Eclipse workspace,
 * or just stand-alone as part of some other application.
 * To support this, all resource access (e.g., NL strings, images, and so on) is directed to the resource locator methods,
 * which can redirect the service as appopriate to the runtime.
 * During Eclipse invocation, the implementation delegates to a plugin implementation.
 * During stand-alone invocation, no plugin initialization takes place,
 * so the implementation delegates to a resource JAR on the CLASSPATH.
 * The resource jar will typically <b>not</b> be on the CLASSPATH during Eclipse invocation.
 * It will contain things like the icons and the .properties,  
 * which are available in a different way during Eclipse invocation.
 * @see ResourceLocator
 * @see Logger
 */
public abstract class EMFPlugin implements ResourceLocator, Logger
{
  public static final boolean IS_ECLIPSE_RUNNING;
  static
  {
    boolean result = false;
    try
    {
      result = Platform.isRunning();
    }
    catch (Throwable exception)
    {
    }
    IS_ECLIPSE_RUNNING = result;
  }

  protected ResourceLocator [] delegateResourceLocators;
  protected URL baseURL;
  protected ResourceBundle untranslatedResourceBundle;
  protected ResourceBundle resourceBundle;
  protected Map strings = new HashMap();
  protected Map untranslatedStrings = new HashMap();
  protected boolean shouldTranslate = true;
  protected Map images = new HashMap();

  public EMFPlugin(ResourceLocator [] delegateResourceLocators)
  {
    this.delegateResourceLocators = delegateResourceLocators;
  }

  /**
   * Returns an Eclipse plugin implementation of a resource locator.
   * @return an Eclipse plugin implementation of a resource locator.
   */
  public abstract ResourceLocator getPluginResourceLocator();

  /**
   * Returns an Eclipse plugin implementation of a logger.
   * @return an Eclipse plugin implementation of a logger.
   */
  public Logger getPluginLogger()
  {
    return (Logger)getPluginResourceLocator();
  }

  public String getSymbolicName()
  {
    ResourceLocator resourceLocator = getPluginResourceLocator();
    if (resourceLocator instanceof InternalEclipsePlugin)
    {
      return ((InternalEclipsePlugin)resourceLocator).getSymbolicName();
    }
    else
    {
      String result = getClass().getName();
      return result.substring(0, result.lastIndexOf('.'));
    }
  }

  private static final URI DOT = URI.createURI(".");
  /*
   * Javadoc copied from interface.
   */
  public URL getBaseURL()
  {
    if (baseURL == null)
    {
      if (getPluginResourceLocator() == null)
      {
        try
        {
          // Determine the base URL by looking for the plugin.properties file in the standard way.
          //
          Class theClass = getClass();
          URL pluginPropertiesURL = theClass.getResource("plugin.properties");
          if (pluginPropertiesURL == null)
          {
            // If that fails, determine the URL for the class itself.
            // The URL will be of one of the following forms,
            // so there are a few good places to consider looking for the plugin.properties.
            //
            // For a plugin.xml with runtime="common.jar":
            // jar:file:/D:/sandbox/unpackage1-3.1M7/eclipse/plugins/org.eclipse.emf.common/common.jar!/org/eclipse/common/CommonPlugin.class
            //
            // For a plugin.xml with runtime="runtime/common.jar":
            // jar:file:/D:/sandbox/unpackage1-3.1M7/eclipse/plugins/org.eclipse.emf.common/runtime/common.jar!/org/eclipse/common/CommonPlugin.class
            // 
            // For a plugin.xml with runtime="." where the plugin is jarred:
            // jar:file:/D:/sandbox/unpackage1-3.1M7/eclipse/plugins/org.eclipse.emf.common.jar!/org/eclipse/common/CommonPlugin.class
            //
            // For a plugin.xml with runtime="." where the plugin is not jarred.
            // file:/D:/sandbox/unpackage1-3.1M7/eclipse/plugins/org.eclipse.emf.common/org/eclipse/emf/common/CommonPlugin.class
            //
            // Running in PDE with bin on classpath:
            // file:/D:/sandbox/unpackage1-3.1M7/eclipse/plugins/org.eclipse.emf.common/bin/org/eclipse/emf/common/CommonPlugin.class
            //
            String className = theClass.getName();
            int index = className.lastIndexOf(".");
            URL classURL = theClass.getResource((index == -1 ? className : className.substring(index + 1)) + ".class");
            URI uri = URI.createURI(classURL.toString());
            
            // Trim off the segments corresponding to the package nesting.
            //
            int count = 1;
            for (int i = 0; (i = className.indexOf('.', i)) != -1; ++i)
            {
              ++count;
            }
            uri = uri.trimSegments(count);
            
            // For an archive URI, check for the plugin.properties in the archive.
            //
            if (URI.isArchiveScheme(uri.scheme()))
            {
              try
              {
                // If we can open  an input stream, then the plugin.properties is there, and we have a good base URL.
                //
                InputStream inputStream =  new URL(uri.appendSegment("plugin.properties").toString()).openStream();
                inputStream.close();
                baseURL = new URL(uri.toString());
              }
              catch (IOException exception)
              {
                // If the plugin.properties isn't within the root of the archive, 
                // create a new URI for the folder location of the archive, 
                // so we can look in the folder that contains it.
                //
                uri = URI.createURI(uri.authority()).trimSegments(1);
              }
            }
            
            // If we didn't find the plugin.properties in the usual place nor in the archive...
            //
            if (baseURL == null)
            {
              // Trim off the "bin" or "runtime" segment.
              //
              String lastSegment = uri.lastSegment();
              if ("bin".equals(lastSegment) || "runtime".equals(lastSegment))
              {
                uri = uri.trimSegments(1);
              }
              uri = uri.appendSegment("plugin.properties");
              try
              {
                // If we can open  an input stream, then the plugin.properties is in the folder, and we have a good base URL.
                //
                InputStream inputStream = new URL(uri.toString()).openStream();
                inputStream.close();
                baseURL = new URL(DOT.resolve(uri).toString());
              }
              catch (IOException exception)
              {
              }
            }
            
            // If we still don't have a good base URL, complain about it.
            //
            if (baseURL == null)
            {
              String resourceName = 
                index == -1 ? 
                  "plugin.properties" : 
                  className.substring(0, index + 1).replace('.','/') + "plugin.properties";
              throw new MissingResourceException("Missing properties: " + resourceName, theClass.getName(), "plugin.properties");
            }
          }
          else
          {
            baseURL = new URL(DOT.resolve(URI.createURI(pluginPropertiesURL.toString())).toString());
          }
        }
        catch (IOException exception)
        {
          throw new WrappedException(exception);
        }
      }
      else
      {
        baseURL = getPluginResourceLocator().getBaseURL();
      }
    }

    return baseURL;
  } 

  /*
   * Javadoc copied from interface.
   */
  public Object getImage(String key)
  {
    Object result = (URL)images.get(key);
    if (result == null)
    {
      if (getPluginResourceLocator() == null)
      {
        try
        {
          result = doGetImage(key);
        }
        catch (MalformedURLException exception)
        {
          throw new WrappedException(exception);
        }
        catch (IOException exception)
        {
          result = delegatedGetImage(key);
        }
      }
      else
      {
        try
        {
          result = getPluginResourceLocator().getImage(key);
        }
        catch (MissingResourceException exception)
        {
          result = delegatedGetImage(key);
        }
      }

      images.put(key, result);
    }

    return result;
  }

  /**
   * Does the work of fetching the image associated with the key.
   * It ensures that the image exists.
   * @param key the key of the image to fetch.
   * @exception IOException if an image doesn't exist.
   * @return the description of the image associated with the key.
   */
  protected Object doGetImage(String key) throws IOException
  {
    URL url = new URL(getBaseURL() + "icons/" + key + ".gif");
    InputStream inputStream = url.openStream(); 
    inputStream.close();
    return url;
  }

  /**
   * Does the work of fetching the image associated with the key,
   * when the image resource is not available locally.
   * @param key the key of the image to fetch.
   * @exception MissingResourceException if the image resource doesn't exist anywhere.
   * @see #delegateResourceLocators
   */
  protected Object delegatedGetImage(String key) throws MissingResourceException
  {
    for (int i = 0; i < delegateResourceLocators.length; ++i)
    {
      try
      {
        return delegateResourceLocators[i].getImage(key);
      }
      catch (MissingResourceException exception)
      {
      }
    }

    throw 
      new MissingResourceException
        (CommonPlugin.INSTANCE.getString("_UI_ImageResourceNotFound_exception", new Object [] { key }),
         getClass().getName(), 
         key);
  }

  /**
   * Indicates whether strings should be translated by default.
   * 
   * @return <code>true</code> if strings should be translated by default; <code>false</code> otherwise.
   */
  public boolean shouldTranslate()
  {
    return shouldTranslate;
  }

  /**
   * Sets whether strings should be translated by default.
   * 
   * @param shouldTranslate whether strings should be translated by default.
   */
  public void setShouldTranslate(boolean shouldTranslate)
  {
    this.shouldTranslate = shouldTranslate;
  }

  /*
   * Javadoc copied from interface.
   */
  public String getString(String key)
  {
    return getString(key, shouldTranslate());
  }

  /*
   * Javadoc copied from interface.
   */
  public String getString(String key, boolean translate)
  {
    Map stringMap = translate ? strings : untranslatedStrings;
    String result = (String)stringMap.get(key);
    if (result == null)
    {
      try
      {
        if (getPluginResourceLocator() == null)
        {
          ResourceBundle bundle = translate ? resourceBundle : untranslatedResourceBundle;
          if (bundle == null)
          {
            String packageName = getClass().getName();
            int index = packageName.lastIndexOf(".");
            if (index != -1)
            {
              packageName = packageName.substring(0, index);
            }
            if (translate)
            {
              try
              {
                bundle = resourceBundle = ResourceBundle.getBundle(packageName + ".plugin");
              }
              catch (MissingResourceException exception)
              {
                // If the bundle can't be found the normal way, try to find it as the base URL.
                // If that also doesn't work, rethrow the original exception.
                //
                try
                {
                  InputStream inputStream =  new URL(getBaseURL().toString() + "plugin.properties").openStream();
                  bundle = untranslatedResourceBundle = resourceBundle = new PropertyResourceBundle(inputStream);
                  inputStream.close();
                }
                catch (IOException ioException)
                {
                }
                if (resourceBundle == null)
                {
                  throw exception; 
                }
              }
            }
            else
            {
              String resourceName = getBaseURL().toString() + "plugin.properties";
              try
              {
                InputStream inputStream =  new URL(resourceName).openStream();
                bundle = untranslatedResourceBundle = new PropertyResourceBundle(inputStream);
                inputStream.close();
              }
              catch (IOException ioException)
              {
                throw new MissingResourceException("Missing properties: " + resourceName, getClass().getName(), "plugin.properties");
              }
            }
          }
          result = bundle.getString(key);
        }
        else
        {
          result = getPluginResourceLocator().getString(key, translate);
        }
      }
      catch (MissingResourceException exception)
      {
        result = delegatedGetString(key, translate);
      }
  
      stringMap.put(key, result);
    }

    return result;
  }

  /**
   * Does the work of fetching the string associated with the key,
   * when the string resource is not available locally.
   * @param key the key of the string to fetch.
   * @exception MissingResourceException if the string resource doesn't exist anywhere.
   * @see #delegateResourceLocators
   */
  protected String delegatedGetString(String key, boolean translate)
  {
    for (int i = 0; i < delegateResourceLocators.length; ++i)
    {
      try
      {
        return delegateResourceLocators[i].getString(key, translate);
      }
      catch (MissingResourceException exception)
      {
      }
    }

    throw 
      new MissingResourceException
        (MessageFormat.format("The string resource ''{0}'' could not be located", new Object [] { key }),
         getClass().getName(), 
         key);
  }

  /*
   * Javadoc copied from interface.
   */
  public String getString(String key, Object [] substitutions)
  {
    return getString(key, substitutions, shouldTranslate());
  }
  
  /*
   * Javadoc copied from interface.
   */
  public String getString(String key, Object [] substitutions, boolean translate)
  {
    return MessageFormat.format(getString(key, translate), substitutions);
  }

  /*
   * Javadoc copied from interface.
   */
  public void log(Object logEntry)
  {
    Logger logger = getPluginLogger();
    if (logger == null)
    {
      if (logEntry instanceof Throwable)
      {
        ((Throwable)logEntry).printStackTrace(System.err);
      }
      else
      {
        System.err.println(logEntry);
      }
    }
    else
    {
      logger.log(logEntry);
    }
  }

  /**
   * The actual implementation of an Eclipse <b>Plugin</b>.
   */
  public static abstract class EclipsePlugin extends Plugin implements ResourceLocator, Logger, InternalEclipsePlugin
  {
    /**
     * The EMF plug-in APIs are all delegated to this helper, so that code can be shared by plug-in
     * implementations with a different platform base class (e.g. AbstractUIPlugin).
     */
    protected InternalHelper helper;
    
    /**
     * Creates an instance.
     */
    public EclipsePlugin()
    {
      super();
      helper = new InternalHelper(this);
    }

    /**
     * Creates an instance.
     * @param descriptor the description of the plugin.
     * @deprecated
     */
    public EclipsePlugin(org.eclipse.core.runtime.IPluginDescriptor descriptor)
    {
      super(descriptor);
      helper = new InternalHelper(this);
    }

    /**
     * Return the plugin ID.
     */
    public String getSymbolicName()
    {
      return helper.getSymbolicName();
    }

    /*
     * Javadoc copied from interface.
     */
    public URL getBaseURL()
    {
      return helper.getBaseURL();
    }

    /*
     * Javadoc copied from interface.
     */
    public Object getImage(String key)
    {
      try
      {
        return doGetImage(key);
      }
      catch (MalformedURLException exception)
      {
        throw new WrappedException(exception);
      }
      catch (IOException exception)
      {
        throw 
          new MissingResourceException
            (CommonPlugin.INSTANCE.getString("_UI_StringResourceNotFound_exception", new Object [] { key }),
             getClass().getName(), 
             key);
      }
    }

    /**
     * Does the work of fetching the image associated with the key.
     * It ensures that the image exists.
     * @param key the key of the image to fetch.
     * @exception IOException if an image doesn't exist.
     * @return the description of the image associated with the key.
     */
    protected Object doGetImage(String key) throws IOException
    {
      return helper.getImage(key);
    }

    public String getString(String key)
    {
      return helper.getString(key, true);
    }
    
    public String getString(String key, boolean translate)
    {
      return helper.getString(key, translate);
    }

    public String getString(String key, Object [] substitutions)
    {
      return helper.getString(key, substitutions, true);
    }

    public String getString(String key, Object [] substitutions, boolean translate)
    {
      return helper.getString(key, substitutions, translate);
    }

    public void log(Object logEntry)
    {
      helper.log(logEntry);
    }
  }

  /**
   * This just provides a common interface for the Eclipse plugins supported by EMF.
   * It is not considered API and should not be used by clients.
   */
  public static interface InternalEclipsePlugin
  {
    String getSymbolicName();
  }
  
  /**
   * This just provides a common delegate for non-UI and UI plug-in classes.
   * It is not considered API and should not be used by clients.
   */
  public static class InternalHelper
  {
    protected Plugin plugin;
    protected ResourceBundle resourceBundle;
    protected ResourceBundle untranslatedResourceBundle;

    public InternalHelper(Plugin plugin)
    {
      this.plugin = plugin;
    }

    protected Bundle getBundle()
    {
      return plugin.getBundle();
    }

    protected ILog getLog()
    {
      return plugin.getLog();
    }
    
    /**
     * Return the plugin ID.
     */
    public String getSymbolicName()
    {
      return getBundle().getSymbolicName();
    }

    public URL getBaseURL()
    {
      return getBundle().getEntry("/");
    }

    /**
     * Fetches the image associated with the given key. It ensures that the image exists.
     * @param key the key of the image to fetch.
     * @exception IOException if an image doesn't exist.
     * @return the description of the image associated with the key.
     */
    public Object getImage(String key) throws IOException
    {
      URL url = new URL(getBaseURL() + "icons/" + key + ".gif");
      InputStream inputStream = url.openStream(); 
      inputStream.close();
      return url;
    }

    public String getString(String key, boolean translate)
    {
      ResourceBundle bundle = translate ? resourceBundle : untranslatedResourceBundle;
      if (bundle == null)
      {
        if (translate)
        {
           bundle = resourceBundle = Platform.getResourceBundle(getBundle());
        }
        else
        {
          String resourceName = getBaseURL().toString() + "plugin.properties";
          try
          {
            InputStream inputStream =  new URL(resourceName).openStream();
            bundle = untranslatedResourceBundle = new PropertyResourceBundle(inputStream);
            inputStream.close();
          }
          catch (IOException ioException)
          {
            throw new MissingResourceException("Missing properties: " + resourceName, getClass().getName(), "plugin.properties");
          }
        }
      }
      return bundle.getString(key);
    }

    public String getString(String key, Object [] substitutions, boolean translate)
    {
      return MessageFormat.format(getString(key, translate), substitutions);
    }

    public void log(Object logEntry)
    {
      IStatus status;
      if (logEntry instanceof IStatus)
      {
        status = (IStatus)logEntry;
        getLog().log(status);
      }
      else 
      {
        if (logEntry == null)
        {
          logEntry = new RuntimeException(getString("_UI_NullLogEntry_exception", true)).fillInStackTrace();
        }

        if (logEntry instanceof Throwable)
        {
          Throwable throwable = (Throwable)logEntry;

          // System.err.println("Logged throwable: --------------------");
          // throwable.printStackTrace();

          String message = throwable.getLocalizedMessage();
          if (message == null)
          {
            message = "";
          }

          getLog().log(new Status(IStatus.WARNING, getBundle().getSymbolicName(), 0, message, throwable));
        }
        else
        {
          // System.err.println("Logged throwable: --------------------");
          // throwable.printStackTrace();

          getLog().log (new Status (IStatus.WARNING, getBundle().getSymbolicName(), 0, logEntry.toString(), null));
        }
      }
    } 
  }

  public static void main(String[] args)
  {
    try
    {
      String [] relativePath = { "META-INF", "MANIFEST.MF" };
      Class theClass =  args.length > 0 ? Class.forName(args[0]) : EMFPlugin.class;

      String className = theClass.getName();
      int index = className.lastIndexOf(".");
      URL classURL = theClass.getResource((index == -1 ? className : className.substring(index + 1)) + ".class");
      URI uri = URI.createURI(classURL.toString());

      // Trim off the segments corresponding to the package nesting.
      //
      int count = 1;
      for (int i = 0; (i = className.indexOf('.', i)) != -1; ++i)
      {
        ++count;
      }
      uri = uri.trimSegments(count);

      URL manifestURL = null;
  
      // For an archive URI, check for the path in the archive.
      //
      if (URI.isArchiveScheme(uri.scheme()))
      {
        try
        {
          // If we can open  an input stream, then the path is there, and we have a good URL.
          //
          String manifestURI = uri.appendSegments(relativePath).toString();
          InputStream inputStream =  new URL(manifestURI).openStream();
          inputStream.close();
          manifestURL = new URL(manifestURI);
        }
        catch (IOException exception)
        {
          // If the path isn't within the root of the archive, 
          // create a new URI for the folder location of the archive, 
          // so we can look in the folder that contains it.
          //
          uri = URI.createURI(uri.authority()).trimSegments(1);
        }
      }
              
      // If we didn't find the path in the usual place nor in the archive...
      //
      if (manifestURL == null)
      {
        // Trim off the "bin" or "runtime" segment.
        //
        String lastSegment = uri.lastSegment();
        if ("bin".equals(lastSegment) || "runtime".equals(lastSegment))
        {
          uri = uri.trimSegments(1);
        }
        uri = uri.appendSegments(relativePath);
        manifestURL = new URL(uri.toString());
      }
              
      if (manifestURL != null)
      {
        Manifest manifest = new Manifest(manifestURL.openStream());
        String symbolicName =  manifest.getMainAttributes().getValue("Bundle-SymbolicName");
        if (symbolicName != null)
        {
          int end = symbolicName.indexOf(";");
          if (end != -1)
          {
            symbolicName = symbolicName.substring(0, end);
          }
          System.out.println("Bundle-SymbolicName=" + symbolicName + " Bundle-Version=" + manifest.getMainAttributes().getValue("Bundle-Version"));
          return;
        }
      }
    }
    catch (Exception exception)
    {
    }
    
    System.err.println("No Bundle information found");
  }
}

Lines 8-14 Link Here

(-)META-INF/MANIFEST.MF (-1 lines)
8	Bundle-Vendor: %providerName	8	Bundle-Vendor: %providerName
9	Bundle-Localization: plugin	9	Bundle-Localization: plugin
10	Export-Package: org.eclipse.emf.common,	10	Export-Package: org.eclipse.emf.common,
11	org.eclipse.emf.common.archive,
12	org.eclipse.emf.common.command,	11	org.eclipse.emf.common.command,
13	org.eclipse.emf.common.notify,	12	org.eclipse.emf.common.notify,
14	org.eclipse.emf.common.notify.impl,	13	org.eclipse.emf.common.notify.impl,

Added Link Here

(-)src/org/eclipse/emf/common/EMFCommonLib.gwt.xml (+7 lines)
1	<module>
2	<!-- Inherit the core Web Toolkit stuff. -->
3	<inherits name='com.google.gwt.user.User'/>
4	<inherits name='org.eclipse.core.RuntimeCoreLib' />
5
6	<source path="common" />
7	</module>

Return to bug 209434

Removed Link Here

(-)src/org/eclipse/emf/common/archive/Handler.java (-128 lines)
1	/**
2	* <copyright>
3	*
4	* Copyright (c) 2004-2005 IBM Corporation and others.
5	* All rights reserved. This program and the accompanying materials
6	* are made available under the terms of the Eclipse Public License v1.0
7	* which accompanies this distribution, and is available at
8	* http://www.eclipse.org/legal/epl-v10.html
9	*
10	* Contributors:
11	* IBM - Initial API and implementation
12	*
13	* </copyright>
14	*
15	* $Id$
16	*/
17	package org.eclipse.emf.common.archive;
18
19	import java.io.IOException;
20	import java.io.InputStream;
21	import java.net.URL;
22	import java.net.URLConnection;
23	import java.net.URLStreamHandler;
24
25	/**
26	* A URL stream handler that can be {@link #register() registered} to support archive access protocol.
27	* It uses {@link ArchiveURLConnection} to implement the connection.
28	*/
29	public class Handler extends URLStreamHandler
30	{
31	/**
32	* Registers this class.
33	* A handler for protocol "xyz" is registered
34	* by providing a class named Handler implementing {@link URLStreamHandler}
35	* in a package called named xyz in a package of your choosing,
36	* and then registering that chosen prefix package name
37	* in the system property for <code>"java.protocol.handler.pkgs"</code>,
38	* which is an "\|" separated list of package prefixes to search for handlers.
39	*/
40	public static void register()
41	{
42	String javaProtocolHandlerPkgs = System.getProperty("java.protocol.handler.pkgs");
43	if (javaProtocolHandlerPkgs == null \|\| javaProtocolHandlerPkgs.length() == 0)
44	{
45	javaProtocolHandlerPkgs = "org.eclipse.emf.common";
46	}
47	else
48	{
49	javaProtocolHandlerPkgs += "\|org.eclipse.emf.common";
50	}
51	System.setProperty("java.protocol.handler.pkgs", javaProtocolHandlerPkgs);
52	}
53
54	/**
55	* Registers this handler and interprets each argument as URL to be opened, read in, and written out to System.out.
56	* @param args URLs to open, read, and write to System.out
57	* @throws IOException if there are problems opening or reading from the URLs, or writing to System.out.
58	*/
59	public static void main(String[] args) throws IOException
60	{
61	register();
62
63	for (int i = 0; i < args.length; ++i)
64	{
65	InputStream inputStream = new URL(args[i]).openStream();
66	byte [] bytes = new byte [4048];
67	for (int size; (size = inputStream.read(bytes, 0, bytes.length)) > -1; )
68	{
69	System.out.write(bytes, 0, size);
70	}
71	}
72	}
73
74	/**
75	* Creates an instance.
76	*/
77	public Handler()
78	{
79	super();
80	}
81
82	/**
83	* Overrides parsing the URL to validate constraints on well formed archive syntax.
84	* @see URLStreamHandler#parseURL(java.net.URL, java.lang.String, int, int)
85	*/
86	protected void parseURL(URL url, String specification, int start, int limit)
87	{
88	super.parseURL(url, specification, start, limit);
89
90	// There needs to be another URL protocol right after the archive protocol, and not a "/".
91	//
92	if (start > limit \|\| specification.charAt(start) == '/')
93	{
94	throw
95	new IllegalArgumentException
96	("archive protocol must be immediately followed by another URL protocol " + specification);
97	}
98
99	// There must be at least one archive path.
100	//
101	int archiveSeparator = specification.indexOf("!/", start);
102	if (archiveSeparator < 0)
103	{
104	throw new IllegalArgumentException("missing archive separators " + specification.substring(start, limit));
105	}
106
107	// Parse to count the archive paths that must will be delegated to the nested URL based on the number of schemes at the start.
108	//
109	for (int i = start, end = specification.indexOf('/', start) - 1; (i = specification.indexOf(':', i)) < end; ++i)
110	{
111	// There should be at least one archive separator per scheme.
112	//
113	archiveSeparator = specification.indexOf("!/", archiveSeparator + 2);
114	if (archiveSeparator < 0)
115	{
116	throw new IllegalArgumentException("too few archive separators " + specification);
117	}
118	}
119	}
120
121	/**
122	* Returns a new {@link ArchiveURLConnection}.
123	*/
124	protected URLConnection openConnection(URL url) throws IOException
125	{
126	return new ArchiveURLConnection(url);
127	}
128	}

Removed Link Here

(-)src/org/eclipse/emf/common/archive/package.html (-23 lines)
1	<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
2	"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
3	<html xmlns="http://www.w3.org/1999/xhtml">
4	<head>
5	<meta name="generator" content="HTML Tidy, see www.w3.org" />
6	<meta http-equiv="Content-Type"
7	content="text/html; charset=ISO-8859-1" /><!--
8	/**
9	* <copyright>
10	*
11	* Copyright (c) 2005 IBM Corporation and others.
12	* All rights reserved. This program and the accompanying materials
13	* are made available under the terms of the Eclipse Public License v1.0
14	* which accompanies this distribution, and is available at
15	* http://www.eclipse.org/legal/epl-v10.html
16	*
17	* Contributors:
18	* IBM - Initial API and implementation
19	*
20	* </copyright>
21	*
22	* $Id$
23	*/

Removed Link Here

(-)src/org/eclipse/emf/common/archive/ArchiveURLConnection.java (-553 lines)
1	/**
2	* <copyright>
3	*
4	* Copyright (c) 2004-2005 IBM Corporation and others.
5	* All rights reserved. This program and the accompanying materials
6	* are made available under the terms of the Eclipse Public License v1.0
7	* which accompanies this distribution, and is available at
8	* http://www.eclipse.org/legal/epl-v10.html
9	*
10	* Contributors:
11	* IBM - Initial API and implementation
12	*
13	* </copyright>
14	*
15	* $Id$
16	*/
17	package org.eclipse.emf.common.archive;
18
19	import java.io.File;
20	import java.io.FileInputStream;
21	import java.io.FileOutputStream;
22	import java.io.FilterInputStream;
23	import java.io.FilterOutputStream;
24	import java.io.IOException;
25	import java.io.InputStream;
26	import java.io.OutputStream;
27	import java.net.MalformedURLException;
28	import java.net.URL;
29	import java.net.URLConnection;
30	import java.util.zip.ZipEntry;
31	import java.util.zip.ZipFile;
32	import java.util.zip.ZipInputStream;
33	import java.util.zip.ZipOutputStream;
34
35	/**
36	* A connection that can access an entry in an archive, and then recursively an entry in that archive, and so on.
37	* For example, it can be used just like jar: or zip:, only the archive paths can repeat, e.g.,
38	*<pre>
39	* archive:file:///c:/temp/example.zip!/org/example/nested.zip!/org/example/deeply-nested.html
40	*</pre>
41	* The general recursive pattern is
42	*<pre>
43	* archive:$nestedURL${/!$archivePath$}+
44	*</pre>
45	* So the nested URL for the example above is
46	*<pre>
47	* file:///c:/temp/example.zip
48	*</pre>
49	*
50	* <p>
51	* Since the nested URL may itself contain archive schemes,
52	* the subsequence of the archive paths that should be associated with the nested URL
53	* is determined by finding the nth archive separator, i.e., the nth !/,
54	* where n is the number of ":"s before the first "/" of the nested URL, i.e., the number of nested schemes.
55	* For example, for a more complex case where the nested URL is itself an archive-based scheme, e.g.,
56	*<pre>
57	* archive:jar:file:///c:/temp/example.zip!/org/example/nested.zip!/org/example/deeply-nested.html
58	*</pre>
59	* the nested URL is correctly parsed to skip to the second archive separator as
60	*<pre>
61	* jar:file:///c:/temp/example.zip!/org/example/nested.zip
62	*</pre>
63	* </p>
64	*
65	* <p>
66	* The logic for accessing archives can be tailored and reused independant from its usage as a URL connection.
67	* This is normally done by using the constructor {@link #ArchiveURLConnection(String)}
68	* and overriding {@link #createInputStream(String)} and {@link #createOutputStream(String)}.
69	* The behavior can be tailored by overriding {@link #emulateArchiveScheme()} and {@link #useZipFile()}.
70	* </p>
71	*/
72	public class ArchiveURLConnection extends URLConnection
73	{
74	/**
75	* The cached string version of the {@link #url URL}.
76	*/
77	protected String urlString;
78
79	/**
80	* Constructs a new connection for the URL.
81	* @param url the URL of this connection.
82	*/
83	public ArchiveURLConnection(URL url)
84	{
85	super(url);
86	urlString = url.toString();
87	}
88
89	/**
90	* Constructs a new archive accessor.
91	* This constructor forwards a null URL to be super constructor,
92	* so an instance built with this constructor <b>cannot</b> be used as a URLConnection.
93	* The logic for accessing archives and for delegating to the nested URL can be reused in other applications,
94	* without creating an URLs.
95	* @param url the URL of the archive.
96	*/
97	protected ArchiveURLConnection(String url)
98	{
99	super(null);
100	urlString = url;
101	}
102
103	/**
104	* </p>
105	* Returns whether the implementation will handle all the archive accessors directly.
106	* For example, whether
107	*<pre>
108	* archive:jar:file:///c:/temp/example.zip!/org/example/nested.zip!/org/example/deeply-nested.html
109	*</pre>
110	* will be handled as if it were specified as
111	*<pre>
112	* archive:file:///c:/temp/example.zip!/org/example/nested.zip!/org/example/deeply-nested.html
113	*</pre>
114	* Override this only if you are reusing the logic of retrieving an input stream into an archive
115	* and hence are likely to be overriding createInputStream,
116	* which is the point of delegation to the nested URL for recursive stream creation.
117	* </p>
118	* @return whether the implementation will handle all the archive accessors directly.
119	*/
120	protected boolean emulateArchiveScheme()
121	{
122	return false;
123	}
124
125	/**
126	* Returns whether to handle the special case of a nested URL with file: schema using a {@link ZipFile}.
127	* This gives more efficient direct access to the root entry, e.g.,
128	*<pre>
129	* archive:file:///c:/temp/example.zip!/org/example/nested.html
130	*</pre>
131	* @return whether to handle the special case of a nested URL with file: schema using a ZipFile.
132	*/
133	protected boolean useZipFile()
134	{
135	return false;
136	}
137
138	/**
139	* Record that this is connected.
140	*/
141	public void connect() throws IOException
142	{
143	connected = true;
144	}
145
146	/**
147	* Creates the input stream for the URL.
148	* @return the input stream for the URL.
149	*/
150	public InputStream getInputStream() throws IOException
151	{
152	// There must be at least one archive path.
153	//
154	int archiveSeparator = urlString.indexOf("!/");
155	if (archiveSeparator < 0)
156	{
157	throw new MalformedURLException("missing archive separators " + urlString);
158	}
159
160	// There needs to be another URL protocol right after the archive protocol, and not a "/".
161	//
162	int start = urlString.indexOf(':') + 1;
163	if (start > urlString.length() \|\| urlString.charAt(start) == '/')
164	{
165	throw
166	new IllegalArgumentException
167	("archive protocol must be immediately followed by another URL protocol " + urlString);
168	}
169
170	// Parse to extract the archives that will be delegated to the nested URL based on the number of schemes at the start.
171	//
172	for (int i = start, end = urlString.indexOf("/") - 1; (i = urlString.indexOf(":", i)) < end; )
173	{
174	if (emulateArchiveScheme())
175	{
176	// Skip a scheme for the achive accessor to be handled directly here.
177	//
178	start = ++i;
179	}
180	else
181	{
182	// Skip an archive accessor to be handled by delegation to the scheme in nested URL.
183	//
184	archiveSeparator = urlString.indexOf("!/", archiveSeparator + 2);
185	if (archiveSeparator < 0)
186	{
187	throw new MalformedURLException("too few archive separators " + urlString);
188	}
189	++i;
190	}
191	}
192
193	// System.out.println("archive: " + urlString.substring(start, archiveSeparator) + " -> " + urlString.substring(archiveSeparator + 2));
194
195	// Create the delegate URL.
196	//
197	String nestedURL = urlString.substring(start, archiveSeparator);
198
199	// The cutoff point to the next archive.
200	//
201	int nextArchiveSeparator = urlString.indexOf("!/", archiveSeparator + 2);
202
203	// Construct the input stream in a special efficient way for case of a file scheme.
204	//
205	InputStream inputStream;
206	if (!useZipFile() \|\| !nestedURL.startsWith("file:"))
207	{
208	// Just get the stream from the URL.
209	//
210	inputStream = createInputStream(nestedURL);
211	}
212	else
213	{
214	// The name to be used for the entry.
215	//
216	String entry =
217	nextArchiveSeparator < 0 ?
218	urlString.substring(archiveSeparator + 2) :
219	urlString.substring(archiveSeparator + 2, nextArchiveSeparator);
220
221	// Skip over this archive path to the next one, since we are handling this one special.
222	//
223	archiveSeparator = nextArchiveSeparator;
224	nextArchiveSeparator = urlString.indexOf("!/", archiveSeparator + 2);
225
226	// Go directly to the right entry in the zip file,
227	// get the stream,
228	// and wrap it so that closing it closes the zip file.
229	//
230	final ZipFile zipFile = new ZipFile(nestedURL.substring(5));
231	ZipEntry zipEntry = zipFile.getEntry(entry);
232	if (zipEntry == null)
233	{
234	throw new IOException("archive entry not found " + entry);
235	}
236	inputStream =
237	new FilterInputStream(zipFile.getInputStream(zipEntry))
238	{
239	public void close() throws IOException
240	{
241	super.close();
242	zipFile.close();
243	}
244	};
245	}
246
247	// Loop over the archive paths.
248	//
249	LOOP:
250	while (archiveSeparator > 0)
251	{
252	// The entry name to be matched.
253	//
254	String entry =
255	nextArchiveSeparator < 0 ?
256	urlString.substring(archiveSeparator + 2) :
257	urlString.substring(archiveSeparator + 2, nextArchiveSeparator);
258
259	// Wrap the input stream as a zip stream to scan it's contents for a match.
260	//
261	ZipInputStream zipInputStream = new ZipInputStream(inputStream);
262	while (zipInputStream.available() >= 0)
263	{
264	ZipEntry zipEntry = zipInputStream.getNextEntry();
265	if (zipEntry == null)
266	{
267	break;
268	}
269	else if (entry.equals(zipEntry.getName()))
270	{
271	inputStream = zipInputStream;
272
273	// Skip to the next archive path and continue the loop.
274	//
275	archiveSeparator = nextArchiveSeparator;
276	nextArchiveSeparator = urlString.indexOf("!/", archiveSeparator + 2);
277	continue LOOP;
278	}
279	}
280
281	// Unless we matched an entry, we're done.
282	//
283	break;
284	}
285
286	return inputStream;
287	}
288
289	/**
290	* Creates an input stream for the nested URL by calling {@link URL#openStream()opening} a stream on it.
291	* @param nestedURL the nested URL for which a stream is required.
292	* @return the open stream of the nested URL.
293	*/
294	protected InputStream createInputStream(String nestedURL) throws IOException
295	{
296	return new URL(nestedURL).openStream();
297	}
298
299	/**
300	* Creates the output stream for the URL.
301	* @return the output stream for the URL.
302	*/
303	public OutputStream getOutputStream() throws IOException
304	{
305	// There must be at least one archive separator.
306	//
307	int archiveSeparator = urlString.indexOf("!/");
308	if (archiveSeparator < 0)
309	{
310	throw new MalformedURLException("missing archive separator in " + urlString);
311	}
312
313	// There needs to be another URL protocol right after the archive protocol, and not a "/".
314	//
315	int start = urlString.indexOf(':') + 1;
316	if (start > urlString.length() \|\| urlString.charAt(start) == '/')
317	{
318	throw
319	new IllegalArgumentException
320	("archive protocol must be immediately followed by another URL protocol " + urlString);
321	}
322
323	// Parse the URI to extract the nested/delegate URI based on preference and the number of schemes at the start.
324	//
325	for (int i = start, end = urlString.indexOf("/") - 1; (i = urlString.indexOf(":", i)) < end; )
326	{
327	if (emulateArchiveScheme())
328	{
329	// Skip a scheme for the achive accessor to be handled directly here.
330	//
331	start = ++i;
332	}
333	else
334	{
335	// Skip an archive accessor to be handled by delegation to the scheme in nested URI.
336	//
337	archiveSeparator = urlString.indexOf("!/", archiveSeparator + 2);
338	if (archiveSeparator < 0)
339	{
340	throw new MalformedURLException("too few archive separators in " + urlString);
341	}
342	++i;
343	}
344	}
345
346	// System.out.println("archive: -> " + urlString.substring(start, archiveSeparator) + " -> " + urlString.substring(archiveSeparator + 2));
347
348	// Create the delegate URL
349	//
350	final String nestedURL = urlString.substring(start, archiveSeparator);
351
352	// Create a temporary file where the existing contents of the archive can be written
353	// before the new contents are added.
354	//
355	final File tempFile = File.createTempFile("Archive", "zip");
356
357	// Record the input and output streams for closing in case of failure so that handles are not left open.
358	//
359	InputStream sourceInputStream = null;
360	OutputStream tempOutputStream = null;
361	try
362	{
363	// Create the output stream to the temporary file and the input stream for the delegate URL.
364	//
365	tempOutputStream = new FileOutputStream(tempFile);
366	try
367	{
368	sourceInputStream = createInputStream(nestedURL);
369	}
370	catch (IOException exception)
371	{
372	// Continue processing if the file doesn't exist so that we try create a new empty one.
373	}
374
375	// Record them as generic streams to record state during the loop that emulates recursion.
376	//
377	OutputStream outputStream = tempOutputStream;
378	InputStream inputStream = sourceInputStream;
379
380	// The cutoff point to the next archive.
381	//
382	int nextArchiveSeparator = urlString.indexOf("!/", archiveSeparator + 2);
383
384	// The most deeply nested output stream that will be returned wrapped as the result.
385	//
386	ZipOutputStream zipOutputStream;
387
388	// A buffer for transferring archive contents.
389	//
390	final byte [] bytes = new byte [4096];
391
392	// We expect there to be at least one archive path.
393	//
394	do
395	{
396	// The name that will be used as the archive entry.
397	//
398	String entry =
399	nextArchiveSeparator < 0 ?
400	urlString.substring(archiveSeparator + 2) :
401	urlString.substring(archiveSeparator + 2, nextArchiveSeparator);
402
403	// Wrap the current result as a zip stream, and record it for loop-based recursion.
404	//
405	zipOutputStream = new ZipOutputStream(outputStream);
406	outputStream = zipOutputStream;
407
408	// Wrap the current input as a zip stream, and record it for loop-based recursion.
409	//
410	ZipInputStream zipInputStream = inputStream == null ? null : new ZipInputStream(inputStream);
411	inputStream = zipInputStream;
412
413	// Loop over the entries in the zip stream.
414	//
415	while (zipInputStream != null && zipInputStream.available() >= 0)
416	{
417	// If this entry isn't the end marker
418	// and isn't the matching one that we are replacing...
419	//
420	ZipEntry zipEntry = zipInputStream.getNextEntry();
421	if (zipEntry == null)
422	{
423	break;
424	}
425	else if (!entry.equals(zipEntry.getName()))
426	{
427	// Transfer the entry and its contents.
428	//
429	zipOutputStream.putNextEntry(zipEntry);
430	for (int size; (size = zipInputStream.read(bytes, 0, bytes.length)) > -1; )
431	{
432	zipOutputStream.write(bytes, 0, size);
433	}
434	}
435	}
436
437	// Create a new or replaced entry.
438	//
439	zipOutputStream.putNextEntry(new ZipEntry(entry));
440
441	// Find the next archive path and continue "recursively" if there is one.
442	//
443	archiveSeparator = nextArchiveSeparator;
444	nextArchiveSeparator = urlString.indexOf("!/", archiveSeparator + 2);
445	}
446	while (archiveSeparator > 0);
447
448	// Ensure that it won't be closed in the finally block.
449	//
450	tempOutputStream = null;
451
452	// Wrap the deepest result so that on close, the results are finally transferred.
453	//
454	final boolean deleteRequired = sourceInputStream != null;
455	return
456	new FilterOutputStream(zipOutputStream)
457	{
458	protected boolean isClosed;
459
460	public void close() throws IOException
461	{
462	// Make sure we close only once.
463	//
464	if (!isClosed)
465	{
466	isClosed = true;
467
468	// Close for real so that the temporary file is ready to be read.
469	//
470	super.close();
471
472	boolean useRenameTo = nestedURL.startsWith("file:");
473
474	// If the delegate URI can be handled as a file,
475	// we'll hope that renaming it will be really efficient.
476	//
477	if (useRenameTo)
478	{
479	File targetFile = new File(nestedURL.substring(5));
480	if (deleteRequired && !targetFile.delete())
481	{
482	throw new IOException("cannot delete " + targetFile.getPath());
483	}
484	else if (!tempFile.renameTo(targetFile))
485	{
486	useRenameTo = false;
487	}
488	}
489	if (!useRenameTo)
490	{
491	// Try to transfer it by reading the contents of the temporary file
492	// and writing them to the output stream of the delegate.
493	//
494	InputStream inputStream = null;
495	OutputStream outputStream = null;
496	try
497	{
498	inputStream = new FileInputStream(tempFile);
499	outputStream = createOutputStream(nestedURL);
500	for (int size; (size = inputStream.read(bytes, 0, bytes.length)) > -1; )
501	{
502	outputStream.write(bytes, 0, size);
503	}
504	}
505	finally
506	{
507	// Make sure they are closed no matter what bad thing happens.
508	//
509	if (inputStream != null)
510	{
511	inputStream.close();
512	}
513	if (outputStream != null)
514	{
515	outputStream.close();
516	}
517	}
518	}
519	}
520	}
521	};
522	}
523	finally
524	{
525	// Close in case of failure to complete.
526	//
527	if (tempOutputStream != null)
528	{
529	tempOutputStream.close();
530	}
531
532	// Close if we created this.
533	//
534	if (sourceInputStream != null)
535	{
536	sourceInputStream.close();
537	}
538	}
539	}
540
541	/**
542	* Creates an input stream for the nested URL by calling {@link URL#openStream()opening} a stream on it.
543	* @param nestedURL the nested URL for which a stream is required.
544	* @return the open stream of the nested URL.
545	*/
546	protected OutputStream createOutputStream(String nestedURL) throws IOException
547	{
548	URL url = new URL(nestedURL.toString());
549	URLConnection urlConnection = url.openConnection();
550	urlConnection.setDoOutput(true);
551	return urlConnection.getOutputStream();
552	}
553	}

Lines 1-79 Link Here

(-)src/org/eclipse/emf/common/util/ResourceLocator.java (-74 / +2 lines)
1	/**
2	* <copyright>
3	*
4	* Copyright (c) 2002-2004 IBM Corporation and others.
5	* All rights reserved. This program and the accompanying materials
6	* are made available under the terms of the Eclipse Public License v1.0
7	* which accompanies this distribution, and is available at
8	* http://www.eclipse.org/legal/epl-v10.html
9	*
10	* Contributors:
11	* IBM - Initial API and implementation
12	*
13	* </copyright>
14	*
15	* $Id: ResourceLocator.java,v 1.3 2005/06/08 06:19:08 nickb Exp $
16	*/
17	package org.eclipse.emf.common.util;	1	package org.eclipse.emf.common.util;
18		2
		3	public interface ResourceLocator {
19		4
20	import java.net.URL;	5	String getString(String string, Object[] objects);
21		6
22
23	/**
24	* A locator of Java resources.
25	*/
26	public interface ResourceLocator
27	{
28	/**
29	* Returns the URL from which all resources are based.
30	* @return the URL from which all resources are based.
31	*/
32	URL getBaseURL();
33
34	/**
35	* Returns the description that can be used to create the image resource associated with the key.
36	* The description will typically be in the form of a URL to the image data.
37	* Creation of an actual image depends on the GUI environment;
38	* within Eclipse, org.eclipse.emf.edit.ui.provider.ExtendedImageRegistry can be used.
39	* @param key the key of the image resource.
40	* @return the description on the image resource.
41	*/
42	Object getImage(String key);
43
44	/**
45	* Returns the string resource associated with the key.
46	* @param key the key of the string resource.
47	* @return the string resource associated with the key.
48	*/
49	String getString(String key);
50
51	/**
52	* Returns the string resource associated with the key.
53	* @param key the key of the string resource.
54	* @param translate whether the result is to be translated to the current locale.
55	* @return the string resource associated with the key.
56	*/
57	String getString(String key, boolean translate);
58
59	/**
60	* Returns a string resource associated with the key, and peforms substitutions.
61	* @param key the key of the string.
62	* @param substitutions the message substitutions.
63	* @return a string resource associated with the key.
64	* @see #getString(String)
65	* @see java.text.MessageFormat#format(String, Object[])
66	*/
67	String getString(String key, Object [] substitutions);
68
69	/**
70	* Returns a string resource associated with the key, and peforms substitutions.
71	* @param key the key of the string.
72	* @param substitutions the message substitutions.
73	* @param translate whether the result is to be translated to the current locale.
74	* @return a string resource associated with the key.
75	* @see #getString(String)
76	* @see java.text.MessageFormat#format(String, Object[])
77	*/
78	String getString(String key, Object [] substitutions, boolean translate);
79	}	7	}

Lines 1-201 Link Here

(-)src/org/eclipse/emf/common/CommonPlugin.java (-196 / +18 lines)
1	/**
2	* <copyright>
3	*
4	* Copyright (c) 2002-2004 IBM Corporation and others.
5	* All rights reserved. This program and the accompanying materials
6	* are made available under the terms of the Eclipse Public License v1.0
7	* which accompanies this distribution, and is available at
8	* http://www.eclipse.org/legal/epl-v10.html
9	*
10	* Contributors:
11	* IBM - Initial API and implementation
12	*
13	* </copyright>
14	*
15	* $Id: CommonPlugin.java,v 1.11 2006/02/14 18:14:43 marcelop Exp $
16	*/
17	package org.eclipse.emf.common;	1	package org.eclipse.emf.common;
18		2
		3	public class CommonPlugin {
19		4
20	import java.io.IOException;	5	public static final CommonPlugin INSTANCE = new CommonPlugin();
21	import java.net.URL;	6
		7	public static Class loadClass(String string, String string2) {
		8	throw new UnsupportedOperationException();
		9	}
		10
		11	public String getString(String string, String[] strings) {
		12	return string;
		13	}
		14
		15	public String getString(String string) {
		16	return string;
		17	}
		18
		19	public void log(Throwable fillInStackTrace) {
		20	System.err.println(fillInStackTrace.toString());
		21	}
22		22
23	import org.eclipse.core.runtime.Platform;
24	import org.eclipse.emf.common.util.ResourceLocator;
25	import org.eclipse.emf.common.util.URI;
26
27
28	/**
29	* The <b>Plugin</b> for the model EMF.Common library.
30	* EMF must run
31	* within an Eclipse workbench,
32	* within a headless Eclipse workspace,
33	* or just stand-alone as part of some other application.
34	* To support this, all resource access should be directed to the resource locator,
35	* which can redirect the service as appopriate to the runtime.
36	* During stand-alone invocation no plugin initialization takes place.
37	* In this case, common.resources.jar must be on the CLASSPATH.
38	* @see #INSTANCE
39	*/
40	public final class CommonPlugin extends EMFPlugin
41	{
42	/**
43	* The singleton instance of the plugin.
44	*/
45	public static final CommonPlugin INSTANCE = new CommonPlugin();
46
47	/**
48	* The one instance of this class.
49	*/
50	private static Implementation plugin;
51
52	/**
53	* Creates the singleton instance.
54	*/
55	private CommonPlugin()
56	{
57	super(new ResourceLocator[] {});
58	}
59
60	/*
61	* Javadoc copied from base class.
62	*/
63	public ResourceLocator getPluginResourceLocator()
64	{
65	return plugin;
66	}
67
68	/**
69	* Returns the singleton instance of the Eclipse plugin.
70	* @return the singleton instance.
71	*/
72	public static Implementation getPlugin()
73	{
74	return plugin;
75	}
76
77	/**
78	* Use the platform, if available, to convert to a local URI.
79	*/
80	public static URI asLocalURI(URI uri)
81	{
82	return plugin == null ? uri : Implementation.asLocalURI(uri);
83	}
84
85	/**
86	* Use the platform, if available, to resolve the URI.
87	*/
88	public static URI resolve(URI uri)
89	{
90	return plugin == null ? uri : Implementation.resolve(uri);
91	}
92
93	/**
94	* Use the platform, if available, to load the named class using the right class loader.
95	*/
96	public static Class loadClass(String pluginID, String className) throws ClassNotFoundException
97	{
98	return plugin == null ? Class.forName(className) : Implementation.loadClass(pluginID, className);
99	}
100
101	/**
102	* The actual implementation of the Eclipse <b>Plugin</b>.
103	*/
104	public static class Implementation extends EclipsePlugin
105	{
106	/**
107	* Creates an instance.
108	*/
109	public Implementation()
110	{
111	super();
112
113	// Remember the static instance.
114	//
115	plugin = this;
116	}
117
118	/**
119	* Use the platform to convert to a local URI.
120	*/
121	protected static URI asLocalURI(URI uri)
122	{
123	try
124	{
125	String fragment = uri.fragment();
126	URL url = Platform.asLocalURL(new URL(uri.trimFragment().toString()));
127	return fix(url, fragment);
128	}
129	catch (IOException exception)
130	{
131	}
132	return uri;
133	}
134
135	/**
136	* Use the platform to convert to a local URI.
137	*/
138	protected static URI resolve(URI uri)
139	{
140	String fragment = uri.fragment();
141	URI uriWithoutFragment = uri.trimFragment();
142	String uriWithoutFragmentToString = uriWithoutFragment.toString();
143
144	URL url = null;
145	try
146	{
147	url = Platform.resolve(new URL(uriWithoutFragmentToString));
148	}
149	catch (IOException exception1)
150	{
151	// Platform.resolve() doesn't work if the project is encoded.
152	//
153	try
154	{
155	uriWithoutFragmentToString = URI.decode(uriWithoutFragmentToString);
156	url = Platform.resolve(new URL(uriWithoutFragmentToString));
157	}
158	catch (IOException exception2)
159	{
160	}
161	}
162	if (url != null)
163	{
164	try
165	{
166	return fix(url, fragment);
167	}
168	catch (IOException exception)
169	{
170	}
171	}
172
173	return uri;
174	}
175
176	protected static URI fix(URL url, String fragment) throws IOException
177	{
178	// Only file-scheme URIs will be re-encoded. If a URI was decoded in the workaround
179	// above, and Platform.resolve() didn't return a file-scheme URI, then this will return
180	// an decoded URI.
181	//
182	URI result =
183	"file".equalsIgnoreCase(url.getProtocol()) ?
184	URI.createFileURI(URI.decode(url.getFile())) :
185	URI.createURI(url.toString());
186	if (fragment != null)
187	{
188	result = result.appendFragment(fragment);
189	}
190	return result;
191	}
192
193	/**
194	* Use the platform to load the named class using the right class loader.
195	*/
196	public static Class loadClass(String pluginID, String className) throws ClassNotFoundException
197	{
198	return Platform.getBundle(pluginID).loadClass(className);
199	}
200	}
201	}	23	}