org.eclipse.wst.common.project.facet.core_1.4.201.v201201101553

16:48:53.442 INFO  jd.cli.Main - Decompiling org.eclipse.wst.common.project.facet.core_1.4.201.v201201101553.jar
package org.eclipse.wst.common.project.facet.core;

import java.util.HashSet;
import java.util.Set;
import org.eclipse.core.resources.IFile;
import org.eclipse.core.runtime.IStatus;
import org.eclipse.core.runtime.Status;

public abstract class ActionConfig
{
  private IFacetedProjectWorkingCopy fpjwc = null;
  private IProjectFacetVersion fv = null;
  
  public IFacetedProjectWorkingCopy getFacetedProjectWorkingCopy()
  {
    return fpjwc;
  }
  
  public void setFacetedProjectWorkingCopy(IFacetedProjectWorkingCopy fpjwc)
  {
    this.fpjwc = fpjwc;
  }
  
  public IProjectFacetVersion getProjectFacetVersion()
  {
    return fv;
  }
  
  public void setProjectFacetVersion(IProjectFacetVersion fv)
  {
    this.fv = fv;
  }
  
  public Set<IFile> getValidateEditFiles()
  {
    return new HashSet();
  }
  
  public IStatus validate()
  {
    return Status.OK_STATUS;
  }
  
  public void dispose() {}
}

/* Location:
 * Qualified Name:     org.eclipse.wst.common.project.facet.core.ActionConfig
 * Java Class Version: 5 (49.0)
 * JD-Core Version:    0.7.1
 */
package org.eclipse.wst.common.project.facet.core;

import org.eclipse.osgi.util.NLS;

final class DefaultConfigurationPresetFactory$Resources
  extends NLS
{
  public static String presetLabel;
  public static String presetDescription;
  public static String presetLabelNoRuntime;
  public static String presetDescriptionNoRuntime;
  
  static
  {
    initializeMessages(DefaultConfigurationPresetFactory.class.getName(), 
      Resources.class);
  }
}

/* Location:
 * Qualified Name:     org.eclipse.wst.common.project.facet.core.DefaultConfigurationPresetFactory.Resources
 * Java Class Version: 5 (49.0)
 * JD-Core Version:    0.7.1
 */
package org.eclipse.wst.common.project.facet.core;

import java.util.Map;
import java.util.Set;
import org.eclipse.core.runtime.CoreException;
import org.eclipse.osgi.util.NLS;
import org.eclipse.wst.common.project.facet.core.internal.DefaultFacetsExtensionPoint;
import org.eclipse.wst.common.project.facet.core.runtime.IRuntime;

public class DefaultConfigurationPresetFactory
  implements IPresetFactory
{
  public static final String PRESET_ID = "default.configuration";
  
  public PresetDefinition createPreset(String presetId, Map<String, Object> context)
    throws CoreException
  {
    IFacetedProjectBase fproj = 
      (IFacetedProjectBase)context.get("CONTEXT_KEY_FACETED_PROJECT");
    
    IRuntime runtime = fproj.getPrimaryRuntime();
    String description;
    String label;
    String description;
    if (runtime != null)
    {
      String label = Resources.bind(Resources.presetLabel, runtime.getLocalizedName());
      description = Resources.bind(Resources.presetDescription, runtime.getLocalizedName());
    }
    else
    {
      label = Resources.presetLabelNoRuntime;
      description = Resources.presetDescriptionNoRuntime;
    }
    Set<IProjectFacetVersion> facets = 
      DefaultFacetsExtensionPoint.getDefaultFacets(fproj);
    if (facets == null) {
      return null;
    }
    return new PresetDefinition(label, description, facets);
  }
  
  private static final class Resources
    extends NLS
  {
    public static String presetLabel;
    public static String presetDescription;
    public static String presetLabelNoRuntime;
    public static String presetDescriptionNoRuntime;
    
    static
    {
      initializeMessages(DefaultConfigurationPresetFactory.class.getName(), 
        Resources.class);
    }
  }
}

/* Location:
 * Qualified Name:     org.eclipse.wst.common.project.facet.core.DefaultConfigurationPresetFactory
 * Java Class Version: 5 (49.0)
 * JD-Core Version:    0.7.1
 */
package org.eclipse.wst.common.project.facet.core;

import java.math.BigDecimal;
import java.util.ArrayList;
import java.util.Comparator;
import java.util.List;
import java.util.StringTokenizer;

public class DefaultVersionComparator
  implements Comparator<String>
{
  public final int compare(String obj1, String obj2)
    throws VersionFormatException
  {
    Comparable[] parsed1 = parse(obj1);
    Comparable[] parsed2 = parse(obj2);
    for (int i = 0; (i < parsed1.length) && (i < parsed2.length); i++)
    {
      int res = parsed1[i].compareTo(parsed2[i]);
      if (res != 0) {
        return res;
      }
    }
    if (parsed1.length > parsed2.length) {
      return 1;
    }
    if (parsed1.length < parsed2.length) {
      return -1;
    }
    return 0;
  }
  
  protected String getSeparators()
  {
    return ".";
  }
  
  protected Comparable<? extends Object> parse(String version, String segment, int position)
    throws VersionFormatException
  {
    try
    {
      if (position == 0) {
        return new Integer(segment);
      }
      return new BigDecimal("." + segment);
    }
    catch (NumberFormatException localNumberFormatException)
    {
      throw new VersionFormatException(this, version);
    }
  }
  
  private Comparable<Object>[] parse(String ver)
  {
    List<String> segments = new ArrayList();
    for (StringTokenizer t = new StringTokenizer(ver, getSeparators()); 
          t.hasMoreTokens();) {
      segments.add(t.nextToken());
    }
    Comparable[] parsed = new Comparable[segments.size()];
    
    int i = 0;
    for (int n = segments.size(); i < n; i++) {
      parsed[i] = parse(ver, (String)segments.get(i), i);
    }
    return parsed;
  }
}

/* Location:
 * Qualified Name:     org.eclipse.wst.common.project.facet.core.DefaultVersionComparator
 * Java Class Version: 5 (49.0)
 * JD-Core Version:    0.7.1
 */
package org.eclipse.wst.common.project.facet.core;

import org.eclipse.core.resources.IProject;
import org.eclipse.core.runtime.CoreException;
import org.eclipse.wst.common.project.facet.core.events.IFacetedProjectEvent.Type;
import org.eclipse.wst.common.project.facet.core.events.IFacetedProjectFrameworkEvent.Type;
import org.eclipse.wst.common.project.facet.core.events.IFacetedProjectFrameworkListener;
import org.eclipse.wst.common.project.facet.core.events.IFacetedProjectListener;
import org.eclipse.wst.common.project.facet.core.internal.FacetedProjectFrameworkImpl;
import org.eclipse.wst.common.project.facet.core.util.internal.VersionExpr;
import org.osgi.service.prefs.BackingStoreException;
import org.osgi.service.prefs.Preferences;

public final class FacetedProjectFramework
{
  public static final String PLUGIN_ID = "org.eclipse.wst.common.project.facet.core";
  public static final String DEFAULT_CONFIGURATION_PRESET_ID = "default.configuration";
  private static FacetedProjectFrameworkImpl impl = null;
  
  public static IFacetedProjectWorkingCopy createNewProject()
  {
    initialize();
    return impl.createNewProject();
  }
  
  public static boolean isFacetedProject(IProject project)
    throws CoreException
  {
    return (project.isAccessible()) && (project.isNatureEnabled("org.eclipse.wst.common.project.facet.core.nature"));
  }
  
  public static boolean hasProjectFacet(IProject project, String fid)
    throws CoreException
  {
    return hasProjectFacet(project, fid, null);
  }
  
  public static boolean hasProjectFacet(IProject project, String fid, String vexpr)
    throws CoreException
  {
    if ((project.isAccessible()) && 
      (project.isNatureEnabled("org.eclipse.wst.common.project.facet.core.nature")))
    {
      initialize();
      
      IFacetedProject fproj = ProjectFacetsManager.create(project);
      if (fproj != null)
      {
        IProjectFacetVersion fv;
        if (ProjectFacetsManager.isProjectFacetDefined(fid))
        {
          IProjectFacet f = ProjectFacetsManager.getProjectFacet(fid);
          if (vexpr == null) {
            return fproj.hasProjectFacet(f);
          }
          fv = fproj.getInstalledVersion(f);
          if (fv != null)
          {
            VersionExpr<IProjectFacetVersion> expr = 
              new VersionExpr(f, vexpr, null);
            
            return expr.check(fv);
          }
        }
        else
        {
          for (IProjectFacetVersion fv : fproj.getProjectFacets())
          {
            IProjectFacet f = fv.getProjectFacet();
            if (f.getId().equals(fid))
            {
              if (vexpr == null) {
                return true;
              }
              VersionExpr<IProjectFacetVersion> expr = 
                new VersionExpr(f, vexpr, null);
              
              return expr.check(fv);
            }
          }
        }
      }
    }
    return false;
  }
  
  public static void addListener(IFacetedProjectListener listener, IFacetedProjectEvent.Type... types)
  {
    initialize();
    impl.addListener(listener, types);
  }
  
  public static void addListener(IFacetedProjectFrameworkListener listener, IFacetedProjectFrameworkEvent.Type... types)
  {
    initialize();
    impl.addListener(listener, types);
  }
  
  public static void removeListener(IFacetedProjectListener listener)
  {
    initialize();
    impl.removeListener(listener);
  }
  
  public static void removeListener(IFacetedProjectFrameworkListener listener)
  {
    initialize();
    impl.removeListener(listener);
  }
  
  public static Preferences getPreferences(IProjectFacet facet)
    throws BackingStoreException
  {
    initialize();
    return impl.getPreferences(facet);
  }
  
  private static synchronized void initialize()
  {
    if (impl == null) {
      impl = FacetedProjectFrameworkImpl.getInstance();
    }
  }
}

/* Location:
 * Qualified Name:     org.eclipse.wst.common.project.facet.core.FacetedProjectFramework
 * Java Class Version: 5 (49.0)
 * JD-Core Version:    0.7.1
 */
package org.eclipse.wst.common.project.facet.core;

import org.eclipse.core.runtime.CoreException;
import org.eclipse.core.runtime.IStatus;

public final class FacetedProjectFrameworkException
  extends CoreException
{
  private static final long serialVersionUID = 1L;
  private boolean expected;
  
  public FacetedProjectFrameworkException(IStatus status)
  {
    super(status);
    
    expected = false;
  }
  
  public boolean isExpected()
  {
    return expected;
  }
  
  public void setExpected(boolean expected)
  {
    this.expected = expected;
  }
}

/* Location:
 * Qualified Name:     org.eclipse.wst.common.project.facet.core.FacetedProjectFrameworkException
 * Java Class Version: 5 (49.0)
 * JD-Core Version:    0.7.1
 */
package org.eclipse.wst.common.project.facet.core;

import org.eclipse.core.runtime.IStatus;

public abstract interface IActionConfig
{
  public abstract void setVersion(IProjectFacetVersion paramIProjectFacetVersion);
  
  public abstract void setProjectName(String paramString);
  
  public abstract IStatus validate();
}

/* Location:
 * Qualified Name:     org.eclipse.wst.common.project.facet.core.IActionConfig
 * Java Class Version: 5 (49.0)
 * JD-Core Version:    0.7.1
 */
package org.eclipse.wst.common.project.facet.core;

import org.eclipse.core.runtime.CoreException;

public abstract interface IActionConfigFactory
{
  public abstract Object create()
    throws CoreException;
}

/* Location:
 * Qualified Name:     org.eclipse.wst.common.project.facet.core.IActionConfigFactory
 * Java Class Version: 5 (49.0)
 * JD-Core Version:    0.7.1
 */
package org.eclipse.wst.common.project.facet.core;

import java.util.Map;
import org.eclipse.core.runtime.CoreException;

public abstract interface IActionDefinition
{
  public static final String PROP_FROM_VERSIONS = "from.versions";
  
  public abstract String getId();
  
  public abstract IProjectFacet getProjectFacet();
  
  public abstract IVersionExpr getVersionExpr();
  
  public abstract IFacetedProject.Action.Type getActionType();
  
  public abstract Map<String, Object> getProperties();
  
  public abstract Object getProperty(String paramString);
  
  public abstract Object createConfigObject()
    throws CoreException;
  
  /**
   * @deprecated
   */
  public abstract Object createConfigObject(IProjectFacetVersion paramIProjectFacetVersion, String paramString)
    throws CoreException;
}

/* Location:
 * Qualified Name:     org.eclipse.wst.common.project.facet.core.IActionDefinition
 * Java Class Version: 5 (49.0)
 * JD-Core Version:    0.7.1
 */
package org.eclipse.wst.common.project.facet.core;

import java.util.Set;
import org.eclipse.core.runtime.IAdaptable;

public abstract interface ICategory
  extends IAdaptable
{
  public abstract String getId();
  
  public abstract String getPluginId();
  
  public abstract String getLabel();
  
  public abstract String getDescription();
  
  public abstract Set<IProjectFacet> getProjectFacets();
}

/* Location:
 * Qualified Name:     org.eclipse.wst.common.project.facet.core.ICategory
 * Java Class Version: 5 (49.0)
 * JD-Core Version:    0.7.1
 */
package org.eclipse.wst.common.project.facet.core;

import java.util.HashMap;
import java.util.Map;

public final class IConstraint$Type
{
  private static final Map<String, Type> items = new HashMap();
  public static final Type AND = new Type("and");
  public static final Type OR = new Type("or");
  public static final Type REQUIRES = new Type("requires");
  public static final Type CONFLICTS = new Type("conflicts");
  private final String name;
  
  private IConstraint$Type(String name)
  {
    this.name = name;
    items.put(name, this);
  }
  
  public static Type valueOf(String name)
  {
    return (Type)items.get(name.toLowerCase());
  }
  
  public String name()
  {
    return name;
  }
  
  public String toString()
  {
    return name;
  }
}

/* Location:
 * Qualified Name:     org.eclipse.wst.common.project.facet.core.IConstraint.Type
 * Java Class Version: 5 (49.0)
 * JD-Core Version:    0.7.1
 */
package org.eclipse.wst.common.project.facet.core;

import java.util.Collection;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import org.eclipse.core.runtime.IStatus;

public abstract interface IConstraint
{
  public abstract Type getType();
  
  public abstract List<Object> getOperands();
  
  public abstract Object getOperand(int paramInt);
  
  public abstract IStatus check(Collection<IProjectFacetVersion> paramCollection);
  
  public abstract IStatus check(Collection<IProjectFacetVersion> paramCollection, boolean paramBoolean);
  
  public static final class Type
  {
    private static final Map<String, Type> items = new HashMap();
    public static final Type AND = new Type("and");
    public static final Type OR = new Type("or");
    public static final Type REQUIRES = new Type("requires");
    public static final Type CONFLICTS = new Type("conflicts");
    private final String name;
    
    private Type(String name)
    {
      this.name = name;
      items.put(name, this);
    }
    
    public static Type valueOf(String name)
    {
      return (Type)items.get(name.toLowerCase());
    }
    
    public String name()
    {
      return name;
    }
    
    public String toString()
    {
      return name;
    }
  }
}

/* Location:
 * Qualified Name:     org.eclipse.wst.common.project.facet.core.IConstraint
 * Java Class Version: 5 (49.0)
 * JD-Core Version:    0.7.1
 */
package org.eclipse.wst.common.project.facet.core;

public abstract interface IDefaultVersionProvider
{
  public abstract IProjectFacetVersion getDefaultVersion();
}

/* Location:
 * Qualified Name:     org.eclipse.wst.common.project.facet.core.IDefaultVersionProvider
 * Java Class Version: 5 (49.0)
 * JD-Core Version:    0.7.1
 */
package org.eclipse.wst.common.project.facet.core;

import org.eclipse.core.resources.IProject;
import org.eclipse.core.runtime.CoreException;
import org.eclipse.core.runtime.IProgressMonitor;

public abstract interface IDelegate
{
  public abstract void execute(IProject paramIProject, IProjectFacetVersion paramIProjectFacetVersion, Object paramObject, IProgressMonitor paramIProgressMonitor)
    throws CoreException;
}

/* Location:
 * Qualified Name:     org.eclipse.wst.common.project.facet.core.IDelegate
 * Java Class Version: 5 (49.0)
 * JD-Core Version:    0.7.1
 */
package org.eclipse.wst.common.project.facet.core;

import java.util.Map;

public abstract interface IDynamicPreset
  extends IPreset
{
  public static final String CONTEXT_KEY_FACETED_PROJECT = "CONTEXT_KEY_FACETED_PROJECT";
  public static final String CONTEXT_KEY_FIXED_FACETS = "CONTEXT_KEY_FIXED_FACETS";
  public static final String CONTEXT_KEY_PRIMARY_RUNTIME = "CONTEXT_KEY_PRIMARY_RUNTIME";
  
  public abstract IPreset resolve(Map<String, Object> paramMap);
}

/* Location:
 * Qualified Name:     org.eclipse.wst.common.project.facet.core.IDynamicPreset
 * Java Class Version: 5 (49.0)
 * JD-Core Version:    0.7.1
 */
package org.eclipse.wst.common.project.facet.core;

import java.util.HashMap;
import java.util.Map;

public final class IFacetedProject$Action$Type
{
  private static final Map<String, Type> items = new HashMap();
  public static final Type INSTALL = new Type("INSTALL");
  public static final Type UNINSTALL = new Type("UNINSTALL");
  public static final Type VERSION_CHANGE = new Type("VERSION_CHANGE");
  private final String name;
  
  static
  {
    items.put("install", INSTALL);
    items.put("uninstall", UNINSTALL);
    items.put("version-change", VERSION_CHANGE);
  }
  
  private IFacetedProject$Action$Type(String name)
  {
    this.name = name;
    items.put(name, this);
  }
  
  public static Type valueOf(String name)
  {
    return (Type)items.get(name);
  }
  
  public String name()
  {
    return name;
  }
  
  public String toString()
  {
    return name;
  }
}

/* Location:
 * Qualified Name:     org.eclipse.wst.common.project.facet.core.IFacetedProject.Action.Type
 * Java Class Version: 5 (49.0)
 * JD-Core Version:    0.7.1
 */
package org.eclipse.wst.common.project.facet.core;

import java.util.HashMap;
import java.util.Map;

public final class IFacetedProject$Action
{
  private final Type type;
  private final IProjectFacetVersion fv;
  private final Object config;
  
  public static final class Type
  {
    private static final Map<String, Type> items = new HashMap();
    public static final Type INSTALL = new Type("INSTALL");
    public static final Type UNINSTALL = new Type("UNINSTALL");
    public static final Type VERSION_CHANGE = new Type("VERSION_CHANGE");
    private final String name;
    
    static
    {
      items.put("install", INSTALL);
      items.put("uninstall", UNINSTALL);
      items.put("version-change", VERSION_CHANGE);
    }
    
    private Type(String name)
    {
      this.name = name;
      items.put(name, this);
    }
    
    public static Type valueOf(String name)
    {
      return (Type)items.get(name);
    }
    
    public String name()
    {
      return name;
    }
    
    public String toString()
    {
      return name;
    }
  }
  
  public IFacetedProject$Action(Type type, IProjectFacetVersion fv, Object config)
  {
    if ((type == null) || (fv == null)) {
      throw new IllegalArgumentException();
    }
    this.type = type;
    this.fv = fv;
    this.config = config;
  }
  
  public Type getType()
  {
    return type;
  }
  
  public IProjectFacetVersion getProjectFacetVersion()
  {
    return fv;
  }
  
  public Object getConfig()
  {
    return config;
  }
  
  public boolean equals(Object obj)
  {
    if (!(obj instanceof Action)) {
      return false;
    }
    Action action = (Action)obj;
    
    return (type == type) && (fv.equals(fv));
  }
  
  public int hashCode()
  {
    return type.hashCode() ^ fv.hashCode();
  }
  
  public String toString()
  {
    StringBuffer buf = new StringBuffer();
    
    buf.append(type.toString());
    buf.append('[');
    buf.append(fv.getProjectFacet().getId());
    buf.append(' ');
    buf.append(fv.getVersionString());
    buf.append(']');
    
    return buf.toString();
  }
}

/* Location:
 * Qualified Name:     org.eclipse.wst.common.project.facet.core.IFacetedProject.Action
 * Java Class Version: 5 (49.0)
 * JD-Core Version:    0.7.1
 */
package org.eclipse.wst.common.project.facet.core;

import java.util.HashMap;
import java.util.Map;
import java.util.Set;
import org.eclipse.core.resources.IMarker;
import org.eclipse.core.runtime.CoreException;
import org.eclipse.core.runtime.IProgressMonitor;
import org.eclipse.wst.common.project.facet.core.runtime.IRuntime;
import org.osgi.service.prefs.BackingStoreException;
import org.osgi.service.prefs.Preferences;

public abstract interface IFacetedProject
  extends IFacetedProjectBase
{
  public abstract IProjectFacetVersion getInstalledVersion(IProjectFacet paramIProjectFacet);
  
  public abstract void installProjectFacet(IProjectFacetVersion paramIProjectFacetVersion, Object paramObject, IProgressMonitor paramIProgressMonitor)
    throws CoreException;
  
  public abstract void uninstallProjectFacet(IProjectFacetVersion paramIProjectFacetVersion, Object paramObject, IProgressMonitor paramIProgressMonitor)
    throws CoreException;
  
  public abstract void modify(Set<Action> paramSet, IProgressMonitor paramIProgressMonitor)
    throws CoreException;
  
  public abstract void setFixedProjectFacets(Set<IProjectFacet> paramSet)
    throws CoreException;
  
  /**
   * @deprecated
   */
  public abstract IRuntime getRuntime();
  
  /**
   * @deprecated
   */
  public abstract void setRuntime(IRuntime paramIRuntime, IProgressMonitor paramIProgressMonitor)
    throws CoreException;
  
  public abstract void setTargetedRuntimes(Set<IRuntime> paramSet, IProgressMonitor paramIProgressMonitor)
    throws CoreException;
  
  public abstract void addTargetedRuntime(IRuntime paramIRuntime, IProgressMonitor paramIProgressMonitor)
    throws CoreException;
  
  public abstract void removeTargetedRuntime(IRuntime paramIRuntime, IProgressMonitor paramIProgressMonitor)
    throws CoreException;
  
  public abstract void setPrimaryRuntime(IRuntime paramIRuntime, IProgressMonitor paramIProgressMonitor)
    throws CoreException;
  
  public abstract IFacetedProjectWorkingCopy createWorkingCopy();
  
  public abstract IMarker createErrorMarker(String paramString)
    throws CoreException;
  
  public abstract IMarker createErrorMarker(String paramString1, String paramString2)
    throws CoreException;
  
  public abstract IMarker createWarningMarker(String paramString)
    throws CoreException;
  
  public abstract IMarker createWarningMarker(String paramString1, String paramString2)
    throws CoreException;
  
  /**
   * @deprecated
   */
  public abstract void addListener(IFacetedProjectListener paramIFacetedProjectListener);
  
  /**
   * @deprecated
   */
  public abstract void removeListener(IFacetedProjectListener paramIFacetedProjectListener);
  
  public abstract Preferences getPreferences(IProjectFacet paramIProjectFacet)
    throws BackingStoreException;
  
  public static final class Action
  {
    private final Type type;
    private final IProjectFacetVersion fv;
    private final Object config;
    
    public static final class Type
    {
      private static final Map<String, Type> items = new HashMap();
      public static final Type INSTALL = new Type("INSTALL");
      public static final Type UNINSTALL = new Type("UNINSTALL");
      public static final Type VERSION_CHANGE = new Type("VERSION_CHANGE");
      private final String name;
      
      static
      {
        items.put("install", INSTALL);
        items.put("uninstall", UNINSTALL);
        items.put("version-change", VERSION_CHANGE);
      }
      
      private Type(String name)
      {
        this.name = name;
        items.put(name, this);
      }
      
      public static Type valueOf(String name)
      {
        return (Type)items.get(name);
      }
      
      public String name()
      {
        return name;
      }
      
      public String toString()
      {
        return name;
      }
    }
    
    public Action(Type type, IProjectFacetVersion fv, Object config)
    {
      if ((type == null) || (fv == null)) {
        throw new IllegalArgumentException();
      }
      this.type = type;
      this.fv = fv;
      this.config = config;
    }
    
    public Type getType()
    {
      return type;
    }
    
    public IProjectFacetVersion getProjectFacetVersion()
    {
      return fv;
    }
    
    public Object getConfig()
    {
      return config;
    }
    
    public boolean equals(Object obj)
    {
      if (!(obj instanceof Action)) {
        return false;
      }
      Action action = (Action)obj;
      
      return (type == type) && (fv.equals(fv));
    }
    
    public int hashCode()
    {
      return type.hashCode() ^ fv.hashCode();
    }
    
    public String toString()
    {
      StringBuffer buf = new StringBuffer();
      
      buf.append(type.toString());
      buf.append('[');
      buf.append(fv.getProjectFacet().getId());
      buf.append(' ');
      buf.append(fv.getVersionString());
      buf.append(']');
      
      return buf.toString();
    }
  }
}

/* Location:
 * Qualified Name:     org.eclipse.wst.common.project.facet.core.IFacetedProject
 * Java Class Version: 5 (49.0)
 * JD-Core Version:    0.7.1
 */
package org.eclipse.wst.common.project.facet.core;

import java.util.Set;
import org.eclipse.core.resources.IProject;
import org.eclipse.core.runtime.IProgressMonitor;
import org.eclipse.core.runtime.IStatus;
import org.eclipse.wst.common.project.facet.core.events.IFacetedProjectEvent.Type;
import org.eclipse.wst.common.project.facet.core.events.IFacetedProjectListener;
import org.eclipse.wst.common.project.facet.core.runtime.IRuntime;

public abstract interface IFacetedProjectBase
{
  public static final int PROBLEM_PROJECT_NAME = 1;
  public static final int PROBLEM_OTHER = -1;
  
  public abstract IProject getProject();
  
  public abstract Set<IProjectFacet> getFixedProjectFacets();
  
  public abstract boolean isFixedProjectFacet(IProjectFacet paramIProjectFacet);
  
  public abstract Set<IProjectFacetVersion> getProjectFacets();
  
  public abstract IProjectFacetVersion getProjectFacetVersion(IProjectFacet paramIProjectFacet);
  
  public abstract boolean hasProjectFacet(IProjectFacet paramIProjectFacet);
  
  public abstract boolean hasProjectFacet(IProjectFacetVersion paramIProjectFacetVersion);
  
  public abstract boolean isTargetable(IRuntime paramIRuntime);
  
  public abstract boolean isTargeted(IRuntime paramIRuntime);
  
  public abstract Set<IRuntime> getTargetedRuntimes();
  
  public abstract IRuntime getPrimaryRuntime();
  
  public abstract IStatus validate(IProgressMonitor paramIProgressMonitor);
  
  public abstract IStatus validate();
  
  public abstract void addListener(IFacetedProjectListener paramIFacetedProjectListener, IFacetedProjectEvent.Type... paramVarArgs);
  
  public abstract void removeListener(IFacetedProjectListener paramIFacetedProjectListener);
}

/* Location:
 * Qualified Name:     org.eclipse.wst.common.project.facet.core.IFacetedProjectBase
 * Java Class Version: 5 (49.0)
 * JD-Core Version:    0.7.1
 */
package org.eclipse.wst.common.project.facet.core;

/**
 * @deprecated
 */
public abstract interface IFacetedProjectListener
{
  public abstract void projectChanged();
}

/* Location:
 * Qualified Name:     org.eclipse.wst.common.project.facet.core.IFacetedProjectListener
 * Java Class Version: 5 (49.0)
 * JD-Core Version:    0.7.1
 */
package org.eclipse.wst.common.project.facet.core;

import java.util.Set;

public abstract interface IFacetedProjectTemplate
{
  public abstract String getId();
  
  public abstract String getLabel();
  
  public abstract Set<IProjectFacet> getFixedProjectFacets();
  
  public abstract IPreset getInitialPreset();
}

/* Location:
 * Qualified Name:     org.eclipse.wst.common.project.facet.core.IFacetedProjectTemplate
 * Java Class Version: 5 (49.0)
 * JD-Core Version:    0.7.1
 */
package org.eclipse.wst.common.project.facet.core;

import org.eclipse.core.runtime.CoreException;

public abstract interface IFacetedProjectValidator
{
  public static final String BASE_MARKER_ID = "org.eclipse.wst.common.project.facet.core.validation.marker";
  
  public abstract void validate(IFacetedProject paramIFacetedProject)
    throws CoreException;
}

/* Location:
 * Qualified Name:     org.eclipse.wst.common.project.facet.core.IFacetedProjectValidator
 * Java Class Version: 5 (49.0)
 * JD-Core Version:    0.7.1
 */
package org.eclipse.wst.common.project.facet.core;

import java.util.Map;
import java.util.Set;
import java.util.SortedSet;
import org.eclipse.core.runtime.CoreException;
import org.eclipse.core.runtime.IPath;
import org.eclipse.core.runtime.IProgressMonitor;
import org.eclipse.wst.common.project.facet.core.runtime.IRuntime;

public abstract interface IFacetedProjectWorkingCopy
  extends IFacetedProjectBase
{
  public abstract String getProjectName();
  
  public abstract void setProjectName(String paramString);
  
  public abstract IPath getProjectLocation();
  
  public abstract void setProjectLocation(IPath paramIPath);
  
  public abstract IFacetedProject getFacetedProject();
  
  public abstract Map<IProjectFacet, SortedSet<IProjectFacetVersion>> getAvailableFacets();
  
  public abstract boolean isFacetAvailable(IProjectFacet paramIProjectFacet);
  
  public abstract boolean isFacetAvailable(IProjectFacetVersion paramIProjectFacetVersion);
  
  public abstract SortedSet<IProjectFacetVersion> getAvailableVersions(IProjectFacet paramIProjectFacet);
  
  public abstract IProjectFacetVersion getHighestAvailableVersion(IProjectFacet paramIProjectFacet);
  
  public abstract void setFixedProjectFacets(Set<IProjectFacet> paramSet);
  
  public abstract void setProjectFacets(Set<IProjectFacetVersion> paramSet);
  
  public abstract void addProjectFacet(IProjectFacetVersion paramIProjectFacetVersion);
  
  public abstract void removeProjectFacet(IProjectFacet paramIProjectFacet);
  
  public abstract void removeProjectFacet(IProjectFacetVersion paramIProjectFacetVersion);
  
  public abstract void changeProjectFacetVersion(IProjectFacetVersion paramIProjectFacetVersion);
  
  public abstract Set<IPreset> getAvailablePresets();
  
  public abstract IPreset getSelectedPreset();
  
  public abstract void setSelectedPreset(String paramString);
  
  public abstract IPreset getDefaultConfiguration();
  
  public abstract IPreset getMinimalConfiguration();
  
  public abstract Set<IRuntime> getTargetableRuntimes();
  
  public abstract void refreshTargetableRuntimes();
  
  public abstract void setTargetedRuntimes(Set<IRuntime> paramSet);
  
  public abstract void addTargetedRuntime(IRuntime paramIRuntime);
  
  public abstract void removeTargetedRuntime(IRuntime paramIRuntime);
  
  public abstract void setPrimaryRuntime(IRuntime paramIRuntime);
  
  public abstract Set<IFacetedProject.Action> getProjectFacetActions();
  
  public abstract IFacetedProject.Action getProjectFacetAction(IProjectFacet paramIProjectFacet);
  
  public abstract void setProjectFacetActionConfig(IProjectFacet paramIProjectFacet, Object paramObject);
  
  public abstract void detect(IProgressMonitor paramIProgressMonitor);
  
  public abstract boolean isDirty();
  
  public abstract void commitChanges(IProgressMonitor paramIProgressMonitor)
    throws CoreException;
  
  public abstract void mergeChanges(IFacetedProjectWorkingCopy paramIFacetedProjectWorkingCopy);
  
  public abstract void revertChanges();
  
  public abstract IFacetedProjectWorkingCopy clone();
  
  public abstract void dispose();
}

/* Location:
 * Qualified Name:     org.eclipse.wst.common.project.facet.core.IFacetedProjectWorkingCopy
 * Java Class Version: 5 (49.0)
 * JD-Core Version:    0.7.1
 */
package org.eclipse.wst.common.project.facet.core;

import java.util.Set;

public abstract interface IGroup
{
  public abstract String getId();
  
  public abstract String getLabel();
  
  public abstract String getDescription();
  
  public abstract Set<IProjectFacetVersion> getMembers();
}

/* Location:
 * Qualified Name:     org.eclipse.wst.common.project.facet.core.IGroup
 * Java Class Version: 5 (49.0)
 * JD-Core Version:    0.7.1
 */
package org.eclipse.wst.common.project.facet.core;

public abstract interface IListener
{
  public abstract void handle();
}

/* Location:
 * Qualified Name:     org.eclipse.wst.common.project.facet.core.IListener
 * Java Class Version: 5 (49.0)
 * JD-Core Version:    0.7.1
 */
package org.eclipse.wst.common.project.facet.core;

public enum IPreset$Type
{
  STATIC,  DYNAMIC,  USER_DEFINED;
}

/* Location:
 * Qualified Name:     org.eclipse.wst.common.project.facet.core.IPreset.Type
 * Java Class Version: 5 (49.0)
 * JD-Core Version:    0.7.1
 */
package org.eclipse.wst.common.project.facet.core;

import java.util.Set;

public abstract interface IPreset
{
  public abstract String getId();
  
  public abstract Type getType();
  
  public abstract String getLabel();
  
  public abstract String getDescription();
  
  public abstract Set<IProjectFacetVersion> getProjectFacets();
  
  /**
   * @deprecated
   */
  public abstract boolean isUserDefined();
  
  public static enum Type
  {
    STATIC,  DYNAMIC,  USER_DEFINED;
  }
}

/* Location:
 * Qualified Name:     org.eclipse.wst.common.project.facet.core.IPreset
 * Java Class Version: 5 (49.0)
 * JD-Core Version:    0.7.1
 */
package org.eclipse.wst.common.project.facet.core;

import java.util.Map;
import org.eclipse.core.runtime.CoreException;

public abstract interface IPresetFactory
{
  public abstract PresetDefinition createPreset(String paramString, Map<String, Object> paramMap)
    throws CoreException;
}

/* Location:
 * Qualified Name:     org.eclipse.wst.common.project.facet.core.IPresetFactory
 * Java Class Version: 5 (49.0)
 * JD-Core Version:    0.7.1
 */
package org.eclipse.wst.common.project.facet.core;

import java.util.Comparator;
import java.util.List;
import java.util.Map;
import java.util.Set;
import org.eclipse.core.runtime.CoreException;
import org.eclipse.core.runtime.IAdaptable;
import org.eclipse.wst.common.project.facet.core.runtime.IRuntime;

public abstract interface IProjectFacet
  extends IAdaptable
{
  public static final String PROP_HIDE_VERSION = "hide.version";
  
  public abstract String getId();
  
  public abstract Set<String> getAliases();
  
  public abstract String getPluginId();
  
  public abstract String getLabel();
  
  public abstract String getDescription();
  
  public abstract ICategory getCategory();
  
  public abstract Set<IProjectFacetVersion> getVersions();
  
  public abstract Set<IProjectFacetVersion> getVersions(String paramString)
    throws CoreException;
  
  public abstract boolean hasVersion(String paramString);
  
  public abstract IProjectFacetVersion getVersion(String paramString);
  
  public abstract IProjectFacetVersion getLatestVersion()
    throws VersionFormatException, CoreException;
  
  public abstract IProjectFacetVersion getLatestSupportedVersion(IRuntime paramIRuntime)
    throws CoreException;
  
  public abstract IProjectFacetVersion getDefaultVersion();
  
  public abstract List<IProjectFacetVersion> getSortedVersions(boolean paramBoolean)
    throws VersionFormatException, CoreException;
  
  public abstract Comparator<String> getVersionComparator()
    throws CoreException;
  
  public abstract Map<String, Object> getProperties();
  
  public abstract Object getProperty(String paramString);
}

/* Location:
 * Qualified Name:     org.eclipse.wst.common.project.facet.core.IProjectFacet
 * Java Class Version: 5 (49.0)
 * JD-Core Version:    0.7.1
 */
package org.eclipse.wst.common.project.facet.core;

import java.util.Map;
import java.util.Set;
import org.eclipse.core.runtime.CoreException;

public abstract interface IProjectFacetVersion
  extends Comparable, IVersion
{
  public abstract IProjectFacet getProjectFacet();
  
  public abstract String getVersionString();
  
  public abstract Set<String> getAliases();
  
  public abstract String getPluginId();
  
  public abstract IConstraint getConstraint();
  
  public abstract boolean supports(Set<IProjectFacetVersion> paramSet, IFacetedProject.Action.Type paramType);
  
  /**
   * @deprecated
   */
  public abstract boolean supports(IFacetedProject.Action.Type paramType);
  
  public abstract Set<IActionDefinition> getActionDefinitions();
  
  public abstract Set<IActionDefinition> getActionDefinitions(IFacetedProject.Action.Type paramType);
  
  public abstract IActionDefinition getActionDefinition(Set<IProjectFacetVersion> paramSet, IFacetedProject.Action.Type paramType)
    throws CoreException;
  
  /**
   * @deprecated
   */
  public abstract Object createActionConfig(IFacetedProject.Action.Type paramType, String paramString)
    throws CoreException;
  
  /**
   * @deprecated
   */
  public abstract boolean isSameActionConfig(IFacetedProject.Action.Type paramType, IProjectFacetVersion paramIProjectFacetVersion)
    throws CoreException;
  
  public abstract boolean isValidFor(Set<IProjectFacet> paramSet);
  
  public abstract boolean conflictsWith(IProjectFacetVersion paramIProjectFacetVersion);
  
  public abstract Map<String, Object> getProperties();
  
  public abstract Object getProperty(String paramString);
}

/* Location:
 * Qualified Name:     org.eclipse.wst.common.project.facet.core.IProjectFacetVersion
 * Java Class Version: 5 (49.0)
 * JD-Core Version:    0.7.1
 */
package org.eclipse.wst.common.project.facet.core;

import org.eclipse.wst.common.project.facet.core.runtime.IRuntime;

/**
 * @deprecated
 */
public abstract interface IRuntimeChangedEvent
{
  public abstract IRuntime getOldRuntime();
  
  public abstract IRuntime getNewRuntime();
}

/* Location:
 * Qualified Name:     org.eclipse.wst.common.project.facet.core.IRuntimeChangedEvent
 * Java Class Version: 5 (49.0)
 * JD-Core Version:    0.7.1
 */
package org.eclipse.wst.common.project.facet.core;

public abstract interface IVersion
  extends Comparable
{
  public abstract String getVersionString();
}

/* Location:
 * Qualified Name:     org.eclipse.wst.common.project.facet.core.IVersion
 * Java Class Version: 5 (49.0)
 * JD-Core Version:    0.7.1
 */
package org.eclipse.wst.common.project.facet.core;

public abstract interface IVersionExpr
{
  public static final String WILDCARD_SYMBOL = "*";
  
  public abstract boolean check(IVersion paramIVersion);
  
  /**
   * @deprecated
   */
  public abstract boolean evaluate(String paramString);
  
  public abstract String toDisplayString();
}

/* Location:
 * Qualified Name:     org.eclipse.wst.common.project.facet.core.IVersionExpr
 * Java Class Version: 5 (49.0)
 * JD-Core Version:    0.7.1
 */
package org.eclipse.wst.common.project.facet.core;

import org.eclipse.osgi.util.NLS;

final class MinimalConfigurationPresetFactory$Resources
  extends NLS
{
  public static String presetLabel;
  public static String presetDescription;
  
  static
  {
    initializeMessages(MinimalConfigurationPresetFactory.class.getName(), 
      Resources.class);
  }
}

/* Location:
 * Qualified Name:     org.eclipse.wst.common.project.facet.core.MinimalConfigurationPresetFactory.Resources
 * Java Class Version: 5 (49.0)
 * JD-Core Version:    0.7.1
 */
package org.eclipse.wst.common.project.facet.core;

import java.util.HashSet;
import java.util.Map;
import java.util.Set;
import org.eclipse.core.runtime.CoreException;
import org.eclipse.osgi.util.NLS;
import org.eclipse.wst.common.project.facet.core.internal.DefaultFacetsExtensionPoint;

public class MinimalConfigurationPresetFactory
  implements IPresetFactory
{
  public static final String PRESET_ID = "minimal.configuration";
  
  public PresetDefinition createPreset(String presetId, Map<String, Object> context)
    throws CoreException
  {
    IFacetedProjectBase fproj = 
      (IFacetedProjectBase)context.get("CONTEXT_KEY_FACETED_PROJECT");
    
    Set<IProjectFacetVersion> facets = new HashSet();
    
    Set<IProjectFacetVersion> defaultFacets = 
      DefaultFacetsExtensionPoint.getDefaultFacets(fproj);
    if (d
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18

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