6
Using Renderers

This chapter covers the following topics:

• What Is a Renderer?

• Using Standard Renderers

• Introduction to Custom Renderers

• Overview of a Renderer Application

What Is a Renderer?

A renderer takes an object stored in the repository and outputs its content in a specific format. In a sense, a renderer is the opposite of a parser. While the information output by a renderer may be identical to the document as it was input, it doesn't have to be. You can use a renderer to:

• Reconstruct a parsed file and display it in its original format.

• Reconstruct a parsed file and display it in a different file format.

• Filter only certain file components for display.

• Calculate values from file components.

Once information in the original document has been parsed and stored as an object in the Oracle Internet File System, the object can be rendered in a variety of formats and layouts.

The Oracle iFS Framework for Rendering

The Oracle iFS rendering framework allows a developer to:

• Create a custom renderer by writing a class that implements the renderer interface.

• Register a custom renderer with the repository using XML files.

• Invoke a renderer using the methods inherited from LibraryObject. These methods can be used to invoke both out-of-the-box and custom renderers.

As a developer, you have two options to render a repository object:

• You can use the standard renderers provided by Oracle iFS. For more information, see "Using Standard Renderers".

• If the standard renderers do not meet the needs of your application, you can write a custom renderer in Java. For more information, see "Overview of a Renderer Application".

A Renderer Does Not Create a Repository Object

The output from a renderer is read-only and is not persistent. A renderer does not automatically create a Document object in the repository or a data file stored locally. If an application requires that the rendered output be available for later use, it is a post-rendering step to create a Document object or to save a data file locally.

What Objects Can Be Rendered?

Any LibraryObject can be rendered. For example, you might write an application that calls an XML renderer to display the following:

• If the object is a folder or an ACL, or other LibraryObject that does not contain content, the rendered output consists of attributes only.

• If the object contains content (that is, the object is a Document object or a subclass of Document), the rendered output could consist of attributes only, content only, or both.

Although, in general, any LibraryObject can be rendered, a custom renderer is likely to be written for the purpose of rendering specific kinds of objects. For example, while the SimpleXmlRenderer can render any LibraryObject, a PurchaseOrder renderer can render only PurchaseOrder objects, and throws an exception if requested to render an object that it cannot handle.

Because Document objects are the most commonly rendered objects, we will refer to documents for the balance of this discussion.

Using Server-Side Classes with Renderers

In the Oracle iFS Java class hierarchy each Oracle iFS object has two representations:

• The bean-side representation, known by the object name, such as Document.

• The server-side representation, known by the object name preceded with "S_", such as S_Document.

Because rendering is a server-side operation, you must use the S_ classes.

Using PolicyPropertyBundles to Register Renderers

The process of registering a renderer is, at the basic level, a matter of mapping a connection between a class of objects and a specific renderer. The underlying mechanism for storing these mappings is a PolicyPropertyBundle object.

A PolicyPropertyBundle is a specific type of PropertyBundle object. In general, PropertyBundles are used to store name/value pairs. In the case of a PolicyPropertyBundle, a Policy is stored in each Property of the PropertyBundle. Each Policy contains the mapping between a class and a renderer for a specific protocol.

Each class in Oracle iFS has an associated PolicyPropertyBundle. When an object of a class is retrieved from the repository, Oracle iFS checks the associated PolicyPropertyBundle to determine which renderer to use to display the object, based on the protocol making the request for the object.

Because Oracle iFS includes multiple protocols (FTP, HTTP, SMB), a specific Policy must be registered for each protocol; that is, one Policy each for HTTP, FTP, and SMB.

When a Property is used to store a Policy:

• The Name attribute of the Property object is specified first. The Property Name attribute must be the value of the Policy Operation attribute.

• The Value attribute of the Property object comes next. The Property Value attribute holds the Object ID of the Policy object.

Each Policy object stores the following attributes:

Attribute	Datatype	Description	Example
Name	String	Name of this custom renderer. Must be unique. Must be one word, no spaces.	POSmbRenderer
Operation	String	The name of the Property object. Operation specifies the key to the PolicyBundle hashtable, so it must precisely match the name used in the hashtable.	SmbRenderer
Implementation Name	String	Fully-qualified classname of the custom renderer, starting with package name.	ifs.demo.po. renderer.PoRenderer

For the procedures to register a renderer, see "Registering a Renderer Using Oracle iFS Manager". For an XML code sample of a PolicyPropertyBundle, see "Registering a Renderer Using XML".

Using Standard Renderers

Out-of-the-box, Oracle iFS includes two standard renderers that will meet the needs of most developers creating new applications in Oracle iFS.

Class	Description
SimpleXMLRenderer	Generates a complete XML document body based on properties in a particular document.
SimpleTextRenderer	Provided as a starting point example for developers who need to create a custom renderer.

Note: A renderer must be registered before you can use it. The standard renderers are registered by default.

Invoking Renderers

Whether your application invokes an Oracle iFS standard renderer or a custom renderer, the process is the same. Applications invoke renderers using the appropriate renderAsXxxx() method defined in oracle.ifs.beans.LibraryObject. The renderer application must invoke the appropriate method for the type of output desired.

• An InputStream object (a series of bytes)

• A Reader object (a series of characters)

To use any renderer, invoke one of the following methods inherited from the LibraryObject class on the object you want to render:

public java.io.InputStream renderAsStream

                     (String rendererType, 

                      String rendererName, 

                      Hashtable options)

    throws IfsException

public java.io.Reader renderAsReader

                     (String rendererType, 

                      String rendererName, 

                      Hashtable options)

    throws IfsException

The following table lists the parameters for the renderAsXxxx() methods. These parameters are used to determine which renderer is invoked and to pass options to the target renderer.

Parameter	Datatype	Description	Example
rendererType	String	Value of the Operation attribute of the Policy. Non-unique.	SmbRenderer
rendererName	String	Name of the Policy object. Must be unique.	VcardSmbRenderer
options	Hashtable	Contains values for each specific renderer to use.	Renderer-specific options. Values in this Hashtable must be serializable.

The rendererType and rendererName arguments differ as follows:

• The rendererType argument is a String value that specifies the name of a Policy's Operation attribute.

• The rendererName argument is a String value that specifies the Name attribute of the Policy that contains the Operation specified by rendererType.

The rendererType and rendererName arguments together determine which renderer is to be used. The determination is made as follows:

• If rendererName is not null:
  • The custom Policy object called rendererName for the Operation specified by rendererType is obtained. This custom Policy object contains the fully-qualified classname of the renderer in its ImplementationName attribute.

• If rendererName is null:
  • The default Policy object for this LibraryObject for the operation specified by rendererType is obtained. This default Policy object contains the fully-qualified classname of the renderer in its ImplementationName attribute.

Choosing a Renderer

You can use the renderAs() methods in two ways:

• Explicit specification: The application explicitly specifies a certain renderer.

• Default selection: The repository chooses a default renderer.

The following table shows the method signatures that correspond to each use:

`

Use	Method Signatures
Explicit	renderAsStream (String rendererType,String rendererName, Hashtable options) renderAsReader (String rendererType,String rendererName, Hashtable options)
Default	renderAsStream (String rendererType, null, Hashtable options) renderAsReader (String rendererType, null, Hashtable options)

Example: Explicit Choice of Renderer

To choose a specific renderer, specify the rendererName attribute. The following example shows how an application can explicitly specify the SimpleTextRenderer, assuming Stream input:

renderAsStream("RenderAsText", "SimpleTextRenderer", myOptions)

The options argument passes additional information to the specified renderer, such as character encoding. The available options, their settings, and the meanings of each option/setting pair are renderer-specific. In this example, the SimpleTextRenderer uses the myOptions Hashtable to obtain additional information. Consult the Javadoc for each standard renderer for more information about the options available.

Example: Accepting the Default Renderer

To accept the default renderer specified by Oracle iFS, substitute null for the rendererName attribute. The following example shows how an application can allow the repository to select the default renderer for this Document object, assuming that this Document object can have two default renderers:

• A default text renderer

• A default XML renderer

  renderAsStream("RenderAsText", null, myOptions)
  renderAsStream("RenderAsXML",null, myOptions)
  

Introduction to Custom Renderers

The only reason for creating a custom renderer is if one of the standard renderers provided with Oracle iFS does not allow you to render a repository object in the format required by a particular application.

Custom renderers can be used for many purposes:

• To render a repository object in the format required by an application. For example, a Vcard needs to be rendered in the format required by the Windows Addressbook application.

• To convert documents from one MIME type to another (for example, to convert from image/jpeg to image/gif).

• To create virtual documents based on calculation and manipulation of information in the repository.

• To construct compound documents, combining data from more than one source.

Note: The sample application and code used in this chapter are taken from the "XSL Custom Renderer Sample Application Technical Brief," downloadable from the Oracle Internet File System page of the Oracle Technology Network.

How Custom Renderers Work

To develop a custom renderer you need to understand how the information flows from the custom application to the custom renderer.

Step	Area	Description/Sample
1.	Client	The application requests that the object be rendered by calling the appropriate renderAsXxx() method. Example: Document.renderAsStream(rendererType, rendererName, options)
2.	Server	The server uses the rendererType and rendererName arguments to determine which renderer to invoke. The server invokes the renderer, passing the server-side representation of the object to be rendered and any options that were provided by the client. Example: Renderer.renderAsStream(S_Document, options)
3.	Renderer	The renderer receives the document representation and the options. The renderer then executes whatever custom code is needed to render the object in the format requested by the client.

Overview of a Renderer Application

When you plan a custom renderer application, include the following stages:

1. Write the Renderer Class.

2. Deploy the Renderer.

3. Invoke the Renderer.

Write the Renderer Class

When creating a custom renderer, you can choose from two approaches:

• If one of the existing Oracle iFS renderers partially meets the needs of your application, you can subclass an existing renderer. (Each of the existing Oracle iFS renderers implements the oracle.ifs.server.renderers.Renderer interface.)

• If you cannot use an existing Oracle iFS renderer as a starting point, you must create a custom class from scratch, directly implementing the oracle.ifs.server.renderers.Renderer interface.

Whichever approach you choose, writing a custom renderer means implementing the Renderer interface, either directly or indirectly. The Renderer interface defines the following two methods:

• renderAsStream()

• renderAsReader()

These renderAsXxxx() methods allow the Oracle iFS clients or a custom application to render documents in the required format.

The syntax and arguments for each method are described below.

To write a custom renderer:

• Write a constructor.

• Write a renderAsXxxx() method.

Write a Constructor

Every renderer must implement the standard constructor for a renderer. The standard constructor takes one parameter, as shown in the following table.

Parameter	Datatype	Description
session	S_LibrarySession	The server-side representation of the current user's LibrarySession.

Sample: Write a Constructor

 public AirportDynamicRenderer(S_LibrarySession ifs) throws IfsException
  {
    m_IfsSession = ifs;
  }

Write a renderAsXxxx() Method

The following table describes the parameters of the two renderAsXxxx() methods:

• renderAsStream()

• renderAsReader()

  
  

  Parameter	Datatype	Description
  lo	S_LibraryObject	The object to be rendered.
  options	Hashtable	Optional parameter. May be null. If specified, the options parameter further controls the behavior of the renderer through a set of optional name/value pairs. Commonly used to specify character encoding.

Example: Write the renderAsXxxx() Methods

The example builds up a string containing the required content and uses the StringBufferInputStream class to convert the string to an InputStream, which is the object this method returns.

The overall structure of this example is:

1. The renderAsStream() method calls renderAsString().

   The renderAsStream() method renders the specified LibraryObject as an InputStream.

2. The renderAsString() method calls renderAirport().

3. The renderAirport() method creates a String containing the required representation of the airport.

Sample Code: The renderAsStream() method

public InputStream renderAsStream(S_LibraryObject lo,
                                    Hashtable options)
    throws IfsException
  {
    InputStream in = null;
    String stream = renderAsString(lo, options);
    in = new ByteArrayInputStream(stream.getBytes());
    return in;
  }

Sample Code: The renderAsString() method

The renderAsString() method calls the renderAirport method and returns the result as a string.

public String renderAsString(S_LibraryObject lo,
                               Hashtable options)
    throws IfsException
  {
    String documentBody = null;
    documentBody = renderAirport(lo, options);
    return documentBody;
  }

Sample Code: The renderAirport() method

This method:

1. Renders an iFS object as XML with the iFS out-of-the-box SimpleXmlRenderer.

2. Obtains the XSL (stylesheet) passed in through parameter options.

3. Does the XSL transformation on the XML document from Step 1.

4. Returns the generated result.

   public String renderAirport(S_LibraryObject lo,
                                 Hashtable options)
     {
       
       String resultOutput = "";
       String xmlDoc = "";
   
       DOMParser parser = new DOMParser();
   
       try
       {
         //Retrieve the result from the SimpleXmlRenderer
         //This call is referencing the SimpleXMLRenderer, as defined
         //in the file AirportDefinitionPolicyBundle.xml.
         Reader reader = lo.renderAsReader("RenderXmlAirportDefinition",
                                           "AirportDefinitionXmlRenderer",
                                           null);
         BufferedReader r = new BufferedReader(reader);
         for (String nextLine = r.readLine(); nextLine != null; nextLine =
                                                             r.readLine())
           xmlDoc += nextLine;
   
         //Turn the XML String into an XML Document
         XMLDocument xml = ParseDocument(xmlDoc, parser);
   
         XMLDocument xsl = null;
         //Retrieves the XSL Style Sheet in a String format
         //from the Hashtable parameter (named options) passed in to the Renderer.
         String xslContent = (String)options.get("xsl");
         
         if (xslContent != null && xslContent.length() > 0 &&
                    !xslContent.toUpperCase().equals("NONE"))
         {
           try
           {
             //Turn XSL String into an XML Document
             xsl = ParseDocument(xslContent, parser);
           }
           catch (Exception e)
           {
             System.err.println("XSL : " + e.toString());
           }
         }
   
         if (xsl != null)
         {
           //Do the XSL Transformation.
           resultOutput = ProcessXML(xml, xsl, parser);
         }
         else
         {
           resultOutput = xmlDoc;
         }
       }
       catch (IfsException e)
       {
         resultOutput += ("<errorInRenderer type=\"IFS\">" + e.toString() +
                                                     "</errorInRenderer>");
       }
       catch (IOException e)
       {
         resultOutput += ("<errorInRenderer type=\"IO\">" + e.toString() +
                                                    "</errorInRenderer>");
       }
       //Return the result
       return resultOutput;
     }
   

Javadoc References

For more information about renderers, see the following classes in the Oracle iFS Javadoc.

Class	Purpose
oracle.ifs.server.renderers. Renderer	Interface that must be implemented for all renderers. Contains two key methods: renderAsStream() and renderAsReader().
oracle.ifs.server. renderers.XmlRenderer	Base class for creating a custom XML renderer. XmlRenderer converts an XML Document object into an InputStream or a Reader. Extend XmlRenderer to convert any S_LibraryObject into an XML Document representation.
oracle.ifs.server.renderers. SimpleXmlRenderer	Sample of a simple XML renderer based on XmlRenderer.
oracle.ifs.server.renderers. SimpleTextRenderer	Sample of a complete renderer for text.

Deploy the Renderer

For the protocol servers and other standard Oracle iFS components to access your custom renderer, the folder tree containing the class for the renderer must reside in the Oracle iFS CLASSPATH. Oracle iFS includes a special directory for this purpose. This directory, called custom_classes, is already in the CLASSPATH environment variable that the Oracle iFS server software uses.

To deploy a renderer:

1. Compile the renderer, creating a .class file.

2. Place the folder tree that contains the resulting .class file in the directory $ORACLE_HOME/ifs/custom_classes on the server where Oracle iFS is installed.

   
   

   Note: The compiled Java code must be copied to the native file system of the server, not to the Oracle iFS repository.

Register the Renderer

The process of registering a renderer connects a class of objects with a specific renderer. You can register a renderer using any of the following facilities:

Facility	Advantages/Restrictions
Oracle iFS Manager	Use Oracle iFS Manager for simplicity and ease-of-use. Using Oracle iFS Manager, you can only register a renderer that exists on the same instance of Oracle iFS as the Oracle iFS Manager facility.
XML	Use XML if you prefer to register a renderer using a script, or if you need to deploy the renderer on a separate Oracle iFS instance.
Java	Use Java for special cases: If you need register a renderer for a specific object, instead of a class. If you need to specify multiple renderers for the same object. For example, a document might be rendered by two renderers: one for an SMB application, another for an HTTP application.

No matter which facility you use, registering a render includes the following tasks:

• Create a Policy object.

• Set the attributes of that Policy object.

• Associate the Policy object (or the PolicyProperty Bundle containing it) with a specific class or classes.

For specific information about the attributes of Policy objects, see "Using PolicyPropertyBundles to Register Renderers".

Registering a Renderer Using Oracle iFS Manager

To register a renderer using Oracle iFS Manager, follow these steps:

1. From the Oracle iFS Manager Object menu, choose Register.

2. From the Select Object Type window, choose Renderer Lookup.

3. From the Renderer Lookup Registry window, choose Add.

4. On the Renderer Lookup Entry window, fill in the text boxes for the attributes.

5. From the Class Association list, select the class to associate with this renderer.

6. Click OK.

Registering a Renderer Using XML

To register a renderer using XML, write an XML file to update the PolicyProperty bundle, creating a mapping between a specific class (AirportDefinition) and its associated PolicyPropertyBundle (AirportDefinitionPolicyBundle).

<?xml version = '1.0' standalone = 'yes'?>
<CLASSOBJECT>
       	<update reftype= 'name'>AirportDefinition</update>
       	<policybundle reftype='name' classname='PolicyPropertyBundle'>
             		AirportDefinitionPolicyBundle
       	</policybundle>
</CLASSOBJECT>

Sample Code: AirportDefinitionPolicyBundle

This sample code creates the PolicyPropertyBundle object, which is a collection of Property objects. For details about the attributes of Policy objects, see "Using PolicyPropertyBundles to Register Renderers".

<?xml version="1.0" standalone="yes"?>
<POLICYPROPERTYBUNDLE>
  <NAME> AirportDefinitionPolicyBundle </NAME>
  <PROPERTIES>
    <PROPERTY>
      <NAME> RenderXmlAirportDefinition </NAME>
      <VALUE Datatype='SystemObject' Classname='Policy' >
        <NAME> AirportDefinitionXmlRenderer </NAME>
        <IMPLEMENTATIONNAME>
          oracle.ifs.server.renderers.SimpleXmlRenderer
        </IMPLEMENTATIONNAME>
        <OPERATION> RenderXmlAirportDefinition </OPERATION>
      </VALUE>
    </PROPERTY>
    <PROPERTY>
      <NAME> CompleteDynamicRenderer </NAME>
      <VALUE Datatype='SystemObject' Classname='Policy' >
        <NAME> AirportDefinitionCompleteRenderer </NAME>
        <IMPLEMENTATIONNAME>
          ifs.sampleapps.OlivAirlines.AirportDynamicRenderer
        </IMPLEMENTATIONNAME>
        <OPERATION> CompleteDynamicRenderer </OPERATION>
      </VALUE>
    </PROPERTY>
  </PROPERTIES>
</POLICYPROPERTYBUNDLE>

Invoke the Renderer

This servlet calls the custom renderer and passes it the appropriate XSL stylesheet based on which client is making the request, then renders the result to the client.

Sample Code: Invoke the Renderer

package ifs.sampleapps.OlivAirlines;

import javax.servlet.ServletConfig;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.io.PrintWriter;
import java.io.Reader;
import java.io.BufferedReader;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.util.Hashtable;

import oracle.ifs.common.IfsException;

import oracle.ifs.beans.Document;
import oracle.ifs.beans.LibraryObject;
import oracle.ifs.beans.LibraryService;
import oracle.ifs.beans.LibrarySession;
import oracle.ifs.beans.Selector;

import oracle.ifs.search.AttributeQualification;
import oracle.ifs.search.AttributeSearchSpecification;
import oracle.ifs.search.SearchClassSpecification;
import oracle.ifs.search.SearchSortSpecification;

import oracle.ifs.beans.Search;

 
public class iFSAirportServlet extends HttpServlet
{
 
  private static final boolean DEBUG = false;
  private static final int ERRORCODE = 22000;

 /**
  * Constructs the iFSAirportServlet.
  */
  public iFSAirportServlet()
  {
  }

 /**
  * The servlet container calls the init method exactly once
  * after instantiating the servlet. The init method must
  * complete successfully before the servlet can receive any requests.
  *
  * @param      ServletConfig config
  * @exception  An exception a servlet throws when it encounters difficulty.
  * @pub
  */

  public void init(ServletConfig config)
  throws ServletException
  {
    super.init(config);
  }


 /**
  * Called by the servlet container to allow the servlet to
  * respond to a request.
  * Calls the printContent method, which does the actual work.
  *
  * @param req  the ServletRequest object that contains the client's request.
  * @param res  the ServletResponse object that contains the servlet's respond.
  *
  * @exception  ServletException if an exception occurs that interferes with
  *                               the servlet's normal operation
  * @exception  java.io.IOException if an input or output exception occurs
  * @pub
  */
  public void service(HttpServletRequest request,
                      HttpServletResponse response)
  throws ServletException,
         IOException
  {
    // Retrieve Servlet's output stream
    PrintWriter out = new PrintWriter(response.getOutputStream());
    try
    {
      printContent(request, response, out);
    }
    catch (IfsException e)
    {
      out.println("<IfsException>" + e.toString() + "</IfsException>");
    }
    out.close();
  }

 /**
  * Calls the custom renderer and passes in the appropriate XSL
  * style sheet to the custom renderer based on which client is
  * making a request. Outputs the rendered result to the client.
  *
  * @param request  the ServletRequest object that contains the client's 
request.
  * @param resonse  the ServletResponse object that contains the servlet's 
respond.
  * @param out  for output
  * @exception  IfsException if operation fails.
  * @exception  IOException if an input or output exception occurs.
  * @pub
  */
  private void printContent(HttpServletRequest request,
                            HttpServletResponse response,
                            PrintWriter out) throws IOException,
                                                    IfsException
  {
    // Retrieve User-Agent to know which kind of client is making the request.
    String userAgent = request.getHeader("User-Agent");

    LibraryService service = new LibraryService();

    String userName = request.getParameter("userName");
    String passWord = request.getParameter("passWord");
    String serviceName = request.getParameter("serviceName");
    LibrarySession  ifs = service.connect(userName, passWord, serviceName);
    // Finds the iFS object we are doing to render with a Selector.
    Selector mySelector = new Selector(ifs);
    // Select the Airportdefinition class based on its attribute: AIRPORTCODE.
    mySelector.setSearchClassname("AIRPORTDEFINITION");

    // The airport code is passed in as a parameter provide along with the URL.
    String code  = request.getParameter("code");
    mySelector.setSearchSelection("AIRPORTCODE = '" + code + "'");
    for (int i=0; i<mySelector.getItemCount(); i++)
    {
      LibraryObject lo = mySelector.getItems(i);
      String contentType = "";
      
      Hashtable h = new Hashtable();
      // Check if a given string ("HANDHTTP" here) matchs any substring
      // of the User-Agent parameter passed in, case insensative.
      // If it matches, the corresponding style sheet is read from iFS,
      // and put in an Hashtable, to be passed in to the renderer.
      if (userAgent.toUpperCase().indexOf("HANDHTTP") > -1)
      {
         h.put("xsl", getStyleSheetContent(ifs, "apHTML.xsl"));
         contentType = "text/html";
      }
      else if (userAgent.toUpperCase().indexOf("MOZILLA") > -1)
      {
         h.put("xsl", getStyleSheetContent(ifs, "apHTML.xsl"));
         contentType = "text/html";
      }
      else if (userAgent.toUpperCase().indexOf("UP") > -1)
      {
         h.put("xsl", getStyleSheetContent(ifs, "apWAP.xsl"));
         contentType = "text/x-wap.wml";
      }
      else if (userAgent.toUpperCase().indexOf("NOKIA") > -1)
      {
         h.put("xsl", getStyleSheetContent(ifs, "apWAP.xsl"));
         contentType = "text/x-wap.wml";
      }
      else if (userAgent.toUpperCase().indexOf("MOTOROLA") > -1)
      {
         h.put("xsl", getStyleSheetContent(ifs, "apVox.xsl"));
         contentType = "text/html";
      }
      else
      { 
         h.put("xsl", "none");
      }

      response.setContentType(contentType);
     // Calls the custom renderer. Pass in the Hashtable
     // The custom renderer is registered in the
     // AirportDefinitionPolicyBundle.xml file.
     Reader reader = lo.renderAsReader("CompleteDynamicRenderer",                                        
"AirportDefinitionCompleteRenderer", h);
     // Reads results from the Reader, and prints to the Servlet output.
     printAirport(reader, out);
    } //end for loop
  }


 /**
 * This method seaches and gets the content of an iFS document, the XSL style
 * sheet that will be passed to the custom renderer, based on its file name.
 **/
 private static String getStyleSheetContent(LibrarySession ifs, String xslName)
   throws IfsException
  {
    String retString = "";

    String className[] = {"DOCUMENT"};
    SearchClassSpecification scs = new SearchClassSpecification(className);
    scs.addResultClass("DOCUMENT");
    AttributeQualification aq1 = new AttributeQualification();
    aq1.setAttribute("DOCUMENT", "NAME");
    aq1.setOperatorType(AttributeQualification.LIKE);
    aq1.setValue(xslName);
    SearchSortSpecification ss = new SearchSortSpecification();
    ss.add("NAME" , SearchSortSpecification.ASCENDING);
    AttributeSearchSpecification ass = new AttributeSearchSpecification();
    ass.setSearchClassSpecification(scs);
    ass.setSearchQualification(aq1);
    ass.setSearchSortSpecification(ss);
    Search srch = new Search(ifs, ass);
    srch.open(); 
    try   
    {  while (true) 
       {
          LibraryObject lo = srch.next().getLibraryObject();
          Document d = (Document)lo;
          InputStream is = d.getContentStream();
          BufferedReader br = new BufferedReader(new InputStreamReader(is));
          for (String nextLine = br.readLine(); nextLine != null; nextLine = 
br.readLine())
          {   	 
            retString += nextLine;
          }
          br.close();
        }  
    }    
    catch (IfsException e)
    {
      if (e.getErrorCode() == ERRORCODE)
      {    [Is this set of braces needed????}
       }
      else
      {
        throw e;
      }
    }
    catch (IOException ioe)
    {
       System.err.println("IOException reading XSL : " + ioe.toString());
    }
    srch.close();
    return retString;
  }

 /**
  * Prints out the renderer output to the client.
  *
  * @param reader   the renderer output passed in
  * @param out      for output
  */
  public static void printAirport(Reader reader,
                                  PrintWriter out)
  throws IOException
  {
     // Dumps the reader on the output.
     BufferedReader r = new BufferedReader(reader);
     for (String nextLine = r.readLine(); nextLine != null; nextLine = 
r.readLine())
     {
        out.println(nextLine);
     }
   }

 
}

Output from the Custom Renderer

To run the servlet:

1. Open a web browser.

2. Type the following command in the Location window:

   Http://machineName:portNumber/XSLRenderer?code=LAX&userName=
   yourUserName&passWord=yourPassWord&serviceName=yourServiceName

   where:

   machineName is the server name where the iFS is running.

   portNumber is the port where the Java Web Server is running. Get the port number by typing http://machineName:9090.

   yourUserName is the user you created during this example.

   yourPassWord is the password for this user.

   serviceName is the Service Name of iFS. The default for the Service Name is ServerManager.

You should see LAX and Los Angeles in the browser. You can change the code to SEA or SFO. For example:

http://bsmith-sun:80/XSLRenderer?code=LAX&userName=gking&passWord=ifs&serviceName=ServerManager

Access the Servlet from Different Devices

Try entering the command from the previous step into different devices to see what the output looks like.

Figure 6-1 Output of AirportDefinition as seen on a desktop HTML Browser

Figure 6-2 Output of AirportDefinition as seen on a cellphone

Figure 6-3 Output of AirportDefinition as seen on the HTML browser of a personal digital assistant.

Figure 6-4 Output of AirportDefinition as displayed through a Voice Simulator.