org-openide-modules

16:40:38.563 INFO  jd.cli.Main - Decompiling org-openide-modules.jar
package org.netbeans.modules.openide.modules;

import java.io.IOException;
import java.io.OutputStream;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.Set;
import javax.annotation.processing.AbstractProcessor;
import javax.annotation.processing.Filer;
import javax.annotation.processing.Messager;
import javax.annotation.processing.ProcessingEnvironment;
import javax.annotation.processing.RoundEnvironment;
import javax.annotation.processing.SupportedSourceVersion;
import javax.lang.model.SourceVersion;
import javax.lang.model.element.Element;
import javax.lang.model.element.Modifier;
import javax.lang.model.element.TypeElement;
import javax.tools.Diagnostic.Kind;
import javax.tools.FileObject;
import javax.tools.StandardLocation;
import org.openide.modules.PatchedPublic;

@SupportedSourceVersion(SourceVersion.RELEASE_6)
public class PatchedPublicProcessor
  extends AbstractProcessor
{
  private List<Element> originatingElements;
  
  public Set<String> getSupportedAnnotationTypes()
  {
    return Collections.singleton(PatchedPublic.class.getCanonicalName());
  }
  
  public synchronized void init(ProcessingEnvironment paramProcessingEnvironment)
  {
    super.init(paramProcessingEnvironment);
    originatingElements = new ArrayList();
  }
  
  public boolean process(Set<? extends TypeElement> paramSet, RoundEnvironment paramRoundEnvironment)
  {
    if (paramRoundEnvironment.processingOver())
    {
      if (!originatingElements.isEmpty()) {
        try
        {
          processingEnv.getFiler().createResource(StandardLocation.CLASS_OUTPUT, "", "META-INF/.bytecodePatched", (Element[])originatingElements.toArray(new Element[originatingElements.size()])).openOutputStream().close();
        }
        catch (IOException localIOException)
        {
          processingEnv.getMessager().printMessage(Diagnostic.Kind.ERROR, localIOException.getMessage());
        }
      }
      return false;
    }
    for (Element localElement : paramRoundEnvironment.getElementsAnnotatedWith(PatchedPublic.class)) {
      if (localElement.getAnnotationMirrors().size() > 1) {
        processingEnv.getMessager().printMessage(Diagnostic.Kind.ERROR, "Cannot currently mix @PatchedPublic with other annotations", localElement);
      } else if (localElement.getModifiers().contains(Modifier.PUBLIC)) {
        processingEnv.getMessager().printMessage(Diagnostic.Kind.ERROR, "@PatchedPublic cannot be applied to what is already public", localElement);
      } else {
        originatingElements.add(localElement);
      }
    }
    return true;
  }
}

/* Location:
 * Qualified Name:     org.netbeans.modules.openide.modules.PatchedPublicProcessor
 * Java Class Version: 6 (50.0)
 * JD-Core Version:    0.7.1
 */
package org.openide.modules;

final class Dependency$DependencyKey
{
  private final int type;
  private final String name;
  
  public Dependency$DependencyKey(Dependency paramDependency)
  {
    type = paramDependency.getType();
    int i;
    switch (type)
    {
    case 1: 
    case 4: 
      String str1 = paramDependency.getName();
      i = str1.lastIndexOf('/');
      if (i == -1) {
        name = str1;
      } else {
        name = str1.substring(0, i);
      }
      break;
    case 2: 
      String str2 = paramDependency.getName();
      i = str2.indexOf('[');
      if (i != -1)
      {
        if (i == 0) {
          name = str2;
        } else {
          name = str2.substring(0, i);
        }
      }
      else {
        name = str2;
      }
      break;
    case 3: 
    default: 
      name = paramDependency.getName();
    }
  }
  
  public int hashCode()
  {
    return name.hashCode();
  }
  
  public boolean equals(Object paramObject)
  {
    return ((paramObject instanceof DependencyKey)) && (name.equals(name)) && (type == type);
  }
  
  public String toString()
  {
    return "DependencyKey[" + name + "," + type + "]";
  }
}

/* Location:
 * Qualified Name:     org.openide.modules.Dependency.DependencyKey
 * Java Class Version: 6 (50.0)
 * JD-Core Version:    0.7.1
 */
package org.openide.modules;

import java.io.PrintStream;
import java.io.Serializable;
import java.util.Collections;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Map;
import java.util.Set;
import java.util.StringTokenizer;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import org.openide.util.Utilities;

public final class Dependency
  implements Serializable
{
  static final long serialVersionUID = 9548259318L;
  public static final int TYPE_MODULE = 1;
  public static final int TYPE_PACKAGE = 2;
  public static final int TYPE_JAVA = 3;
  @Deprecated
  public static final int TYPE_IDE = 4;
  public static final int TYPE_REQUIRES = 5;
  public static final int TYPE_NEEDS = 6;
  public static final int TYPE_RECOMMENDS = 7;
  public static final int COMPARE_SPEC = 1;
  public static final int COMPARE_IMPL = 2;
  public static final int COMPARE_ANY = 3;
  @Deprecated
  public static final String IDE_NAME = System.getProperty("org.openide.major.version", "IDE");
  @Deprecated
  public static final SpecificationVersion IDE_SPEC = makeSpec(System.getProperty("org.openide.specification.version"));
  @Deprecated
  public static final String IDE_IMPL = System.getProperty("org.openide.version");
  public static final String JAVA_NAME = "Java";
  public static final SpecificationVersion JAVA_SPEC = makeSpec(System.getProperty("java.specification.version"));
  public static final String JAVA_IMPL = System.getProperty("java.version");
  public static final String VM_NAME = "VM";
  public static final SpecificationVersion VM_SPEC = makeSpec(System.getProperty("java.vm.specification.version"));
  public static final String VM_IMPL = System.getProperty("java.vm.version");
  private final int type;
  private final int comparison;
  private final String name;
  private final String version;
  private static final String IDENTIFIER = "(?:\\p{javaJavaIdentifierStart}\\p{javaJavaIdentifierPart}*)";
  
  private Dependency(int paramInt1, String paramString1, int paramInt2, String paramString2)
  {
    type = paramInt1;
    name = paramString1.intern();
    comparison = paramInt2;
    version = (paramString2 != null ? paramString2.intern() : null);
  }
  
  private static void checkCodeName(String paramString, boolean paramBoolean)
    throws IllegalArgumentException
  {
    int i = paramString.indexOf('/');
    String str1;
    if (i == -1)
    {
      str1 = paramString;
    }
    else
    {
      if (!paramBoolean) {
        throw new IllegalArgumentException("No slash permitted in: " + paramString);
      }
      str1 = paramString.substring(0, i);
      
      String str2 = paramString.substring(i + 1);
      int j = str2.indexOf('-');
      try
      {
        int k;
        if (j == -1)
        {
          k = Integer.parseInt(str2);
          if (k < 0) {
            throw new IllegalArgumentException("Negative release number: " + paramString);
          }
        }
        else
        {
          k = Integer.parseInt(str2.substring(0, j));
          int m = Integer.parseInt(str2.substring(j + 1));
          if (k < 0) {
            throw new IllegalArgumentException("Negative release number: " + paramString);
          }
          if (m <= k) {
            throw new IllegalArgumentException("Release number range must be increasing: " + paramString);
          }
        }
      }
      catch (NumberFormatException localNumberFormatException)
      {
        throw new IllegalArgumentException(localNumberFormatException.toString());
      }
    }
    if (!FQN.matcher(str1).matches()) {
      throw new IllegalArgumentException("Malformed dot-separated identifier: " + str1);
    }
  }
  
  private static final Pattern FQN = Pattern.compile("(?:\\p{javaJavaIdentifierStart}\\p{javaJavaIdentifierPart}*)(?:[.](?:\\p{javaJavaIdentifierStart}\\p{javaJavaIdentifierPart}*))*");
  
  public static Set<Dependency> create(int paramInt, String paramString)
    throws IllegalArgumentException
  {
    if (paramString == null) {
      return Collections.emptySet();
    }
    HashSet localHashSet = new HashSet(5);
    
    StringTokenizer localStringTokenizer1 = new StringTokenizer(paramString, ",");
    if (!localStringTokenizer1.hasMoreTokens()) {
      throw new IllegalArgumentException("No deps given: \"" + paramString + "\"");
    }
    HashMap localHashMap = new HashMap(11);
    while (localStringTokenizer1.hasMoreTokens())
    {
      String str1 = localStringTokenizer1.nextToken();
      StringTokenizer localStringTokenizer2 = new StringTokenizer(str1, " \t\n\r");
      if (!localStringTokenizer2.hasMoreTokens()) {
        throw new IllegalArgumentException("No name in dependency: " + str1);
      }
      String str2 = localStringTokenizer2.nextToken();
      int i;
      String str3;
      if (localStringTokenizer2.hasMoreTokens())
      {
        String str4 = localStringTokenizer2.nextToken();
        if (str4.equals(">")) {
          i = 1;
        } else if (str4.equals("=")) {
          i = 2;
        } else {
          throw new IllegalArgumentException("Strange comparison string: " + str4);
        }
        if (!localStringTokenizer2.hasMoreTokens()) {
          throw new IllegalArgumentException("Comparison string without version: " + str1);
        }
        str3 = localStringTokenizer2.nextToken();
        if (localStringTokenizer2.hasMoreTokens()) {
          throw new IllegalArgumentException("Trailing garbage in dependency: " + str1);
        }
        if (i == 1) {
          try
          {
            new SpecificationVersion(str3);
          }
          catch (NumberFormatException localNumberFormatException1)
          {
            throw new IllegalArgumentException(localNumberFormatException1.toString());
          }
        }
      }
      else
      {
        i = 3;
        str3 = null;
      }
      if (paramInt == 1)
      {
        checkCodeName(str2, true);
        if ((str2.indexOf('-') != -1) && (i == 2)) {
          throw new IllegalArgumentException("Cannot have an implementation dependency on a ranged release version: " + str1);
        }
      }
      else
      {
        int j;
        if (paramInt == 2)
        {
          j = str2.indexOf('[');
          if (j != -1)
          {
            if (j > 0) {
              checkCodeName(str2.substring(0, j), false);
            }
            if (str2.charAt(str2.length() - 1) != ']') {
              throw new IllegalArgumentException("No close bracket on package dep: " + str2);
            }
            checkCodeName(str2.substring(j + 1, str2.length() - 1), false);
          }
          else
          {
            checkCodeName(str2, false);
          }
          if ((j == 0) && (i != 3)) {
            throw new IllegalArgumentException("Cannot use a version comparison on a package dependency when only a sample class is given");
          }
          if ((j > 0) && (str2.substring(j + 1, str2.length() - 1).indexOf('.') != -1)) {
            throw new IllegalArgumentException("Cannot have a sample class with dots when package is specified");
          }
        }
        else if (paramInt == 3)
        {
          if ((!str2.equals("Java")) && (!str2.equals("VM"))) {
            throw new IllegalArgumentException("Java dependency must be on \"Java\" or \"VM\": " + str2);
          }
          if (i == 3) {
            throw new IllegalArgumentException("Must give a comparison for a Java dep: " + paramString);
          }
        }
        else if (paramInt == 4)
        {
          if (!str2.equals("IDE"))
          {
            j = str2.indexOf("/");
            int k;
            if (j == -1)
            {
              k = 0;
            }
            else
            {
              if (!str2.substring(0, j).equals("IDE")) {
                k = 0;
              }
              try
              {
                int m = Integer.parseInt(str2.substring(j + 1));
                k = m >= 0 ? 1 : 0;
              }
              catch (NumberFormatException localNumberFormatException2)
              {
                k = 0;
              }
            }
            if (k == 0) {
              throw new IllegalArgumentException("Invalid IDE dependency: " + str2);
            }
          }
          if (i == 3) {
            throw new IllegalArgumentException("Must give a comparison for an IDE dep: " + paramString);
          }
        }
        else if (paramInt == 5)
        {
          if (i != 3) {
            throw new IllegalArgumentException("Cannot give a comparison for a token requires dep: " + paramString);
          }
          checkCodeName(str2, false);
        }
        else if (paramInt == 6)
        {
          if (i != 3) {
            throw new IllegalArgumentException("Cannot give a comparison for a token needs dep: " + paramString);
          }
          checkCodeName(str2, false);
        }
        else if (paramInt == 7)
        {
          if (i != 3) {
            throw new IllegalArgumentException("Cannot give a comparison for a token needs dep: " + paramString);
          }
          checkCodeName(str2, false);
        }
        else
        {
          throw new IllegalArgumentException("unknown type");
        }
      }
      Dependency localDependency = new Dependency(paramInt, str2, i, str3);
      DependencyKey localDependencyKey = new DependencyKey(localDependency);
      if (localHashMap.containsKey(localDependencyKey)) {
        throw new IllegalArgumentException("Dependency " + localDependency + " duplicates the similar dependency " + localHashMap.get(localDependencyKey));
      }
      localHashSet.add(localDependency);
      localHashMap.put(localDependencyKey, localDependency);
    }
    return localHashSet;
  }
  
  public final int getType()
  {
    return type;
  }
  
  public final String getName()
  {
    return name;
  }
  
  public final int getComparison()
  {
    return comparison;
  }
  
  public final String getVersion()
  {
    return version;
  }
  
  public boolean equals(Object paramObject)
  {
    if (paramObject.getClass() != Dependency.class) {
      return false;
    }
    Dependency localDependency = (Dependency)paramObject;
    
    return (type == type) && (comparison == comparison) && (name.equals(name)) && (Utilities.compareObjects(version, version));
  }
  
  public int hashCode()
  {
    return 0xBC7E3 ^ type ^ name.hashCode();
  }
  
  public String toString()
  {
    StringBuffer localStringBuffer = new StringBuffer(100);
    if (type == 1) {
      localStringBuffer.append("module ");
    } else if (type == 2) {
      localStringBuffer.append("package ");
    } else if (type == 5) {
      localStringBuffer.append("requires ");
    } else if (type == 6) {
      localStringBuffer.append("needs ");
    } else if (type == 7) {
      localStringBuffer.append("recommends ");
    }
    localStringBuffer.append(name);
    if (comparison == 2)
    {
      localStringBuffer.append(" = ");
      localStringBuffer.append(version);
    }
    else if (comparison == 1)
    {
      localStringBuffer.append(" > ");
      localStringBuffer.append(version);
    }
    return localStringBuffer.toString();
  }
  
  private static SpecificationVersion makeSpec(String paramString)
  {
    if (paramString != null)
    {
      try
      {
        return new SpecificationVersion(paramString);
      }
      catch (NumberFormatException localNumberFormatException1)
      {
        System.err.println("WARNING: invalid specification version: " + paramString);
      }
      do
      {
        paramString = paramString.substring(0, paramString.length() - 1);
        try
        {
          return new SpecificationVersion(paramString);
        }
        catch (NumberFormatException localNumberFormatException2) {}
      } while (paramString.length() > 0);
    }
    return new SpecificationVersion("0");
  }
  
  private static final class DependencyKey
  {
    private final int type;
    private final String name;
    
    public DependencyKey(Dependency paramDependency)
    {
      type = paramDependency.getType();
      int i;
      switch (type)
      {
      case 1: 
      case 4: 
        String str1 = paramDependency.getName();
        i = str1.lastIndexOf('/');
        if (i == -1) {
          name = str1;
        } else {
          name = str1.substring(0, i);
        }
        break;
      case 2: 
        String str2 = paramDependency.getName();
        i = str2.indexOf('[');
        if (i != -1)
        {
          if (i == 0) {
            name = str2;
          } else {
            name = str2.substring(0, i);
          }
        }
        else {
          name = str2;
        }
        break;
      case 3: 
      default: 
        name = paramDependency.getName();
      }
    }
    
    public int hashCode()
    {
      return name.hashCode();
    }
    
    public boolean equals(Object paramObject)
    {
      return ((paramObject instanceof DependencyKey)) && (name.equals(name)) && (type == type);
    }
    
    public String toString()
    {
      return "DependencyKey[" + name + "," + type + "]";
    }
  }
}

/* Location:
 * Qualified Name:     org.openide.modules.Dependency
 * Java Class Version: 6 (50.0)
 * JD-Core Version:    0.7.1
 */
package org.openide.modules;

import java.io.File;
import java.util.Collection;
import java.util.Collections;
import java.util.LinkedHashSet;
import java.util.Set;

final class InstalledFileLocator$1
  extends InstalledFileLocator
{
  public File locate(String paramString1, String paramString2, boolean paramBoolean)
  {
    InstalledFileLocator[] arrayOfInstalledFileLocator = InstalledFileLocator.access$000();
    for (int i = 0; i < arrayOfInstalledFileLocator.length; i++)
    {
      File localFile = arrayOfInstalledFileLocator[i].locate(paramString1, paramString2, paramBoolean);
      if (localFile != null) {
        return localFile;
      }
    }
    return null;
  }
  
  public Set<File> locateAll(String paramString1, String paramString2, boolean paramBoolean)
  {
    Object localObject = null;
    for (InstalledFileLocator localInstalledFileLocator : InstalledFileLocator.access$000())
    {
      Set localSet = localInstalledFileLocator.locateAll(paramString1, paramString2, paramBoolean);
      if (!localSet.isEmpty()) {
        if (localObject == null)
        {
          localObject = localSet;
        }
        else
        {
          localObject = new LinkedHashSet((Collection)localObject);
          ((Set)localObject).addAll(localSet);
        }
      }
    }
    return (Set<File>)(localObject != null ? localObject : Collections.emptySet());
  }
}

/* Location:
 * Qualified Name:     org.openide.modules.InstalledFileLocator.1
 * Java Class Version: 6 (50.0)
 * JD-Core Version:    0.7.1
 */
package org.openide.modules;

import org.openide.util.LookupEvent;
import org.openide.util.LookupListener;

final class InstalledFileLocator$2
  implements LookupListener
{
  public void resultChanged(LookupEvent paramLookupEvent)
  {
    synchronized ()
    {
      InstalledFileLocator.access$202(null);
    }
  }
}

/* Location:
 * Qualified Name:     org.openide.modules.InstalledFileLocator.2
 * Java Class Version: 6 (50.0)
 * JD-Core Version:    0.7.1
 */
package org.openide.modules;

import java.io.File;
import java.util.Collection;
import java.util.Collections;
import java.util.LinkedHashSet;
import java.util.Set;
import org.openide.util.Lookup.Result;
import org.openide.util.LookupEvent;
import org.openide.util.LookupListener;

public abstract class InstalledFileLocator
{
  private static final InstalledFileLocator DEFAULT = new InstalledFileLocator()
  {
    public File locate(String paramAnonymousString1, String paramAnonymousString2, boolean paramAnonymousBoolean)
    {
      InstalledFileLocator[] arrayOfInstalledFileLocator = InstalledFileLocator.access$000();
      for (int i = 0; i < arrayOfInstalledFileLocator.length; i++)
      {
        File localFile = arrayOfInstalledFileLocator[i].locate(paramAnonymousString1, paramAnonymousString2, paramAnonymousBoolean);
        if (localFile != null) {
          return localFile;
        }
      }
      return null;
    }
    
    public Set<File> locateAll(String paramAnonymousString1, String paramAnonymousString2, boolean paramAnonymousBoolean)
    {
      Object localObject = null;
      for (InstalledFileLocator localInstalledFileLocator : InstalledFileLocator.access$000())
      {
        Set localSet = localInstalledFileLocator.locateAll(paramAnonymousString1, paramAnonymousString2, paramAnonymousBoolean);
        if (!localSet.isEmpty()) {
          if (localObject == null)
          {
            localObject = localSet;
          }
          else
          {
            localObject = new LinkedHashSet((Collection)localObject);
            ((Set)localObject).addAll(localSet);
          }
        }
      }
      return (Set<File>)(localObject != null ? localObject : Collections.emptySet());
    }
  };
  private static InstalledFileLocator[] instances = null;
  private static Lookup.Result<InstalledFileLocator> result = null;
  private static final Object LOCK = new String(InstalledFileLocator.class.getName());
  
  public abstract File locate(String paramString1, String paramString2, boolean paramBoolean);
  
  public Set<File> locateAll(String paramString1, String paramString2, boolean paramBoolean)
  {
    File localFile = locate(paramString1, paramString2, paramBoolean);
    return localFile != null ? Collections.singleton(localFile) : Collections.emptySet();
  }
  
  public static InstalledFileLocator getDefault()
  {
    return DEFAULT;
  }
  
  /* Error */
  private static InstalledFileLocator[] getInstances()
  {
    // Byte code:
    //   0: getstatic 2	org/openide/modules/InstalledFileLocator:LOCK	Ljava/lang/Object;
    //   3: dup
    //   4: astore_0
    //   5: monitorenter
    //   6: getstatic 1	org/openide/modules/InstalledFileLocator:instances	[Lorg/openide/modules/InstalledFileLocator;
    //   9: ifnull +9 -> 18
    //   12: getstatic 1	org/openide/modules/InstalledFileLocator:instances	[Lorg/openide/modules/InstalledFileLocator;
    //   15: aload_0
    //   16: monitorexit
    //   17: areturn
    //   18: aload_0
    //   19: monitorexit
    //   20: goto +8 -> 28
    //   23: astore_1
    //   24: aload_0
    //   25: monitorexit
    //   26: aload_1
    //   27: athrow
    //   28: getstatic 2	org/openide/modules/InstalledFileLocator:LOCK	Ljava/lang/Object;
    //   31: dup
    //   32: astore_1
    //   33: monitorenter
    //   34: getstatic 9	org/openide/modules/InstalledFileLocator:result	Lorg/openide/util/Lookup$Result;
    //   37: astore_0
    //   38: aload_1
    //   39: monitorexit
    //   40: goto +8 -> 48
    //   43: astore_2
    //   44: aload_1
    //   45: monitorexit
    //   46: aload_2
    //   47: athrow
    //   48: aload_0
    //   49: ifnonnull +44 -> 93
    //   52: invokestatic 10	org/openide/util/Lookup:getDefault	()Lorg/openide/util/Lookup;
    //   55: ldc_w 11
    //   58: invokevirtual 12	org/openide/util/Lookup:lookupResult	(Ljava/lang/Class;)Lorg/openide/util/Lookup$Result;
    //   61: astore_0
    //   62: aload_0
    //   63: new 13	org/openide/modules/InstalledFileLocator$2
    //   66: dup
    //   67: invokespecial 14	org/openide/modules/InstalledFileLocator$2:<init>	()V
    //   70: invokevirtual 15	org/openide/util/Lookup$Result:addLookupListener	(Lorg/openide/util/LookupListener;)V
    //   73: getstatic 2	org/openide/modules/InstalledFileLocator:LOCK	Ljava/lang/Object;
    //   76: dup
    //   77: astore_1
    //   78: monitorenter
    //   79: aload_0
    //   80: putstatic 9	org/openide/modules/InstalledFileLocator:result	Lorg/openide/util/Lookup$Result;
    //   83: aload_1
    //   84: monitorexit
    //   85: goto +8 -> 93
    //   88: astore_3
    //   89: aload_1
    //   90: monitorexit
    //   91: aload_3
    //   92: athrow
    //   93: aload_0
    //   94: invokevirtual 16	org/openide/util/Lookup$Result:allInstances	()Ljava/util/Collection;
    //   97: astore_1
    //   98: getstatic 2	org/openide/modules/InstalledFileLocator:LOCK	Ljava/lang/Object;
    //   101: dup
    //   102: astore_2
    //   103: monitorenter
    //   104: aload_1
    //   105: aload_1
    //   106: invokeinterface 17 1 0
    //   111: anewarray 11	org/openide/modules/InstalledFileLocator
    //   114: invokeinterface 18 2 0
    //   119: checkcast 19	[Lorg/openide/modules/InstalledFileLocator;
    //   122: dup
    //   123: putstatic 1	org/openide/modules/InstalledFileLocator:instances	[Lorg/openide/modules/InstalledFileLocator;
    //   126: aload_2
    //   127: monitorexit
    //   128: areturn
    //   129: astore 4
    //   131: aload_2
    //   132: monitorexit
    //   133: aload 4
    //   135: athrow
    // Line number table:
    //   Java source line #240	-> byte code offset #0
    //   Java source line #241	-> byte code offset #6
    //   Java source line #242	-> byte code offset #12
    //   Java source line #244	-> byte code offset #18
    //   Java source line #247	-> byte code offset #28
    //   Java source line #248	-> byte code offset #34
    //   Java source line #249	-> byte code offset #38
    //   Java source line #250	-> byte code offset #48
    //   Java source line #251	-> byte code offset #52
    //   Java source line #252	-> byte code offset #62
    //   Java source line #259	-> byte code offset #73
    //   Java source line #260	-> byte code offset #79
    //   Java source line #261	-> byte code offset #83
    //   Java source line #264	-> byte code offset #93
    //   Java source line #265	-> byte code offset #98
    //   Java source line #266	-> byte code offset #104
    //   Java source line #267	-> byte code offset #129
    // Local variable table:
    //   start	length	slot	name	signature
    //   4	90	0	Ljava/lang/Object;	Object
    //   23	4	1	localObject1	Object
    //   32	74	1	Ljava/lang/Object;	Object
    //   43	4	2	localObject2	Object
    //   102	30	2	Ljava/lang/Object;	Object
    //   88	4	3	localObject3	Object
    //   129	5	4	localObject4	Object
    // Exception table:
    //   from	to	target	type
    //   6	17	23	finally
    //   18	20	23	finally
    //   23	26	23	finally
    //   34	40	43	finally
    //   43	46	43	finally
    //   79	85	88	finally
    //   88	91	88	finally
    //   104	128	129	finally
    //   129	133	129	finally
  }
}

/* Location:
 * Qualified Name:     org.openide.modules.InstalledFileLocator
 * Java Class Version: 6 (50.0)
 * JD-Core Version:    0.7.1
 */
package org.openide.modules;

import java.beans.PropertyChangeListener;
import java.beans.PropertyChangeSupport;
import java.util.Set;

public abstract class ModuleInfo
{
  public static final String PROP_ENABLED = "enabled";
  private final PropertyChangeSupport changeSupport = new PropertyChangeSupport(this);
  
  public abstract String getCodeNameBase();
  
  public abstract int getCodeNameRelease();
  
  public abstract String getCodeName();
  
  public String getDisplayName()
  {
    String str = (String)getLocalizedAttribute("OpenIDE-Module-Name");
    if (str != null) {
      return str;
    }
    return getCodeNameBase();
  }
  
  public abstract SpecificationVersion getSpecificationVersion();
  
  public String getImplementationVersion()
  {
    return (String)getAttribute("OpenIDE-Module-Implementation-Version");
  }
  
  public String getBuildVersion()
  {
    String str = (String)getAttribute("OpenIDE-Module-Build-Version");
    
    return str == null ? getImplementationVersion() : str;
  }
  
  public abstract boolean isEnabled();
  
  public abstract Object getAttribute(String paramString);
  
  public abstract Object getLocalizedAttribute(String paramString);
  
  public final void addPropertyChangeListener(PropertyChangeListener paramPropertyChangeListener)
  {
    if (paramPropertyChangeListener == null) {
      throw new NullPointerException("If you see this stack trace, please attach to: http://www.netbeans.org/issues/show_bug.cgi?id=22379");
    }
    changeSupport.addPropertyChangeListener(paramPropertyChangeListener);
  }
  
  public final void removePropertyChangeListener(PropertyChangeListener paramPropertyChangeListener)
  {
    changeSupport.removePropertyChangeListener(paramPropertyChangeListener);
  }
  
  protected final void firePropertyChange(String paramString, Object paramObject1, Object paramObject2)
  {
    changeSupport.firePropertyChange(paramString, paramObject1, paramObject2);
  }
  
  public abstract Set<Dependency> getDependencies();
  
  public abstract boolean owns(Class<?> paramClass);
  
  public ClassLoader getClassLoader()
    throws IllegalArgumentException
  {
    throw new UnsupportedOperationException("Must be overridden");
  }
  
  public String[] getProvides()
  {
    return new String[0];
  }
}

/* Location:
 * Qualified Name:     org.openide.modules.ModuleInfo
 * Java Class Version: 6 (50.0)
 * JD-Core Version:    0.7.1
 */
package org.openide.modules;

import org.openide.util.SharedClassObject;

public class ModuleInstall
  extends SharedClassObject
{
  private static final long serialVersionUID = -5615399519545301432L;
  
  public void validate()
    throws IllegalStateException
  {}
  
  @Deprecated
  public void installed()
  {
    restored();
  }
  
  public void restored() {}
  
  @Deprecated
  public void updated(int paramInt, String paramString)
  {
    restored();
  }
  
  public void uninstalled() {}
  
  public boolean closing()
  {
    return true;
  }
  
  public void close() {}
  
  protected boolean clearSharedData()
  {
    return false;
  }
}

/* Location:
 * Qualified Name:     org.openide.modules.ModuleInstall
 * Java Class Version: 6 (50.0)
 * JD-Core Version:    0.7.1
 */
package org.openide.modules;

import java.lang.annotation.Annotation;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

@Retention(RetentionPolicy.CLASS)
@Target({java.lang.annotation.ElementType.METHOD, java.lang.annotation.ElementType.CONSTRUCTOR})
public @interface PatchedPublic {}

/* Location:
 * Qualified Name:     org.openide.modules.PatchedPublic
 * Java Class Version: 6 (50.0)
 * JD-Core Version:    0.7.1
 */
package org.openide.modules;

import java.util.Arrays;
import java.util.HashMap;
import java.util.Map;
import java.util.StringTokenizer;

public final class SpecificationVersion
  implements Comparable
{
  private static final Map<String, int[]> parseCache = new HashMap(200);
  private final int[] digits;
  
  public SpecificationVersion(String paramString)
    throws NumberFormatException
  {
    synchronized (parseCache)
    {
      int[] arrayOfInt = (int[])parseCache.get(paramString);
      if (arrayOfInt == null)
      {
        arrayOfInt = parse(paramString);
        parseCache.put(paramString.intern(), arrayOfInt);
      }
      digits = arrayOfInt;
    }
  }
  
  private static int[] parse(String paramString)
    throws NumberFormatException
  {
    StringTokenizer localStringTokenizer = new StringTokenizer(paramString, ".", true);
    
    int i = localStringTokenizer.countTokens();
    if (i % 2 == 0) {
      throw new NumberFormatException("Even number of pieces in a spec version: `" + paramString + "'");
    }
    int[] arrayOfInt = new int[i / 2 + 1];
    int j = 0;
    
    int k = 1;
    while (localStringTokenizer.hasMoreTokens()) {
      if (k != 0)
      {
        k = 0;
        
        int m = Integer.parseInt(localStringTokenizer.nextToken());
        if (m < 0) {
          throw new NumberFormatException("Spec version component <0: " + m);
        }
        arrayOfInt[(j++)] = m;
      }
      else
      {
        if (!".".equals(localStringTokenizer.nextToken())) {
          throw new NumberFormatException("Expected dot in spec version: `" + paramString + "'");
        }
        k = 1;
      }
    }
    return arrayOfInt;
  }
  
  public int compareTo(Object paramObject)
  {
    int[] arrayOfInt = digits;
    int i = digits.length;
    int j = arrayOfInt.length;
    int k = Math.max(i, j);
    for (int m = 0; m < k; m++)
    {
      int n = m < i ? digits[m] : 0;
      int i1 = m < j ? arrayOfInt[m] : 0;
      if (n != i1) {
        return n - i1;
      }
    }
    return 0;
  }
  
  public boolean equals(Object paramObject)
  {
    if (!(paramObject instanceof SpecificationVersion)) {
      return false;
    }
    return Arrays.equals(digits, digits);
  }
  
  public int hashCode()
  {
    int i = 925295;
    int j = digits.length;
    for (int k = 0; k < j; k++) {
      i ^= digits[k] << k;
    }
    return i;
  }
  
  public String toString()
  {
    StringBuilder localStringBuilder = new StringBuilder(digits.length * 3 + 1);
    for (int i = 0; i < digits.length; i++)
    {
      if (i > 0) {
        localStringBuilder.append('.');
      }
      localStringBuilder.append(digits[i]);
    }
    return localStringBuilder.toString();
  }
}

/* Location:
 * Qualified Name:     org.openide.modules.SpecificationVersion
 * Java Class Version: 6 (50.0)
 * JD-Core Version:    0.7.1
 */
1

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