org.eclipse.pde.api.tools_1.0.301.v20111129-2053

     }
                        else
                        {
                          val$typeRootBaseLineNames.add(typeName);
                          IApiType typeDescriptor2 = typeRoot2.getStructure();
                          IApiAnnotations elementDescription2 = providerApiDesc.resolveAnnotations(typeDescriptor2.getHandle());
                          int visibility2 = 0;
                          if (elementDescription2 != null) {
                            visibility2 = elementDescription2.getVisibility();
                          }
                          if ((Util.isDefault(typeDescriptor.getModifiers())) || 
                            (Flags.isPrivate(typeDescriptor.getModifiers()))) {
                            return;
                          }
                          if ((Util.isAPI(visibility, typeDescriptor)) && 
                            (!Util.isAPI(visibility2, typeDescriptor2)))
                          {
                            val$globalDelta.add(
                              new Delta(
                              val$currentComponentID, 
                              2, 
                              3, 
                              71, 
                              elementDescription2 != null ? elementDescription2.getRestrictions() : 0, 
                              0, 
                              typeDescriptor.getModifiers(), 
                              typeDescriptor2.getModifiers(), 
                              typeName, 
                              typeName, 
                              new String[] { typeName, Util.getComponentVersionsId(val$component) }));
                            return;
                          }
                        }
                      }
                      catch (CoreException e)
                      {
                        ApiPlugin.log(e);
                      }
                    }
                  });
                }
                catch (CoreException e)
                {
                  ApiPlugin.log(e);
                }
              }
            }
          }
        }
      }
    }
    Util.updateMonitor(localmonitor, 1);
    if (typeRootContainers2 != null)
    {
      int i = 0;
      for (int max = typeRootContainers2.length; i < max; i++)
      {
        Util.updateMonitor(localmonitor);
        IApiTypeContainer container = typeRootContainers2[i];
        try
        {
          container.accept(new ApiTypeContainerVisitor()
          {
            private final IApiDescription val$apiDescription2;
            private final int val$visibilityModifiers;
            private final Set val$typeRootBaseLineNames;
            private final IApiComponent val$component2;
            private final Delta val$globalDelta;
            
            public void visit(String packageName, IApiTypeRoot typeRoot)
            {
              Util.updateMonitor(ApiComparator.this);
              String typeName = typeRoot.getTypeName();
              try
              {
                IApiType type = typeRoot.getStructure();
                IApiAnnotations elementDescription = val$apiDescription2.resolveAnnotations(type.getHandle());
                if ((type.isMemberType()) || (type.isLocal()) || (type.isAnonymous())) {
                  return;
                }
                if (ApiComparator.filterType(val$visibilityModifiers, elementDescription, type)) {
                  return;
                }
                if (val$typeRootBaseLineNames.contains(typeName)) {
                  return;
                }
                val$typeRootBaseLineNames.add(typeName);
                String deltaComponentID = Util.getDeltaComponentVersionsId(val$component2);
                val$globalDelta.add(
                  new Delta(
                  deltaComponentID, 
                  2, 
                  1, 
                  46, 
                  elementDescription != null ? elementDescription.getRestrictions() : 0, 
                  0, 
                  0, 
                  type.getModifiers(), 
                  typeName, 
                  typeName, 
                  new String[] { typeName, Util.getComponentVersionsId(val$component2) }));
              }
              catch (CoreException e)
              {
                ApiPlugin.log(e);
              }
            }
          });
        }
        catch (CoreException e)
        {
          ApiPlugin.log(e);
        }
      }
    }
    Util.updateMonitor(localmonitor, 1);
    requiredComponents = component2.getRequiredComponents();
    length = requiredComponents.length;
    if (length != 0) {
      for (int j = 0; j < length; j++)
      {
        Util.updateMonitor(localmonitor);
        IRequiredComponentDescription description = requiredComponents[j];
        if (description.isExported())
        {
          String currentComponentID = Util.getDeltaComponentVersionsId(component);
          String descriptionID = description.getId();
          IApiComponent currentRequiredApiComponent = baseline.getApiComponent(descriptionID);
          if (currentRequiredApiComponent != null)
          {
            IApiTypeContainer[] apiTypeContainers = currentRequiredApiComponent.getApiTypeContainers();
            IApiDescription reexportedApiDescription = currentRequiredApiComponent.getApiDescription();
            if (apiTypeContainers != null)
            {
              int i = 0;
              for (int max = apiTypeContainers.length; i < max; i++)
              {
                Util.updateMonitor(localmonitor);
                IApiTypeContainer container = apiTypeContainers[i];
                try
                {
                  container.accept(new ApiTypeContainerVisitor()
                  {
                    private final IApiDescription val$reexportedApiDescription;
                    private final int val$visibilityModifiers;
                    private final Set val$typeRootBaseLineNames;
                    private final Delta val$globalDelta;
                    private final String val$currentComponentID;
                    private final IApiComponent val$component;
                    
                    public void visit(String packageName, IApiTypeRoot typeRoot)
                    {
                      Util.updateMonitor(ApiComparator.this);
                      String typeName = typeRoot.getTypeName();
                      try
                      {
                        IApiType typeDescriptor = typeRoot.getStructure();
                        IApiAnnotations elementDescription = val$reexportedApiDescription.resolveAnnotations(typeDescriptor.getHandle());
                        if ((typeDescriptor.isMemberType()) || (typeDescriptor.isAnonymous()) || (typeDescriptor.isLocal())) {
                          return;
                        }
                        if (ApiComparator.filterType(val$visibilityModifiers, elementDescription, typeDescriptor)) {
                          return;
                        }
                        if (val$typeRootBaseLineNames.contains(typeName)) {
                          return;
                        }
                        val$typeRootBaseLineNames.add(typeName);
                        val$globalDelta.add(
                          new Delta(
                          val$currentComponentID, 
                          2, 
                          1, 
                          70, 
                          elementDescription != null ? elementDescription.getRestrictions() : 0, 
                          0, 
                          0, 
                          typeDescriptor.getModifiers(), 
                          typeName, 
                          typeName, 
                          new String[] { typeName, Util.getComponentVersionsId(val$component) }));
                      }
                      catch (CoreException e)
                      {
                        ApiPlugin.log(e);
                      }
                    }
                  });
                }
                catch (CoreException e)
                {
                  ApiPlugin.log(e);
                }
              }
            }
          }
        }
      }
    }
    return globalDelta.isEmpty() ? NO_DELTA : globalDelta;
  }
  
  public static void setDebug(boolean debugValue)
  {
    DEBUG = (debugValue) || (Util.DEBUG);
  }
}

/* Location:
 * Qualified Name:     org.eclipse.pde.api.tools.internal.provisional.comparator.ApiComparator
 * Java Class Version: 1.2 (46.0)
 * JD-Core Version:    0.7.1
 */
package org.eclipse.pde.api.tools.internal.provisional.comparator;

import java.util.ArrayList;
import java.util.Iterator;
import org.eclipse.core.runtime.CoreException;
import org.eclipse.core.runtime.Status;
import org.eclipse.osgi.util.NLS;
import org.eclipse.pde.api.tools.internal.model.Messages;
import org.eclipse.pde.api.tools.internal.provisional.model.ApiScopeVisitor;
import org.eclipse.pde.api.tools.internal.provisional.model.IApiBaseline;
import org.eclipse.pde.api.tools.internal.provisional.model.IApiComponent;
import org.eclipse.pde.api.tools.internal.provisional.model.IApiElement;
import org.eclipse.pde.api.tools.internal.provisional.model.IApiScope;
import org.eclipse.pde.api.tools.internal.provisional.model.IApiTypeContainer;
import org.eclipse.pde.api.tools.internal.provisional.model.IApiTypeRoot;
import org.eclipse.pde.api.tools.internal.util.Util;

public class ApiScope
  implements IApiScope
{
  private static final IApiElement[] NO_ELEMENTS = new IApiElement[0];
  ArrayList elements;
  
  public void accept(ApiScopeVisitor visitor)
    throws CoreException
  {
    IApiElement[] elements = getApiElements();
    for (int i = 0; i < elements.length; i++)
    {
      IApiElement apiElement = elements[i];
      int type = apiElement.getType();
      switch (type)
      {
      case 3: 
        IApiTypeContainer container = (IApiTypeContainer)apiElement;
        visitor.visit(container);
        visitor.endVisit(container);
        break;
      case 7: 
        IApiTypeRoot root = (IApiTypeRoot)apiElement;
        visitor.visit(root);
        visitor.endVisit(root);
        break;
      case 4: 
        IApiBaseline baseline = (IApiBaseline)apiElement;
        visitor.visit(baseline);
        visitor.endVisit(baseline);
        break;
      case 1: 
        IApiComponent component = (IApiComponent)apiElement;
        visitor.visit(component);
        visitor.endVisit(component);
        break;
      case 2: 
      case 5: 
      case 6: 
      default: 
        throw new CoreException(
          new Status(
          4, 
          "org.eclipse.pde.api.tools", 
          NLS.bind(
          Messages.ApiScope_0, 
          Util.getApiElementType(type))));
      }
    }
  }
  
  public void addElement(IApiElement newelement)
  {
    if (elements == null) {
      elements = new ArrayList();
    }
    elements.add(newelement);
  }
  
  public boolean encloses(IApiElement element)
  {
    if (element != null)
    {
      IApiComponent component = element.getApiComponent();
      IApiComponent enclosing = null;
      for (Iterator iter = elements.iterator(); iter.hasNext();)
      {
        enclosing = ((IApiElement)iter.next()).getApiComponent();
        if (component.equals(enclosing)) {
          return true;
        }
      }
    }
    return false;
  }
  
  public IApiElement[] getApiElements()
  {
    if ((elements == null) || (elements.size() == 0)) {
      return NO_ELEMENTS;
    }
    return (IApiElement[])elements.toArray(new IApiElement[elements.size()]);
  }
}

/* Location:
 * Qualified Name:     org.eclipse.pde.api.tools.internal.provisional.comparator.ApiScope
 * Java Class Version: 1.2 (46.0)
 * JD-Core Version:    0.7.1
 */
package org.eclipse.pde.api.tools.internal.provisional.comparator;

import java.util.Set;

class CompareApiScopeVisitor$1
  extends DeltaVisitor
{
  final CompareApiScopeVisitor this$0;
  
  CompareApiScopeVisitor$1(CompareApiScopeVisitor paramCompareApiScopeVisitor)
  {
    this$0 = paramCompareApiScopeVisitor;
  }
  
  public void endVisit(IDelta localDelta)
  {
    if (localDelta.getChildren().length == 0) {
      this$0.deltas.add(localDelta);
    }
  }
}

/* Location:
 * Qualified Name:     org.eclipse.pde.api.tools.internal.provisional.comparator.CompareApiScopeVisitor.1
 * Java Class Version: 1.2 (46.0)
 * JD-Core Version:    0.7.1
 */
package org.eclipse.pde.api.tools.internal.provisional.comparator;

import org.eclipse.core.runtime.CoreException;
import org.eclipse.pde.api.tools.internal.provisional.ApiPlugin;
import org.eclipse.pde.api.tools.internal.provisional.model.ApiTypeContainerVisitor;
import org.eclipse.pde.api.tools.internal.provisional.model.IApiTypeRoot;
import org.eclipse.pde.api.tools.internal.util.Util;

class CompareApiScopeVisitor$2
  extends ApiTypeContainerVisitor
{
  final CompareApiScopeVisitor this$0;
  
  CompareApiScopeVisitor$2(CompareApiScopeVisitor paramCompareApiScopeVisitor)
  {
    this$0 = paramCompareApiScopeVisitor;
  }
  
  public void visit(String packageName, IApiTypeRoot typeroot)
  {
    try
    {
      Util.updateMonitor(this$0.monitor);
      this$0.compareApiTypeRoot(typeroot);
    }
    catch (CoreException e)
    {
      ApiPlugin.log(e);
    }
  }
}

/* Location:
 * Qualified Name:     org.eclipse.pde.api.tools.internal.provisional.comparator.CompareApiScopeVisitor.2
 * Java Class Version: 1.2 (46.0)
 * JD-Core Version:    0.7.1
 */
package org.eclipse.pde.api.tools.internal.provisional.comparator;

import java.util.Set;

class CompareApiScopeVisitor$3
  extends DeltaVisitor
{
  final CompareApiScopeVisitor this$0;
  
  CompareApiScopeVisitor$3(CompareApiScopeVisitor paramCompareApiScopeVisitor)
  {
    this$0 = paramCompareApiScopeVisitor;
  }
  
  public void endVisit(IDelta localDelta)
  {
    if (localDelta.getChildren().length == 0) {
      this$0.deltas.add(localDelta);
    }
  }
}

/* Location:
 * Qualified Name:     org.eclipse.pde.api.tools.internal.provisional.comparator.CompareApiScopeVisitor.3
 * Java Class Version: 1.2 (46.0)
 * JD-Core Version:    0.7.1
 */
package org.eclipse.pde.api.tools.internal.provisional.comparator;

import java.util.Set;

class CompareApiScopeVisitor$4
  extends DeltaVisitor
{
  final CompareApiScopeVisitor this$0;
  
  CompareApiScopeVisitor$4(CompareApiScopeVisitor paramCompareApiScopeVisitor)
  {
    this$0 = paramCompareApiScopeVisitor;
  }
  
  public void endVisit(IDelta localDelta)
  {
    if (localDelta.getChildren().length == 0) {
      this$0.deltas.add(localDelta);
    }
  }
}

/* Location:
 * Qualified Name:     org.eclipse.pde.api.tools.internal.provisional.comparator.CompareApiScopeVisitor.4
 * Java Class Version: 1.2 (46.0)
 * JD-Core Version:    0.7.1
 */
package org.eclipse.pde.api.tools.internal.provisional.comparator;

import java.util.Set;
import org.eclipse.core.runtime.CoreException;
import org.eclipse.core.runtime.IProgressMonitor;
import org.eclipse.pde.api.tools.internal.comparator.Delta;
import org.eclipse.pde.api.tools.internal.provisional.ApiPlugin;
import org.eclipse.pde.api.tools.internal.provisional.model.ApiScopeVisitor;
import org.eclipse.pde.api.tools.internal.provisional.model.ApiTypeContainerVisitor;
import org.eclipse.pde.api.tools.internal.provisional.model.IApiBaseline;
import org.eclipse.pde.api.tools.internal.provisional.model.IApiComponent;
import org.eclipse.pde.api.tools.internal.provisional.model.IApiTypeContainer;
import org.eclipse.pde.api.tools.internal.provisional.model.IApiTypeRoot;
import org.eclipse.pde.api.tools.internal.util.Util;

public class CompareApiScopeVisitor
  extends ApiScopeVisitor
{
  Set deltas;
  IApiBaseline referenceBaseline;
  int visibilityModifiers;
  boolean force;
  boolean containsErrors = false;
  IProgressMonitor monitor;
  
  public CompareApiScopeVisitor(Set deltas, IApiBaseline baseline, boolean force, int visibilityModifiers, IProgressMonitor monitor)
  {
    this.deltas = deltas;
    referenceBaseline = baseline;
    this.visibilityModifiers = visibilityModifiers;
    this.force = force;
    this.monitor = monitor;
  }
  
  public boolean visit(IApiBaseline baseline)
    throws CoreException
  {
    try
    {
      Util.updateMonitor(monitor);
      IDelta delta = ApiComparator.compare(referenceBaseline, baseline, visibilityModifiers, force, null);
      if (delta != null) {
        delta.accept(new DeltaVisitor()
        {
          public void endVisit(IDelta localDelta)
          {
            if (localDelta.getChildren().length == 0) {
              deltas.add(localDelta);
            }
          }
        });
      } else {
        containsErrors = true;
      }
      return false;
    }
    finally
    {
      monitor.worked(1);
    }
  }
  
  public boolean visit(IApiTypeContainer container)
    throws CoreException
  {
    try
    {
      Util.updateMonitor(monitor);
      container.accept(new ApiTypeContainerVisitor()
      {
        public void visit(String packageName, IApiTypeRoot typeroot)
        {
          try
          {
            Util.updateMonitor(monitor);
            compareApiTypeRoot(typeroot);
          }
          catch (CoreException e)
          {
            ApiPlugin.log(e);
          }
        }
      });
      return false;
    }
    finally
    {
      monitor.worked(1);
    }
  }
  
  public boolean visit(IApiComponent component)
    throws CoreException
  {
    try
    {
      Util.updateMonitor(monitor);
      if (component.getErrors() != null)
      {
        containsErrors = true;
        return false;
      }
      IApiComponent referenceComponent = referenceBaseline.getApiComponent(component.getSymbolicName());
      if ((referenceComponent != null) && (referenceComponent.getErrors() != null))
      {
        containsErrors = true;
        return false;
      }
      if ((component.isSourceComponent()) || (component.isSystemComponent())) {
        return false;
      }
      Util.updateMonitor(monitor);
      Delta globalDelta = new Delta();
      globalDelta.add(ApiComparator.compare(referenceComponent, component, visibilityModifiers, null));
      if (referenceComponent != null)
      {
        String versionString = referenceComponent.getVersion();
        String versionString2 = component.getVersion();
        IDelta bundleVersionChangesDelta = ApiComparator.checkBundleVersionChanges(component, referenceComponent.getSymbolicName(), versionString, versionString2);
        if (bundleVersionChangesDelta != null) {
          globalDelta.add(bundleVersionChangesDelta);
        }
      }
      globalDelta.accept(new DeltaVisitor()
      {
        public void endVisit(IDelta localDelta)
        {
          if (localDelta.getChildren().length == 0) {
            deltas.add(localDelta);
          }
        }
      });
      return false;
    }
    finally
    {
      monitor.worked(1);
    }
  }
  
  /* Error */
  public void visit(IApiTypeRoot root)
    throws CoreException
  {
    // Byte code:
    //   0: aload_0
    //   1: getfield 132	org/eclipse/pde/api/tools/internal/provisional/comparator/CompareApiScopeVisitor:monitor	Lorg/eclipse/core/runtime/IProgressMonitor;
    //   4: invokestatic 147	org/eclipse/pde/api/tools/internal/util/Util:updateMonitor	(Lorg/eclipse/core/runtime/IProgressMonitor;)V
    //   7: aload_0
    //   8: aload_1
    //   9: invokevirtual 141	org/eclipse/pde/api/tools/internal/provisional/comparator/CompareApiScopeVisitor:compareApiTypeRoot	(Lorg/eclipse/pde/api/tools/internal/provisional/model/IApiTypeRoot;)V
    //   12: goto +16 -> 28
    //   15: astore_2
    //   16: aload_0
    //   17: getfield 132	org/eclipse/pde/api/tools/internal/provisional/comparator/CompareApiScopeVisitor:monitor	Lorg/eclipse/core/runtime/IProgressMonitor;
    //   20: iconst_1
    //   21: invokeinterface 148 2 0
    //   26: aload_2
    //   27: athrow
    //   28: aload_0
    //   29: getfield 132	org/eclipse/pde/api/tools/internal/provisional/comparator/CompareApiScopeVisitor:monitor	Lorg/eclipse/core/runtime/IProgressMonitor;
    //   32: iconst_1
    //   33: invokeinterface 148 2 0
    //   38: return
    // Line number table:
    //   Java source line #134	-> byte code offset #0
    //   Java source line #135	-> byte code offset #7
    //   Java source line #136	-> byte code offset #15
    //   Java source line #137	-> byte code offset #16
    //   Java source line #138	-> byte code offset #26
    //   Java source line #137	-> byte code offset #28
    //   Java source line #139	-> byte code offset #38
    // Local variable table:
    //   start	length	slot	name	signature
    //   0	39	0	this	CompareApiScopeVisitor
    //   0	39	1	root	IApiTypeRoot
    //   15	12	2	localObject	Object
    // Exception table:
    //   from	to	target	type
    //   0	15	15	finally
  }
  
  void compareApiTypeRoot(IApiTypeRoot root)
    throws CoreException
  {
    IApiComponent apiComponent = root.getApiComponent();
    if ((apiComponent == null) || (apiComponent.isSystemComponent()) || (apiComponent.isSourceComponent())) {
      return;
    }
    if (apiComponent.getErrors() != null)
    {
      containsErrors = true;
      return;
    }
    IApiComponent referenceComponent = referenceBaseline.getApiComponent(apiComponent.getSymbolicName());
    if (referenceComponent == null) {
      return;
    }
    if (referenceComponent.getErrors() != null)
    {
      containsErrors = true;
      return;
    }
    IApiBaseline baseline = referenceComponent.getBaseline();
    IDelta delta = ApiComparator.compare(
      root, 
      referenceComponent, 
      apiComponent, 
      null, 
      referenceBaseline, 
      baseline, visibilityModifiers, null);
    if (delta != null) {
      delta.accept(new DeltaVisitor()
      {
        public void endVisit(IDelta localDelta)
        {
          if (localDelta.getChildren().length == 0) {
            deltas.add(localDelta);
          }
        }
      });
    } else {
      containsErrors = true;
    }
  }
  
  public boolean containsError()
  {
    return containsErrors;
  }
}

/* Location:
 * Qualified Name:     org.eclipse.pde.api.tools.internal.provisional.comparator.CompareApiScopeVisitor
 * Java Class Version: 1.2 (46.0)
 * JD-Core Version:    0.7.1
 */
package org.eclipse.pde.api.tools.internal.provisional.comparator;

class DeltaProcessor$1$CompatibleVisitor
  extends DeltaVisitor
{
  boolean isCompatible = true;
  
  public boolean visit(IDelta delta)
  {
    if (!isCompatible) {
      return false;
    }
    return true;
  }
  
  public void endVisit(IDelta delta)
  {
    if (isCompatible) {
      isCompatible = DeltaProcessor.isCompatible0(delta);
    }
  }
}

/* Location:
 * Qualified Name:     org.eclipse.pde.api.tools.internal.provisional.comparator.DeltaProcessor.1.CompatibleVisitor
 * Java Class Version: 1.2 (46.0)
 * JD-Core Version:    0.7.1
 */
package org.eclipse.pde.api.tools.internal.provisional.comparator;

import org.eclipse.jdt.core.Flags;
import org.eclipse.pde.api.tools.internal.provisional.RestrictionModifiers;
import org.eclipse.pde.api.tools.internal.util.Util;

public class DeltaProcessor
{
  class 1$CompatibleVisitor
    extends DeltaVisitor
  {
    boolean isCompatible = true;
    
    public boolean visit(IDelta delta)
    {
      if (!isCompatible) {
        return false;
      }
      return true;
    }
    
    public void endVisit(IDelta delta)
    {
      if (isCompatible) {
        isCompatible = DeltaProcessor.isCompatible0(delta);
      }
    }
  }
  
  public static boolean isCompatible(IDelta delta)
  {
    if (delta.getChildren().length != 0)
    {
      1.CompatibleVisitor visitor = new 1.CompatibleVisitor();
      delta.accept(visitor);
      return isCompatible;
    }
    return isCompatible0(delta);
  }
  
  static boolean isCompatible0(IDelta delta)
  {
    switch (delta.getElementType())
    {
    case 3: 
      return isApiProfileCompatible(delta);
    case 2: 
      return isApiComponentCompatible(delta);
    case 8: 
      return isInterfaceCompatible(delta);
    case 1: 
      return isAnnotationCompatible(delta);
    case 9: 
      return isMethodCompatible(delta);
    case 5: 
      return isConstructorCompatible(delta);
    case 7: 
      return isFieldCompatible(delta);
    case 4: 
      return isClassCompatible(delta);
    case 6: 
      return isEnumCompatible(delta);
    case 10: 
      return isTypeParameterCompatible(delta);
    }
    return true;
  }
  
  private static boolean isApiProfileCompatible(IDelta delta)
  {
    switch (delta.getKind())
    {
    case 3: 
      switch (delta.getFlags())
      {
      case 3: 
        return false;
      }
      break;
    }
    return true;
  }
  
  private static boolean isApiComponentCompatible(IDelta delta)
  {
    switch (delta.getKind())
    {
    case 3: 
      switch (delta.getFlags())
      {
      case 46: 
      case 56: 
      case 70: 
      case 71: 
        return false;
      }
      break;
    }
    return true;
  }
  
  private static boolean isAnnotationCompatible(IDelta delta)
  {
    switch (delta.getKind())
    {
    case 1: 
      switch (delta.getFlags())
      {
      case 16: 
      case 28: 
      case 49: 
        return false;
      }
      break;
    case 3: 
      switch (delta.getFlags())
      {
      case 16: 
      case 27: 
      case 28: 
      case 48: 
      case 49: 
      case 61: 
      case 65: 
      case 66: 
        return false;
      }
      break;
    case 2: 
      switch (delta.getFlags())
      {
      case 10: 
      case 41: 
        return false;
      }
      break;
    }
    return true;
  }
  
  private static boolean isMethodCompatible(IDelta delta)
  {
    int restrictions = delta.getCurrentRestrictions();
    if (RestrictionModifiers.isReferenceRestriction(restrictions)) {
      return true;
    }
    switch (delta.getKind())
    {
    case 3: 
      switch (delta.getFlags())
      {
      case 2: 
      case 49: 
        return !Util.isVisible(delta.getOldModifiers());
      }
      break;
    case 1: 
      switch (delta.getFlags())
      {
      case 37: 
      case 49: 
        if (Util.isVisible(delta.getNewModifiers())) {
          return RestrictionModifiers.isExtendRestriction(delta.getPreviousRestrictions());
        }
        return true;
      }
      break;
    case 2: 
      switch (delta.getFlags())
      {
      case 30: 
      case 33: 
      case 38: 
      case 55: 
        return !Util.isVisible(delta.getNewModifiers());
      case 11: 
        return (!Util.isVisible(delta.getOldModifiers())) || (RestrictionModifiers.isExtendRestriction(restrictions));
      case 31: 
        return (!Util.isVisible(delta.getOldModifiers())) || (!Util.isVisible(delta.getNewModifiers())) || (RestrictionModifiers.isExtendRestriction(restrictions)) || (RestrictionModifiers.isOverrideRestriction(restrictions));
      }
      break;
    }
    return true;
  }
  
  private static boolean isFieldCompatible(IDelta delta)
  {
    int restrictions = delta.getCurrentRestrictions();
    if (RestrictionModifiers.isReferenceRestriction(restrictions)) {
      return true;
    }
    int newModifiers = delta.getNewModifiers();
    int oldModifiers = delta.getOldModifiers();
    switch (delta.getKind())
    {
    case 3: 
      switch (delta.getFlags())
      {
      case 54: 
        if (Flags.isProtected(oldModifiers)) {
          return RestrictionModifiers.isExtendRestriction(delta.getCurrentRestrictions());
        }
        if (Flags.isPublic(oldModifiers)) {
          return false;
        }
        return true;
      case 47: 
      case 68: 
        return !Util.isVisible(oldModifiers);
      }
      break;
    case 2: 
      if (!Util.isVisible(oldModifiers)) {
        return true;
      }
      switch (delta.getFlags())
      {
      case 46: 
        if (Flags.isProtected(newModifiers)) {
          return RestrictionModifiers.isExtendRestriction(delta.getCurrentRestrictions());
        }
        return !Util.isVisible(newModifiers);
      case 31: 
      case 33: 
      case 38: 
      case 68: 
        return !Util.isVisible(newModifiers);
      case 20: 
      case 54: 
        if (Flags.isProtected(newModifiers)) {
          return RestrictionModifiers.isExtendRestriction(delta.getCurrentRestrictions());
        }
        if (Flags.isPublic(newModifiers)) {
          return false;
        }
        return true;
      case 11: 
        return RestrictionModifiers.isExtendRestriction(delta.getCurrentRestrictions());
      }
      break;
    case 1: 
      switch (delta.getFlags())
      {
      case 68: 
        return !Util.isVisible(newModifiers);
      }
      break;
    }
    return true;
  }
  
  private static boolean isConstructorCompatible(IDelta delta)
  {
    int restrictions = delta.getCurrentRestrictions();
    if (RestrictionModifiers.isReferenceRestriction(restrictions)) {
      return true;
    }
    switch (delta.getKind())
    {
    case 3: 
      switch (delta.getFlags())
      {
      case 49: 
        return !Util.isVisible(delta.getOldModifiers());
      }
      break;
    case 1: 
      switch (delta.getFlags())
      {
      case 49: 
        return !Util.isVisible(delta.getNewModifiers());
      }
      break;
    case 2: 
      switch (delta.getFlags())
      {
      case 30: 
      case 33: 
      case 38: 
      case 55: 
        return !Util.isVisible(delta.getNewModifiers());
      case 11: 
        return RestrictionModifiers.isExtendRestriction(restrictions);
      }
      break;
    }
    return true;
  }
  
  private static boolean isEnumCompatible(IDelta delta)
  {
    switch (delta.getKind())
    {
    case 1: 
      switch (delta.getFlags())
      {
      case 16: 
      case 25: 
        return !Util.isVisible(delta.getNewModifiers());
      }
      break;
    case 3: 
      switch (delta.getFlags())
      {
      case 8: 
      case 12: 
      case 16: 
      case 25: 
      case 48: 
        return !Util.isVisible(delta.getOldModifiers());
      case 61: 
      case 62: 
      case 63: 
      case 64: 
        return false;
      }
      break;
    case 2: 
      if (!Util.isVisible(delta.getNewModifiers())) {
        return true;
      }
      switch (delta.getFlags())
      {
      case 10: 
      case 30: 
      case 41: 
        return false;
      case 11: 
        return !Util.isVisible(delta.getOldModifiers());
      }
      break;
    }
    return true;
  }
  
  private static boolean isClassCompatible(IDelta delta)
  {
    switch (delta.getKind())
    {
    case 1: 
      int newModifiers = delta.getNewModifiers();
      switch (delta.getFlags())
      {
      case 16: 
        return true;
      case 25: 
        if ((Util.isVisible(newModifiers)) && 
          (Flags.isAbstract(newModifiers))) {
          return RestrictionModifiers.isExtendRestriction(delta.getCurrentRestrictions());
        }
        return true;
      case 37: 
      case 49: 
        return !Util.isVisible(newModifiers);
      }
      break;
    case 3: 
      switch (delta.getFlags())
      {
      case 16: 
      case 25: 
      case 48: 
      case 61: 
      case 62: 
        if (Flags.isPublic(delta.getOldModifiers())) {
          return false;
        }
        if (Flags.isProtected(delta.getOldModifiers())) {
          return RestrictionModifiers.isExtendRestriction(delta.getCurrentRestrictions());
        }
        return true;
      case 8: 
      case 63: 
        if (Util.isVisible(delta.getOldModifiers())) {
          return (RestrictionModifiers.isExtendRestriction(delta.getCurrentRestrictions())) && ((Flags.isProtected(delta.getOldModifiers())) || (RestrictionModifiers.isInstantiateRestriction(delta.getCurrentRestrictions())));
        }
        return true;
      case 39: 
      case 49: 
        return !Util.isVisible(delta.getOldModifiers());
      }
      break;
    case 2: 
      switch (delta.getFlags())
      {
      case 30: 
        if (Util.isVisible(delta.getNewModifiers())) {
          return RestrictionModifiers.isInstantiateRestriction(delta.getCurrentRestrictions());
        }
        return true;
      case 10: 
      case 33: 
      case 38: 
      case 41: 
        return !Util.isVisible(delta.getNewModifiers());
      case 31: 
        if (Util.isVisible(delta.getNewModifiers())) {
          return RestrictionModifiers.isExtendRestriction(delta.getCurrentRestrictions());
        }
        return true;
      case 11: 
        return RestrictionModifiers.isExtendRestriction(delta.getCurrentRestrictions());
      }
      break;
    }
    return true;
  }
  
  private static boolean isTypeParameterCompatible(IDelta delta)
  {
    switch (delta.getKind())
    {
    case 1: 
      switch (delta.getFlags())
      {
      case 6: 
      case 23: 
        return false;
      }
      break;
    case 3: 
      switch (delta.getFlags())
      {
      case 6: 
      case 23: 
        return false;
      }
      break;
    case 2: 
      switch (delta.getFlags())
      {
      case 6: 
      case 23: 
        return false;
      }
      break;
    }
    return true;
  }
  
  private static boolean isInterfaceCompatible(IDelta delta)
  {
    switch (delta.getKind())
    {
    case 1: 
      switch (delta.getFlags())
      {
      case 16: 
      case 25: 
      case 69: 
        return (RestrictionModifiers.isImplementRestriction(delta.getPreviousRestrictions())) || (RestrictionModifiers.isImplementRestriction(delta.getCurrentRestrictions()));
      case 49: 
        return false;
      case 37: 
        return false;
      }
      break;
    case 3: 
      switch (delta.getFlags())
      {
      case 16: 
      case 25: 
      case 48: 
      case 49: 
      case 61: 
      case 62: 
        return false;
      }
      break;
    case 2: 
      switch (delta.getFlags())
      {
      case 10: 
      case 41: 
        return false;
      case 11: 
        return RestrictionModifiers.isExtendRestriction(delta.getCurrentRestrictions());
      }
      break;
    }
    return true;
  }
}

/* Location:
 * Qualified Name:     org.eclipse.pde.api.tools.internal.provisional.comparator.DeltaProcessor
 * Java Class Version: 1.2 (46.0)
 * JD-Core Version:    0.7.1
 */
package org.eclipse.pde.api.tools.internal.provisional.comparator;

public class DeltaVisitor
{
  public boolean visit(IDelta delta)
  {
    return true;
  }
  
  public void endVisit(IDelta delta) {}
}

/* Location:
 * Qualified Name:     org.eclipse.pde.api.tools.internal.provisional.comparator.DeltaVisitor
 * Java Class Version: 1.2 (46.0)
 * JD-Core Version:    0.7.1
 */
package org.eclipse.pde.api.tools.internal.provisional.comparator;

public abstract interface IDelta
{
  public static final int ADDED = 1;
  public static final int CHANGED = 2;
  public static final int REMOVED = 3;
  public static final int ANNOTATION_ELEMENT_TYPE = 1;
  public static final int API_COMPONENT_ELEMENT_TYPE = 2;
  public static final int API_BASELINE_ELEMENT_TYPE = 3;
  public static final int CLASS_ELEMENT_TYPE = 4;
  public static final int CONSTRUCTOR_ELEMENT_TYPE = 5;
  public static final int ENUM_ELEMENT_TYPE = 6;
  public static final int FIELD_ELEMENT_TYPE = 7;
  public static final int INTERFACE_ELEMENT_TYPE = 8;
  public static final int METHOD_ELEMENT_TYPE = 9;
  public static final int TYPE_PARAMETER_ELEMENT_TYPE = 10;
  public static final int ABSTRACT_TO_NON_ABSTRACT = 1;
  public static final int ANNOTATION_DEFAULT_VALUE = 2;
  public static final int API_COMPONENT = 3;
  public static final int ARRAY_TO_VARARGS = 4;
  public static final int CHECKED_EXCEPTION = 5;
  public static final int CLASS_BOUND = 6;
  public static final int CLINIT = 7;
  public static final int CONSTRUCTOR = 8;
  public static final int CONTRACTED_SUPERINTERFACES_SET = 10;
  public static final int DECREASE_ACCESS = 11;
  public static final int ENUM_CONSTANT = 12;
  public static final int EXECUTION_ENVIRONMENT = 13;
  public static final int EXPANDED_SUPERINTERFACES_SET = 15;
  public static final int FIELD = 16;
  public static final int FIELD_MOVED_UP = 17;
  public static final int FINAL_TO_NON_FINAL = 18;
  public static final int FINAL_TO_NON_FINAL_NON_STATIC = 19;
  public static final int FINAL_TO_NON_FINAL_STATIC_CONSTANT = 20;
  public static final int FINAL_TO_NON_FINAL_STATIC_NON_CONSTANT = 21;
  public static final int INCREASE_ACCESS = 22;
  public static final int INTERFACE_BOUND = 23;
  public static final int METHOD = 25;
  public static final int METHOD_MOVED_UP = 26;
  public static final int METHOD_WITH_DEFAULT_VALUE = 27;
  public static final int METHOD_WITHOUT_DEFAULT_VALUE = 28;
  public static final int NATIVE_TO_NON_NATIVE = 29;
  public static final int NON_ABSTRACT_TO_ABSTRACT = 30;
  public static final int NON_FINAL_TO_FINAL = 31;
  public static final int NON_NATIVE_TO_NATIVE = 32;
  public static final int NON_STATIC_TO_STATIC = 33;
  public static final int NON_SYNCHRONIZED_TO_SYNCHRONIZED = 34;
  public static final int NON_TRANSIENT_TO_TRANSIENT = 35;
  public static final int OVERRIDEN_METHOD = 36;
  public static final int RESTRICTIONS = 37;
  public static final int STATIC_TO_NON_STATIC = 38;
  public static final int SUPERCLASS = 39;
  public static final int SYNCHRONIZED_TO_NON_SYNCHRONIZED = 40;
  public static final int TYPE_CONVERSION = 41;
  public static final int TRANSIENT_TO_NON_TRANSIENT = 45;
  public static final int TYPE = 46;
  public static final int TYPE_ARGUMENTS = 47;
  public static final int TYPE_MEMBER = 48;
  public static final int TYPE_PARAMETER = 49;
  public static final int TYPE_PARAMETER_NAME = 50;
  public static final int TYPE_PARAMETERS = 51;
  public static final int TYPE_VISIBILITY = 52;
  public static final int UNCHECKED_EXCEPTION = 53;
  public static final int VALUE = 54;
  public static final int VARARGS_TO_ARRAY = 55;
  public static final int API_TYPE = 56;
  public static final int NON_VOLATILE_TO_VOLATILE = 57;
  public static final int VOLATILE_TO_NON_VOLATILE = 58;
  public static final int MAJOR_VERSION = 59;
  public static final int MINOR_VERSION = 60;
  public static final int API_FIELD = 61;
  public static final int API_METHOD = 62;
  public static final int API_CONSTRUCTOR = 63;
  public static final int API_ENUM_CONSTANT = 64;
  public static final int API_METHOD_WITH_DEFAULT_VALUE = 65;
  public static final int API_METHOD_WITHOUT_DEFAULT_VALUE = 66;
  public static final int METHOD_MOVED_DOWN = 67;
  public static final int TYPE_ARGUMENT = 68;
  public static final int SUPER_INTERFACE_WITH_METHODS = 69;
  public static final int REEXPORTED_TYPE = 70;
  public static final int REEXPORTED_API_TYPE = 71;
  public static final int DEPRECATION = 72;
  
  public abstract boolean isEmpty();
  
  public abstract String getKey();
  
  public abstract int getKind();
  
  public abstract int getFlags();
  
  public abstract int getElementType();
  
  public abstract IDelta[] getChildren();
  
  public abstract void accept(DeltaVisitor paramDeltaVisitor);
  
  public abstract String getTypeName();
  
  public abstract String getMessage();
  
  public abstract String[] getArguments();
  
  public abstract int getCurrentRestrictions();
  
  public abstract int getPreviousRestrictions();
  
  public abstract int getNewModifiers();
  
  public abstract int getOldModifiers();
  
  public abstract String getComponentVersionId();
  
  public abstract String getComponentId();
}

/* Location:
 * Qualified Name:     org.eclipse.pde.api.tools.internal.provisional.comparator.IDelta
 * Java Class Version: 1.2 (46.0)
 * JD-Core Version:    0.7.1
 */
package org.eclipse.pde.api.tools.internal.provisional.descriptors;

public abstract interface IComponentDescriptor
  extends IElementDescriptor
{
  public abstract String getId();
  
  public abstract String getVersion();
}

/* Location:
 * Qualified Name:     org.eclipse.pde.api.tools.internal.provisional.descriptors.IComponentDescriptor
 * Java Class Versi
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

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