org.eclipse.xsd_2.7.1.v20120130-0943

16:49:38.260 INFO  jd.cli.Main - Decompiling org.eclipse.xsd_2.7.1.v20120130-0943.jar
package org.eclipse.xsd;

import java.util.Set;
import org.eclipse.emf.common.util.EList;
import org.w3c.dom.Attr;
import org.w3c.dom.Element;

public abstract interface XSDAnnotation
  extends XSDComponent, XSDRedefineContent
{
  public abstract EList<Element> getApplicationInformation();
  
  public abstract EList<Element> getUserInformation();
  
  public abstract EList<Attr> getAttributes();
  
  public abstract Element createApplicationInformation(String paramString);
  
  public abstract Element createUserInformation(String paramString);
  
  public abstract EList<Element> getApplicationInformation(String paramString);
  
  public abstract EList<Element> getUserInformation(String paramString);
  
  public abstract Set<String> getApplicationInformationSources();
  
  public abstract Set<String> getUserInformationSources();
}

/* Location:
 * Qualified Name:     org.eclipse.xsd.XSDAnnotation
 * Java Class Version: 5 (49.0)
 * JD-Core Version:    0.7.1
 */
package org.eclipse.xsd;

public abstract interface XSDAttributeDeclaration
  extends XSDFeature, XSDSchemaContent
{
  public abstract boolean isAttributeDeclarationReference();
  
  public abstract XSDAnnotation getAnnotation();
  
  public abstract void setAnnotation(XSDAnnotation paramXSDAnnotation);
  
  public abstract XSDSimpleTypeDefinition getAnonymousTypeDefinition();
  
  public abstract void setAnonymousTypeDefinition(XSDSimpleTypeDefinition paramXSDSimpleTypeDefinition);
  
  public abstract XSDSimpleTypeDefinition getTypeDefinition();
  
  public abstract void setTypeDefinition(XSDSimpleTypeDefinition paramXSDSimpleTypeDefinition);
  
  public abstract XSDAttributeDeclaration getResolvedAttributeDeclaration();
  
  public abstract void setResolvedAttributeDeclaration(XSDAttributeDeclaration paramXSDAttributeDeclaration);
}

/* Location:
 * Qualified Name:     org.eclipse.xsd.XSDAttributeDeclaration
 * Java Class Version: 5 (49.0)
 * JD-Core Version:    0.7.1
 */
package org.eclipse.xsd;

public abstract interface XSDAttributeGroupContent
  extends XSDConcreteComponent
{}

/* Location:
 * Qualified Name:     org.eclipse.xsd.XSDAttributeGroupContent
 * Java Class Version: 5 (49.0)
 * JD-Core Version:    0.7.1
 */
package org.eclipse.xsd;

import org.eclipse.emf.common.util.EList;

public abstract interface XSDAttributeGroupDefinition
  extends XSDRedefinableComponent, XSDAttributeGroupContent, XSDRedefineContent
{
  public abstract boolean isAttributeGroupDefinitionReference();
  
  public abstract XSDAnnotation getAnnotation();
  
  public abstract void setAnnotation(XSDAnnotation paramXSDAnnotation);
  
  public abstract EList<XSDAttributeGroupContent> getContents();
  
  public abstract EList<XSDAttributeUse> getAttributeUses();
  
  public abstract XSDWildcard getAttributeWildcardContent();
  
  public abstract void setAttributeWildcardContent(XSDWildcard paramXSDWildcard);
  
  public abstract XSDWildcard getAttributeWildcard();
  
  public abstract void setAttributeWildcard(XSDWildcard paramXSDWildcard);
  
  public abstract XSDAttributeGroupDefinition getResolvedAttributeGroupDefinition();
  
  public abstract void setResolvedAttributeGroupDefinition(XSDAttributeGroupDefinition paramXSDAttributeGroupDefinition);
  
  public abstract XSDWildcard getSyntheticWildcard();
  
  public abstract void setSyntheticWildcard(XSDWildcard paramXSDWildcard);
}

/* Location:
 * Qualified Name:     org.eclipse.xsd.XSDAttributeGroupDefinition
 * Java Class Version: 5 (49.0)
 * JD-Core Version:    0.7.1
 */
package org.eclipse.xsd;

public abstract interface XSDAttributeUse
  extends XSDComponent, XSDAttributeGroupContent
{
  public abstract boolean isRequired();
  
  public abstract void setRequired(boolean paramBoolean);
  
  public abstract Object getValue();
  
  public abstract void setValue(Object paramObject);
  
  public abstract XSDConstraint getConstraint();
  
  public abstract void setConstraint(XSDConstraint paramXSDConstraint);
  
  public abstract void unsetConstraint();
  
  public abstract boolean isSetConstraint();
  
  public abstract XSDAttributeUseCategory getUse();
  
  public abstract void setUse(XSDAttributeUseCategory paramXSDAttributeUseCategory);
  
  public abstract void unsetUse();
  
  public abstract boolean isSetUse();
  
  public abstract String getLexicalValue();
  
  public abstract void setLexicalValue(String paramString);
  
  public abstract XSDAttributeDeclaration getAttributeDeclaration();
  
  public abstract void setAttributeDeclaration(XSDAttributeDeclaration paramXSDAttributeDeclaration);
  
  public abstract XSDAttributeDeclaration getContent();
  
  public abstract void setContent(XSDAttributeDeclaration paramXSDAttributeDeclaration);
}

/* Location:
 * Qualified Name:     org.eclipse.xsd.XSDAttributeUse
 * Java Class Version: 5 (49.0)
 * JD-Core Version:    0.7.1
 */
package org.eclipse.xsd;

import java.util.Arrays;
import java.util.Collections;
import java.util.List;
import org.eclipse.emf.common.util.Enumerator;

public enum XSDAttributeUseCategory
  implements Enumerator
{
  OPTIONAL_LITERAL(
  
    0, "optional", "optional"),  PROHIBITED_LITERAL(
  
    1, "prohibited", "prohibited"),  REQUIRED_LITERAL(
  
    2, "required", "required");
  
  public static final int OPTIONAL = 0;
  public static final int PROHIBITED = 1;
  public static final int REQUIRED = 2;
  private static final XSDAttributeUseCategory[] VALUES_ARRAY = {
    OPTIONAL_LITERAL, 
    PROHIBITED_LITERAL, 
    REQUIRED_LITERAL };
  public static final List<XSDAttributeUseCategory> VALUES = Collections.unmodifiableList(Arrays.asList(VALUES_ARRAY));
  private final int value;
  private final String name;
  private final String literal;
  
  public static XSDAttributeUseCategory get(String literal)
  {
    for (int i = 0; i < VALUES_ARRAY.length; i++)
    {
      XSDAttributeUseCategory result = VALUES_ARRAY[i];
      if (result.toString().equals(literal)) {
        return result;
      }
    }
    return null;
  }
  
  public static XSDAttributeUseCategory getByName(String name)
  {
    for (int i = 0; i < VALUES_ARRAY.length; i++)
    {
      XSDAttributeUseCategory result = VALUES_ARRAY[i];
      if (result.getName().equals(name)) {
        return result;
      }
    }
    return null;
  }
  
  public static XSDAttributeUseCategory get(int value)
  {
    switch (value)
    {
    case 0: 
      return OPTIONAL_LITERAL;
    case 1: 
      return PROHIBITED_LITERAL;
    case 2: 
      return REQUIRED_LITERAL;
    }
    return null;
  }
  
  private XSDAttributeUseCategory(int value, String name, String literal)
  {
    this.value = value;
    this.name = name;
    this.literal = literal;
  }
  
  public int getValue()
  {
    return value;
  }
  
  public String getName()
  {
    return name;
  }
  
  public String getLiteral()
  {
    return literal;
  }
  
  public String toString()
  {
    return literal;
  }
}

/* Location:
 * Qualified Name:     org.eclipse.xsd.XSDAttributeUseCategory
 * Java Class Version: 5 (49.0)
 * JD-Core Version:    0.7.1
 */
package org.eclipse.xsd;

public abstract interface XSDBoundedFacet
  extends XSDFundamentalFacet
{
  public abstract boolean isValue();
  
  public abstract void setValue(boolean paramBoolean);
}

/* Location:
 * Qualified Name:     org.eclipse.xsd.XSDBoundedFacet
 * Java Class Version: 5 (49.0)
 * JD-Core Version:    0.7.1
 */
package org.eclipse.xsd;

import java.util.Arrays;
import java.util.Collections;
import java.util.List;
import org.eclipse.emf.common.util.Enumerator;

public enum XSDCardinality
  implements Enumerator
{
  FINITE_LITERAL(
  
    0, "finite", "finite"),  COUNTABLY_INFINITE_LITERAL(
  
    1, "countablyInfinite", "countablyInfinite");
  
  public static final int FINITE = 0;
  public static final int COUNTABLY_INFINITE = 1;
  private static final XSDCardinality[] VALUES_ARRAY = {
    FINITE_LITERAL, 
    COUNTABLY_INFINITE_LITERAL };
  public static final List<XSDCardinality> VALUES = Collections.unmodifiableList(Arrays.asList(VALUES_ARRAY));
  private final int value;
  private final String name;
  private final String literal;
  
  public static XSDCardinality get(String literal)
  {
    for (int i = 0; i < VALUES_ARRAY.length; i++)
    {
      XSDCardinality result = VALUES_ARRAY[i];
      if (result.toString().equals(literal)) {
        return result;
      }
    }
    return null;
  }
  
  public static XSDCardinality getByName(String name)
  {
    for (int i = 0; i < VALUES_ARRAY.length; i++)
    {
      XSDCardinality result = VALUES_ARRAY[i];
      if (result.getName().equals(name)) {
        return result;
      }
    }
    return null;
  }
  
  public static XSDCardinality get(int value)
  {
    switch (value)
    {
    case 0: 
      return FINITE_LITERAL;
    case 1: 
      return COUNTABLY_INFINITE_LITERAL;
    }
    return null;
  }
  
  private XSDCardinality(int value, String name, String literal)
  {
    this.value = value;
    this.name = name;
    this.literal = literal;
  }
  
  public int getValue()
  {
    return value;
  }
  
  public String getName()
  {
    return name;
  }
  
  public String getLiteral()
  {
    return literal;
  }
  
  public String toString()
  {
    return literal;
  }
}

/* Location:
 * Qualified Name:     org.eclipse.xsd.XSDCardinality
 * Java Class Version: 5 (49.0)
 * JD-Core Version:    0.7.1
 */
package org.eclipse.xsd;

public abstract interface XSDCardinalityFacet
  extends XSDFundamentalFacet
{
  public abstract XSDCardinality getValue();
  
  public abstract void setValue(XSDCardinality paramXSDCardinality);
}

/* Location:
 * Qualified Name:     org.eclipse.xsd.XSDCardinalityFacet
 * Java Class Version: 5 (49.0)
 * JD-Core Version:    0.7.1
 */
package org.eclipse.xsd;

import java.util.Arrays;
import java.util.Collections;
import java.util.List;
import org.eclipse.emf.common.util.Enumerator;

public enum XSDComplexFinal
  implements Enumerator
{
  EXTENSION_LITERAL(
  
    0, "extension", "extension"),  RESTRICTION_LITERAL(
  
    1, "restriction", "restriction"),  ALL_LITERAL(
  
    2, "all", "all");
  
  public static final int EXTENSION = 0;
  public static final int RESTRICTION = 1;
  public static final int ALL = 2;
  private static final XSDComplexFinal[] VALUES_ARRAY = {
    EXTENSION_LITERAL, 
    RESTRICTION_LITERAL, 
    ALL_LITERAL };
  public static final List<XSDComplexFinal> VALUES = Collections.unmodifiableList(Arrays.asList(VALUES_ARRAY));
  private final int value;
  private final String name;
  private final String literal;
  
  public static XSDComplexFinal get(String literal)
  {
    for (int i = 0; i < VALUES_ARRAY.length; i++)
    {
      XSDComplexFinal result = VALUES_ARRAY[i];
      if (result.toString().equals(literal)) {
        return result;
      }
    }
    return null;
  }
  
  public static XSDComplexFinal getByName(String name)
  {
    for (int i = 0; i < VALUES_ARRAY.length; i++)
    {
      XSDComplexFinal result = VALUES_ARRAY[i];
      if (result.getName().equals(name)) {
        return result;
      }
    }
    return null;
  }
  
  public static XSDComplexFinal get(int value)
  {
    switch (value)
    {
    case 0: 
      return EXTENSION_LITERAL;
    case 1: 
      return RESTRICTION_LITERAL;
    case 2: 
      return ALL_LITERAL;
    }
    return null;
  }
  
  private XSDComplexFinal(int value, String name, String literal)
  {
    this.value = value;
    this.name = name;
    this.literal = literal;
  }
  
  public int getValue()
  {
    return value;
  }
  
  public String getName()
  {
    return name;
  }
  
  public String getLiteral()
  {
    return literal;
  }
  
  public String toString()
  {
    return literal;
  }
}

/* Location:
 * Qualified Name:     org.eclipse.xsd.XSDComplexFinal
 * Java Class Version: 5 (49.0)
 * JD-Core Version:    0.7.1
 */
package org.eclipse.xsd;

public abstract interface XSDComplexTypeContent
  extends XSDComponent
{}

/* Location:
 * Qualified Name:     org.eclipse.xsd.XSDComplexTypeContent
 * Java Class Version: 5 (49.0)
 * JD-Core Version:    0.7.1
 */
package org.eclipse.xsd;

import org.eclipse.emf.common.util.EList;

public abstract interface XSDComplexTypeDefinition
  extends XSDTypeDefinition, XSDScope
{
  public abstract XSDDerivationMethod getDerivationMethod();
  
  public abstract void setDerivationMethod(XSDDerivationMethod paramXSDDerivationMethod);
  
  public abstract void unsetDerivationMethod();
  
  public abstract boolean isSetDerivationMethod();
  
  public abstract EList<XSDComplexFinal> getFinal();
  
  public abstract String getStringFinal();
  
  public abstract boolean isAbstract();
  
  public abstract void setAbstract(boolean paramBoolean);
  
  public abstract void unsetAbstract();
  
  public abstract boolean isSetAbstract();
  
  public abstract XSDContentTypeCategory getContentTypeCategory();
  
  public abstract void setContentTypeCategory(XSDContentTypeCategory paramXSDContentTypeCategory);
  
  public abstract EList<XSDProhibitedSubstitutions> getProhibitedSubstitutions();
  
  public abstract String getStringProhibitedSubstitutions();
  
  public abstract EList<XSDComplexFinal> getLexicalFinal();
  
  public abstract void unsetLexicalFinal();
  
  public abstract boolean isSetLexicalFinal();
  
  public abstract String getStringLexicalFinal();
  
  public abstract void setStringLexicalFinal(String paramString);
  
  public abstract EList<XSDProhibitedSubstitutions> getBlock();
  
  public abstract void unsetBlock();
  
  public abstract boolean isSetBlock();
  
  public abstract String getStringBlock();
  
  public abstract void setStringBlock(String paramString);
  
  public abstract boolean isMixed();
  
  public abstract void setMixed(boolean paramBoolean);
  
  public abstract void unsetMixed();
  
  public abstract boolean isSetMixed();
  
  public abstract XSDAnnotation getContentAnnotation();
  
  public abstract void setContentAnnotation(XSDAnnotation paramXSDAnnotation);
  
  public abstract XSDTypeDefinition getBaseTypeDefinition();
  
  public abstract void setBaseTypeDefinition(XSDTypeDefinition paramXSDTypeDefinition);
  
  public abstract XSDComplexTypeContent getContent();
  
  public abstract void setContent(XSDComplexTypeContent paramXSDComplexTypeContent);
  
  public abstract XSDComplexTypeContent getContentType();
  
  public abstract void setContentType(XSDComplexTypeContent paramXSDComplexTypeContent);
  
  public abstract EList<XSDAttributeUse> getAttributeUses();
  
  public abstract EList<XSDAttributeGroupContent> getAttributeContents();
  
  public abstract XSDWildcard getAttributeWildcard();
  
  public abstract void setAttributeWildcard(XSDWildcard paramXSDWildcard);
  
  public abstract XSDWildcard getAttributeWildcardContent();
  
  public abstract void setAttributeWildcardContent(XSDWildcard paramXSDWildcard);
  
  public abstract XSDTypeDefinition getRootTypeDefinition();
  
  public abstract XSDParticle getSyntheticParticle();
  
  public abstract void setSyntheticParticle(XSDParticle paramXSDParticle);
  
  public abstract XSDWildcard getSyntheticWildcard();
  
  public abstract void setSyntheticWildcard(XSDWildcard paramXSDWildcard);
}

/* Location:
 * Qualified Name:     org.eclipse.xsd.XSDComplexTypeDefinition
 * Java Class Version: 5 (49.0)
 * JD-Core Version:    0.7.1
 */
package org.eclipse.xsd;

public abstract interface XSDComponent
  extends XSDConcreteComponent
{}

/* Location:
 * Qualified Name:     org.eclipse.xsd.XSDComponent
 * Java Class Version: 5 (49.0)
 * JD-Core Version:    0.7.1
 */
package org.eclipse.xsd;

import java.util.Arrays;
import java.util.Collections;
import java.util.List;
import org.eclipse.emf.common.util.Enumerator;

public enum XSDCompositor
  implements Enumerator
{
  ALL_LITERAL(
  
    0, "all", "all"),  CHOICE_LITERAL(
  
    1, "choice", "choice"),  SEQUENCE_LITERAL(
  
    2, "sequence", "sequence");
  
  public static final int ALL = 0;
  public static final int CHOICE = 1;
  public static final int SEQUENCE = 2;
  private static final XSDCompositor[] VALUES_ARRAY = {
    ALL_LITERAL, 
    CHOICE_LITERAL, 
    SEQUENCE_LITERAL };
  public static final List<XSDCompositor> VALUES = Collections.unmodifiableList(Arrays.asList(VALUES_ARRAY));
  private final int value;
  private final String name;
  private final String literal;
  
  public static XSDCompositor get(String literal)
  {
    for (int i = 0; i < VALUES_ARRAY.length; i++)
    {
      XSDCompositor result = VALUES_ARRAY[i];
      if (result.toString().equals(literal)) {
        return result;
      }
    }
    return null;
  }
  
  public static XSDCompositor getByName(String name)
  {
    for (int i = 0; i < VALUES_ARRAY.length; i++)
    {
      XSDCompositor result = VALUES_ARRAY[i];
      if (result.getName().equals(name)) {
        return result;
      }
    }
    return null;
  }
  
  public static XSDCompositor get(int value)
  {
    switch (value)
    {
    case 0: 
      return ALL_LITERAL;
    case 1: 
      return CHOICE_LITERAL;
    case 2: 
      return SEQUENCE_LITERAL;
    }
    return null;
  }
  
  private XSDCompositor(int value, String name, String literal)
  {
    this.value = value;
    this.name = name;
    this.literal = literal;
  }
  
  public int getValue()
  {
    return value;
  }
  
  public String getName()
  {
    return name;
  }
  
  public String getLiteral()
  {
    return literal;
  }
  
  public String toString()
  {
    return literal;
  }
}

/* Location:
 * Qualified Name:     org.eclipse.xsd.XSDCompositor
 * Java Class Version: 5 (49.0)
 * JD-Core Version:    0.7.1
 */
package org.eclipse.xsd;

import java.util.Collection;
import org.eclipse.emf.common.util.EList;
import org.eclipse.emf.ecore.EObject;
import org.w3c.dom.Element;

public abstract interface XSDConcreteComponent
  extends EObject
{
  public abstract Element getElement();
  
  public abstract void setElement(Element paramElement);
  
  public abstract void updateElement();
  
  public abstract void updateElement(boolean paramBoolean);
  
  public abstract XSDConcreteComponent getContainer();
  
  public abstract XSDConcreteComponent getRootContainer();
  
  public abstract XSDSchema getSchema();
  
  public abstract EList<XSDDiagnostic> getDiagnostics();
  
  public abstract void elementChanged(Element paramElement);
  
  public abstract void elementAttributesChanged(Element paramElement);
  
  public abstract void elementContentsChanged(Element paramElement);
  
  public abstract XSDTypeDefinition resolveTypeDefinitionURI(String paramString);
  
  public abstract XSDTypeDefinition resolveTypeDefinition(String paramString1, String paramString2);
  
  public abstract XSDTypeDefinition resolveTypeDefinition(String paramString);
  
  public abstract XSDSimpleTypeDefinition resolveSimpleTypeDefinitionURI(String paramString);
  
  public abstract XSDSimpleTypeDefinition resolveSimpleTypeDefinition(String paramString1, String paramString2);
  
  public abstract XSDSimpleTypeDefinition resolveSimpleTypeDefinition(String paramString);
  
  public abstract XSDComplexTypeDefinition resolveComplexTypeDefinitionURI(String paramString);
  
  public abstract XSDComplexTypeDefinition resolveComplexTypeDefinition(String paramString1, String paramString2);
  
  public abstract XSDComplexTypeDefinition resolveComplexTypeDefinition(String paramString);
  
  public abstract XSDAttributeDeclaration resolveAttributeDeclarationURI(String paramString);
  
  public abstract XSDAttributeDeclaration resolveAttributeDeclaration(String paramString1, String paramString2);
  
  public abstract XSDAttributeDeclaration resolveAttributeDeclaration(String paramString);
  
  public abstract XSDElementDeclaration resolveElementDeclarationURI(String paramString);
  
  public abstract XSDElementDeclaration resolveElementDeclaration(String paramString1, String paramString2);
  
  public abstract XSDElementDeclaration resolveElementDeclaration(String paramString);
  
  public abstract XSDAttributeGroupDefinition resolveAttributeGroupDefinitionURI(String paramString);
  
  public abstract XSDAttributeGroupDefinition resolveAttributeGroupDefinition(String paramString1, String paramString2);
  
  public abstract XSDAttributeGroupDefinition resolveAttributeGroupDefinition(String paramString);
  
  public abstract XSDModelGroupDefinition resolveModelGroupDefinitionURI(String paramString);
  
  public abstract XSDModelGroupDefinition resolveModelGroupDefinition(String paramString1, String paramString2);
  
  public abstract XSDModelGroupDefinition resolveModelGroupDefinition(String paramString);
  
  public abstract XSDIdentityConstraintDefinition resolveIdentityConstraintDefinitionURI(String paramString);
  
  public abstract XSDIdentityConstraintDefinition resolveIdentityConstraintDefinition(String paramString1, String paramString2);
  
  public abstract XSDIdentityConstraintDefinition resolveIdentityConstraintDefinition(String paramString);
  
  public abstract XSDNotationDeclaration resolveNotationDeclarationURI(String paramString);
  
  public abstract XSDNotationDeclaration resolveNotationDeclaration(String paramString1, String paramString2);
  
  public abstract XSDNotationDeclaration resolveNotationDeclaration(String paramString);
  
  public abstract Collection<XSDConcreteComponent> getComponentsWithApplicationInformation(String paramString);
  
  public abstract Collection<XSDConcreteComponent> getComponentsWithUserInformation(String paramString);
  
  public abstract void validate();
  
  public abstract void clearDiagnostics();
  
  public abstract XSDConcreteComponent cloneConcreteComponent(boolean paramBoolean1, boolean paramBoolean2);
  
  public abstract boolean contains(XSDConcreteComponent paramXSDConcreteComponent);
}

/* Location:
 * Qualified Name:     org.eclipse.xsd.XSDConcreteComponent
 * Java Class Version: 5 (49.0)
 * JD-Core Version:    0.7.1
 */
package org.eclipse.xsd;

public abstract interface XSDConstrainingFacet
  extends XSDFacet
{
  public abstract boolean isConstraintSatisfied(Object paramObject);
}

/* Location:
 * Qualified Name:     org.eclipse.xsd.XSDConstrainingFacet
 * Java Class Version: 5 (49.0)
 * JD-Core Version:    0.7.1
 */
package org.eclipse.xsd;

import java.util.Arrays;
import java.util.Collections;
import java.util.List;
import org.eclipse.emf.common.util.Enumerator;

public enum XSDConstraint
  implements Enumerator
{
  DEFAULT_LITERAL(
  
    0, "default", "default"),  FIXED_LITERAL(
  
    1, "fixed", "fixed");
  
  public static final int DEFAULT = 0;
  public static final int FIXED = 1;
  private static final XSDConstraint[] VALUES_ARRAY = {
    DEFAULT_LITERAL, 
    FIXED_LITERAL };
  public static final List<XSDConstraint> VALUES = Collections.unmodifiableList(Arrays.asList(VALUES_ARRAY));
  private final int value;
  private final String name;
  private final String literal;
  
  public static XSDConstraint get(String literal)
  {
    for (int i = 0; i < VALUES_ARRAY.length; i++)
    {
      XSDConstraint result = VALUES_ARRAY[i];
      if (result.toString().equals(literal)) {
        return result;
      }
    }
    return null;
  }
  
  public static XSDConstraint getByName(String name)
  {
    for (int i = 0; i < VALUES_ARRAY.length; i++)
    {
      XSDConstraint result = VALUES_ARRAY[i];
      if (result.getName().equals(name)) {
        return result;
      }
    }
    return null;
  }
  
  public static XSDConstraint get(int value)
  {
    switch (value)
    {
    case 0: 
      return DEFAULT_LITERAL;
    case 1: 
      return FIXED_LITERAL;
    }
    return null;
  }
  
  private XSDConstraint(int value, String name, String literal)
  {
    this.value = value;
    this.name = name;
    this.literal = literal;
  }
  
  public int getValue()
  {
    return value;
  }
  
  public String getName()
  {
    return name;
  }
  
  public String getLiteral()
  {
    return literal;
  }
  
  public String toString()
  {
    return literal;
  }
}

/* Location:
 * Qualified Name:     org.eclipse.xsd.XSDConstraint
 * Java Class Version: 5 (49.0)
 * JD-Core Version:    0.7.1
 */
package org.eclipse.xsd;

import java.util.Arrays;
import java.util.Collections;
import java.util.List;
import org.eclipse.emf.common.util.Enumerator;

public enum XSDContentTypeCategory
  implements Enumerator
{
  EMPTY_LITERAL(
  
    0, "empty", "empty"),  SIMPLE_LITERAL(
  
    1, "simple", "simple"),  MIXED_LITERAL(
  
    2, "mixed", "mixed"),  ELEMENT_ONLY_LITERAL(
  
    3, "elementOnly", "elementOnly");
  
  public static final int EMPTY = 0;
  public static final int SIMPLE = 1;
  public static final int MIXED = 2;
  public static final int ELEMENT_ONLY = 3;
  private static final XSDContentTypeCategory[] VALUES_ARRAY = {
    EMPTY_LITERAL, 
    SIMPLE_LITERAL, 
    MIXED_LITERAL, 
    ELEMENT_ONLY_LITERAL };
  public static final List<XSDContentTypeCategory> VALUES = Collections.unmodifiableList(Arrays.asList(VALUES_ARRAY));
  private final int value;
  private final String name;
  private final String literal;
  
  public static XSDContentTypeCategory get(String literal)
  {
    for (int i = 0; i < VALUES_ARRAY.length; i++)
    {
      XSDContentTypeCategory result = VALUES_ARRAY[i];
      if (result.toString().equals(literal)) {
        return result;
      }
    }
    return null;
  }
  
  public static XSDContentTypeCategory getByName(String name)
  {
    for (int i = 0; i < VALUES_ARRAY.length; i++)
    {
      XSDContentTypeCategory result = VALUES_ARRAY[i];
      if (result.getName().equals(name)) {
        return result;
      }
    }
    return null;
  }
  
  public static XSDContentTypeCategory get(int value)
  {
    switch (value)
    {
    case 0: 
      return EMPTY_LITERAL;
    case 1: 
      return SIMPLE_LITERAL;
    case 2: 
      return MIXED_LITERAL;
    case 3: 
      return ELEMENT_ONLY_LITERAL;
    }
    return null;
  }
  
  private XSDContentTypeCategory(int value, String name, String literal)
  {
    this.value = value;
    this.name = name;
    this.literal = literal;
  }
  
  public int getValue()
  {
    return value;
  }
  
  public String getName()
  {
    return name;
  }
  
  public String getLiteral()
  {
    return literal;
  }
  
  public String toString()
  {
    return literal;
  }
}

/* Location:
 * Qualified Name:     org.eclipse.xsd.XSDContentTypeCategory
 * Java Class Version: 5 (49.0)
 * JD-Core Version:    0.7.1
 */
package org.eclipse.xsd;

import java.util.Arrays;
import java.util.Collections;
import java.util.List;
import org.eclipse.emf.common.util.Enumerator;

public enum XSDDerivationMethod
  implements Enumerator
{
  EXTENSION_LITERAL(
  
    0, "extension", "extension"),  RESTRICTION_LITERAL(
  
    1, "restriction", "restriction");
  
  public static final int EXTENSION = 0;
  public static final int RESTRICTION = 1;
  private static final XSDDerivationMethod[] VALUES_ARRAY = {
    EXTENSION_LITERAL, 
    RESTRICTION_LITERAL };
  public static final List<XSDDerivationMethod> VALUES = Collections.unmodifiableList(Arrays.asList(VALUES_ARRAY));
  private final int value;
  private final String name;
  private final String literal;
  
  public static XSDDerivationMethod get(String literal)
  {
    for (int i = 0; i < VALUES_ARRAY.length; i++)
    {
      XSDDerivationMethod result = VALUES_ARRAY[i];
      if (result.toString().equals(literal)) {
        return result;
      }
    }
    return null;
  }
  
  public static XSDDerivationMethod getByName(String name)
  {
    for (int i = 0; i < VALUES_ARRAY.length; i++)
    {
      XSDDerivationMethod result = VALUES_ARRAY[i];
      if (result.getName().equals(name)) {
        return result;
      }
    }
    return null;
  }
  
  public static XSDDerivationMethod get(int value)
  {
    switch (value)
    {
    case 0: 
      return EXTENSION_LITERAL;
    case 1: 
      return RESTRICTION_LITERAL;
    }
    return null;
  }
  
  private XSDDerivationMethod(int value, String name, String literal)
  {
    this.value = value;
    this.name = name;
    this.literal = literal;
  }
  
  public int getValue()
  {
    return value;
  }
  
  public String getName()
  {
    return name;
  }
  
  public String getLiteral()
  {
    return literal;
  }
  
  public String toString()
  {
    return literal;
  }
}

/* Location:
 * Qualified Name:     org.eclipse.xsd.XSDDerivationMethod
 * Java Class Version: 5 (49.0)
 * JD-Core Version:    0.7.1
 */
package org.eclipse.xsd;

import org.eclipse.emf.common.util.EList;
import org.eclipse.emf.ecore.resource.Resource.Diagnostic;
import org.w3c.dom.Node;

public abstract interface XSDDiagnostic
  extends XSDConcreteComponent, Resource.Diagnostic
{
  public static final String MARKER = "org.eclipse.xsd.diagnostic";
  public static final String URI_FRAGMENT_ATTRIBUTE = "diagnostic";
  
  public abstract XSDDiagnosticSeverity getSeverity();
  
  public abstract void setSeverity(XSDDiagnosticSeverity paramXSDDiagnosticSeverity);
  
  public abstract String getMessage();
  
  public abstract void setMessage(String paramString);
  
  public abstract String getLocationURI();
  
  public abstract void setLocationURI(String paramString);
  
  public abstract int getLine();
  
  public abstract void setLine(int paramInt);
  
  public abstract int getColumn();
  
  public abstract void setColumn(int paramInt);
  
  public abstract Node getNode();
  
  public abstract void setNode(Node paramNode);
  
  public abstract String getAnnotationURI();
  
  public abstract void setAnnotationURI(String paramString);
  
  public abstract String getKey();
  
  public abstract void setKey(String paramString);
  
  public abstract EList<String> getSubstitutions();
  
  public abstract EList<XSDConcreteComponent> getComponents();
  
  public abstract XSDConcreteComponent getPrimaryComponent();
  
  public abstract void setPrimaryComponent(XSDConcreteComponent paramXSDConcreteComponent);
}

/* Location:
 * Qualified Name:     org.eclipse.xsd.XSDDiagnostic
 * Java Class Version: 5 (49.0)
 * JD-Core Version:    0.7.1
 */
package org.eclipse.xsd;

import java.util.Arrays;
import java.util.Collections;
import java.util.List;
import org.eclipse.emf.common.util.Enumerator;

public enum XSDDiagnosticSeverity
  implements Enumerator
{
  FATAL_LITERAL(
  
    0, "fatal", "fatal"),  ERROR_LITERAL(
  
    1, "error", "error"),  WARNING_LITERAL(
  
    2, "warning", "warning"),  INFORMATION_LITERAL(
  
    3, "information", "information");
  
  public static final int FATAL = 0;
  public static final int ERROR = 1;
  public static final int WARNING = 2;
  public static final int INFORMATION = 3;
  private static final XSDDiagnosticSeverity[] VALUES_ARRAY = {
    FATAL_LITERAL, 
    ERROR_LITERAL, 
    WARNING_LITERAL, 
    INFORMATION_LITERAL };
  public static final List<XSDDiagnosticSeverity> VALUES = Collections.unmodifiableList(Arrays.asList(VALUES_ARRAY));
  private final int value;
  private final String name;
  private final String literal;
  
  public static XSDDiagnosticSeverity get(String literal)
  {
    for (int i = 0; i < VALUES_ARRAY.length; i++)
    {
      XSDDiagnosticSeverity result = VALUES_ARRAY[i];
      if (result.toString().equals(literal)) {
        return result;
      }
    }
    return null;
  }
  
  public static XSDDiagnosticSeverity getByName(String name)
  {
    for (int i = 0; i < VALUES_ARRAY.length; i++)
    {
      XSDDiagnosticSeverity result = VALUES_ARRAY[i];
      if (result.getName().equals(name)) {
        return result;
      }
    }
    return null;
  }
  
  public static XSDDiagnosticSeverity get(int value)
  {
    switch (value)
    {
    case 0: 
      return FATAL_LITERAL;
    case 1: 
      return ERROR_LITERAL;
    case 2: 
      return WARNING_LITERAL;
    case 3: 
      return INFORMATION_LITERAL;
    }
    return null;
  }
  
  private XSDDiagnosticSeverity(int value, String name, String literal)
  {
    this.value = value;
    this.name = name;
    this.literal = literal;
  }
  
  public int getValue()
  {
    return value;
  }
  
  public String getName()
  {
    return name;
  }
  
  public String getLiteral()
  {
    return literal;
  }
  
  public String toString()
  {
    return literal;
  }
}

/* Location:
 * Qualified Name:     org.eclipse.xsd.XSDDiagnosticSeverity
 * Java Class Version: 5 (49.0)
 * JD-Core Version:    0.7.1
 */
package org.eclipse.xsd;

import java.util.Arrays;
import java.util.Collections;
import java.util.List;
import org.eclipse.emf.common.util.Enumerator;

public enum XSDDisallowedSubstitutions
  implements Enumerator
{
  SUBSTITUTION_LITERAL(
  
    0, "substitution", "substitution"),  EXTENSION_LITERAL(
  
    1, "extension", "extension"),  RESTRICTION_LITERAL(
  
    2, "restriction", "restriction"),  ALL_LITERAL(
  
    3, "all", "all");
  
  public static final int SUBSTITUTION = 0;
  public static final int EXTENSION = 1;
  public static final int RESTRICTION = 2;
  public static final int ALL = 3;
  private static final XSDDisallowedSubstitutions[] VALUES_ARRAY = {
    SUBSTITUTION_LITERAL, 
    EXTENSION_LITERAL, 
    RESTRICTION_LITERAL, 
    ALL_LITERAL };
  public static final List<XSDDisallowedSubstitutions> VALUES = Collections.unmodifiableList(Arrays.asList(VALUES_ARRAY));
  private final int value;
  private final String name;
  private final String literal;
  
  public static XSDDisallowedSubstitutions get(String literal)
  {
    for (int i = 0; i < VALUES_ARRAY.length; i++)
    {
      XSDDisallowedSubstitutions result = VALUES_ARRAY[i];
      if (result.toString().equals(literal)) {
        return result;
      }
    }
    return null;
  }
  
  public static XSDDisallowedSubstitutions getByName(String name)
  {
    for (int i = 0; i < VALUES_ARRAY.length; i++)
    {
      XSDDisallowedSubstitutions result = VALUES_ARRAY[i];
      if (result.getName().equals(name)) {
        return result;
      }
    }
    return null;
  }
  
  public static XSDDisallowedSubstitutions get(int value)
  {
    switch (value)
    {
    case 0: 
      return SUBSTITUTION_LITERAL;
    case 1: 
      return EXTENSION_LITERAL;
    case 2: 
      return RESTRICTION_LITERAL;
    case 3: 
      return ALL_LITERAL;
    }
    return null;
  }
  
  private XSDDisallowedSubstitutions(int value, String name, String literal)
  {
    this.value = value;
    this.name = name;
    this.literal = literal;
  }
  
  public int getValue()
  {
    return value;
  }
  
  public String getName()
  {
    return name;
  }
  
  public String getLiteral()
  {
    return literal;
  }
  
  public String toString()
  {
    return literal;
  }
}

/* Location:
 * Qualified Name:     org.eclipse.xsd.XSDDisallowedSubstitutions
 * Java Class Version: 5 (49.0)
 * JD-Core Version:    0.7.1
 */
package org.eclipse.xsd;

import org.eclipse.emf.common.util.EList;

public abstract interface XSDElementDeclaration
  extends XSDFeature, XSDSchemaContent, XSDTerm
{
  public abstract boolean isNillable();
  
  public abstract void setNillable(boolean paramBoolean);
  
  public abstract void unsetNillable();
  
  public abstract boolean isSetNillable();
  
  public abstract EList<XSDDisallowedSubstitutions> getDisallowedSubstitutions();
  
  public abstract String getStringDisallowedSubstitutions();
  
  public abstract EList<XSDSubstitutionGroupExclusions> getSubstitutionGroupExclusions();
  
  public abstract String getStringSubstitutionGroupExclusions();
  
  public abstract boolean isAbstract();
  
  public abstract void setAbstract(boolean paramBoolean);
  
  public abstract void unsetAbstract();
  
  public abstract boolean isSetAbstract();
  
  public abstract EList<XSDProhibitedSubstitutions> getLexicalFinal();
  
  public abstract void unsetLexicalFinal();
  
  public abstract boolean isSetLexicalFinal();
  
  public abstract String getStringLexicalFinal();
  
  public abstract void setStringLexicalFinal(String paramString);
  
  public abstract EList<XSDDisallowedSubstitutions> getBlock();
  
  public abstract void unsetBlock();
  
  public abstract boolean isSetBlock();
  
  public abstract String getStringBlock();
  
  public abstract void setStringBlock(String paramString);
  
  public abstract boolean isElementDeclarationReference();
  
  public abstract boolean isCircular();
  
  public abstract XSDAnnotation getAnnotation();
  
  public abstract void setAnnotation(XSDAnnotation paramXSDAnnotation);
  
  public abstract XSDTypeDefinition getAnonymousTypeDefinition();
  
  public abstract void setAnonymousTypeDefinition(XSDTypeDefinition paramXSDTypeDefinition);
  
  public abstract XSDTypeDefinition getTypeDefinition();
  
  public abstract void setTypeDefinition(XSDTypeDefinition paramXSDTypeDefinition);
  
  public abstract EList<XSDIdentityConstraintDefinition> getIdentityConstraintDefinitions();
  
  public abstract XSDElementDeclaration getResolvedElementDeclaration();
  
  public abstract void setResolvedElementDeclaration(XSDElementDeclaration paramXSDElementDeclaration);
  
  public abstract XSDElementDeclaration getSubstitutionGroupAffiliation();
  
  public abstract void setSubstitutionGroupAffiliation(XSDElementDeclaration paramXSDElementDeclaration);
  
  public abstract EList<XSDElementDeclaration> getSubstitutionGroup();
}

/* Location:
 * Qualified Name:     org.eclipse.xsd.XSDElementDeclaration
 * Java Class Version: 5 (49.0)
 * JD-Core Version:    0.7.1
 */
package org.eclipse.xsd;

import org.eclipse.emf.common.util.EList;

public abstract interface XSDEnumerationFacet
  extends XSDRepeatableFacet
{
  public abstract EList<Object> getValue();
}

/* Location:
 * Qualified Name:     org.eclipse.xsd.XSDEnumerationFacet
 * Java Class Version: 5 (49.0)
 * JD-Core Version:    0.7.1
 */
package org.eclipse.xsd;

public abstract interface XSDFacet
  extends XSDComponent
{
  public abstract String getLexicalValue();
  
  public abstract void setLexicalValue(String paramString);
  
  public abstract String getFacetName();
  
  public abstract Object getEffectiveValue();
  
  public abstract XSDAnnotation getAnnotation();
  
  public abstract void setAnnotation(XSDAnnotation paramXSDAnnotation);
  
  public abstract XSDSimpleTypeDefinition getSimpleTypeDefinition();
}

/* Location:
 * Qualified Name:     org.eclipse.xsd.XSDFacet
 * Java Class Version: 5 (49.0)
 * JD-Core Version:    0.7.1
 */
package org.eclipse.xsd;

import org.eclipse.emf.ecore.EFactory;
import org.eclipse.xsd.impl.XSDFactoryImpl;

public abstract interface XSDFactory
  extends EFactory
{
  public static final XSDFactory eINSTANCE = ;
  
  public abstract XSDSchema createXSDSchema();
  
  public abstract XSDSimpleTypeDefinition createXSDSimpleTypeDefinition();
  
  public abstract XSDMaxInclusiveFacet createXSDMaxInclusiveFacet();
  
  public abstract XSDMinInclusiveFacet createXSDMinInclusiveFacet();
  
  public abstract XSDMinExclusiveFacet createXSDMinExclusiveFacet();
  
  public abstract XSDMaxExclusiveFacet createXSDMaxExclusiveFacet();
  
  public abstract XSDLengthFacet createXSDLengthFacet();
  
  public abstract XSDWhiteSpaceFacet createXSDWhiteSpaceFacet();
  
  public abstract XSDEnumerationFacet createXSDEnumerationFacet();
  
  public abstract XSDPatternFacet createXSDPatternFacet();
  
  public abstract XSDCardinalityFacet createXSDCardinalityFacet();
  
  public abstract XSDNumericFacet createXSDNumericFacet();
  
  public abstract XSDMaxLengthFacet createXSDMaxLengthFacet();
  
  public abstract XSDMinLengthFacet createXSDMinLengthFacet();
  
  public abstract XSDTotalDigitsFacet createXSDTotalDigitsFacet();
  
  public abstract XSDFractionDigitsFacet createXSDFractionDigitsFacet();
  
  public abstract XSDOrderedFacet createXSDOrderedFacet();
  
  public abstract XSDBoundedFacet createXSDBoundedFacet();
  
  public abstract XSDParticle createXSDParticle();
  
  public abstract XSDElementDeclaration createXSDElementDeclaration();
  
  public abstra
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

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