XSLTTemplate.java :  » Content-Management-System » webman » de » webman » template » xslt » Java Open Source

package de.webman.template.xslt;

import java.util.Enumeration;
import java.io.*;
import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;
import javax.xml.transform.Transformer;
import javax.xml.transform.dom.DOMSource;
import javax.xml.transform.stream.StreamResult;
import com.teamkonzept.lib.*;
import com.teamkonzept.lib.templates.*;
import de.webman.template.jsp.*;
import de.webman.util.xslt.XSLTTemplateCache;
import org.w3c.dom.Document;
import org.w3c.dom.Element;
import org.apache.log4j.Category;
import javax.servlet.http.HttpServletRequest;

/**
 * Implementierung der XSLT-Templates.
 * <P>
 * XSLT Templates werden vorcompiliert gehalten...
 *
 * @author $Author: uli $
 * @version $Revision: 1.9 $
 */
public class XSLTTemplate
  implements TemplateBasic,
         TemplateTypes

{

  /**
   * The logging category.
   */
  private static Category cat = Category.getInstance(XSLTTemplate.class);

  /** Name des Templates */
  private String name;

  /** erzeugter Text */
  private String text;

  /** Basisdirectory */
  private String rootDir;

  private DOMTemplateData data;

  /**
   * The absolute path name of the template.
   */
  private String path = null;

  /**
   * Creates a new JSP template.
   *
   * @param _docRoot the document root.
   * @param _name the template source name.
   * @param _editor the template editing mode.
   * @throws TKTemplateSyntaxException if the specified template source is errornous.
   */
  public XSLTTemplate (String _docRoot,
             String _name,
             boolean _editor)
    throws TKTemplateSyntaxException
  {
    try
    {
      rootDir = _docRoot;
      name = _name;
      // Build absolute path name.
      this.path = rootDir + File.separator;
      if (_editor)
        path += TemplateUtils.getWebmanTemplateDirectory() + File.separator;
      else
        path += TemplateUtils.getGenerationDirectory();
      path += name;

      data = new DOMTemplateData();
    }
    catch (Exception e)
    {
      cat.error("XSLT constructor: " , e);
    }
  }

  public void setOriginalRequest(HttpServletRequest request)
  {
  }

  public String getType()
  {
    return JSP_TEMPLATE;
  }

  void init() throws TKTemplateSyntaxException
  {
  }

  /**
    setzt Daten in die Root
  */
  public void set( TKHashtable aSubst )
  {
    data.set(aSubst);
  }

  public void set( String key, Object val )
  {
    data.set(key, val);
  }

  protected void resetData()
  {
    try
    {
      data = new DOMTemplateData();
    }
    catch (Exception e)
    {
      cat.error("Unable to reset Data", e);
    }
  }

  public synchronized void sendData (Element node, PrintWriter out)
  {
    try
    {
      // Lookup transformer for stylesheet and perform transformation.
      XSLTTemplateCache.getTransformer(this.path)
               .transform(new DOMSource(node), new StreamResult(out));

      // Flush result.
      out.flush();
    }
    catch (Exception e)
    {
      cat.error("sendData: " + e.getMessage(), e);
    }
    finally
    {
      resetData();
    }
  }

  /**
     * Das substituierte Template wird als String zurueckgegeben.
     * Hierfuer muss die Instanzvariable "text" mit dem Text eines Templates
     * zuvor gefuellt werden. Dies geschieht, indem die Tags im Template zuerst
     * substituiert werden.
   * @return einen String des substituierten Templates
     */
  public String getText()
  {
    return text;
  }

    /**
     * Das Template wird in den PrintStream geschrieben.
     * Hierfuer muss die Instanzvariable "text" mit dem Text eines Templates
     * zuvor gefuellt werden. Dies geschieht, indem die Tags im Template zuerst
     * substituiert werden.
     *
     */
  public void printTemplate( PrintStream out )
  {
    sendData(data.getRoot(), new PrintWriter(out));
  }

  /**
     * Das Template wird in den Writer geschrieben.
     * Hierfuer muss die Instanzvariable "text" mit dem Text eines Templates
     * zuvor gefuellt werden. Dies geschieht, indem die Tags im Template zuerst
     * substituiert werden.
     *
     */
  public void printTemplate( Writer writer ) throws IOException
  {
    sendData(data.getRoot(), new PrintWriter(writer));
  }

  /**
   * Das substituierte Template wird in ein File geschrieben werden.
   * Hierfuer muss die Instanzvariable "text" mit dem Text eines Templates
     * zuvor gefuellt werden. Dies geschieht, indem die Tags im Template zuerst
     * substituiert werden.
     *
     * Bsp. Reihenfolge der Aufrufe:
     *    TKTemplateObject.doTagSubstitution();
   *    TKTemplateObject.doCleanup();
   *    TKTemplateObject.printTemplate(String file)
   *
   * @param String file, der Filename des zu speichernden templates
   */
  public void printTemplate(String file) throws IOException
  {
    FileWriter w = new FileWriter(file);
    sendData(data.getRoot(), new PrintWriter(w));
  }

    /**
     * Das Template wird auf stdout geschrieben.
     * Hierfuer muss die Instanzvariable "text" mit dem Text eines Templates
     * zuvor gefuellt werden. Dies geschieht, indem die Tags im Template zuerst
     * substituiert werden.
     *
     */
  public void printTemplate()
  {
    throw new RuntimeException("Method not implemented !");
  }

  public DOMTemplateData getDOMData()
  {
    return data;
  }

  /**
   * Durch den Aufruf der Methode doMainSubstitution enthaelt die
   * Instanzvariable "text" das Template mit den substituierten TKTags.
   * Die nicht vollstaendigen Pfade werden ersetzt.
   *
   * Die URL-Base ist gestzt, wenn Images ausserhalb des CGI-Verzeichnisses
   * abgelegt sind. Fuer diese Bilder muss der vollstaendige Pfad im
   * Template gesetzt werden.
   */
  public void doTagSubstitution() throws TKTemplateSyntaxException
  {
    doMainSubstitutions();
  }

  /**
   * Die Instanzvariable "text" enthaelt das Template mit den
   * substituierten TKTags
   *
   *
   */
  public void doMainSubstitutions() throws TKTemplateSyntaxException
  {
    /*
    StringWriter w = new StringWriter();
    sendData(data.getRoot(), new PrintWriter(w));
    text = w.toString();*/
  }

}