org.eclipse.osgi_3.8.2.v20130124-134944

_0
    //   220: invokeinterface 658 7 0
    //   225: iinc 12 1
    //   228: iload 12
    //   230: aload 5
    //   232: arraylength
    //   233: if_icmplt -28 -> 205
    //   236: aload 8
    //   238: iconst_0
    //   239: aaload
    //   240: areturn
    // Line number table:
    //   Java source line #592	-> byte code offset #0
    //   Java source line #593	-> byte code offset #15
    //   Java source line #597	-> byte code offset #18
    //   Java source line #599	-> byte code offset #23
    //   Java source line #600	-> byte code offset #29
    //   Java source line #601	-> byte code offset #47
    //   Java source line #602	-> byte code offset #52
    //   Java source line #599	-> byte code offset #55
    //   Java source line #604	-> byte code offset #66
    //   Java source line #605	-> byte code offset #79
    //   Java source line #607	-> byte code offset #86
    //   Java source line #608	-> byte code offset #97
    //   Java source line #609	-> byte code offset #102
    //   Java source line #610	-> byte code offset #107
    //   Java source line #611	-> byte code offset #112
    //   Java source line #609	-> byte code offset #115
    //   Java source line #610	-> byte code offset #120
    //   Java source line #612	-> byte code offset #125
    //   Java source line #613	-> byte code offset #128
    //   Java source line #614	-> byte code offset #136
    //   Java source line #613	-> byte code offset #147
    //   Java source line #617	-> byte code offset #157
    //   Java source line #618	-> byte code offset #159
    //   Java source line #620	-> byte code offset #165
    //   Java source line #618	-> byte code offset #185
    //   Java source line #621	-> byte code offset #196
    //   Java source line #618	-> byte code offset #199
    //   Java source line #620	-> byte code offset #205
    //   Java source line #618	-> byte code offset #225
    //   Java source line #623	-> byte code offset #236
    // Local variable table:
    //   start	length	slot	name	signature
    //   0	241	0	this	ClasspathManager
    //   0	241	1	name	String
    //   0	241	2	classbytes	byte[]
    //   0	241	3	classpathEntry	ClasspathEntry
    //   0	241	4	entry	BundleEntry
    //   0	241	5	statsHooks	ClassLoadingStatsHook[]
    //   13	48	6	hooks	ClassLoadingHook[]
    //   16	37	7	modifiedBytes	byte[]
    //   21	216	8	result	Class[]
    //   24	35	9	i	int
    //   84	32	9	initialLock	boolean
    //   100	13	10	localObject1	Object
    //   157	40	11	localObject2	Object
    //   160	29	12	i	int
    //   200	29	12	i	int
    // Exception table:
    //   from	to	target	type
    //   86	100	100	finally
    //   136	150	153	finally
    //   153	156	153	finally
    //   23	157	157	finally
  }
  
  private Class<?>[] defineClassHoldingLock(String name, byte[] classbytes, ClasspathEntry classpathEntry, BundleEntry entry)
  {
    Class[] result = new Class[2];
    
    result[0] = classloader.publicFindLoaded(name);
    if (result[0] == null) {
      result[0] = (result[1] = classloader.defineClass(name, classbytes, classpathEntry, entry));
    }
    return result;
  }
  
  public BaseData getBaseData()
  {
    return data;
  }
  
  public FragmentClasspath[] getFragmentClasspaths()
  {
    return fragments;
  }
  
  public ClasspathEntry[] getHostClasspathEntries()
  {
    return entries;
  }
  
  public BaseClassLoader getBaseClassLoader()
  {
    return classloader;
  }
  
  public String findLibrary(String libname)
  {
    synchronized (this)
    {
      if (loadedLibraries == null) {
        loadedLibraries = new ArrayMap(1);
      }
    }
    synchronized (loadedLibraries)
    {
      String libpath = (String)loadedLibraries.get(libname);
      if (libpath != null) {
        return libpath;
      }
      libpath = classloader.getDelegate().findLibrary(libname);
      if (libpath != null) {
        loadedLibraries.put(libname, libpath);
      }
      return libpath;
    }
  }
  
  public List<URL> findEntries(String path, String filePattern, int options)
  {
    BaseAdaptor adaptor = getBaseData().getAdaptor();
    List<BundleData> datas = new ArrayList();
    
    datas.add(getBaseData());
    
    FragmentClasspath[] currentFragments = getFragmentClasspaths();
    FragmentClasspath[] arrayOfFragmentClasspath1;
    int j = (arrayOfFragmentClasspath1 = currentFragments).length;
    for (int i = 0; i < j; i++)
    {
      FragmentClasspath fragmentClasspath = arrayOfFragmentClasspath1[i];
      datas.add(fragmentClasspath.getBundleData());
    }
    List<URL> result = Collections.EMPTY_LIST;
    
    Object eURLs = adaptor.findEntries(datas, path, filePattern, options);
    if (eURLs == null) {
      return result;
    }
    result = new ArrayList();
    while (((Enumeration)eURLs).hasMoreElements()) {
      result.add((URL)((Enumeration)eURLs).nextElement());
    }
    return Collections.unmodifiableList(result);
  }
  
  public Collection<String> listLocalResources(String path, String filePattern, int options)
  {
    List<BundleFile> bundleFiles = new ArrayList();
    
    ClasspathEntry[] cpEntries = getHostClasspathEntries();
    ClasspathEntry[] arrayOfClasspathEntry1;
    int j = (arrayOfClasspathEntry1 = cpEntries).length;
    for (int i = 0; i < j; i++)
    {
      ClasspathEntry cpEntry = arrayOfClasspathEntry1[i];
      bundleFiles.add(cpEntry.getBundleFile());
    }
    FragmentClasspath[] currentFragments = getFragmentClasspaths();
    FragmentClasspath[] arrayOfFragmentClasspath1;
    int k = (arrayOfFragmentClasspath1 = currentFragments).length;
    for (j = 0; j < k; j++)
    {
      FragmentClasspath fragmentClasspath = arrayOfFragmentClasspath1[j];
      ClasspathEntry[] fragEntries = fragmentClasspath.getEntries();
      ClasspathEntry[] arrayOfClasspathEntry2;
      int n = (arrayOfClasspathEntry2 = fragEntries).length;
      for (int m = 0; m < n; m++)
      {
        ClasspathEntry cpEntry = arrayOfClasspathEntry2[m];
        bundleFiles.add(cpEntry.getBundleFile());
      }
    }
    return getBaseData().getAdaptor().listEntryPaths(bundleFiles, path, filePattern, options);
  }
}

/* Location:
 * Qualified Name:     org.eclipse.osgi.baseadaptor.loader.ClasspathManager
 * Java Class Version: 1.4 (48.0)
 * JD-Core Version:    0.7.1
 */
package org.eclipse.osgi.baseadaptor.loader;

import java.io.IOException;
import java.security.ProtectionDomain;
import org.eclipse.osgi.baseadaptor.BaseAdaptor;
import org.eclipse.osgi.baseadaptor.BaseData;
import org.eclipse.osgi.baseadaptor.bundlefile.BundleFile;
import org.eclipse.osgi.framework.adaptor.EventPublisher;

public class FragmentClasspath
{
  private BaseData bundledata;
  private ClasspathEntry[] entries;
  private ProtectionDomain domain;
  
  public FragmentClasspath(BaseData bundledata, ClasspathEntry[] entries, ProtectionDomain domain)
  {
    this.bundledata = bundledata;
    this.entries = entries;
    this.domain = domain;
  }
  
  public BaseData getBundleData()
  {
    return bundledata;
  }
  
  public ProtectionDomain getDomain()
  {
    return domain;
  }
  
  public ClasspathEntry[] getEntries()
  {
    return entries;
  }
  
  public void close()
  {
    for (int i = 0; i < entries.length; i++) {
      try
      {
        entries[i].getBundleFile().close();
      }
      catch (IOException e)
      {
        bundledata.getAdaptor().getEventPublisher().publishFrameworkEvent(2, bundledata.getBundle(), e);
      }
    }
  }
}

/* Location:
 * Qualified Name:     org.eclipse.osgi.baseadaptor.loader.FragmentClasspath
 * Java Class Version: 1.4 (48.0)
 * JD-Core Version:    0.7.1
 */
package org.eclipse.osgi.baseadaptor.loader;

public abstract interface ParallelClassLoader
  extends BaseClassLoader
{
  public abstract boolean isParallelCapable();
}

/* Location:
 * Qualified Name:     org.eclipse.osgi.baseadaptor.loader.ParallelClassLoader
 * Java Class Version: 1.4 (48.0)
 * JD-Core Version:    0.7.1
 */
package org.eclipse.osgi.event;

import org.osgi.framework.BundleListener;

public abstract interface BatchBundleListener
  extends BundleListener
{
  public abstract void batchBegin();
  
  public abstract void batchEnd();
}

/* Location:
 * Qualified Name:     org.eclipse.osgi.event.BatchBundleListener
 * Java Class Version: 1.4 (48.0)
 * JD-Core Version:    0.7.1
 */
package org.eclipse.osgi.framework.adaptor;

import java.io.IOException;
import java.net.URL;
import java.security.ProtectionDomain;
import java.util.Collection;
import java.util.Enumeration;
import java.util.List;
import org.osgi.framework.BundleReference;

public abstract interface BundleClassLoader
  extends BundleReference
{
  public abstract void initialize();
  
  public abstract URL findLocalResource(String paramString);
  
  public abstract Enumeration<URL> findLocalResources(String paramString);
  
  public abstract Class<?> findLocalClass(String paramString)
    throws ClassNotFoundException;
  
  public abstract URL getResource(String paramString);
  
  public abstract Enumeration<URL> getResources(String paramString)
    throws IOException;
  
  public abstract Class<?> loadClass(String paramString)
    throws ClassNotFoundException;
  
  public abstract void close();
  
  public abstract void attachFragment(BundleData paramBundleData, ProtectionDomain paramProtectionDomain, String[] paramArrayOfString);
  
  public abstract ClassLoaderDelegate getDelegate();
  
  public abstract ClassLoader getParent();
  
  public abstract List<URL> findEntries(String paramString1, String paramString2, int paramInt);
  
  public abstract Collection<String> listResources(String paramString1, String paramString2, int paramInt);
  
  public abstract Collection<String> listLocalResources(String paramString1, String paramString2, int paramInt);
}

/* Location:
 * Qualified Name:     org.eclipse.osgi.framework.adaptor.BundleClassLoader
 * Java Class Version: 1.4 (48.0)
 * JD-Core Version:    0.7.1
 */
package org.eclipse.osgi.framework.adaptor;

import java.io.File;
import java.io.IOException;
import java.net.URL;
import java.util.Dictionary;
import java.util.Enumeration;
import org.osgi.framework.Bundle;
import org.osgi.framework.BundleException;
import org.osgi.framework.BundleReference;
import org.osgi.framework.Version;

public abstract interface BundleData
  extends BundleReference
{
  public static final int TYPE_FRAGMENT = 1;
  public static final int TYPE_FRAMEWORK_EXTENSION = 2;
  public static final int TYPE_BOOTCLASSPATH_EXTENSION = 4;
  public static final int TYPE_SINGLETON = 8;
  public static final int TYPE_EXTCLASSPATH_EXTENSION = 16;
  public static final int TYPE_COMPOSITEBUNDLE = 32;
  public static final int TYPE_SURROGATEBUNDLE = 64;
  
  public abstract BundleClassLoader createClassLoader(ClassLoaderDelegate paramClassLoaderDelegate, BundleProtectionDomain paramBundleProtectionDomain, String[] paramArrayOfString);
  
  public abstract URL getEntry(String paramString);
  
  public abstract Enumeration<String> getEntryPaths(String paramString);
  
  public abstract String findLibrary(String paramString);
  
  public abstract void installNativeCode(String[] paramArrayOfString)
    throws BundleException;
  
  public abstract File getDataFile(String paramString);
  
  public abstract Dictionary<String, String> getManifest()
    throws BundleException;
  
  public abstract long getBundleID();
  
  public abstract String getLocation();
  
  public abstract long getLastModified();
  
  public abstract void close()
    throws IOException;
  
  public abstract void open()
    throws IOException;
  
  public abstract void setBundle(Bundle paramBundle);
  
  public abstract int getStartLevel();
  
  public abstract int getStatus();
  
  public abstract void setStartLevel(int paramInt);
  
  public abstract void setStatus(int paramInt);
  
  public abstract void save()
    throws IOException;
  
  public abstract String getSymbolicName();
  
  public abstract Version getVersion();
  
  public abstract int getType();
  
  public abstract String[] getClassPath()
    throws BundleException;
  
  public abstract String getActivator();
  
  public abstract String getExecutionEnvironment();
  
  public abstract String getDynamicImports();
  
  public abstract Enumeration<URL> findLocalResources(String paramString);
}

/* Location:
 * Qualified Name:     org.eclipse.osgi.framework.adaptor.BundleData
 * Java Class Version: 1.4 (48.0)
 * JD-Core Version:    0.7.1
 */
package org.eclipse.osgi.framework.adaptor;

import org.osgi.framework.BundleException;

public abstract interface BundleOperation
{
  public abstract BundleData begin()
    throws BundleException;
  
  public abstract void commit(boolean paramBoolean)
    throws BundleException;
  
  public abstract void undo()
    throws BundleException;
}

/* Location:
 * Qualified Name:     org.eclipse.osgi.framework.adaptor.BundleOperation
 * Java Class Version: 1.4 (48.0)
 * JD-Core Version:    0.7.1
 */
package org.eclipse.osgi.framework.adaptor;

import java.security.CodeSource;
import java.security.PermissionCollection;
import java.security.ProtectionDomain;
import org.osgi.framework.Bundle;
import org.osgi.framework.BundleReference;

public class BundleProtectionDomain
  extends ProtectionDomain
  implements BundleReference
{
  private volatile Bundle bundle;
  
  /**
   * @deprecated
   */
  public BundleProtectionDomain(PermissionCollection permCollection)
  {
    this(permCollection, null, null);
  }
  
  public BundleProtectionDomain(PermissionCollection permCollection, CodeSource codeSource, Bundle bundle)
  {
    super(codeSource, permCollection);
    this.bundle = bundle;
  }
  
  public void setBundle(Bundle bundle)
  {
    if ((this.bundle != null) || (bundle == null)) {
      return;
    }
    this.bundle = bundle;
  }
  
  public Bundle getBundle()
  {
    return bundle;
  }
}

/* Location:
 * Qualified Name:     org.eclipse.osgi.framework.adaptor.BundleProtectionDomain
 * Java Class Version: 1.4 (48.0)
 * JD-Core Version:    0.7.1
 */
package org.eclipse.osgi.framework.adaptor;

import org.osgi.framework.Bundle;

public abstract interface BundleWatcher
{
  public static final int START_INSTALLING = 1;
  public static final int END_INSTALLING = 2;
  public static final int START_ACTIVATION = 4;
  public static final int END_ACTIVATION = 8;
  public static final int START_DEACTIVATION = 16;
  public static final int END_DEACTIVATION = 32;
  public static final int START_UNINSTALLING = 64;
  public static final int END_UNINSTALLING = 128;
  
  public abstract void watchBundle(Bundle paramBundle, int paramInt);
}

/* Location:
 * Qualified Name:     org.eclipse.osgi.framework.adaptor.BundleWatcher
 * Java Class Version: 1.4 (48.0)
 * JD-Core Version:    0.7.1
 */
package org.eclipse.osgi.framework.adaptor;

import java.io.IOException;
import java.net.URL;
import java.util.Collection;
import java.util.Enumeration;
import org.osgi.framework.BundleException;

public abstract interface ClassLoaderDelegate
{
  public abstract Class<?> findClass(String paramString)
    throws ClassNotFoundException;
  
  public abstract URL findResource(String paramString);
  
  public abstract Enumeration<URL> findResources(String paramString)
    throws IOException;
  
  public abstract String findLibrary(String paramString);
  
  public abstract boolean isLazyTriggerSet();
  
  public abstract void setLazyTrigger()
    throws BundleException;
  
  public abstract Collection<String> listResources(String paramString1, String paramString2, int paramInt);
}

/* Location:
 * Qualified Name:     org.eclipse.osgi.framework.adaptor.ClassLoaderDelegate
 * Java Class Version: 1.4 (48.0)
 * JD-Core Version:    0.7.1
 */
package org.eclipse.osgi.framework.adaptor;

import java.io.FileNotFoundException;
import java.net.URL;
import java.util.Enumeration;

public abstract interface ClassLoaderDelegateHook
{
  public abstract Class<?> preFindClass(String paramString, BundleClassLoader paramBundleClassLoader, BundleData paramBundleData)
    throws ClassNotFoundException;
  
  public abstract Class<?> postFindClass(String paramString, BundleClassLoader paramBundleClassLoader, BundleData paramBundleData)
    throws ClassNotFoundException;
  
  public abstract URL preFindResource(String paramString, BundleClassLoader paramBundleClassLoader, BundleData paramBundleData)
    throws FileNotFoundException;
  
  public abstract URL postFindResource(String paramString, BundleClassLoader paramBundleClassLoader, BundleData paramBundleData)
    throws FileNotFoundException;
  
  public abstract Enumeration<URL> preFindResources(String paramString, BundleClassLoader paramBundleClassLoader, BundleData paramBundleData)
    throws FileNotFoundException;
  
  public abstract Enumeration<URL> postFindResources(String paramString, BundleClassLoader paramBundleClassLoader, BundleData paramBundleData)
    throws FileNotFoundException;
  
  public abstract String preFindLibrary(String paramString, BundleClassLoader paramBundleClassLoader, BundleData paramBundleData)
    throws FileNotFoundException;
  
  public abstract String postFindLibrary(String paramString, BundleClassLoader paramBundleClassLoader, BundleData paramBundleData);
}

/* Location:
 * Qualified Name:     org.eclipse.osgi.framework.adaptor.ClassLoaderDelegateHook
 * Java Class Version: 1.4 (48.0)
 * JD-Core Version:    0.7.1
 */
package org.eclipse.osgi.framework.adaptor;

import org.osgi.framework.Bundle;

public abstract interface EventPublisher
{
  public abstract void publishFrameworkEvent(int paramInt, Bundle paramBundle, Throwable paramThrowable);
}

/* Location:
 * Qualified Name:     org.eclipse.osgi.framework.adaptor.EventPublisher
 * Java Class Version: 1.4 (48.0)
 * JD-Core Version:    0.7.1
 */
package org.eclipse.osgi.framework.adaptor;

import java.io.File;

public class FilePath
{
  private static final boolean WINDOWS = File.separatorChar == '\\';
  private static final String CURRENT_DIR = ".";
  private static final char DEVICE_SEPARATOR = ':';
  private static final byte HAS_LEADING = 1;
  private static final byte HAS_TRAILING = 4;
  private static final String[] NO_SEGMENTS = new String[0];
  private static final String PARENT_DIR = "..";
  private static final char SEPARATOR = '/';
  private static final String UNC_SLASHES = "//";
  private String device;
  private byte flags;
  private String[] segments;
  
  public FilePath(File location)
  {
    initialize(location.getPath());
    if (location.isDirectory()) {
      flags = ((byte)(flags | 0x4));
    } else {
      flags = ((byte)(flags & 0xFFFFFFFB));
    }
  }
  
  public FilePath(String original)
  {
    initialize(original);
  }
  
  private int computeSegmentCount(String path)
  {
    int len = path.length();
    if ((len == 0) || ((len == 1) && (path.charAt(0) == '/'))) {
      return 0;
    }
    int count = 1;
    int prev = -1;
    int i;
    while ((i = path.indexOf('/', prev + 1)) != -1)
    {
      int i;
      if ((i != prev + 1) && (i != len)) {
        count++;
      }
      prev = i;
    }
    if (path.charAt(len - 1) == '/') {
      count--;
    }
    return count;
  }
  
  private String[] computeSegments(String path)
  {
    int maxSegmentCount = computeSegmentCount(path);
    if (maxSegmentCount == 0) {
      return NO_SEGMENTS;
    }
    String[] newSegments = new String[maxSegmentCount];
    int len = path.length();
    
    int firstPosition = isAbsolute() ? 1 : 0;
    int lastPosition = hasTrailingSlash() ? len - 2 : len - 1;
    
    int next = firstPosition;
    int actualSegmentCount = 0;
    for (int i = 0; i < maxSegmentCount; i++)
    {
      int start = next;
      int end = path.indexOf('/', next);
      next = end + 1;
      String segment = path.substring(start, end == -1 ? lastPosition + 1 : end);
      if (!".".equals(segment)) {
        if ("..".equals(segment))
        {
          if (actualSegmentCount > 0) {
            actualSegmentCount--;
          }
        }
        else {
          newSegments[(actualSegmentCount++)] = segment;
        }
      }
    }
    if (actualSegmentCount == newSegments.length) {
      return newSegments;
    }
    if (actualSegmentCount == 0) {
      return NO_SEGMENTS;
    }
    String[] actualSegments = new String[actualSegmentCount];
    System.arraycopy(newSegments, 0, actualSegments, 0, actualSegments.length);
    return actualSegments;
  }
  
  public String getDevice()
  {
    return device;
  }
  
  public String[] getSegments()
  {
    return (String[])segments.clone();
  }
  
  public boolean hasTrailingSlash()
  {
    return (flags & 0x4) != 0;
  }
  
  private void initialize(String original)
  {
    original = original.indexOf('\\') == -1 ? original : original.replace('\\', '/');
    if (WINDOWS)
    {
      int deviceSeparatorPos = original.indexOf(':');
      if (deviceSeparatorPos >= 0)
      {
        int start = original.charAt(0) == '/' ? 1 : 0;
        device = original.substring(start, deviceSeparatorPos + 1);
        original = original.substring(deviceSeparatorPos + 1, original.length());
      }
      else if (original.startsWith("//"))
      {
        int uncPrefixEnd = original.indexOf('/', 2);
        if (uncPrefixEnd >= 0) {
          uncPrefixEnd = original.indexOf('/', uncPrefixEnd + 1);
        }
        if (uncPrefixEnd >= 0)
        {
          device = original.substring(0, uncPrefixEnd);
          original = original.substring(uncPrefixEnd, original.length());
        }
        else
        {
          throw new IllegalArgumentException("Not a valid UNC: " + original);
        }
      }
    }
    if (original.charAt(0) == '/') {
      flags = ((byte)(flags | 0x1));
    }
    if (original.charAt(original.length() - 1) == '/') {
      flags = ((byte)(flags | 0x4));
    }
    segments = computeSegments(original);
  }
  
  public boolean isAbsolute()
  {
    return (flags & 0x1) != 0;
  }
  
  public String makeRelative(FilePath base)
  {
    if ((device != null) && (!device.equalsIgnoreCase(device))) {
      return base.toString();
    }
    int baseCount = segments.length;
    int count = matchingFirstSegments(base);
    if ((baseCount == count) && (count == segments.length)) {
      return base.hasTrailingSlash() ? "./" : ".";
    }
    StringBuffer relative = new StringBuffer();
    for (int j = 0; j < baseCount - count; j++) {
      relative.append("../");
    }
    for (int i = 0; i < segments.length - count; i++)
    {
      relative.append(segments[(count + i)]);
      relative.append('/');
    }
    if (!base.hasTrailingSlash()) {
      relative.deleteCharAt(relative.length() - 1);
    }
    return relative.toString();
  }
  
  private int matchingFirstSegments(FilePath anotherPath)
  {
    int anotherPathLen = segments.length;
    int max = Math.min(segments.length, anotherPathLen);
    int count = 0;
    for (int i = 0; i < max; i++)
    {
      if (!segments[i].equals(segments[i])) {
        return count;
      }
      count++;
    }
    return count;
  }
  
  public String toString()
  {
    StringBuffer result = new StringBuffer();
    if (device != null) {
      result.append(device);
    }
    if (isAbsolute()) {
      result.append('/');
    }
    for (int i = 0; i < segments.length; i++)
    {
      result.append(segments[i]);
      result.append('/');
    }
    if ((segments.length > 0) && (!hasTrailingSlash())) {
      result.deleteCharAt(result.length() - 1);
    }
    return result.toString();
  }
}

/* Location:
 * Qualified Name:     org.eclipse.osgi.framework.adaptor.FilePath
 * Java Class Version: 1.4 (48.0)
 * JD-Core Version:    0.7.1
 */
package org.eclipse.osgi.framework.adaptor;

import java.io.IOException;
import java.net.URL;
import java.net.URLConnection;
import java.util.Enumeration;
import java.util.List;
import java.util.Properties;
import org.eclipse.osgi.framework.log.FrameworkLog;
import org.eclipse.osgi.service.resolver.PlatformAdmin;
import org.eclipse.osgi.service.resolver.State;
import org.osgi.framework.BundleContext;
import org.osgi.framework.BundleException;

public abstract interface FrameworkAdaptor
{
  public static final String FRAMEWORK_SYMBOLICNAME = "org.eclipse.osgi";
  
  public abstract void initialize(EventPublisher paramEventPublisher);
  
  public abstract void initializeStorage()
    throws IOException;
  
  public abstract void compactStorage()
    throws IOException;
  
  public abstract Properties getProperties();
  
  public abstract BundleData[] getInstalledBundles();
  
  public abstract URLConnection mapLocationToURLConnection(String paramString)
    throws BundleException;
  
  public abstract BundleOperation installBundle(String paramString, URLConnection paramURLConnection);
  
  public abstract BundleOperation updateBundle(BundleData paramBundleData, URLConnection paramURLConnection);
  
  public abstract BundleOperation uninstallBundle(BundleData paramBundleData);
  
  public abstract long getTotalFreeSpace()
    throws IOException;
  
  public abstract PermissionStorage getPermissionStorage()
    throws IOException;
  
  public abstract void frameworkStart(BundleContext paramBundleContext)
    throws BundleException;
  
  public abstract void frameworkStop(BundleContext paramBundleContext)
    throws BundleException;
  
  public abstract void frameworkStopping(BundleContext paramBundleContext);
  
  public abstract int getInitialBundleStartLevel();
  
  public abstract void setInitialBundleStartLevel(int paramInt);
  
  public abstract FrameworkLog getFrameworkLog();
  
  public abstract BundleData createSystemBundleData()
    throws BundleException;
  
  public abstract BundleWatcher getBundleWatcher();
  
  public abstract PlatformAdmin getPlatformAdmin();
  
  public abstract State getState();
  
  public abstract ClassLoader getBundleClassLoaderParent();
  
  public abstract void handleRuntimeError(Throwable paramThrowable);
  
  public abstract Enumeration<URL> findEntries(List<BundleData> paramList, String paramString1, String paramString2, int paramInt);
}

/* Location:
 * Qualified Name:     org.eclipse.osgi.framework.adaptor.FrameworkAdaptor
 * Java Class Version: 1.4 (48.0)
 * JD-Core Version:    0.7.1
 */
package org.eclipse.osgi.framework.adaptor;

import java.io.IOException;

public abstract interface PermissionStorage
{
  public abstract String[] getLocations()
    throws IOException;
  
  public abstract String[] getPermissionData(String paramString)
    throws IOException;
  
  public abstract void setPermissionData(String paramString, String[] paramArrayOfString)
    throws IOException;
  
  public abstract void saveConditionalPermissionInfos(String[] paramArrayOfString)
    throws IOException;
  
  public abstract String[] getConditionalPermissionInfos()
    throws IOException;
}

/* Location:
 * Qualified Name:     org.eclipse.osgi.framework.adaptor.PermissionStorage
 * Java Class Version: 1.4 (48.0)
 * JD-Core Version:    0.7.1
 */
package org.eclipse.osgi.framework.adaptor;

public abstract interface StatusException
{
  public static final int CODE_OK = 1;
  public static final int CODE_INFO = 2;
  public static final int CODE_WARNING = 4;
  public static final int CODE_ERROR = 8;
  
  public abstract Object getStatus();
  
  public abstract int getStatusCode();
}

/* Location:
 * Qualified Name:     org.eclipse.osgi.framework.adaptor.StatusException
 * Java Class Version: 1.4 (48.0)
 * JD-Core Version:    0.7.1
 */
package org.eclipse.osgi.framework.console;

import java.util.Dictionary;
import org.osgi.framework.Bundle;

public abstract interface CommandInterpreter
{
  public abstract String nextArgument();
  
  public abstract Object execute(String paramString);
  
  public abstract void print(Object paramObject);
  
  public abstract void println();
  
  public abstract void println(Object paramObject);
  
  public abstract void printStackTrace(Throwable paramThrowable);
  
  public abstract void printDictionary(Dictionary<?, ?> paramDictionary, String paramString);
  
  public abstract void printBundleResource(Bundle paramBundle, String paramString);
}

/* Location:
 * Qualified Name:     org.eclipse.osgi.framework.console.CommandInterpreter
 * Java Class Version: 1.4 (48.0)
 * JD-Core Version:    0.7.1
 */
package org.eclipse.osgi.framework.console;

public abstract interface CommandProvider
{
  public abstract String getHelp();
}

/* Location:
 * Qualified Name:     org.eclipse.osgi.framework.console.CommandProvider
 * Java Class Version: 1.4 (48.0)
 * JD-Core Version:    0.7.1
 */
package org.eclipse.osgi.framework.console;

import java.io.InputStream;
import java.io.OutputStream;
import org.osgi.framework.Bundle;
import org.osgi.framework.ServiceFactory;
import org.osgi.framework.ServiceRegistration;

public abstract class ConsoleSession
  implements ServiceFactory<Object>
{
  private volatile ServiceRegistration<Object> sessionRegistration;
  
  public final void close()
  {
    doClose();
    ServiceRegistration<Object> current = sessionRegistration;
    if (current != null)
    {
      sessionRegistration = null;
      try
      {
        current.unregister();
      }
      catch (IllegalStateException localIllegalStateException) {}
    }
  }
  
  protected abstract void doClose();
  
  public abstract InputStream getInput();
  
  public abstract OutputStream getOutput();
  
  public final Object getService(Bundle bundle, ServiceRegistration<Object> registration)
  {
    if (sessionRegistration == null) {
      sessionRegistration = registration;
    }
    return this;
  }
  
  public final void ungetService(Bundle bundle, ServiceRegistration<Object> registration, Object service) {}
}

/* Location:
 * Qualified Name:     org.eclipse.osgi.framework.console.ConsoleSession
 * Java Class Version: 1.4 (48.0)
 * JD-Core Version:    0.7.1
 */
package org.eclipse.osgi.framework.debug;

import java.io.PrintStream;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.lang.reflect.Modifier;

public class Debug
{
  public static boolean DEBUG_ENABLED = false;
  public static boolean DEBUG_GENERAL = false;
  public static boolean DEBUG_BUNDLE_TIME = false;
  public static boolean DEBUG_LOADER = false;
  public static boolean DEBUG_EVENTS = false;
  public static boolean DEBUG_SERVICES = false;
  public static boolean DEBUG_HOOKS = false;
  public static boolean DEBUG_PACKAGES = false;
  public static boolean DEBUG_MANIFEST = false;
  public static boolean DEBUG_FILTER = false;
  public static boolean DEBUG_SECURITY = false;
  public static boolean DEBUG_STARTLEVEL = false;
  public static boolean DEBUG_PACKAGEADMIN = false;
  public static boolean DEBUG_PACKAGEADMIN_TIMING = false;
  public static boolean DEBUG_MESSAGE_BUNDLES = false;
  public static boolean MONITOR_ACTIVATION = false;
  public static final String ECLIPSE_OSGI = "org.eclipse.osgi";
  public static final String OPTION_DEBUG_GENERAL = "org.eclipse.osgi/debug";
  public static final String OPTION_DEBUG_BUNDLE_TIME = "org.eclipse.osgi/debug/bundleTime";
  public static final String OPTION_DEBUG_LOADER = "org.eclipse.osgi/debug/loader";
  public static final String OPTION_DEBUG_EVENTS = "org.eclipse.osgi/debug/events";
  public static final String OPTION_DEBUG_SERVICES = "org.eclipse.osgi/debug/services";
  public static final String OPTION_DEBUG_HOOKS = "org.eclipse.osgi/debug/hooks";
  public static final String OPTION_DEBUG_PACKAGES = "org.eclipse.osgi/debug/packages";
  public static final String OPTION_DEBUG_MANIFEST = "org.eclipse.osgi/debug/manifest";
  public static final String OPTION_DEBUG_FILTER = "org.eclipse.osgi/debug/filter";
  public static final String OPTION_DEBUG_SECURITY = "org.eclipse.osgi/debug/security";
  public static final String OPTION_DEBUG_STARTLEVEL = "org.eclipse.osgi/debug/startlevel";
  public static final String OPTION_DEBUG_PACKAGEADMIN = "org.eclipse.osgi/debug/packageadmin";
  public static final String OPTION_DEBUG_PACKAGEADMIN_TIMING = "org.eclipse.osgi/debug/packageadmin/timing";
  public static final String OPTION_MONITOR_ACTIVATION = "org.eclipse.osgi/monitor/activation";
  public static final String OPTION_DEBUG_MESSAGE_BUNDLES = "org.eclipse.osgi/debug/messageBundles";
  
  static
  {
    FrameworkDebugOptions dbgOptions = FrameworkDebugOptions.getDefault();
    if (dbgOptions != null)
    {
      DEBUG_ENABLED = dbgOptions.isDebugEnabled();
      DEBUG_GENERAL = dbgOptions.getBooleanOption("org.eclipse.osgi/debug", false);
      DEBUG_BUNDLE_TIME = (dbgOptions.getBooleanOption("org.eclipse.osgi/debug/bundleTime", false)) || (dbgOptions.getBooleanOption("org.eclipse.core.runtime/timing/startup", false));
      DEBUG_LOADER = dbgOptions.getBooleanOption("org.eclipse.osgi/debug/loader", false);
      DEBUG_EVENTS = dbgOptions.getBooleanOption("org.eclipse.osgi/debug/events", false);
      DEBUG_SERVICES = dbgOptions.getBooleanOption("org.eclipse.osgi/debug/services", false);
      DEBUG_HOOKS = dbgOptions.getBooleanOption("org.eclipse.osgi/debug/hooks", false);
      DEBUG_PACKAGES = dbgOptions.getBooleanOption("org.eclipse.osgi/debug/packages", false);
      DEBUG_MANIFEST = dbgOptions.getBooleanOption("org.eclipse.osgi/debug/manifest", false);
      DEBUG_FILTER = dbgOptions.getBooleanOption("org.eclipse.osgi/debug/filter", false);
      DEBUG_SECURITY = dbgOptions.getBooleanOption("org.eclipse.osgi/debug/security", false);
      DEBUG_STARTLEVEL = dbgOptions.getBooleanOption("org.eclipse.osgi/debug/startlevel", false);
      DEBUG_PACKAGEADMIN = dbgOptions.getBooleanOption("org.eclipse.osgi/debug/packageadmin", false);
      DEBUG_PACKAGEADMIN_TIMING = (dbgOptions.getBooleanOption("org.eclipse.osgi/debug/packageadmin/timing", false)) || (dbgOptions.getBooleanOption("org.eclipse.core.runtime/debug", false));
      DEBUG_MESSAGE_BUNDLES = dbgOptions.getBooleanOption("org.eclipse.osgi/debug/messageBundles", false);
      MONITOR_ACTIVATION = dbgOptions.getBooleanOption("org.eclipse.osgi/monitor/activation", false);
    }
  }
  
  public static PrintStream out = System.out;
  
  public static void print(boolean x)
  {
    out.print(x);
  }
  
  public static void print(char x)
  {
    out.print(x);
  }
  
  public static void print(int x)
  {
    out.print(x);
  }
  
  public static void print(long x)
  {
    out.print(x);
  }
  
  public static void print(float x)
  {
    out.print(x);
  }
  
  public static void print(double x)
  {
    out.print(x);
  }
  
  public static void print(char[] x)
  {
    out.print(x);
  }
  
  public static void print(String x)
  {
    out.print(x);
  }
  
  public static void print(Object x)
  {
    out.print(x);
  }
  
  public static void println(boolean x)
  {
    out.println(x);
  }
  
  public static void println(char x)
  {
    out.println(x);
  }
  
  public static void println(int x)
  {
    out.println(x);
  }
  
  public static void println(long x)
  {
    out.println(x);
  }
  
  public static void println(float x)
  {
    out.println(x);
  }
  
  public static void println(double x)
  {
    out.println(x);
  }
  
  public static void println(char[] x)
  {
    out.println(x);
  }
  
  public static void println(String x)
  {
    out.println(x);
  }
  
  public static void println(Object x)
  {
    out.println(x);
  }
  
  public static void printStackTrace(Throwable t)
  {
    if (t == null) {
      return;
    }
    t.printStackTrace(out);
    
    Method[] methods = t.getClass().getMethods();
    
    int size = methods.length;
    Class<?> throwable = Throwable.class;
    for (int i = 0; i < size; i++)
    {
      Method method = methods[i];
      if ((Modifier.isPublic(method.getModifiers())) && (method.getName().startsWith("get")) && (throwable.isAssignableFrom(method.getReturnType())) && (method.getParameterTypes().length == 0)) {
        try
        {
          Throwable nested = (Throwable)method.invoke(t, null);
          if ((nested != null) && (nested != t))
          {
            out.println("Nested Exception:");
            printStackTrace(nested);
          }
        }
        catch (IllegalAccessException localIllegalAccessException) {}catch (InvocationTargetException localInvocationTargetException) {}
      }
    }
  }
}

/* Location:
 * Qualified Name:     org.eclipse.osgi.framework.debug.Debug
 * Java Class Version: 1.4 (48.0)
 * JD-Core Version:    0.7.1
 */
package org.eclipse.osgi.framework.debug;

import java.io.BufferedWriter;
import java.io.File;
import java.io.IOException;
import java.io.OutputStream;
import java.io.OutputStreamWriter;
import java.io.UnsupportedEncodingException;
import java.io.Writer;
import java.security.AccessController;
import java.text.MessageFormat;
import java.text.SimpleDateFormat;
import java.util.Date;
import org.eclipse.osgi.framework.util.SecureAction;
import org.eclipse.osgi.service.debug.DebugTrace;

class EclipseDebugTrace
  implements DebugTrace
{
  private static final String PROP_TRACE_SIZE_MAX = "eclipse.trace.size.max";
  private static final String PROP_TRACE_FILE_MAX = "eclipse.trace.backup.max";
  private static final String MESSAGE_THREAD_DUMP = "Thread Stack dump: ";
  private static final String MESSAGE_EXIT_METHOD_WITH_RESULTS = "Exiting method {0}with result: ";
  private static final String MESSAGE_EXIT_METHOD_NO_RESULTS = "Exiting method {0}with a void return";
  private static final String MESSAGE_ENTER_METHOD_WITH_PARAMS = "Entering method {0}with parameters: (";
  private static final String MESSAGE_ENTER_METHOD_NO_PARAMS = "Entering method {0}with no parameters";
  private static final String TRACE_FILE_VERSION_COMMENT = "version: ";
  private static final String TRACE_FILE_VERBOSE_COMMENT = "verbose: ";
  private static final String TRACE_FILE_VERSION = "1.1";
  private static final String TRACE_NEW_SESSION = "!SESSION ";
  private static final String TRACE_FILE_DATE = "Time of creation: ";
  private static final SimpleDateFormat TRACE_FILE_DATE_FORMATTER = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss.SSS");
  private static final String TRACE_COMMENT = "#";
  private static final String TRACE_ELEMENT_DELIMITER = "|";
  private static final String TRACE_ELEMENT_DELIMITER_ENCODED = "&#124;";
  private static final String LINE_SEPARATOR;
  private static final String NULL_VALUE = "<null>";
  
  static
  {
    String s = System.getProperty("line.separator");
    LINE_SEPARATOR = s == null ? "\n" : s;
  }
  
  private static final SecureAction secureAction = (SecureAction)AccessController.doPrivileged(SecureAction.createSecureAction());
  private static final Object writeLock = new Object();
  private static final int DEFAULT_TRACE_FILE_SIZE = 1000;
  private static final int DEFAULT_TRACE_FILES = 10;
  private static final int DEFAULT_TRACE_FILE_MIN_SIZE = 10;
  private static final String TRACE_FILE_EXTENSION = ".trace";
  private static final String BACKUP_MARK = ".bak_";
  private int maxTraceFileSize = 1000;
  private int maxTraceFiles = 10;
  private int backupTraceFileIndex = 0;
  private String traceClass = null;
  private String bundleSymbolicName = null;
  static boolean newSession = true;
  private FrameworkDebugOptions debugOptions = null;
  
  EclipseDebugTrace(String bundleSymbolicName, FrameworkDebugOptions debugOptions)
  {
    this(bundleSymbolicName, debugOptions, null);
  }
  
  EclipseDebugTrace(String bundleSymbolicName, FrameworkDebugOptions debugOptions, Class<?> traceClass)
  {
    this.traceClass = (traceClass != null ? traceClass.getName() : null);
    this.debugOptions = debugOptions;
    this.bundleSymbolicName = bundleSymbolicName;
    readLogProperties();
  }
  
  private final boolean isDebuggingEnabled(String optionPath)
  {
    if (optionPath == null) {
      return true;
    }
    boolean debugEnabled = false;
    if (debugOptions.isDebugEnabled())
    {
      String option = bundleSymbolicName + optionPath;
      debugEnabled = debugOptions.getBooleanOption(option, false);
    }
    return debugEnabled;
  }
  
  public void trace(String optionPat
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87

Further reading...

For more information on Java 1.5 Tiger, you may find Java 1.5 Tiger, A developer's Notebook by D. Flanagan and B. McLaughlin from O'Reilly of interest.

New!JAR listings


Copyright 2006-2019. Infinite Loop Ltd