TKTemplateData.java :  » Content-Management-System » webman » com » teamkonzept » lib » templates » Java Open Source

package com.teamkonzept.lib.templates;

//import com.teamkonzept.lib.templates.xml.*;
import com.teamkonzept.lib.*;
import org.w3c.dom.*;
import de.webman.util.legacy.Legacy;

/**
 * In dieser Klasse werden die Ersetzungsdaten eines Templates verwaltet.
 *
 * @author $Author: sebastian $
 * @version $Revision: 1.25 $
 */
public class TKTemplateData
{

     /** incl. DOM Daten */
    private DOMTemplateData domData;

    /** Parent Template */
  public TKTemplateData parent        = null;

  /** die TemplateVariablen */
  private TKHashtable variables        = new TKHashtable();

  /** Lookup fuer Listenteilstuecke */
  private TKTemplateData lookup = null;

  /** der Listiterator */
  private TKListIterator listIterator      = null;

  /** a hashtable of hashtables */
  public TKHashtable enumerationContext    = new TKHashtable();


  /**
   * Creates a new template data container.
   */
  public TKTemplateData ()
  {
    // NOP.
  }

  /**
   * Creates a new template data container with the given parent.
   *
   * @param td the parent template data container.
   */
  public TKTemplateData (TKTemplateData td)
  {
    if (td == null)
    {
      return;
    }

    this.listIterator = td.listIterator;
    this.parent = td;

    merge(td);
  }

  /** @return DOMTemplateData */
  public DOMTemplateData getDOMData()
  {

    try
    {
      if (domData == null)
        domData = new DOMTemplateData();
      return domData;
    }
    catch (Exception e)
    {
      return null;
    }
  }

  /**
    Die Methode wird vor dem apply-Aufruf des zugeordneten Syntax-Objekts
    aufgerufen um eventuelle globalen Vorbereitungen fr die Tag-Ersetzung
    durchzufhren
   */
  public void prepareApply()
  {
  }

  public TKListIterator getListIterator()
  {
//    if (domData == null)
      return listIterator;
//
//    return new DOMListIterator((DOMModel)domData);

  }

  public void setListIterator(TKListIterator iterator)
  {
    listIterator = iterator;
  }

  /**
    Die Methode wird vor dem apply-Aufruf des Listen-Sub-Syntax-Objekts
    aufgerufen um eventuelle globalen Vorbereitungen fr die Tag-Ersetzung
    durchzufhren, bzw. um die in der ueren Syntax definierten, und in
    td bergebenene  Ersetzungsdaten zu bernehmen
   */
  public void setMergedApply( TKTemplateData td )
  {
    lookup = td;
    /* wer hatte das rausgenohmen und wieso ? ohne funktioniert die 1.5 nicht (Bug 789) */
    variables = (( variables == null || variables.size() == 0 )
      ? td.variables
      : TKHashtable.merge( variables, td.variables )
    );
  }

  /**
    Erzeugt eine neue Hashtabelle aus der alten und der Uebergebenen, wobei
    im Unterschied zu prepareMergedApply() auf jeden Fall ein neuer Scope
    erzeugt wird, d.h. die uebergebene Tabelle nur kopiert wird und nicht evtl.
    die alte ersetzt. Vorhandene Eintraege in der alten bleiben erhalten
    (siehe TKHashtable.merge());
   */
  public void merge ( TKTemplateData td )
  {
    if (variables == null) variables = new TKHashtable();

    if ((td != null) && (td.variables != null))
      variables.merge (td.variables);
  }

  public void setVariable( Object key, Object value )
  {
    if( (parent == null) || (parent.variables != variables) ) {
      variables.put( key, value );
    }
    if( parent != null ) {
      parent.setVariable( key, value );
    }
  }

  public void mergeVariables(TKHashtable merger)
  {
    variables.merge(merger);
  }

  public void concatVariables(TKHashtable merger)
  {
    variables.concat(merger);
  }

  public void removeVariable(String key)
  {
    variables.remove(key);
  }

  public Object getVariable(Object key)
  {
    Object back = variables.get(key);
    if (back == null && lookup != null)
      back = lookup.getVariable(key);
//    if (back == null && domData != null)
//      back = ((DOMModel)domData).getVariable((String) key);
    return back;
  }

  public void setLocalVariable( Object key, Object value )
  {
    variables.put( key, value );
  }

  public void extendVariable( String key, Object value )
  {
    variables.extend( key, value );
  }


  /**
  in nested lists, there is sometimes the neccessarity to pass some data from
  the implementation of the outer iterator to the implementation of the inner
  iterator. this can be done by the enumeration context. the implementation
  ensures, that a enumerationContext which is set by a call of the apply-method
  of the outer iterator is available to all corresponding apply-calls of the
  inner iterator.
  */

  public void setEnumerationContext( Object key, Object value )
  {
    enumerationContext.put( key, value );
  }

  /**
  @see setEnumerationContext
  */

  public Object getEnumerationContext(Object key )
  {
    Object result;
    return ((result = enumerationContext.get( key )) == null)
      ? ( parent == null ? null : parent.getEnumerationContext( key ) )
      : result;
  }

}