You are viewing a plain text version of this content. The canonical link for it is here.
Posted to general-cvs@xml.apache.org by pb...@apache.org on 2003/03/17 03:19:31 UTC
cvs commit: xml-site/targets/fop/design/alt.design FoXMLEvent.html SyncedFoXmlEventsBuffer.html XMLNamespaces.html
pbwest 2003/03/16 18:19:30
Added: targets/fop/design/alt.design FoXMLEvent.html
SyncedFoXmlEventsBuffer.html XMLNamespaces.html
Log:
codedisplay.js
Revision Changes Path
1.1 xml-site/targets/fop/design/alt.design/FoXMLEvent.html
Index: FoXMLEvent.html
===================================================================
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01//EN">
<!-- Created by htmlize-0.67 in css mode. -->
<html>
<head>
<title>FoXMLEvent.java</title>
<style type="text/css">
<!--
body {
color: #000000;
background-color: #faf0e6;
} /* default */
.comment {
color: #00008b;
background-color: #faf0e6;
} /* font-lock-comment-face */
.jde-java-font-lock-package {
color: #0000cd;
background-color: #faf0e6;
} /* jde-java-font-lock-package-face */
.jde-java-font-lock-constant {
color: #5f9ea0;
background-color: #faf0e6;
} /* jde-java-font-lock-constant-face */
.function-name {
color: #8b2323;
background-color: #faf0e6;
} /* font-lock-function-name-face */
.variable-name {
color: #8b008b;
background-color: #faf0e6;
} /* font-lock-variable-name-face */
.jde-java-font-lock-doc-tag {
color: #008b00;
background-color: #faf0e6;
} /* jde-java-font-lock-doc-tag-face */
.keyword {
color: #8b0000;
background-color: #faf0e6;
} /* font-lock-keyword-face */
.jde-java-font-lock-italic {
background-color: #faf0e6;
font-style: italic;
} /* jde-java-font-lock-italic-face */
.jde-java-font-lock-modifier {
color: #da70d6;
background-color: #faf0e6;
} /* jde-java-font-lock-modifier-face */
.string {
color: #008b00;
background-color: #faf0e6;
} /* font-lock-string-face */
.type {
color: #4682b4;
background-color: #faf0e6;
} /* font-lock-type-face */
a {
color: inherit;
background-color: inherit;
font: inherit;
text-decoration: inherit;
}
a:hover {
text-decoration: underline;
}
-->
</style>
</head>
<body>
<pre>
<span class="keyword">package</span> <span class="jde-java-font-lock-package">org</span>.<span class="jde-java-font-lock-package">apache</span>.<span class="jde-java-font-lock-package">fop</span>.<span class="jde-java-font-lock-package">xml</span>;
<span class="keyword">import</span> <span class="jde-java-font-lock-package">org</span>.<span class="jde-java-font-lock-package">apache</span>.<span class="jde-java-font-lock-package">fop</span>.<span class="jde-java-font-lock-package">apps</span>.<span class="type">FOPException</span>;
<span class="keyword">import</span> <span class="jde-java-font-lock-package">org</span>.<span class="jde-java-font-lock-package">apache</span>.<span class="jde-java-font-lock-package">fop</span>.<span class="jde-java-font-lock-package">fo</span>.<span class="type">FObjectNames</span>;
<span class="keyword">import</span> <span class="jde-java-font-lock-package">org</span>.<span class="jde-java-font-lock-package">xml</span>.<span class="jde-java-font-lock-package">sax</span>.<span class="jde-java-font-lock-package">helpers</span>.<span class="type">AttributesImpl</span>;
<span class="comment">/*
* $Id: FoXMLEvent.html,v 1.1 2003/03/17 02:19:30 pbwest Exp $
* Copyright (C) 2001 The Apache Software Foundation. All rights reserved.
* For details on use and redistribution please refer to the
* LICENSE file included with these sources.
* @author <a href="mailto:pbwest@powerup.com.au">Peter B. West</a>
* @version $Revision: 1.1 $ $Name: $
*/</span>
<span class="comment">/**
* This is a data class to encapsulate the data of an individual XML
* parse event in an XML-FO file. The current version, while defining
* accessor methods, leaves the component data of the event as protected.
* The <tt>XMLSerialHandler</tt> methods set the values directly.
*/</span>
<span class="jde-java-font-lock-modifier">public</span> <span class="keyword">class</span> <span class="function-name" id="FoXMLEventClass">FoXMLEvent</span> <span class="keyword">extends</span> <span class="type">XMLEvent</span> {
<span class="jde-java-font-lock-modifier">private</span> <span class="jde-java-font-lock-modifier">static</span> <span class="jde-java-font-lock-modifier">final</span> <span class="type">String</span> <span class="variable-name" id="tag">tag</span> = "<span class="string">$Name: $</span>";
<span class="jde-java-font-lock-modifier">private</span> <span class="jde-java-font-lock-modifier">static</span> <span class="jde-java-font-lock-modifier">final</span> <span class="type">String</span> <span class="variable-name" id="revision">revision</span> = "<span class="string">$Revision: 1.1 $</span>";
<span class="comment">/** The FO type, as defined in FObjectNames, of fo: XML events. */</span>
<span class="jde-java-font-lock-modifier">protected</span> <span class="type">int</span> <span class="variable-name" id="foType">foType</span> = FObjectNames.<span class="jde-java-font-lock-constant" id="NO_FO">NO_FO</span>;
<span class="comment">/**
* The one-argument constructor uses the default initialization values:
* NOEVENT for the event <i></span><span class="jde-java-font-lock-italic">type</span><span class="comment"></i>, and null references for all others
* except <i></span><span class="jde-java-font-lock-italic">namespaces</span><span class="comment"></i>.
*/</span>
<span class="jde-java-font-lock-modifier">public</span> <span class="function-name" id="FoXMLEvent">FoXMLEvent</span> (<span class="type">XMLNamespaces</span> <span class="variable-name" id="namespaces">namespaces</span>) {
<span class="keyword">super</span>(namespaces);
}
<span class="comment">/**
* The fully defined constructor takes values for each of the data
* elements.
*/</span>
<span class="jde-java-font-lock-modifier">public</span> <span class="function-name">FoXMLEvent</span>(<span class="type">int</span> <span class="variable-name" id="type">type</span>, <span class="type">String</span> <span class="variable-name">chars</span>, <span class="type">int</span> <span class="variable-name">uriIndex</span>,
<span class="type">String</span> <span class="variable-name" id="localName">localName</span>, <span class="type">String</span> <span class="variable-name">qName</span>,
<span class="type">AttributesImpl</span> <span class="variable-name" id="attributes">attributes</span>, <span class="type">XMLNamespaces</span> <span class="variable-name">namespaces</span>,
<span class="type">int</span> <span class="variable-name">foType</span>)
{
<span class="keyword">super</span>
(type, chars, uriIndex, localName, qName, attributes, namespaces);
<span class="keyword">this</span>.foType = foType;
}
<span class="comment">/**
* The cloning constructor takes a reference to an existing
* <tt>FoXMLEvent</tt> object.
*/</span>
<span class="jde-java-font-lock-modifier">public</span> <span class="function-name">FoXMLEvent</span>(<span class="type">FoXMLEvent</span> <span class="variable-name" id="ev">ev</span>) {
<span class="keyword">super</span>(ev);
foType = ev.foType;
}
<span class="jde-java-font-lock-modifier">public</span> <span class="function-name">FoXMLEvent</span>(<span class="type">int</span> <span class="variable-name">type</span>, <span class="type">String</span> <span class="variable-name">chars</span>, <span class="type">XMLNamespaces</span> <span class="variable-name">namespaces</span>) {
<span class="keyword">super</span>(type, chars, namespaces);
}
<span class="jde-java-font-lock-modifier">public</span> <span class="function-name">FoXMLEvent</span>(<span class="type">int</span> <span class="variable-name">type</span>, <span class="type">int</span> <span class="variable-name">uriIndex</span>, <span class="type">AttributesImpl</span> <span class="variable-name">attributes</span>,
<span class="type">XMLNamespaces</span> <span class="variable-name">namespaces</span>, <span class="type">int</span> <span class="variable-name">foType</span>) {
<span class="keyword">super</span>(namespaces);
<span class="keyword">this</span>.type = type;
<span class="keyword">this</span>.uriIndex = uriIndex;
<span class="keyword">this</span>.attributes = attributes;
<span class="keyword">this</span>.foType = foType;
}
<span class="comment">/**
* Clear the fields of this event. Provided for pool operations.
* Neither the <i></span><span class="jde-java-font-lock-italic">namespaces</i> nor the <i>id</span><span class="comment"></i> field is cleared.
* </span><span class="jde-java-font-lock-doc-tag">@return</span><span class="comment"> the cleared <tt>XMLEvent</tt> event.
*/</span>
<span class="jde-java-font-lock-modifier">public</span> <span class="type">XMLEvent</span> <span class="function-name" id="clear">clear</span>() {
foType = FObjectNames.<span class="jde-java-font-lock-constant">NO_FO</span>;
<span class="keyword">return</span> <span class="keyword">super</span>.clear();
}
<span class="comment">/**
* Clear the fields of this event. Provided for pool operations.
* Neither the <i></span><span class="jde-java-font-lock-italic">namespaces</i> nor the <i>id</span><span class="comment"></i> field is cleared.
* </span><span class="jde-java-font-lock-doc-tag">@return</span><span class="comment"> the cleared <tt>XMLEvent</tt> event.
*/</span>
<span class="jde-java-font-lock-modifier">public</span> <span class="type">FoXMLEvent</span> <span class="function-name" id="clearFo">clearFo</span>() {
<span class="keyword">return</span> (<span class="type">FoXMLEvent</span>)clear();
}
<span class="comment">/**
* Copy the fields of the argument event to this event.
* Provided for pool operations.
* Neither the <i></span><span class="jde-java-font-lock-italic">namespaces</i> nor the <i>id</span><span class="comment"></i> field is copied.
* The <i></span><span class="jde-java-font-lock-italic">namespaces</span><span class="comment"></i> field is not cleared.
* </span><span class="jde-java-font-lock-doc-tag">@param</span><span class="comment"> </span><span class="variable-name">ev</span><span class="comment"> the <tt>XMLEvent</tt> to copy.
* </span><span class="jde-java-font-lock-doc-tag">@return</span><span class="comment"> the copied <tt>XMLEvent</tt> event.
*/</span>
<span class="jde-java-font-lock-modifier">public</span> <span class="type">XMLEvent</span> <span class="function-name" id="copyEvent">copyEvent</span>(<span class="type">FoXMLEvent</span> <span class="variable-name">ev</span>) {
foType = ev.foType;
<span class="keyword">return</span> <span class="keyword">super</span>.copyEvent(ev);
}
<span class="comment">/**
* Copy the fields of the argument event to this event.
* Provided for pool operations.
* Neither the <i></span><span class="jde-java-font-lock-italic">namespaces</i> nor the <i>id</span><span class="comment"></i> field is copied.
* The <i></span><span class="jde-java-font-lock-italic">namespaces</span><span class="comment"></i> field is not cleared.
* </span><span class="jde-java-font-lock-doc-tag">@return</span><span class="comment"> the copied <tt>XMLEvent</tt> event.
*/</span>
<span class="jde-java-font-lock-modifier">public</span> <span class="type">FoXMLEvent</span> <span class="function-name" id="copyFoEvent">copyFoEvent</span>(<span class="type">FoXMLEvent</span> <span class="variable-name">ev</span>) {
<span class="keyword">return</span> (<span class="type">FoXMLEvent</span>)copyEvent(ev);
}
<span class="comment">/**
* Get the FO type of this <i></span><span class="jde-java-font-lock-italic">FoXMLEvent</span><span class="comment"></i>.
* </span><span class="jde-java-font-lock-doc-tag">@returns</span><span class="comment"> the FO type.
*/</span>
<span class="jde-java-font-lock-modifier">public</span> <span class="type">int</span> <span class="function-name" id="getFoType">getFoType</span>() { <span class="keyword">return</span> foType; }
<span class="comment">/**
* Set the FO type of this <i></span><span class="jde-java-font-lock-italic">FoXMLEvent</span><span class="comment"></i>.
* </span><span class="jde-java-font-lock-doc-tag">@param</span><span class="comment"> </span><span class="variable-name">foType</span><span class="comment"> -the FO type.
*/</span>
<span class="jde-java-font-lock-modifier">public</span> <span class="type">void</span> <span class="function-name" id="setFoType">setFoType</span>(<span class="type">int</span> <span class="variable-name">foType</span>) { <span class="keyword">this</span>.foType = foType; }
<span class="jde-java-font-lock-modifier">public</span> <span class="type">String</span> <span class="function-name" id="toString">toString</span>() {
<span class="type">String</span> <span class="variable-name" id="tstr">tstr</span>;
<span class="keyword">try</span> {
tstr = "<span class="string">FO type: </span>" + FObjectNames.getFOName(foType) + "<span class="string">\n</span>";
} <span class="keyword">catch</span> (<span class="type">FOPException</span> <span class="variable-name" id="e">e</span>) {
<span class="keyword">throw</span> <span class="keyword">new</span> <span class="type">RuntimeException</span>(e.getMessage());
}
tstr = tstr + <span class="keyword">super</span>.toString();
<span class="keyword">return</span> tstr;
}
}
</pre>
</body>
</html>
1.1 xml-site/targets/fop/design/alt.design/SyncedFoXmlEventsBuffer.html
Index: SyncedFoXmlEventsBuffer.html
===================================================================
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01//EN">
<!-- Created by htmlize-0.67 in css mode. -->
<html>
<head>
<title>SyncedFoXmlEventsBuffer.java</title>
<style type="text/css">
<!--
body {
color: #000000;
background-color: #faf0e6;
} /* default */
.reference {
color: #cd0000;
background-color: #faf0e6;
} /* font-lock-reference-face */
.comment {
color: #00008b;
background-color: #faf0e6;
} /* font-lock-comment-face */
.jde-java-font-lock-package {
color: #0000cd;
background-color: #faf0e6;
} /* jde-java-font-lock-package-face */
.jde-java-font-lock-constant {
color: #5f9ea0;
background-color: #faf0e6;
} /* jde-java-font-lock-constant-face */
.function-name {
color: #8b2323;
background-color: #faf0e6;
} /* font-lock-function-name-face */
.variable-name {
color: #8b008b;
background-color: #faf0e6;
} /* font-lock-variable-name-face */
.jde-java-font-lock-bold {
background-color: #faf0e6;
font-weight: bold;
} /* jde-java-font-lock-bold-face */
.jde-java-font-lock-doc-tag {
color: #008b00;
background-color: #faf0e6;
} /* jde-java-font-lock-doc-tag-face */
.keyword {
color: #8b0000;
background-color: #faf0e6;
} /* font-lock-keyword-face */
.jde-java-font-lock-number {
color: #bc8f8f;
background-color: #faf0e6;
} /* jde-java-font-lock-number-face */
.jde-java-font-lock-code {
background-color: #faf0e6;
} /* jde-java-font-lock-code-face */
.jde-java-font-lock-italic {
background-color: #faf0e6;
font-style: italic;
} /* jde-java-font-lock-italic-face */
.jde-java-font-lock-modifier {
color: #da70d6;
background-color: #faf0e6;
} /* jde-java-font-lock-modifier-face */
.string {
color: #008b00;
background-color: #faf0e6;
} /* font-lock-string-face */
.type {
color: #4682b4;
background-color: #faf0e6;
} /* font-lock-type-face */
a {
color: inherit;
background-color: inherit;
font: inherit;
text-decoration: inherit;
}
a:hover {
text-decoration: underline;
}
-->
</style>
</head>
<body>
<pre>
<span class="keyword">package</span> <span class="jde-java-font-lock-package">org</span>.<span class="jde-java-font-lock-package">apache</span>.<span class="jde-java-font-lock-package">fop</span>.<span class="jde-java-font-lock-package">xml</span>;
<span class="keyword">import</span> <span class="jde-java-font-lock-package">org</span>.<span class="jde-java-font-lock-package">apache</span>.<span class="jde-java-font-lock-package">fop</span>.<span class="jde-java-font-lock-package">datastructs</span>.<span class="type">SyncedCircularBuffer</span>;
<span class="keyword">import</span> <span class="jde-java-font-lock-package">org</span>.<span class="jde-java-font-lock-package">apache</span>.<span class="jde-java-font-lock-package">fop</span>.<span class="jde-java-font-lock-package">apps</span>.<span class="type">FOPException</span>;
<span class="keyword">import</span> <span class="jde-java-font-lock-package">org</span>.<span class="jde-java-font-lock-package">apache</span>.<span class="jde-java-font-lock-package">fop</span>.<span class="jde-java-font-lock-package">fo</span>.<span class="type">FObjectNames</span>;
<span class="keyword">import</span> <span class="jde-java-font-lock-package">org</span>.<span class="jde-java-font-lock-package">apache</span>.<span class="jde-java-font-lock-package">fop</span>.<span class="jde-java-font-lock-package">fo</span>.<span class="type">FObjectSets</span>;
<span class="keyword">import</span> <span class="jde-java-font-lock-package">org</span>.<span class="jde-java-font-lock-package">apache</span>.<span class="jde-java-font-lock-package">fop</span>.<span class="jde-java-font-lock-package">xml</span>.<span class="type">FoXMLEventPool</span>;
<span class="keyword">import</span> <span class="jde-java-font-lock-package">java</span>.<span class="jde-java-font-lock-package">util</span>.<span class="type">NoSuchElementException</span>;
<span class="keyword">import</span> <span class="jde-java-font-lock-package">java</span>.<span class="jde-java-font-lock-package">util</span>.<span class="type">LinkedList</span>;
<span class="keyword">import</span> <span class="jde-java-font-lock-package">java</span>.<span class="jde-java-font-lock-package">util</span>.<span class="type">Iterator</span>;
<span class="keyword">import</span> <span class="jde-java-font-lock-package">java</span>.<span class="jde-java-font-lock-package">util</span>.<span class="type">BitSet</span>;
<span class="comment">/*
* $Id: SyncedFoXmlEventsBuffer.html,v 1.1 2003/03/17 02:19:30 pbwest Exp $
*
* Copyright (C) 2001 The Apache Software Foundation. All rights reserved.
* For details on use and redistribution please refer to the
* LICENSE file included with these sources.
*
* @author <a href="mailto:pbwest@powerup.com.au">Peter B. West</a>
* @version $Revision: 1.1 $ $Name: $
*/</span>
<span class="comment">/**
* A synchronized circular buffer for FoXMLEvents.
* </span><span class="jde-java-font-lock-doc-tag">@see</span><span class="comment"> </span><span class="jde-java-font-lock-code">org.apache.fop.datastructs.SyncedCircularBuffer</span><span class="comment">
*/</span>
<span class="jde-java-font-lock-modifier">public</span> <span class="keyword">class</span> <span class="function-name" id="SyncedFoXmlEventsBufferClass">SyncedFoXmlEventsBuffer</span> <span class="keyword">extends</span> <span class="type">SyncedCircularBuffer</span> {
<span class="comment">/**
* Constant for <i></span><span class="jde-java-font-lock-italic">discardEvent</span><span class="comment"></i> field of
* <i>getEndElement(boolean discardEvent, FoXMLEvent(, boolean)).
*/</span>
<span class="jde-java-font-lock-modifier">public</span> <span class="jde-java-font-lock-modifier">static</span> <span class="jde-java-font-lock-modifier">final</span> <span class="type">boolean</span> <span class="variable-name" id="DISCARD_EV">DISCARD_EV</span> = <span class="jde-java-font-lock-constant" id="true">true</span>,
<span class="jde-java-font-lock-constant" id="RETAIN_EV">RETAIN_EV</span> = <span class="jde-java-font-lock-constant">false</span>;
<span class="comment">/**
* Maintains an index of namespace URIs. These can then be referred to
* by an <tt>int</tt> index.
*/</span>
<span class="jde-java-font-lock-modifier">private</span> <span class="type">XMLNamespaces</span> <span class="variable-name" id="namespaces">namespaces</span>;
<span class="comment">/**
* The FoXMLEventPool for this buffer.
*/</span>
<span class="jde-java-font-lock-modifier">private</span> <span class="type">FoXMLEventPool</span> <span class="variable-name" id="pool">pool</span>;
<span class="comment">/**
* No-argument constructor sets up a buffer with the default number of
* elements.
* The producer and consumer <tt>Thread</tt>s default to the current
* thread at the time of instantiation.
*/</span>
<span class="jde-java-font-lock-modifier">public</span> <span class="function-name" id="SyncedFoXmlEventsBuffer">SyncedFoXmlEventsBuffer</span>()
<span class="keyword">throws</span> <span class="type">IllegalArgumentException</span>
{
<span class="keyword">super</span>();
namespaces = <span class="keyword">new</span> <span class="type">XMLNamespaces</span>();
pool = <span class="keyword">new</span> <span class="type">FoXMLEventPool</span>(namespaces, <span class="jde-java-font-lock-constant" id="DEFAULTBUFSIZE">DEFAULTBUFSIZE</span>);
}
<span class="comment">/**
* Constructor taking one argument; the size of the buffer.
* </span><span class="jde-java-font-lock-doc-tag">@param</span><span class="comment"> </span><span class="variable-name" id="size">size</span><span class="comment"> the size of the buffer. Must be > 1.
*/</span>
<span class="jde-java-font-lock-modifier">public</span> <span class="function-name">SyncedFoXmlEventsBuffer</span>(<span class="type">int</span> <span class="variable-name">size</span>)
<span class="keyword">throws</span> <span class="type">IllegalArgumentException</span>
{
<span class="keyword">super</span>(size);
namespaces = <span class="keyword">new</span> <span class="type">XMLNamespaces</span>();
pool = <span class="keyword">new</span> <span class="type">FoXMLEventPool</span>(namespaces);
}
<span class="comment">/**
* Get the <tt>XMLNamespaces</tt> from this buffer.
* </span><span class="jde-java-font-lock-doc-tag">@return</span><span class="comment"> - the namespaces object.
*/</span>
<span class="jde-java-font-lock-modifier">public</span> <span class="type">XMLNamespaces</span> <span class="function-name" id="getNamespaces">getNamespaces</span>() { <span class="keyword">return</span> namespaces; }
<span class="comment">/**
* Get the <tt>FoXMLEventPool</tt> from this buffer.
* </span><span class="jde-java-font-lock-doc-tag">@return</span><span class="comment"> - the pool object.
*/</span>
<span class="jde-java-font-lock-modifier">public</span> <span class="type">FoXMLEventPool</span> <span class="function-name" id="getPool">getPool</span>() { <span class="keyword">return</span> pool; }
<span class="comment">/**
* </span><span class="jde-java-font-lock-doc-tag">@return</span><span class="comment"> next event from the SyncedCircularBuffer
* </span><span class="jde-java-font-lock-doc-tag">@exception</span><span class="comment"> </span><span class="type">FOPException.</span><span class="comment"> The purpose of this method is to catch
* and transform any InterruptedException exceptions thrown by the
* <tt>SyncedCircularBuffer</tt>.
*/</span>
<span class="jde-java-font-lock-modifier">public</span> <span class="type">FoXMLEvent</span> <span class="function-name" id="getEvent">getEvent</span>() <span class="keyword">throws</span> <span class="type">FOPException</span> {
<span class="type">FoXMLEvent</span> <span class="variable-name" id="ev">ev</span>;
<span class="keyword">try</span> {
ev = (<span class="type">FoXMLEvent</span>)get();
<span class="comment">//System.out.println("getEvent: " + ev);
</span> <span class="keyword">return</span> ev;
} <span class="keyword">catch</span> (<span class="type">InterruptedException</span> <span class="variable-name" id="e">e</span>) {
<span class="keyword">throw</span> <span class="keyword">new</span> <span class="type">FOPException</span>(e);
}
}
<span class="comment">/**
* Get the next event of the given type from the buffer. Discard
* intervening events.
* </span><span class="jde-java-font-lock-doc-tag">@param</span><span class="comment"> </span><span class="variable-name" id="eventType">eventType</span><span class="comment"> - the <tt>int</tt> event type.
* </span><span class="jde-java-font-lock-doc-tag">@return</span><span class="comment"> an event of the given type.
* </span><span class="jde-java-font-lock-doc-tag">@exception</span><span class="comment"> </span><span class="type">FOPException</span><span class="comment"> if buffer errors or interrupts occur.
* </span><span class="jde-java-font-lock-doc-tag">@exception</span><span class="comment"> </span><span class="type">NoSuchElementException</span><span class="comment"> if the event is not found.
*/</span>
<span class="jde-java-font-lock-modifier">public</span> <span class="type">FoXMLEvent</span> <span class="function-name" id="getTypedEvent">getTypedEvent</span>(<span class="type">int</span> <span class="variable-name">eventType</span>) <span class="keyword">throws</span> <span class="type">FOPException</span> {
<span class="type">FoXMLEvent</span> <span class="variable-name">ev</span> = getEvent();
<span class="keyword">while</span> (ev != <span class="jde-java-font-lock-constant" id="null">null</span> && ev.type != eventType) {
ev = getEvent();
}
<span class="keyword">if</span> (ev == <span class="jde-java-font-lock-constant">null</span>) {
<span class="keyword">throw</span> <span class="keyword">new</span> <span class="type">NoSuchElementException</span>
(XMLEvent.eventTypeName(eventType) + "<span class="string"> not found.</span>");
}
<span class="keyword">return</span> ev;
}
<span class="comment">/**
* Get the next event of the given type and with the given <tt>QName</tt>
* from the buffer. Discard intervening events.
* </span><span class="jde-java-font-lock-doc-tag">@param</span><span class="comment"> </span><span class="variable-name">eventType</span><span class="comment"> - the <tt>int</tt> event type.
* </span><span class="jde-java-font-lock-doc-tag">@param</span><span class="comment"> </span><span class="variable-name" id="qName">qName</span><span class="comment"> a <tt>String</tt> with the <tt>QName</tt> of the
* required element.
* </span><span class="jde-java-font-lock-doc-tag">@return</span><span class="comment"> an event of the given type.
* </span><span class="jde-java-font-lock-doc-tag">@exception</span><span class="comment"> </span><span class="type">FOPException</span><span class="comment"> if buffer errors or interrupts occur.
* </span><span class="jde-java-font-lock-doc-tag">@exception</span><span class="comment"> </span><span class="type">NoSuchElementException</span><span class="comment"> if the event is not found.
*/</span>
<span class="jde-java-font-lock-modifier">public</span> <span class="type">FoXMLEvent</span> <span class="function-name">getTypedEvent</span>(<span class="type">int</span> <span class="variable-name">eventType</span>, <span class="type">String</span> <span class="variable-name">qName</span>)
<span class="keyword">throws</span> <span class="type">FOPException</span>
{
<span class="type">FoXMLEvent</span> <span class="variable-name">ev</span> = getEvent();
<span class="keyword">while</span> (ev != <span class="jde-java-font-lock-constant">null</span> &&
! (ev.type == eventType && ev.qName.equals(qName))) {
ev = getEvent();
}
<span class="keyword">if</span> (ev == <span class="jde-java-font-lock-constant">null</span>) {
<span class="keyword">throw</span> <span class="keyword">new</span> <span class="type">NoSuchElementException</span>
(XMLEvent.eventTypeName(eventType) + "<span class="string"> </span>" + qName + "<span class="string"> not found.</span>");
}
<span class="keyword">return</span> ev;
}
<span class="comment">/**
* Get the next event of the given type, and with the given URI index and
* local name, from the buffer. Discard intervening events.
* </span><span class="jde-java-font-lock-doc-tag">@param</span><span class="comment"> </span><span class="variable-name">eventType</span><span class="comment"> - the <tt>int</tt> event type.
* </span><span class="jde-java-font-lock-doc-tag">@param</span><span class="comment"> </span><span class="variable-name" id="uriIndex">uriIndex</span><span class="comment"> - the <tt>int</tt> URI index maintained in the
* <tt>XMLNamespaces</tt> object.
* </span><span class="jde-java-font-lock-doc-tag">@param</span><span class="comment"> </span><span class="variable-name" id="localName">localName</span><span class="comment"> a <tt>String</tt> with the local name of the
* required element.
* </span><span class="jde-java-font-lock-doc-tag">@return</span><span class="comment"> an event of the given type.
* </span><span class="jde-java-font-lock-doc-tag">@exception</span><span class="comment"> </span><span class="type">FOPException</span><span class="comment"> if buffer errors or interrupts occur.
* </span><span class="jde-java-font-lock-doc-tag">@exception</span><span class="comment"> </span><span class="type">NoSuchElementException</span><span class="comment"> if the event is not found.
*/</span>
<span class="jde-java-font-lock-modifier">public</span> <span class="type">FoXMLEvent</span> <span class="variable-name">getTypedEvent</span>
(<span class="type">int</span> <span class="variable-name">eventType</span>, <span class="type">int</span> <span class="variable-name">uriIndex</span>, <span class="type">String</span> <span class="variable-name">localName</span>)
<span class="keyword">throws</span> <span class="type">FOPException</span>
{
<span class="type">FoXMLEvent</span> <span class="variable-name">ev</span> = getEvent();
<span class="keyword">while</span> (ev != <span class="jde-java-font-lock-constant">null</span> &&
! (ev.type == eventType
&& ev.uriIndex == uriIndex
&& ev.localName.equals(localName))) {
pool.surrenderEvent(ev);
ev = getEvent();
}
<span class="keyword">if</span> (ev == <span class="jde-java-font-lock-constant">null</span>)
<span class="keyword">throw</span> <span class="keyword">new</span> <span class="type">NoSuchElementException</span>
(XMLEvent.eventTypeName(eventType)
+ namespaces.getIndexURI(uriIndex)
+ "<span class="string">:</span>" + localName + "<span class="string"> not found.</span>");
<span class="keyword">return</span> ev;
}
<span class="comment">/**
* Get the next event of the given type, from the fo: namespace, with
* the given FO type. Discard intervening events.
* </span><span class="jde-java-font-lock-doc-tag">@param</span><span class="comment"> </span><span class="variable-name">eventType</span><span class="comment"> - the <tt>int</tt> event type.
* </span><span class="jde-java-font-lock-doc-tag">@param</span><span class="comment"> </span><span class="variable-name" id="foType">foType</span><span class="comment"> - the <tt>int</tt> FO type.
* </span><span class="jde-java-font-lock-doc-tag">@return</span><span class="comment"> an event of the given type.
* </span><span class="jde-java-font-lock-doc-tag">@exception</span><span class="comment"> </span><span class="type">FOPException</span><span class="comment"> if buffer errors or interrupts occur.
* </span><span class="jde-java-font-lock-doc-tag">@exception</span><span class="comment"> </span><span class="type">NoSuchElementException</span><span class="comment"> if the event is not found.
*/</span>
<span class="jde-java-font-lock-modifier">public</span> <span class="type">FoXMLEvent</span> <span class="function-name">getTypedEvent</span>(<span class="type">int</span> <span class="variable-name">eventType</span>, <span class="type">int</span> <span class="variable-name">foType</span>)
<span class="keyword">throws</span> <span class="type">FOPException</span>
{
<span class="type">FoXMLEvent</span> <span class="variable-name">ev</span> = getEvent();
<span class="keyword">while</span> (ev != <span class="jde-java-font-lock-constant">null</span> &&
! (ev.type == eventType && ev.foType == foType)) {
pool.surrenderEvent(ev);
ev = getEvent();
}
<span class="keyword">if</span> (ev == <span class="jde-java-font-lock-constant">null</span>)
<span class="keyword">throw</span> <span class="keyword">new</span> <span class="type">NoSuchElementException</span>
(XMLEvent.eventTypeName(eventType)
+ "<span class="string"> FO type </span>" + foType + "<span class="string"> not found.</span>");
<span class="keyword">return</span> ev;
}
<span class="comment">/**
* Return the next element if it is of the required type. If the next
* element is not of the required type, push it back onto the buffer.
* </span><span class="jde-java-font-lock-doc-tag">@param</span><span class="comment"> </span><span class="variable-name">eventType</span><span class="comment"> - the <tt>int</tt> event type.
* </span><span class="jde-java-font-lock-doc-tag">@param</span><span class="comment"> </span><span class="variable-name" id="discardWhiteSpace">discardWhiteSpace</span><span class="comment"> - if true, discard any <tt>characters</tt>
* events which contain only whitespace.
* </span><span class="jde-java-font-lock-doc-tag">@return</span><span class="comment"> an event of the required type. If the next
* event detected is not of the required type, <tt>null</tt> is returned.
* The erroneous event is pushed back.
* </span><span class="jde-java-font-lock-doc-tag">@exception</span><span class="comment"> </span><span class="type">FOPException</span><span class="comment"> if buffer errors or interrupts occur.
* </span><span class="jde-java-font-lock-doc-tag">@exception</span><span class="comment"> </span><span class="type">NoSuchElementException</span><span class="comment"> if the buffer is empty.
*/</span>
<span class="jde-java-font-lock-modifier">public</span> <span class="type">FoXMLEvent</span> <span class="variable-name" id="expectTypedEvent">expectTypedEvent</span>
(<span class="type">int</span> <span class="variable-name">eventType</span>, <span class="type">boolean</span> <span class="variable-name">discardWhiteSpace</span>)
<span class="keyword">throws</span> <span class="type">FOPException</span>
{
<span class="type">FoXMLEvent</span> <span class="variable-name">ev</span> = getEvent();
<span class="keyword">if</span> (discardWhiteSpace) {
<span class="keyword">while</span> (ev != <span class="jde-java-font-lock-constant">null</span> && ev.type == <span class="reference">XMLEvent</span>.<span class="type">CHARACTERS</span>
&& ev.chars.trim().equals("")) {
pool.surrenderEvent(ev);
ev = getEvent();
}
}
<span class="keyword">if</span> (ev != <span class="jde-java-font-lock-constant">null</span> && ev.type == eventType) {
<span class="keyword">return</span> ev;
}
<span class="keyword">if</span> (ev == <span class="jde-java-font-lock-constant">null</span>)
<span class="keyword">throw</span> <span class="keyword">new</span> <span class="type">NoSuchElementException</span>
(XMLEvent.eventTypeName(eventType)
+ "<span class="string"> not found: end of buffer.</span>");
pushBack(ev);
<span class="keyword">return</span> <span class="jde-java-font-lock-constant">null</span>;
}
<span class="comment">/**
* Return the next element if it is of the required type and has the
* required <tt>QName</tt>. If the next
* element is not of the required type, push it back onto the buffer.
* </span><span class="jde-java-font-lock-doc-tag">@param</span><span class="comment"> </span><span class="variable-name">eventType</span><span class="comment"> - the <tt>int</tt> event type.
* </span><span class="jde-java-font-lock-doc-tag">@param</span><span class="comment"> </span><span class="variable-name">qName</span><span class="comment"> a <tt>String</tt> with the <tt>QName</tt> of the
* required element.
* </span><span class="jde-java-font-lock-doc-tag">@param</span><span class="comment"> </span><span class="variable-name">discardWhiteSpace</span><span class="comment"> - if true, discard any <tt>characters</tt>
* events which contain only whitespace.
* </span><span class="jde-java-font-lock-doc-tag">@return</span><span class="comment"> an event of the required type. If the next
* event detected is not of the required type, <tt>null</tt> is returned.
* The erroneous event is pushed back.
* </span><span class="jde-java-font-lock-doc-tag">@exception</span><span class="comment"> </span><span class="type">FOPException</span><span class="comment"> if buffer errors or interrupts occur.
* </span><span class="jde-java-font-lock-doc-tag">@exception</span><span class="comment"> </span><span class="type">NoSuchElementException</span><span class="comment"> if the event is not found.
*/</span>
<span class="jde-java-font-lock-modifier">public</span> <span class="type">FoXMLEvent</span> <span class="variable-name">expectTypedEvent</span>
(<span class="type">int</span> <span class="variable-name">eventType</span>, <span class="type">String</span> <span class="variable-name">qName</span>, <span class="type">boolean</span> <span class="variable-name">discardWhiteSpace</span>)
<span class="keyword">throws</span> <span class="type">FOPException</span>
{
<span class="type">FoXMLEvent</span> <span class="variable-name">ev</span> = getEvent();
<span class="keyword">if</span> (discardWhiteSpace) {
<span class="keyword">while</span> (ev != <span class="jde-java-font-lock-constant">null</span> && ev.type == <span class="reference">XMLEvent</span>.<span class="type">CHARACTERS</span>
&& ev.chars.trim().equals("")) {
pool.surrenderEvent(ev);
ev = getEvent();
}
}
<span class="keyword">if</span> (ev != <span class="jde-java-font-lock-constant">null</span> && ev.type == eventType && ev.qName.equals(qName)) {
<span class="keyword">return</span> ev;
}
<span class="keyword">if</span> (ev == <span class="jde-java-font-lock-constant">null</span>)
<span class="keyword">throw</span> <span class="keyword">new</span> <span class="type">NoSuchElementException</span>
(XMLEvent.eventTypeName(eventType)
+ "<span class="string"> not found: end of buffer.</span>");
pushBack(ev);
<span class="keyword">return</span> <span class="jde-java-font-lock-constant">null</span>;
}
<span class="comment">/**
* Return the next element if it is of the required type and has the
* required URI index and local name. If the next
* element is not of the required type, push it back onto the buffer.
* </span><span class="jde-java-font-lock-doc-tag">@param</span><span class="comment"> </span><span class="variable-name">eventType</span><span class="comment"> - the <tt>int</tt> event type.
* </span><span class="jde-java-font-lock-doc-tag">@param</span><span class="comment"> </span><span class="variable-name">uriIndex</span><span class="comment"> - the <tt>int</tt> URI index.
* </span><span class="jde-java-font-lock-doc-tag">@param</span><span class="comment"> </span><span class="variable-name">localName</span><span class="comment"> a <tt>String</tt> with the local name of the
* required element.
* </span><span class="jde-java-font-lock-doc-tag">@param</span><span class="comment"> </span><span class="variable-name">discardWhiteSpace</span><span class="comment"> - if true, discard any <tt>characters</tt>
* events which contain only whitespace.
* </span><span class="jde-java-font-lock-doc-tag">@return</span><span class="comment"> an event of the required type. If the next
* event detected is not of the required type, <tt>null</tt> is returned.
* The erroneous event is pushed back.
* </span><span class="jde-java-font-lock-doc-tag">@exception</span><span class="comment"> </span><span class="type">FOPException</span><span class="comment"> if buffer errors or interrupts occur.
* </span><span class="jde-java-font-lock-doc-tag">@exception</span><span class="comment"> </span><span class="type">NoSuchElementException</span><span class="comment"> if end of buffer detected.
*/</span>
<span class="jde-java-font-lock-modifier">public</span> <span class="type">FoXMLEvent</span> <span class="variable-name">expectTypedEvent</span>
(<span class="type">int</span> <span class="variable-name">eventType</span>, <span class="type">int</span> <span class="variable-name">uriIndex</span>,
<span class="type">String</span> <span class="variable-name">localName</span>, <span class="type">boolean</span> <span class="variable-name">discardWhiteSpace</span>)
<span class="keyword">throws</span> <span class="type">FOPException</span>
{
<span class="type">FoXMLEvent</span> <span class="variable-name">ev</span> = getEvent();
<span class="keyword">if</span> (discardWhiteSpace) {
<span class="keyword">while</span> (ev != <span class="jde-java-font-lock-constant">null</span> && ev.type == <span class="reference">XMLEvent</span>.<span class="type">CHARACTERS</span>
&& ev.chars.trim().equals("")) {
pool.surrenderEvent(ev);
ev = getEvent();
}
}
<span class="keyword">if</span> (ev != <span class="jde-java-font-lock-constant">null</span>
&& ev.type == eventType
&& ev.uriIndex == uriIndex
&& ev.localName.equals(localName)) {
<span class="keyword">return</span> ev;
}
<span class="keyword">if</span> (ev == <span class="jde-java-font-lock-constant">null</span>)
<span class="keyword">throw</span> <span class="keyword">new</span> <span class="type">NoSuchElementException</span>
(XMLEvent.eventTypeName(eventType)
+ "<span class="string"> not found: end of buffer.</span>");
pushBack(ev);
<span class="keyword">return</span> <span class="jde-java-font-lock-constant">null</span>;
}
<span class="comment">/**
* Return the next element if it is of the required type and has the
* required FO type. If the next
* element is not of the required type, push it back onto the buffer.
* </span><span class="jde-java-font-lock-doc-tag">@param</span><span class="comment"> </span><span class="variable-name">eventType</span><span class="comment"> - the <tt>int</tt> event type.
* </span><span class="jde-java-font-lock-doc-tag">@param</span><span class="comment"> </span><span class="variable-name">foType</span><span class="comment"> - the <tt>int</tt> FO type.
* </span><span class="jde-java-font-lock-doc-tag">@param</span><span class="comment"> </span><span class="variable-name">discardWhiteSpace</span><span class="comment"> - if true, discard any <tt>characters</tt>
* events which contain only whitespace.
* </span><span class="jde-java-font-lock-doc-tag">@return</span><span class="comment"> an event of the required type. If the next
* event detected is not of the required type, <tt>null</tt> is returned.
* The erroneous event is pushed back.
* </span><span class="jde-java-font-lock-doc-tag">@exception</span><span class="comment"> </span><span class="type">FOPException</span><span class="comment"> if buffer errors or interrupts occur.
* </span><span class="jde-java-font-lock-doc-tag">@exception</span><span class="comment"> </span><span class="type">NoSuchElementException</span><span class="comment"> if end of buffer detected.
*/</span>
<span class="jde-java-font-lock-modifier">public</span> <span class="type">FoXMLEvent</span> <span class="variable-name">expectTypedEvent</span>
(<span class="type">int</span> <span class="variable-name">eventType</span>, <span class="type">int</span> <span class="variable-name">foType</span>, <span class="type">boolean</span> <span class="variable-name">discardWhiteSpace</span>)
<span class="keyword">throws</span> <span class="type">FOPException</span>
{
<span class="type">FoXMLEvent</span> <span class="variable-name">ev</span> = getEvent();
<span class="keyword">if</span> (discardWhiteSpace) {
<span class="keyword">while</span> (ev != <span class="jde-java-font-lock-constant">null</span> && ev.type == <span class="reference">XMLEvent</span>.<span class="type">CHARACTERS</span>
&& ev.chars.trim().equals("")) {
pool.surrenderEvent(ev);
ev = getEvent();
}
}
<span class="keyword">if</span> (ev != <span class="jde-java-font-lock-constant">null</span> && ev.type == eventType && ev.foType == foType) {
<span class="keyword">return</span> ev;
}
<span class="keyword">if</span> (ev == <span class="jde-java-font-lock-constant">null</span>)
<span class="keyword">throw</span> <span class="keyword">new</span> <span class="type">NoSuchElementException</span>
(XMLEvent.eventTypeName(eventType)
+ "<span class="string"> not found: end of buffer.</span>");
pushBack(ev);
<span class="keyword">return</span> <span class="jde-java-font-lock-constant">null</span>;
}
<span class="comment">/**
* Get the next ENDDOCUMENT event from the buffer. Discard any other
* events preceding the ENDDOCUMENT event.
* </span><span class="jde-java-font-lock-doc-tag">@return</span><span class="comment"> an ENDDOCUMENT event
* </span><span class="jde-java-font-lock-doc-tag">@exception</span><span class="comment"> </span><span class="type">FOPException</span><span class="comment"> if buffer errors or interrupts occur
* </span><span class="jde-java-font-lock-doc-tag">@exception</span><span class="comment"> </span><span class="type">NoSuchElementException</span><span class="comment"> if the event is not found
*/</span>
<span class="jde-java-font-lock-modifier">public</span> <span class="type">FoXMLEvent</span> <span class="function-name" id="getEndDocument">getEndDocument</span>() <span class="keyword">throws</span> <span class="type">FOPException</span> {
<span class="keyword">return</span> getTypedEvent(XMLEvent.<span class="jde-java-font-lock-constant" id="ENDDOCUMENT">ENDDOCUMENT</span>);
}
<span class="comment">/**
* Return the next element if it is an ENDDOCUMENT. If the next
* element is not of the required type, push it back onto the buffer.
* </span><span class="jde-java-font-lock-doc-tag">@param</span><span class="comment"> </span><span class="variable-name">discardWhiteSpace</span><span class="comment"> - if true, discard any <tt>characters</tt>
* events which contain only whitespace.
* </span><span class="jde-java-font-lock-doc-tag">@return</span><span class="comment"> an ENDDOCUMENT event. If the next
* event detected is not of the required type, <tt>null</tt> is returned.
* The erroneous event is pushed back.
* </span><span class="jde-java-font-lock-doc-tag">@exception</span><span class="comment"> </span><span class="type">FOPException</span><span class="comment"> if buffer errors or interrupts occur
* </span><span class="jde-java-font-lock-doc-tag">@exception</span><span class="comment"> </span><span class="type">NoSuchElementException</span><span class="comment"> if end of buffer detected.
*/</span>
<span class="jde-java-font-lock-modifier">public</span> <span class="type">FoXMLEvent</span> <span class="function-name" id="expectEndDocument">expectEndDocument</span>(<span class="type">boolean</span> <span class="variable-name">discardWhiteSpace</span>)
<span class="keyword">throws</span> <span class="type">FOPException</span>
{
<span class="keyword">return</span> expectTypedEvent(XMLEvent.<span class="jde-java-font-lock-constant">ENDDOCUMENT</span>, discardWhiteSpace);
}
<span class="comment">/**
* Get the next STARTELEMENT event from the buffer. Discard any other
* events preceding the STARTELEMENT event.
* </span><span class="jde-java-font-lock-doc-tag">@return</span><span class="comment"> a STARTELEMENT event
* </span><span class="jde-java-font-lock-doc-tag">@exception</span><span class="comment"> </span><span class="type">FOPException</span><span class="comment"> if buffer errors or interrupts occur
* </span><span class="jde-java-font-lock-doc-tag">@exception</span><span class="comment"> </span><span class="type">NoSuchElementException</span><span class="comment"> if the event is not found
*/</span>
<span class="jde-java-font-lock-modifier">public</span> <span class="type">FoXMLEvent</span> <span class="function-name" id="getStartElement">getStartElement</span>() <span class="keyword">throws</span> <span class="type">FOPException</span> {
<span class="keyword">return</span> getTypedEvent(XMLEvent.<span class="jde-java-font-lock-constant" id="STARTELEMENT">STARTELEMENT</span>);
}
<span class="comment">/**
* Return the next element if it is a STARTELEMENT. If the next
* element is not of the required type, push it back onto the buffer.
* </span><span class="jde-java-font-lock-doc-tag">@param</span><span class="comment"> </span><span class="variable-name">discardWhiteSpace</span><span class="comment"> - if true, discard any <tt>characters</tt>
* events which contain only whitespace.
* </span><span class="jde-java-font-lock-doc-tag">@return</span><span class="comment"> a STARTELEMENT event. If the next
* event detected is not of the required type, <tt>null</tt> is returned.
* The erroneous event is pushed back.
* </span><span class="jde-java-font-lock-doc-tag">@exception</span><span class="comment"> </span><span class="type">FOPException</span><span class="comment"> if buffer errors or interrupts occur
* </span><span class="jde-java-font-lock-doc-tag">@exception</span><span class="comment"> </span><span class="type">NoSuchElementException</span><span class="comment"> if end of buffer detected.
*/</span>
<span class="jde-java-font-lock-modifier">public</span> <span class="type">FoXMLEvent</span> <span class="function-name" id="expectStartElement">expectStartElement</span>(<span class="type">boolean</span> <span class="variable-name">discardWhiteSpace</span>)
<span class="keyword">throws</span> <span class="type">FOPException</span>
{
<span class="keyword">return</span> expectTypedEvent(XMLEvent.<span class="jde-java-font-lock-constant">STARTELEMENT</span>, discardWhiteSpace);
}
<span class="comment">/**
* Get the next STARTELEMENT event with the given <tt>QName</tt>
* from the buffer. Discard any other events preceding the
* STARTELEMENT event.
* </span><span class="jde-java-font-lock-doc-tag">@param</span><span class="comment"> </span><span class="variable-name">qName</span><span class="comment"> a <tt>String</tt> with the <tt>QName</tt> of the
* required STARTELEMENT
* </span><span class="jde-java-font-lock-doc-tag">@return</span><span class="comment"> a STARTELEMENT event
* </span><span class="jde-java-font-lock-doc-tag">@exception</span><span class="comment"> </span><span class="type">FOPException</span><span class="comment"> if buffer errors or interrupts occur
* </span><span class="jde-java-font-lock-doc-tag">@exception</span><span class="comment"> </span><span class="type">NoSuchElementException</span><span class="comment"> if the event is not found
*/</span>
<span class="jde-java-font-lock-modifier">public</span> <span class="type">FoXMLEvent</span> <span class="function-name">getStartElement</span>(<span class="type">String</span> <span class="variable-name">qName</span>) <span class="keyword">throws</span> <span class="type">FOPException</span>
{
<span class="keyword">return</span> getTypedEvent(XMLEvent.<span class="jde-java-font-lock-constant">STARTELEMENT</span>, qName);
}
<span class="comment">/**
* Return the next element if it is a STARTELEMENT with the given
* <tt>QName</tt>. If the next
* element is not of the required type, push it back onto the buffer.
* </span><span class="jde-java-font-lock-doc-tag">@param</span><span class="comment"> </span><span class="variable-name">qName</span><span class="comment"> a <tt>String</tt> with the <tt>QName</tt> of the
* required STARTELEMENT
* </span><span class="jde-java-font-lock-doc-tag">@param</span><span class="comment"> </span><span class="variable-name">discardWhiteSpace</span><span class="comment"> - if true, discard any <tt>characters</tt>
* events which contain only whitespace.
* </span><span class="jde-java-font-lock-doc-tag">@return</span><span class="comment"> a STARTELEMENT event. If the next
* event detected is not of the required type, <tt>null</tt> is returned.
* The erroneous event is pushed back.
* </span><span class="jde-java-font-lock-doc-tag">@exception</span><span class="comment"> </span><span class="type">FOPException</span><span class="comment"> if buffer errors or interrupts occur
* </span><span class="jde-java-font-lock-doc-tag">@exception</span><span class="comment"> </span><span class="type">NoSuchElementException</span><span class="comment"> if end of buffer detected.
*/</span>
<span class="jde-java-font-lock-modifier">public</span> <span class="type">FoXMLEvent</span> <span class="variable-name">expectStartElement</span>
(<span class="type">String</span> <span class="variable-name">qName</span>, <span class="type">boolean</span> <span class="variable-name">discardWhiteSpace</span>)
<span class="keyword">throws</span> <span class="type">FOPException</span>
{
<span class="keyword">return</span> expectTypedEvent
(XMLEvent.<span class="jde-java-font-lock-constant">STARTELEMENT</span>, qName, discardWhiteSpace);
}
<span class="comment">/**
* Get the next STARTELEMENT event with the given URI index and local name
* from the buffer. Discard any other events preceding the
* STARTELEMENT event.
* </span><span class="jde-java-font-lock-doc-tag">@param</span><span class="comment"> </span><span class="variable-name">uriIndex</span><span class="comment"> an <tt>int</tt> with the index of the URI of the
* required URI
* </span><span class="jde-java-font-lock-doc-tag">@param</span><span class="comment"> </span><span class="variable-name">localName</span><span class="comment"> a <tt>String</tt> with the local name of the
* required STARTELEMENT
* </span><span class="jde-java-font-lock-doc-tag">@return</span><span class="comment"> a STARTELEMENT event
* </span><span class="jde-java-font-lock-doc-tag">@exception</span><span class="comment"> </span><span class="type">FOPException</span><span class="comment"> if buffer errors or interrupts occur
* </span><span class="jde-java-font-lock-doc-tag">@exception</span><span class="comment"> </span><span class="type">NoSuchElementException</span><span class="comment"> if the event is not found
*/</span>
<span class="jde-java-font-lock-modifier">public</span> <span class="type">FoXMLEvent</span> <span class="function-name">getStartElement</span>(<span class="type">int</span> <span class="variable-name">uriIndex</span>, <span class="type">String</span> <span class="variable-name">localName</span>)
<span class="keyword">throws</span> <span class="type">FOPException</span>
{
<span class="keyword">return</span> getTypedEvent(XMLEvent.<span class="jde-java-font-lock-constant">STARTELEMENT</span>, uriIndex, localName);
}
<span class="comment">/**
* Return the next element if it is a STARTELEMENT with the given
* URI index and local name. If the next
* element is not of the required type, push it back onto the buffer.
* </span><span class="jde-java-font-lock-doc-tag">@param</span><span class="comment"> </span><span class="variable-name">uriIndex</span><span class="comment"> an <tt>int</tt> URI index.
* </span><span class="jde-java-font-lock-doc-tag">@param</span><span class="comment"> </span><span class="variable-name">localName</span><span class="comment"> a <tt>String</tt> with the local name of the
* required STARTELEMENT
* </span><span class="jde-java-font-lock-doc-tag">@param</span><span class="comment"> </span><span class="variable-name">discardWhiteSpace</span><span class="comment"> - if true, discard any <tt>characters</tt>
* events which contain only whitespace.
* </span><span class="jde-java-font-lock-doc-tag">@return</span><span class="comment"> a STARTELEMENT event. If the next
* event detected is not of the required type, <tt>null</tt> is returned.
* The erroneous event is pushed back.
* </span><span class="jde-java-font-lock-doc-tag">@exception</span><span class="comment"> </span><span class="type">FOPException</span><span class="comment"> if buffer errors or interrupts occur
* </span><span class="jde-java-font-lock-doc-tag">@exception</span><span class="comment"> </span><span class="type">NoSuchElementException</span><span class="comment"> if end of buffer detected.
*/</span>
<span class="jde-java-font-lock-modifier">public</span> <span class="type">FoXMLEvent</span> <span class="variable-name">expectStartElement</span>
(<span class="type">int</span> <span class="variable-name">uriIndex</span>, <span class="type">String</span> <span class="variable-name">localName</span>, <span class="type">boolean</span> <span class="variable-name">discardWhiteSpace</span>)
<span class="keyword">throws</span> <span class="type">FOPException</span>
{
<span class="keyword">return</span> expectTypedEvent
(XMLEvent.<span class="jde-java-font-lock-constant">STARTELEMENT</span>, uriIndex, localName, discardWhiteSpace);
}
<span class="comment">/**
* From the buffer get the next STARTELEMENT event from the fo: namespace
* with the given FO object type.
* Discard any other events preceding the
* STARTELEMENT event.
* </span><span class="jde-java-font-lock-doc-tag">@param</span><span class="comment"> </span><span class="variable-name">foType</span><span class="comment"> - the <tt>int</tt> FO object type, as defined in
* <tt>FObjectNames</tt>.
* </span><span class="jde-java-font-lock-doc-tag">@return</span><span class="comment"> a matching STARTELEMENT event.
* </span><span class="jde-java-font-lock-doc-tag">@exception</span><span class="comment"> </span><span class="type">FOPException</span><span class="comment"> if buffer errors or interrupts occur
* </span><span class="jde-java-font-lock-doc-tag">@exception</span><span class="comment"> </span><span class="type">NoSuchElementException</span><span class="comment"> if the event is not found
*/</span>
<span class="jde-java-font-lock-modifier">public</span> <span class="type">FoXMLEvent</span> <span class="function-name">getStartElement</span>(<span class="type">int</span> <span class="variable-name">foType</span>)
<span class="keyword">throws</span> <span class="type">FOPException</span>
{
<span class="keyword">return</span> getTypedEvent(XMLEvent.<span class="jde-java-font-lock-constant">STARTELEMENT</span>, foType);
}
<span class="comment">/**
* From the buffer return the next STARTELEMENT event from the fo:
* namespace with the given FO object type. If the next
* element is not of the required type, push it back onto the buffer.
* </span><span class="jde-java-font-lock-doc-tag">@param</span><span class="comment"> </span><span class="variable-name">foType</span><span class="comment"> - the <tt>int</tt> FO object type, as defined in
* <tt>FObjectNames</tt>.
* </span><span class="jde-java-font-lock-doc-tag">@param</span><span class="comment"> </span><span class="variable-name">discardWhiteSpace</span><span class="comment"> - if true, discard any <tt>characters</tt>
* events which contain only whitespace.
* </span><span class="jde-java-font-lock-doc-tag">@return</span><span class="comment"> a matching STARTELEMENT event. If the next
* event detected is not of the required type, <tt>null</tt> is returned.
* The erroneous event is pushed back.
* </span><span class="jde-java-font-lock-doc-tag">@exception</span><span class="comment"> </span><span class="type">FOPException</span><span class="comment"> if buffer errors or interrupts occur
* </span><span class="jde-java-font-lock-doc-tag">@exception</span><span class="comment"> </span><span class="type">NoSuchElementException</span><span class="comment"> if end of buffer detected.
*/</span>
<span class="jde-java-font-lock-modifier">public</span> <span class="type">FoXMLEvent</span> <span class="variable-name">expectStartElement</span>
(<span class="type">int</span> <span class="variable-name">foType</span>, <span class="type">boolean</span> <span class="variable-name">discardWhiteSpace</span>)
<span class="keyword">throws</span> <span class="type">FOPException</span>
{
<span class="keyword">return</span> expectTypedEvent
(XMLEvent.<span class="jde-java-font-lock-constant">STARTELEMENT</span>, foType, discardWhiteSpace);
}
<span class="comment">/**
* Get one of a list of possible STARTELEMENT events.
* </span><span class="jde-java-font-lock-doc-tag">@param</span><span class="comment"> </span><span class="variable-name" id="list">list</span><span class="comment"> a <tt>LinkedList</tt> containing either <tt>String</tt>s
* with the <tt>QName</tt>, or <tt>UriLocalName</tt>
* objects with the URI index and local name of one of the required
* STARTELEMENT events.
* </span><span class="jde-java-font-lock-doc-tag">@param</span><span class="comment"> </span><span class="variable-name">discardWhiteSpace</span><span class="comment"> - if true, discard any <tt>characters</tt>
* events which contain only whitespace.
* </span><span class="jde-java-font-lock-doc-tag">@return</span><span class="comment"> a STARTELEMENT event
* </span><span class="jde-java-font-lock-doc-tag">@exception</span><span class="comment"> </span><span class="type">FOPException</span><span class="comment"> if buffer errors or interrupts occur
* </span><span class="jde-java-font-lock-doc-tag">@exception</span><span class="comment"> </span><span class="type">NoSuchElementException</span><span class="comment"> if the event is not found
*/</span>
<span class="jde-java-font-lock-modifier">public</span> <span class="type">FoXMLEvent</span> <span class="variable-name">getStartElement</span>
(<span class="type">LinkedList</span> <span class="variable-name">list</span>, <span class="type">boolean</span> <span class="variable-name">discardWhiteSpace</span>)
<span class="keyword">throws</span> <span class="type">FOPException</span>
{
<span class="type">FoXMLEvent</span> <span class="variable-name">ev</span>;
<span class="keyword">do</span> {
ev = expectStartElement(list, discardWhiteSpace);
<span class="keyword">if</span> (ev != <span class="jde-java-font-lock-constant">null</span>) <span class="keyword">return</span> ev;
<span class="comment">// The non-matching event has been pushed back.
</span> <span class="comment">// Get it and discard. Note that if the first attempt to
</span> <span class="comment">// getEvent() returns null, the expectStartElement() calls
</span> <span class="comment">// return null.
</span> ev = getEvent();
pool.surrenderEvent(ev);
} <span class="keyword">while</span> (ev != <span class="jde-java-font-lock-constant">null</span>);
<span class="comment">// Exit from this while loop is only by discovery of null event
</span> <span class="keyword">throw</span> <span class="keyword">new</span> <span class="type">NoSuchElementException</span>
("<span class="string">StartElement from list not found.</span>");
}
<span class="comment">/**
* Get one of a list of possible STARTELEMENT events.
* </span><span class="jde-java-font-lock-doc-tag">@param</span><span class="comment"> </span><span class="variable-name">list</span><span class="comment"> a <tt>LinkedList</tt> containing either <tt>String</tt>s
* with the <tt>QName</tt>, or <tt>UriLocalName</tt>
* objects with the URI index and local name of one of the required
* STARTELEMENT events.
* </span><span class="jde-java-font-lock-doc-tag">@param</span><span class="comment"> </span><span class="variable-name">discardWhiteSpace</span><span class="comment"> - if true, discard any <tt>characters</tt>
* events which contain only whitespace.
* </span><span class="jde-java-font-lock-doc-tag">@return</span><span class="comment"> a STARTELEMENT event. If the next
* event detected is not of the required type, <tt>null</tt> is returned.
* The erroneous event is pushed back.
* </span><span class="jde-java-font-lock-doc-tag">@exception</span><span class="comment"> </span><span class="type">FOPException</span><span class="comment"> if buffer errors or interrupts occur
* </span><span class="jde-java-font-lock-doc-tag">@exception</span><span class="comment"> </span><span class="type">NoSuchElementException</span><span class="comment"> if end of buffer detected.
*/</span>
<span class="jde-java-font-lock-modifier">public</span> <span class="type">FoXMLEvent</span> <span class="variable-name">expectStartElement</span>
(<span class="type">LinkedList</span> <span class="variable-name">list</span>, <span class="type">boolean</span> <span class="variable-name">discardWhiteSpace</span>)
<span class="keyword">throws</span> <span class="type">FOPException</span>
{
<span class="type">FoXMLEvent</span> <span class="variable-name">ev</span>;
<span class="type">Iterator</span> <span class="variable-name" id="elements">elements</span> = list.iterator();
<span class="keyword">while</span> (elements.hasNext()) {
<span class="type">Object</span> <span class="variable-name" id="o">o</span> = elements.next();
<span class="keyword">if</span> (o <span class="keyword">instanceof</span> <span class="type">String</span>) {
ev = expectStartElement((<span class="type">String</span>) o, discardWhiteSpace);
<span class="comment">// Found it!
</span> <span class="keyword">if</span> (ev != <span class="jde-java-font-lock-constant">null</span>) <span class="keyword">return</span> ev;
} <span class="keyword">else</span> <span class="keyword">if</span> (o <span class="keyword">instanceof</span> <span class="type">UriLocalName</span>) {
ev = expectStartElement
(((<span class="type">UriLocalName</span>) o).uriIndex,
((<span class="type">UriLocalName</span>) o).localName,
discardWhiteSpace);
<span class="comment">// Found it!
</span> <span class="keyword">if</span> (ev != <span class="jde-java-font-lock-constant">null</span>) <span class="keyword">return</span> ev;
} <span class="keyword">else</span> <span class="keyword">if</span> (o <span class="keyword">instanceof</span> <span class="type">Integer</span>) {
ev = expectStartElement(((<span class="type">Integer</span>)o).intValue(),
discardWhiteSpace);
<span class="keyword">if</span> (ev != <span class="jde-java-font-lock-constant">null</span>) <span class="keyword">return</span> ev;
} <span class="keyword">else</span>
<span class="keyword">throw</span> <span class="keyword">new</span> <span class="type">FOPException</span>
("<span class="string">Invalid list elements for getStartElement</span>");
}
<span class="keyword">return</span> <span class="jde-java-font-lock-constant">null</span>;
}
<span class="comment">/**
* Get one of a array of possible STARTELEMENT events. Scan and discard
* events until a STARTELEMENT event is found whose URI index and
* local name matches one of those in the argument
* <tt>UriLocalName[]</tt> array.
* </span><span class="jde-java-font-lock-doc-tag">@param</span><span class="comment"> </span><span class="variable-name">list</span><span class="comment"> an array containing <tt>UriLocalName</tt>
* objects with the URI index and local name of
* </span><span class="jde-java-font-lock-doc-tag">@param</span><span class="comment"> </span><span class="variable-name">discardWhiteSpace</span><span class="comment"> - if true, discard any <tt>characters</tt>
* events which contain only whitespace.
* STARTELEMENT events, one of which is required.
* </span><span class="jde-java-font-lock-doc-tag">@return</span><span class="comment"> the next matching STARTELEMENT event from the buffer.
* </span><span class="jde-java-font-lock-doc-tag">@exception</span><span class="comment"> </span><span class="type">FOPException</span><span class="comment"> if buffer errors or interrupts occur
* </span><span class="jde-java-font-lock-doc-tag">@exception</span><span class="comment"> </span><span class="type">NoSuchElementException</span><span class="comment"> if the event is not found
*/</span>
<span class="jde-java-font-lock-modifier">public</span> <span class="type">FoXMLEvent</span> <span class="variable-name">getStartElement</span>
(<span class="type">UriLocalName</span>[] <span class="variable-name">list</span>, <span class="type">boolean</span> <span class="variable-name">discardWhiteSpace</span>)
<span class="keyword">throws</span> <span class="type">FOPException</span>
{
<span class="type">FoXMLEvent</span> <span class="variable-name">ev</span>;
<span class="keyword">do</span> {
ev = expectStartElement(list, discardWhiteSpace);
<span class="keyword">if</span> (ev != <span class="jde-java-font-lock-constant">null</span>) <span class="keyword">return</span> ev;
<span class="comment">// The non-matching event has been pushed back.
</span> <span class="comment">// Get it and discard. Note that if the first attempt to
</span> <span class="comment">// getEvent() returns null, the expectStartElement() calls
</span> <span class="comment">// will throw a NoSuchElementException
</span> ev = getEvent();
pool.surrenderEvent(ev);
} <span class="keyword">while</span> (ev != <span class="jde-java-font-lock-constant">null</span>);
<span class="comment">// Exit from this while loop is only by discovery of null event
</span> <span class="keyword">throw</span> <span class="keyword">new</span> <span class="type">NoSuchElementException</span>
("<span class="string">StartElement from list not found.</span>");
}
<span class="comment">/**
* Expect one of an array of possible STARTELEMENT events. The next
* STARTELEMENT must have a URI index and local name which match
* an element of the argument <tt>UriLocalName[]</tt> list.
* </span><span class="jde-java-font-lock-doc-tag">@param</span><span class="comment"> </span><span class="variable-name">list</span><span class="comment"> an <tt>UriLocalName[]</tt> array containing the
* namespace Uri index and LocalName
* of possible events, one of which must be the next returned.
* </span><span class="jde-java-font-lock-doc-tag">@param</span><span class="comment"> </span><span class="variable-name">discardWhiteSpace</span><span class="comment"> - if true, discard any <tt>characters</tt>
* events which contain only whitespace.
* </span><span class="jde-java-font-lock-doc-tag">@return</span><span class="comment"> the matching STARTELEMENT event. If the next
* event detected is not of the required type, <tt>null</tt> is returned.
* The erroneous event is pushed back.
* </span><span class="jde-java-font-lock-doc-tag">@exception</span><span class="comment"> </span><span class="type">FOPException</span><span class="comment"> if buffer errors or interrupts occur
* </span><span class="jde-java-font-lock-doc-tag">@exception</span><span class="comment"> </span><span class="type">NoSuchElementException</span><span class="comment"> if end of buffer detected.
*/</span>
<span class="jde-java-font-lock-modifier">public</span> <span class="type">FoXMLEvent</span> <span class="variable-name">expectStartElement</span>
(<span class="type">UriLocalName</span>[] <span class="variable-name">list</span>, <span class="type">boolean</span> <span class="variable-name">discardWhiteSpace</span>)
<span class="keyword">throws</span> <span class="type">FOPException</span>
{
<span class="type">FoXMLEvent</span> <span class="variable-name">ev</span>;
<span class="keyword">for</span> (<span class="type">int</span> <span class="variable-name" id="i">i</span> = <span class="jde-java-font-lock-number">0</span>; i < list.length; i++) {
ev = expectStartElement(list[i].uriIndex,
list[i].localName,
discardWhiteSpace);
<span class="comment">// Found it!
</span> <span class="keyword">if</span> (ev != <span class="jde-java-font-lock-constant">null</span>) <span class="keyword">return</span> ev;
}
<span class="keyword">return</span> <span class="jde-java-font-lock-constant">null</span>;
}
<span class="comment">/**
* Get one of a array of possible STARTELEMENT events. Scan and discard
* events until a STARTELEMENT event is found whose <tt>QName</tt>
* matches one of those in the argument <tt>String[]</tt> array.
* </span><span class="jde-java-font-lock-doc-tag">@param</span><span class="comment"> </span><span class="variable-name">list</span><span class="comment"> a <tt>String[]</tt> array containing <tt>QName</tt>s,
* one of which is required.
* </span><span class="jde-java-font-lock-doc-tag">@param</span><span class="comment"> </span><span class="variable-name">discardWhiteSpace</span><span class="comment"> - if true, discard any <tt>characters</tt>
* events which contain only whitespace.
* </span><span class="jde-java-font-lock-doc-tag">@return</span><span class="comment"> the next matching STARTELEMENT event from the buffer.
* </span><span class="jde-java-font-lock-doc-tag">@exception</span><span class="comment"> </span><span class="type">FOPException</span><span class="comment"> if buffer errors or interrupts occur
* </span><span class="jde-java-font-lock-doc-tag">@exception</span><span class="comment"> </span><span class="type">NoSuchElementException</span><span class="comment"> if the event is not found
*/</span>
<span class="jde-java-font-lock-modifier">public</span> <span class="type">FoXMLEvent</span> <span class="function-name">getStartElement</span>(<span class="type">String</span>[] <span class="variable-name">list</span>, <span class="type">boolean</span> <span class="variable-name">discardWhiteSpace</span>)
<span class="keyword">throws</span> <span class="type">FOPException</span>
{
<span class="type">FoXMLEvent</span> <span class="variable-name">ev</span>;
<span class="keyword">do</span> {
ev = expectStartElement(list, discardWhiteSpace);
<span class="keyword">if</span> (ev != <span class="jde-java-font-lock-constant">null</span>) <span class="keyword">return</span> ev;
<span class="comment">// The non-matching event has been pushed back.
</span> <span class="comment">// Get it and discard. Note that if the first attempt to
</span> <span class="comment">// getEvent() returns null, the expectStartElement() calls
</span> <span class="comment">// will throw a NoSuchElementException
</span> ev = getEvent();
pool.surrenderEvent(ev);
} <span class="keyword">while</span> (ev != <span class="jde-java-font-lock-constant">null</span>);
<span class="comment">// Exit from this while loop is only by discovery of null event
</span> <span class="keyword">throw</span> <span class="keyword">new</span> <span class="type">NoSuchElementException</span>
("<span class="string">StartElement from array not found.</span>");
}
<span class="comment">/**
* Expect one of an array of possible STARTELEMENT events. The next
* STARTELEMENT must have a <tt>QName</tt> which matches an element
* of the argument <tt>String[]</tt> list.
* </span><span class="jde-java-font-lock-doc-tag">@param</span><span class="comment"> </span><span class="variable-name">list</span><span class="comment"> a <tt>String[]</tt> array containing <tt>QName</tt>s
* of possible events, one of which must be the next returned.
* </span><span class="jde-java-font-lock-doc-tag">@param</span><span class="comment"> </span><span class="variable-name">discardWhiteSpace</span><span class="comment"> - if true, discard any <tt>characters</tt>
* events which contain only whitespace.
* </span><span class="jde-java-font-lock-doc-tag">@return</span><span class="comment"> the matching STARTELEMENT event.If the next
* event detected is not of the required type, <tt>null</tt> is returned.
* The erroneous event is pushed back.
* </span><span class="jde-java-font-lock-doc-tag">@exception</span><span class="comment"> </span><span class="type">FOPException</span><span class="comment"> if buffer errors or interrupts occur
* </span><span class="jde-java-font-lock-doc-tag">@exception</span><span class="comment"> </span><span class="type">NoSuchElementException</span><span class="comment"> if end of buffer detected.
*/</span>
<span class="jde-java-font-lock-modifier">public</span> <span class="type">FoXMLEvent</span> <span class="variable-name">expectStartElement</span>
(<span class="type">String</span>[] <span class="variable-name">list</span>, <span class="type">boolean</span> <span class="variable-name">discardWhiteSpace</span>)
<span class="keyword">throws</span> <span class="type">FOPException</span>
{
<span class="type">FoXMLEvent</span> <span class="variable-name">ev</span>;
<span class="keyword">for</span> (<span class="type">int</span> <span class="variable-name">i</span> = <span class="jde-java-font-lock-number">0</span>; i < list.length; i++) {
ev = expectStartElement(list[i], discardWhiteSpace);
<span class="comment">// Found it!
</span> <span class="keyword">if</span> (ev != <span class="jde-java-font-lock-constant">null</span>) <span class="keyword">return</span> ev;
}
<span class="keyword">return</span> <span class="jde-java-font-lock-constant">null</span>;
}
<span class="comment">/**
* Get one of a array of possible STARTELEMENT events. Scan and discard
* events until a STARTELEMENT event is found which is in the fo:
* namespace and whose FO type matches one of those in the argument
* <tt>int</tt> array.
* </span><span class="jde-java-font-lock-doc-tag">@param</span><span class="comment"> </span><span class="variable-name">list</span><span class="comment"> an <tt>int[]</tt> array containing FO types
* one of which is required.
* </span><span class="jde-java-font-lock-doc-tag">@param</span><span class="comment"> </span><span class="variable-name">discardWhiteSpace</span><span class="comment"> - if true, discard any <tt>characters</tt>
* events which contain only whitespace.
* </span><span class="jde-java-font-lock-doc-tag">@return</span><span class="comment"> the next matching STARTELEMENT event from the buffer.
* </span><span class="jde-java-font-lock-doc-tag">@exception</span><span class="comment"> </span><span class="type">FOPException</span><span class="comment"> if buffer errors or interrupts occur
* </span><span class="jde-java-font-lock-doc-tag">@exception</span><span class="comment"> </span><span class="type">NoSuchElementException</span><span class="comment"> if the event is not found
*/</span>
<span class="jde-java-font-lock-modifier">public</span> <span class="type">FoXMLEvent</span> <span class="function-name">getStartElement</span>(<span class="type">int</span>[] <span class="variable-name">list</span>, <span class="type">boolean</span> <span class="variable-name">discardWhiteSpace</span>)
<span class="keyword">throws</span> <span class="type">FOPException</span>
{
<span class="type">FoXMLEvent</span> <span class="variable-name">ev</span>;
<span class="keyword">do</span> {
ev = expectStartElement(list, discardWhiteSpace);
<span class="keyword">if</span> (ev != <span class="jde-java-font-lock-constant">null</span>) <span class="keyword">return</span> ev;
<span class="comment">// The non-matching event has been pushed back.
</span> <span class="comment">// Get it and discard. Note that if the first attempt to
</span> <span class="comment">// getEvent() returns null, the expectStartElement() calls
</span> <span class="comment">// will throw a NoSuchElementException
</span> ev = getEvent();
pool.surrenderEvent(ev);
} <span class="keyword">while</span> (ev != <span class="jde-java-font-lock-constant">null</span>);
<span class="comment">// Exit from this while loop is only by discovery of null event
</span> <span class="keyword">throw</span> <span class="keyword">new</span> <span class="type">NoSuchElementException</span>
("<span class="string">StartElement from array not found.</span>");
}
<span class="comment">/**
* Expect one of an array of possible STARTELEMENT events. The next
* STARTELEMENT must be in the fo: namespace, and must have an FO type
* which matches one of those in the argument <tt>int[]</tt> list.
* </span><span class="jde-java-font-lock-doc-tag">@param</span><span class="comment"> </span><span class="variable-name">list</span><span class="comment"> a <tt>int[]</tt> array containing the FO types
* of possible events, one of which must be the next returned.
* </span><span class="jde-java-font-lock-doc-tag">@param</span><span class="comment"> </span><span class="variable-name">discardWhiteSpace</span><span class="comment"> - if true, discard any <tt>characters</tt>
* events which contain only whitespace.
* </span><span class="jde-java-font-lock-doc-tag">@return</span><span class="comment"> the matching STARTELEMENT event.If the next
* event detected is not of the required type, <tt>null</tt> is returned.
* The erroneous event is pushed back.
* </span><span class="jde-java-font-lock-doc-tag">@exception</span><span class="comment"> </span><span class="type">FOPException</span><span class="comment"> if buffer errors or interrupts occur
* </span><span class="jde-java-font-lock-doc-tag">@exception</span><span class="comment"> </span><span class="type">NoSuchElementException</span><span class="comment"> if end of buffer detected.
*/</span>
<span class="jde-java-font-lock-modifier">public</span> <span class="type">FoXMLEvent</span> <span class="variable-name">expectStartElement</span>
(<span class="type">int</span>[] <span class="variable-name">list</span>, <span class="type">boolean</span> <span class="variable-name">discardWhiteSpace</span>)
<span class="keyword">throws</span> <span class="type">FOPException</span>
{
<span class="type">FoXMLEvent</span> <span class="variable-name">ev</span>;
<span class="keyword">for</span> (<span class="type">int</span> <span class="variable-name">i</span> = <span class="jde-java-font-lock-number">0</span>; i < list.length; i++) {
ev = expectStartElement(list[i], discardWhiteSpace);
<span class="comment">// Found it!
</span> <span class="keyword">if</span> (ev != <span class="jde-java-font-lock-constant">null</span>) <span class="keyword">return</span> ev;
}
<span class="keyword">return</span> <span class="jde-java-font-lock-constant">null</span>;
}
<span class="comment">/**
* Get one of a <tt>BitSet</tt> of possible STARTELEMENT events. Scan
* and discard events until a STARTELEMENT event is found which is in
* the fo: namespace and whose FO type matches one of those in the
* argument <tt>BitSet</tt>.
* </span><span class="jde-java-font-lock-doc-tag">@param</span><span class="comment"> </span><span class="variable-name" id="set">set</span><span class="comment"> a <tt>BitSet</tt> containing FO types one of which is
* required.
* </span><span class="jde-java-font-lock-doc-tag">@param</span><span class="comment"> </span><span class="variable-name">discardWhiteSpace</span><span class="comment"> - if true, discard any <tt>characters</tt>
* events which contain only whitespace.
* </span><span class="jde-java-font-lock-doc-tag">@return</span><span class="comment"> the next matching STARTELEMENT event from the buffer.
* </span><span class="jde-java-font-lock-doc-tag">@exception</span><span class="comment"> </span><span class="type">FOPException</span><span class="comment"> if buffer errors or interrupts occur
* </span><span class="jde-java-font-lock-doc-tag">@exception</span><span class="comment"> </span><span class="type">NoSuchElementException</span><span class="comment"> if the event is not found
*/</span>
<span class="jde-java-font-lock-modifier">public</span> <span class="type">FoXMLEvent</span> <span class="function-name">getStartElement</span>(<span class="type">BitSet</span> <span class="variable-name">set</span>, <span class="type">boolean</span> <span class="variable-name">discardWhiteSpace</span>)
<span class="keyword">throws</span> <span class="type">FOPException</span>
{
<span class="type">FoXMLEvent</span> <span class="variable-name">ev</span>;
<span class="keyword">do</span> {
<span class="keyword">try</span> {
ev = expectStartElement(set, discardWhiteSpace);
<span class="keyword">if</span> (ev != <span class="jde-java-font-lock-constant">null</span>) <span class="keyword">return</span> ev;
<span class="comment">// The non-matching event has been pushed back.
</span> <span class="comment">// Get it and discard. Note that if the first attempt to
</span> <span class="comment">// getEvent() returns null, the expectStartElement() calls
</span> <span class="comment">// will throw a NoSuchElementException
</span> ev = getEvent();
pool.surrenderEvent(ev);
} <span class="keyword">catch</span>(<span class="type">UnexpectedStartElementException</span> <span class="variable-name">e</span>) {
ev = getEvent();
pool.surrenderEvent(ev);
}
} <span class="keyword">while</span> (ev != <span class="jde-java-font-lock-constant">null</span>);
<span class="comment">// Exit from this while loop is only by discovery of null event
</span> <span class="keyword">throw</span> <span class="keyword">new</span> <span class="type">NoSuchElementException</span>
("<span class="string">StartElement from BitSet not found.</span>");
}
<span class="comment">/**
* Expect one of an <tt>BitSet</tt> of possible STARTELEMENT events.
* The next STARTELEMENT must be in the fo: namespace, and must have an
* FO type which matches one of those in the argument <tt>BitSet</tt>.
* <p>TODO:<br>
* This method should be retro-fitted to list and array versions.
*
* </span><span class="jde-java-font-lock-doc-tag">@param</span><span class="comment"> </span><span class="variable-name">set</span><span class="comment"> a <tt>BitSet</tt> containing the FO types
* of possible events, one of which must be the next returned.
* </span><span class="jde-java-font-lock-doc-tag">@param</span><span class="comment"> </span><span class="variable-name">discardWhiteSpace</span><span class="comment"> - if true, discard any <tt>characters</tt>
* events which contain only whitespace.
* </span><span class="jde-java-font-lock-doc-tag">@return</span><span class="comment"> the matching STARTELEMENT event.If the next
* event detected is not of the required type, <tt>null</tt> is returned.
* The erroneous event is pushed back.
* </span><span class="jde-java-font-lock-doc-tag">@exception</span><span class="comment"> </span><span class="type">FOPException</span><span class="comment"> if buffer errors or interrupts occur
* </span><span class="jde-java-font-lock-doc-tag">@exception</span><span class="comment"> </span><span class="type">NoSuchElementException</span><span class="comment"> if end of buffer detected.
*/</span>
<span class="jde-java-font-lock-modifier">public</span> <span class="type">FoXMLEvent</span> <span class="variable-name">expectStartElement</span>
(<span class="type">BitSet</span> <span class="variable-name">set</span>, <span class="type">boolean</span> <span class="variable-name">discardWhiteSpace</span>)
<span class="keyword">throws</span> <span class="type">FOPException</span>, <span class="type">UnexpectedStartElementException</span>
{
<span class="type">FoXMLEvent</span> <span class="variable-name">ev</span>;
ev = expectTypedEvent(XMLEvent.<span class="jde-java-font-lock-constant">STARTELEMENT</span>, discardWhiteSpace);
<span class="keyword">if</span> (ev == <span class="jde-java-font-lock-constant">null</span>) <span class="keyword">return</span> ev;
<span class="keyword">for</span> (<span class="type">int</span> <span class="variable-name">i</span> = set.nextSetBit(<span class="jde-java-font-lock-number">0</span>); i >= <span class="jde-java-font-lock-number">0</span>; i = set.nextSetBit(++i)) {
<span class="keyword">if</span> (ev.foType == i)
<span class="keyword">return</span> ev; <span class="comment">// Found it!
</span> }
<span class="comment">// Not found - push the STARTELEMENT event back and throw an
</span> <span class="comment">// UnexpectedStartElementException
</span> pushBack(ev);
<span class="keyword">throw</span> <span class="keyword">new</span> <span class="type">UnexpectedStartElementException</span>
("<span class="string">Unexpected START element: </span>" + ev.getQName());
}
<span class="comment">/**
* Expect that the next element will be a STARTELEMENT for one of the
* flow objects which are members of %block; from
* <b></span><span class="jde-java-font-lock-bold">6.2 Formatting Object Content</span><span class="comment"></b>, including out-of-line flow
* objects which may occur except as descendents of out-of-line formatting
* objects. White space is discarded.
* </span><span class="jde-java-font-lock-doc-tag">@return</span><span class="comment"> the <tt>FoXMLEvent found. If any other events are encountered
* return <tt>null</tt>.
*/</span>
<span class="jde-java-font-lock-modifier">public</span> <span class="type">FoXMLEvent</span> <span class="function-name" id="expectBlock">expectBlock</span>()
<span class="keyword">throws</span> <span class="type">FOPException</span>, <span class="type">UnexpectedStartElementException</span>
{
<span class="keyword">return</span> expectStartElement
(FObjectSets.blockEntity, XMLEvent.<span class="jde-java-font-lock-constant" id="DISCARD_W_SPACE">DISCARD_W_SPACE</span>);
}
<span class="comment">/**
* Expect that the next element will be a STARTELEMENT for one of the
* flow objects which are members of %block; from
* <b></span><span class="jde-java-font-lock-bold">6.2 Formatting Object Content</span><span class="comment"></b>, excluding out-of-line flow
* objects which may not occur as descendents of out-of-line formatting
* objects. White space is discarded.
* </span><span class="jde-java-font-lock-doc-tag">@return</span><span class="comment"> the <tt>FoXMLEvent found. If any other events are encountered
* return <tt>null</tt>.
*/</span>
<span class="jde-java-font-lock-modifier">public</span> <span class="type">FoXMLEvent</span> <span class="function-name" id="expectOutOfLineBlock">expectOutOfLineBlock</span>()
<span class="keyword">throws</span> <span class="type">FOPException</span>, <span class="type">UnexpectedStartElementException</span>
{
<span class="keyword">return</span> expectStartElement
(FObjectSets.outOfLineBlockSet, XMLEvent.<span class="jde-java-font-lock-constant">DISCARD_W_SPACE</span>);
}
<span class="comment">/**
* Expect that the next element will be a STARTELEMENT for one of the
* flow objects which are members of (#PCDATA|%inline;) from
* <b></span><span class="jde-java-font-lock-bold">6.2 Formatting Object Content</span><span class="comment"></b>, including out-of-line flow
* objects which may occur except as descendents of out-of-line
* formatting objects. White space is retained, and
* will appear as #PCDATA, i.e, as an instance of FoCharacters.
* </span><span class="jde-java-font-lock-doc-tag">@return</span><span class="comment"> the <tt>FoXMLEvent found. If any other events are encountered
* return <tt>null</tt>.
*/</span>
<span class="jde-java-font-lock-modifier">public</span> <span class="type">FoXMLEvent</span> <span class="function-name" id="expectPcdataOrInline">expectPcdataOrInline</span>()
<span class="keyword">throws</span> <span class="type">FOPException</span>, <span class="type">UnexpectedStartElementException</span>
{
<span class="type">FoXMLEvent</span> <span class="variable-name">ev</span> = expectStartElement
(FObjectSets.normalPcdataInlineSet, XMLEvent.<span class="jde-java-font-lock-constant" id="RETAIN_W_SPACE">RETAIN_W_SPACE</span>);
<span class="keyword">if</span> (ev == <span class="jde-java-font-lock-constant">null</span>)
ev = expectCharacters();
<span class="keyword">return</span> ev;
}
<span class="comment">/**
* Expect that the next element will be a STARTELEMENT for one of the
* flow objects which are members of (#PCDATA|%inline;) from
* <b></span><span class="jde-java-font-lock-bold">6.2 Formatting Object Content</span><span class="comment"></b>, excluding out-of-line flow
* objects which may not occur as descendents of out-of-line formatting
* objects. White space is retained, and
* will appear as #PCDATA, i.e, as an instance of FoCharacters.
* </span><span class="jde-java-font-lock-doc-tag">@return</span><span class="comment"> the <tt>FoXMLEvent found. If any other events are encountered
* return <tt>null</tt>.
*/</span>
<span class="jde-java-font-lock-modifier">public</span> <span class="type">FoXMLEvent</span> <span class="function-name" id="expectOutOfLinePcdataOrInline">expectOutOfLinePcdataOrInline</span>()
<span class="keyword">throws</span> <span class="type">FOPException</span>, <span class="type">UnexpectedStartElementException</span>
{
<span class="type">FoXMLEvent</span> <span class="variable-name">ev</span> = expectStartElement
(FObjectSets.inlineEntity, XMLEvent.<span class="jde-java-font-lock-constant">RETAIN_W_SPACE</span>);
<span class="keyword">if</span> (ev == <span class="jde-java-font-lock-constant">null</span>)
ev = expectCharacters();
<span class="keyword">return</span> ev;
}
<span class="comment">/**
* Expect that the next element will be a STARTELEMENT for one of the
* flow objects which are members of (#PCDATA|%inline;|%block;) from
* <b></span><span class="jde-java-font-lock-bold">6.2 Formatting Object Content</span><span class="comment"></b>, including out-of-line flow
* objects which may occur except as descendents of out-of-line
* formatting objects. White space is retained, and
* will appear as #PCDATA, i.e, as an instance of FoCharacters.
* </span><span class="jde-java-font-lock-doc-tag">@return</span><span class="comment"> the <tt>FoXMLEvent</tt> found. If any other events are
* encountered return <tt>null</tt>.
*/</span>
<span class="jde-java-font-lock-modifier">public</span> <span class="type">FoXMLEvent</span> <span class="function-name" id="expectPcdataOrInlineOrBlock">expectPcdataOrInlineOrBlock</span>()
<span class="keyword">throws</span> <span class="type">FOPException</span>, <span class="type">UnexpectedStartElementException</span>
{
<span class="type">FoXMLEvent</span> <span class="variable-name">ev</span> = expectStartElement
(FObjectSets.normalPcdataBlockInlineSet, XMLEvent.<span class="jde-java-font-lock-constant">RETAIN_W_SPACE</span>);
<span class="keyword">if</span> (ev == <span class="jde-java-font-lock-constant">null</span>)
ev = expectCharacters();
<span class="keyword">return</span> ev;
}
<span class="comment">/**
* Expect that the next element will be a STARTELEMENT for one of the
* flow objects which are members of (#PCDATA|%inline;|%block;) from
* <b></span><span class="jde-java-font-lock-bold">6.2 Formatting Object Content</span><span class="comment"></b>, excluding out-of-line flow
* objects which may not occur as descendents of out-of-line formatting
* objects. White space is retained, and
* will appear as #PCDATA, i.e, as an instance of FoCharacters.
* </span><span class="jde-java-font-lock-doc-tag">@return</span><span class="comment"> the <tt>FoXMLEvent</tt> found. If any other events are
* encountered return <tt>null</tt>.
*/</span>
<span class="jde-java-font-lock-modifier">public</span> <span class="type">FoXMLEvent</span> <span class="function-name" id="expectOutOfLinePcdataOrInlineOrBlock">expectOutOfLinePcdataOrInlineOrBlock</span>()
<span class="keyword">throws</span> <span class="type">FOPException</span>, <span class="type">UnexpectedStartElementException</span>
{
<span class="type">FoXMLEvent</span> <span class="variable-name">ev</span> = expectStartElement
(FObjectSets.outOfLinePcdataBlockInlineSet,
XMLEvent.<span class="jde-java-font-lock-constant">RETAIN_W_SPACE</span>);
<span class="keyword">if</span> (ev == <span class="jde-java-font-lock-constant">null</span>)
ev = expectCharacters();
<span class="keyword">return</span> ev;
}
<span class="comment">/**
* Get the next ENDELEMENT event from the buffer. Discard any other
* events preceding the ENDELEMENT event.
* </span><span class="jde-java-font-lock-doc-tag">@return</span><span class="comment"> an ENDELEMENT event
* </span><span class="jde-java-font-lock-doc-tag">@exception</span><span class="comment"> </span><span class="type">FOPException</span><span class="comment"> if buffer errors or interrupts occur
* </span><span class="jde-java-font-lock-doc-tag">@exception</span><span class="comment"> </span><span class="type">NoSuchElementException</span><span class="comment"> if the event is not found
*/</span>
<span class="jde-java-font-lock-modifier">public</span> <span class="type">FoXMLEvent</span> <span class="function-name" id="getEndElement">getEndElement</span>() <span class="keyword">throws</span> <span class="type">FOPException</span> {
<span class="keyword">return</span> getTypedEvent(XMLEvent.<span class="jde-java-font-lock-constant" id="ENDELEMENT">ENDELEMENT</span>);
}
<span class="comment">/**
* Return the next element if it is an ENDELEMENT. If the next
* element is not of the required type, push it back onto the buffer.
* </span><span class="jde-java-font-lock-doc-tag">@param</span><span class="comment"> </span><span class="variable-name">discardWhiteSpace</span><span class="comment"> - if true, discard any <tt>characters</tt>
* events which contain only whitespace.
* </span><span class="jde-java-font-lock-doc-tag">@return</span><span class="comment"> a matching ENDELEMENT event. If the next
* event detected is not of the required type, <tt>null</tt> is returned.
* The erroneous event is pushed back.
* </span><span class="jde-java-font-lock-doc-tag">@exception</span><span class="comment"> </span><span class="type">FOPException</span><span class="comment"> if buffer errors or interrupts occur
* </span><span class="jde-java-font-lock-doc-tag">@exception</span><span class="comment"> </span><span class="type">NoSuchElementException</span><span class="comment"> if ENDELEMENT is not the next
* event detected. The erroneous event is pushed back.
* </span><span class="jde-java-font-lock-doc-tag">@exception</span><span class="comment"> </span><span class="type">NoSuchElementException</span><span class="comment"> if end of buffer detected.
*/</span>
<span class="jde-java-font-lock-modifier">public</span> <span class="type">FoXMLEvent</span> <span class="function-name" id="expectEndElement">expectEndElement</span>(<span class="type">boolean</span> <span class="variable-name">discardWhiteSpace</span>)
<span class="keyword">throws</span> <span class="type">FOPException</span>
{
<span class="keyword">return</span> expectTypedEvent(XMLEvent.<span class="jde-java-font-lock-constant">ENDELEMENT</span>, discardWhiteSpace);
}
<span class="comment">/**
* Get the next ENDELEMENT event with the given <tt>QName</tt>
* from the buffer. Discard any other events preceding the
* ENDELEMENT event.
* </span><span class="jde-java-font-lock-doc-tag">@param</span><span class="comment"> </span><span class="variable-name">qName</span><span class="comment"> a <tt>String</tt> with the <tt>QName</tt> of the
* required STARTELEMENT
* </span><span class="jde-java-font-lock-doc-tag">@return</span><span class="comment"> an ENDELEMENT event
* </span><span class="jde-java-font-lock-doc-tag">@exception</span><span class="comment"> </span><span class="type">FOPException</span><span class="comment"> if buffer errors or interrupts occur
* </span><span class="jde-java-font-lock-doc-tag">@exception</span><span class="comment"> </span><span class="type">NoSuchElementException</span><span class="comment"> if the event is not found
*/</span>
<span class="jde-java-font-lock-modifier">public</span> <span class="type">FoXMLEvent</span> <span class="function-name">getEndElement</span>(<span class="type">String</span> <span class="variable-name">qName</span>) <span class="keyword">throws</span> <span class="type">FOPException</span>
{
<span class="keyword">return</span> getTypedEvent(XMLEvent.<span class="jde-java-font-lock-constant">ENDELEMENT</span>, qName);
}
<span class="comment">/**
* Return the next element if it is an ENDELEMENT with the given
* <tt>QName</tt>. If the next
* element is not of the required type, push it back onto the buffer.
* </span><span class="jde-java-font-lock-doc-tag">@param</span><span class="comment"> </span><span class="variable-name">qName</span><span class="comment"> a <tt>String</tt> with the <tt>QName</tt> of the
* required ENDELEMENT
* </span><span class="jde-java-font-lock-doc-tag">@param</span><span class="comment"> </span><span class="variable-name">discardWhiteSpace</span><span class="comment"> - if true, discard any <tt>characters</tt>
* events which contain only whitespace.
* </span><span class="jde-java-font-lock-doc-tag">@return</span><span class="comment"> an ENDELEMENT with the given qname. If the next
* event detected is not an ENDELEMENT, <tt>null</tt> is returned.
* The erroneous event is pushed back.
* </span><span class="jde-java-font-lock-doc-tag">@exception</span><span class="comment"> </span><span class="type">FOPException</span><span class="comment"> if buffer errors or interrupts occur
* </span><span class="jde-java-font-lock-doc-tag">@exception</span><span class="comment"> </span><span class="type">NoSuchElementException</span><span class="comment"> if end of buffer detected.
*/</span>
<span class="jde-java-font-lock-modifier">public</span> <span class="type">FoXMLEvent</span> <span class="function-name">expectEndElement</span>(<span class="type">String</span> <span class="variable-name">qName</span>, <span class="type">boolean</span> <span class="variable-name">discardWhiteSpace</span>)
<span class="keyword">throws</span> <span class="type">FOPException</span>
{
<span class="keyword">return</span> expectTypedEvent(XMLEvent.<span class="jde-java-font-lock-constant">ENDELEMENT</span>, qName, discardWhiteSpace);
}
<span class="comment">/**
* Get the next ENDELEMENT event with the given URI index and local name
* from the buffer. Discard any other events preceding the
* ENDELEMENT event.
* </span><span class="jde-java-font-lock-doc-tag">@param</span><span class="comment"> </span><span class="variable-name">uriIndex</span><span class="comment"> an <tt>int</tt> with the index of the URI of the
* required URI
* </span><span class="jde-java-font-lock-doc-tag">@param</span><span class="comment"> </span><span class="variable-name">localName</span><span class="comment"> a <tt>String</tt> with the local name of the
* required ENDELEMENT
* </span><span class="jde-java-font-lock-doc-tag">@return</span><span class="comment"> an ENDELEMENT event
* </span><span class="jde-java-font-lock-doc-tag">@exception</span><span class="comment"> </span><span class="type">FOPException</span><span class="comment"> if buffer errors or interrupts occur
* </span><span class="jde-java-font-lock-doc-tag">@exception</span><span class="comment"> </span><span class="type">NoSuchElementException</span><span class="comment"> if the event is not found
*/</span>
<span class="jde-java-font-lock-modifier">public</span> <span class="type">FoXMLEvent</span> <span class="function-name">getEndElement</span>(<span class="type">int</span> <span class="variable-name">uriIndex</span>, <span class="type">String</span> <span class="variable-name">localName</span>)
<span class="keyword">throws</span> <span class="type">FOPException</span>
{
<span class="keyword">return</span> getTypedEvent(XMLEvent.<span class="jde-java-font-lock-constant">ENDELEMENT</span>, uriIndex, localName);
}
<span class="comment">/**
* Return the next element if it is an ENDELEMENT with the given
* URI index and local name. If the next
* element is not of the required type, push it back onto the buffer.
* </span><span class="jde-java-font-lock-doc-tag">@param</span><span class="comment"> </span><span class="variable-name">uriIndex</span><span class="comment"> an <tt>int</tt> with the index of the URI of the
* required URI
* </span><span class="jde-java-font-lock-doc-tag">@param</span><span class="comment"> </span><span class="variable-name">localName</span><span class="comment"> a <tt>String</tt> with the local name of the
* required ENDELEMENT
* </span><span class="jde-java-font-lock-doc-tag">@param</span><span class="comment"> </span><span class="variable-name">discardWhiteSpace</span><span class="comment"> - if true, discard any <tt>characters</tt>
* events which contain only whitespace.
* </span><span class="jde-java-font-lock-doc-tag">@return</span><span class="comment"> a matching ENDELEMENT event.
* If the next
* event detected is not an ENDELEMENT, <tt>null</tt> is returned.
* The erroneous event is pushed back.
* </span><span class="jde-java-font-lock-doc-tag">@exception</span><span class="comment"> </span><span class="type">FOPException</span><span class="comment"> if buffer errors or interrupts occur
* </span><span class="jde-java-font-lock-doc-tag">@exception</span><span class="comment"> </span><span class="type">NoSuchElementException</span><span class="comment"> if end of buffer detected.
*/</span>
<span class="jde-java-font-lock-modifier">public</span> <span class="type">FoXMLEvent</span> <span class="variable-name">expectEndElement</span>
(<span class="type">int</span> <span class="variable-name">uriIndex</span>, <span class="type">String</span> <span class="variable-name">localName</span>, <span class="type">boolean</span> <span class="variable-name">discardWhiteSpace</span>)
<span class="keyword">throws</span> <span class="type">FOPException</span>
{
<span class="keyword">return</span> expectTypedEvent
(XMLEvent.<span class="jde-java-font-lock-constant">ENDELEMENT</span>, uriIndex, localName, discardWhiteSpace);
}
<span class="comment">/**
* Get the next ENDELEMENT event with the given Fo type
* from the buffer. Discard any other events preceding the
* ENDELEMENT event.
* </span><span class="jde-java-font-lock-doc-tag">@param</span><span class="comment"> </span><span class="variable-name">foType</span><span class="comment"> - the FO type of the required ENDELEMENT
* </span><span class="jde-java-font-lock-doc-tag">@return</span><span class="comment"> a matching ENDELEMENT event.
* </span><span class="jde-java-font-lock-doc-tag">@exception</span><span class="comment"> </span><span class="type">FOPException</span><span class="comment"> if buffer errors or interrupts occur
* </span><span class="jde-java-font-lock-doc-tag">@exception</span><span class="comment"> </span><span class="type">NoSuchElementException</span><span class="comment"> if the event is not found
*/</span>
<span class="jde-java-font-lock-modifier">public</span> <span class="type">FoXMLEvent</span> <span class="function-name">getEndElement</span>(<span class="type">int</span> <span class="variable-name">foType</span>) <span class="keyword">throws</span> <span class="type">FOPException</span>
{
<span class="keyword">return</span> getTypedEvent(XMLEvent.<span class="jde-java-font-lock-constant">ENDELEMENT</span>, foType);
}
<span class="comment">/**
* Return the next element if it is an ENDELEMENT with the given
* FO type. If the next
* element is not of the required type, push it back onto the buffer.
* </span><span class="jde-java-font-lock-doc-tag">@param</span><span class="comment"> </span><span class="variable-name">foType</span><span class="comment"> - the FO type of the required ENDELEMENT
* </span><span class="jde-java-font-lock-doc-tag">@param</span><span class="comment"> </span><span class="variable-name">discardWhiteSpace</span><span class="comment"> - if true, discard any <tt>characters</tt>
* events which contain only whitespace.
* </span><span class="jde-java-font-lock-doc-tag">@return</span><span class="comment"> a matching ENDELEMENT. If the next
* event detected is not an ENDELEMENT, <tt>null</tt> is returned.
* The erroneous event is pushed back.
* </span><span class="jde-java-font-lock-doc-tag">@exception</span><span class="comment"> </span><span class="type">FOPException</span><span class="comment"> if buffer errors or interrupts occur
* </span><span class="jde-java-font-lock-doc-tag">@exception</span><span class="comment"> </span><span class="type">NoSuchElementException</span><span class="comment"> if end of buffer detected.
*/</span>
<span class="jde-java-font-lock-modifier">public</span> <span class="type">FoXMLEvent</span> <span class="function-name">expectEndElement</span>(<span class="type">int</span> <span class="variable-name">foType</span>, <span class="type">boolean</span> <span class="variable-name">discardWhiteSpace</span>)
<span class="keyword">throws</span> <span class="type">FOPException</span>
{
<span class="keyword">return</span> expectTypedEvent
(XMLEvent.<span class="jde-java-font-lock-constant">ENDELEMENT</span>, foType, discardWhiteSpace);
}
<span class="comment">/**
* Get the next ENDELEMENT event, with the same URI index and local name
* as the <tt>FoXMLEvent</tt> argument, from the buffer.
* Discard any other events preceding the ENDELEMENT event.
* </span><span class="jde-java-font-lock-doc-tag">@param</span><span class="comment"> </span><span class="variable-name" id="event">event</span><span class="comment"> an <tt>FoXMLEvent</tt>. Only the uriIndex and the
* localName from the event are used. It is intended that the FoXMLEvent
* returned to the corresponding get/expectStartElement() call be used.
* </span><span class="jde-java-font-lock-doc-tag">@return</span><span class="comment"> an ENDELEMENT event
* </span><span class="jde-java-font-lock-doc-tag">@exception</span><span class="comment"> </span><span class="type">FOPException</span><span class="comment"> if buffer errors or interrupts occur
* </span><span class="jde-java-font-lock-doc-tag">@exception</span><span class="comment"> </span><span class="type">NoSuchElementException</span><span class="comment"> if the event is not found
*/</span>
<span class="jde-java-font-lock-modifier">public</span> <span class="type">FoXMLEvent</span> <span class="function-name">getEndElement</span>(<span class="type">FoXMLEvent</span> <span class="variable-name">event</span>) <span class="keyword">throws</span> <span class="type">FOPException</span>
{
<span class="keyword">if</span> (event.foType != FObjectNames.<span class="jde-java-font-lock-constant" id="NO_FO">NO_FO</span>)
<span class="keyword">return</span> getTypedEvent(XMLEvent.<span class="jde-java-font-lock-constant">ENDELEMENT</span>, event.foType);
<span class="keyword">return</span> getTypedEvent
(XMLEvent.<span class="jde-java-font-lock-constant">ENDELEMENT</span>, event.uriIndex, event.localName);
}
<span class="comment">/**
* Return the next element if it is an ENDELEMENT with the same
* URI index and local name as the <tt>FoXMLEvent argument</tt>. If the
* next element is not of the required type, push it back onto the buffer.
* </span><span class="jde-java-font-lock-doc-tag">@param</span><span class="comment"> </span><span class="variable-name">event</span><span class="comment"> an <tt>FoXMLEvent</tt>. Only the uriIndex and the
* localName from the event are used. It is intended that the FoXMLEvent
* returned to the corresponding get/expectStartElement() call be used.
* </span><span class="jde-java-font-lock-doc-tag">@param</span><span class="comment"> </span><span class="variable-name">discardWhiteSpace</span><span class="comment"> - if true, discard any <tt>characters</tt>
* events which contain only whitespace.
* </span><span class="jde-java-font-lock-doc-tag">@return</span><span class="comment"> a matching ENDELEMENT event. If the next
* event detected is not an ENDELEMENT, <tt>null</tt> is returned.
* The erroneous event is pushed back.
* </span><span class="jde-java-font-lock-doc-tag">@exception</span><span class="comment"> </span><span class="type">FOPException</span><span class="comment"> if buffer errors or interrupts occur
* </span><span class="jde-java-font-lock-doc-tag">@exception</span><span class="comment"> </span><span class="type">NoSuchElementException</span><span class="comment"> if end of buffer detected.
*/</span>
<span class="jde-java-font-lock-modifier">public</span> <span class="type">FoXMLEvent</span> <span class="variable-name">expectEndElement</span>
(<span class="type">FoXMLEvent</span> <span class="variable-name">event</span>, <span class="type">boolean</span> <span class="variable-name">discardWhiteSpace</span>)
<span class="keyword">throws</span> <span class="type">FOPException</span>
{
<span class="keyword">if</span> (event.foType != FObjectNames.<span class="jde-java-font-lock-constant">NO_FO</span>)
<span class="keyword">return</span> expectTypedEvent
(XMLEvent.<span class="jde-java-font-lock-constant">ENDELEMENT</span>, event.foType, discardWhiteSpace);
<span class="keyword">return</span> expectTypedEvent
(XMLEvent.<span class="jde-java-font-lock-constant">ENDELEMENT</span>, event.uriIndex, event.localName,
discardWhiteSpace);
}
<span class="comment">/**
* Get the next ENDELEMENT event, with the same URI index and local name
* as the <tt>FoXMLEvent</tt> argument, from the buffer.
* Discard any other events preceding the ENDELEMENT event.
* </span><span class="jde-java-font-lock-doc-tag">@param</span><span class="comment"> </span><span class="variable-name" id="discardEvent">discardEvent</span><span class="comment"> the argument event may be discarded.
* </span><span class="jde-java-font-lock-doc-tag">@param</span><span class="comment"> </span><span class="variable-name">event</span><span class="comment"> an <tt>FoXMLEvent</tt>. Only the uriIndex and the
* localName from the event are used. It is intended that the FoXMLEvent
* returned to the corresponding get/expectStartElement() call be used.
* </span><span class="jde-java-font-lock-doc-tag">@return</span><span class="comment"> an ENDELEMENT event
* </span><span class="jde-java-font-lock-doc-tag">@exception</span><span class="comment"> </span><span class="type">FOPException</span><span class="comment"> if buffer errors or interrupts occur
* </span><span class="jde-java-font-lock-doc-tag">@exception</span><span class="comment"> </span><span class="type">NoSuchElementException</span><span class="comment"> if the event is not found
*/</span>
<span class="jde-java-font-lock-modifier">public</span> <span class="type">FoXMLEvent</span> <span class="function-name">getEndElement</span>(<span class="type">boolean</span> <span class="variable-name">discardEvent</span>, <span class="type">FoXMLEvent</span> <span class="variable-name">event</span>)
<span class="keyword">throws</span> <span class="type">FOPException</span>
{
<span class="type">FoXMLEvent</span> <span class="variable-name">ev</span>;
<span class="keyword">if</span> (event.foType != FObjectNames.<span class="jde-java-font-lock-constant">NO_FO</span>)
ev = getTypedEvent(XMLEvent.<span class="jde-java-font-lock-constant">ENDELEMENT</span>, event.foType);
<span class="keyword">else</span>
ev = getTypedEvent
(XMLEvent.<span class="jde-java-font-lock-constant">ENDELEMENT</span>, event.uriIndex, event.localName);
<span class="keyword">if</span> (discardEvent) {
<span class="comment">//System.out.println("discardEvent");
</span> pool.surrenderEvent(event);
}
<span class="keyword">return</span> ev;
}
<span class="comment">/**
* Return the next element if it is an ENDELEMENT with the same
* URI index and local name as the <tt>FoXMLEvent argument</tt>. If the
* next element is not of the required type, push it back onto the buffer.
* </span><span class="jde-java-font-lock-doc-tag">@param</span><span class="comment"> </span><span class="variable-name">discardEvent</span><span class="comment"> the argument event may be discarded.
* </span><span class="jde-java-font-lock-doc-tag">@param</span><span class="comment"> </span><span class="variable-name">event</span><span class="comment"> an <tt>FoXMLEvent</tt>. Only the uriIndex and the
* localName from the event are used. It is intended that the FoXMLEvent
* returned to the corresponding get/expectStartElement() call be used.
* </span><span class="jde-java-font-lock-doc-tag">@param</span><span class="comment"> </span><span class="variable-name">discardWhiteSpace</span><span class="comment"> - if true, discard any <tt>characters</tt>
* events which contain only whitespace.
* </span><span class="jde-java-font-lock-doc-tag">@return</span><span class="comment"> a matching ENDELEMENT event. If the next
* event detected is not an ENDELEMENT, <tt>null</tt> is returned.
* The erroneous event is pushed back.
* </span><span class="jde-java-font-lock-doc-tag">@exception</span><span class="comment"> </span><span class="type">FOPException</span><span class="comment"> if buffer errors or interrupts occur
* </span><span class="jde-java-font-lock-doc-tag">@exception</span><span class="comment"> </span><span class="type">NoSuchElementException</span><span class="comment"> if end of buffer detected.
*/</span>
<span class="jde-java-font-lock-modifier">public</span> <span class="type">FoXMLEvent</span> <span class="variable-name">expectEndElement</span>
(<span class="type">boolean</span> <span class="variable-name">discardEvent</span>, <span class="type">FoXMLEvent</span> <span class="variable-name">event</span>, <span class="type">boolean</span> <span class="variable-name">discardWhiteSpace</span>)
<span class="keyword">throws</span> <span class="type">FOPException</span>
{
<span class="type">FoXMLEvent</span> <span class="variable-name">ev</span>;
<span class="keyword">if</span> (event.foType != FObjectNames.<span class="jde-java-font-lock-constant">NO_FO</span>)
ev = expectTypedEvent
(XMLEvent.<span class="jde-java-font-lock-constant">ENDELEMENT</span>, event.foType, discardWhiteSpace);
<span class="keyword">else</span>
ev = expectTypedEvent
(XMLEvent.<span class="jde-java-font-lock-constant">ENDELEMENT</span>, event.uriIndex, event.localName,
discardWhiteSpace);
<span class="keyword">if</span> (discardEvent)
pool.surrenderEvent(event);
<span class="keyword">return</span> ev;
}
<span class="comment">/**
* </span><span class="jde-java-font-lock-doc-tag">@return</span><span class="comment"> a CHARACTERS event
* </span><span class="jde-java-font-lock-doc-tag">@exception</span><span class="comment"> </span><span class="type">FOPException</span><span class="comment"> if buffer errors or interrupts occur
* </span><span class="jde-java-font-lock-doc-tag">@exception</span><span class="comment"> </span><span class="type">NoSuchElementException</span><span class="comment"> if the event is not found
*/</span>
<span class="jde-java-font-lock-modifier">public</span> <span class="type">FoXMLEvent</span> <span class="function-name" id="getCharacters">getCharacters</span>() <span class="keyword">throws</span> <span class="type">FOPException</span> {
<span class="type">FoXMLEvent</span> <span class="variable-name">ev</span> = getEvent();
<span class="keyword">while</span> (ev != <span class="jde-java-font-lock-constant">null</span> && ev.type != XMLEvent.<span class="jde-java-font-lock-constant">CHARACTERS</span>) {
pool.surrenderEvent(ev);
ev = getEvent();
}
<span class="keyword">if</span> (ev == <span class="jde-java-font-lock-constant">null</span>) {
<span class="keyword">throw</span> <span class="keyword">new</span> <span class="type">NoSuchElementException</span>("<span class="string">Characters not found.</span>");
}
<span class="keyword">return</span> ev;
}
<span class="comment">/**
* </span><span class="jde-java-font-lock-doc-tag">@return</span><span class="comment"> a CHARACTERS event. If the next event detected is not
* a CHARACTERS event, <tt>null</tt> is returned.
* The erroneous event is pushed back.
* </span><span class="jde-java-font-lock-doc-tag">@exception</span><span class="comment"> </span><span class="type">FOPException</span><span class="comment"> if buffer errors or interrupts occur
* </span><span class="jde-java-font-lock-doc-tag">@exception</span><span class="comment"> </span><span class="type">NoSuchElementException</span><span class="comment"> if end of buffer detected.
*/</span>
<span class="jde-java-font-lock-modifier">public</span> <span class="type">FoXMLEvent</span> <span class="function-name" id="expectCharacters">expectCharacters</span>() <span class="keyword">throws</span> <span class="type">FOPException</span> {
<span class="type">FoXMLEvent</span> <span class="variable-name">ev</span> = getEvent();
<span class="keyword">if</span> (ev != <span class="jde-java-font-lock-constant">null</span> && ev.type == XMLEvent.<span class="jde-java-font-lock-constant">CHARACTERS</span>) {
<span class="keyword">return</span> ev;
}
pushBack(ev);
<span class="keyword">return</span> <span class="jde-java-font-lock-constant">null</span>;
}
}
</pre>
</body>
</html>
1.1 xml-site/targets/fop/design/alt.design/XMLNamespaces.html
Index: XMLNamespaces.html
===================================================================
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01//EN">
<!-- Created by htmlize-0.67 in css mode. -->
<html>
<head>
<title>XMLNamespaces.java</title>
<style type="text/css">
<!--
body {
color: #000000;
background-color: #faf0e6;
} /* default */
.jde-java-font-lock-modifier {
color: #da70d6;
background-color: #faf0e6;
} /* jde-java-font-lock-modifier-face */
.comment {
color: #00008b;
background-color: #faf0e6;
} /* font-lock-comment-face */
.function-name {
color: #8b2323;
background-color: #faf0e6;
} /* font-lock-function-name-face */
.jde-java-font-lock-package {
color: #0000cd;
background-color: #faf0e6;
} /* jde-java-font-lock-package-face */
.jde-java-font-lock-constant {
color: #5f9ea0;
background-color: #faf0e6;
} /* jde-java-font-lock-constant-face */
.keyword {
color: #8b0000;
background-color: #faf0e6;
} /* font-lock-keyword-face */
.jde-java-font-lock-doc-tag {
color: #008b00;
background-color: #faf0e6;
} /* jde-java-font-lock-doc-tag-face */
.jde-java-font-lock-number {
color: #bc8f8f;
background-color: #faf0e6;
} /* jde-java-font-lock-number-face */
.string {
color: #008b00;
background-color: #faf0e6;
} /* font-lock-string-face */
.variable-name {
color: #8b008b;
background-color: #faf0e6;
} /* font-lock-variable-name-face */
.jde-java-font-lock-italic {
background-color: #faf0e6;
font-style: italic;
} /* jde-java-font-lock-italic-face */
.type {
color: #4682b4;
background-color: #faf0e6;
} /* font-lock-type-face */
a {
color: inherit;
background-color: inherit;
font: inherit;
text-decoration: inherit;
}
a:hover {
text-decoration: underline;
}
-->
</style>
</head>
<body>
<pre>
<span class="keyword">package</span> <span class="jde-java-font-lock-package">org</span>.<span class="jde-java-font-lock-package">apache</span>.<span class="jde-java-font-lock-package">fop</span>.<span class="jde-java-font-lock-package">xml</span>;
<span class="keyword">import</span> <span class="jde-java-font-lock-package">org</span>.<span class="jde-java-font-lock-package">apache</span>.<span class="jde-java-font-lock-package">fop</span>.<span class="jde-java-font-lock-package">datatypes</span>.<span class="type">Ints</span>;
<span class="keyword">import</span> <span class="jde-java-font-lock-package">java</span>.<span class="jde-java-font-lock-package">util</span>.<span class="type">HashMap</span>;
<span class="keyword">import</span> <span class="jde-java-font-lock-package">java</span>.<span class="jde-java-font-lock-package">util</span>.<span class="type">ArrayList</span>;
<span class="comment">/*
* $Id: XMLNamespaces.html,v 1.1 2003/03/17 02:19:30 pbwest Exp $
* Copyright (C) 2001 The Apache Software Foundation. All rights reserved.
* For details on use and redistribution please refer to the
* LICENSE file included with these sources.
* @author <a href="mailto:pbwest@powerup.com.au">Peter B. West</a>
* @version $Revision: 1.1 $ $Name: $
*/</span>
<span class="comment">/**
* Maintains the namespaces encountered by an invocation of
* <tt>XMLSerialHandler</tt>.
* <p>One instance of <i></span><span class="jde-java-font-lock-italic">XMLNamespaces</span><span class="comment"></i> is maintained across all
* documents that may be processed in a single invocation of
* <tt>XMLSerialhandler</tt>. A reference to that instance is kept with
* every instance of <tt>XMLEvent</tt>.
*/</span>
<span class="jde-java-font-lock-modifier">public</span> <span class="keyword">class</span> <span class="function-name" id="XMLNamespacesClass">XMLNamespaces</span> {
<span class="jde-java-font-lock-modifier">private</span> <span class="jde-java-font-lock-modifier">static</span> <span class="jde-java-font-lock-modifier">final</span> <span class="type">String</span> <span class="variable-name" id="tag">tag</span> = "<span class="string">$Name: $</span>";
<span class="jde-java-font-lock-modifier">private</span> <span class="jde-java-font-lock-modifier">static</span> <span class="jde-java-font-lock-modifier">final</span> <span class="type">String</span> <span class="variable-name" id="revision">revision</span> = "<span class="string">$Revision: 1.1 $</span>";
<span class="jde-java-font-lock-modifier">public</span> <span class="jde-java-font-lock-modifier">static</span> <span class="jde-java-font-lock-modifier">final</span> <span class="type">String</span> <span class="variable-name" id="DefAttrNSpace">DefAttrNSpace</span> = "";
<span class="jde-java-font-lock-modifier">public</span> <span class="jde-java-font-lock-modifier">static</span> <span class="jde-java-font-lock-modifier">final</span> <span class="type">String</span> <span class="variable-name" id="XSLNamespace">XSLNamespace</span> =
"<span class="string">http://www.w3.org/1999/XSL/Format</span>";
<span class="jde-java-font-lock-modifier">public</span> <span class="jde-java-font-lock-modifier">static</span> <span class="jde-java-font-lock-modifier">final</span> <span class="type">String</span> <span class="variable-name" id="SVGNamespace">SVGNamespace</span> = "<span class="string">http://www.w3.org/2000/svg</span>";
<span class="jde-java-font-lock-modifier">public</span> <span class="jde-java-font-lock-modifier">static</span> <span class="jde-java-font-lock-modifier">final</span> <span class="type">String</span> <span class="variable-name" id="XlinkNamespace">XlinkNamespace</span> =
"<span class="string">http://www.w3.org/1999/xlink</span>";
<span class="jde-java-font-lock-modifier">public</span> <span class="jde-java-font-lock-modifier">static</span> <span class="jde-java-font-lock-modifier">final</span> <span class="type">int</span> <span class="variable-name" id="DefAttrNSIndex">DefAttrNSIndex</span> = <span class="jde-java-font-lock-number">0</span>;
<span class="jde-java-font-lock-modifier">public</span> <span class="jde-java-font-lock-modifier">static</span> <span class="jde-java-font-lock-modifier">final</span> <span class="type">int</span> <span class="variable-name" id="XSLNSpaceIndex">XSLNSpaceIndex</span> = <span class="jde-java-font-lock-number">1</span>;
<span class="jde-java-font-lock-modifier">public</span> <span class="jde-java-font-lock-modifier">static</span> <span class="jde-java-font-lock-modifier">final</span> <span class="type">int</span> <span class="variable-name" id="SVGNSpaceIndex">SVGNSpaceIndex</span> = <span class="jde-java-font-lock-number">2</span>;
<span class="jde-java-font-lock-modifier">public</span> <span class="jde-java-font-lock-modifier">static</span> <span class="jde-java-font-lock-modifier">final</span> <span class="type">int</span> <span class="variable-name" id="XLinkNSpaceIndex">XLinkNSpaceIndex</span> = <span class="jde-java-font-lock-number">3</span>;
<span class="comment">/**
* A <tt>HashMap</tt> mapping a namespace URI to an <tt>int</tt>
* index. The HashMap is initialized with a few well-known URIs. As
* URIs are encountered in parsing, they are converted to an integer
* index by lookup in this HashMap. If the URI has not been seen, it
* is added to the <i></span><span class="jde-java-font-lock-italic">uriIndices</i> and <i>uris</span><span class="comment"></i> for future reference.
* <b>It is vital that no URI, once added, ever be deleted
* from this <tt>HashMap</tt></b>.
* <p><tt>HashMap</> is unsynchronized, so accesses and updates must be
* protected.
* <p>
* Updates will be very rare, and accesses are directly related to the
* number of elements (and attributes) encountered.
*/</span>
<span class="jde-java-font-lock-modifier">private</span> <span class="type">HashMap</span> <span class="variable-name" id="uriIndices">uriIndices</span>;
<span class="comment">/**
* A <tt>ArrayList</tt> of namespace URIs. Effectively, a mapping of
* an <tt>int</tt> index onto a URI.
* ArrayList is initialized with a few well-known URIs. As
* URIs are encountered in parsing, they are converted to an integer
* index by lookup in the <i></span><span class="jde-java-font-lock-italic">uriIndices</span><span class="comment"></i> Hashmap. If the URI has not
* been seen, it is added to <i></span><span class="jde-java-font-lock-italic">uriIndices</i> and <i>uris</span><span class="comment"></i>
* for future reference.
* <p>
* <tt>ArrayList</> is unsynchronized, so access and updates must be
* protected. Both will be more rare than accesses to <i></span><span class="jde-java-font-lock-italic">uriIndices</span><span class="comment"></i>.
*/</span>
<span class="jde-java-font-lock-modifier">private</span> <span class="type">ArrayList</span> <span class="variable-name" id="uris">uris</span>;
<span class="comment">/**
* A sequence object for use by <tt>XMLEvent</tt>s. Because an
* <tt>XMLEvent</tt> object must always be associated with an
* <i></span><span class="jde-java-font-lock-italic">XMLNamespace</span><span class="comment"></i> object, this namespace object will act as a
* singleton for <tt>XMLEvent</tt>s. This field provides a
* counter for those objects. The range of values which may be
* assigned to <i></span><span class="jde-java-font-lock-italic">sequence</i> is restricted by <i>seqMask</span><span class="comment"></i>.
*/</span>
<span class="jde-java-font-lock-modifier">private</span> <span class="type">int</span> <span class="variable-name" id="sequence">sequence</span> = <span class="jde-java-font-lock-number">0</span>;
<span class="comment">/** Mask to restrict the range of values within which <i></span><span class="jde-java-font-lock-italic">sequence</span><span class="comment"></i>
* may cycle.
*/</span>
<span class="jde-java-font-lock-modifier">public</span> <span class="jde-java-font-lock-modifier">final</span> <span class="type">int</span> <span class="variable-name" id="seqMask">seqMask</span> = (<span class="jde-java-font-lock-number">1</span> << <span class="jde-java-font-lock-number">20</span>) - <span class="jde-java-font-lock-number">1</span>;
<span class="comment">/**
* The access function for the sequence.
* </span><span class="jde-java-font-lock-doc-tag">@return</span><span class="comment"> the next positive sequence number. This number may wrap
* but is guaranteed to be within the range seqMask >= sequence >= 0.
*/</span>
<span class="jde-java-font-lock-modifier">public</span> <span class="type">int</span> <span class="function-name" id="getSequence">getSequence</span>() {
sequence = ++sequence & seqMask;
<span class="keyword">return</span> sequence;
}
<span class="jde-java-font-lock-modifier">public</span> <span class="function-name" id="XMLNamespaces">XMLNamespaces</span>() {
uriIndices = <span class="keyword">new</span> <span class="type">HashMap</span>(<span class="jde-java-font-lock-number">4</span>);
uris = <span class="keyword">new</span> <span class="type">ArrayList</span>(<span class="jde-java-font-lock-number">4</span>);
uriIndices.put(DefAttrNSpace, Ints.consts.get(DefAttrNSIndex));
uris.add(DefAttrNSIndex, DefAttrNSpace);
uriIndices.put(XSLNamespace, Ints.consts.get(XSLNSpaceIndex));
uris.add(XSLNSpaceIndex, XSLNamespace);
uriIndices.put(SVGNamespace, Ints.consts.get(SVGNSpaceIndex));
uris.add(SVGNSpaceIndex, SVGNamespace);
uriIndices.put(XlinkNamespace, Ints.consts.get(XLinkNSpaceIndex));
uris.add(XLinkNSpaceIndex, XlinkNamespace);
}
<span class="comment">/**
* </span><span class="jde-java-font-lock-doc-tag">@return</span><span class="comment"> size of the <tt>uris</tt> <ttArrayList</tt>.
*/</span>
<span class="jde-java-font-lock-modifier">public</span> <span class="jde-java-font-lock-modifier">synchronized</span> <span class="type">int</span> <span class="function-name" id="getUrisSize">getUrisSize</span>() {
<span class="keyword">return</span> uris.size();
}
<span class="comment">/**
* If the URI is not pre-defined, and has not been seen before, add
* it to the stored namespaces, and return the index.
* </span><span class="jde-java-font-lock-doc-tag">@param</span><span class="comment"> </span><span class="variable-name" id="uri">uri</span><span class="comment"> the namespace uri
* </span><span class="jde-java-font-lock-doc-tag">@return</span><span class="comment"> integer index of the namespace URI
*/</span>
<span class="jde-java-font-lock-modifier">public</span> <span class="jde-java-font-lock-modifier">synchronized</span> <span class="type">int</span> <span class="function-name" id="getURIIndex">getURIIndex</span>(<span class="type">String</span> <span class="variable-name">uri</span>) {
<span class="type">int</span> <span class="variable-name" id="i">i</span>;
<span class="type">Integer</span> <span class="variable-name" id="intg">intg</span> = (<span class="type">Integer</span>)uriIndices.get(uri);
<span class="keyword">if</span> (intg == <span class="jde-java-font-lock-constant" id="null">null</span>) {
<span class="comment">// update the indices
</span> i = uris.size();
<span class="comment">//System.out.println("****Adding namespace " + uri + " " + i);
</span> uriIndices.put(uri, Ints.consts.get(i));
uris.add(i, uri);
<span class="keyword">return</span> i;
}
<span class="comment">// not null - found the integer
</span> <span class="keyword">return</span> intg.intValue();
}
<span class="comment">/**
* </span><span class="jde-java-font-lock-doc-tag">@param</span><span class="comment"> </span><span class="variable-name" id="index">index</span><span class="comment"> the integer index of the namespace URI
* </span><span class="jde-java-font-lock-doc-tag">@return</span><span class="comment"> the corresponding namespace URI
*/</span>
<span class="jde-java-font-lock-modifier">public</span> <span class="jde-java-font-lock-modifier">synchronized</span> <span class="type">String</span> <span class="function-name" id="getIndexURI">getIndexURI</span>(<span class="type">int</span> <span class="variable-name">index</span>) {
<span class="keyword">return</span> (<span class="type">String</span>)uris.get(index);
}
}
</pre>
</body>
</html>
---------------------------------------------------------------------
To unsubscribe, e-mail: general-cvs-unsubscribe@xml.apache.org
For additional commands, e-mail: general-cvs-help@xml.apache.org