plugins/org.eclipse.actf.ai.fennec/src/org/eclipse/actf/ai/fennec/impl/FennecMode.java - actf/org.eclipse.actf.ai - Git at Google

 /*******************************************************************************
  * Copyright (c) 2007 IBM Corporation and Others
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
  *
  * Contributors:
  *    Hisashi MIYASHITA - initial API and implementation
  *******************************************************************************/
 package org.eclipse.actf.ai.fennec.impl;

 import java.util.ArrayList;
 import java.util.HashMap;
 import java.util.List;

 import org.eclipse.actf.ai.fennec.FennecException;
 import org.eclipse.actf.ai.fennec.FennecInterruptedException;
 import org.eclipse.actf.ai.fennec.autotranslator.AutoTranslator;
 import org.eclipse.actf.ai.fennec.treemanager.ITreeItem;
 import org.w3c.dom.Node;
 import org.w3c.dom.NodeList;


 // TODO I'd like to make it package-local.
 public class FennecMode {
     static public final int TYPE_SIMPLE = 0;

     static public final int TYPE_ATTACH = 1;

     static public final int TYPE_UNWRAP = 2;

     static public final int TYPE_BUILT = 2;

     static public final int TRIGGER_MOVE = 1 << 0;

     static public final int TRIGGER_CLICK = 1 << 1;

     static public final int TRIGGER_KEEP = 1 << 2;

     static public final int TRIGGER_WITHOUTCHANGE = 1 << 3;

     static public final int TRIGGER_UNWRAP = 1 << 4;

     static public final int TRIGGER_ALWAYS = (TRIGGER_MOVE
                                               | TRIGGER_CLICK
                                               | TRIGGER_KEEP
                                               | TRIGGER_UNWRAP);

     private final int type;

     private final int trigger;

     private final boolean automatic;

     private final boolean changeless;

     private final boolean waitContents;

     private FennecRecombinantMetadata baseMetadata;

     private List<FennecMetadata> belongingMetadata;

     private HashMap<Node, ArrayList<FennecMetadata>> metadataMap;

     void addMetadata(FennecMetadata md) {
         if (false) {
             // A mode manages its belonging metadata in order to manage substate, but
             // currently it is not used...  So now this part is disabled.
             if (belongingMetadata == null) {
                 belongingMetadata = new ArrayList<FennecMetadata>();
             }
             belongingMetadata.add(md);
         }
     }

     void setBaseMetadata(FennecRecombinantMetadata md) {
         this.baseMetadata = md;
     }

     boolean changed(TreeItemFennec pItem, int trigger) {
         // TODO:
         // return true;
         if ((trigger & TRIGGER_WITHOUTCHANGE) != 0)
             return false;
         if (changeless)
             return false;
         return true;
     }

     private TreeItemFennec currentTopItem;

     TreeItemFennec buildItem(Node n, TreeItemFennec pItem) {
         currentTopItem = pItem;
         TreeItemFennec item = AutoTranslator.translate(this, pItem, n);
         if (pItem != null)
             pItem.markRefreshedChild();
         return item;
     }

     TreeItemFennec buildItemContinued(Node n, TreeItemFennec item) {
         currentTopItem = null;
         TreeItemFennec newItem = AutoTranslator.translateContinued(this, item, n);
         if (newItem != null)
             newItem.markRefreshedChild();
         return newItem;
     }

     private FennecMetadata[] topMds;

     private FennecMetadata[] initMetadataMap(FennecMetadata[] mds, Node n) {
         if (topMds != null) return topMds;

         metadataMap = new HashMap<Node, ArrayList<FennecMetadata>>();
         ArrayList<FennecMetadata> mdList = new ArrayList<FennecMetadata>();
         for (int i = 0; i < mds.length; i++) {
             if (mds[i].hasTargets()) {
                 registMetadata(metadataMap, mds[i], n);
             } else {
                 mdList.add(mds[i]);
             }
         }
         topMds = mdList.toArray(new FennecMetadata[mdList.size()]);
         return topMds;
     }

     public TreeItemFennec generateItem(TreeItemFennec pItem, Node n) {
         FennecMetadata[] cmds = null;

         FennecMetadata[] mds = baseMetadata.getChildMetadata();
         if (mds != null) {
             if (currentTopItem == pItem) {
                 // This item is top.
                 cmds = initMetadataMap(mds, n);
             } else {
                 initMetadataMap(mds, n);
                 ArrayList<FennecMetadata> aMeta = metadataMap.get(n);
                 if (aMeta != null) {
                     cmds = (FennecMetadata[]) aMeta.toArray(new FennecMetadata[aMeta.size()]);
                 }
             }
         }
         FennecMetadata md = FennecGeneratedMetadata.generate(baseMetadata, this, n, cmds);

         return TreeItemFennec.newTreeItem(md, pItem, n);
     }

     private void registMetadata(HashMap<Node, ArrayList<FennecMetadata>> metaMap, FennecMetadata meta, Node base) {
         NodeList list = meta.query(base);

         for (int i = 0; i < list.getLength(); i++) {
             Node node = list.item(i);
             ArrayList<FennecMetadata> aMeta = metaMap.get(node);
             if (aMeta == null) {
                 aMeta = new ArrayList<FennecMetadata>();
                 metaMap.put(node, aMeta);
             }
             if (meta instanceof FennecBundleMetadata) {
                 FennecMetadata[] m = ((FennecBundleMetadata) meta).childMetadata;
                 for (int j = 0; j < m.length; j++) {
                     if (m[j].hasTargets()) {
                         registMetadata(metaMap, m[j], node);
                     } else {
                         aMeta.add(m[j]);
                     }
                 }
             }
         }
     }

     private List autoAttach(TreeItemFennec pItem, NodeList nl, int len, int trigger) throws FennecException {
         List l = new ArrayList(len);

         for (int i = 0; i < len; i++) {
             Node n = nl.item(i);
             /*
              if (n instanceof CacheableNode) {
              CachableNode cn = (CachableNode) cn;
              if (!cn.isChanged()) {
              } else {
              }
              }
              */
             TreeItemFennec newItem = buildItem(n, pItem);
             if (newItem != null)
                 l.add(newItem);
         }
         if (l.size() == 0) {
             if (this.trigger == TRIGGER_CLICK) {
                 throw new FennecInterruptedException("Could not attach the expected nodes.");
             }
             return null;
         }
         if (waitContents && (l.size() == 0)) {
             throw new FennecInterruptedException("Contents have not been prepared yet.");
         }
         return l;
     }

     private List manualAttach(TreeItemFennec pItem, NodeList nl, int len, int trigger) throws FennecException {
         List l = new ArrayList(len);

         FennecMetadata[] childMds = baseMetadata.getChildMetadata();
         for (int j = 0; j < len; j++) {
             for (int i = 0; i < childMds.length; i++) {
                 FennecMetadata md = childMds[i];
                 List l2 = md.buildItems(pItem, nl.item(j), trigger);
                 if (l2 != null) {
                     if (l2.size() > 0) {
                         l.addAll(l2);
                     } else if (waitContents) {
                         throw new FennecInterruptedException("Contents have not been prepared yet.");
                     }
                 }
             }
         }

         return l;
     }

     private List unwrap(TreeItemFennec pItem, NodeList nl, int len, int trigger) {
         //TODO
         return null;
     }

     // TODO:
     private HashMap cachedResult = new HashMap();

     List expand(TreeItemFennec pItem, Node baseNode, int trigger) throws FennecException {
         if ((trigger != TRIGGER_KEEP) && ((trigger & this.trigger) == 0)) {
             return null;
         }
         Object key;
         if (baseNode != null) {
             key = baseNode;
         } else if (pItem == null) {
             key = null;
         } else {
             key = pItem.getBaseNode();
         }
         if (!changed(pItem, trigger)) {
             List l = (List) cachedResult.get(key);
             if (l != null)
                 return l;
         }

         NodeList nl;
         if (baseNode != null) {
             nl = baseMetadata.query(baseNode);
         } else {
             nl = baseMetadata.query(pItem);
         }
         int len = nl.getLength();
         List result = null;
         switch (type) {
         case TYPE_ATTACH:
             if (len == 0) {
                 if (this.trigger == TRIGGER_CLICK) {
                     throw new FennecInterruptedException("Could not attach the expected nodes.");
                 }
                 return null;
             }
             if (automatic) {
                 result = autoAttach(pItem, nl, len, trigger);
             } else {
                 result = manualAttach(pItem, nl, len, trigger);
             }
             cachedResult.put(key, result);
             return result;
         case TYPE_UNWRAP:
             // TODO;
         }

         return result;
     }

     FennecMode(int type, int trigger, boolean automatic, boolean changeless, boolean waitContents) {
         this.type = type;
         this.trigger = trigger;
         this.automatic = automatic;
         this.changeless = changeless;
         this.waitContents = waitContents;
     }

     FennecMode(int type) {
         this.type = type;
         this.trigger = TRIGGER_ALWAYS;
         this.automatic = false;
         this.changeless = false;
         this.waitContents = false;
     }
 }
	/*******************************************************************************
	* Copyright (c) 2007 IBM Corporation and Others
	* All rights reserved. This program and the accompanying materials
	* are made available under the terms of the Eclipse Public License v1.0
	* which accompanies this distribution, and is available at
	* http://www.eclipse.org/legal/epl-v10.html
	*
	* Contributors:
	* Hisashi MIYASHITA - initial API and implementation
	*******************************************************************************/
	package org.eclipse.actf.ai.fennec.impl;

	import java.util.ArrayList;
	import java.util.HashMap;
	import java.util.List;

	import org.eclipse.actf.ai.fennec.FennecException;
	import org.eclipse.actf.ai.fennec.FennecInterruptedException;
	import org.eclipse.actf.ai.fennec.autotranslator.AutoTranslator;
	import org.eclipse.actf.ai.fennec.treemanager.ITreeItem;
	import org.w3c.dom.Node;
	import org.w3c.dom.NodeList;


	// TODO I'd like to make it package-local.
	public class FennecMode {
	static public final int TYPE_SIMPLE = 0;

	static public final int TYPE_ATTACH = 1;

	static public final int TYPE_UNWRAP = 2;

	static public final int TYPE_BUILT = 2;

	static public final int TRIGGER_MOVE = 1 << 0;

	static public final int TRIGGER_CLICK = 1 << 1;

	static public final int TRIGGER_KEEP = 1 << 2;

	static public final int TRIGGER_WITHOUTCHANGE = 1 << 3;

	static public final int TRIGGER_UNWRAP = 1 << 4;

	static public final int TRIGGER_ALWAYS = (TRIGGER_MOVE
	\| TRIGGER_CLICK
	\| TRIGGER_KEEP
	\| TRIGGER_UNWRAP);

	private final int type;

	private final int trigger;

	private final boolean automatic;

	private final boolean changeless;

	private final boolean waitContents;

	private FennecRecombinantMetadata baseMetadata;

	private List<FennecMetadata> belongingMetadata;

	private HashMap<Node, ArrayList<FennecMetadata>> metadataMap;

	void addMetadata(FennecMetadata md) {
	if (false) {
	// A mode manages its belonging metadata in order to manage substate, but
	// currently it is not used... So now this part is disabled.
	if (belongingMetadata == null) {
	belongingMetadata = new ArrayList<FennecMetadata>();
	}
	belongingMetadata.add(md);
	}
	}

	void setBaseMetadata(FennecRecombinantMetadata md) {
	this.baseMetadata = md;
	}

	boolean changed(TreeItemFennec pItem, int trigger) {
	// TODO:
	// return true;
	if ((trigger & TRIGGER_WITHOUTCHANGE) != 0)
	return false;
	if (changeless)
	return false;
	return true;
	}

	private TreeItemFennec currentTopItem;

	TreeItemFennec buildItem(Node n, TreeItemFennec pItem) {
	currentTopItem = pItem;
	TreeItemFennec item = AutoTranslator.translate(this, pItem, n);
	if (pItem != null)
	pItem.markRefreshedChild();
	return item;
	}

	TreeItemFennec buildItemContinued(Node n, TreeItemFennec item) {
	currentTopItem = null;
	TreeItemFennec newItem = AutoTranslator.translateContinued(this, item, n);
	if (newItem != null)
	newItem.markRefreshedChild();
	return newItem;
	}

	private FennecMetadata[] topMds;

	private FennecMetadata[] initMetadataMap(FennecMetadata[] mds, Node n) {
	if (topMds != null) return topMds;

	metadataMap = new HashMap<Node, ArrayList<FennecMetadata>>();
	ArrayList<FennecMetadata> mdList = new ArrayList<FennecMetadata>();
	for (int i = 0; i < mds.length; i++) {
	if (mds[i].hasTargets()) {
	registMetadata(metadataMap, mds[i], n);
	} else {
	mdList.add(mds[i]);
	}
	}
	topMds = mdList.toArray(new FennecMetadata[mdList.size()]);
	return topMds;
	}

	public TreeItemFennec generateItem(TreeItemFennec pItem, Node n) {
	FennecMetadata[] cmds = null;

	FennecMetadata[] mds = baseMetadata.getChildMetadata();
	if (mds != null) {
	if (currentTopItem == pItem) {
	// This item is top.
	cmds = initMetadataMap(mds, n);
	} else {
	initMetadataMap(mds, n);
	ArrayList<FennecMetadata> aMeta = metadataMap.get(n);
	if (aMeta != null) {
	cmds = (FennecMetadata[]) aMeta.toArray(new FennecMetadata[aMeta.size()]);
	}
	}
	}
	FennecMetadata md = FennecGeneratedMetadata.generate(baseMetadata, this, n, cmds);

	return TreeItemFennec.newTreeItem(md, pItem, n);
	}

	private void registMetadata(HashMap<Node, ArrayList<FennecMetadata>> metaMap, FennecMetadata meta, Node base) {
	NodeList list = meta.query(base);

	for (int i = 0; i < list.getLength(); i++) {
	Node node = list.item(i);
	ArrayList<FennecMetadata> aMeta = metaMap.get(node);
	if (aMeta == null) {
	aMeta = new ArrayList<FennecMetadata>();
	metaMap.put(node, aMeta);
	}
	if (meta instanceof FennecBundleMetadata) {
	FennecMetadata[] m = ((FennecBundleMetadata) meta).childMetadata;
	for (int j = 0; j < m.length; j++) {
	if (m[j].hasTargets()) {
	registMetadata(metaMap, m[j], node);
	} else {
	aMeta.add(m[j]);
	}
	}
	}
	}
	}

	private List autoAttach(TreeItemFennec pItem, NodeList nl, int len, int trigger) throws FennecException {
	List l = new ArrayList(len);

	for (int i = 0; i < len; i++) {
	Node n = nl.item(i);
	/*
	if (n instanceof CacheableNode) {
	CachableNode cn = (CachableNode) cn;
	if (!cn.isChanged()) {
	} else {
	}
	}
	*/
	TreeItemFennec newItem = buildItem(n, pItem);
	if (newItem != null)
	l.add(newItem);
	}
	if (l.size() == 0) {
	if (this.trigger == TRIGGER_CLICK) {
	throw new FennecInterruptedException("Could not attach the expected nodes.");
	}
	return null;
	}
	if (waitContents && (l.size() == 0)) {
	throw new FennecInterruptedException("Contents have not been prepared yet.");
	}
	return l;
	}

	private List manualAttach(TreeItemFennec pItem, NodeList nl, int len, int trigger) throws FennecException {
	List l = new ArrayList(len);

	FennecMetadata[] childMds = baseMetadata.getChildMetadata();
	for (int j = 0; j < len; j++) {
	for (int i = 0; i < childMds.length; i++) {
	FennecMetadata md = childMds[i];
	List l2 = md.buildItems(pItem, nl.item(j), trigger);
	if (l2 != null) {
	if (l2.size() > 0) {
	l.addAll(l2);
	} else if (waitContents) {
	throw new FennecInterruptedException("Contents have not been prepared yet.");
	}
	}
	}
	}

	return l;
	}

	private List unwrap(TreeItemFennec pItem, NodeList nl, int len, int trigger) {
	//TODO
	return null;
	}

	// TODO:
	private HashMap cachedResult = new HashMap();

	List expand(TreeItemFennec pItem, Node baseNode, int trigger) throws FennecException {
	if ((trigger != TRIGGER_KEEP) && ((trigger & this.trigger) == 0)) {
	return null;
	}
	Object key;
	if (baseNode != null) {
	key = baseNode;
	} else if (pItem == null) {
	key = null;
	} else {
	key = pItem.getBaseNode();
	}
	if (!changed(pItem, trigger)) {
	List l = (List) cachedResult.get(key);
	if (l != null)
	return l;
	}

	NodeList nl;
	if (baseNode != null) {
	nl = baseMetadata.query(baseNode);
	} else {
	nl = baseMetadata.query(pItem);
	}
	int len = nl.getLength();
	List result = null;
	switch (type) {
	case TYPE_ATTACH:
	if (len == 0) {
	if (this.trigger == TRIGGER_CLICK) {
	throw new FennecInterruptedException("Could not attach the expected nodes.");
	}
	return null;
	}
	if (automatic) {
	result = autoAttach(pItem, nl, len, trigger);
	} else {
	result = manualAttach(pItem, nl, len, trigger);
	}
	cachedResult.put(key, result);
	return result;
	case TYPE_UNWRAP:
	// TODO;
	}

	return result;
	}

	FennecMode(int type, int trigger, boolean automatic, boolean changeless, boolean waitContents) {
	this.type = type;
	this.trigger = trigger;
	this.automatic = automatic;
	this.changeless = changeless;
	this.waitContents = waitContents;
	}

	FennecMode(int type) {
	this.type = type;
	this.trigger = TRIGGER_ALWAYS;
	this.automatic = false;
	this.changeless = false;
	this.waitContents = false;
	}
	}