org.eclipse.osgi_3.7.2.v20120110-1415

.4 (48.0)
 * JD-Core Version:    0.7.1
 */
package org.eclipse.osgi.service.resolver;

import org.osgi.framework.BundleException;

public abstract interface PlatformAdmin
{
  public abstract State getState();
  
  public abstract State getState(boolean paramBoolean);
  
  public abstract StateHelper getStateHelper();
  
  public abstract void commit(State paramState)
    throws BundleException;
  
  /**
   * @deprecated
   */
  public abstract Resolver getResolver();
  
  public abstract Resolver createResolver();
  
  public abstract StateObjectFactory getFactory();
  
  public abstract void addDisabledInfo(DisabledInfo paramDisabledInfo);
  
  public abstract void removeDisabledInfo(DisabledInfo paramDisabledInfo);
}

/* Location:
 * Qualified Name:     org.eclipse.osgi.service.resolver.PlatformAdmin
 * Java Class Version: 1.4 (48.0)
 * JD-Core Version:    0.7.1
 */
package org.eclipse.osgi.service.resolver;

import java.util.Comparator;
import java.util.Dictionary;

public abstract interface Resolver
{
  public abstract void resolve(BundleDescription[] paramArrayOfBundleDescription, Dictionary<Object, Object>[] paramArrayOfDictionary);
  
  public abstract void flush();
  
  public abstract State getState();
  
  public abstract void setState(State paramState);
  
  public abstract void bundleAdded(BundleDescription paramBundleDescription);
  
  public abstract void bundleRemoved(BundleDescription paramBundleDescription, boolean paramBoolean);
  
  public abstract void bundleUpdated(BundleDescription paramBundleDescription1, BundleDescription paramBundleDescription2, boolean paramBoolean);
  
  public abstract ExportPackageDescription resolveDynamicImport(BundleDescription paramBundleDescription, String paramString);
  
  public abstract void setSelectionPolicy(Comparator<BaseDescription> paramComparator);
  
  public abstract Comparator<BaseDescription> getSelectionPolicy();
}

/* Location:
 * Qualified Name:     org.eclipse.osgi.service.resolver.Resolver
 * Java Class Version: 1.4 (48.0)
 * JD-Core Version:    0.7.1
 */
package org.eclipse.osgi.service.resolver;

public abstract interface ResolverError
{
  public static final int MISSING_IMPORT_PACKAGE = 1;
  public static final int MISSING_REQUIRE_BUNDLE = 2;
  public static final int MISSING_FRAGMENT_HOST = 4;
  public static final int SINGLETON_SELECTION = 8;
  public static final int FRAGMENT_CONFLICT = 16;
  public static final int IMPORT_PACKAGE_USES_CONFLICT = 32;
  public static final int REQUIRE_BUNDLE_USES_CONFLICT = 64;
  public static final int IMPORT_PACKAGE_PERMISSION = 128;
  public static final int EXPORT_PACKAGE_PERMISSION = 256;
  public static final int REQUIRE_BUNDLE_PERMISSION = 512;
  public static final int PROVIDE_BUNDLE_PERMISSION = 1024;
  public static final int HOST_BUNDLE_PERMISSION = 2048;
  public static final int FRAGMENT_BUNDLE_PERMISSION = 4096;
  public static final int PLATFORM_FILTER = 8192;
  public static final int MISSING_EXECUTION_ENVIRONMENT = 16384;
  public static final int MISSING_GENERIC_CAPABILITY = 32768;
  public static final int NO_NATIVECODE_MATCH = 65536;
  public static final int INVALID_NATIVECODE_PATHS = 131072;
  public static final int DISABLED_BUNDLE = 262144;
  public static final int REQUIRE_CAPABILITY_PERMISSION = 524288;
  public static final int PROVIDE_CAPABILITY_PERMISSION = 1048576;
  
  public abstract BundleDescription getBundle();
  
  public abstract int getType();
  
  public abstract String getData();
  
  public abstract VersionConstraint getUnsatisfiedConstraint();
}

/* Location:
 * Qualified Name:     org.eclipse.osgi.service.resolver.ResolverError
 * Java Class Version: 1.4 (48.0)
 * JD-Core Version:    0.7.1
 */
package org.eclipse.osgi.service.resolver;

public class ResolverHookException
  extends RuntimeException
{
  private static final long serialVersionUID = 5686047743173396286L;
  
  public ResolverHookException(String message, Throwable cause)
  {
    super(message, cause);
  }
}

/* Location:
 * Qualified Name:     org.eclipse.osgi.service.resolver.ResolverHookException
 * Java Class Version: 1.4 (48.0)
 * JD-Core Version:    0.7.1
 */
package org.eclipse.osgi.service.resolver;

import java.util.Collection;
import java.util.Dictionary;
import java.util.List;
import java.util.Map;
import org.osgi.framework.BundleException;
import org.osgi.framework.Version;
import org.osgi.framework.hooks.resolver.ResolverHookFactory;

public abstract interface State
{
  public abstract boolean addBundle(BundleDescription paramBundleDescription);
  
  public abstract StateDelta compare(State paramState)
    throws BundleException;
  
  public abstract BundleDescription removeBundle(long paramLong);
  
  public abstract boolean removeBundle(BundleDescription paramBundleDescription);
  
  public abstract boolean updateBundle(BundleDescription paramBundleDescription);
  
  public abstract StateDelta getChanges();
  
  public abstract BundleDescription[] getBundles();
  
  public abstract BundleDescription getBundle(long paramLong);
  
  public abstract BundleDescription getBundle(String paramString, Version paramVersion);
  
  public abstract BundleDescription getBundleByLocation(String paramString);
  
  public abstract long getTimeStamp();
  
  public abstract void setTimeStamp(long paramLong);
  
  public abstract boolean isResolved();
  
  public abstract void resolveConstraint(VersionConstraint paramVersionConstraint, BaseDescription paramBaseDescription);
  
  /**
   * @deprecated
   */
  public abstract void resolveBundle(BundleDescription paramBundleDescription, boolean paramBoolean, BundleDescription[] paramArrayOfBundleDescription1, ExportPackageDescription[] paramArrayOfExportPackageDescription1, BundleDescription[] paramArrayOfBundleDescription2, ExportPackageDescription[] paramArrayOfExportPackageDescription2);
  
  /**
   * @deprecated
   */
  public abstract void resolveBundle(BundleDescription paramBundleDescription, boolean paramBoolean, BundleDescription[] paramArrayOfBundleDescription1, ExportPackageDescription[] paramArrayOfExportPackageDescription1, ExportPackageDescription[] paramArrayOfExportPackageDescription2, BundleDescription[] paramArrayOfBundleDescription2, ExportPackageDescription[] paramArrayOfExportPackageDescription3);
  
  public abstract void resolveBundle(BundleDescription paramBundleDescription, boolean paramBoolean, BundleDescription[] paramArrayOfBundleDescription1, ExportPackageDescription[] paramArrayOfExportPackageDescription1, ExportPackageDescription[] paramArrayOfExportPackageDescription2, GenericDescription[] paramArrayOfGenericDescription1, BundleDescription[] paramArrayOfBundleDescription2, ExportPackageDescription[] paramArrayOfExportPackageDescription3, GenericDescription[] paramArrayOfGenericDescription2, Map<String, List<StateWire>> paramMap);
  
  public abstract void removeBundleComplete(BundleDescription paramBundleDescription);
  
  public abstract void addResolverError(BundleDescription paramBundleDescription, int paramInt, String paramString, VersionConstraint paramVersionConstraint);
  
  public abstract void removeResolverErrors(BundleDescription paramBundleDescription);
  
  public abstract ResolverError[] getResolverErrors(BundleDescription paramBundleDescription);
  
  public abstract Resolver getResolver();
  
  public abstract void setResolver(Resolver paramResolver);
  
  public abstract StateDelta resolve(boolean paramBoolean);
  
  public abstract StateDelta resolve();
  
  public abstract StateDelta resolve(BundleDescription[] paramArrayOfBundleDescription);
  
  public abstract StateDelta resolve(BundleDescription[] paramArrayOfBundleDescription, boolean paramBoolean);
  
  /**
   * @deprecated
   */
  public abstract void setOverrides(Object paramObject);
  
  public abstract BundleDescription[] getResolvedBundles();
  
  public abstract BundleDescription[] getRemovalPending();
  
  public abstract Collection<BundleDescription> getDependencyClosure(Collection<BundleDescription> paramCollection);
  
  public abstract boolean isEmpty();
  
  public abstract ExportPackageDescription[] getExportedPackages();
  
  public abstract BundleDescription[] getBundles(String paramString);
  
  public abstract StateObjectFactory getFactory();
  
  public abstract ExportPackageDescription linkDynamicImport(BundleDescription paramBundleDescription, String paramString);
  
  public abstract void addDynamicImportPackages(BundleDescription paramBundleDescription, ImportPackageSpecification[] paramArrayOfImportPackageSpecification);
  
  public abstract boolean setPlatformProperties(Dictionary<?, ?> paramDictionary);
  
  public abstract boolean setPlatformProperties(Dictionary<?, ?>[] paramArrayOfDictionary);
  
  public abstract Dictionary[] getPlatformProperties();
  
  public abstract ExportPackageDescription[] getSystemPackages();
  
  public abstract StateHelper getStateHelper();
  
  public abstract long getHighestBundleId();
  
  public abstract void setNativePathsInvalid(NativeCodeDescription paramNativeCodeDescription, boolean paramBoolean);
  
  public abstract BundleDescription[] getDisabledBundles();
  
  public abstract void addDisabledInfo(DisabledInfo paramDisabledInfo);
  
  public abstract void removeDisabledInfo(DisabledInfo paramDisabledInfo);
  
  public abstract DisabledInfo[] getDisabledInfos(BundleDescription paramBundleDescription);
  
  public abstract DisabledInfo getDisabledInfo(BundleDescription paramBundleDescription, String paramString);
  
  public abstract void setResolverHookFactory(ResolverHookFactory paramResolverHookFactory);
}

/* Location:
 * Qualified Name:     org.eclipse.osgi.service.resolver.State
 * Java Class Version: 1.4 (48.0)
 * JD-Core Version:    0.7.1
 */
package org.eclipse.osgi.service.resolver;

public abstract interface StateDelta
{
  public abstract BundleDelta[] getChanges();
  
  public abstract BundleDelta[] getChanges(int paramInt, boolean paramBoolean);
  
  public abstract State getState();
  
  public abstract ResolverHookException getResovlerHookException();
}

/* Location:
 * Qualified Name:     org.eclipse.osgi.service.resolver.StateDelta
 * Java Class Version: 1.4 (48.0)
 * JD-Core Version:    0.7.1
 */
package org.eclipse.osgi.service.resolver;

public abstract interface StateHelper
{
  public static final int ACCESS_ENCOURAGED = 1;
  public static final int ACCESS_DISCOURAGED = 2;
  public static final int VISIBLE_INCLUDE_EE_PACKAGES = 1;
  public static final int VISIBLE_INCLUDE_ALL_HOST_WIRES = 2;
  
  public abstract BundleDescription[] getDependentBundles(BundleDescription[] paramArrayOfBundleDescription);
  
  public abstract BundleDescription[] getPrerequisites(BundleDescription[] paramArrayOfBundleDescription);
  
  public abstract VersionConstraint[] getUnsatisfiedConstraints(BundleDescription paramBundleDescription);
  
  public abstract VersionConstraint[] getUnsatisfiedLeaves(BundleDescription[] paramArrayOfBundleDescription);
  
  public abstract boolean isResolvable(ImportPackageSpecification paramImportPackageSpecification);
  
  public abstract boolean isResolvable(BundleSpecification paramBundleSpecification);
  
  public abstract boolean isResolvable(HostSpecification paramHostSpecification);
  
  public abstract Object[][] sortBundles(BundleDescription[] paramArrayOfBundleDescription);
  
  public abstract ExportPackageDescription[] getVisiblePackages(BundleDescription paramBundleDescription);
  
  public abstract ExportPackageDescription[] getVisiblePackages(BundleDescription paramBundleDescription, int paramInt);
  
  public abstract int getAccessCode(BundleDescription paramBundleDescription, ExportPackageDescription paramExportPackageDescription);
}

/* Location:
 * Qualified Name:     org.eclipse.osgi.service.resolver.StateHelper
 * Java Class Version: 1.4 (48.0)
 * JD-Core Version:    0.7.1
 */
package org.eclipse.osgi.service.resolver;

import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.File;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.util.Dictionary;
import java.util.Map;
import org.eclipse.osgi.internal.resolver.StateObjectFactoryImpl;
import org.osgi.framework.BundleException;
import org.osgi.framework.InvalidSyntaxException;
import org.osgi.framework.Version;

public abstract interface StateObjectFactory
{
  public static final StateObjectFactory defaultFactory = new StateObjectFactoryImpl();
  
  /**
   * @deprecated
   */
  public abstract State createState();
  
  public abstract State createState(boolean paramBoolean);
  
  public abstract State createState(State paramState);
  
  /**
   * @deprecated
   */
  public abstract BundleDescription createBundleDescription(long paramLong, String paramString1, Version paramVersion, String paramString2, BundleSpecification[] paramArrayOfBundleSpecification, HostSpecification paramHostSpecification, ImportPackageSpecification[] paramArrayOfImportPackageSpecification, ExportPackageDescription[] paramArrayOfExportPackageDescription, String[] paramArrayOfString, boolean paramBoolean);
  
  /**
   * @deprecated
   */
  public abstract BundleDescription createBundleDescription(long paramLong, String paramString1, Version paramVersion, String paramString2, BundleSpecification[] paramArrayOfBundleSpecification, HostSpecification paramHostSpecification, ImportPackageSpecification[] paramArrayOfImportPackageSpecification, ExportPackageDescription[] paramArrayOfExportPackageDescription, String[] paramArrayOfString, boolean paramBoolean1, boolean paramBoolean2, boolean paramBoolean3, String paramString3, String paramString4, GenericSpecification[] paramArrayOfGenericSpecification, GenericDescription[] paramArrayOfGenericDescription);
  
  public abstract BundleDescription createBundleDescription(long paramLong, String paramString1, Version paramVersion, String paramString2, BundleSpecification[] paramArrayOfBundleSpecification, HostSpecification paramHostSpecification, ImportPackageSpecification[] paramArrayOfImportPackageSpecification, ExportPackageDescription[] paramArrayOfExportPackageDescription, boolean paramBoolean1, boolean paramBoolean2, boolean paramBoolean3, String paramString3, String[] paramArrayOfString, GenericSpecification[] paramArrayOfGenericSpecification, GenericDescription[] paramArrayOfGenericDescription);
  
  public abstract BundleDescription createBundleDescription(long paramLong, String paramString1, Version paramVersion, String paramString2, BundleSpecification[] paramArrayOfBundleSpecification, HostSpecification paramHostSpecification, ImportPackageSpecification[] paramArrayOfImportPackageSpecification, ExportPackageDescription[] paramArrayOfExportPackageDescription, boolean paramBoolean1, boolean paramBoolean2, boolean paramBoolean3, String paramString3, String[] paramArrayOfString, GenericSpecification[] paramArrayOfGenericSpecification, GenericDescription[] paramArrayOfGenericDescription, NativeCodeSpecification paramNativeCodeSpecification);
  
  public abstract BundleDescription createBundleDescription(State paramState, Dictionary<String, String> paramDictionary, String paramString, long paramLong)
    throws BundleException;
  
  /**
   * @deprecated
   */
  public abstract BundleDescription createBundleDescription(Dictionary<String, String> paramDictionary, String paramString, long paramLong)
    throws BundleException;
  
  public abstract BundleDescription createBundleDescription(BundleDescription paramBundleDescription);
  
  public abstract BundleSpecification createBundleSpecification(String paramString, VersionRange paramVersionRange, boolean paramBoolean1, boolean paramBoolean2);
  
  public abstract BundleSpecification createBundleSpecification(BundleSpecification paramBundleSpecification);
  
  public abstract HostSpecification createHostSpecification(String paramString, VersionRange paramVersionRange);
  
  public abstract HostSpecification createHostSpecification(HostSpecification paramHostSpecification);
  
  public abstract ImportPackageSpecification createImportPackageSpecification(String paramString1, VersionRange paramVersionRange1, String paramString2, VersionRange paramVersionRange2, Map<String, ?> paramMap1, Map<String, ?> paramMap2, BundleDescription paramBundleDescription);
  
  public abstract ImportPackageSpecification createImportPackageSpecification(ImportPackageSpecification paramImportPackageSpecification);
  
  public abstract ExportPackageDescription createExportPackageDescription(String paramString, Version paramVersion, Map<String, ?> paramMap1, Map<String, ?> paramMap2, boolean paramBoolean, BundleDescription paramBundleDescription);
  
  /**
   * @deprecated
   */
  public abstract GenericDescription createGenericDescription(String paramString1, String paramString2, Version paramVersion, Map<String, ?> paramMap);
  
  public abstract GenericDescription createGenericDescription(String paramString, Map<String, ?> paramMap, Map<String, String> paramMap1, BundleDescription paramBundleDescription);
  
  public abstract GenericSpecification createGenericSpecification(String paramString1, String paramString2, String paramString3, boolean paramBoolean1, boolean paramBoolean2)
    throws InvalidSyntaxException;
  
  public abstract NativeCodeSpecification createNativeCodeSpecification(NativeCodeDescription[] paramArrayOfNativeCodeDescription, boolean paramBoolean);
  
  public abstract NativeCodeDescription createNativeCodeDescription(String[] paramArrayOfString1, String[] paramArrayOfString2, String[] paramArrayOfString3, VersionRange[] paramArrayOfVersionRange, String[] paramArrayOfString4, String paramString)
    throws InvalidSyntaxException;
  
  public abstract ExportPackageDescription createExportPackageDescription(ExportPackageDescription paramExportPackageDescription);
  
  /**
   * @deprecated
   */
  public abstract void writeState(State paramState, OutputStream paramOutputStream)
    throws IOException;
  
  /**
   * @deprecated
   */
  public abstract void writeState(State paramState, DataOutputStream paramDataOutputStream)
    throws IOException;
  
  public abstract void writeState(State paramState, File paramFile)
    throws IOException;
  
  /**
   * @deprecated
   */
  public abstract State readState(InputStream paramInputStream)
    throws IOException;
  
  /**
   * @deprecated
   */
  public abstract State readState(DataInputStream paramDataInputStream)
    throws IOException;
  
  public abstract State readState(File paramFile)
    throws IOException;
}

/* Location:
 * Qualified Name:     org.eclipse.osgi.service.resolver.StateObjectFactory
 * Java Class Version: 1.4 (48.0)
 * JD-Core Version:    0.7.1
 */
package org.eclipse.osgi.service.resolver;

public class StateWire
{
  private final BundleDescription requirementHost;
  private final VersionConstraint declaredRequirement;
  private final BundleDescription capabilityHost;
  private final BaseDescription declaredCapability;
  
  public StateWire(BundleDescription requirementHost, VersionConstraint declaredRequirement, BundleDescription capabilityHost, BaseDescription declaredCapability)
  {
    this.requirementHost = requirementHost;
    this.declaredRequirement = declaredRequirement;
    this.capabilityHost = capabilityHost;
    this.declaredCapability = declaredCapability;
  }
  
  public BundleDescription getRequirementHost()
  {
    return requirementHost;
  }
  
  public VersionConstraint getDeclaredRequirement()
  {
    return declaredRequirement;
  }
  
  public BundleDescription getCapabilityHost()
  {
    return capabilityHost;
  }
  
  public BaseDescription getDeclaredCapability()
  {
    return declaredCapability;
  }
}

/* Location:
 * Qualified Name:     org.eclipse.osgi.service.resolver.StateWire
 * Java Class Version: 1.4 (48.0)
 * JD-Core Version:    0.7.1
 */
package org.eclipse.osgi.service.resolver;

import org.osgi.framework.wiring.BundleRequirement;

public abstract interface VersionConstraint
  extends Cloneable
{
  public abstract String getName();
  
  public abstract VersionRange getVersionRange();
  
  public abstract BundleDescription getBundle();
  
  public abstract boolean isResolved();
  
  public abstract boolean isSatisfiedBy(BaseDescription paramBaseDescription);
  
  public abstract BaseDescription getSupplier();
  
  public abstract BundleRequirement getRequirement();
}

/* Location:
 * Qualified Name:     org.eclipse.osgi.service.resolver.VersionConstraint
 * Java Class Version: 1.4 (48.0)
 * JD-Core Version:    0.7.1
 */
package org.eclipse.osgi.service.resolver;

import org.osgi.framework.Version;

public class VersionRange
{
  private static final Version versionMax = new Version(Integer.MAX_VALUE, Integer.MAX_VALUE, Integer.MAX_VALUE);
  public static final VersionRange emptyRange = new VersionRange(null);
  private final Version minVersion;
  private final boolean includeMin;
  private final Version maxVersion;
  private final boolean includeMax;
  
  public VersionRange(Version minVersion, boolean includeMin, Version maxVersion, boolean includeMax)
  {
    this.minVersion = (minVersion == null ? Version.emptyVersion : minVersion);
    this.includeMin = includeMin;
    this.maxVersion = (maxVersion == null ? versionMax : maxVersion);
    this.includeMax = includeMax;
  }
  
  public VersionRange(String versionRange)
  {
    if ((versionRange == null) || (versionRange.length() == 0))
    {
      minVersion = Version.emptyVersion;
      includeMin = true;
      maxVersion = versionMax;
      includeMax = true;
      return;
    }
    versionRange = versionRange.trim();
    if ((versionRange.charAt(0) == '[') || (versionRange.charAt(0) == '('))
    {
      int comma = versionRange.indexOf(',');
      if (comma < 0) {
        throw new IllegalArgumentException();
      }
      char last = versionRange.charAt(versionRange.length() - 1);
      if ((last != ']') && (last != ')')) {
        throw new IllegalArgumentException();
      }
      minVersion = Version.parseVersion(versionRange.substring(1, comma).trim());
      includeMin = (versionRange.charAt(0) == '[');
      maxVersion = Version.parseVersion(versionRange.substring(comma + 1, versionRange.length() - 1).trim());
      includeMax = (last == ']');
    }
    else
    {
      minVersion = Version.parseVersion(versionRange.trim());
      includeMin = true;
      maxVersion = versionMax;
      includeMax = true;
    }
  }
  
  public Version getMinimum()
  {
    return minVersion;
  }
  
  public boolean getIncludeMinimum()
  {
    return includeMin;
  }
  
  public Version getMaximum()
  {
    return maxVersion;
  }
  
  public boolean getIncludeMaximum()
  {
    return includeMax;
  }
  
  public boolean isIncluded(Version version)
  {
    if (version == null) {
      version = Version.emptyVersion;
    }
    int minCheck = includeMin ? 0 : 1;
    int maxCheck = includeMax ? 0 : -1;
    return (version.compareTo(minVersion) >= minCheck) && (version.compareTo(maxVersion) <= maxCheck);
  }
  
  public boolean equals(Object object)
  {
    if (!(object instanceof VersionRange)) {
      return false;
    }
    VersionRange vr = (VersionRange)object;
    if ((minVersion.equals(vr.getMinimum())) && (includeMin == includeMin) && 
      (maxVersion.equals(vr.getMaximum())) && (includeMax == includeMax)) {
      return true;
    }
    return false;
  }
  
  public int hashCode()
  {
    int result = 1;
    result = 31 * result + maxVersion.hashCode();
    result = 31 * result + minVersion.hashCode();
    result = 31 * result + (includeMax ? 1231 : 1237);
    result = 31 * result + (includeMin ? 1231 : 1237);
    return result;
  }
  
  public String toString()
  {
    if (versionMax.equals(maxVersion)) {
      return minVersion.toString();
    }
    StringBuffer result = new StringBuffer();
    result.append(includeMin ? '[' : '(');
    result.append(minVersion);
    result.append(',');
    result.append(maxVersion);
    result.append(includeMax ? ']' : ')');
    return result.toString();
  }
}

/* Location:
 * Qualified Name:     org.eclipse.osgi.service.resolver.VersionRange
 * Java Class Version: 1.4 (48.0)
 * JD-Core Version:    0.7.1
 */
package org.eclipse.osgi.service.runnable;

public abstract interface ApplicationLauncher
{
  public abstract void launch(ParameterizedRunnable paramParameterizedRunnable, Object paramObject);
  
  public abstract void shutdown();
}

/* Location:
 * Qualified Name:     org.eclipse.osgi.service.runnable.ApplicationLauncher
 * Java Class Version: 1.4 (48.0)
 * JD-Core Version:    0.7.1
 */
package org.eclipse.osgi.service.runnable;

public abstract interface ApplicationRunnable
  extends ParameterizedRunnable
{
  public abstract void stop();
}

/* Location:
 * Qualified Name:     org.eclipse.osgi.service.runnable.ApplicationRunnable
 * Java Class Version: 1.4 (48.0)
 * JD-Core Version:    0.7.1
 */
package org.eclipse.osgi.service.runnable;

public abstract interface ParameterizedRunnable
{
  public abstract Object run(Object paramObject)
    throws Exception;
}

/* Location:
 * Qualified Name:     org.eclipse.osgi.service.runnable.ParameterizedRunnable
 * Java Class Version: 1.4 (48.0)
 * JD-Core Version:    0.7.1
 */
package org.eclipse.osgi.service.runnable;

public abstract interface StartupMonitor
{
  public abstract void update();
  
  public abstract void applicationRunning();
}

/* Location:
 * Qualified Name:     org.eclipse.osgi.service.runnable.StartupMonitor
 * Java Class Version: 1.4 (48.0)
 * JD-Core Version:    0.7.1
 */
package org.eclipse.osgi.service.security;

import java.io.IOException;
import java.security.GeneralSecurityException;
import java.security.cert.Certificate;
import org.eclipse.osgi.internal.signedcontent.TrustEngineListener;

public abstract class TrustEngine
{
  public abstract Certificate findTrustAnchor(Certificate[] paramArrayOfCertificate)
    throws IOException;
  
  public String addTrustAnchor(Certificate anchor, String alias)
    throws IOException, GeneralSecurityException
  {
    String storedAlias = doAddTrustAnchor(anchor, alias);
    TrustEngineListener listener = TrustEngineListener.getInstance();
    if (listener != null) {
      listener.addedTrustAnchor(anchor);
    }
    return storedAlias;
  }
  
  protected abstract String doAddTrustAnchor(Certificate paramCertificate, String paramString)
    throws IOException, GeneralSecurityException;
  
  public final void removeTrustAnchor(Certificate anchor)
    throws IOException, GeneralSecurityException
  {
    doRemoveTrustAnchor(anchor);
    TrustEngineListener listener = TrustEngineListener.getInstance();
    if (listener != null) {
      listener.removedTrustAnchor(anchor);
    }
  }
  
  protected abstract void doRemoveTrustAnchor(Certificate paramCertificate)
    throws IOException, GeneralSecurityException;
  
  public void removeTrustAnchor(String alias)
    throws IOException, GeneralSecurityException
  {
    Certificate existing = getTrustAnchor(alias);
    doRemoveTrustAnchor(alias);
    if (existing != null)
    {
      TrustEngineListener listener = TrustEngineListener.getInstance();
      if (listener != null) {
        listener.removedTrustAnchor(existing);
      }
    }
  }
  
  protected abstract void doRemoveTrustAnchor(String paramString)
    throws IOException, GeneralSecurityException;
  
  public abstract Certificate getTrustAnchor(String paramString)
    throws IOException, GeneralSecurityException;
  
  public abstract String[] getAliases()
    throws IOException, GeneralSecurityException;
  
  public abstract boolean isReadOnly();
  
  public abstract String getName();
}

/* Location:
 * Qualified Name:     org.eclipse.osgi.service.security.TrustEngine
 * Java Class Version: 1.4 (48.0)
 * JD-Core Version:    0.7.1
 */
package org.eclipse.osgi.service.urlconversion;

import java.io.IOException;
import java.net.URL;

public abstract interface URLConverter
{
  public abstract URL toFileURL(URL paramURL)
    throws IOException;
  
  public abstract URL resolve(URL paramURL)
    throws IOException;
}

/* Location:
 * Qualified Name:     org.eclipse.osgi.service.urlconversion.URLConverter
 * Java Class Version: 1.4 (48.0)
 * JD-Core Version:    0.7.1
 */
package org.eclipse.osgi.signedcontent;

import java.io.IOException;

public class InvalidContentException
  extends IOException
{
  private static final long serialVersionUID = -399150159330289387L;
  private final Throwable cause;
  
  public InvalidContentException(String message, Throwable cause)
  {
    super(message);
    this.cause = cause;
  }
  
  public Throwable getCause()
  {
    return cause;
  }
  
  public Throwable initCause(Throwable t)
  {
    throw new IllegalStateException();
  }
}

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

import java.security.cert.CertificateExpiredException;
import java.security.cert.CertificateNotYetValidException;
import java.util.Date;

public abstract interface SignedContent
{
  public abstract SignedContentEntry[] getSignedEntries();
  
  public abstract SignedContentEntry getSignedEntry(String paramString);
  
  public abstract SignerInfo[] getSignerInfos();
  
  public abstract boolean isSigned();
  
  public abstract Date getSigningTime(SignerInfo paramSignerInfo);
  
  public abstract SignerInfo getTSASignerInfo(SignerInfo paramSignerInfo);
  
  public abstract void checkValidity(SignerInfo paramSignerInfo)
    throws CertificateExpiredException, CertificateNotYetValidException;
}

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

import java.io.IOException;

public abstract interface SignedContentEntry
{
  public abstract String getName();
  
  public abstract SignerInfo[] getSignerInfos();
  
  public abstract boolean isSigned();
  
  public abstract void verify()
    throws IOException, InvalidContentException;
}

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

import java.io.File;
import java.io.IOException;
import java.security.InvalidKeyException;
import java.security.NoSuchAlgorithmException;
import java.security.NoSuchProviderException;
import java.security.SignatureException;
import java.security.cert.CertificateException;
import org.osgi.framework.Bundle;

public abstract interface SignedContentFactory
{
  public abstract SignedContent getSignedContent(File paramFile)
    throws IOException, InvalidKeyException, SignatureException, CertificateException, NoSuchAlgorithmException, NoSuchProviderException;
  
  public abstract SignedContent getSignedContent(Bundle paramBundle)
    throws IOException, InvalidKeyException, SignatureException, CertificateException, NoSuchAlgorithmException, NoSuchProviderException;
}

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

import java.security.cert.Certificate;

public abstract interface SignerInfo
{
  public abstract Certificate[] getCertificateChain();
  
  public abstract Certificate getTrustAnchor();
  
  public abstract boolean isTrusted();
  
  public abstract String getMessageDigestAlgorithm();
}

/* Location:
 * Qualified Name:     org.eclipse.osgi.signedcontent.SignerInfo
 * Java Class Version: 1.4 (48.0)
 * JD-Core Version:    0.7.1
 */
package org.eclipse.osgi.storagemanager;

import java.io.File;
import java.io.FilterOutputStream;
import java.io.IOException;
import java.io.OutputStream;

public final class ManagedOutputStream
  extends FilterOutputStream
{
  static final int ST_OPEN = 0;
  static final int ST_CLOSED = 1;
  private String target;
  private StorageManager manager;
  private File outputFile;
  private int state;
  private ManagedOutputStream[] streamSet = null;
  
  ManagedOutputStream(OutputStream out, StorageManager manager, String target, File outputFile)
  {
    super(out);
    this.manager = manager;
    this.target = target;
    this.outputFile = outputFile;
    state = 0;
  }
  
  public void close()
    throws IOException
  {
    manager.closeOutputStream(this);
  }
  
  public void abort()
  {
    manager.abortOutputStream(this);
  }
  
  OutputStream getOutputStream()
  {
    return out;
  }
  
  String getTarget()
  {
    return target;
  }
  
  File getOutputFile()
  {
    return outputFile;
  }
  
  int getState()
  {
    return state;
  }
  
  void setState(int state)
  {
    this.state = state;
  }
  
  void setStreamSet(ManagedOutputStream[] set)
  {
    streamSet = set;
  }
  
  ManagedOutputStream[] getStreamSet()
  {
    return streamSet;
  }
  
  public void write(byte[] bytes, int off, int len)
    throws IOException
  {
    out.write(bytes, off, len);
  }
}

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

class StorageManager$Entry
{
  int readId;
  int writeId;
  int fileType;
  final StorageManager this$0;
  
  StorageManager$Entry(StorageManager paramStorageManager, int readId, int writeId, int type)
  {
    this.readId = readId;
    this.writeId = writeId;
    fileType = type;
  }
  
  int getReadId()
  {
    return readId;
  }
  
  int getWriteId()
  {
    return writeId;
  }
  
  int getFileType()
  {
    return fileType;
  }
  
  void setReadId(int value)
  {
    readId = value;
  }
  
  void setWriteId(int value)
  {
    writeId = value;
  }
  
  void setFileType(int type)
  {
    fileType = type;
  }
}

/* Location:
 * Qualified Name:     org.eclipse.osgi.storagemanager.StorageManager.Entry
 * Java Class Version: 1.4 (48.0)
 * JD-Core Version:    0.7.1
 */
package org.eclipse.osgi.storagemanager;

import java.io.File;
import java.io.FileDescriptor;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.PrintStream;
import java.io.SyncFailedException;
import java.security.AccessController;
import java.util.Collection;
import java.util.Enumeration;
import java.util.Iterator;
import java.util.Map.Entry;
import java.util.Properties;
import java.util.Set;
import org.eclipse.core.runtime.internal.adaptor.BasicLocation;
import org.eclipse.core.runtime.internal.adaptor.EclipseAdaptorMsg;
import org.eclipse.core.runtime.internal.adaptor.Locker;
import org.eclipse.osgi.framework.internal.reliablefile.ReliableFile;
import org.eclipse.osgi.framework.internal.reliablefile.ReliableFileInputStream;
import org.eclipse.osgi.framework.internal.reliablefile.ReliableFileOutputStream;
import org.eclipse.osgi.framework.util.SecureAction;

public final class StorageManager
{
  private static final int FILETYPE_STANDARD = 0;
  private static final int FILETYPE_RELIABLEFILE = 1;
  private static final SecureAction secure = (SecureAction)AccessController.doPrivileged(SecureAction.createSecureAction());
  private static final String MANAGER_FOLDER = ".manager";
  private static final String TABLE_FILE = ".fileTable";
  private static final String LOCK_FILE = ".fileTableLock";
  private static final int MAX_LOCK_WAIT = 5000;
  private final boolean useReliableFiles = Boolean.valueOf(secure.getProperty("osgi.useReliableFiles")).booleanValue();
  private final boolean tempCleanup = Boolean.valueOf(secure.getProperty("osgi.embedded.cleanTempFiles")).booleanValue();
  private final boolean openCleanup = Boolean.valueOf(secure.getProperty("osgi.embedded.cleanupOnOpen")).booleanValue();
  private final boolean saveCleanup = Boolean.valueOf(secure.getProperty("osgi.embedded.cleanupOnSave")).booleanValue();
  private final File base;
  private final File managerRoot;
  private final String lockMode;
  private final File tableFile;
  private final File lockFile;
  private Locker locker;
  private File instanceFile;
  
  private class Entry
  {
    int readId;
    int writeId;
    int fileType;
    
    Entry(int readId, int writeId, int type)
    {
      this.readId = readId;
      this.writeId = writeId;
      fileType = type;
    }
    
    int getReadId()
    {
      return readId;
    }
    
    int getWriteId()
    {
      return writeId;
    }
    
    int getFileType()
    {
      return fileType;
    }
    
    void setReadId(int value)
    {
      readId = value;
    }
    
    void setWriteId(int value)
    {
      writeId = value;
    }
    
    void setFileType(int type)
    {
      fileType = type;
    }
  }
  
  private Locker instanceLocker = null;
  private final boolean readOnly;
  private boolean open;
  private int tableStamp = -1;
  private final Properties table = new Properties();
  
  public StorageManager(File base, String lockMode)
  {
    this(base, lockMode, false);
  }
  
  public StorageManager(File base, String lockMode, boolean readOnly)
  {
    this.base = base;
    this.lockMode = lockMode;
    managerRoot = new File(base, ".manager");
    tableFile = new File(managerRoot, ".fileTable");
    lockFile = new File(managerRoot, ".fileTableLock");
    this.readOnly = readOnly;
    open = false;
  }
  
  private void initializeInstanceFile()
    throws IOException
  {
    if ((instanceFile != null) || (readOnly)) {
      return;
    }
    instanceFile = File.createTempFile(".tmp", ".instance", managerRoot);
    instanceFile.deleteOnExit();
    instanceLocker = BasicLocation.createLocker(instanceFile, lockMode);
    instanceLocker.lock();
  }
  
  private String getAbsolutePath(String file)
  {
    return new File(base, file).getAbsolutePath();
  }
  
  public void add(String managedFile)
    throws IOException
  {
    add(managedFile, 0);
  }
  
  /* Error */
  private void add(String managedFile, int fileType)
    throws IOException
  {
    // Byte code:
    //   0: aload_0
    //   1: getfield 501	org/eclipse/osgi/storagemanager/StorageManager:open	Z
    //   4: ifne +14 -> 18
    //   7: new 261	java/io/IOException
    //   10: dup
    //   11: getstatic 498	org/eclipse/core/runtime/internal/adaptor/EclipseAdaptorMsg:fileManager_notOpen	Ljava/lang/String;
    //   14: invokespecial 533	java/io/IOException:<init>	(Ljava/lang/String;)V
    //   17: athrow
    //   18: aload_0
    //   19: getfield 503	org/eclipse/osgi/storagemanager/StorageManager:readOnly	Z
    //   22: ifeq +14 -> 36
    //   25: new 261	java/io/IOException
    //   28: dup
    //   29: getstatic 497	org/eclipse/core/runtime/internal/adaptor/EclipseAdaptorMsg:fileManager_illegalInReadOnlyMode	Ljava/lang/String;
    //   32: invokespecial 533	java/io/IOException:<init>	(Ljava/lang/String;)V
    //   35: athrow
    //   36: aload_0
    //   37: iconst_1
    //   38: invokespecial 597	org/eclipse/osgi/storagemanager/StorageManager:lock	(Z)Z
    //   41: ifne +14 -> 55
    //   44: new 261	java/io/IOException
    //   47: dup
    //   48: getstatic 496	org/eclipse/core/runtime/internal/adaptor/EclipseAdaptorMsg:fileManager_cannotLock	Ljava/lang/String;
    //   51: invokespecial 533	java/io/IOException:<init>	(Ljava/lang/String;)V
    //   54: athrow
    //   55: aload_0
    //   56: invokespecial 595	org/eclipse/osgi/storagemanager/StorageManager:updateTable	()V
    //   59: aload_0
    //   60: getfield 513	org/eclipse/osgi/storagemanager/StorageManager:table	Ljava/util/Properties;
    //   63: aload_1
    //   64: invokevirtual 566	java/util/Properties:get	(Ljava/lang/Object;)Ljava/lang/Object;
    //   67: checkcast 292	org/eclipse/osgi/storagemanager/StorageManager$Entry
    //   70: astore_3
    //   71: aload_3
    //   72: ifnonnull +52 -> 124
    //   75
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

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-2017. Infinite Loop Ltd