/*
    * Created on Jul 30, 2005. Copyright 1999-2006 Faculty of Mathematics, Physics
    * and Informatics, Comenius University, Bratislava. This file is protected by
    * the Mozilla Public License version 1.1 (the "License"); you may not use this
    * file except in compliance with the License. You may obtain a copy of the
    * License at http://euromath2.sourceforge.net/license.html Unless required by
    * applicable law or agreed to in writing, software distributed under the
    * License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS
    * OF ANY KIND, either express or implied. See the License for the specific
   * language governing permissions and limitations under the License.
   */
  package sk.uniba.euromath.gene;
  import java.io.File;
  import java.io.IOException;
  import java.util.ArrayList;
  import java.util.EnumSet;
  import java.util.HashMap;
  import java.util.HashSet;
  import java.util.List;
  import java.util.Map;
  import java.util.Set;
  import javax.xml.transform.Result;
  import javax.xml.transform.Source;
  import javax.xml.transform.dom.DOMResult;
  import javax.xml.transform.dom.DOMSource;
  import javax.xml.transform.stream.StreamResult;
  import org.w3c.dom.Document;
  import org.w3c.dom.DocumentFragment;
  import org.w3c.dom.Element;
  import org.w3c.dom.Node;
  import org.w3c.dom.ProcessingInstruction;
  import sk.baka.ikslibs.ObjectSource;
  import sk.baka.ikslibs.ResultEnum;
  import sk.baka.ikslibs.SourceEnum;
  import sk.baka.ikslibs.TransformUtils;
  import sk.baka.ikslibs.modify.DOMChangeCollector;
  import sk.baka.ikslibs.modify.IChangeCollector;
  import sk.baka.ikslibs.modify.ObjectChangeCollector;
  import sk.baka.ikslibs.splitted.SplittedDocHolder;
  import sk.baka.xml.gene.CoordinatorInfo;
  import sk.baka.xml.gene.CoordinatorInputKey;
  import sk.baka.xml.gene.ExportContext;
  import sk.baka.xml.gene.ExportException;
  import sk.baka.xml.gene.ExportUtils;
  import sk.baka.xml.gene.IConfigurator;
  import sk.baka.xml.gene.ICoordinator;
  import sk.baka.xml.gene.IExporter;
  import sk.baka.xml.gene.controller.NamespacePath;
  import sk.baka.xml.gene.exportgraph.ExportGraphBuilder;
  import sk.baka.xml.gene.exportgraph.TransformGraph;
  import sk.uniba.euromath.document.XMLAccess;
  import sk.uniba.euromath.editor.EditorException;
  import sk.uniba.euromath.editor.EditorSite;
  import sk.uniba.euromath.editor.IInputPreprocessor;
  import sk.uniba.euromath.editor.IRenderer;
  import sk.uniba.euromath.editor.RendererInfo;
  import sk.uniba.euromath.editor.RendererSelector;
  import sk.uniba.euromath.tools.StringTools;
  import sk.uniba.euromath.tools.URLDir;
  /***
   * <p>
   * Acts as a GENE coordinator. Collects GENE output, instantiates and
   * initializes renderers, and fires events on document change.
   * </p>
   * <h3>Implementation of GENE output handler</h3>
   * <p>
   * The object produces a special tree (using the
   * {@link Coordinator#partialResultEvent(DocumentFragment, NamespacePath, Source, String, CoordinatorInputKey)}
   * function), that is processed by the object itself on
   * {@link Coordinator#finishExport()} function. This tree is intended to capture
   * the tree structure of nametrees in output document (and renderers, rendering
   * these nametrees).
   * </p>
   * <p>
   * Each
   * {@link Coordinator#partialResultEvent(DocumentFragment, NamespacePath, Source, String, CoordinatorInputKey)}
   * constructs (or updates) a renderer, associates it with the
   * {@link CoordinatorInputKey key} and produces some elements. These elements
   * must be able to provide:
   * </p>
   * <ul>
   * <li>a mapping from GENE-providen ID (given to the renderer via the
   * <code>emp:mark</code> element) to the key (we must be able to provide child
   * renderers to a renderer, that uses ID as their identification key), and</li>
   * <li>a parent-child relation for renderers, to verify renderers requirements
   * for child renderers.</li>
   * </ul>
   * <p>
   * These elements are produced:
   * </p>
   * <ul>
   * <li><code>ref</code> element - serves for identification of the renderer.
   * Contains attribute <code>id</code> that uniquely identifies key in the
   * renderer tree.</li>
   * <li>We must store ids for each child nametree. Thus, each
   * <code>emp:mark</code> element is copied and placed in
   * <code>child-renderer</code>, whose ID attribute identifies the child
   * nametree (it is a copy of <code>emp:id</code> element placed in the
   * <code>emp:mark</code> element).</li>
  * </ul>
  * <p>
  * <code>ref</code> element will receive same namespace as the input of the
  * renderer it references. All child <code>child-renderer</code> elements will
  * have same namespace as their parent <code>ref</code>. This will allow GENE
  * to provide correct namespace paths.
  * </p>
  * <p>
  * Following this algorithm (when GENE resolves all <code>emp:mark</code>
  * elements) we receive this document in the <code>finishExport()</code>
  * method: root element is <code>keyref</code> identifying root renderer. Each
  * <code>keyref</code> contains zero or more <code>child-renderer</code>
  * elements, containing ids of children renderers. Each
  * <code>child-renderer</code> contains one <code>keyref</code> element,
  * identifying this renderer, etc.
  * </p>
  * @author Martin Vysny
  */
 public final class GeneDataProvider {
 	/***
 	 * Localname (and qname, because of <code>null</code> namespace) of the
 	 * <code>keyref</code> element.
 	 */
 	private final static String KEYREF_ELEMENT_NAME = "keyref"; //$NON-NLS-1$
 	/***
 	 * Localname (and qname, because of <code>null</code> namespace) of the
 	 * <code>child-renderer</code> element.
 	 */
 	private final static String CHILD_RENDERER_ELEMENT_NAME = "child-renderer"; //$NON-NLS-1$
 	/***
 	 * Localname (and qname, because of <code>null</code> namespace) of the
 	 * <code>id</code> attribute.
 	 */
 	private final static String ID_ATTRIBUTE_NAME = "id"; //$NON-NLS-1$
 	/***
 	 * Constructor.
 	 * @param selector the renderer selector.
 	 * @param xmlAccess the transformed document.
 	 * @param edr the data receiver.
 	 */
 	public GeneDataProvider(final RendererSelector selector,
 			final XMLAccess xmlAccess, final IEditorDataReceiver edr) {
 		super();
 		this.selector = new RendererSelector(selector);
 		this.coordinator = new Coordinator();
 		this.coordinator.edr = edr;
 		edr.initReceiver();
 		this.context = new RendererContext(this.coordinator.geneIdMapping,
 				this.coordinator.rendererKeys, xmlAccess);
 		// construct accepted namespaces map.
 		final Map<String, EnumSet<SourceEnum>> accepts = selector
 				.getRenderable();
 		// create the coordinator info instance.
 		this.coordinatorInfo = new CoordinatorInfo(COORDINATOR_ID, null,
 				"The GENE output to editor framework data redirector", //$NON-NLS-1$
 				"application/X-gene-direct-rendering", null, accepts); //$NON-NLS-1$
 	}
 	/***
 	 * The renderer selector instance.
 	 */
 	private final RendererSelector selector;
 	/***
 	 * Returns the coordinator instance - this object receives GENE output.
 	 * @return GENE's coordinator instance.
 	 */
 	public ICoordinator getCoordinator() {
 		return this.coordinator;
 	}
 	/***
 	 * The coordinator id.
 	 */
 	private final static String COORDINATOR_ID = GeneDataProvider.class
 			.getName()
 			+ GeneDataProvider.class.hashCode();
 	/***
 	 * <p>
 	 * GENE's coordinator instance, captures GENE output and builds a tree of
 	 * renderers.
 	 * </p>
 	 * <p>
 	 * The following properties are valid when the GENE data receiving is
 	 * complete:
 	 * </p>
 	 * <ul>
 	 * <li>{@link #rendererKeys} - maps coordinator 'pipe' key to the renderer,
 	 * processing the pipe output.</li>
 	 * <li>{@link #rootKey} - defines root nametree and its renderer.</li>
 	 * <li>{@link #geneIdMapping} - useful for {@link RendererContext} to
 	 * resolve GENE-specific IDs (passed in form of <code>emp:mark</code>
 	 * elements in Source to the renderer) into the renderer instances.</li>
 	 * <li>{@link #nametreeHierarchy} - defines the nametree hierarchy. Useful
 	 * for {@link EditorSite} when creating IEditor instances.</li>
 	 * <li>{@link #newKeys} and {@link #deletedKeys} - shows new or deleted
 	 * nametrees.</li>
 	 * </ul>
 	 * @author Martin Vysny
 	 */
 	private final class Coordinator implements ICoordinator {
 		/***
 		 * The data receiver.
 		 */
 		private IEditorDataReceiver edr;
 		/***
 		 * Constructor.
 		 */
 		public Coordinator() {
 			super();
 		}
 		/*
 		 * (non-Javadoc)
 		 * @see sk.uniba.euromath.api.export.ICoordinator#finishExport()
 		 */
 		public void finishExport() throws ExportException, IOException {
 			// process the rendererTree
 			final DocumentFragment frag = (DocumentFragment) this.rendererTree
 					.getNode();
 			// the tree must contain a sole keyref element
 			final Element rootKeyRef = (Element) frag.getFirstChild();
 			assert rootKeyRef != null;
 			this.geneIdMapping.clear();
 			this.rootKey = processHierarchy(rootKeyRef);
 			// we have the hierarchy. the DOM tree is no longer needed, let gc
 			// get rid of it.
 			this.rendererTree = null;
 			this.keyMap.clear();
 			// we have to remove all deleted keys from our structures.
 			this.rendererKeys.keySet().removeAll(this.deletedKeys);
 			// now, all structures are filled correctly. Initialize all
 			// renderers.
 			// note that the context is already initialized and configured
 			// properly - it works on live maps.
 			// we have to carefully initialize renderers - we must not try to
 			// initialize renderer that have not-yet-initialized descendant
 			// renderers.
 			try {
 				initializeRenderer(this.rootKey);
 			} catch (EditorException ex) {
 				throw new ExportException("Failed to initialize renderers", ex); //$NON-NLS-1$
 			}
 			// inform EditorSite that changes were made.
 			try {
 				this.edr.dataChanged(this.rendererKeys, this.rootKey,
 						this.nametreeHierarchy, this.geneIdMapping,
 						this.newKeys, this.deletedKeys);
 			} catch (EditorException ex) {
 				throw new ExportException(ex);
 			}
 		}
 		/***
 		 * Processes hierarchy of <code>keyref</code> and
 		 * <code>child-renderer</code> elements.
 		 * @param keyRef the <code>keyref</code> element.
 		 * @return the coordinator input key, represented by the
 		 * <code>keyref</code> element.
 		 */
 		private CoordinatorInputKey processHierarchy(final Element keyRef) {
 			assert keyRef.getLocalName().equals(KEYREF_ELEMENT_NAME);
 			final String id = keyRef.getAttributeNS(null, ID_ATTRIBUTE_NAME);
 			assert id != null;
 			final CoordinatorInputKey key = this.keyMap.get(id);
 			assert key != null;
 			// process child elements and create the key hierarchy.
 			Set<CoordinatorInputKey> children = this.nametreeHierarchy.get(key);
 			if (children == null) {
 				children = new HashSet<CoordinatorInputKey>();
 				this.nametreeHierarchy.put(key, children);
 			}
 			for (Element childRenderer = (Element) keyRef.getFirstChild(); childRenderer != null; childRenderer = (Element) childRenderer
 					.getNextSibling()) {
 				assert childRenderer.getLocalName().equals(
 						CHILD_RENDERER_ELEMENT_NAME);
 				final String geneId = childRenderer.getAttributeNS(null,
 						ID_ATTRIBUTE_NAME);
 				assert geneId != null;
 				// it must have exactly one keyref element.
 				final Element childKeyRef = (Element) childRenderer
 						.getFirstChild();
 				assert childKeyRef.getNextSibling() == null;
 				final CoordinatorInputKey childKey = processHierarchy(childKeyRef);
 				// register this mapping
 				this.geneIdMapping.put(geneId, childKey);
 				children.add(childKey);
 			}
 			return key;
 		}
 		/***
 		 * Initializes renderer with given key. Children renderers are
 		 * initialized before the renderer itself, to prevent queries for
 		 * uninitialized renderers.
 		 * @param key identifies the renderer to be initialized.
 		 * @throws EditorException
 		 */
 		private void initializeRenderer(final CoordinatorInputKey key)
 				throws EditorException {
 			// initialize children
 			Set<CoordinatorInputKey> children = this.nametreeHierarchy.get(key);
 			if ((children != null) && !children.isEmpty()) {
 				for (final CoordinatorInputKey child : children) {
 					initializeRenderer(child);
 				}
 			}
 			// now, initialize the renderer itself.
 			final RendererSite site = this.rendererKeys.get(key);
 			site.init();
 		}
 		/*
 		 * (non-Javadoc)
 		 * @see sk.uniba.euromath.api.export.ICoordinator#getGraphBuilder()
 		 */
 		public ExportGraphBuilder getGraphBuilder() {
 			// Let GENE build the export graph.
 			return new ExportGraphBuilder();
 		}
 		/*
 		 * (non-Javadoc)
 		 * @see sk.uniba.euromath.api.export.ICoordinator#getSource(java.lang.String)
 		 */
 		public EnumSet<SourceEnum> getSource(String namespace) {
 			return GeneDataProvider.this.coordinatorInfo.getSource(namespace);
 		}
 		/*
 		 * (non-Javadoc)
 		 * @see sk.uniba.euromath.api.export.ICoordinator#getTransformationGraph()
 		 */
 		public TransformGraph getTransformationGraph() {
 			// we should not get here
 			throw new AssertionError("Should not be called."); //$NON-NLS-1$
 		}
 		/*
 		 * (non-Javadoc)
 		 * @see sk.uniba.euromath.api.export.ICoordinator#offerObject(java.lang.String)
 		 */
 		public Object offerObject(String namespace) throws ExportException {
 			namespace = StringTools.nonNullStr(namespace);
 			// call appropriate renderer to query for the object.
 			final List<RendererSite> renderers = this.rendererNamespaces
 					.get(namespace);
 			if ((renderers == null) || renderers.isEmpty()) {
 				// construct a renderer instance and place it into the temporary
 				// storage.
 				try {
 					final RendererInfo info = GeneDataProvider.this.selector
 							.getRendererInfo(namespace, EnumSet
 									.of(ResultEnum.OBJECT));
 					final IRenderer renderer = info.newRenderer();
 					this.tempStorage.put(namespace, renderer);
 					return renderer.offerObject();
 				} catch (EditorException ex) {
 					throw new ExportException(ex);
 				}
 			}
 			for (final RendererSite r : renderers) {
 				if (r.renderer.getInfo().sourceTypes
 						.contains(SourceEnum.OBJECT))
 					return r.renderer.offerObject();
 			}
 			return null;
 		}
 		/*
 		 * (non-Javadoc)
 		 * @see sk.uniba.euromath.api.export.ICoordinator#partialResultEvent(org.w3c.dom.DocumentFragment,
 		 * sk.uniba.euromath.api.export.controller.NamespacePath,
 		 * javax.xml.transform.Source, java.lang.String,
 		 * sk.uniba.euromath.api.export.CoordinatorInputKey)
 		 */
 		public Source partialResultEvent(final DocumentFragment processed,
 				final NamespacePath path, final Source source,
 				final String sourceNamespace, final CoordinatorInputKey key)
 				throws ExportException, IOException {
 			// get the instance of renderer that will process given source.
 			RendererSite renderer = null;
 			// first check if it isn't in temp storage
 			IRenderer r = this.tempStorage.get(sourceNamespace);
 			if ((r != null)
 					&& r.getInfo().sourceTypes.contains(SourceEnum
 							.valueOf(source.getClass()))) {
 				// yeah. move it between regular renderers.
 				this.tempStorage.remove(sourceNamespace);
 				renderer = registerRenderer(r, key);
 				assert renderer.getSource() == null;
 			}
 			// if no renderer is found, try to retrieve it from the rendererKeys
 			// map.
 			if (renderer == null) {
 				renderer = this.rendererKeys.get(key);
 				if (renderer != null) {
 					// gotcha.
 					assert renderer.getSource() != null;
 				}
 			}
 			// if no renderer is found, we have to create one.
 			if (renderer == null) {
 				final EnumSet<ResultEnum> sourceKind = EnumSet.of(SourceEnum
 						.valueOf(source.getClass()).getPair());
 				try {
 					final RendererInfo info = GeneDataProvider.this.selector
 							.getRendererInfo(sourceNamespace, sourceKind);
 					r = info.newRenderer();
 					renderer = registerRenderer(r, key);
 					assert renderer.getSource() == null;
 				} catch (EditorException ex) {
 					throw new ExportException(ex);
 				}
 			}
 			assert renderer != null;
 			this.keyMap.put(this.rendererKeys.get(key).id, key);
 			// if(source instanceof DOMSource){
 			// ExportHelper.serializeDOM(new
 			// FileOutputStream("C:/srcfragment.xml"),null,null,processed);
 			// ExportHelper.serializeDOM(new
 			// FileOutputStream("C:/src.xml"),null,null,((DOMSource)source).getNode());
 			// }
 			renderer.setSource(source);
 			// ok, renderer is instantiated and registered correctly. return the
 			// keyref element, with all emp:mark elements as children.
 			final DOMSource result = new DOMSource();
 			result.setNode(createHierarchyElement(source, renderer));
 			// this key is present in current data thus is not deleted.
 			this.deletedKeys.remove(key);
 			return result;
 		}
 		/***
 		 * Registers renderer into the <code>rendererKeys</code> and
 		 * <code>rendererNamespaces</code>.
 		 * @param renderer renderer to register. Must not be initialized.
 		 * @param key
 		 * @return the socket instance.
 		 */
 		private RendererSite registerRenderer(final IRenderer renderer,
 				final CoordinatorInputKey key) {
 			final RendererSite rs = new RendererSite(renderer, key);
 			if (this.rendererKeys.put(key, rs) != null)
 				throw new IllegalArgumentException(
 						"renderer is already registered under key " + key); //$NON-NLS-1$
 			List<RendererSite> renderers = this.rendererNamespaces
 					.get(key.targetNamespace);
 			if (renderers == null) {
 				renderers = new ArrayList<RendererSite>();
 				this.rendererNamespaces.put(key.targetNamespace, renderers);
 			}
 			renderers.add(rs);
 			this.newKeys.add(key);
 			return rs;
 		}
 		/***
 		 * Creates the <code>keyref</code> element, containing all
 		 * <code>emp:mark</code> elements.
 		 * @param source the data source. In case of Object source, no
 		 * <code>emp:mark</code> are generated. This probably changes later,
 		 * but it requires wide GENE changes.
 		 * @param renderer the renderer.
 		 * @return the <code>keyref</code> element.
 		 */
 		private Element createHierarchyElement(final Source source,
 				final RendererSite renderer) {
 			final Element result = doc.createElementNS(renderer.renderer
 					.getInfo().sourceNamespace, KEYREF_ELEMENT_NAME);
 			result.setAttributeNS(null, ID_ATTRIBUTE_NAME, renderer.id);
 			if (source instanceof ObjectSource) {
 				// no known way to retrieve emp:mark elements from an object,
 				// just quit.
 				return result;
 			}
 			// retrieve all emp:mark elements, clone them and put them as
 			// children into the 'result' element.
 			// no need to have several emp:mark with same ids. Remember all used
 			// ids in this set and filter them out.
 			final List<ProcessingInstruction> mark = new ArrayList<ProcessingInstruction>();
 			getDescendantMarkElements(((DOMSource) source).getNode(), mark,
 					new HashSet<String>());
 			// enclose all mark elements in the 'child-renderer' element.
 			for (final ProcessingInstruction m : mark) {
 				final Element cr = doc.createElementNS(
 						result.getNamespaceURI(), CHILD_RENDERER_ELEMENT_NAME);
 				final String empId = SplittedDocHolder.getGeneRef(m);
 				cr.setAttributeNS(null, ID_ATTRIBUTE_NAME, empId);
 				final Element clone = (Element) doc.importNode(m, true);
 				cr.appendChild(clone);
 				result.appendChild(cr);
 			}
 			return result;
 		}
 		/***
 		 * Retrieves all {@link SplittedDocHolder#PI_GENEREF_TARGET} processing instructions. Filters out multiple
 		 * instances of {@link SplittedDocHolder#PI_GENEREF_TARGET} with same id.
 		 * @param node walk through descendants of this node. Returns empty list
 		 * when <code>null</code>.
 		 * @param refs place all ref PIs here.
 		 * @param ids ids of elements present in the result.
 		 */
 		private void getDescendantMarkElements(final Node node,
 				List<ProcessingInstruction> refs, Set<String> ids) {
 			if (node == null)
 				return;
 			final String id = SplittedDocHolder.getGeneRef(node);
 			if(id!=null){
 				if (ids.contains(id))
 					return;
 				// not yet present in the mark list, append it.
 				ids.add(id);
 				refs.add((ProcessingInstruction)node);
 			}
 			// walk through its children.
 			for (Node child = node.getFirstChild(); child != null; child = child
 					.getNextSibling()) {
 				getDescendantMarkElements(child, refs, ids);
 			}
 		}
 		/*
 		 * (non-Javadoc)
 		 * @see sk.baka.xml.gene.ICoordinator#dispose()
 		 */
 		public void dispose() {
 			// nothing to free
 		}
 		/*
 		 * (non-Javadoc)
 		 * @see sk.baka.xml.gene.ICoordinator#getConfigurator()
 		 */
 		public IConfigurator getConfigurator() {
 			// nothing to configure
 			return null;
 		}
 		/*
 		 * (non-Javadoc)
 		 * @see sk.baka.xml.gene.ICoordinator#getInfo()
 		 */
 		public CoordinatorInfo getInfo() {
 			return coordinatorInfo;
 		}
 		/*
 		 * (non-Javadoc)
 		 * @see sk.uniba.euromath.api.export.ICoordinator#requestResult(java.lang.String)
 		 */
 		public StreamResult requestResult(String fileName) throws IOException {
 			final StreamResult result = new StreamResult(fileName);
 			result.setOutputStream(ExportUtils.openStream(new File(fileName)));
 			return result;
 		}
 		/*
 		 * (non-Javadoc)
 		 * @see sk.baka.xml.gene.ICoordinator#startExport(java.io.File)
 		 */
 		public Result startExport(File systemId) throws ExportException,
 				IOException {
 			assert this.keyMap.isEmpty();
 			// prepare internal structures
 			this.geneIdMapping.clear();
 			this.newKeys.clear();
 			this.deletedKeys.clear();
 			this.deletedKeys.addAll(this.rendererKeys.keySet());
 			// ignore all parameters, just return result where a DOM tree will
 			// be constructed.
 			this.rendererTree = new DOMResult();
 			this.rendererTree.setNode(doc.createDocumentFragment());
 			return this.rendererTree;
 		}
 		/***
 		 * <p>
 		 * Here a coordinator output is written. This output is intended to show
 		 * the tree hierarchy of renderers. For further description please see
 		 * {@link #partialResultEvent(DocumentFragment, NamespacePath, Source, String, CoordinatorInputKey)}.
 		 * </p>
 		 */
 		private DOMResult rendererTree = null;
 		/***
 		 * <p>
 		 * Maps input pipe ID to a renderer instance. Filled in
 		 * {@link #partialResultEvent(DocumentFragment, NamespacePath, Source, String, CoordinatorInputKey)}
 		 * method.
 		 * </p>
 		 * <p>
 		 * {@link #deletedKeys Deleted keys} are automatically removed in
 		 * {@link #finishExport()}.
 		 * </p>
 		 */
 		public final Map<CoordinatorInputKey, RendererSite> rendererKeys = new HashMap<CoordinatorInputKey, RendererSite>();
 		/***
 		 * Maps namespace of the document that the renderer processes, to a
 		 * renderer instance. Contains same renderer instances as
 		 * {@link #rendererKeys}.
 		 */
 		private final Map<String, List<RendererSite>> rendererNamespaces = new HashMap<String, List<RendererSite>>();
 		/***
 		 * <p>
 		 * Temporary storage of renderer instances. When coordinator is queried
 		 * for object offer and no renderer for given namespace exists, one is
 		 * constructed and placed here. When the instance is really needed, it
 		 * is moved to {@link #rendererKeys} and {@link #rendererNamespaces}
 		 * maps.
 		 * </p>
 		 * <p>
 		 * Only renderers able to process Object source are placed here.
 		 * </p>
 		 */
 		private final Map<String, IRenderer> tempStorage = new HashMap<String, IRenderer>();
 		/***
 		 * Maps {@link RendererSite}'s id to the coordinator input key. Filled
 		 * in
 		 * {@link #partialResultEvent(DocumentFragment, NamespacePath, Source, String, CoordinatorInputKey)}
 		 * method, and cleared when the GENE output processing finishes.
 		 */
 		private final Map<String, CoordinatorInputKey> keyMap = new HashMap<String, CoordinatorInputKey>();
 		/***
 		 * The root key of the hierarchy.
 		 */
 		public CoordinatorInputKey rootKey;
 		/***
 		 * <p>
 		 * The nametree (key) hierarchy. Maps key to a set of its children. If
 		 * key is missing from the map, maps to <code>null</code> value or an
 		 * empty set then the nametree does not have any children.
 		 * </p>
 		 * <p>
 		 * {@link #deletedKeys Deleted keys} are automatically removed in
 		 * {@link #finishExport()}.
 		 * </p>
 		 */
 		public final Map<CoordinatorInputKey, Set<CoordinatorInputKey>> nametreeHierarchy = new HashMap<CoordinatorInputKey, Set<CoordinatorInputKey>>();
 		/***
 		 * <p>
 		 * Maps GENE-generated ids to the coordinator input key instance. Used
 		 * by renderer context to map from GENE id (provided to the renderer) to
 		 * child renderer instance.
 		 * </p>
 		 * <p>
 		 * Constructed in {@link #finishExport()}.
 		 * </p>
 		 */
 		public final Map<String, CoordinatorInputKey> geneIdMapping = new HashMap<String, CoordinatorInputKey>();
 		/***
 		 * <p>
 		 * Contains set of new keys (keys that were not introduced in previous
 		 * GENE output processing).
 		 * </p>
 		 * <p>
 		 * Cleared in {@link #startExport(URLDir, String, String)}, filled in
 		 * {@link #partialResultEvent(DocumentFragment, NamespacePath, Source, String, CoordinatorInputKey)}.
 		 * </p>
 		 */
 		public final Set<CoordinatorInputKey> newKeys = new HashSet<CoordinatorInputKey>();
 		/***
 		 * <p>
 		 * Contains set of keys that were introduced in previous GENE output
 		 * processing but they are missing in current data.
 		 * </p>
 		 * <p>
 		 * Initialized in {@link #startExport(File)},
 		 * processed in
 		 * {@link #partialResultEvent(DocumentFragment, NamespacePath, Source, String, CoordinatorInputKey)}.
 		 * </p>
 		 */
 		public final Set<CoordinatorInputKey> deletedKeys = new HashSet<CoordinatorInputKey>();
 		/*
 		 * (non-Javadoc)
 		 * @see sk.uniba.euromath.gene.ICoordinator#alterContext(sk.uniba.euromath.gene.IExporter,
 		 * sk.uniba.euromath.gene.ExportContext,
 		 * sk.uniba.euromath.gene.controller.NamespacePath)
 		 */
 		public void alterContext(IExporter exporter, ExportContext context,
 				NamespacePath path) {
 			// each exporter is fully separated, thus each is the root one.
 			context.isRoot = true;
 			context.parentNamespace = null;
 		}
 	}
 	/***
 	 * Represents the renderer with its environment.
 	 * @author Martin Vysny
 	 */
 	public final class RendererSite {
 		/***
 		 * Constructor.
 		 * @param renderer the renderer instance.
 		 * @param input the input path identifier.
 		 */
 		public RendererSite(final IRenderer renderer,
 				final CoordinatorInputKey input) {
 			super();
 			if (renderer == null)
 				throw new IllegalArgumentException("null renderer"); //$NON-NLS-1$
 			this.renderer = renderer;
 			this.preprocessor = renderer.createPreprocessor();
 			if (this.preprocessor != null) {
 				this.preprocessor.init(input);
 			}
 		}
 		/***
 		 * The renderer instance.
 		 */
 		public final IRenderer renderer;
 		/***
 		 * Input preprocessor instance.
 		 */
 		private final IInputPreprocessor preprocessor;
 		/***
 		 * Source data for the renderer. May be DOM or Object only. Do not set
 		 * directly, use {@link #setSource(Source)} instead.
 		 */
 		private IChangeCollector source;
 		/***
 		 * Sets given source to the renderer.
 		 * @param source the source to set.
 		 */
 		public void setSource(final Source source) {
 			if (this.source == null) {
 				if (source instanceof DOMSource) {
 					this.source = new DOMChangeCollector();
 				} else if (source instanceof ObjectSource) {
 					this.source = new ObjectChangeCollector();
 				} else
 					throw new IllegalArgumentException(
 							"Illegal source type: " + source.getClass().getName());//$NON-NLS-1$
 				this.source.init(source);
 			} else {
 				this.source.reinit(source);
 			}
 			if (this.preprocessor == null) {
 				return;
 			}
 			this.source = this.preprocessor.process(this.source);
 			if (this.source.getSource() == null)
 				throw new IllegalStateException("Preprocessor " //$NON-NLS-1$
 						+ this.preprocessor.getClass().getName()
 						+ " failed to initialize result change collector."); //$NON-NLS-1$
 		}
 		/***
 		 * Returns the source object.
 		 * @return the source.
 		 */
 		public IChangeCollector getSource() {
 			return this.source;
 		}
 		/***
 		 * An unique integer id.
 		 */
 		public final String id = String
 				.valueOf(++GeneDataProvider.this.rendererSiteId);
 		/***
 		 * <code>false</code> if the renderer is not new and needs to
 		 * reinitialize instead of initialization.
 		 */
 		private boolean isNew = true;
 		/***
 		 * Checks if this renderer is new or being reused.
 		 * @return <code>false</code> if the renderer is not new and needs to
 		 * reinitialize instead of initialization.
 		 */
 		public boolean isNew() {
 			return this.isNew;
 		}
 		/***
 		 * Initializes (or reinitializes) the renderer.
 		 * @throws EditorException if initialization fails.
 		 */
 		public void init() throws EditorException {
 			if (this.source == null)
 				throw new IllegalStateException("source is null"); //$NON-NLS-1$
 			if (this.isNew) {
 				this.isNew = false;
 				this.renderer.init(this.source.getSource(),
 						GeneDataProvider.this.context);
 				return;
 			}
 			// we have to reinit the renderer
 			this.renderer.reinit(this.source);
 		}
 	}
 	/***
 	 * Unique id for the renderer site instance.
 	 */
 	private int rendererSiteId = 0;
 	/***
 	 * The coordinator instance.
 	 */
 	private final Coordinator coordinator;
 	/***
 	 * The coordinator info.
 	 */
 	private final CoordinatorInfo coordinatorInfo;
 	/***
 	 * Returns the coordinator information instance for the GENE coordinator.
 	 * @return coordinator info for this coordinator.
 	 */
 	public CoordinatorInfo getCoordinatorInfo() {
 		return this.coordinatorInfo;
 	}
 	/***
 	 * The context object for renderers.
 	 */
 	private final RendererContext context;
 	/***
 	 * The document instance, owning all nodes created by this class.
 	 */
 	private static final Document doc = TransformUtils.builder.newDocument();
 }