org.eclipse.osgi_3.8.2.v20130124-134944

nchronized Enumeration<Permission> elements()
  {
    List<Permission> all = new ArrayList(permissions.values());
    Map<String, ServicePermission> pc = filterPermissions;
    if (pc != null) {
      all.addAll(pc.values());
    }
    return Collections.enumeration(all);
  }
  
  private static final ObjectStreamField[] serialPersistentFields = { new ObjectStreamField("permissions", Hashtable.class), new ObjectStreamField("all_allowed", Boolean.TYPE), 
    new ObjectStreamField("filterPermissions", HashMap.class) };
  
  private synchronized void writeObject(ObjectOutputStream out)
    throws IOException
  {
    Hashtable<String, ServicePermission> hashtable = new Hashtable(permissions);
    ObjectOutputStream.PutField pfields = out.putFields();
    pfields.put("permissions", hashtable);
    pfields.put("all_allowed", all_allowed);
    pfields.put("filterPermissions", filterPermissions);
    out.writeFields();
  }
  
  private synchronized void readObject(ObjectInputStream in)
    throws IOException, ClassNotFoundException
  {
    ObjectInputStream.GetField gfields = in.readFields();
    Hashtable<String, ServicePermission> hashtable = (Hashtable)gfields.get("permissions", null);
    permissions = new HashMap(hashtable);
    all_allowed = gfields.get("all_allowed", false);
    HashMap<String, ServicePermission> fp = (HashMap)gfields.get("filterPermissions", null);
    filterPermissions = fp;
  }
}

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

public abstract interface ServiceReference<S>
  extends Comparable<Object>
{
  public abstract Object getProperty(String paramString);
  
  public abstract String[] getPropertyKeys();
  
  public abstract Bundle getBundle();
  
  public abstract Bundle[] getUsingBundles();
  
  public abstract boolean isAssignableTo(Bundle paramBundle, String paramString);
  
  public abstract int compareTo(Object paramObject);
}

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

import java.util.Dictionary;

public abstract interface ServiceRegistration<S>
{
  public abstract ServiceReference<S> getReference();
  
  public abstract void setProperties(Dictionary<String, ?> paramDictionary);
  
  public abstract void unregister();
}

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

import java.security.Principal;
import java.security.cert.X509Certificate;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;
import java.util.List;
import java.util.Map;

final class SignerProperty
{
  private final Bundle bundle;
  private final String pattern;
  
  public SignerProperty(String pattern)
  {
    this.pattern = pattern;
    bundle = null;
  }
  
  SignerProperty(Bundle bundle)
  {
    this.bundle = bundle;
    pattern = null;
  }
  
  public boolean equals(Object o)
  {
    if (!(o instanceof SignerProperty)) {
      return false;
    }
    SignerProperty other = (SignerProperty)o;
    Bundle matchBundle = bundle != null ? bundle : bundle;
    String matchPattern = bundle != null ? pattern : pattern;
    Map<X509Certificate, List<X509Certificate>> signers = matchBundle.getSignerCertificates(2);
    for (Iterator localIterator1 = signers.values().iterator(); localIterator1.hasNext();)
    {
      List<X509Certificate> signerCerts = (List)localIterator1.next();
      List<String> dnChain = new ArrayList(signerCerts.size());
      for (Iterator localIterator2 = signerCerts.iterator(); localIterator2.hasNext();)
      {
        X509Certificate signerCert = (X509Certificate)localIterator2.next();
        dnChain.add(signerCert.getSubjectDN().getName());
      }
      try
      {
        if (FrameworkUtil.matchDistinguishedNameChain(matchPattern, dnChain)) {
          return true;
        }
      }
      catch (IllegalArgumentException localIllegalArgumentException) {}
    }
    return false;
  }
  
  public int hashCode()
  {
    return 31;
  }
  
  boolean isBundleSigned()
  {
    if (bundle == null) {
      return false;
    }
    Map<X509Certificate, List<X509Certificate>> signers = bundle.getSignerCertificates(2);
    return !signers.isEmpty();
  }
}

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

public abstract interface SynchronousBundleListener
  extends BundleListener
{}

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

public abstract interface UnfilteredServiceListener
  extends ServiceListener
{}

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

import java.util.NoSuchElementException;
import java.util.StringTokenizer;

public class Version
  implements Comparable<Version>
{
  private final int major;
  private final int minor;
  private final int micro;
  private final String qualifier;
  private static final String SEPARATOR = ".";
  private transient String versionString;
  private transient int hash;
  public static final Version emptyVersion = new Version(0, 0, 0);
  
  public Version(int major, int minor, int micro)
  {
    this(major, minor, micro, null);
  }
  
  public Version(int major, int minor, int micro, String qualifier)
  {
    if (qualifier == null) {
      qualifier = "";
    }
    this.major = major;
    this.minor = minor;
    this.micro = micro;
    this.qualifier = qualifier;
    validate();
  }
  
  public Version(String version)
  {
    int maj = 0;
    int min = 0;
    int mic = 0;
    String qual = "";
    try
    {
      StringTokenizer st = new StringTokenizer(version, ".", true);
      maj = parseInt(st.nextToken(), version);
      if (st.hasMoreTokens())
      {
        st.nextToken();
        min = parseInt(st.nextToken(), version);
        if (st.hasMoreTokens())
        {
          st.nextToken();
          mic = parseInt(st.nextToken(), version);
          if (st.hasMoreTokens())
          {
            st.nextToken();
            qual = st.nextToken("");
            if (st.hasMoreTokens()) {
              throw new IllegalArgumentException("invalid version \"" + version + "\": invalid format");
            }
          }
        }
      }
    }
    catch (NoSuchElementException e)
    {
      IllegalArgumentException iae = new IllegalArgumentException("invalid version \"" + version + "\": invalid format");
      iae.initCause(e);
      throw iae;
    }
    major = maj;
    minor = min;
    micro = mic;
    qualifier = qual;
    validate();
  }
  
  private static int parseInt(String value, String version)
  {
    try
    {
      return Integer.parseInt(value);
    }
    catch (NumberFormatException e)
    {
      IllegalArgumentException iae = new IllegalArgumentException("invalid version \"" + version + "\": non-numeric \"" + value + "\"");
      iae.initCause(e);
      throw iae;
    }
  }
  
  private void validate()
  {
    if (major < 0) {
      throw new IllegalArgumentException("invalid version \"" + toString0() + "\": negative number \"" + major + "\"");
    }
    if (minor < 0) {
      throw new IllegalArgumentException("invalid version \"" + toString0() + "\": negative number \"" + minor + "\"");
    }
    if (micro < 0) {
      throw new IllegalArgumentException("invalid version \"" + toString0() + "\": negative number \"" + micro + "\"");
    }
    char[] arrayOfChar;
    int j = (arrayOfChar = qualifier.toCharArray()).length;
    for (int i = 0; i < j; i++)
    {
      char ch = arrayOfChar[i];
      if (('A' > ch) || (ch > 'Z')) {
        if (('a' > ch) || (ch > 'z')) {
          if (('0' > ch) || (ch > '9')) {
            if ((ch != '_') && (ch != '-')) {
              throw new IllegalArgumentException("invalid version \"" + toString0() + "\": invalid qualifier \"" + qualifier + "\"");
            }
          }
        }
      }
    }
  }
  
  public static Version parseVersion(String version)
  {
    if (version == null) {
      return emptyVersion;
    }
    version = version.trim();
    if (version.length() == 0) {
      return emptyVersion;
    }
    return new Version(version);
  }
  
  public int getMajor()
  {
    return major;
  }
  
  public int getMinor()
  {
    return minor;
  }
  
  public int getMicro()
  {
    return micro;
  }
  
  public String getQualifier()
  {
    return qualifier;
  }
  
  public String toString()
  {
    return toString0();
  }
  
  String toString0()
  {
    if (versionString != null) {
      return versionString;
    }
    int q = qualifier.length();
    StringBuffer result = new StringBuffer(20 + q);
    result.append(major);
    result.append(".");
    result.append(minor);
    result.append(".");
    result.append(micro);
    if (q > 0)
    {
      result.append(".");
      result.append(qualifier);
    }
    return versionString = result.toString();
  }
  
  public int hashCode()
  {
    if (hash != 0) {
      return hash;
    }
    int h = 527;
    h = 31 * h + major;
    h = 31 * h + minor;
    h = 31 * h + micro;
    h = 31 * h + qualifier.hashCode();
    return hash = h;
  }
  
  public boolean equals(Object object)
  {
    if (object == this) {
      return true;
    }
    if (!(object instanceof Version)) {
      return false;
    }
    Version other = (Version)object;
    return (major == major) && (minor == minor) && (micro == micro) && (qualifier.equals(qualifier));
  }
  
  public int compareTo(Version other)
  {
    if (other == this) {
      return 0;
    }
    int result = major - major;
    if (result != 0) {
      return result;
    }
    result = minor - minor;
    if (result != 0) {
      return result;
    }
    result = micro - micro;
    if (result != 0) {
      return result;
    }
    return qualifier.compareTo(qualifier);
  }
}

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

import java.util.NoSuchElementException;
import java.util.StringTokenizer;

public class VersionRange
{
  public static final char LEFT_OPEN = '(';
  public static final char LEFT_CLOSED = '[';
  public static final char RIGHT_OPEN = ')';
  public static final char RIGHT_CLOSED = ']';
  private final boolean leftClosed;
  private final Version left;
  private final Version right;
  private final boolean rightClosed;
  private final boolean empty;
  private transient String versionRangeString;
  private transient int hash;
  private static final String LEFT_OPEN_DELIMITER = "(";
  private static final String LEFT_CLOSED_DELIMITER = "[";
  private static final String LEFT_DELIMITERS = "[(";
  private static final String RIGHT_OPEN_DELIMITER = ")";
  private static final String RIGHT_CLOSED_DELIMITER = "]";
  private static final String RIGHT_DELIMITERS = ")]";
  private static final String ENDPOINT_DELIMITER = ",";
  
  public VersionRange(char leftType, Version leftEndpoint, Version rightEndpoint, char rightType)
  {
    if ((leftType != '[') && (leftType != '(')) {
      throw new IllegalArgumentException("invalid leftType \"" + leftType + "\"");
    }
    if ((rightType != ')') && (rightType != ']')) {
      throw new IllegalArgumentException("invalid rightType \"" + rightType + "\"");
    }
    if (leftEndpoint == null) {
      throw new IllegalArgumentException("null leftEndpoint argument");
    }
    leftClosed = (leftType == '[');
    rightClosed = (rightType == ']');
    left = leftEndpoint;
    right = rightEndpoint;
    empty = isEmpty0();
  }
  
  public VersionRange(String range)
  {
    try
    {
      StringTokenizer st = new StringTokenizer(range, "[(", true);
      String token = st.nextToken().trim();
      if (token.length() == 0) {
        token = st.nextToken();
      }
      boolean closedLeft = "[".equals(token);
      if ((!closedLeft) && (!"(".equals(token)))
      {
        if (st.hasMoreTokens()) {
          throw new IllegalArgumentException("invalid range \"" + range + "\": invalid format");
        }
        leftClosed = true;
        rightClosed = false;
        left = parseVersion(token, range);
        right = null;
        empty = false;
        return;
      }
      String version = st.nextToken(",");
      Version endpointLeft = parseVersion(version, range);
      token = st.nextToken();
      version = st.nextToken(")]");
      token = st.nextToken();
      boolean closedRight = "]".equals(token);
      if ((!closedRight) && (!")".equals(token))) {
        throw new IllegalArgumentException("invalid range \"" + range + "\": invalid format");
      }
      Version endpointRight = parseVersion(version, range);
      if (st.hasMoreTokens())
      {
        token = st.nextToken("").trim();
        if (token.length() != 0) {
          throw new IllegalArgumentException("invalid range \"" + range + "\": invalid format");
        }
      }
    }
    catch (NoSuchElementException e)
    {
      IllegalArgumentException iae = new IllegalArgumentException("invalid range \"" + range + "\": invalid format");
      iae.initCause(e);
      throw iae;
    }
    Version endpointRight;
    Version endpointLeft;
    boolean closedRight;
    boolean closedLeft;
    leftClosed = closedLeft;
    rightClosed = closedRight;
    left = endpointLeft;
    right = endpointRight;
    empty = isEmpty0();
  }
  
  private static Version parseVersion(String version, String range)
  {
    try
    {
      return Version.parseVersion(version);
    }
    catch (IllegalArgumentException e)
    {
      IllegalArgumentException iae = new IllegalArgumentException("invalid range \"" + range + "\": " + e.getMessage());
      iae.initCause(e);
      throw iae;
    }
  }
  
  public Version getLeft()
  {
    return left;
  }
  
  public Version getRight()
  {
    return right;
  }
  
  public char getLeftType()
  {
    return leftClosed ? '[' : '(';
  }
  
  public char getRightType()
  {
    return rightClosed ? ']' : ')';
  }
  
  public boolean includes(Version version)
  {
    if (empty) {
      return false;
    }
    if (left.compareTo(version) >= (leftClosed ? 1 : 0)) {
      return false;
    }
    if (right == null) {
      return true;
    }
    return right.compareTo(version) >= (rightClosed ? 0 : 1);
  }
  
  public VersionRange intersection(VersionRange[] ranges)
  {
    if ((ranges == null) || (ranges.length == 0)) {
      return this;
    }
    boolean closedLeft = leftClosed;
    boolean closedRight = rightClosed;
    Version endpointLeft = left;
    Version endpointRight = right;
    VersionRange[] arrayOfVersionRange;
    int j = (arrayOfVersionRange = ranges).length;
    for (int i = 0; i < j; i++)
    {
      VersionRange range = arrayOfVersionRange[i];
      int comparison = endpointLeft.compareTo(left);
      if (comparison == 0)
      {
        closedLeft = (closedLeft) && (leftClosed);
      }
      else if (comparison < 0)
      {
        endpointLeft = left;
        closedLeft = leftClosed;
      }
      if (right != null) {
        if (endpointRight == null)
        {
          endpointRight = right;
          closedRight = rightClosed;
        }
        else
        {
          comparison = endpointRight.compareTo(right);
          if (comparison == 0)
          {
            closedRight = (closedRight) && (rightClosed);
          }
          else if (comparison > 0)
          {
            endpointRight = right;
            closedRight = rightClosed;
          }
        }
      }
    }
    return new VersionRange(closedLeft ? '[' : '(', endpointLeft, endpointRight, closedRight ? ']' : ')');
  }
  
  public boolean isEmpty()
  {
    return empty;
  }
  
  private boolean isEmpty0()
  {
    if (right == null) {
      return false;
    }
    int comparison = left.compareTo(right);
    if (comparison == 0) {
      return (!leftClosed) || (!rightClosed);
    }
    return comparison > 0;
  }
  
  public boolean isExact()
  {
    if ((empty) || (right == null)) {
      return false;
    }
    if (leftClosed)
    {
      if (rightClosed) {
        return left.equals(right);
      }
      Version adjacent1 = new Version(left.getMajor(), left.getMinor(), left.getMicro(), left.getQualifier() + "-");
      return adjacent1.compareTo(right) >= 0;
    }
    if (rightClosed)
    {
      Version adjacent1 = new Version(left.getMajor(), left.getMinor(), left.getMicro(), left.getQualifier() + "-");
      return adjacent1.equals(right);
    }
    Version adjacent2 = new Version(left.getMajor(), left.getMinor(), left.getMicro(), left.getQualifier() + "--");
    return adjacent2.compareTo(right) >= 0;
  }
  
  public String toString()
  {
    if (versionRangeString != null) {
      return versionRangeString;
    }
    String leftVersion = left.toString();
    if (right == null)
    {
      StringBuffer result = new StringBuffer(leftVersion.length() + 1);
      result.append(left.toString0());
      return versionRangeString = result.toString();
    }
    String rightVerion = right.toString();
    StringBuffer result = new StringBuffer(leftVersion.length() + rightVerion.length() + 5);
    result.append(leftClosed ? '[' : '(');
    result.append(left.toString0());
    result.append(",");
    result.append(right.toString0());
    result.append(rightClosed ? ']' : ')');
    return versionRangeString = result.toString();
  }
  
  public int hashCode()
  {
    if (hash != 0) {
      return hash;
    }
    if (empty) {
      return hash = 31;
    }
    int h = 31 + (leftClosed ? 7 : 5);
    h = 31 * h + left.hashCode();
    if (right != null)
    {
      h = 31 * h + right.hashCode();
      h = 31 * h + (rightClosed ? 7 : 5);
    }
    return hash = h;
  }
  
  public boolean equals(Object object)
  {
    if (object == this) {
      return true;
    }
    if (!(object instanceof VersionRange)) {
      return false;
    }
    VersionRange other = (VersionRange)object;
    if ((empty) && (empty)) {
      return true;
    }
    if (right == null) {
      return (leftClosed == leftClosed) && (right == null) && (left.equals(left));
    }
    return (leftClosed == leftClosed) && (rightClosed == rightClosed) && (left.equals(left)) && (right.equals(right));
  }
  
  public String toFilterString(String attributeName)
  {
    if (attributeName.length() == 0) {
      throw new IllegalArgumentException("invalid attributeName \"" + attributeName + "\"");
    }
    char[] arrayOfChar;
    int j = (arrayOfChar = attributeName.toCharArray()).length;
    for (int i = 0; i < j; i++)
    {
      char ch = arrayOfChar[i];
      if ((ch == '=') || (ch == '>') || (ch == '<') || (ch == '~') || (ch == '(') || (ch == ')')) {
        throw new IllegalArgumentException("invalid attributeName \"" + attributeName + "\"");
      }
    }
    StringBuffer result = new StringBuffer(128);
    if (right != null) {
      result.append("(&");
    }
    if (leftClosed)
    {
      result.append('(');
      result.append(attributeName);
      result.append(">=");
      result.append(left.toString0());
      result.append(')');
    }
    else
    {
      result.append("(!(");
      result.append(attributeName);
      result.append("<=");
      result.append(left.toString0());
      result.append("))");
    }
    if (right != null)
    {
      if (rightClosed)
      {
        result.append('(');
        result.append(attributeName);
        result.append("<=");
        result.append(right.toString0());
        result.append(')');
      }
      else
      {
        result.append("(!(");
        result.append(attributeName);
        result.append(">=");
        result.append(right.toString0());
        result.append("))");
      }
      result.append(')');
    }
    return result.toString();
  }
}

/* Location:
 * Qualified Name:     org.osgi.framework.VersionRange
 * Java Class Version: 1.4 (48.0)
 * JD-Core Version:    0.7.1
 */
package org.osgi.framework.hooks.bundle;

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

public abstract interface CollisionHook
{
  public static final int INSTALLING = 1;
  public static final int UPDATING = 2;
  
  public abstract void filterCollisions(int paramInt, Bundle paramBundle, Collection<Bundle> paramCollection);
}

/* Location:
 * Qualified Name:     org.osgi.framework.hooks.bundle.CollisionHook
 * Java Class Version: 1.4 (48.0)
 * JD-Core Version:    0.7.1
 */
package org.osgi.framework.hooks.bundle;

import java.util.Collection;
import org.osgi.framework.BundleContext;
import org.osgi.framework.BundleEvent;

public abstract interface EventHook
{
  public abstract void event(BundleEvent paramBundleEvent, Collection<BundleContext> paramCollection);
}

/* Location:
 * Qualified Name:     org.osgi.framework.hooks.bundle.EventHook
 * Java Class Version: 1.4 (48.0)
 * JD-Core Version:    0.7.1
 */
package org.osgi.framework.hooks.bundle;

import java.util.Collection;
import org.osgi.framework.Bundle;
import org.osgi.framework.BundleContext;

public abstract interface FindHook
{
  public abstract void find(BundleContext paramBundleContext, Collection<Bundle> paramCollection);
}

/* Location:
 * Qualified Name:     org.osgi.framework.hooks.bundle.FindHook
 * Java Class Version: 1.4 (48.0)
 * JD-Core Version:    0.7.1
 */
package org.osgi.framework.hooks.resolver;

import java.util.Collection;
import org.osgi.framework.wiring.BundleCapability;
import org.osgi.framework.wiring.BundleRequirement;
import org.osgi.framework.wiring.BundleRevision;

public abstract interface ResolverHook
{
  public abstract void filterResolvable(Collection<BundleRevision> paramCollection);
  
  public abstract void filterSingletonCollisions(BundleCapability paramBundleCapability, Collection<BundleCapability> paramCollection);
  
  public abstract void filterMatches(BundleRequirement paramBundleRequirement, Collection<BundleCapability> paramCollection);
  
  public abstract void end();
}

/* Location:
 * Qualified Name:     org.osgi.framework.hooks.resolver.ResolverHook
 * Java Class Version: 1.4 (48.0)
 * JD-Core Version:    0.7.1
 */
package org.osgi.framework.hooks.resolver;

import java.util.Collection;
import org.osgi.framework.wiring.BundleRevision;

public abstract interface ResolverHookFactory
{
  public abstract ResolverHook begin(Collection<BundleRevision> paramCollection);
}

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

import java.util.Collection;
import org.osgi.framework.BundleContext;
import org.osgi.framework.ServiceEvent;

/**
 * @deprecated
 */
public abstract interface EventHook
{
  public abstract void event(ServiceEvent paramServiceEvent, Collection<BundleContext> paramCollection);
}

/* Location:
 * Qualified Name:     org.osgi.framework.hooks.service.EventHook
 * Java Class Version: 1.4 (48.0)
 * JD-Core Version:    0.7.1
 */
package org.osgi.framework.hooks.service;

import java.util.Collection;
import java.util.Map;
import org.osgi.framework.BundleContext;
import org.osgi.framework.ServiceEvent;

public abstract interface EventListenerHook
{
  public abstract void event(ServiceEvent paramServiceEvent, Map<BundleContext, Collection<ListenerHook.ListenerInfo>> paramMap);
}

/* Location:
 * Qualified Name:     org.osgi.framework.hooks.service.EventListenerHook
 * Java Class Version: 1.4 (48.0)
 * JD-Core Version:    0.7.1
 */
package org.osgi.framework.hooks.service;

import java.util.Collection;
import org.osgi.framework.BundleContext;
import org.osgi.framework.ServiceReference;

public abstract interface FindHook
{
  public abstract void find(BundleContext paramBundleContext, String paramString1, String paramString2, boolean paramBoolean, Collection<ServiceReference<?>> paramCollection);
}

/* Location:
 * Qualified Name:     org.osgi.framework.hooks.service.FindHook
 * Java Class Version: 1.4 (48.0)
 * JD-Core Version:    0.7.1
 */
package org.osgi.framework.hooks.service;

import org.osgi.framework.BundleContext;

public abstract interface ListenerHook$ListenerInfo
{
  public abstract BundleContext getBundleContext();
  
  public abstract String getFilter();
  
  public abstract boolean isRemoved();
  
  public abstract boolean equals(Object paramObject);
  
  public abstract int hashCode();
}

/* Location:
 * Qualified Name:     org.osgi.framework.hooks.service.ListenerHook.ListenerInfo
 * Java Class Version: 1.4 (48.0)
 * JD-Core Version:    0.7.1
 */
package org.osgi.framework.hooks.service;

import java.util.Collection;
import org.osgi.framework.BundleContext;

public abstract interface ListenerHook
{
  public abstract void added(Collection<ListenerInfo> paramCollection);
  
  public abstract void removed(Collection<ListenerInfo> paramCollection);
  
  public static abstract interface ListenerInfo
  {
    public abstract BundleContext getBundleContext();
    
    public abstract String getFilter();
    
    public abstract boolean isRemoved();
    
    public abstract boolean equals(Object paramObject);
    
    public abstract int hashCode();
  }
}

/* Location:
 * Qualified Name:     org.osgi.framework.hooks.service.ListenerHook
 * Java Class Version: 1.4 (48.0)
 * JD-Core Version:    0.7.1
 */
package org.osgi.framework.hooks.weaving;

public class WeavingException
  extends RuntimeException
{
  private static final long serialVersionUID = 1L;
  
  public WeavingException(String msg, Throwable cause)
  {
    super(msg, cause);
  }
  
  public WeavingException(String msg)
  {
    super(msg);
  }
}

/* Location:
 * Qualified Name:     org.osgi.framework.hooks.weaving.WeavingException
 * Java Class Version: 1.4 (48.0)
 * JD-Core Version:    0.7.1
 */
package org.osgi.framework.hooks.weaving;

public abstract interface WeavingHook
{
  public abstract void weave(WovenClass paramWovenClass);
}

/* Location:
 * Qualified Name:     org.osgi.framework.hooks.weaving.WeavingHook
 * Java Class Version: 1.4 (48.0)
 * JD-Core Version:    0.7.1
 */
package org.osgi.framework.hooks.weaving;

import java.security.ProtectionDomain;
import java.util.List;
import org.osgi.framework.wiring.BundleWiring;

public abstract interface WovenClass
{
  public abstract byte[] getBytes();
  
  public abstract void setBytes(byte[] paramArrayOfByte);
  
  public abstract List<String> getDynamicImports();
  
  public abstract boolean isWeavingComplete();
  
  public abstract String getClassName();
  
  public abstract ProtectionDomain getProtectionDomain();
  
  public abstract Class<?> getDefinedClass();
  
  public abstract BundleWiring getBundleWiring();
}

/* Location:
 * Qualified Name:     org.osgi.framework.hooks.weaving.WovenClass
 * Java Class Version: 1.4 (48.0)
 * JD-Core Version:    0.7.1
 */
package org.osgi.framework.launch;

import java.io.InputStream;
import java.net.URL;
import java.util.Enumeration;
import org.osgi.framework.Bundle;
import org.osgi.framework.BundleException;
import org.osgi.framework.FrameworkEvent;

public abstract interface Framework
  extends Bundle
{
  public abstract void init()
    throws BundleException;
  
  public abstract FrameworkEvent waitForStop(long paramLong)
    throws InterruptedException;
  
  public abstract void start()
    throws BundleException;
  
  public abstract void start(int paramInt)
    throws BundleException;
  
  public abstract void stop()
    throws BundleException;
  
  public abstract void stop(int paramInt)
    throws BundleException;
  
  public abstract void uninstall()
    throws BundleException;
  
  public abstract void update()
    throws BundleException;
  
  public abstract void update(InputStream paramInputStream)
    throws BundleException;
  
  public abstract long getBundleId();
  
  public abstract String getLocation();
  
  public abstract String getSymbolicName();
  
  public abstract Enumeration<String> getEntryPaths(String paramString);
  
  public abstract URL getEntry(String paramString);
  
  public abstract Enumeration<URL> findEntries(String paramString1, String paramString2, boolean paramBoolean);
  
  public abstract <A> A adapt(Class<A> paramClass);
}

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

import java.util.Map;

public abstract interface FrameworkFactory
{
  public abstract Framework newFramework(Map<String, String> paramMap);
}

/* Location:
 * Qualified Name:     org.osgi.framework.launch.FrameworkFactory
 * Java Class Version: 1.4 (48.0)
 * JD-Core Version:    0.7.1
 */
package org.osgi.framework.namespace;

import org.osgi.resource.Namespace;

public abstract class AbstractWiringNamespace
  extends Namespace
{
  public static final String CAPABILITY_MANDATORY_DIRECTIVE = "mandatory";
  public static final String CAPABILITY_BUNDLE_VERSION_ATTRIBUTE = "bundle-version";
}

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

public final class BundleNamespace
  extends AbstractWiringNamespace
{
  public static final String BUNDLE_NAMESPACE = "osgi.wiring.bundle";
  public static final String CAPABILITY_SINGLETON_DIRECTIVE = "singleton";
  public static final String CAPABILITY_FRAGMENT_ATTACHMENT_DIRECTIVE = "fragment-attachment";
  public static final String REQUIREMENT_EXTENSION_DIRECTIVE = "extension";
  public static final String REQUIREMENT_VISIBILITY_DIRECTIVE = "visibility";
  public static final String VISIBILITY_PRIVATE = "private";
  public static final String VISIBILITY_REEXPORT = "reexport";
}

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

import org.osgi.resource.Namespace;

public final class ExecutionEnvironmentNamespace
  extends Namespace
{
  public static final String EXECUTION_ENVIRONMENT_NAMESPACE = "osgi.ee";
  public static final String CAPABILITY_VERSION_ATTRIBUTE = "version";
}

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

public final class HostNamespace
  extends AbstractWiringNamespace
{
  public static final String HOST_NAMESPACE = "osgi.wiring.host";
  public static final String CAPABILITY_SINGLETON_DIRECTIVE = "singleton";
  public static final String CAPABILITY_FRAGMENT_ATTACHMENT_DIRECTIVE = "fragment-attachment";
  public static final String FRAGMENT_ATTACHMENT_ALWAYS = "always";
  public static final String FRAGMENT_ATTACHMENT_RESOLVETIME = "resolve-time";
  public static final String FRAGMENT_ATTACHMENT_NEVER = "never";
  public static final String REQUIREMENT_EXTENSION_DIRECTIVE = "extension";
  public static final String EXTENSION_FRAMEWORK = "framework";
  public static final String EXTENSION_BOOTCLASSPATH = "bootclasspath";
  public static final String REQUIREMENT_VISIBILITY_DIRECTIVE = "visibility";
}

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

import org.osgi.resource.Namespace;

public final class IdentityNamespace
  extends Namespace
{
  public static final String IDENTITY_NAMESPACE = "osgi.identity";
  public static final String CAPABILITY_SINGLETON_DIRECTIVE = "singleton";
  public static final String CAPABILITY_VERSION_ATTRIBUTE = "version";
  public static final String CAPABILITY_TYPE_ATTRIBUTE = "type";
  public static final String TYPE_BUNDLE = "osgi.bundle";
  public static final String TYPE_FRAGMENT = "osgi.fragment";
  public static final String TYPE_UNKNOWN = "unknown";
  public static final String CAPABILITY_COPYRIGHT_ATTRIBUTE = "copyright";
  public static final String CAPABILITY_DESCRIPTION_ATTRIBUTE = "description";
  public static final String CAPABILITY_DOCUMENTATION_ATTRIBUTE = "documentation";
  public static final String CAPABILITY_LICENSE_ATTRIBUTE = "license";
  public static final String REQUIREMENT_CLASSIFIER_DIRECTIVE = "classifier";
  public static final String CLASSIFIER_SOURCES = "sources";
  public static final String CLASSIFIER_JAVADOC = "javadoc";
}

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

public final class PackageNamespace
  extends AbstractWiringNamespace
{
  public static final String PACKAGE_NAMESPACE = "osgi.wiring.package";
  public static final String CAPABILITY_INCLUDE_DIRECTIVE = "include";
  public static final String CAPABILITY_EXCLUDE_DIRECTIVE = "exclude";
  public static final String CAPABILITY_VERSION_ATTRIBUTE = "version";
  public static final String CAPABILITY_BUNDLE_SYMBOLICNAME_ATTRIBUTE = "bundle-symbolic-name";
  public static final String RESOLUTION_DYNAMIC = "dynamic";
}

/* Location:
 * Qualified Name:     org.osgi.framework.namespace.PackageNamespace
 * Java Class Version: 1.4 (48.0)
 * JD-Core Version:    0.7.1
 */
package org.osgi.framework.startlevel;

import org.osgi.framework.BundleReference;

public abstract interface BundleStartLevel
  extends BundleReference
{
  public abstract int getStartLevel();
  
  public abstract void setStartLevel(int paramInt);
  
  public abstract boolean isPersistentlyStarted();
  
  public abstract boolean isActivationPolicyUsed();
}

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

import org.osgi.framework.BundleReference;
import org.osgi.framework.FrameworkListener;

public abstract interface FrameworkStartLevel
  extends BundleReference
{
  public abstract int getStartLevel();
  
  public abstract void setStartLevel(int paramInt, FrameworkListener[] paramArrayOfFrameworkListener);
  
  public abstract int getInitialBundleStartLevel();
  
  public abstract void setInitialBundleStartLevel(int paramInt);
}

/* Location:
 * Qualified Name:     org.osgi.framework.startlevel.FrameworkStartLevel
 * Java Class Version: 1.4 (48.0)
 * JD-Core Version:    0.7.1
 */
package org.osgi.framework.wiring;

import java.util.Map;
import org.osgi.resource.Capability;

public abstract interface BundleCapability
  extends Capability
{
  public abstract BundleRevision getRevision();
  
  public abstract String getNamespace();
  
  public abstract Map<String, String> getDirectives();
  
  public abstract Map<String, Object> getAttributes();
  
  public abstract BundleRevision getResource();
}

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

import java.util.Map;
import org.osgi.resource.Requirement;

public abstract interface BundleRequirement
  extends Requirement
{
  public abstract BundleRevision getRevision();
  
  public abstract boolean matches(BundleCapability paramBundleCapability);
  
  public abstract String getNamespace();
  
  public abstract Map<String, String> getDirectives();
  
  public abstract Map<String, Object> getAttributes();
  
  public abstract BundleRevision getResource();
}

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

import java.util.List;
import org.osgi.framework.BundleReference;
import org.osgi.framework.Version;
import org.osgi.resource.Capability;
import org.osgi.resource.Requirement;
import org.osgi.resource.Resource;

public abstract interface BundleRevision
  extends BundleReference, Resource
{
  public static final String PACKAGE_NAMESPACE = "osgi.wiring.package";
  public static final String BUNDLE_NAMESPACE = "osgi.wiring.bundle";
  public static final String HOST_NAMESPACE = "osgi.wiring.host";
  public static final int TYPE_FRAGMENT = 1;
  
  public abstract String getSymbolicName();
  
  public abstract Version getVersion();
  
  public abstract List<BundleCapability> getDeclaredCapabilities(String paramString);
  
  public abstract List<BundleRequirement> getDeclaredRequirements(String paramString);
  
  public abstract int getTypes();
  
  public abstract BundleWiring getWiring();
  
  public abstract List<Capability> getCapabilities(String paramString);
  
  public abstract List<Requirement> getRequirements(String paramString);
}

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

import java.util.List;
import org.osgi.framework.BundleReference;

public abstract interface BundleRevisions
  extends BundleReference
{
  public abstract List<BundleRevision> getRevisions();
}

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

import org.osgi.resource.Wire;

public abstract interface BundleWire
  extends Wire
{
  public abstract BundleCapability getCapability();
  
  public abstract BundleRequirement getRequirement();
  
  public abstract BundleWiring getProviderWiring();
  
  public abstract BundleWiring getRequirerWiring();
  
  public abstract BundleRevision getProvider();
  
  public abstract BundleRevision getRequirer();
}

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

import java.net.URL;
import java.util.Collection;
import java.util.List;
import org.osgi.framework.BundleReference;
import org.osgi.resource.Capability;
import org.osgi.resource.Requirement;
import org.osgi.resource.Wire;
import org.osgi.resource.Wiring;

public abstract interface BundleWiring
  extends BundleReference, Wiring
{
  public static final int FINDENTRIES_RECURSE = 1;
  public static final int LISTRESOURCES_RECURSE = 1;
  public static final int LISTRESOURCES_LOCAL = 2;
  
  public abstract boolean isCurrent();
  
  public abstract boolean isInUse();
  
  public abstract List<BundleCapability> getCapabilities(String paramString);
  
  public abstract List<BundleRequirement> getRequirements(String paramString);
  
  public abstract List<BundleWire> getProvidedWires(String paramString);
  
  public abstract List<BundleWire> getRequiredWires(String paramString);
  
  public abstract BundleRevision getRevision();
  
  public abstract ClassLoader getClassLoader();
  
  public abstract List<URL> findEntries(String paramString1, String paramString2, int paramInt);
  
  public abstract Collection<String> listResources(String paramString1, String paramString2, int paramInt);
  
  public abstract List<Capability> getResourceCapabilities(String paramString);
  
  public abstract List<Requirement> getResourceRequirements(String paramString);
  
  public abstract List<Wire> getProvidedResourceWires(String paramString);
  
  public abstract List<Wire> getRequiredResourceWires(String paramString);
  
  public abstract BundleRevision getResource();
}

/* Location:
 * Qualified Name:     org.osgi.framework.wiring.BundleWiring
 * Java Class Version: 1.4 (48.0)
 * JD-Core Version:    0.7.1
 */
package org.osgi.framework.wirin
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-2017. Infinite Loop Ltd