text:
Java JAXP, Implementing Default XSLT Behavior in Java
Java Programming Notes # 2206
- Preface
- Preview
- Some Details Regarding XSLT
- Discussion and Sample Code
- Run the Program
- Summary
- What's Next?
- Complete Program Listings
In this lesson, I will explain default XSLT behavior, and will show you how to write Java code that mimics that behavior. The resulting Java code serves as a skeleton for more advanced transformation programs.
What is JAXP?
JAXP is an
API designed
to help you write programs for creating and processing XML
documents. JAXP is
very important for many reasons, not the least of which is the
fact that it is a critical part of Sun's Java Web Services Developer
(JWSDP). As you are probably already aware, web services is
expected by many to be a very important aspect of the Internet of the
This lesson is one in a series designed to help you understand how to use JAXP and how to use the JWSDP.
The first lesson in this series was
entitled Java
API for XML Processing (JAXP), Getting Started.
previous lesson was entitled Java
JAXP, Exposing a DOM Tree.
What is XML?XML is an acronym for the eXtensible Markup Language. I will assume that you already understand XML, and will teach you how to use JAXP to write programs for creating and processing XML documents.
What are XSL and XSLT?
I provided quite a lot of background material on XSL and XSLT in a previous lesson in this series. A brief review of that material follows.
XSL is an acronym for Extensible Stylesheet language. XSLT is an acronym for XSL Transformations. The W3C is a governing body that has published many important documents on XML, XSL, and XSLT.
- Transforming non-XML documents into XML documents.
- Transforming XML documents into other XML documents.
- Transforming XML documents into non-XML documents.
You may find it useful to open another copy of this lesson in a separate browser window. That will make it easier for you to scroll back and forth among the different listings and figures while you are reading about them.
Supplementary material
I recommend that you also study the other lessons in my extensive collection of online Java and XML tutorials. You will find those lessons published at Gamelan.com. As of the date of this writing, Gamelan doesn't maintain a consolidated index of my tutorial lessons, and sometimes they are difficult to locate there. You will find a consolidated index at www.DickBaldwin.com.
A tree structure in memory
A DOM parser can be used to
create a tree structure in memory that represents an XML
document. In Java, that tree structure is encapsulated in an
object of the interface type Document. Document
and its superinterface Node declare numerous methods that can
be used to navigate, extract information from, modify, and otherwise
manipulate the DOM tree. As
is always the case, classes that implement Document must
provide concrete definitions of those methods.
Many operations are possible
Given an object of type Document, there are many
methods that
can be invoked on the object to perform a variety of operations.
For example, it is possible to write Java code to move nodes from one
location in the tree
to another location in the tree, thus rearranging the structure of the
XML document represented by the Document object. It is
possible to delete nodes, and to insert new nodes. It is
also possible
recursively traverse the tree, extracting information about the nodes
the way.
Two ways to
transform an XML document
There are at least two ways to transform the contents of an XML
document into another document:
- By writing Java code to manipulate the DOM and perform the transformation.
- By using XSLT to perform the transformation.
It should be possible to write Java code to perform any
transformation that can be performed using XSLT, but the reverse may
not be true.
description of XSLT
Here is a partial quotation from XML In A Nutshell, (which I highly recommend), by
Elliotte Rusty Harold and
W. Scott Means. This quotation provides a general description of
(XSLT) is a functional programming language used to specify how an
input XML document is converted into another text document -- possibly,
though not necessarily, another XML document. An XSLT processor
reads both an input XML document and an XSLT stylesheet (which is
itself an XML document because XSLT is an XML application) and produces
a result tree as output. ... Documents can be transformed using a
standalone program or as part of a larger program that communicates
with the XSLT processor through its API."
In this lesson, I will provide and explain a larger program that communicates
with the XSLT processor through its API. The program will also
execute Java code that mimics the transformation provided by XSLT.
and disadvantages
As is usually the case, there are advantages and disadvantages to
both approaches to
document transformation.
As an example of an advantage provided by XSLT, if it is possible to
perform the required
transformation using XSLT, that approach will probably require you to
write less code than would be required to perform the same
transformation by writing a Java program from scratch.
A large
library of functions
With the XSLT transformation process, you write a stylesheet, which
is somewhat analogous to a driver program in a more conventional
programming environment. That driver program accesses and
uses functions from a large library of pre-written functions to perform
a series of well-defined operations on the DOM tree to produce
the desired transformation.
authors don't call them functions. Rather, they are called XSLT
elements. According to XML
In A Nutshell, there are 37 standard
elements. Also according to XML In A Nutshell, most
processors also provide various nonstandard extension elements and
allow you to write your own extension elements in languages such as
Is there a
similar library of Java methods?
I am not aware of a library of Java methods in the public domain
that emulates the 37 standard XSLT Elements. However, I freely
admit that such a library may exist and I may simply not know
about it.
Therefore, to write a Java program that emulates an XSLT
transformation, you need to either
- Create your own library of Java methods and use that library with your Java code to perform the transformation, or
- Start from scratch each time and write a custom program to perform the transformation.
A skeleton
library of Java methods
This lesson, and several lessons to follow this one, will show you
how to write the skeleton of a Java library containing methods that
emulate the most common XSLT elements. Once you have the library,
writing Java code to transform XML documents consists simply of writing
a short driver program to access and use those methods. Thus,
given the proper library of methods, it is no more difficult to write a
driver Java program to perform the transformation than it is to write
XSLT stylesheet.
Library is
not my primary purpose
However, my primary purpose in these lessons is not to provide such
a library, but rather is to help you understand how to use a DOM
tree to create, modify, and manipulate XML documents. By
comparing Java code that manipulates a DOM tree with similar XSLT
operations, you will have an opportunity to learn a little about XSLT
in the process of learning how to manipulate a DOM tree using Java code.
If you already know a lot about XSLT, you may learn a little
about Java by studying these lessons. If you already know a lot
about Java, you may learn a little about XSLT. If you don't
already know either
Java or XSLT, you may learn a little about both.
XSLT can be difficult
While writing a Java program to emulate an XSLT Transformation may
require you to write more code than writing a stylesheet, in my
opinion, it is much easier to debug a Java program that fails to
deliver the desired result than it is to debug an XSL stylesheet that
fails to deliver. This is an advantage of
using Java code over XSLT. I find XSLT to be extremely difficult
to debug (but I haven't attempted to
use a fancy XSLT debugger, several of which are freely available on the
provides more detailed control
Another difference in using Java code relative to XSLT has to do
the detailed control of the transformation process. I
believe, (but cannot prove),
that it is possible to write Java programs
to provide transformations that are not possible using standard XSLT
elements. If I am correct, this may be another
advantage of writing Java code over using XSLT.
Some Details Regarding XSLT
The following is a partial quotation from XML In A Nutshell. (Note that I will be referring to
this excellent book several more times in this lesson. For
brevity, I will refer to it simply as Nutshell.)
is an XML application for specifying rules by which one XML document is
transformed into another XML document. An XSLT document -- that
is, an XSLT stylesheet -- contains template rules. Each template
rule has a pattern and a template. An XSLT processor compares the
elements and other nodes in an input XML document to the template-rule
patterns in a stylesheet. When one matches, it writes the
template from that rule into the output tree. ... XSLT uses the
XPath syntax to identify matching nodes."
Let's see if I can explain this process in my own words.
Assume that an XML document has been parsed so as to produce a DOM tree
in memory that represents the XML document. (The creation of a DOM tree in this manner
was discussed in several previous lessons
in this series.)
An XSLT processor starts examining the DOM tree at its root
node. It
obtains instructions from the XSLT stylesheet telling it how to
navigate the
tree, and what to do with each node that it encounters along the way.
matching template rules
As each node is encountered, the processor searches the stylesheet
looking for instructions on how to treat that node. (These instructions will be referred to
later as template rules.) If the processor finds
instructions that match the node type, it performs the operations
indicated by the
instructions. If it doesn't find matching instructions, it
executes built-in instructions appropriate to that node.
(An XML
document can contain seven different types of nodes. The
different types will be identified later. This lesson will
describe and explain the built-in
instructions for six of those seven node types. Java code will be
developed that emulates the built-in
instructions for each of the six types of nodes.)
the context node
An XPath expression can be
used to point to a specific node and to
establish that node as the context node. Once a context node is
established, there are at least two XSLT elements that can be used to
manage the traversal among children of that node:
- xsl:apply-templates
select, optional attribute
mode, optional attribute
xsl:sort, optional XSLT element
- xsl:for-each
select, required attribute
xsl:sort, optional XSLT element
xsl:apply-templates XSLT element
The first of these, xsl:apply-templates,
examines and processes all child nodes of the context node that match
an optional select
combined with a default template rule to be discussed later, this often
results in a recursive examination and processing of all descendant
nodes of the context node.)
According to Nutshell,
xsl:apply-templates instruction tells the processor to search for and
apply the highest-priority template in the stylesheet that matches each
node identified by the select attribute."
template rules
As each node is examined, the processor searches the stylesheet to
determine if the XSLT programmer has provided a template rule that
matches the node and defines how that
node should be treated. If a matching template rule is found, the
node is treated in the manner prescribed by the template rule.
Literal text
in the XSLT stylesheet elements
You can think of the XSLT process as operating on an input DOM tree
to produce an output DOM tree. If the template rule being applied
contains literal text, that literal text is used to
create a text node in the output tree.
(I will
explain how this feature is used to transform XML documents into XHTML
documents in a future lesson.)
If no match
is found
If a matching template rule is not found, the processor executes a
built-in template rule appropriate to the type of node involved.
Built-in template rules are provided by the XSLT processor to handle
the seven different types of nodes in an XML document:
- root node
- element node
- attribute node
- text node
- comment node
- processing instruction node
- namespace node
This lesson will explain the built-in rules that handle the first
six types of nodes in the above list.
Recursion is
As mentioned earlier, the combination of xsl:apply-templates and a built-in
template rule often produces recursion. Assuming that there is
nothing in a matching template rule that stops
the recursion operation, recursion continues until all descendant nodes
of the original context node have been examined and processed.
The mode
The mode attribute of xsl:apply-templates makes it
possible to cause different template
rules to match nodes of the same type at different places in the DOM
The optional xsl:sort
element makes it possible to modify the
order in which the nodes are examined.
The second XSLT element in the above list, xsl:for-each, executes an iterative
examination and processing of all child nodes of the context node that
match the required select attribute.
According to Nutshell,
xsl:for-each instruction iterates over the nodes identified by its
select attribute and applies templates to each one."
In other words, the processor will examine all child nodes of the
context node that match the select
attribute. As each child node is examined, the processor will
search the stylesheet looking for a template rule that matches the
child node. If a matching template rule is found, the matching
template rule will be used to process that
If a matching template rule is not found, a built-in template rule
appropriate for the type of node will be used to process the node.
As before, the optional xsl:sort
element makes it possible to modify the
order in which the nodes are examined. I will explain this in
detail in a future lesson.
Frequently a stylesheet will combine recursive and iterative
operations to produce more complex operations.
Enough talk, let's see some code
I will begin by discussing the XML file named Dom11.xml (shown in Listing 29) along with
the XSL
stylesheet file named Dom11.xsl
(shown in Listing 30).
These two listings are provided near the end of the lesson.
After explaining the transformation produced by applying this stylesheet to this XML document, I will explain the transformation produced by applying the empty stylesheet named Dom11a.xsl, (shown in Listing 33), to a nearly identical XML document.
A Java program named Dom11
Following that, I will explain a Java program (shown in Listing 31) that emulates the behavior of the stylesheets shown in Listings 30 and 33 when applied to the XML file shown in Listing 29.
I will explain that the Java program shown in Listing 31 emulates the behavior of the empty stylesheet shown in Listing 33, and will explain why that is true.
Discussion and Sample Code
The XML file shown in Listing 29 is relatively straightforward. A tree view of that XML file is shown in Figure 1.
The values of the text nodes in Figure 1 were manually highlighted in red to make it easier to refer to those values later in this lesson.)
#document DOCUMENT_NODE
Figure 1
A database of books
As you may already have figured out, this XML document represents a small database containing information about books. However, the structure and content of this XML file was not intended to have any purpose other than to illustrate the default behavior of the built-in XSLT template rules.
The XSL stylesheet file named Dom11.xsl
The stylesheet file shown in Listing 30 is very important relative to the purpose of this lesson, so I will discuss it in detail.
Recall that an XSL stylesheet is itself an XML file, and can therefore be represented as a tree. I will begin by showing you an abbreviated version of a tree view of the stylesheet, as shown in Figure 2.
#document DOCUMENT_NODE
Figure 2
Why abbreviated?
The reason that I refer to this as an abbreviated version is because I manually deleted comment nodes and extraneous text nodes in order to emphasize the important elements in the document.
The root element
The root node of all XML documents is the document node. However, in addition to the root node, there is also a root element.
As you can see from Figure 2, the root element in the XSL document is of type xsl:stylesheet. The root element has two attributes, each of which is standard for XSL stylesheets.
The first attribute points to the XSLT namespace URI, which you can read about in the W3C Recommendation. The second attribute provides the XSLT version. According to Nutshell, the version must be 1.0. Also, according to Nutshell,
Unable to verify this behavior
I have been unable to verify this behavior experimentally. When I delete a character from the XSL namespace URI and then load the XML file into IE 6.0, there is simply no output. The browser screen remains blank. When I modify the XSL namespace URI and attempt to use JAXP to apply the stylesheet to the XML file, the system throws several errors and the program aborts. Neither approach seems to "output the stylesheet itself" as indicated by Nutshell.
Children of the root element node
As you can see from Figure 2, the root element node has two child nodes, both of which are of type xsl:template. Here is what XSLT and XPath On The Edge by Jeni Tennison has to say about xsl:template:
As you can see from the attribute values in Figure 2, a match pattern is provided for both of the xsl:template nodes in Figure 2.
Back to basics
Getting back to XSLT basics, whenever the XSLT processor encounters a node while traversing the DOM tree, it will examine all of the template rules in the stylesheet searching for one whose match pattern matches the node. If it finds a matching template rule, it will execute the instructions contained as elements within the template rule. If it doesn't find a match, it will execute a built-in template rule that matches the node.
An explicit representation of a built-in template rule
Consider the first child node of the xsl:stylesheet root element in Figure 2. Listing 1 shows this template rule in XSL syntax, (extracted from Listing 30).
<xsl:template match="*|/">
Matching the root node and element nodes
Consider the match pattern for this template rule (the text value of the attribute named match). According to Nutshell,
The forward slash / is an XPath pattern that matches the root node.
This is the first node the processor selects for processing, and therefore this is the first template rule the processor executes (unless a nondefault template rule also matches the root node).
... the vertical bar combines these two expressions so that it matches both the root node and element nodes."
The <xsl:apply-templates/> element
Now consider the <xsl:apply-templates/> element that makes up the body of this template rule. This element causes the processor to process all child nodes of each matching node, examining nodes, searching for matching template rules, and executing the elements embedded in matching template rules along the way. Again, according to Nutshell, still speaking of the template rule in Listing 1,
An explicit representation of a built-in template rule
Once again, the template rule shown in Listing 1 is an explicit representation of one of the built-in template rules. If I were to remove this template rule from the stylesheet, and then apply the stylesheet to the XML document, this template rule would still be applied where appropriate by the XSLT processor, because it is built into the processor.
Handling text nodes by default
Listing 2 shows the template rule, in XSL syntax that corresponds to the second child node of the root element node in Figure 2. Once again, this is a template rule with a match pattern. This template rule is also an explicit representation of one of the built-in rules, which copies the value of text and attribute nodes into the output document.
<xsl:template match="text()|@*">
The text() in the value of the attribute named match is an XPath pattern matching all text nodes. The @* is an XPath pattern matching all attribute nodes. The vertical bar combines the two patterns. Hence, the template rule matches all text and all attribute nodes.
The xsl:value-of element
Once a match is made, the behavior of the rule is governed by the single element that is embedded in the rule. The xsl:value-of element, with a select value of "." returns the text value of the context or current node. (This is similar to the use of a single period to represent the current directory in some file management systems such as MSDOS.)
Text value to the output
Therefore, whenever the XSLT processor applies this template rule to a text or attribute node, the text value of that node is sent to the output document (a text node is created in the output tree).
If the node is a text node, the value is simply the text in the node.
If the node is an attribute node, the value is the attribute value, but not the attribute name.
The output
Now it's time for the big question. What does the output look like when the stylesheet shown in Listing 30 is used to transform the XML document shown in Listing 29? The result of such a transformation is shown in Figure 3.
<?xml version="1.0" encoding="UTF-8"?>
Figure 3
The XML declaration
The first line in Figure 3 is an XML declaration that was placed there by the XSLT processor independent of the content of the XML file.
The text in the output
If you compare the text in Figure 3 with the material highlighted in red in Figure 1, you will see that the output produced by this stylesheet containing only explicit representations of default template rules is the concatenation of text values for all the element nodes in the XML document.
Line breaks in the output
The two line breaks following the words Java and rules in Figure 3 correspond to the line breaks in the text portion of the title element shown in Listing 3. (This element was extracted from the original XML file in Listing 29.)
The remaining line breaks in the XML file shown in Listing 29 occur between XML tags. Therefore, they are not considered to be a part of the text content of any element and they do not appear in Figure 3.
No attribute values in the output
You may have noticed that even though a couple of the elements in the XML file have attributes (see Figure 1), and one of the template rules matches attribute nodes, the attribute values do not appear in the output shown in Figure 3. Nutshell explains this in the following way:
Nutshell goes on to tell us,
Finally, Nutshell tells us,
Applying an empty stylesheet
Now consider the stylesheet shown in Listing 33, as shown in abbreviated tree format in Figure 4.
#document DOCUMENT_NODE
Figure 4
Unlike Figure 2, the stylesheet represented by Figure 4 doesn't contain any template rules. In fact, except for the root (document) node and the xsl:stylesheet root element node, the stylesheet is completely empty.
Produces exactly the same output
However, the result of applying the empty stylesheet to the XML file discussed earlier produces exactly the same result as was produced by applying the stylesheet shown in Listing 30 and Figure 2 to that XML file.
This is because the two template rules shown in Listing 30 and Figure 2 replicate the behavior of two of the built-in template rules. Therefore, removing them from the stylesheet has no impact on the result produced by applying the stylesheet to the XML file. If they are needed, they are available as built-in rules of the XSLT processor.
Transformation behavior of an empty stylesheet
Because the two template rules in the previous stylesheet replicate the behavior of two of the built-in template rules, removing those template rules from the stylesheet to produce an empty stylesheet had absolutely no impact on the transformation result. The transformation result produced by the previous stylesheet was identical to those produced by the empty stylesheet.
According to Nutshell, when you transform an XML document using an empty stylesheet,
Combined output
Whenever the XSLT processor encounters a node for which you haven't defined a matching template rule, the default template rule for that type of node will be applied. Therefore, the total output is often a combination of output produced by template rules that you provide and built-in template rules.
Therefore, if you are going to create a stylesheet containing template rules of your own design, it is very important for you to understand the default behavior provided by the built-in template rules. The total output produced by your stylesheet is very likely to be a combination of the output produced by your template rules and the output produced by the built-in template rules.
Other built-in template rules
I have explained the behavior of the built-in template rules that cover the following four types of nodes:
- root node
- element node
- attribute node
- text node
- comment node
- processing instruction node
A Java program that emulates the built-in template rules
Now let's change direction and concentrate on Java code rather than XSLT elements. The following paragraphs describe a Java program named Dom11.
The primary purposes of this lesson are to:
- Demonstrate Java code that replicates the behavior of the built-in template rules for six of the seven possible types of nodes.
- Provide a skeleton program that can be expanded later to provide more complex behavior.
As such, the program serves as the skeleton for the definition of custom template rules.
Behavior of the program
As written, this program extracts and concatenates all text values from a specified XML file, and writes that text into a result file, using two different approaches:
- An XSLT transformation operating under program control.
- Program code that emulates the behavior of the XSLT transformation.
As you saw in the earlier discussion, both XSL files produce the same result when processed against the XML files named Dom11.xml and Dom11a.xml, demonstrating the behavior of the built-in template rules. The execution of these built-in template rules causes the contents of every text node to be concatenated and written into the result file.
The program code in this program emulates those built-in template rules and produces the same results.
Usage instructions
The program requires three command line arguments in the following order:
- The name of the input XML file - must be Dom11.xml or Dom11a.xml.
- The name of the output file to be produced by the XSLT transformation.
- The name of the output file to be produced by the program code that emulates the XSLT transformation.
The program begins by executing code to transform the incoming XML file in a way that mimics the XSLT transformation. Along the way, it saves the processing instructions, (one of which contains the name of the stylesheet file), for later use by the code that governs the XSLT transformation process. (Otherwise, the code that performs the XSLT transformation later would have to search the DOM tree for the XSL stylesheet file name.)
The name of the XSL stylesheet file is extracted from the processing instruction in the XML file. Then the program uses the XSL style sheet to transform the XML file into a result file.
Errors, exceptions, and testing
No effort was made to provide meaningful information about errors and exceptions. If an error or exception occurs, the default behavior for that error or exception will occur.
The program was tested using SDK 1.4.2 under WinXP.
Will discuss in fragments
I will discuss this program in fragments. A complete listing of the program is shown in Listing 31 near the end of the lesson.
Listing 4 shows the beginning of the class named Dom11 and the beginning of the main method.
public class Dom11{
Then the code in Listing 4 provides usage instructions based on command-line arguments.
Parse the input XML file
The code in Listing 5 parses the input XML file, producing an object of type Document, which is a DOM tree in memory.
There is nothing new in the code in Listing 5. I have discussed the code required to create a Document object in several previous lessons beginning with the lesson entitled Java API for XML Processing (JAXP), Getting Started.
As you saw in those earlier lessons, creating a Document object involves three steps:
- Create a DocumentBuilderFactory object
- Use the DocumentBuilderFactory object to create a DocumentBuilder object
- Use the DocumentBuilder object to create a Document object
Transformation through program code
The code in Listing 6 begins the process of transforming the DOM tree into an output file through the execution of program code (as opposed to an XSLT transformation).
The code begins by instantiating a new object of the Dom11 class.
Dom11 thisObj = new Dom11();
Then the program gets an output stream for the output produced by the program code. This stream points to an output file that was specified by the third command- line parameter.
Process the DOM tree
The code in listing 7 invokes the processDocumentNode method to process the DOM tree. This method (and the methods that it calls) begins with the Document node, and processes all the nodes in the DOM tree to produce the required output.
Set the main method aside
My explanation of this program will follow the execution thread through the program. At this point, I will set the discussion of the main method aside temporarily and come back to it later when the processDocumentNode method returns control to the main method.
The processDocumentNode method
The entire processDocumentNode method is shown in Listing 8.
void processDocumentNode(Node node){
Invoke the processNode method
Despite the name that I chose to give to the processDocumentNode method, it doesn't actually process the document node directly. Rather after sending any required text to the output, it invokes the method named processNode to actually process the document node.
When the DOM tree has been processed ...
When the processNode method returns, (after the entire DOM tree has been processed), the processDocumentNode method flushes the output stream and returns control to the main method.
As you will see later, subsequent code in the main method invokes a method that will perform an XSLT transformation on the XML file and write the output into a different output file. I will discuss that method later in this lesson.
The processNode method
There are seven possible types of nodes in an XML document:
- root or document node
- element node
- attribute node
- text node
- comment node
- processing instruction node
- namespace node
Get and save the node type
The beginning of the processNode method is shown in Listing 9. Note that the method receives an incoming parameter, which is a reference to an object as type Node. This can include any of the seven node types that can occur in a DOM tree.
If the parameter doesn't point to an actual object, the method simply returns, as opposed to throwing a NullPointerException.
void processNode(Node node){
Process the node
Each time the processNode method is invoked, it receives a Node object's reference as an incoming parameter. The code in Listing 9 determines the type of the incoming node. Listing 10 shows the beginning of a switch statement that is used to initiate the processing of each incoming node based on its type.
switch (type){
The DOCUMENT_NODE case
The code in Listing 10 will be executed whenever the incoming method parameter points to a document node.
DOCUMENT_NODE is a constant (public static final variable) that is defined in the Node interface. (The interface provides similar constants for all node types other than namespace nodes.) These constants can be used to distinguish between different node types.
Will invoke default behavior in this case
Note that the code in the case in Listing 10 is an if/else construct. If the conditional clause in the if statement evaluates to true (which is not possible in this case), the code in the if statement will be executed. (This is where I will place the code for custom template rules in subsequent lessons.)
If the conditional clause in the if statement does not evaluate to true, the code in the else statement will be executed. (This is where I have placed the code that mimics the built-in template rules.)
Note that the code in the else statement in Listing 10 invokes a method named defElOrRtNodeTemp. When I discuss this method momentarily, you will see that its behavior mimics one of the built-in template rules that I discussed earlier in this lesson. Before getting to that, however, I want to give you a preview of how I will define custom template rules in future lessons.
Creating custom template rules
As you will see in subsequent lessons, the process for creating a custom template rule is as follows:
- Go to the method named processNode, which I am discussing right now.
- Identify the case for the node type in the switch statement.
- Change the conditional clause in the if statement for that case to implement a match for a particular node of that type.
- Write code in the body of the if statement to implement the custom template rule.
The ELEMENT_NODE case
Before getting to the discussion of the method named defElOrRtNodeTemp, I want to show you the ELEMENT_NODE case in Listing 11.
case Node.ELEMENT_NODE:{
As before, the code in the if statement is not reachable in this program.
The method named defElOrRtNodeTemp
Still following the execution thread, I will set my discussion of the switch statement aside temporarily and discuss the method named defElOrRtNodeTemp. As mentioned above, this method is invoked as the default behavior for document nodes and element nodes in Listings 10 and 11.
I will return to my discussion of the switch statement shortly.
The entire method named defElOrRtNodeTemp is shown in Listing 12.
void defElOrRtNodeTemp(Node node)
This method mimics the behavior of the built-in XSLT template rule shown in Listing 1, and repeated in Figure 5 below for convenient viewing.
<xsl:template match="*|/">
Figure 5
As I indicated earlier, the match pattern for this template rule matches the document node and all element nodes.
Code is straightforward
The code in this method is relatively straightforward. First it tests to confirm that the incoming parameter points to a node of the correct type, and throws an exception if the incoming parameter is not of the correct type.
If the incoming parameter is of the correct type, the code in the method invokes a method named applyTemplates passing the node as a parameter to that method.
The method named applyTemplates
Continuing to follow the execution thread, I will now discuss the method named applyTemplates, shown in Listing 13.
void applyTemplates(Node node,String select){
The applyTemplates method partially emulates the XSLT apply-templates rule discussed earlier in this lesson, and shown in Figure 6.
Figure 6
The apply-templates rule has two attributes, select and mode.
As I explained earlier in this lesson,
Behavior of the method named applyTemplates
The applyTemplates method shown in Listing 13 receives two incoming parameters:
- The context node.
- The select parameter.
The code in Listing 13 invokes the getChildNodes method on the context node to get a list of all child nodes of the context node. If there are no child nodes, it quietly returns.
A recursive method call
If there are child nodes, the method uses a for loop to process all child nodes that match the select parameter as described above.
For each matching child node, the applyTemplates method makes a recursive call to the method named processNode, passing the child node's reference as a parameter to the processNode method.
Return to defElOrRtNodeTemp method
Eventually, the recursive process will end, and control will return to the defElOrRtNodeTemp method shown in Listing 12. From there, control will return to either the DOCUMENT_NODE case or the ELEMENT_NODE case in the switch statement in Listing 10 or Listing 11 from which the defElOrRtNodeTemp method was called.
That, in turn, brings us back to a discussion of the other cases in the switch statement.
The TEXT_NODE and ATTRIBUTE_NODE cases
The next two cases from the switch statement that I will discuss are shown in Listing 14. (The switch statement began in Listing 10)
Listing 14 shows the cases for text nodes and attribute nodes. I have grouped these two cases together because the default behavior of both cases is to invoke the method named defTextOrAttrTemp, and to send the String returned by that method to the output.
case Node.TEXT_NODE:{
Once again, following the execution thread, I will now discuss the method named defTextOrAttrTemp method. This method is called whenever:
- The processNode method is called with a reference to either a text node or an attribute node, and.
- The default behavior for the node type is executed.
String defTextOrAttrTemp(Node node)
This method emulates the built-in XSLT template rule shown in Listing 2 and repeated in Figure 7 below for convenient viewing.
<xsl:template match="text()|@*">
Figure 7
As I told you earlier, this template rule matches all text nodes and all attribute nodes. Therefore, the defTextOrAttrTemp method is invoked by the default behavior of either the TEXT_NODE case or the ATTRIBUTE_NODE case in the switch statement in Listing 14.
Similar behavior
Once again, note the similarity between the method named defTextOrAttrTemp in Listing 15 and the template rule shown in Figure 7.
In Figure 7, the template rule executes the xsl:value-of XSLT element to send the value of the context node to the output.
The method shown in Listing 15 invokes a method named valueOf, passing "." as a parameter (note the period between the quotation marks). The value returned by that method is sent to the output by the code in the default behaviors of the two cases in Listing 14.
The method named valueOf
The method named valueOf, which begins in Listing 16, is fairly complex. I will discuss portions of this method in this lesson and will discuss the remainder of the method in subsequent lessons.
This method emulates an <xsl:value-of select="???"/> XSLT element.
Three forms of method call
The method requires two parameters. The first parameter is of type Node, and is the context node. The second parameter is of type String and is a select parameter.
The valueOf method recognizes three forms of call:
- valueOf(Node theNode,String "@attrName")
- valueOf(Node theNode,String ".")
- valueOf(Node theNode,String "nodeName")
In the second form, which is the only form actually used in this program, the value of the select parameter is a String containing a single period. In this form, the method returns the concatenated text values of the context node and all descendants of the context node (including text nodes that are children of the context node).
In the third form, the method returns the concatenated text values of all descendants of a specified child node of the context node. If the context node has more than one child node with the specified name, only the first one found is processed. The others are ignored.
Features not supported
The valueOf method does not support the following features, which are standard features of the xsl:value-of XSLT element:
- disable-output-escaping
- processing instruction nodes
- comment nodes
- namespace nodes
Since the second form of call listed above is the only form actually used in this program, I will discuss only those portions of the method that support that form. I will defer discussion of the other portions of the method until they are used in subsequent lessons.
Process the context node
The code in Listing 16 picks up at the point where it is determined that the incoming value for select is a String object's reference with a value of "." (note the period between the quotation marks). This is a request to return the value of the context node.
This method supports two possibilities for the context node:
- Element node - return the concatenated text values of all descendant nodes of the context node.
- Text node - return the text value of the text node.
When the context node is an element node ...
The code in Listing 16 shows the beginning of the code required to process the context node as an element node.
public String valueOf(Node node,String select){
In preparation for processing all descendant nodes of the context node, the code in Listing 17 gets a list of child nodes, along with the length of the list.
In addition, the code in Listing 17 initializes a String variable named nodeTextValue that will be used to collect the concatenated text values of the descendant nodes. Note that this variable is initialized to contain an empty string.
NodeList childNodes =
Having gotten a list of child nodes of the context node, all that is required to accomplish the objective is to make a series of recursive calls to the valueOf method, passing each child node in turn to the valueOf method as shown in Listing 18.
for(int j = 0; j < listLen; j++){
The code in Listing 18 also deals with concatenation. The value returned from each call to the valueOf method is concatenated with the text value already stored in the variable named nodeTextValue.
Finally, after all child nodes have been processed, the code in Listing 18 returns the concatenated value stored in the variable named nodeTextValue.
When the context node is a text node ...
If you understood all of the above, (including the recursion), you should find it easy to understand the code shown in Listing 19. Listing 19 shows the case where the context node is a text node.
}else if(nodeType == Node.TEXT_NODE){
One other possibility
There is one other possibility that is handled by the code in Listing 20. That possibility is that the context node is neither a text node nor an element node. In that case, the valueOf method returns an empty string.
Returning to the switch statement that began in Listing 10, we find two additional cases, each of which invokes the same method by default:
case Node.COMMENT_NODE:{
I will discuss the defComOrProcInstrTemp method shortly. First, however, I will explain the extra code that appears in the default portion of the processing instruction node case in Listing 21.
The purpose of a processing instruction in an XML file is to provide instructions to processing programs such as this one. The XML file shown in Listing 29 contains the three processing instructions shown in Listing 22.
<?dummy-target dummy-data="def"?>
The first and third of the three processing instructions are dummy processing instructions put there to test the capabilities of this program. However, the processing instruction in the middle is a real processing instruction that specifies the name of the file containing a stylesheet. That stylesheet will be used later when this program causes an XSLT transformation to take place using the XML file in Listing 29, and the stylesheet file identified in Listing 22. (That stylesheet actually appears in Listing 30.)
In order to use that processing instruction to identify the stylesheet file, this program must capture the processing instruction and extract the file name from the processing instruction. A statement in the second case in Listing 21 causes references to all processing instruction nodes to be added to and saved in static variable of the Dom11 class named procInstr.
That information will be used later to extract the name of the stylesheet file from the processing instruction.
The defComOrProcInstrTemp method
Both of the switch cases shown in Listing 21 invoke this method as their default behavior. A complete listing of the defComOrProcInstrTemp method is shown in Listing 23.
String defComOrProcInstrTemp(Node node)
Figure 8
According to Nutshell, the built-in template rule for comments and processing instructions doesn't output anything into the output tree. Therefore, the defComOrProcInstrTemp method shown in Listing 23 simply returns an empty string.
The namespace node case
The default case for the switch statement begun in Listing 10 is shown in Listing 24.
Also, here is what Nutshell has to say about the built-in template rule for namespace nodes:
Therefore, the default case in Listing 24, which catches all namespace nodes, doesn't send anything to the output.
End of the processNode method
I have discussed everything of significance in the processNode method. Continuing to follow the execution thread, I will now turn my attention back to the main method.
Perform an XSLT transformation
After the code has been executed to process the document using program code (beginning with the invocation of the processDocumentNode method in Listing 7), the statement in Listing 25 invokes the doXslTransform method to cause the XML document to be transformed using the stylesheet identified in one of the processing instructions in the XML file.
The success of the method call in Listing 25 depends on the stylesheet processing instruction having been saved while the document was being processed. Otherwise, it would be necessary to add code in this method to search the DOM tree for the stylesheet processing instruction.
All processing instructions are saved in a Vector object by this program. The Vector object's reference is passed as the third parameter to this method. The first parameter is a reference to the Document or root node in the DOM tree. The second parameter is the name of the output file.
The doXslTransform method
The doXslTransform method begins in Listing 26. This method uses an XSLT stylesheet file to transform an incoming Document object into an output file. A large portion of the code in this method is dedicated to:
- Identifying the processing instruction containing the stylesheet information.
- Extracting the stylesheet information from the processing instruction.
The code in Listing 26 searches the Vector object seeking a processing instruction node that contains a stylesheet reference.
void doXslTransform(Document document,
To see how this code works, first take a look at the processing instruction in the XML file that contains the stylesheet reference. This processing instruction was shown in Listing 22, and is repeated below in Figure 9 for convenient viewing.
Figure 9
The purpose of a processing instruction is to provide information to processing programs that will be used to process the XML file.
Format of a processing instruction
According to Nutshell,
Applying this knowledge to the stylesheet processing instruction in Figure 9, you can see that the target consists of the following text: xml-stylesheet.
Accessing the target and the data
The target of a processing instruction node can be accessed in Java by invoking the getTarget method on the processing instruction node's reference.
The remainder of the text in the processing instruction can be accessed by invoking the getData method on the same reference.
The code in Listing 26 examines each of the objects in the Vector, invoking getTarget and getData, searching for a processing instruction whose target and data match that which is known to be true for a stylesheet. When a match is found, the code breaks out of the for loop.
If no match is found, the code in Listing 26 throws an exception.
Extract the stylesheet file name
Having identified the processing instruction that contains the stylesheet reference, the code in Listing 27 uses the getData method of the ProcessingInstruction interface, along with some methods of the String class to extract the name of the file containing the stylesheet.
String xslFile = pi.getData().
Do the XSLT transformation
The remaining code in the doXslTransform method is shown in Listing 28.
//Get a TransformerFactory object
The code in Listing 28 is not new to this series of lessons. This code was discussed in detail in the earlier lesson entitled Getting Started with Java JAXP and XSL Transformations (XSLT). Therefore, other than to point out one difference relative to the previous code, and to review the steps involved, I won't discuss the code in Listing 28 further in this lesson.
Steps for creating a Transformer object
The following two steps are required to create a Transformer object. Once a Transformer object is available, it can be used to transform one DOM tree into another DOM tree.
- Create a TransformerFactory object by invoking the static newInstance method of the TransformerFactory class.
- Invoke the newTransformer method on the TransformerFactory object.
There is one important difference between the code in Listing 28 and the code in the earlier lesson. The two programs invoke different overloaded versions of the newTransformer method of the TransformerFactory class.
The earlier lesson entitled Getting Started with Java JAXP and XSL Transformations (XSLT) invoked a version that took no parameters and returned a Transformer object that simply copies a source tree to a result tree.
The code in Listing 28 invokes a version of the newTransformer method that takes the stylesheet file as an input parameter and returns a Transformer object that uses the stylesheet file to perform an XSLT transformation.
That concludes the discussion of the program named Dom11.
Run the Program
I encourage you to copy the Java code, XML files, and XSL files from the listings near the end of this lesson. Compile and execute the programs. Experiment with them, making changes, and observing the results of your changes.
SummaryI explained default XSLT behavior and showed you how to write Java code that mimics that behavior. The resulting Java code serves as a skeleton for more advanced transformation programs.
What's Next?
In the next lesson, I will show you how to write a Java program that mimics an XSLT transformation for converting an XML file into a text file. I will also show that once you have a library of Java methods that emulate XSLT elements, it is no more difficult to write a Java program to transform an XML document than it is to write an XSL stylesheet to transform the same document.
Complete Program Listings
<?xml version="1.0"?>
<?xml version='1.0'?>
/*File Dom11.java
<?xml version="1.0"?>
<?xml version='1.0'?>
Copyright 2004, Richard G. Baldwin. Reproduction in whole or in part in any form or medium without express written permission from Richard Baldwin is prohibited.
About the authorRichard Baldwin is a college professor (at Austin Community College in Austin, TX) and private consultant whose primary focus is a combination of Java, C#, and XML. In addition to the many platform and/or language independent benefits of Java and C# applications, he believes that a combination of Java, C#, and XML will become the primary driving force in the delivery of structured information on the Web.
Richard has participated in numerous consulting projects, and he frequently provides onsite training at the high-tech companies located in and around Austin, Texas. He is the author of Baldwin's Programming Tutorials, which has gained a worldwide following among experienced and aspiring programmers. He has also published articles in JavaPro magazine.
Richard holds an MSEE degree from Southern Methodist University and has many years of experience in the application of computer technology to real-world problems.
This article was originally published on February 17, 2004
IT Solutions Builder TOP IT RESOURCES TO MOVE YOUR BUSINESS FORWARD
Which topic are you interested in?
Data Storage
IT Management
What is your company size?
What is your job title?
What is your job function?
Searching our resource database to find your matches...


text:
From the moment Louise and I first spoke we were on the same page about what we speculated for Kate's wedding gown. We reviewed designs I previously featured here, talked about our visions and I even texted her a picture of some rough sketches in the middle of the night, just so she could see how it was coming along since there was certainly not much time for changes.
Kate has a clear style of classic-traditional. Louise and I agreed that the overall silhouette of her gown would be a simple A-line but large enough to not get swallowed by the cathedral setting. She'd have long lace sleeves and her shoulders and chest would be covered as well. The design would be "modest," and not revealing or inappropriate. It would include couture detailing such as a perfectly contoured and fitted bodice with hand embroidery and/or lace appliqué along the bottom of the skirt and along the train. We also included a delicate and simple tiara, beaded waistband, and a polished and modern bouquet of white flowers and greenery. We knew her dress, train and veil would be beautiful, but certainly nowhere near as opulent as Diana's.
It was such a thrill to collaborate with Louise, I've been such a admirer of hers and have actually turned many of my "fashion friends"on to her by sending her vogue.com video and her website. I have also been a avid Nate follower ever since he first stepped onto Oprah's stage 9 years ago. (A little while back I gushed about him here.)
I know I'll never forget the feeling I had sitting in the audience beside my friend Renaldo and my mom (who actually happened to be visiting from California that same week,) and at the risk of sounding cheesy, it really was a "Secret" moment. I honestly feel like I put it out there, and look what happened. Seeing my fashion illustrations on television was incredible and I just know its the first of many. (But how lucky am I that Nate was my first. ;) When the show aired last week my mom sent me a text saying she was crying with pride. I picked up the phone and called her, but she promptly hung up on me because "the show was on!"For a closer look at all the sketches you can click on over to the Nate Berkus Show website. I'm working on a new illustration based off Kate's real look from the wedding, which I'll share and add to my etsy shop soon. (Sorry if I rambled on, I normally try to keep posts short!)

subset: commoncrawl


text:
Industry News and Articles
Collaborator On Board:
Sponsors On Board:
Allied World Assurance Company Holdings
Bloomberg BNA Environmental Due Diligence Guide
Brownfield Listings
Buchanan Ingersoll Rooney PC
Collateral Status
Dechert, LLP
Environmental Liability Transfer, Inc.
Goodwin Procter
Langan Engineering & Environmental Services
New York State Bar Association
Risk Management Technologies, Inc.
Schnapf LLC
Synergy Environmental Inc.
Tokio Marine Specialty Environmental
WCD Group
EPA Issues Rule to Reduce Water Pollution from Construction Sites The U.S. Environmental Protection Agency today issued a final rule to help reduce water pollution from construction sites. The agency believes this rule, which takes effect in February 2010 and will be phased in over four years, will significantly improve the quality of water nationwide. Construction activities like clearing, excavating and grading significantly disturb soil and sediment. If that soil is not managed properly it can easily be washed off of the construction site during storms and pollute nearby water bodies. The final rule requires construction site owners and operators that disturb one or more acres to use best management practices to ensure that soil disturbed during construction activity does not pollute nearby water bodies. In addition, owners and operators of sites that impact 10 or more acres of land at one time will be required to monitor discharges and ensure they comply with specific limits on discharges to minimize the impact on nearby water bodies. This is the first time that EPA has imposed national monitoring requirements and enforceable numeric limitations on construction site stormwater discharges. Soil and sediment runoff is one of the leading causes of water quality problems nationwide. Soil runoff from construction has also reduced the depth of small streams, lakes and reservoirs, leading to the need for dredging.
Return to Search ResultsNameCategory Building Energy Disclosure Laws Push Companies to Hire News"Cluster Approach" to Cleanup May Launch Site ReuseNews20-acre Reading brownfield to be cleaned, redevelopedArticles2006 Hot Button Issues in Environmental Due DiligenceArticlesAAI: All A Matter of Perspective?ArticlesAdministrative Order Not Sufficient for Contribution ClaimArticlesAll Appropriate Rule Out for Public CommentArticlesAnother Court Strikes Down a Superfund Contribution CaseArticlesArctic Undergoing Rapid Ice Melt That Could Speed Global Warming: StudyArticlesAsarco Deal Highlights Benefits of Liability Transfer StrategyArticlesAsh Pond Closures Update - October 2016NewsASTM Addresses Fundamental Conflict over Vapor IntrusionArticlesBankruptcy Cases Dismissed After Court Finds 'Bad Faith' ArticlesBankruptcy Cases Dismissed After Court Finds 'Bad Faith'NewsBFPP Affiliation LanguageNewsBNA Interview with Jeff TelegoArticlesBNA to Co-Sponsor ConferenceArticlesBrownfield Partners and EnviroFinance Group Join Forces to Boost Distressed Asset Redevelopment Across the United StatesNewsBrownfield Partners and EnviroFinance Group Join Forces to Boost Distressed Asset Redevelopment Across the United States NewsBrownfields: Progress Made, But Further Actions NeededArticlesBuying Distressed Assets out of BankruptcyArticlesCabot Corporation Agrees to Spend Over $84 Million to Control Harmful Air Pollution at Texas, Louisiana FacilitiesArticlesCase LawArticlesCase Law – Hydraulic FrackingArticlesCDC Acquires 425-Acre Distressed Steel Mill and Plans RedevelopmentNewsCDC Purchases AEP Power Plant, ELT Assumes Environmental LiabilitiesNewsCDC Reaches Major Milestone in the Reclamation of St. Louis QuarryArticlesCERCLA's BFPP Protections in QuestionArticlesChanges to Michigan's Environmental Cleanup Program Coming Soon ArticlesChanges to Michigan's Environmental Cleanup Program Coming SoonNewsCity & County of Denver and Adams County AgreeArticlesClaims Against Railroads Survive Arranger Liability RuleArticlesCommercial Development Company, Inc. Acquires 725-Acre Coal-Fired Power Plant, Prepares Site for Potential Development as Indiana's Fourth PortNewsCommercial Development Company, Inc. Purchases 108-Acre Heavy-Industrial Waterfront Site in Antioch, CA for RedevelopmentNewsCommercial Development Company, Inc. Purchases 468-Acre Retired Coal-Fired Power Plant from AEP, Assumes Environmental Liabilities, Plans Demolition and RedevelopmentNewsConsultant Says Market Remains UncertainArticlesContamination Not Required for Damage AwardArticlesCORPORATE SUSTAINABILITY IN THE UNITED STATES AND IMPROVING YOUR
"CORPORATE PROFILEArticlesCourt Affirms Judgment, Orders $3.1 Million PaymentArticlesCourt Affirms Judgment, Orders $3.1 Million PaymentNewsCourt Directed to Reconsider If Aviall May Recover Its CostsArticlesCourt Orders Jackson to Issue Final Air Permit, Likely Bypassing EAB Court Reverses Revocation of NFA Letter ArticlesCourt Rules on 3 Year Time Period for CERCLA Contribution ActionsArticlesCredit Crisis, Distressed Market Impacting Brownfield Sites, Redevelopment ArticlesCurrently Being Updated...ArticlesDeath of Green Card Program Could Halt Brownfields ProjectsArticlesDeterring Citizen Suits: Remedies for Unsubstantiated ClaimsArticlesDevelopments EPA Lists Major Industries As Targets For First-Time Cleanup GuaranteesArticlesDioxin Soil Cleanup StandardsArticlesDTE Energy Sells Coal Fired Power Plant to CDC/ELTArticlesDTE Energy sells Michigan power plant to Commercial Development Company, Inc.ArticlesDue Diligence in the Era of Climate ChangeArticlesDue Diligence Standards-EPA All Appropriate InquiryArticlesEBA Media Release for June Meeting 20th Anniversary ArticlesELT Acquires 1,000,000 Square Foot GM Facility ELT and Chemtura Close TransactionELT and Chrysler Close TransactionNewsEmerging Best Practice for Underwriting Energy Efficiency Loans - WebinarArticlesEmerging Best Practice for Underwriting Energy Efficiency Loans - WhitepaperArticlesEnergy Disclosure Laws – A Nationwide Trend In TransparencyNewsEnviroFinance Group Joint Venture to Develope 3mW Solar Power Plant on Closed LandfillNewsEnvironmental Due Diligence Guide ReportArticlesEnvironmental Liability Transfer & Chemtura Close TransactionEnvironmental Site Assessment Standards Revised by the American Society for Testing and Materials (ASTM)InternationalArticlesEPA Administrator Signs Proposed Rule Setting Standards for Site AssessmentsArticlesEPA Announces Cities with the Most Energy Star Buildings in the USArticlesEPA Announces Novel Superfund AgreementArticlesEPA Announces Schedule to Develop Natural Gas Wastewater StandardsEPA Announces U.S. Organizations Using the Most Green PowerArticlesEPA Announces Winner of Annual Energy Star National Building CompetitionArticlesEPA Disapproves Air Permitting Exemption Program in Texas ArticlesEPA Embracing Green Cleanups, Standard ForthcomingArticlesEPA Embracing Superfund Policy to Expedite Site CleanupsArticlesEPA Faces Industry Pressure On Brownfields Rule On Eve Of ReleaseArticlesEPA Finalizes Greenhouse Gas Reporting Requirements for Petroleum and Natural Gas IndustryNewsEPA Issues Ready-for-Reuse GuidanceArticlesEPA Issues Rule to Reduce Water Pollution from Construction Sites NewsEPA Issues Updated, Achievable Air Pollution Standards for Oil and Natural GasNewsEPA Lists Major Industries as Targets for First-Time Cleanup GuaranteesArticlesEPA Moves to Ease Groundwater Cleanup Policy ArticlesEPA Plans Further Vapor Intrusion Revisions Amid New CriticismArticlesEPA Plans on Stepping Up Work on Vapor Intrusion Plan ArticlesEPA Proposes Rule to Modernize Clean Water Act ReportingArticlesEPA Proposes to Keep Greenhouse Gas Permitting Requirements Focused on Largest Emitters NewsEPA Proposes to Reduce Toxic Pollutants Discharged into Waterways by Power PlantsArticlesEPA Proposes to Replace and Reduce Harmful Greenhouse GasesArticlesEPA Pushes Back Final UST Regulation ArticlesEPA RCRA Goals Require CreativityArticlesEPA Releases Final Risk Assessment on Trichloroethylene (TCE) ArticlesEPA Releases New Policy Statement on Climate Change AdaptationArticlesEPA Report Shows Impact of Changing Climate on Americans' Health and EnvironmentArticlesEPA Revises Consent Orders in Response to AviallArticlesEPA Rule Increases Protection from Lead-Paint Poisoning ArticlesEPA Solicits Public Input on Using Vapor Intrusion Threats as Criteria for Superfund Sites NewsEPA to Work with Ports to Improve Environmental Performance / Clean diesel grants and new ports initiative will advance sustainable technologiesArticlesEPA Will Review Cleanup Program PoliciesArticlesEPA's Integrated Cleanup Initiative Implementation Plan ProposedArticlesEPA, California OK Agreements To Waive City's LiabilityArticlesEPA, DOE to Study Potential for Renewable Energy Possibilities on West Haymarket Brownfield Site in Lincoln, Neb.NewsEPA: Greenhouse Gases Threaten Public Health and the Environment ArticlesERRA Seminar: Environmental Insurance 101ArticlesFannie Mae Releases 1st PNA Guidance in Over 20 YearsArticlesFed Reg Development - EPA Revisions to PCB Building Waste Rules ArticlesFed Reg Dev - EPA Relaxes Builders' Stormwater Permit NewsFed Reg Dev - EPA Seeking Comment On Re-classifying PCB-Contaminated Building Materials Slated For Disposal NewsFed Reg Dev Stormwater Violations at Concrete Ready-Mix Plants, Enforcement Nets More than $4 MillionArticlesFed Reg Developments ArticlesFed Reg Drilling Final Rules on Drilling Emissions ArticlesFederal Regulatory Developments – EPA on StormwaterNewsFederal Task Force Sends Recommendations to President on Fostering Clean Coal TechnologyArticlesFlawed Phase 1 CREC Definition Poses Challenges to Property Owners and LendersArticlesGE Discloses PCB-Related Expenses Under Shareholder PressureArticlesGeorgia Power to close ash lagoons sooner, could cost $2 billionNewsGuardian Trust is Now OperationalArticlesHoneywell Representative to Speak at Deal Making & Redevelopments!ArticlesInsurance against Extreme Events: Pairing Short-Term Incentives with Long-Term StrategiesArticlesKelo Decision-Economic Development Can Be Public UseArticlesKingdom Tower- Langan International and the World's Tallest Tower Lack of Vapor Intrusion Guidance Muddies Issues; Effect on Redevelopment UncertainArticlesLaw Provides No Exception for "Almost Innocent" OwnerArticlesLegal Title Not Necessary for Party to Bring Citizen LawsuitArticlesLiability Transfer of Asarco New Jersey Site from Bankruptcy to ELTArticlesLONG-AWAITED MCP CHANGES ARE AT OUR DOOR STEP ArticlesMaking Institutional Controls Work for California BrownfieldsArticlesMarysville looks to a riverfront renaissanceNewsMassachusetts Tops California as Most Energy-Efficient State, while Arkansas, D.C., Kentucky, and Wisconsin are Most ImprovedArticlesMerger & Acquisition Transaction Facilitated by EnvironmentalLiability Transfer, Inc.NewsMilitary Pays for Real Estate Developer to Cleanup SiteArticlesMore than 5,500 buildings to compete in EPA's Fifth-Annual Energy Star Battle of the BuildingsArticlesN.Y. Residents Sue IBM Alleging ContaminationArticlesNatural Disasters Prompt Attention to Climate Change in Assessing RiskArticlesNew Agency Task Force Developing Tracking DatabaseArticlesNew ASTM Standard Aims to Provide More Accurate Measurement of Energy UseNew Bond Fund Helps Investors See Different Kind of GreenArticlesNew Federal Court Case Signals Increased Litigation Over Vapor Intrusion ReopenersNewsNew Law to Affect California Brownfields RedevelopmentArticlesNews Release - EPA Updates Mercury and Air Toxics Standards for New Power Plants ArticlesOCC Ratchets up Expectations – OCC Requirements for Environmental Due Diligence in Commercial Real Estate Lending ArticlesOn the Cutting Edge: An Insider's Perspective
Favorable Market Trends Driving Contaminated Property TransactionsArticlesOpportunities Are Bright For Those Who Pave the WayArticlesOpposition to Aviall-Court Rules a PRP Can Seek ContributionArticlesP.E. Firms Find Way Around F.D.I.C. RulesArticlesPacific Western Bank, San Diego, California, Assumes All of the Deposits of Los Padres Bank, Solvang, California ArticlesPartner Leverages EDR's New Technology Tools To Drive Even More Quality and Efficiency
ArticlesPurchaser of Assets Pursuant to Bankruptcy Sale Liable for Pre-Existing ContaminationArticlesRCRA Hazardous Waste Systems: Carbon Dioxide (CO2) Streams Being SequesteredNewsRCRA Suit May Include Property Adjacent to FacilityArticlesReal Property Protections for the BuyerRecent Case Ruling Highlights Need for Informed Discussion, Agency GuidanceReforming NCP Could Encourage Brownfields RedevelopmentArticlesResource Damage Liability Precludes Contribution ClaimArticlesResponsible Parties May Be Able to Pursue Section 107 (a) ClaimsArticlesRTM Announces San Francisco, CA May 18-20, 2011 ConferenceRTM Communications, Inc. and Bloomberg BNA Proudly Announce a Webinar
"Closing Property Transactions Using Mitigation Banking Credits."
ArticlesRTM Conference Sponsor ELT Announced 80 New Jobs - Mid America Brick CompanyArticlesRTM Conference: The Bumpy Road to Brownfields RedevelopmentArticlesSen. Clinton Introduces TCE (Trichloroethylene) LegislationArticlesSite Owner Must Allow Testing During DiscoverySolutions for Contaminated Real Estate Newsletter - August 2016NewsSolutions for Contaminated Real Estate Newsletter - September 2016
Newsletter by Commercial Development Company, Inc. (CDC) and Environmental Liability Transfer, Inc. (ELT)NewsSRS & LABBC Collaborate on Workshop Series to Train Contractors on PACE FinancingArticlesStrategy Shift on Global Warming Heralded by Collapse of Chicago Climate ExchangeArticlesSuccessor Firm Liable for Merger Firm's ViolationsArticlesSuperfund and RCRA Reforms Effecting Contaminated Property Transactions for Brownfields RedevelopmentsArticlesSupreme Court Rejection of a Divisibility of Harm ArgumentArticlesSupreme Court Vacates Third Circuit Section 107(a) RulingArticlesSustainability - Energy Improvement Corporation Announces $75 Million Agreement with Bank of America Merrill Lynch for Energy Efficiency and Renewable Energy Program ArticlesSustainability - Retrofits Projected Yield $1Trillion in US Energy SavingsNewsSustainability Energy Efficiency Market Projections 2013 to 2020ArticlesTestimony of EPA Administrator Gina McCarthy Before Senate Environment and Public Works Committee on Proposed FY 2015 BudgetArticlesThe Capital Markets Partnership (CMP) is launching the Sustainable Investment Initiative at the New York Stock Exchange. ArticlesThe End of Community Banking?ArticlesThird of North American Birds Said to Face Extinction Due to Climate Change, Other Man-Made FactorsArticlesUnited States Reaches an Agreement with XTO Energy to Prevent Waste Spills from Natural Gas Exploration and Production ArticlesUnited States Reaches Settlement with Safeway To Reduce Emissions of Ozone-Depleting Substances NationwideArticlesUSDA, EPA Partnership Supports Water Quality Trading To Benefit Environment, EconomyArticlesWells Fargo Supports Clean Technologies With New Commercial Banking Group ArticlesCreate another search
RTM Media Campaigns
Copyright © 2020 RTM Communications, Inc. All Rights Reserved.


text:
November 24, 2012
Believe it or not, the Texas Education Service Center Curriculum Collaborative is teaching impressionable minds that the Boston Tea Party was an act of terrorism.
"A local militia, believed to be a terrorist organization, attacked the property of private citizens today at our nation's busiest port," the curriculum states. "Although no one was injured in the attack, a large quantity of merchandise, considered to be valuable to its owners and loathsome to the perpetrators, was destroyed. The terrorists, dressed in disguise and apparently intoxicated, were able to escape into the night with the help of local citizens who harbor these fugitives and conceal their identities from the authorities.
"It is believed that the terrorist attack was a response to the policies enacted by the occupying country's government. Even stronger policies are anticipated by the local citizens."
Get what you and your family need with today's top-selling products now!


text:
Jamaica Bay's marshes are shrinking. According to the Eco-Watchers, a Queens citizens' organization, the Bay's saltwater marshes have shrunk by over 1200 acres (one and one-half times the area of Central Park) over the past seventy-five years. In the last five years, the rate of loss is said to be five times the rate from 1924-1974. Their statistics suggest that by 2024, the salt water marshes of the central bay will cease to exist.
Though the rate of loss is not universally agreed to and the causes for the shrinkage are incompletely understood, there is agreement that such a loss would be catastrophic for the ecology of Jamaica Bay. Dr. John Tanacredi, Natural Resources Chief for the Gateway Unit of the National Park Service states, "salt water marshes are the most productive areas for biomass production, feeding, and breeding for birds and fish". Tanacredi adds "one-fifth of all bird species in North America" migrate via Jamaica Bay each year. The Bay with an area roughly equal to all of Manhattan, though unknown to many New Yorkers, is a critical, probably irreplaceable, stop on the Atlantic flyway.
For the Eco-Watchers and for their chairman Dan Mundy, who calls himself "an environmentalist with sanity", Jamaica Bay is well known. For decades, these citizen naturalists have explored the bay. Over time, they began to share their separate observations of marsh loss. Eventually, they banded to measure the marsh extent and chronicle their loss. With maps in hand, they contacted government agencies and politicians. Their research was corroborated when the New York State Department of Environmental Conservation released maps of the Bay's marshes that echoed the Eco-Watchers' estimates.
Fearing annual losses exceeding fifty acres, Mundy and his group asked the United States Department of the Interior to intervene. Though it is not exactly what they wanted, a "blue-ribbon panel" of marsh, weather and coastal scientists will convene in March to assess causation.
Tanacredi notes that sea level rise may be the culprit. He cautions that "marsh accretion and erosion are natural processes and getting in the way of natural phenomenon may not be desirable." He wants to establish a five-year research agenda to establish cause and effect scientifically. He also notes that the National Park Service lacks funding for significant interventions.
Mundy is wary of the study approach. He is also concerned that the Park Service might allow a "Yellowstone" by letting natural causes destroy the marshes he has fished and explored for half a century. Mundy wants immediate action. The Eco-Watchers and their allies believe that sediment deprivation is a likely cause of the marsh erosion. To redress that condition, he advocates experimental sediment restoration efforts (dumping sandy soil onto de-vegetated marsh areas) in selected locations. Mundy urges that "pilot projects should begin now."
For a decade, the Army Corps of Engineers (the federal government's official and best-funded muck-moving entity) has been planning a Jamaica Bay Ecosystem Restoration Project. The Corps recently selected twelve Bay sites for study. Two sites, suggested by the Eco-Watchers were added, but the central bay marshes remain off the list. According to the Corps' Robert Will, "we hope to have funding from Congress in 2002, if they like our sites". He notes that the Army Corps' official position is "we can do nothing immediately to stop the (marsh) erosion problem."
Sounding Off
So will the muck stop here? It is hard to say. Government agencies, no matter how well meaning, move slowly, though perhaps with wise deliberation. The passion of focused citizens can move elected officials to take necessary, though perhaps hasty, positions. Science is often non-conclusive. Nature moves in mysterious ways. Man's action cause problems. Man's reactions cause problems. What is certain is that habitat destruction for animals has been a hallmark of human "progress".
The wildlife refuge in Jamaica Bay centers on the large contiguous marshes of the central bay. This is the place striped bass, turtles, ducks, geese and hundreds of species of birds call home even if just for a day. Their bed and breakfast in the bay is a matter of life or death. For them, why not try a few pilot projects now? If nothing else, such experiments will provide an expanded array of observations for the scientists to consider.
Peter B. Fleischer, currently writing a book on the New York City waterfront, was formerly a transportation and environment policy advisor to New York City Mayors David Dinkins and Rudy Giuliani.


text:
U.S. Women's Weekly Update for March 14
Bill Kauffman
Associate Director, Communications
Phone: 719-228-6800
E-Mail: firstname.lastname@example.com
COLORADO SPRINGS, Colo. (March 14, 2011) – The current U.S. Women's National Team Weekly update released on March 14 includes briefs on U.S. players competing overseas and other team news.
U.S. WOMEN'S TRAINING GROUP SCHEDULES INTRASQUAD SCRIMMAGE: The U.S. Women's National Training Team will play in two intrasquad scrimmages in Southern California on March 16 and March 17. The first scrimmage will take place on March 16 at Tstreet Volleyball Club's new facility located at 1 Autry in Irvine, Calif. The match will start at 7 p.m. Pacific Time. The second scrimmage is set 6 p.m. Pacific Time on March 17 at Irvine Valley College in Irvine, Calif. Both contests are open to the public free of charge. For the first scrimmage, Team Red will consist of setter Jenna Hagglund (West Chester, Ohio), outside hitters Cassidy Lichtman (Poway, Calif.) and Juliann Faucette (San Diego), middle blockers Dominique Olowolafe (Lansing, Mich.) and Ashley Benson (Bloomington, Ind.), opposite Kinrda Carlson (Eaton, Colo.) and liberos Ellie Blankenship (Cedar Rapids, Iowa) and Cami Croteau (Orange, Calif.). Team Blue will consist of setter Carli Lloyd (Bonsall, Calif.), outside hitters Kaitlin Sather (Santa Rosa, Calif.), Kari Pestolesi (Huntington Beach, Calif.) and Julianne Piggott (Newport Beach, Calif.), opposite Becky Perry (Austin, Texas), middle blockers Naomi Johnson (Bloomington, Minn.) and Lauren Gibbemeyer (St. Paul, Minn.), and libero Kayla Banwarth (Dubuque, Iowa). The rosters for the Blue and Red Teams may be adjusted for the second scrimmage following the March 16 scrimmage. The U.S. Women's National Training Team is currently in its winter training block, which started Jan. 17 and runs through mid-April at the American Sports Centers in Anaheim, Calif.
U.S. WOMEN'S TRAINING BLOCK ROSTER: The U.S. Women's National Team is holding its winter training block from Jan. 17 to mid-April at the American Sports Centers in Anaheim, Calif. The U.S. Women's National Training Team roster currently has numbers 15 players training. In addition, Juliann Faucette (San Diego) is training with the group between March 14 and March 18. The training roster includes setters Carli Lloyd (Bonsall, Calif.), Jenna Hagglund (West Chester, Ohio) and Cassidy Lichtman (Poway, Calif.); middle blockers Ashley Benson (Bloomington, Ind.), Lauren Gibbemeyer (St. Paul, Minn.), Naomi Johnson (Bloomington, Minn.) and Dominique Olowolafe (Lansing, Mich.); outside hitters Becky Perry (Austin, Texas), Kari Pestolesi (Huntington Beach, Calif.), Julianne Piggott (Newport Beach, Calif.) and Kaitlin Sather (Santa Rosa, Calif.); opposite Kindra Carlson (Eaton, Colo.); and liberos Kayla Banwarth (Dubuque, Iowa), Ellie Blankenship (Cedar Rapids, Iowa) and Cami Croteau (Orange, Calif.). Pestolesi will also see training time at libero. Additional players may be added to the roster during the course of the training block.
AKINRADEWO WITH TOYOTA IN JAPAN: Foluke Akinradewo (Plantation, Fla.), a middle blocker with the U.S. Women's National Team, is playing for Toyota Autobody in Japan's V-League for the 2010-11 professional season. Toyota is now 12-14 on the season and in fifth place in the V-League. After the 9.0 earthquake that struck Japan on March 11 and the aftermath of the tsunami, the V-League has opted to suspend the rest of the regular season and playoff rounds.
TOM WITH GUANGDONG HENGDA IN CHINA UNDER FORMER U.S. HEAD COACH: Three-time U.S. Olympian Logan Tom (Salt Lake City, Utah) is playing for Guangdong Hengda (also known as Evergrande) in the Chinese club league's top division. Evergrande, led by 2008 U.S. Olympic Games head coach "Jenny" Lang Ping, is on a seven-match win streak following a 25-18, 25-18, 25-23 victory over August Keming (9-8) on March 12. In the win over Zhengzhou High Tech Zone, Tom scored seven kills, two blocks and two aces for 11 points in the victory. Evergrande will meet Tianjin on March 15 in a battle of league leaders. Both teams are 15-2 on the season, but Evergrande holds a 46-43 point advantage for the league leader.
BERG, HODGE WITH VILLA CORTESE IN ITALY: U.S. Women's National Team setter Lindsey Berg (Honolulu) and Megan Hodge (Durham, N.C.) are competing for MC-Carnaghi Villa Cortese in the Italian Serie A league during the 2010-11 professional club season. In Italian Serie A action, Villa Cortese (11-4, 31 points) slipped past fourth-place Asystel Volley Novara (9-6, 29 points) 27-25, 25-19, 12-25, 27-25 on March 13. Hodge contributed 22 points with 21 kills on 54 swings and an ace. She also produced a 100 percent positive service reception on three attempts. Berg started the first two sets in which Villa Cortese converted 40.2 percent of its attacks into points. Villa Cortese, now in third place despite having the most match victories along with Bergamo in the league standings, faces eighth-place Florens Castellana Grotte (6-9, 18 points) on March 20.
HARMOTTO WITH LIU-JO VOLLEY MODENA IN ITALY: U.S. Women's National Team middle blocker Christa Harmotto (Hopewell, Pa.) is playing for LIU-JO Volley Modena in Italy's Serie A League during the 2010-11 professional club season. After a lengthy stint away from the team rehabilitating an injury, Harmotto returned to the court for the first time on March 13 and helped Modena to a 29-27, 25-21, 19-25, 23-25, 15-10 victory over sixth-place Chateau d'Ax Urbino Volley (9-6, 25 points). In a starting role, she provided seven kills on 16 attacks and three blocks for 10 points. Harmotto also served a team-high 26 times during the match leading to several points. Modena (5-10, 15 points), who slipped to 10th place in the league standings without Harmotto in the lineup, will play fourth-place Yamamay Busto Arsizio (9-6, 29 points) on March 20 in its next Serie A match.
PAOLINI WITH NOVARA IN ITALY: Lauren Paolini (Ann Arbor, Mich.), a middle blocker on the U.S. Women's National Team, is competing this professional season in Italy with Asystel Volley Novara of the Italian Serie A Division. On March 13, Novara dropped a 27-25, 25-19, 12-25, 27-25 match to third-place MC-Carnaghi Villa Cortese (11-4, 31 points). Paolini charted 10 kills on 16 attacks with a block for 11 total points. Novara, now tied for second place in the Italian Serie A with 29 points, plays sixth-place Spes Conegliano (9-6, 25 points) on March 13 in its next match.
HOOKER WITH ITALY'S PESARO: Destinee Hooker (San Antonio, Texas), who played her first season with the U.S. Women's National Team in 2010, is currently competing for Scavolini Pesaro of the Italian Serie A League. In the Italian Serie A league, Hooker was not available in the team's 25-20, 21-25, 25-18, 25-18 victory over Florens Castellana Grotte (6-9, 18 points) on March 13. Pesaro is currently 10-5 on the season and in second place with 32 points. The team will face Chateaux d'Ax Urbino Volley, originally slated for March 20, on April 6 due to the team's participation in the CEV Champions League semifinals. In CEV Champions League action, Pesaro is slated to face Azerbaijan's Rabita Baku in the first semifinal played on March 19, with the winner playing either Fenerbahce or VakiGunes Telekom of Turkey in the championship match on March 20.
MORRISON, SIX AMERICANS ON ONE AUSTRIAN TEAM: U.S. Women's National Team Assistant Coach Jamie Morrison (Dana Point, Calif.) is serving as head coach of the Austrian Post Schwechat team during the 2010-11 season. The team has six American players including Jill Collymore (Seattle), Alexis Crimes (Rancho Cucamonga, Calif.), Jessica Jones (Naperville, Ill.), Tamari Miyashiro (Kaneohe, Hawaii), Angie Pressey (Lake Mary, Fla.) and Courtney Thompson (Kent, Wash.). Post Schwechat competes in the Middle European Volleyball Zonal Association (teams from Czech Republic, Austria, Slovakia, Slovenia and Croatia). Post Schwechat is nearing the completion of its 2010-11 season and is taking part in the Austrian Bundesliga semifinal round versus Tirol. In the March 12 match, Post Schwechat defeated Tirol 25-9, 25-20, 25-9. Crimes scored 11 points with nine kills on 10 errorless attacks to go with a block and ace. Pressey, who played in just the first set, scored four kills on five errorless attacks with a block for five points. Thompson set the squad in the first two sets leading to a 46.3 kill percent and .352 hitting efficiency. Miyashiro charted a 71 percent positive service reception on 17 chances. The teams will meet again on March 19 and March 23.
KIM GLASS WITH RABITA BAKU IN AZERBAIJAN: Kim Glass (Lancaster, Pa.), a 2008 Olympic Games silver medalist with the U.S. Women's National Team, is competing for Rabita Baku of the Azerbaijan professional league in 2010-11. By finishing first in the regular season, Igtisadchi received a quarterfinal round bye of the Azerbaijan Super League playoffs, which just completed its first match of a best-of-three series this past weekend. In the CEV Champions League, Rabita has advanced to the semifinal final round and will face Italy's Scavolini Pesaro on March 19 in Istanbul, Turkey. The semifinal winner will challenge either Fenerbahce or VakiGunes Telekom of Turkey in the championship match on March 20.
TAMAS WITH AZERRAIL BAKU: Jennifer Tamas (Milpitas, Calif.), a 2008 Olympic Games silver medalist playing middle blocker for Team USA, is playing for Azerrail Baku of the Azerbaijan Super during the 2010-11 professional club season. Azerrail, the third seed in the Azerbaijan Super League playoffs, defeated Shirvan 25-11, 25-13, 25-14 in the first match of the best-of-three quarterfinal round. The second match will take place on March 24. In CEV GM Capital Challenge Cup action, Azerrail has advanced to the semifinal round and will face Russia's Uralochka-NTMK Ekaterinburg in a home-and-home series played on March 15 and March 19.
IGTISADCHI LOADED WITH AMERICANS IN AZERBAIJAN: Two-time Olympian and 2008 Olympic silver medalist Tayyiba Haneef-Park (Laguna Hills, Calif.) is playing for Igtisadchi of the Azerbaijan Super League. By finishing second in the regular season, Igtisadchi received a quarterfinal round bye of the Azerbaijan Super League playoffs, which just completed its first match of a best-of-three series this past weekend. In CEV GM Capital Challenge Cup action, Igtisadchi has advanced to the semifinal round to play country rival Lokomotiv Baku in a home-and-home series contested March 16 and March 20.
DAVIS, METCALF, RICHARDS HEADLINE LOKOMOTIV BAKU IN AZERBAIJAN: U.S. Olympians Nicole Davis (Stockton, Calif.) and Nancy Metcalf (Hull, Iowa), along with 2008 U.S. Olympic Team alternate Kristin Richards (Orem, Utah), are playing for Lokomotiv Baku of the Azerbaijan Super League. Lokomotiv, as the fourth seed in the Azerbaijan Super League playoffs, defeated Baki 25-19, 25-21, 25-15 in the first of a best-of-three series in the quarterfinal round. The second match will be played on March 24. In the CEV GM Capital Challenge Cup, Lokomotiv has advanced to the semifinal round to play country rival Igtisadchi Baku in a home-and-home series contested March 16 and March 20.
SPICER WITH POLAND'S GCB CENTROSTAL BYDGOSZCZ: Nellie Spicer (Barrington, Ill.), a setter for the U.S. Women's National Team, is competing in the Polish professional league this winter for GCB Centrostal Bydgoszrcz. Spicer's side lost to league-leader Bank BPS Muszynianka Fakro 25-23, 25-16, 21-25, 25-17 on March 13. Bydgosrzcz, now 9-6 on the season and in fourth place, was able to score points on 27 percent of its attacks and was out-blocked 15-8. Bydgosrzcz returns to action on March 18 against third-place TAURON MKS Dapbrowa Gornicza (8-7).
SYKORA, ALISHA GLASS SETTING TABLES FOR VOLEI FUTURO IN BRAZIL: Three-time U.S. Olympian Stacy Sykora (Burleson, Texas) and U.S. Women's National Team setter Alisha Glass (Leland, Mich.) are competing for Volei Futuro in the Brazilian Superliga during the 2010-11 professional club season. Volei Futoro upset league-leader Unilever 25-19, 25-19, 25-23 on March 11. Sykora was the libero in the victory, while Glass was absent from the active roster. Volei Futuro had its match with Macae Sports on March 13 postponed until March 14 due to wet floor conditions. With the delay, Macae Sports came away with a 23-25, 25-23, 25-19, 15-25, 15-11 victory.
FAWCETT IN BRAZIL WITH USIMINAS MINAS: Nicole Fawcett (Zanesfield, Ohio), a U.S. Women's National Team opposite, is playing the 2010-11 professional club season in Brazil with Usiminas Minas. After a bye week, Usiminas returned to the court on March 10 and rallied to defeat Pinheiros/Mackenzie 23-25, 18-25, 26-24, 25-15, 15-12. Fawcett scored 17 points in the victory, including 16 kills on 46 attacks and a block. She scored 13 points with 11 kills on 31 attacks and two blocks in Usiminas' 15-25, 25-19, 25-20, 25-20 loss to Sollys/Osasco on March 12.
SCOTT-ARRUDA IN BRAZIL WITH SAO BERNARDO: Four-time U.S. Olympian Danielle Scott-Arruda (Baton Rouge, La.) is back on the volleyball court after giving birth last spring and is playing for BMG Sao Bernardo in the Brazilian Superliga. Sao Bernado, after a break in the league action, came back to defeat Brusque 28-30, 25-20, 25-20, 25-16 on March 10. Scott-Arruda produced a team-high 19 points with 12 kills on 24 attacks, six blocks and an ace. Scott-Arruda scored a team-high 19 points with 15 kills on 24 swings and four blocks as Sao Bernardo topped Pauta/Sao Jose 25-21, 26-28, 25-19, 28-26 on March 12.
LARSON WITH KAZAN IN RUSSIA: U.S. Women's National Team outside hitter Jordan Larson (Hooper, Neb.) is playing for Dinamo Kazan of the Russia Super League during the 2010-2011 pro club season. She helped Kazan to a 25-22, 25-14, 25-15 victory over Proton on March 9. She notched 12 points with 10 kills on 19 swings to go with two aces in the victory. On March 12, Kazan topped Dinamo Krasnador 27-25, 25-23, 27-25 in a tightly contested three-set match with all three sets decided by the minimum two points. Larson provided nine points – all on kills from 20 attacks – while providing a 45 positive reception percent. Kazan improves to 17-1 on the season and a half-match ahead of Dinamo Moscow in the league standings with four matches left. However, Kazan's next match is against Dinamo Moscow on March 25.
BOWN WITH TURKEY'S ECZACIBASI: Heather Bown (Yorba Linda, Calif.), a three-time Olympic Games middle blocker for the U.S. Women's National Team, is competing in Turkey for Eczacibasi during the 2010-11 professional club season. In the Turkish League, Eczacibasi swept Dicle Universitesi 25-11, 26-24, 25-9 on March 12 without Bown in the lineup. Eczacibasi is now 15-1 on the season and tied for first place with Fenerbahce.


text:
2017 Fall Waterfowl Season
Fall Waterfowl Hunting 2016 Season
Fall Waterfowl Hunting 2015 Season
Fully Guided Duck Hunts – Squaw Creek Refuge – Mound City, Missouri
Fall Waterfowl Hunting for mallards, Canada geese and snow geese less than one mile from Squaw Creek NWR. We have seats available in our heated pit blinds both in dry and flooded stalked cornfields for $225 per hunter / per day
All necessary equipment provided to hunt. Full body duck decoys, full body Canada goose decoys, Mojo's and snow goose decoys. Lodging is available for an additional charge. Pit blinds are heated.
Fall Missouri waterfowl season. Call 855-473-2875 to reserve your seat.
Squaw Creek Hunt Club / Waterfowl Lease – Memberships Available
To Join or schedule a Visit Please Call 855-473-2875 or visit www.squawcreekhuntclub.com
Individual Membership – $3000
Cooperate Membership
Blinds for Lease Daily
The Squaw Creek Hunt Club headquarters is located less than one mile west of the Squaw Creek National Wildlife Refuge near Mound City, Missouri and offers the following amenities to club members and their guests.
Memberships Includes Unlimited Use and Access to the Following:
Unlimited Fall Waterfowl Hunting
Locations Include:
- pit blinds, duck blinds in Missouri River bottoms located less than 1 mile from Southwest corner of Squaw Creek National Wildlife Refuge
– blinds provided – layout ground blinds, duck blinds, pit blinds
– field hunting (ducks, Canada geese, snow geese)
– all equipment provided – duck decoys, full body Canada decoys (Avery & Bigfoot)
– fully guided
Lodging & Food
Lodging – Completely furnished five bedroom farm house, with spacious ( kitchen, dining room. living room)
Food – Breakfast, Dinner, Supper – (can be provided)
Fully Guided Duck Hunts – Ducks, Canada Geese, Snow Geese
- $175 per Hunter / per day
- flooded cornfields
- heated pit blinds
- field hunting (ducks, Canada geese, snow geese)
- all equipment provided
- fully guided


text:
Report: Spurs' Tony Parker marries Axelle Francine
SAN ANTONIO — People magazine reported Sunday that San Antonio Spurs point guard Tony Parker married his fiancée French journalist Axelle Francine in the Alamo City Saturday.
According to the article, some friends and family flew to Texas from France for the ceremony, which was preceded by a reception at Cowboys Dancehall on the Northeast Side on Thursday.
"We are so happy we were able to host Tony Parker's Wedding Reception here at Cowboys Dancehall!!" the venue said on Twitter. "We love our SPURS!!"
A Cowboys employee told People that Parker, 32, sipped cocktails and danced at the small gathering. "He wanted to show them a Texas country good time," the employee said.
The wedding caps an already eventful week for Parker, who signed a multi-year extension on Friday. He is now set to remain a Spur through the end of the 2017-18 season, unless he is traded, the Express-News reported. Parker and the Spurs will be defending their fifth NBA Championship when the Spurs season starts later this year.
"I'm very happy and I want to play for the Spurs my whole career and be a Spur for life," Parker told the Express-News after re-signing.
Parker and Francine have one son, Josh, who was born in April.
This is the second marriage for Parker, who was married to actress Eva Longoria from 2007 to 2011.


text:
Last month, BlackBerry Mobile Voice System (MVS) Version 5.2 launched in over 31 countries, enabling organizations to extend desk phone capabilities to BlackBerry® smartphones while enhancing voice coverage and reducing their monthly telecom spend with secure voice-over-Wi-Fi® calling. More recently, many organizations in healthcare and financial services are using BlackBerry MVS to address their regulatory compliance requirements for logging call detail records (CDR) or call recording.
BlackBerry MVS is just one solution that makes up our Unified Communications & Collaboration (UCC) portfolio. To find out more on how BlackBerry addresses the Content Management, Voice Conferencing, and Enterprise Instant Messaging needs of an increasing mobile workforce, check out the interview below.
[ YouTube link for mobile viewing ]
How have BlackBerry products improved your productivity and helped you get things done when collaborating with other co-workers, customers, and partners? Share in the comments below.


text: Serial content dedicated to dramatic material premiered on the Internet. Entries must consist of one or more episodes over 5 minutes in total to qualify for this category. For single short films, episodes or videos with a runtime of less than 5 minutes, please see Drama: Individual Short or Episode.


text:
It Is All About BTC, LTC, ETH, ZEC mining as well as other alternative crypto currencies
There is a new update of the ccMiner fork from tpruvot v2.2.2 (source) available for Nvidia GPU miners that adds supports for new algorithms and comes with some other fixes and improvements. The two new algorithms introduced are HSR used by Hshare/Hcash (x13 + custom hash) as well as the Phi used by LuxCoin, there are improvements for the SIB algorithm for Maxwell and Pascal cards. The new version comes with a small fix to handle more than 9 cards on Linux (-d 10+), an attempt to free Equihash memory "properly" and –submit-stale parameter for the supernova pool (which changes difficulty too fast).
The official Windows binary releases on tpruvot's GitHub are compiled with CUDA 9 and they do require a more recent Nvidia video driver version 384.xx or newer in order to have support for the latest CUDA version. We have compiled a 32-bit Windows Binary for CUDA 8.0 that you can download below, it does not seem much different performance wise, it can just be used on systems with older drivers without having to update the video drivers first with ones supporting CUDA.
– To download the latest ccMiner 2.2.2 Windows 32-bit binary compiled with CUDA 8.0…
Copyright ©2014-2020 - Crypto Mining Blog - It Is All About BTC, LTC, ETH, ZEC mining as well as other alternative crypto currencies.This is a blog for crypto currency miners and crypto coin users of Bitcoin (BTC), Litecoin (LTC), Ethereum (ETH), ZCash (ZEC) and many other altcoins out there.


text:
Are you using LivingSocial? At the top of their website today is an important notice for customers that says "if you haven't already updated your LivingSocial password, please update it now". According to CNN the LivingSocial website, which people use to get daily deals, suffered a cyberattack on some of its servers. Data for more than 50 million users may have been accessed. LivingSocial says that credit card data was not affected by the cyberattack.
AllThingsD has posted the entire email from CEO Tim O'Shaughnessy that was sent to employees of LivingSocial. The email states:
The information accessed includes names, email addresses, date of birth for some users, and encrypted passwords – technically 'hashed' and 'salted' passwords. We never store passwords in plain text.
The same paragraph was in an email sent to users of LivingSocial, along with instructions about how to change their password. Users are encouraged to also change passwords on any other sites in which they used the same, or similar, password as the one they were using on LivingSocial.
I am not a user of LivingSocial, but I know that it is a website that offers people daily deals on a variety of things. There are many other websites, and apps, that also offer special deals to users. When people sign up for these types of things, they are doing it because they want to save money.
Nobody thinks about the potential for their favorite deals website to get hacked. It makes me wonder if the ability to get good deals through services like LivingSocial is really worth the risk of having your personal information out there (potentially accessible to hackers).


text:
Hello CRM community!
Two months ago, Philippe Brissaud from Microsoft Canada asked me to help him migrate the well known CrmDiagTool 4 to Microsoft Dynamics CRM 2011. I guess you know what I answered him: of course I help!
Today, Philippe and I are proud to release this new version of CrmDiagTool.
We focused on Server diagnostics and removed features related to reporting services and email router.
The features are the following:
- Enable/Disable tracing
- Zip content of Trace directory
- Open Trace directory
- Generate diagnostic file in text or html format with components selection
- Enable/Disable DevErrors
Regarding source code: As the previous version had not its source code released, this version does not too.
Download link:


text:
My love of fútbol was made well-known during this year's World Cup. Since then I have had to find other ways to entertain myself, from playing fútbol with the kids, to watching Javier Hernández play for Manchester United, (I like him better with El Tri, but I'll take my "Chicharito" any way I can get him.)
I also spent some time encouraging people to sign a petition in support of our bid to bring the World Cup to the United States in 2022, which we ended up losing to Qatar. ¡Qué desilusión! … I have to say though, their proposed stadiums are absolutely breathtaking.
Still don't feel better about losing our bid for the World Cup? Okay, here are some events to look forward to: The 2011 FIFA Beach Soccer World Cup, the 2011 Copa América and the Women's World Cup 2011!
Speaking of women, I just saw a report this evening about a Salvadoran woman named Eva Linares. Ms. Linares is newsworthy because she is the only female fútbol commentator in El Salvador, most likely the only one in Central America, and possibly even the only one in all of Latin America. I think she is super chévere.