Represents a program element such as a package, class, or method. Each element represents a static, language-level construct (and not, for example, a runtime construct of the virtual machine).

Elements should be compared using the {@link #equals(Object)}method. There is no guarantee that any particular element will always be represented by the same object.

To implement operations based on the class of an {@code Element} object, either use a {@linkplain ElementVisitor visitor} oruse the result of the {@link #getKind} method. Using {@code instanceof} is not necessarily a reliable idiom fordetermining the effective class of an object in this modeling hierarchy since an implementation may choose to have a single object implement multiple {@code Element} subinterfaces. @author Joseph D. Darcy @author Scott Seligman @author Peter von der Ahé @see Elements @see TypeMirror @since 1.6

Interface to describe a structural piece of a document. It is intended to capture the spirit of an SGML element. @author Timothy Prinzing

Tag node.

Enhanced {@link org.w3c.dom.Element} for web platform.

@version 2013/07/30 19:05:51

@author Mobius @version $Revision: 1.0 $

3.org/TR/2004/REC-DOM-Level-3-Core-20040407'>Document Object Model (DOM) Level 3 Core Specification.

The Element interface represents an element in an XML document. Elements may have attributes associated with them. There are methods on the Element interface to retrieve either an {@linkplain Attribute attribute instance} orattribute value by name.

This interface implements {@link HasText} and returns the text of the firstchild in case the first child itself implements {@link HasText}. In all other cases the {@link HasText#getText()} method returns null . @author $Author$ @version $Date$ $Revision: 78$

3.org/TR/html401/intro/sgmltut.html#h-3.2.1">element in a specific {@linkplain Source source} document, which encompasses a {@linkplain #getStartTag() start tag}, an optional {@linkplain #getEndTag() end tag} and all {@linkplain #getContent() content} in between.

Take the following HTML segment as an example:

<p>This is a sample paragraph.</p>

The whole segment is represented by an Element object. This is comprised of the {@link StartTag} "<p>",the {@link EndTag} "</p>", as well as the text in between.An element may also contain other elements between its start and end tags.

The term normal element refers to an element having a {@linkplain #getStartTag() start tag}with a {@linkplain StartTag#getStartTagType() type} of {@link StartTagType#NORMAL}. This comprises all {@linkplain HTMLElements HTML elements} and non-HTML elements.

Element instances are obtained using one of the following methods:

• {@link StartTag#getElement()}
• {@link EndTag#getElement()}
• {@link Segment#getAllElements()}
• {@link Segment#getAllElements(String name)}
• {@link Segment#getAllElements(StartTagType)}

See also the {@link HTMLElements} class, and the XML 1.0 specification for elements.

Element Structure

The three possible structures of an element are listed below:

Single Tag Element:

Example:
<img src="mypicture.jpg">

The element consists only of a single {@linkplain #getStartTag() start tag} and has no {@linkplain #getContent() element content}(although the start tag itself may have {@linkplain StartTag#getTagContent() tag content}).
{@link #getEndTag()}==null
{@link #isEmpty()}==true
{@link #getEnd() getEnd()}== {@link #getStartTag()}. {@link #getEnd() getEnd()}

This occurs in the following situations:

• An HTML element for which the {@linkplain HTMLElements#getEndTagForbiddenElementNames() end tag is forbidden}.
• An HTML element for which the {@linkplain HTMLElements#getEndTagRequiredElementNames() end tag is required}, but the end tag is not present in the source document.
• An HTML element for which the {@linkplain HTMLElements#getEndTagOptionalElementNames() end tag is optional}, where the implicitly terminating tag is situated immediately after the element's {@linkplain #getStartTag() start tag}.
• An {@linkplain #isEmptyElementTag() empty element tag}
• A non-HTML element that is not an {@linkplain #isEmptyElementTag() empty element tag} but is missing its end tag.
• An element with a start tag of a {@linkplain StartTag#getStartTagType() type} that does not define a{@linkplain StartTagType#getCorrespondingEndTagType() corresponding end tag type}.
• An element with a start tag of a {@linkplain StartTag#getStartTagType() type} that does define a{@linkplain StartTagType#getCorrespondingEndTagType() corresponding end tag type} but is missing its end tag.

Explicitly Terminated Element:

Example:
<p>This is a sample paragraph.</p>

The element consists of a {@linkplain #getStartTag() start tag}, {@linkplain #getContent() content}, and an {@linkplain #getEndTag() end tag}.
{@link #getEndTag()}!=null.
{@link #isEmpty()}==false (provided the end tag doesn't immediately follow the start tag)
{@link #getEnd() getEnd()}== {@link #getEndTag()}. {@link #getEnd() getEnd()}.

This occurs in the following situations, assuming the start tag's matching end tag is present in the source document:

• An HTML element for which the end tag is either {@linkplain HTMLElements#getEndTagRequiredElementNames() required} or {@linkplain HTMLElements#getEndTagOptionalElementNames() optional}.
• A non-HTML element that is not an {@linkplain #isEmptyElementTag() empty element tag}.
• An element with a start tag of a {@linkplain StartTag#getStartTagType() type} that defines a{@linkplain StartTagType#getCorrespondingEndTagType() corresponding end tag type}.

Implicitly Terminated Element:

Example:
<p>This text is included in the paragraph element even though no end tag is present.
<p>This is the next paragraph.

The element consists of a {@linkplain #getStartTag() start tag} and {@linkplain #getContent() content}, but no {@linkplain #getEndTag() end tag}.
{@link #getEndTag()}==null.
{@link #isEmpty()}==false
{@link #getEnd() getEnd()}!= {@link #getStartTag()}. {@link #getEnd() getEnd()}.

This only occurs in an HTML element for which the {@linkplain HTMLElements#getEndTagOptionalElementNames() end tag is optional}.

The element ends at the start of a tag which implies the termination of the element, called the implicitly terminating tag. If the implicitly terminating tag is situated immediately after the element's {@linkplain #getStartTag() start tag}, the element is classed as a single tag element.

See the element parsing rules for HTML elements with optional end tags for details on which tags can implicitly terminate a given element.

See also the documentation of the {@link HTMLElements#getEndTagOptionalElementNames()} method.

Element Parsing Rules

The following rules describe the algorithm used in the {@link StartTag#getElement()} method to construct an element.The detection of the start tag's matching end tag or other terminating tags always takes into account the possible nesting of elements.

• If the start tag has a {@linkplain StartTag#getStartTagType() type} of {@link StartTagType#NORMAL}:
  • If the {@linkplain StartTag#getName() name} of the start tag matches one of therecognised {@linkplain HTMLElementName HTML element names} (indicating an HTML element):
    • If the end tag for an element of this {@linkplain StartTag#getName() name} is{@linkplain HTMLElements#getEndTagForbiddenElementNames() forbidden}, the parser does not conduct any search for an end tag and a single tag element is created.
    • If the end tag for an element of this {@linkplain StartTag#getName() name} is {@linkplain HTMLElements#getEndTagRequiredElementNames() required}, the parser searches for the start tag's matching end tag.
      • If the matching end tag is found, an explicitly terminated element is created.
      • If no matching end tag is found, the source document is not valid HTML and the incident is {@linkplain Source#getLogger() logged} as a missing required end tag.In this situation a single tag element is created.
    • If the end tag for an element of this {@linkplain StartTag#getName() name} is{@linkplain HTMLElements#getEndTagOptionalElementNames() optional}, the parser searches not only for the start tag's matching end tag, but also for any other tag that implicitly terminates the element.
      For each tag (T2) following the start tag (ST1) of this element (E1):
      • If T2 is a start tag:
        • If the {@linkplain StartTag#getName() name} of T2 is in the list of{@linkplain HTMLElements#getNonterminatingElementNames(String) non-terminating element names} for E1,then continue evaluating tags from the {@linkplain Element#getEnd() end} of T2's corresponding{@linkplain StartTag#getElement() element}.
        • If the {@linkplain StartTag#getName() name} of T2 is in the list of{@linkplain HTMLElements#getTerminatingStartTagNames(String) terminating start tag names} for E1,then E1 ends at the {@linkplain StartTag#getBegin() beginning} of T2.If T2 follows immediately after ST1, a single tag element is created, otherwise an implicitly terminated element is created.
      • If T2 is an end tag:
        • If the {@linkplain EndTag#getName() name} of T2 is the same as that of ST1,an explicitly terminated element is created.
        • If the {@linkplain EndTag#getName() name} of T2 is in the list of{@linkplain HTMLElements#getTerminatingEndTagNames(String) terminating end tag names} for E1,then E1 ends at the {@linkplain EndTag#getBegin() beginning} of T2.If T2 follows immediately after ST1, a single tag element is created, otherwise an implicitly terminated element is created.
      • If no more tags are present in the source document, then E1 ends at the end of the file, and an implicitly terminated element is created.
    Note that the syntactical indication of an {@linkplain StartTag#isSyntacticalEmptyElementTag() empty-element tag} in the start tagis ignored when determining the end of HTML elements. See the documentation of the {@link #isEmptyElementTag()} method for more information.
  • If the {@linkplain StartTag#getName() name} of the start tag does not match one of therecognised {@linkplain HTMLElementName HTML element names} (indicating a non-HTML element):
    • If the start tag is {@linkplain StartTag#isSyntacticalEmptyElementTag() syntactically an empty-element tag}, the parser does not conduct any search for an end tag and a single tag element is created.
    • Otherwise, section 3.1 of the XML 1.0 specification states that a matching end tag MUST be present, and the parser searches for the start tag's matching end tag.
      • If the matching end tag is found, an explicitly terminated element is created.
      • If no matching end tag is found, the source document is not valid XML and the incident is {@linkplain Source#getLogger() logged} as a missing required end tag.In this situation a single tag element is created.
• If the start tag has any {@linkplain StartTag#getStartTagType() type} other than {@link StartTagType#NORMAL}:
  • If the start tag's type does not define a {@linkplain StartTagType#getCorrespondingEndTagType() corresponding end tag type}, the parser does not conduct any search for an end tag and a single tag element is created.
  • If the start tag's type does define a {@linkplain StartTagType#getCorrespondingEndTagType() corresponding end tag type}, the parser assumes that a matching end tag is required and searches for it.
    • If the matching end tag is found, an explicitly terminated element is created.
    • If no matching end tag is found, the missing required end tag is {@linkplain Source#getLogger() logged}and a single tag element is created.

@see HTMLElements

@author Nakou

base class for types @author James Watson

A Cache Element, consisting of a key, value and attributes.

From ehcache-1.2, Elements can have keys and values that are Serializable or Objects. To preserve backward compatibility, special accessor methods for Object keys and values are provided: {@link #getObjectKey()} and{@link #getObjectValue()}. If placing Objects in ehcache, developers must use the new getObject... methods to avoid CacheExceptions. The get... methods are reserved for Serializable keys and values. @author Greg Luck @version $Id: Element.java 744 2008-08-16 20:10:49Z gregluck $

@author luc peuvrier

Element of a simple read-only tree intended to be built during a SAX event stream. The tree provides context to a ContentHandler implementation.

Definition of an element.

An element. @version $Id$ @author hsivonen

This class represents an XML element. Each element has the following properties:

• Local name
• Prefix (which may be null or the empty string)
• Namespace URI (which may be null or the empty string)
• A list of attributes
• A list of namespace declarations for this element (not including those inherited from its parent)
• A list of child nodes

@author Elliotte Rusty Harold @version 1.2.7

Represents one XML element. @author Tom Baeyens @author Joram Barrez

Root interface for all elements in the Feed Object Model

@author Saliya Ekanayake (esaliya@gmail.com)

This class represents a TypeEntry that is a type (complexType, simpleType, etc. @author Rich Scheuerle (scheu@us.ibm.com)

Characteristics of the "Element" value. The Element value is ready for marshalling or is the result of unmarshalling. The Element value represents the element rendering. Thus it is either a JAXBElement or has the @XmlRootElement annotation. (i.e. it is never a java.lang.String) The Element value is not a JAX-WS object. (i.e. it is not a holder or exception) Characteristics of the "Type" value It is the type value associated with the element value. (Thus it is either the element value or it is value of the JAXBElement The type value is usually the object needed for the method signature (i.e. String)

Here is an example for illustration: ...

..

..

JAXB will generate the following objects: E1, T2, E3 E1 will have an @XMLRootElement annotation. It is "element" and "type" enabled. e2 does not have a generated object. So it will be represented as a JAXBElement that contains an object T2. The JAXBElement is "element" enabled. T2 represents a complexType. It is only "type" enabled. E3 represents the e3 complexType (it does not represent the e3 element). Thus E3 is "type enabled".

When JAXB unmarshals an object, it will return an "element" enabled object (either a generatated object with @XMLRootElement or a JAXBElement). Conversely, you must always marshal "element" enabled objects. @see PDElement

At the signature level, the values passed as arguments in an SEI operation represent type enabled objects. Each of the object must be converted to an element enabled object to marshal (or conversely converted to a type enabled object when unmarshalling)

Provides a base class for rendering HTML elements, for example JavaScript (<script>) and Cascading Stylesheets (<link> / <style>).

Subclasses should override {@link #getTag()} to return a specific HTML tag.

An element represents an XML Element. It contains a name, a namepace, {@link Attribute} objectsand sub-elements. This class is used to parse iPOJO metadata. @author Felix Project Team

Simplified read-only thread safe DOM. Currently, no support for namespaces, but that may come. @author Howard Lewis Ship

@author Lombart Christophe @version $Id: Exp $

A meta data element.

@author mattmann @version $Revision$

A metadata element.

Abstract base class for elements.

TODO Add style properties.

TODO Add style class property.

Node class representing an XML element.

An element that will render with a begin tag and attributes, a body, and an end tag. Also acts as a factory for enclosed Element, Text and Comment nodes. TODO: Support for CDATA nodes. Do we need Entity nodes?

An element that will render with a begin tag and attributes, a body, and an end tag. Also acts as a factory for enclosed Element, Text and Comment nodes.

TODO: Support for CDATA nodes. Do we need Entity nodes?

@author Cezar Andrei (cezar.andrei at bea.com) Date: Jul 16, 2004

Represents one XML element. @author Tom Baeyens @author Joram Barrez

A representation of an Element XML node. @author Edward Kuns @version $Revision: 0000 $ $Date: 2007-01-11 00:00:00 -0600 (Thu, 11 Jan 2007) $ @since Castor 1.1

An accessor that is marshalled in xml to an xml element. @author Ryan Heaton

@author Jason van Zyl @version $Id: Element.java 2336 2005-07-18 21:05:55Z jvanzyl $

Element interface defines an XML element. An element can have declared namespaces, attributes, child nodes and textual content.

Some of this interface is optional. Some implementations may be read-only and not support being modified. Some implementations may not support the parent relationship and methods such as {@link #getParent}or {@link #getDocument}.

@author James Strachan @version $Revision: 1.47 $

@since 1.0 @author yyang

@author Konstantin Komissarchik @author Shenxue Zhou

The super type of all AST elements used in this package @author Sven Efftinge @noimplement This interface is not intended to be implemented by clients.

@author Adam Retter

@author Dmitriy Shabanov

Instances of this interface are intended to represent XML Schema Elements.

@author dzwiers www.refractions.net @source $URL$

An element is a part of a graph (node, edge, the graph itself).

An interface that defines common method to manipulate identifiers, attributes and indices of the elements (graph, nodes and edges) of a graph.

*

Attributes can be any object and are identified by arbitrary strings. Some attributes are stored as numbers or strings and are in this case named number, label or vector. There are utility methods to handle these attributes ( {@link #getNumber(String)}, {@link #getLabel(String)}) or {@link #getVector(String)}, however they are also accessible through the more general method {@link #getAttribute(String)}.

Important

Implementing classes should indicate the complexity of their implementation for each method.

@since July 12 2007

Abstract base class for all pipeline elements.

Element is the abstract base class needed to construct an element that can be used in a GStreamer pipeline. Please refer to the plugin writers guide for more information on creating Element subclasses.

The name of a Element can be retrieved with {@link #getName} and set with{@link #setName}.

All elements have pads (of the type {@link Pad}). These pads link to pads on other elements. {@link Buffer}s flow between these linked pads. An Element has a list of {@link Pad} structures for all their input (or sink)and output (or source) pads. Core and plug-in writers can add and remove pads with {@link #addPad}and {@link #removePad}.

A pad of an element can be retrieved by name with {@link #getPad}. An list of all pads can be retrieved with {@link #getPads}.

Elements can be linked through their pads. If the link is straightforward, use the {@link #link}convenience function to link two elements, or {@link #linkMany}for more elements in a row.

For finer control, use {@link #linkPads} and {@link #linkPadsFiltered}to specify the pads to link on each element by name.

Each element has a state (see {@link State}). You can get and set the state of an element with {@link #getState} and {@link #setState}.

sgi.org/xmlns/repository/v1.0.0 @author Thomas.Diesler@jboss.com @since 14-May-2012

An XML element. Methods allow the user to get and manipulate its child elements and content, directly access the element's textual content, manipulate its attributes, and manage namespaces. @version $Revision: 1.159 $, $Date: 2007/11/14 05:02:08 $ @author Brett McLaughlin @author Jason Hunter @author Lucas Gonze @author Kevin Regan @author Dan Schaffer @author Yusuf Goolamabbas @author Kent C. Johnson @author Jools Enticknap @author Alex Rosen @author Bradley S. Huffman @author Victor Toni

report.sourceforge.net/namespaces/engine/flow' namespace and in the 'http://jfreereport.sourceforge.net/namespaces/engine/compatibility' namespace are considered internal. You should only touch them, if you really know what you are doing. @author Thomas Morgner

Base class for all elements within a form. All forms, containers and form fields must override this class.

A HTML element consists of a tag name, attributes, and child nodes (including text nodes and other elements). From an Element, you can extract data, traverse the node graph, and manipulate the HTML. @author Jonathan Hedley, jonathan@hedley.net

experimental thread local class for tracing inhabitant initialization and module resolution @author Jerome Dochez

In order to create an element, please use the createElement method instead of invoking the constructor directly. The right place to add user defined initialization code is the init method.

A part of a pattern, represents the 'token' element of the grammar.xml. @author Daniel Naber

An Element object represents an item of the printing framework and has the following characteristics:

• a location
• a size

Each object to be included in a Page must implement this interface. @author Richard Gould @since 0.3 @model

@author Johan Hall

@author Jeff Butler

Interface for UCR elements (containers, variables) @author Andreas @responsible Andreas

ted elsewhere ElementStyleSheet globalStyle = report.getStyleSheetCollection().createStyleSheet ("a name for the global style");

Element element = .. // created elsewhere element.getStyleSheet().addParent(globalStyle); report.getItemBand().addElement (element);

Global stylesheets will always be queried before the parent's stylesheet gets queried. The order of the add-operation does matter, StyleSheets which are added last will be preferred over previously added stylesheets. @author David Gilbert @author Thomas Morgner @noinspection ClassReferencesSubclass

@author Maksim Kaszynski

Hold data for screen captured data for one UI element @author Jian Fang (John.Jian.Fang@gmail.com)Date: Dec 10, 2008

An Element node in a Thymeleaf DOM tree. In XML-based templates, Elements normally correspond to tags.

Elements are nestable nodes, and therefore have children. Besides, they have a sequence of attributes, each of them with a value. Attributes are modeled by means of the {@link Attribute} class.

@author Daniel Fernández @since 2.0.0

@author chamanx

The Element interface represents an element in an HTML or XML document. Elements may have attributes associated with them; since the Element interface inherits from Node , the generic Node interface attribute attributes may be used to retrieve the set of all attributes for an element. There are methods on the Element interface to retrieve either an Attr object by name or an attribute value by name. In XML, where an attribute value may contain entity references, an Attr object should be retrieved to examine the possibly fairly complex sub-tree representing the attribute value. On the other hand, in HTML, where all attributes have simple string values, methods to directly access an attribute value can safely be used as a convenience. In DOM Level 2, the method normalize is inherited from the Node interface where it was moved.

Mimics a DOM Element node.

The iDOM element. @author tomyeh @see Attribute

Abstract base class for elements.

TODO Add style properties.

TODO Add style class property. @author gbrown

Element should be a generic element in the Level. Creating an element you don't care about how JBox2D works. you just set the shape, the position, density, friction, the sprites, ecc. @author Antonio Ragagnin

Elements are the basic objects that can be created and edited in diagram components. Basically, an element is a shape that can be translated, removed and restored. @author zxpletran007

Element is basic building block for constructing data processing pipes. It has one or more contact pads, which can be wired with other elements using links.