//
   // $Revision: 5 $
   // $LastChangedBy: mhanns $
   // $Date: 2010-04-01 10:10:45 +0200 (Do, 01 Apr 2010) $
   // $HeadURL:
   // svn://localhost/winf-ps/trunk/repository/src/main/java/de/uni_leipzig/wifa/iwi/mr3/dao/impl/neo4j/AbstractNeoPhaseProcessor.java
   // $
   //
   
  package de.uni_leipzig.wifa.iwi.mr3.dao.neo4j.impl;
  
  import java.util.Map;
  
  import org.apache.log4j.Logger;
  import org.eclipse.emf.common.util.TreeIterator;
  import org.eclipse.emf.ecore.EAnnotation;
  import org.eclipse.emf.ecore.EAttribute;
  import org.eclipse.emf.ecore.EClass;
  import org.eclipse.emf.ecore.EDataType;
  import org.eclipse.emf.ecore.EEnum;
  import org.eclipse.emf.ecore.EEnumLiteral;
  import org.eclipse.emf.ecore.EGenericType;
  import org.eclipse.emf.ecore.EObject;
  import org.eclipse.emf.ecore.EOperation;
  import org.eclipse.emf.ecore.EPackage;
  import org.eclipse.emf.ecore.EParameter;
  import org.eclipse.emf.ecore.EReference;
  import org.eclipse.emf.ecore.ETypeParameter;
  import org.eclipse.emf.ecore.impl.EStringToStringMapEntryImpl;
  import org.eclipse.emf.ecore.resource.Resource;
  import org.neo4j.api.core.NeoService;
  import org.neo4j.api.core.Node;
  
  import de.uni_leipzig.wifa.iwi.mr3.dao.SaveProcessor;
  import de.uni_leipzig.wifa.iwi.mr3.dao.neo4j.EcoreRelationshipType;
  
  /**
   * Abstract save phase processor for neo4j storage.
   * <p>
   * This class contains all the methods all neo4j specific implementations need.
   */
  public abstract class AbstractNeoSaveProcessor implements SaveProcessor
  {
    /** Logger. */
    private static final Logger LOG = Logger.getLogger(AbstractNeoSaveProcessor.class);
  
    /** Neo4j helper. */
    private NeoHelper helper;
  
    /** Neo4j service. */
    private NeoService neo;
  
    /**
     * Setter.
     *
     * @param neoHelper
     *          the helper to set
     */
    public void setHelper(final NeoHelper neoHelper)
    {
      helper = neoHelper;
      neo = neoHelper.getNeo();
    }
  
    /**
     * Getter.
     * 
     * @return the helper
     */
    public NeoHelper getHelper()
    {
      return helper;
    }
  
    /**
     * Process.
     * 
     * @param resource
     *          Resource
     * @param registry
     *          Node cache
     * @see de.uni_leipzig.wifa.iwi.mr3.dao.SaveProcessor#process(org.eclipse.emf.ecore.resource.Resource,
     *      java.util.Map)
     */
    @Override
    public void process(final Resource resource, final Map<EObject, Object> registry)
    {
      // process its containment (the TreeIterator traverses the model tree in
      // depth-first mode)
      for (final TreeIterator<EObject> iter = resource.getAllContents(); iter.hasNext();)
      {
        dispatch(iter.next(), registry);
      }
    }
  
    /**
     * Dispatch the current element to its handler.
     * <p>
     * The order of dispatch types dependends on type hierarchy. Special types
    * <b>must</b> be checked earlier then generally types.
    * <p>
    * 
    * @param element
    *          Element to dispatch
    * @param registry
    *          Node cache
    */
   @Override
   public void dispatch(final EObject element, final Map<EObject, Object> registry)
   {
     LOG.debug(element);
 
     if (element instanceof EPackage)
     {
       process((EPackage) element, registry);
     }
     else if (element instanceof EEnum)
     {
       process((EEnum) element, registry);
     }
     else if (element instanceof EEnumLiteral)
     {
       process((EEnumLiteral) element, registry);
     }
     else if (element instanceof EDataType)
     {
       process((EDataType) element, registry);
     }
     else if (element instanceof EClass)
     {
       process((EClass) element, registry);
     }
     else if (element instanceof EAnnotation)
     {
       process((EAnnotation) element, registry);
     }
     else if (element instanceof EOperation)
     {
       process((EOperation) element, registry);
     }
     else if (element instanceof EAttribute)
     {
       process((EAttribute) element, registry);
     }
     else if (element instanceof EReference)
     {
       process((EReference) element, registry);
     }
     else if (element instanceof EGenericType)
     {
       process((EGenericType) element, registry);
     }
     else if (element instanceof EParameter)
     {
       process((EParameter) element, registry);
     }
     else if (element instanceof ETypeParameter)
     {
       process((ETypeParameter) element, registry);
     }
     else if (element instanceof EStringToStringMapEntryImpl)
     {
       process((EStringToStringMapEntryImpl) element, registry);
     }
     else
     {
       process(element, registry);
     }
   }
 
   /**
    * Determine a node from the registry.
    *
    * @param element
    *          Element for what we need a node.
    * @param registry
    *          Node cache
    * @return Node
    */
   protected Node getNodeFromRegistry(final EObject element, final Map<EObject, Object> registry)
   {
     return (Node) registry.get(element);
   }
 
   /**
    * Creates a node and binds it by a specified relationship to the given node.
    *
    * @param node
    *          the node
    * @param relType
    *          the relationship type
    * @param ordered
    *          <code>true</code> if node will be created with ordering position
    *          value
    * @return the created and bound node
    */
   protected Node createNodeWithRelationship(final Node node, final EcoreRelationshipType relType, final boolean ordered)
   {
     final Node anotherNode = createNode();
     node.createRelationshipTo(anotherNode, relType);
     return anotherNode;
   }
 
   /**
    * Create a node. Optionally the node gets a position ordering value.
    *
    * @return Node
    */
   protected Node createNode()
   {
     return neo.createNode();
   }
 }