Copyright (c) 2000, 2008 IBM Corporation and others.
This program and the accompanying materials
are made available under the terms of the Eclipse Public License 2.0
which accompanies this distribution, and is available at
https://www.eclipse.org/legal/epl-2.0/
SPDX-License-Identifier: EPL-2.0
Contributors:
    IBM Corporation - initial API and implementation
/*******************************************************************************
 * Copyright (c) 2000, 2008 IBM Corporation and others.
 *
 * This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License 2.0
 * which accompanies this distribution, and is available at
 * https://www.eclipse.org/legal/epl-2.0/
 *
 * SPDX-License-Identifier: EPL-2.0
 *
 * Contributors:
 *     IBM Corporation - initial API and implementation
 *******************************************************************************/
package org.eclipse.jdt.core.jdom;

Represents a source type in a compilation unit, either as a top-level type or a member type.
The corresponding syntactic units are ClassDeclaration (JLS2 8.1) and InterfaceDeclaration (JLS2 9.1).
Enumeration types and annotation types, added in J2SE 1.5, are represented as
classes and interfaces, respectively.

Allowable child types for a type are IDOMType, IDOMField,
IDOMMethod, and IDOMInitializer.
Children are listed in the order in which they appear in the source. The parent of a type
is a type (in the case of a member type) or a compilation unit (in the case of a top-level type).

Deprecated:
The JDOM was made obsolete by the addition in 2.0 of the more
powerful, fine-grained DOM/AST API found in the
org.eclipse.jdt.core.dom package.
@noimplement
This interface is not intended to be implemented by clients./**
 * Represents a source type in a compilation unit, either as a top-level type or a member type.
 * The corresponding syntactic units are ClassDeclaration (JLS2 8.1) and InterfaceDeclaration (JLS2 9.1).
 * Enumeration types and annotation types, added in J2SE 1.5, are represented as
 * classes and interfaces, respectively.
 * <p>
 * Allowable child types for a type are <code>IDOMType</code>, <code>IDOMField</code>,
 * <code>IDOMMethod</code>, and <code>IDOMInitializer</code>.
 * Children are listed in the order in which they appear in the source. The parent of a type
 * is a type (in the case of a member type) or a compilation unit (in the case of a top-level type).
 * </p>
 *
 * @deprecated The JDOM was made obsolete by the addition in 2.0 of the more
 * powerful, fine-grained DOM/AST API found in the
 * org.eclipse.jdt.core.dom package.
 * @noimplement This interface is not intended to be implemented by clients.
 */
public interface IDOMType extends IDOMMember {
Adds the given interface name to the names of interfaces that this type implements or extends
(the name will be added after the existing interface names). This is a convenience method.
For classes, this represents the interfaces that this class implements.
For interfaces, this represents the interfaces that this interface extends.
The name may or may not be fully qualified.
Params:
interfaceName – the syntax for an interface name is defined by
 Interfaces in ClassDeclaration (JLS2 8.1). Type names must be specified as they would
 appear in source code. For example: "Cloneable", "java.io.Serializable".
Throws:
IllegalArgumentException – if null is specified/**
 * Adds the given interface name to the names of interfaces that this type implements or extends
 * (the name will be added after the existing interface names). This is a convenience method.
 *
 * For classes, this represents the interfaces that this class implements.
 * For interfaces, this represents the interfaces that this interface extends.
 * The name may or may not be fully qualified.
 *
 * @param interfaceName the syntax for an interface name is defined by
 *  Interfaces in ClassDeclaration (JLS2 8.1). Type names must be specified as they would
 *  appear in source code. For example: "Cloneable", "java.io.Serializable".
 *
 * @exception IllegalArgumentException if <code>null</code> is specified
 */
public void addSuperInterface(String interfaceName) throws IllegalArgumentException;

Returns the formal type parameters for this type.
Returns an empty array if this method has no formal type parameters.
Formal type parameters are as they appear in the source
code; for example:
"X extends List<String> & Serializable".

Returns:
the formal type parameters of this type,
in the order declared in the source, an empty array if none
Since:
3.0/**
 * Returns the formal type parameters for this type.
 * Returns an empty array if this method has no formal type parameters.
 * <p>Formal type parameters are as they appear in the source
 * code; for example:
 * <code>"X extends List&lt;String&gt; & Serializable"</code>.
 * </p>
 *
 * @return the formal type parameters of this type,
 * in the order declared in the source, an empty array if none
 * @since 3.0
 */
String[] getTypeParameters();

The IDOMType refinement of this IDOMNode
method returns the name of this type. The name of a class is defined by
ClassDeclaration (JLS2 8.1); the name of an interface is defined by
InterfaceDeclaration (JLS2 9.1).
Returns:
the name of this type/**
 * The <code>IDOMType</code> refinement of this <code>IDOMNode</code>
 * method returns the name of this type. The name of a class is defined by
 * ClassDeclaration (JLS2 8.1); the name of an interface is defined by
 * InterfaceDeclaration (JLS2 9.1).
 *
 * @return the name of this type
 */
@Override
public String getName();
Returns the name of this type's superclass. The syntax for a superclass name
is specified by Super in ClassDeclaration (JLS2 8.1). Type names must be
specified as they would appear in source code. For example:
"Object", or "java.io.File".
As of J2SE 1.5, the superclass may also include parameterized
types like "ArrayList<String>".
Returns:
the superclass name, or null if this type represents
  an interface or if no superclass has been assigned to this class/**
 * Returns the name of this type's superclass. The syntax for a superclass name
 * is specified by Super in ClassDeclaration (JLS2 8.1). Type names must be
 * specified as they would appear in source code. For example:
 * <code>"Object"</code>, or <code>"java.io.File"</code>.
 * As of J2SE 1.5, the superclass may also include parameterized
 * types like <code>"ArrayList&lt;String&gt;"</code>.
 *
 * @return the superclass name, or <code>null</code> if this type represents
 *   an interface or if no superclass has been assigned to this class
 */
public String getSuperclass();
Returns the names of interfaces that this type implements or extends,
in the order in which they are listed in the source, or an empty array
if no superinterfaces are present. The syntax for interface names is
defined by Interfaces in ClassDeclaration (JLS2 8.1). Type names appear
as they would in source code. For example: "Cloneable",
or "java.io.Serializable".
As of J2SE 1.5, superinterfaces may also include parameterized
types like "List<String>".

For classes, this method returns the interfaces that this class implements.
For interfaces, this method returns the interfaces that this interface extends.

Returns:
the list of interface names/**
 * Returns the names of interfaces that this type implements or extends,
 * in the order in which they are listed in the source, or an empty array
 * if no superinterfaces are present. The syntax for interface names is
 * defined by Interfaces in ClassDeclaration (JLS2 8.1). Type names appear
 * as they would in source code. For example: <code>"Cloneable"</code>,
 * or <code>"java.io.Serializable"</code>.
 * As of J2SE 1.5, superinterfaces may also include parameterized
 * types like <code>"List&lt;String&gt;"</code>.
 * <p>
 * For classes, this method returns the interfaces that this class implements.
 * For interfaces, this method returns the interfaces that this interface extends.
 * </p>
 *
 * @return the list of interface names
 */
public String[] getSuperInterfaces();
Returns whether this type is a class.
Returns:
true for classes, and false for interfaces/**
 * Returns whether this type is a class.
 *
 * @return <code>true</code> for classes, and <code>false</code> for interfaces
 */
public boolean isClass();

Returns whether this type represents an enumeration class ("enum" instead of "class").
Returns:
true if this type represents an enumeration class, false otherwise
Since:
3.0/**
 * Returns whether this type represents an enumeration class ("enum" instead of "class").
 *
 * @return true if this type represents an enumeration class, false otherwise
 * @since 3.0
 */
boolean isEnum();

Returns whether this type represents an annotation type ("@interface" instead of "interface").
Returns:
true if this type represents an annotation type, false otherwise
Since:
3.0/**
 * Returns whether this type represents an annotation type ("@interface" instead of "interface").
 *
 * @return true if this type represents an annotation type, false otherwise
 * @since 3.0
 */
boolean isAnnotation();

Sets whether this type is a class or an interface. If this type is
a class, and is changed to an interface, this type's superclass
becomes null. When a class becomes an interface or an
interface becomes a class, superinterfaces remain (as part of an
implements clause for classes, or an extends
clause for interfaces).
Params:
b – true for classes, and false for interfaces/**
 * Sets whether this type is a class or an interface. If this type is
 * a class, and is changed to an interface, this type's superclass
 * becomes <code>null</code>. When a class becomes an interface or an
 * interface becomes a class, superinterfaces remain (as part of an
 * <code>implements</code> clause for classes, or an <code>extends</code>
 * clause for interfaces).
 *
 * @param b <code>true</code> for classes, and <code>false</code> for interfaces
 */
public void setClass(boolean b);

Sets whether this type represents an enumeration class.
If this type is a class and is changed to an enum,
this type's superclass becomes null.
If this type is an interface (including an annotation type),
and is changed to an enum, this type is also changed to a class.
Params:
b – true for enum classes, and false otherwise
Since:
3.0/**
 * Sets whether this type represents an enumeration class.
 * If this type is a class and is changed to an enum,
 * this type's superclass becomes <code>null</code>.
 * If this type is an interface (including an annotation type),
 * and is changed to an enum, this type is also changed to a class.
 *
 * @param b <code>true</code> for enum classes, and <code>false</code> otherwise
 * @since 3.0
 */
public void setEnum(boolean b);

Sets whether this type represents an annotation type ("@interface" instead of "interface").
If this type is a interface and is changed to an enum,
this type's superclass becomes null and its superinterface list
becomes empty. If this type is an class (including an enum),
and is changed to an annotation type, this type is also changed to an interface.
Params:
b – true for an annotation type, and false otherwise
Since:
3.0/**
 * Sets whether this type represents an annotation type ("@interface" instead of "interface").
 * If this type is a interface and is changed to an enum,
 * this type's superclass becomes <code>null</code> and its superinterface list
 * becomes empty. If this type is an class (including an enum),
 * and is changed to an annotation type, this type is also changed to an interface.
 *
 * @param b <code>true</code> for an annotation type, and <code>false</code> otherwise
 * @since 3.0
 */
public void setAnnotation(boolean b);

Sets the formal type parameters for this type.
Formal type parameters are given as they appear in the source
code; for example:
"X extends List<String> & Serializable".

Params:
typeParameters – the formal type parameters of this type,
in the order to appear in the source, an empty array if none
Since:
3.0/**
 * Sets the formal type parameters for this type.
 * <p>Formal type parameters are given as they appear in the source
 * code; for example:
 * <code>"X extends List&lt;String&gt; & Serializable"</code>.
 * </p>
 *
 * @param typeParameters the formal type parameters of this type,
 * in the order to appear in the source, an empty array if none
 * @since 3.0
 */
void setTypeParameters(String[] typeParameters);

The IDOMType refinement of this IDOMNode
method sets the name of this type. The name of a class is defined by
ClassDeclaration (JLS2 8.1); the name of an interface is defined by
InterfaceDeclaration (JLS2 9.1).
Params:
name – the given name
Throws:
IllegalArgumentException – if null is specified/**
 * The <code>IDOMType</code> refinement of this <code>IDOMNode</code>
 * method sets the name of this type. The name of a class is defined by
 * ClassDeclaration (JLS2 8.1); the name of an interface is defined by
 * InterfaceDeclaration (JLS2 9.1).
 *
 * @param name the given name
 * @exception IllegalArgumentException if <code>null</code> is specified
 */
@Override
public void setName(String name) throws IllegalArgumentException;
Sets the name of this type's superclass. Has no effect if this type
represents an interface. A null name indicates that no
superclass name (extends clause) should appear in the source code.
The syntax for a superclass name is specified by Super in ClassDeclaration
(JLS2 8.1). Type names must be specified as they would appear in source code.
For example: "Object", or "java.io.File".
As of J2SE 1.5, the superclass may also include parameterized
types like "ArrayList<String>".
Params:
superclassName – the superclass name, or null if this type
  should have to no explicitly specified superclass/**
 * Sets the name of this type's superclass. Has no effect if this type
 * represents an interface. A <code>null</code> name indicates that no
 * superclass name (extends clause) should appear in the source code.
 * The syntax for a superclass name is specified by Super in ClassDeclaration
 * (JLS2 8.1). Type names must be specified as they would appear in source code.
 * For example: <code>"Object"</code>, or <code>"java.io.File"</code>.
 * As of J2SE 1.5, the superclass may also include parameterized
 * types like <code>"ArrayList&lt;String&gt;"</code>.
 *
 * @param superclassName the superclass name, or <code>null</code> if this type
 *   should have to no explicitly specified superclass
 */
public void setSuperclass(String superclassName);
Sets the names of interfaces that this type implements or extends,
in the order in which they are to be listed in the source. An empty array
parameter indicates that no superinterfaces are present. The syntax for
interface names is defined by Interfaces in ClassDeclaration (JLS2 8.1).
Type names appear as they would in source code. For example:
"Cloneable", or "java.io.Serializable".
As of J2SE 1.5, superinterfaces may also include parameterized
types like "List<String>".

For classes, this method sets the interfaces that this class implements.
For interfaces, this method sets the interfaces that this interface extends.

Params:
interfaceNames – the list of interface names/**
 * Sets the names of interfaces that this type implements or extends,
 * in the order in which they are to be listed in the source. An empty array
 * parameter indicates that no superinterfaces are present. The syntax for
 * interface names is defined by Interfaces in ClassDeclaration (JLS2 8.1).
 * Type names appear as they would in source code. For example:
 * <code>"Cloneable"</code>, or <code>"java.io.Serializable"</code>.
 * As of J2SE 1.5, superinterfaces may also include parameterized
 * types like <code>"List&lt;String&gt;"</code>.
 * <p>
 * For classes, this method sets the interfaces that this class implements.
 * For interfaces, this method sets the interfaces that this interface extends.
 * </p>
 *
 * @param interfaceNames the list of interface names
 */
public void setSuperInterfaces(String[] interfaceNames);
}