org.eclipse.pde.core_3.7.1.v20120103_r372

16:47:23.712 INFO  jd.cli.Main - Decompiling org.eclipse.pde.core_3.7.1.v20120103_r372.jar
package org.eclipse.pde.core;

import org.eclipse.core.runtime.IAdaptable;

public abstract interface IBaseModel
  extends IAdaptable
{
  public abstract void dispose();
  
  public abstract boolean isDisposed();
  
  public abstract boolean isEditable();
  
  public abstract boolean isValid();
}

/* Location:
 * Qualified Name:     org.eclipse.pde.core.IBaseModel
 * Java Class Version: 1.2 (46.0)
 * JD-Core Version:    0.7.1
 */
package org.eclipse.pde.core;

import java.io.PrintWriter;

public abstract interface IEditable
{
  public abstract boolean isEditable();
  
  public abstract boolean isDirty();
  
  public abstract void save(PrintWriter paramPrintWriter);
  
  public abstract void setDirty(boolean paramBoolean);
}

/* Location:
 * Qualified Name:     org.eclipse.pde.core.IEditable
 * Java Class Version: 1.2 (46.0)
 * JD-Core Version:    0.7.1
 */
package org.eclipse.pde.core;

public abstract interface IEditableModel
  extends IEditable
{
  public abstract void save();
}

/* Location:
 * Qualified Name:     org.eclipse.pde.core.IEditableModel
 * Java Class Version: 1.2 (46.0)
 * JD-Core Version:    0.7.1
 */
package org.eclipse.pde.core;

import org.eclipse.core.runtime.CoreException;

public abstract interface IIdentifiable
{
  public static final String P_ID = "id";
  
  public abstract String getId();
  
  public abstract void setId(String paramString)
    throws CoreException;
}

/* Location:
 * Qualified Name:     org.eclipse.pde.core.IIdentifiable
 * Java Class Version: 1.2 (46.0)
 * JD-Core Version:    0.7.1
 */
package org.eclipse.pde.core;

import java.io.InputStream;
import org.eclipse.core.resources.IResource;
import org.eclipse.core.runtime.CoreException;

public abstract interface IModel
  extends IBaseModel
{
  public abstract String getResourceString(String paramString);
  
  public abstract IResource getUnderlyingResource();
  
  public abstract boolean isLoaded();
  
  public abstract boolean isInSync();
  
  public abstract long getTimeStamp();
  
  public abstract void load()
    throws CoreException;
  
  public abstract void load(InputStream paramInputStream, boolean paramBoolean)
    throws CoreException;
  
  public abstract void reload(InputStream paramInputStream, boolean paramBoolean)
    throws CoreException;
  
  public abstract boolean isReconcilingModel();
}

/* Location:
 * Qualified Name:     org.eclipse.pde.core.IModel
 * Java Class Version: 1.2 (46.0)
 * JD-Core Version:    0.7.1
 */
package org.eclipse.pde.core;

public abstract interface IModelChangeProvider
{
  public abstract void addModelChangedListener(IModelChangedListener paramIModelChangedListener);
  
  public abstract void fireModelChanged(IModelChangedEvent paramIModelChangedEvent);
  
  public abstract void fireModelObjectChanged(Object paramObject1, String paramString, Object paramObject2, Object paramObject3);
  
  public abstract void removeModelChangedListener(IModelChangedListener paramIModelChangedListener);
}

/* Location:
 * Qualified Name:     org.eclipse.pde.core.IModelChangeProvider
 * Java Class Version: 1.2 (46.0)
 * JD-Core Version:    0.7.1
 */
package org.eclipse.pde.core;

public abstract interface IModelChangedEvent
{
  public static final int INSERT = 1;
  public static final int REMOVE = 2;
  public static final int WORLD_CHANGED = 99;
  public static final int CHANGE = 3;
  
  public abstract IModelChangeProvider getChangeProvider();
  
  public abstract Object[] getChangedObjects();
  
  public abstract String getChangedProperty();
  
  public abstract Object getOldValue();
  
  public abstract Object getNewValue();
  
  public abstract int getChangeType();
}

/* Location:
 * Qualified Name:     org.eclipse.pde.core.IModelChangedEvent
 * Java Class Version: 1.2 (46.0)
 * JD-Core Version:    0.7.1
 */
package org.eclipse.pde.core;

public abstract interface IModelChangedListener
{
  public abstract void modelChanged(IModelChangedEvent paramIModelChangedEvent);
}

/* Location:
 * Qualified Name:     org.eclipse.pde.core.IModelChangedListener
 * Java Class Version: 1.2 (46.0)
 * JD-Core Version:    0.7.1
 */
package org.eclipse.pde.core;

import org.eclipse.core.resources.IFile;

public abstract interface IModelProvider
{
  public abstract void addModelProviderListener(IModelProviderListener paramIModelProviderListener);
  
  public abstract IModel getModel(IFile paramIFile);
  
  public abstract void removeModelProviderListener(IModelProviderListener paramIModelProviderListener);
}

/* Location:
 * Qualified Name:     org.eclipse.pde.core.IModelProvider
 * Java Class Version: 1.2 (46.0)
 * JD-Core Version:    0.7.1
 */
package org.eclipse.pde.core;

public abstract interface IModelProviderEvent
{
  public static final int MODELS_ADDED = 1;
  public static final int MODELS_REMOVED = 2;
  public static final int MODELS_CHANGED = 4;
  public static final int TARGET_CHANGED = 8;
  public static final int ENVIRONMENT_CHANGED = 16;
  
  public abstract IModel[] getAddedModels();
  
  public abstract IModel[] getRemovedModels();
  
  public abstract IModel[] getChangedModels();
  
  public abstract int getEventTypes();
  
  public abstract Object getEventSource();
}

/* Location:
 * Qualified Name:     org.eclipse.pde.core.IModelProviderEvent
 * Java Class Version: 1.2 (46.0)
 * JD-Core Version:    0.7.1
 */
package org.eclipse.pde.core;

public abstract interface IModelProviderListener
{
  public abstract void modelsChanged(IModelProviderEvent paramIModelProviderEvent);
}

/* Location:
 * Qualified Name:     org.eclipse.pde.core.IModelProviderListener
 * Java Class Version: 1.2 (46.0)
 * JD-Core Version:    0.7.1
 */
package org.eclipse.pde.core;

public abstract interface ISourceObject
{
  public abstract int getStartLine();
  
  public abstract int getStopLine();
}

/* Location:
 * Qualified Name:     org.eclipse.pde.core.ISourceObject
 * Java Class Version: 1.2 (46.0)
 * JD-Core Version:    0.7.1
 */
package org.eclipse.pde.core;

import java.io.PrintWriter;

public abstract interface IWritable
{
  public abstract void write(String paramString, PrintWriter paramPrintWriter);
}

/* Location:
 * Qualified Name:     org.eclipse.pde.core.IWritable
 * Java Class Version: 1.2 (46.0)
 * JD-Core Version:    0.7.1
 */
package org.eclipse.pde.core;

public class ModelChangedEvent
  implements IModelChangedEvent
{
  private int type;
  private IModelChangeProvider provider;
  private Object[] changedObjects;
  private Object oldValue;
  private Object newValue;
  private String changedProperty;
  
  public ModelChangedEvent(IModelChangeProvider provider, int type, Object[] objects, String changedProperty)
  {
    this.type = type;
    this.provider = provider;
    changedObjects = objects;
    this.changedProperty = changedProperty;
  }
  
  public ModelChangedEvent(IModelChangeProvider provider, Object object, String changedProperty, Object oldValue, Object newValue)
  {
    type = 3;
    this.provider = provider;
    changedObjects = new Object[] { object };
    this.changedProperty = changedProperty;
    this.oldValue = oldValue;
    this.newValue = newValue;
  }
  
  public IModelChangeProvider getChangeProvider()
  {
    return provider;
  }
  
  public Object[] getChangedObjects()
  {
    return changedObjects == null ? new Object[0] : changedObjects;
  }
  
  public String getChangedProperty()
  {
    return changedProperty;
  }
  
  public Object getOldValue()
  {
    return oldValue;
  }
  
  public Object getNewValue()
  {
    return newValue;
  }
  
  public int getChangeType()
  {
    return type;
  }
}

/* Location:
 * Qualified Name:     org.eclipse.pde.core.ModelChangedEvent
 * Java Class Version: 1.2 (46.0)
 * JD-Core Version:    0.7.1
 */
package org.eclipse.pde.core.build;

import org.eclipse.core.runtime.CoreException;
import org.eclipse.pde.core.IWritable;

public abstract interface IBuild
  extends IWritable
{
  public abstract void add(IBuildEntry paramIBuildEntry)
    throws CoreException;
  
  public abstract IBuildEntry[] getBuildEntries();
  
  public abstract IBuildEntry getEntry(String paramString);
  
  public abstract void remove(IBuildEntry paramIBuildEntry)
    throws CoreException;
}

/* Location:
 * Qualified Name:     org.eclipse.pde.core.build.IBuild
 * Java Class Version: 1.2 (46.0)
 * JD-Core Version:    0.7.1
 */
package org.eclipse.pde.core.build;

import org.eclipse.core.runtime.CoreException;
import org.eclipse.pde.core.IWritable;

public abstract interface IBuildEntry
  extends IWritable
{
  public static final String P_NAME = "name";
  public static final String JAR_PREFIX = "source.";
  public static final String OUTPUT_PREFIX = "output.";
  public static final String BIN_INCLUDES = "bin.includes";
  public static final String SRC_INCLUDES = "src.includes";
  public static final String JARS_EXTRA_CLASSPATH = "jars.extra.classpath";
  public static final String SECONDARY_DEPENDENCIES = "additional.bundles";
  
  public abstract void addToken(String paramString)
    throws CoreException;
  
  public abstract IBuildModel getModel();
  
  public abstract String getName();
  
  public abstract String[] getTokens();
  
  public abstract boolean contains(String paramString);
  
  public abstract void removeToken(String paramString)
    throws CoreException;
  
  public abstract void renameToken(String paramString1, String paramString2)
    throws CoreException;
  
  public abstract void setName(String paramString)
    throws CoreException;
}

/* Location:
 * Qualified Name:     org.eclipse.pde.core.build.IBuildEntry
 * Java Class Version: 1.2 (46.0)
 * JD-Core Version:    0.7.1
 */
package org.eclipse.pde.core.build;

import org.eclipse.pde.core.IModel;
import org.eclipse.pde.core.IModelChangeProvider;

public abstract interface IBuildModel
  extends IModel, IModelChangeProvider
{
  public abstract IBuild getBuild();
  
  public abstract IBuildModelFactory getFactory();
  
  public abstract String getInstallLocation();
}

/* Location:
 * Qualified Name:     org.eclipse.pde.core.build.IBuildModel
 * Java Class Version: 1.2 (46.0)
 * JD-Core Version:    0.7.1
 */
package org.eclipse.pde.core.build;

public abstract interface IBuildModelFactory
{
  public abstract IBuildEntry createEntry(String paramString);
}

/* Location:
 * Qualified Name:     org.eclipse.pde.core.build.IBuildModelFactory
 * Java Class Version: 1.2 (46.0)
 * JD-Core Version:    0.7.1
 */
package org.eclipse.pde.core.plugin;

import org.eclipse.core.runtime.CoreException;

public abstract interface IExtensions
  extends IPluginObject
{
  public static final String P_EXTENSION_ORDER = "extension_order";
  
  public abstract void add(IPluginExtension paramIPluginExtension)
    throws CoreException;
  
  public abstract void add(IPluginExtensionPoint paramIPluginExtensionPoint)
    throws CoreException;
  
  public abstract IPluginExtensionPoint[] getExtensionPoints();
  
  public abstract IPluginExtension[] getExtensions();
  
  public abstract void remove(IPluginExtension paramIPluginExtension)
    throws CoreException;
  
  public abstract void remove(IPluginExtensionPoint paramIPluginExtensionPoint)
    throws CoreException;
  
  public abstract void swap(IPluginExtension paramIPluginExtension1, IPluginExtension paramIPluginExtension2)
    throws CoreException;
  
  public abstract int getIndexOf(IPluginExtension paramIPluginExtension);
}

/* Location:
 * Qualified Name:     org.eclipse.pde.core.plugin.IExtensions
 * Java Class Version: 1.2 (46.0)
 * JD-Core Version:    0.7.1
 */
package org.eclipse.pde.core.plugin;

public abstract interface IExtensionsModel
  extends ISharedExtensionsModel
{}

/* Location:
 * Qualified Name:     org.eclipse.pde.core.plugin.IExtensionsModel
 * Java Class Version: 1.2 (46.0)
 * JD-Core Version:    0.7.1
 */
package org.eclipse.pde.core.plugin;

public abstract interface IExtensionsModelFactory
{
  public abstract IPluginAttribute createAttribute(IPluginElement paramIPluginElement);
  
  public abstract IPluginElement createElement(IPluginObject paramIPluginObject);
  
  public abstract IPluginExtension createExtension();
  
  public abstract IPluginExtensionPoint createExtensionPoint();
}

/* Location:
 * Qualified Name:     org.eclipse.pde.core.plugin.IExtensionsModelFactory
 * Java Class Version: 1.2 (46.0)
 * JD-Core Version:    0.7.1
 */
package org.eclipse.pde.core.plugin;

import org.eclipse.core.runtime.CoreException;

public abstract interface IFragment
  extends IPluginBase
{
  public static final String P_PLUGIN_ID = "plugin-id";
  public static final String P_PLUGIN_VERSION = "plugin-version";
  public static final String P_RULE = "match";
  
  public abstract String getPluginId();
  
  public abstract String getPluginVersion();
  
  public abstract int getRule();
  
  public abstract void setPluginId(String paramString)
    throws CoreException;
  
  public abstract void setPluginVersion(String paramString)
    throws CoreException;
  
  public abstract void setRule(int paramInt)
    throws CoreException;
}

/* Location:
 * Qualified Name:     org.eclipse.pde.core.plugin.IFragment
 * Java Class Version: 1.2 (46.0)
 * JD-Core Version:    0.7.1
 */
package org.eclipse.pde.core.plugin;

public abstract interface IFragmentModel
  extends IPluginModelBase
{
  public abstract IFragment getFragment();
}

/* Location:
 * Qualified Name:     org.eclipse.pde.core.plugin.IFragmentModel
 * Java Class Version: 1.2 (46.0)
 * JD-Core Version:    0.7.1
 */
package org.eclipse.pde.core.plugin;

public abstract interface IMatchRules
{
  public static final int NONE = 0;
  public static final int EQUIVALENT = 1;
  public static final String RULE_EQUIVALENT = "equivalent";
  public static final int COMPATIBLE = 2;
  public static final String RULE_COMPATIBLE = "compatible";
  public static final int PERFECT = 3;
  public static final String RULE_PERFECT = "perfect";
  public static final int GREATER_OR_EQUAL = 4;
  public static final String RULE_GREATER_OR_EQUAL = "greaterOrEqual";
  public static final int PREFIX = 5;
  public static final String RULE_PREFIX = "prefix";
  public static final String[] RULE_NAME_TABLE = { "", "equivalent", "compatible", "perfect", "greaterOrEqual" };
}

/* Location:
 * Qualified Name:     org.eclipse.pde.core.plugin.IMatchRules
 * Java Class Version: 1.2 (46.0)
 * JD-Core Version:    0.7.1
 */
package org.eclipse.pde.core.plugin;

import org.eclipse.core.runtime.CoreException;

public abstract interface IPlugin
  extends IPluginBase
{
  public static final String P_CLASS_NAME = "class";
  
  public abstract String getClassName();
  
  public abstract void setClassName(String paramString)
    throws CoreException;
}

/* Location:
 * Qualified Name:     org.eclipse.pde.core.plugin.IPlugin
 * Java Class Version: 1.2 (46.0)
 * JD-Core Version:    0.7.1
 */
package org.eclipse.pde.core.plugin;

import org.eclipse.core.runtime.CoreException;

public abstract interface IPluginAttribute
  extends IPluginObject
{
  public static final String P_VALUE = "value";
  
  public abstract String getValue();
  
  public abstract void setValue(String paramString)
    throws CoreException;
}

/* Location:
 * Qualified Name:     org.eclipse.pde.core.plugin.IPluginAttribute
 * Java Class Version: 1.2 (46.0)
 * JD-Core Version:    0.7.1
 */
package org.eclipse.pde.core.plugin;

import org.eclipse.core.runtime.CoreException;
import org.eclipse.pde.core.IIdentifiable;

public abstract interface IPluginBase
  extends IExtensions, IIdentifiable
{
  public static final String P_PROVIDER = "provider-name";
  public static final String P_VERSION = "version";
  public static final String P_LIBRARY_ORDER = "library_order";
  public static final String P_IMPORT_ORDER = "import_order";
  public static final String P_SCHEMA_VERSION = "schema-version";
  
  public abstract void add(IPluginLibrary paramIPluginLibrary)
    throws CoreException;
  
  public abstract void add(IPluginImport paramIPluginImport)
    throws CoreException;
  
  public abstract void remove(IPluginImport paramIPluginImport)
    throws CoreException;
  
  public abstract IPluginLibrary[] getLibraries();
  
  public abstract IPluginImport[] getImports();
  
  public abstract String getProviderName();
  
  public abstract String getVersion();
  
  public abstract void remove(IPluginLibrary paramIPluginLibrary)
    throws CoreException;
  
  public abstract void setProviderName(String paramString)
    throws CoreException;
  
  public abstract void setVersion(String paramString)
    throws CoreException;
  
  public abstract void swap(IPluginLibrary paramIPluginLibrary1, IPluginLibrary paramIPluginLibrary2)
    throws CoreException;
  
  public abstract void swap(IPluginImport paramIPluginImport1, IPluginImport paramIPluginImport2)
    throws CoreException;
  
  public abstract String getSchemaVersion();
  
  public abstract void setSchemaVersion(String paramString)
    throws CoreException;
}

/* Location:
 * Qualified Name:     org.eclipse.pde.core.plugin.IPluginBase
 * Java Class Version: 1.2 (46.0)
 * JD-Core Version:    0.7.1
 */
package org.eclipse.pde.core.plugin;

import org.eclipse.core.runtime.CoreException;

public abstract interface IPluginElement
  extends IPluginParent
{
  public static final String P_TEXT = "text";
  public static final String P_ATTRIBUTES = "attributes";
  public static final String P_ATTRIBUTE = "attribute";
  
  public abstract IPluginElement createCopy();
  
  public abstract IPluginAttribute getAttribute(String paramString);
  
  public abstract IPluginAttribute[] getAttributes();
  
  public abstract int getAttributeCount();
  
  public abstract String getText();
  
  public abstract Object getElementInfo();
  
  public abstract void setAttribute(String paramString1, String paramString2)
    throws CoreException;
  
  public abstract void setText(String paramString)
    throws CoreException;
}

/* Location:
 * Qualified Name:     org.eclipse.pde.core.plugin.IPluginElement
 * Java Class Version: 1.2 (46.0)
 * JD-Core Version:    0.7.1
 */
package org.eclipse.pde.core.plugin;

import org.eclipse.core.runtime.CoreException;
import org.eclipse.pde.core.IIdentifiable;

public abstract interface IPluginExtension
  extends IPluginParent, IIdentifiable
{
  public static final String P_POINT = "point";
  
  public abstract String getPoint();
  
  public abstract Object getSchema();
  
  public abstract void setPoint(String paramString)
    throws CoreException;
}

/* Location:
 * Qualified Name:     org.eclipse.pde.core.plugin.IPluginExtension
 * Java Class Version: 1.2 (46.0)
 * JD-Core Version:    0.7.1
 */
package org.eclipse.pde.core.plugin;

import org.eclipse.core.runtime.CoreException;
import org.eclipse.pde.core.IIdentifiable;

public abstract interface IPluginExtensionPoint
  extends IPluginObject, IIdentifiable
{
  public static final String P_SCHEMA = "schema";
  
  public abstract String getFullId();
  
  public abstract String getSchema();
  
  public abstract void setSchema(String paramString)
    throws CoreException;
}

/* Location:
 * Qualified Name:     org.eclipse.pde.core.plugin.IPluginExtensionPoint
 * Java Class Version: 1.2 (46.0)
 * JD-Core Version:    0.7.1
 */
package org.eclipse.pde.core.plugin;

import org.eclipse.core.runtime.CoreException;

public abstract interface IPluginImport
  extends IPluginObject, IPluginReference
{
  public static final String P_REEXPORTED = "export";
  public static final String P_OPTIONAL = "optional";
  
  public abstract boolean isReexported();
  
  public abstract boolean isOptional();
  
  public abstract void setReexported(boolean paramBoolean)
    throws CoreException;
  
  public abstract void setOptional(boolean paramBoolean)
    throws CoreException;
}

/* Location:
 * Qualified Name:     org.eclipse.pde.core.plugin.IPluginImport
 * Java Class Version: 1.2 (46.0)
 * JD-Core Version:    0.7.1
 */
package org.eclipse.pde.core.plugin;

import org.eclipse.core.runtime.CoreException;

public abstract interface IPluginLibrary
  extends IPluginObject
{
  public static final String P_EXPORTED = "export";
  public static final String P_PACKAGES = "packages";
  public static final String P_CONTENT_FILTERS = "contentFilters";
  public static final String P_TYPE = "type";
  public static final String CODE = "code";
  public static final String RESOURCE = "resource";
  
  public abstract String[] getContentFilters();
  
  public abstract String[] getPackages();
  
  public abstract boolean isExported();
  
  public abstract boolean isFullyExported();
  
  public abstract String getType();
  
  public abstract void setContentFilters(String[] paramArrayOfString)
    throws CoreException;
  
  public abstract void addContentFilter(String paramString)
    throws CoreException;
  
  public abstract void removeContentFilter(String paramString)
    throws CoreException;
  
  public abstract void setPackages(String[] paramArrayOfString)
    throws CoreException;
  
  public abstract void setExported(boolean paramBoolean)
    throws CoreException;
  
  public abstract void setType(String paramString)
    throws CoreException;
}

/* Location:
 * Qualified Name:     org.eclipse.pde.core.plugin.IPluginLibrary
 * Java Class Version: 1.2 (46.0)
 * JD-Core Version:    0.7.1
 */
package org.eclipse.pde.core.plugin;

public abstract interface IPluginModel
  extends IPluginModelBase
{
  public abstract IPlugin getPlugin();
}

/* Location:
 * Qualified Name:     org.eclipse.pde.core.plugin.IPluginModel
 * Java Class Version: 1.2 (46.0)
 * JD-Core Version:    0.7.1
 */
package org.eclipse.pde.core.plugin;

import java.net.URL;
import org.eclipse.osgi.service.resolver.BundleDescription;
import org.eclipse.pde.core.IModelChangeProvider;
import org.eclipse.pde.core.build.IBuildModel;

public abstract interface IPluginModelBase
  extends ISharedExtensionsModel, IModelChangeProvider
{
  public abstract IPluginBase createPluginBase();
  
  /**
   * @deprecated
   */
  public abstract IBuildModel getBuildModel();
  
  public abstract IPluginBase getPluginBase();
  
  public abstract IPluginBase getPluginBase(boolean paramBoolean);
  
  public abstract boolean isEnabled();
  
  public abstract boolean isFragmentModel();
  
  public abstract void setEnabled(boolean paramBoolean);
  
  public abstract IPluginModelFactory getPluginFactory();
  
  public abstract URL getNLLookupLocation();
  
  public abstract BundleDescription getBundleDescription();
  
  public abstract void setBundleDescription(BundleDescription paramBundleDescription);
}

/* Location:
 * Qualified Name:     org.eclipse.pde.core.plugin.IPluginModelBase
 * Java Class Version: 1.2 (46.0)
 * JD-Core Version:    0.7.1
 */
package org.eclipse.pde.core.plugin;

public abstract interface IPluginModelFactory
  extends IExtensionsModelFactory
{
  public abstract IPluginImport createImport();
  
  public abstract IPluginLibrary createLibrary();
}

/* Location:
 * Qualified Name:     org.eclipse.pde.core.plugin.IPluginModelFactory
 * Java Class Version: 1.2 (46.0)
 * JD-Core Version:    0.7.1
 */
package org.eclipse.pde.core.plugin;

import org.eclipse.core.runtime.CoreException;
import org.eclipse.core.runtime.IAdaptable;
import org.eclipse.pde.core.IWritable;

public abstract interface IPluginObject
  extends IWritable, IAdaptable
{
  public static final String P_NAME = "name";
  
  public abstract ISharedPluginModel getModel();
  
  public abstract IPluginModelBase getPluginModel();
  
  public abstract String getName();
  
  public abstract boolean isInTheModel();
  
  public abstract void setInTheModel(boolean paramBoolean);
  
  public abstract String getTranslatedName();
  
  public abstract IPluginObject getParent();
  
  public abstract IPluginBase getPluginBase();
  
  public abstract String getResourceString(String paramString);
  
  public abstract void setName(String paramString)
    throws CoreException;
  
  public abstract boolean isValid();
}

/* Location:
 * Qualified Name:     org.eclipse.pde.core.plugin.IPluginObject
 * Java Class Version: 1.2 (46.0)
 * JD-Core Version:    0.7.1
 */
package org.eclipse.pde.core.plugin;

import org.eclipse.core.runtime.CoreException;

public abstract interface IPluginParent
  extends IPluginObject
{
  public static final String P_SIBLING_ORDER = "sibling_order";
  
  public abstract void add(int paramInt, IPluginObject paramIPluginObject)
    throws CoreException;
  
  public abstract void add(IPluginObject paramIPluginObject)
    throws CoreException;
  
  public abstract int getChildCount();
  
  public abstract int getIndexOf(IPluginObject paramIPluginObject);
  
  public abstract void swap(IPluginObject paramIPluginObject1, IPluginObject paramIPluginObject2)
    throws CoreException;
  
  public abstract IPluginObject[] getChildren();
  
  public abstract void remove(IPluginObject paramIPluginObject)
    throws CoreException;
}

/* Location:
 * Qualified Name:     org.eclipse.pde.core.plugin.IPluginParent
 * Java Class Version: 1.2 (46.0)
 * JD-Core Version:    0.7.1
 */
package org.eclipse.pde.core.plugin;

import org.eclipse.core.runtime.CoreException;
import org.eclipse.pde.core.IIdentifiable;

public abstract interface IPluginReference
  extends IIdentifiable, IMatchRules
{
  public static final String P_MATCH = "match";
  public static final String P_VERSION = "version";
  
  public abstract int getMatch();
  
  public abstract String getVersion();
  
  public abstract void setMatch(int paramInt)
    throws CoreException;
  
  public abstract void setVersion(String paramString)
    throws CoreException;
}

/* Location:
 * Qualified Name:     org.eclipse.pde.core.plugin.IPluginReference
 * Java Class Version: 1.2 (46.0)
 * JD-Core Version:    0.7.1
 */
package org.eclipse.pde.core.plugin;

public abstract interface ISharedExtensionsModel
  extends ISharedPluginModel
{
  public abstract IExtensions getExtensions();
  
  public abstract IExtensions getExtensions(boolean paramBoolean);
}

/* Location:
 * Qualified Name:     org.eclipse.pde.core.plugin.ISharedExtensionsModel
 * Java Class Version: 1.2 (46.0)
 * JD-Core Version:    0.7.1
 */
package org.eclipse.pde.core.plugin;

import org.eclipse.pde.core.IModel;
import org.eclipse.pde.core.IModelChangeProvider;

public abstract interface ISharedPluginModel
  extends IModel, IModelChangeProvider
{
  public abstract IExtensionsModelFactory getFactory();
  
  public abstract String getInstallLocation();
}

/* Location:
 * Qualified Name:     org.eclipse.pde.core.plugin.ISharedPluginModel
 * Java Class Version: 1.2 (46.0)
 * JD-Core Version:    0.7.1
 */
package org.eclipse.pde.core.plugin;

import java.util.ArrayList;
import org.eclipse.core.runtime.PlatformObject;
import org.eclipse.osgi.service.resolver.BundleDescription;
import org.osgi.framework.Version;

public class ModelEntry
  extends PlatformObject
{
  private String fId;
  protected ArrayList fWorkspaceEntries = new ArrayList(1);
  protected ArrayList fExternalEntries = new ArrayList(1);
  
  public ModelEntry(String id)
  {
    fId = id;
  }
  
  public IPluginModelBase[] getWorkspaceModels()
  {
    return (IPluginModelBase[])fWorkspaceEntries.toArray(new IPluginModelBase[fWorkspaceEntries.size()]);
  }
  
  public IPluginModelBase[] getExternalModels()
  {
    return (IPluginModelBase[])fExternalEntries.toArray(new IPluginModelBase[fExternalEntries.size()]);
  }
  
  public IPluginModelBase getModel()
  {
    IPluginModelBase model = getBestCandidate(getWorkspaceModels());
    if (model == null) {
      model = getBestCandidate(getExternalModels());
    }
    return model;
  }
  
  private IPluginModelBase getBestCandidate(IPluginModelBase[] models)
  {
    IPluginModelBase model = null;
    for (int i = 0; i < models.length; i++) {
      if (models[i].getBundleDescription() != null) {
        if (model == null)
        {
          model = models[i];
        }
        else if ((!model.isEnabled()) && (models[i].isEnabled()))
        {
          model = models[i];
        }
        else
        {
          BundleDescription current = model.getBundleDescription();
          BundleDescription candidate = models[i].getBundleDescription();
          if ((!current.isResolved()) && (candidate.isResolved())) {
            model = models[i];
          } else if (current.getVersion().compareTo(candidate.getVersion()) < 0) {
            model = models[i];
          }
        }
      }
    }
    return model;
  }
  
  public IPluginModelBase[] getActiveModels()
  {
    if (fWorkspaceEntries.size() > 0) {
      return getWorkspaceModels();
    }
    if (fExternalEntries.size() > 0)
    {
      ArrayList list = new ArrayList(fExternalEntries.size());
      for (int i = 0; i < fExternalEntries.size(); i++)
      {
        IPluginModelBase model = (IPluginModelBase)fExternalEntries.get(i);
        if (model.isEnabled()) {
          list.add(model);
        }
      }
      return (IPluginModelBase[])list.toArray(new IPluginModelBase[list.size()]);
    }
    return new IPluginModelBase[0];
  }
  
  public String getId()
  {
    return fId;
  }
  
  public IPluginModelBase getModel(BundleDescription desc)
  {
    if (desc == null) {
      return null;
    }
    for (int i = 0; i < fWorkspaceEntries.size(); i++)
    {
      IPluginModelBase model = (IPluginModelBase)fWorkspaceEntries.get(i);
      if (desc.equals(model.getBundleDescription())) {
        return model;
      }
    }
    for (int i = 0; i < fExternalEntries.size(); i++)
    {
      IPluginModelBase model = (IPluginModelBase)fExternalEntries.get(i);
      if (desc.equals(model.getBundleDescription())) {
        return model;
      }
    }
    return null;
  }
  
  public boolean hasWorkspaceModels()
  {
    return !fWorkspaceEntries.isEmpty();
  }
  
  public boolean hasExternalModels()
  {
    return !fExternalEntries.isEmpty();
  }
}

/* Location:
 * Qualified Name:     org.eclipse.pde.core.plugin.ModelEntry
 * Java Class Version: 1.2 (46.0)
 * JD-Core Version:    0.7.1
 */
package org.eclipse.pde.core.plugin;

public class PluginRegistry$PluginFilter
{
  public boolean accept(IPluginModelBase model)
  {
    return true;
  }
}

/* Location:
 * Qualified Name:     org.eclipse.pde.core.plugin.PluginRegistry.PluginFilter
 * Java Class Version: 1.2 (46.0)
 * JD-Core Version:    0.7.1
 */
package org.eclipse.pde.core.plugin;

import java.util.ArrayList;
import java.util.List;
import org.eclipse.core.resources.IFile;
import org.eclipse.core.resources.IProject;
import org.eclipse.core.resources.IResource;
import org.eclipse.core.runtime.CoreException;
import org.eclipse.core.runtime.IStatus;
import org.eclipse.osgi.service.resolver.BundleDescription;
import org.eclipse.osgi.service.resolver.VersionRange;
import org.eclipse.pde.core.build.IBuildModel;
import org.eclipse.pde.internal.core.PDECore;
import org.eclipse.pde.internal.core.PluginModelManager;
import org.eclipse.pde.internal.core.build.WorkspaceBuildModel;
import org.eclipse.pde.internal.core.project.PDEProject;
import org.eclipse.pde.internal.core.util.VersionUtil;
import org.osgi.framework.Version;

public class PluginRegistry
{
  public static class PluginFilter
  {
    public boolean accept(IPluginModelBase model)
    {
      return true;
    }
  }
  
  public static ModelEntry findEntry(String id)
  {
    return PDECore.getDefault().getModelManager().findEntry(id);
  }
  
  public static IPluginModelBase findModel(String id)
  {
    return PDECore.getDefault().getModelManager().findModel(id);
  }
  
  public static IPluginModelBase findModel(IProject project)
  {
    return PDECore.getDefault().getModelManager().findModel(project);
  }
  
  public static IPluginModelBase findModel(BundleDescription desc)
  {
    return PDECore.getDefault().getModelManager().findModel(desc);
  }
  
  public static IPluginModelBase[] getActiveModels()
  {
    return getActiveModels(true);
  }
  
  public static IPluginModelBase[] getActiveModels(boolean includeFragments)
  {
    return PDECore.getDefault().getModelManager().getActiveModels(includeFragments);
  }
  
  public static IPluginModelBase[] getAllModels()
  {
    return getAllModels(true);
  }
  
  public static IPluginModelBase[] getAllModels(boolean includeFragments)
  {
    return PDECore.getDefault().getModelManager().getAllModels(includeFragments);
  }
  
  public static IPluginModelBase[] getWorkspaceModels()
  {
    return PDECore.getDefault().getModelManager().getWorkspaceModels();
  }
  
  public static IPluginModelBase[] getExternalModels()
  {
    return PDECore.getDefault().getModelManager().getExternalModels();
  }
  
  private static boolean isMatch(IPluginBase base, String id, String version, int match)
  {
    if (base == null) {
      return false;
    }
    if (base.getId() == null) {
      return false;
    }
    if (version == null) {
      return base.getId().equals(id);
    }
    return VersionUtil.compare(base.getId(), base.getVersion(), id, version, match);
  }
  
  public static IPluginModelBase findModel(String id, String version, int match, PluginFilter filter)
  {
    return getMax(findModels(id, version, match, filter));
  }
  
  public static IPluginModelBase[] findModels(String id, String version, int match, PluginFilter filter)
  {
    IPluginModelBase[] models = getAllModels();
    List results = new ArrayList();
    for (int i = 0; i < models.length; i++)
    {
      IPluginModelBase model = models[i];
      if (((filter == null) || (filter.accept(model))) && (isMatch(model.getPluginBase(), id, version, match))) {
        results.add(model);
      }
    }
    return (IPluginModelBase[])results.toArray(new IPluginModelBase[results.size()]);
  }
  
  public static IPluginModelBase findModel(String id, VersionRange range, PluginFilter filter)
  {
    return getMax(findModels(id, range, filter));
  }
  
  private static IPluginModelBase getMax(IPluginModelBase[] models)
  {
    if (models.length == 0) {
      return null;
    }
    if (models.length == 1) {
      return models[0];
    }
    IPluginModelBase max = null;
    Version maxV = null;
    for (int i = 0; i < models.length; i++)
    {
      IPluginModelBase model = models[i];
      String versionStr = model.getPluginBase().getVersion();
      Version version = VersionUtil.validateVersion(versionStr).isOK() ? new Version(versionStr) : Version.emptyVersion;
      if (max == null)
      {
        max = model;
        maxV = version;
      }
      else if (VersionUtil.isGreaterOrEqualTo(version, maxV))
      {
        max = model;
        maxV = version;
      }
    }
    return max;
  }
  
  public static IPluginModelBase[] findModels(String id, VersionRange range, PluginFilter filter)
  {
    IPluginModelBase[] models = getAllModels();
    List results = new ArrayList();
    for (int i = 0; i < models.length; i++)
    {
      IPluginModelBase model = models[i];
      if (((filter == null) || (filter.accept(model))) && (id.equals(model.getPluginBase().getId())))
      {
        String versionStr = model.getPluginBase().getVersion();
        Version version = VersionUtil.validateVersion(versionStr).isOK() ? new Version(versionStr) : Version.emptyVersion;
        if ((range == null) || (range.isIncluded(version))) {
          results.add(model);
        }
      }
    }
    return (IPluginModelBase[])results.toArray(new IPluginModelBase[results.size()]);
  }
  
  public static IBuildModel createBuildModel(IPluginModelBase model)
    throws CoreException
  {
    IProject project = model.getUnderlyingResource().getProject();
    if (project != null)
    {
      IFile buildFile = PDEProject.getBuildProperties(project);
      if (buildFile.exists())
      {
        IBuildModel buildModel = new WorkspaceBuildModel(buildFile);
        buildModel.load();
        return buildModel;
      }
    }
    return null;
  }
}

/* Location:
 * Qualified Name:     org.eclipse.pde.core.plugin.PluginRegistry
 * Java Class Version: 1.2 (46.0)
 * JD-Core Version:    0.7.1
 */
package org.eclipse.pde.core.plugin;

import java.io.File;
import java.net.URL;
import java.util.Properties;
import java.util.Set;
import org.eclipse.core.runtime.CoreException;
import org.eclipse.core.runtime.IPath;
import org.eclipse.core.runtime.Path;
import org.eclipse.core.runtime.Platform;
import org.eclipse.osgi.service.datalocation.Location;
import org.eclipse.pde.internal.core.PDECore;
import org.eclipse.pde.internal.core.PDEPreferencesManager;
import org.eclipse.pde.internal.core.TargetPlatformHelper;
import org.eclipse.pde.internal.core.UpdateManagerHelper;

public class TargetPlatform
{
  private static String PRODUCT_PROPERTY = "eclipse.product";
  private static String APPLICATION_PROPERTY = "eclipse.application";
  private static String SDK_PRODUCT = "org.eclipse.sdk.ide";
  private static String PLATFORM_PRODUCT = "org.eclipse.platform.ide";
  private static String IDE_APPLICATION = "org.eclipse.ui.ide.workbench";
  
  public static String getLocation()
  {
    PDEPreferencesManager preferences = PDECore.getDefault().getPreferencesManager();
    return preferences.getString("platform_path");
  }
  
  public static String getDefaultLocation()
  {
    Location location = Platform.getInstallLocation();
    if (location != null)
    {
      URL url = Platform.getInstallLocation().getURL();
      IPath path = new Path(url.getFile()).removeTrailingSeparator();
      return path.toOSString();
    }
    return "";
  }
  
  public static String getOS()
  {
    return getProperty("org.eclipse.pde.ui.os", Platform.getOS());
  }
  
  public static String getWS()
  {
    return getProperty("org.eclipse.pde.ui.ws", Platform.getWS());
  }
  
  public static String getNL()
  {
    return getProperty("org.eclipse.pde.ui.nl", Platform.getNL());
  }
  
  public static String getOSArch()
  {
    return getProperty("org.eclipse.pde.ui.arch", Platform.getOSArch());
  }
  
  private static String getProperty(String key, String defaultValue)
  {
    PDEPreferencesManager preferences = PDECore.getDefault().getPreferencesManager();
    String value = preferences.getString(key);
    return value.equals("") ? defaultValue : value;
  }
  
  public static String[] getApplications()
  {
    return TargetPlatformHelper.getApplicationNames();
  }
  
  public static String[] getProducts()
  {
    return TargetPlatformHelper.getProductNames();
  }
  
  public static String getDefaultProduct()
  {
    Properties config = TargetPlatformHelper.getConfigIniProperties();
    Set set = TargetPlatformHelper.getProductNameSet();
    if (config != null)
    {
      String product = (String)config.get(PRODUCT_PROPERTY);
      if ((product != null) && (set.contains(product))) {
        return product;
      }
    }
    if (set.contains(SDK_PRODUCT)) {
      return SDK_PRODUCT;
    }
    return set.contains(PLATFORM_PRODUCT) ? PLATFORM_PRODUCT : null;
  }
  
  public static String getDefaultApplication()
  {
    Properties config = TargetPlatformHelper.getConfigIniProperties();
    Set set = TargetPlatformHelper.getApplicationNameSet();
    if (config != null)
    {
      String application = (String)config.get(APPLICATION_PROPERTY);
      if ((application != null) && (set.contains(application))) {
        return application;
      }
    }
    return IDE_APPLICATION;
  }
  
  public static void createPlatformConfiguration(File location, IPluginModelBase[] plugins, IPluginModelBase brandingPlugin)
    throws CoreException
  {
    UpdateManagerHelper.createPlatformConfiguration(location, plugins, brandingPlugin);
  }
  
  public static String getBundleList()
  {
    return TargetPlatformHelper.getBundleList();
  }
}

/* Location:
 * Qualified Name:     org.eclipse.pde.core.plugin.TargetPlatform
 * Java Class Version: 1.2 (46.0)
 * JD-Core Version:    0.7.1
 */
package org.eclipse.pde.core.project;

import org.eclipse.core.runtime.IPath;

public abstract interface I
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

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