Attachment #78135 for bug #202064

Some Eclipse Foundation services are deprecated, or will be soon. Please ensure you've read this important communication.

Lines 50-55 Link Here

(-)src/org/eclipse/emf/cdo/internal/server/protocol/LoadRevisionIndication.java (-17 / +34 lines)
50		50
51	protected CDOID contextID = CDOIDNull.NULL;	51	protected CDOID contextID = CDOIDNull.NULL;
52		52
		53	protected int loadRevisionCollectionChunkSize = 1;
		54
53	public LoadRevisionIndication()	55	public LoadRevisionIndication()
54	{	56	{
55	}	57	}
Lines 78-88 Link Here
78	}	80	}
79		81
80	int fetchSize = in.readInt();	82	int fetchSize = in.readInt();
		83
81	if (fetchSize > 0)	84	if (fetchSize > 0)
82	{	85	{
		86	loadRevisionCollectionChunkSize = in.readInt();
		87	if (loadRevisionCollectionChunkSize < 1)
		88	loadRevisionCollectionChunkSize = 1;
83	contextID = CDOIDImpl.read(in);	89	contextID = CDOIDImpl.read(in);
		90
84	if (PROTOCOL.isEnabled()) PROTOCOL.format("Reading fetch rules for context {0}", contextID);	91	if (PROTOCOL.isEnabled()) PROTOCOL.format("Reading fetch rules for context {0}", contextID);
85		92
		93
86	for (int i = 0; i < fetchSize; i++)	94	for (int i = 0; i < fetchSize; i++)
87	{	95	{
88	CDOFetchRule fetchRule = new CDOFetchRule(in, getPackageManager());	96	CDOFetchRule fetchRule = new CDOFetchRule(in, getPackageManager());
Lines 99-122 Link Here
99	HashSet<CDOID> revisions = new HashSet<CDOID>();	107	HashSet<CDOID> revisions = new HashSet<CDOID>();
100	if (PROTOCOL.isEnabled()) PROTOCOL.format("Writing {0} revisions", ids.length);	108	if (PROTOCOL.isEnabled()) PROTOCOL.format("Writing {0} revisions", ids.length);
101		109
		110	for (CDOID id : ids)
		111	{
		112	revisions.add(id);
		113	}
		114
102	// Need to fetch the rule first.	115	// Need to fetch the rule first.
		116	Set<CDOFetchRule> visitedFetchRules = new HashSet<CDOFetchRule>();
103	if (!contextID.isNull() && fetchRules.size() > 0)	117	if (!contextID.isNull() && fetchRules.size() > 0)
104	{	118	{
105	if (PROTOCOL.isEnabled()) PROTOCOL.format("Collecting more objects based on rules");	119	if (PROTOCOL.isEnabled()) PROTOCOL.format("Collecting more objects based on rules");
106	CDORevisionImpl revisionContext = getRevision(contextID);	120
107	Set<CDOFetchRule> workingFetchRules = new HashSet<CDOFetchRule>();	121	CDORevisionImpl revisionContext = getRevision(contextID);
108	collectRevisionsByRule(revisionContext, referenceChunk, revisions, additionalRevisions, workingFetchRules);	122
		123	collectRevisions(revisionContext, revisions, additionalRevisions, visitedFetchRules);
109	}	124	}
110		125
111	for (CDOID id : ids)	126	for (CDOID id : ids)
112	{	127	{
113	CDORevisionImpl revision = getRevision(id);	128	CDORevisionImpl revision = getRevision(id);
114	revision.write(out, session, referenceChunk);	129	revision.write(out, session, referenceChunk);
115	revisions.add(revision.getID());	130
116	session.collectContainedRevisions(revision, referenceChunk, revisions, additionalRevisions);	131	collectRevisions(revision, revisions, additionalRevisions, visitedFetchRules);
		132
117	}	133	}
118		134
119	out.writeInt(additionalRevisions.size());	135	out.writeInt(additionalRevisions.size());
		136
120	if (PROTOCOL.isEnabled()) PROTOCOL.format("Writing {0} additional revisions", additionalRevisions.size());	137	if (PROTOCOL.isEnabled()) PROTOCOL.format("Writing {0} additional revisions", additionalRevisions.size());
121		138
122	for (CDORevisionImpl revision : additionalRevisions)	139	for (CDORevisionImpl revision : additionalRevisions)
Lines 130-145 Link Here
130	return getRevisionManager().getRevision(id, referenceChunk);	147	return getRevisionManager().getRevision(id, referenceChunk);
131	}	148	}
132		149
133	private void collectRevisionsByRule(CDORevisionImpl revision, int referenceChunk, Set<CDOID> revisions,	150	private void collectRevisions(CDORevisionImpl revision, Set<CDOID> revisions,
134	List<CDORevisionImpl> additionalRevisions, Set<CDOFetchRule> workingFetchRules)	151	List<CDORevisionImpl> additionalRevisions, Set<CDOFetchRule> visitedFetchRules)
135	{	152	{
		153
		154	getSession().collectContainedRevisions(revision, this.referenceChunk, revisions, additionalRevisions);
		155
136	CDOFetchRule fetchRule = fetchRules.get(revision.getCDOClass());	156	CDOFetchRule fetchRule = fetchRules.get(revision.getCDOClass());
137	if (fetchRule == null \|\| workingFetchRules.contains(fetchRule))	157	if (fetchRule == null \|\| visitedFetchRules.contains(fetchRule))
138	{	158	{
139	return;	159	return;
140	}	160	}
141		161
142	workingFetchRules.add(fetchRule);	162	visitedFetchRules.add(fetchRule);
143		163
144	RevisionManager revisionManager = getSessionManager().getRepository().getRevisionManager();	164	RevisionManager revisionManager = getSessionManager().getRepository().getRevisionManager();
145	for (CDOFeature feature : fetchRule.getFeatures())	165	for (CDOFeature feature : fetchRule.getFeatures())
Lines 147-153 Link Here
147	if (feature.isMany())	167	if (feature.isMany())
148	{	168	{
149	MoveableList list = revision.getList(feature);	169	MoveableList list = revision.getList(feature);
150	int toIndex = Math.min(referenceChunk, list.size()) - 1;	170	int toIndex = Math.min(this.loadRevisionCollectionChunkSize, list.size()) - 1;
151	for (int i = 0; i <= toIndex; i++)	171	for (int i = 0; i <= toIndex; i++)
152	{	172	{
153	Object value = list.get(i);	173	Object value = list.get(i);
Lines 159-167 Link Here
159	CDORevisionImpl containedRevision = revisionManager.getRevision(id, referenceChunk);	179	CDORevisionImpl containedRevision = revisionManager.getRevision(id, referenceChunk);
160	revisions.add(containedRevision.getID());	180	revisions.add(containedRevision.getID());
161	additionalRevisions.add(containedRevision);	181	additionalRevisions.add(containedRevision);
162		182	collectRevisions(containedRevision, revisions, additionalRevisions, visitedFetchRules);
163	collectRevisionsByRule(containedRevision, referenceChunk, revisions, additionalRevisions,
164	workingFetchRules);
165	}	183	}
166	}	184	}
167	}	185	}
Lines 177-189 Link Here
177	CDORevisionImpl containedRevision = revisionManager.getRevision(id, referenceChunk);	195	CDORevisionImpl containedRevision = revisionManager.getRevision(id, referenceChunk);
178	revisions.add(containedRevision.getID());	196	revisions.add(containedRevision.getID());
179	additionalRevisions.add(containedRevision);	197	additionalRevisions.add(containedRevision);
180		198	collectRevisions(containedRevision, revisions, additionalRevisions, visitedFetchRules);
181	collectRevisionsByRule(containedRevision, referenceChunk, revisions, additionalRevisions, workingFetchRules);
182	}	199	}
183	}	200	}
184	}	201	}
185	}	202	}
186		203
187	workingFetchRules.remove(fetchRule);	204	visitedFetchRules.remove(fetchRule);
188	}	205	}
189	}	206	}




/***************************************************************************
 * Copyright (c) 2004 - 2007 Eike Stepper, Germany.
 * 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:
 *    Simon McDuff - initial API and implementation
 **************************************************************************/
package org.eclipse.emf.cdo.tests;

import org.eclipse.emf.cdo.CDOSession;
import org.eclipse.emf.cdo.CDOState;
import org.eclipse.emf.cdo.CDOTransaction;
import org.eclipse.emf.cdo.eresource.CDOResource;
import org.eclipse.emf.cdo.tests.model1.Company;
import org.eclipse.emf.cdo.tests.model1.Model1Factory;
import org.eclipse.emf.cdo.tests.model1.PurchaseOrder;
import org.eclipse.emf.cdo.tests.model1.SalesOrder;
import org.eclipse.emf.cdo.tests.model1.Supplier;
import org.eclipse.emf.cdo.util.CDOUtil;

import org.eclipse.net4j.IBufferHandler;
import org.eclipse.net4j.IChannel;

import org.eclipse.emf.common.util.EList;
import org.eclipse.emf.common.util.URI;
import org.eclipse.emf.ecore.EObject;
import org.eclipse.emf.ecore.resource.ResourceSet;
import org.eclipse.emf.ecore.resource.impl.ResourceSetImpl;
import org.eclipse.emf.internal.cdo.CDOSessionImpl;
import org.eclipse.emf.internal.cdo.CDOTransactionImpl;
import org.eclipse.emf.internal.cdo.analyzer.CDOFeatureAnalyzerModelBased;
import org.eclipse.emf.internal.cdo.analyzer.CDOFetchRuleManagerThreadLocal;

import java.util.Date;

/**
 * @author Eike Stepper
 */
public class FetchRuleAnalyzerTest extends AbstractCDOTest
{
  
  public void testLoadObject() throws Exception
  {
    {
      // disableConsole();
      msg("Opening session");
      CDOSession session = openModel1Session();

      msg("Opening transaction");
      CDOTransaction transaction = session.openTransaction(new ResourceSetImpl());

      msg("Creating resource");
      CDOResource resource = transaction.createResource("/test2");

      msg("Creating supplier");

      for (int i = 0 ; i< 10; i++)
      {
          Company company = Model1Factory.eINSTANCE.createCompany();
    	  company.setCity("CITY" + String.valueOf(i));
    	  
          for (int j = 0 ; j< 10; j++)
          {
        	  PurchaseOrder purchaseOrder = Model1Factory.eINSTANCE.createPurchaseOrder();
        	  company.getPurchaseOrders().add(purchaseOrder);
        	  

        	  Supplier supplier = Model1Factory.eINSTANCE.createSupplier();
        	  
        	  // Should it detect supplier to make it persistent...
        	  // I don't want to do resource.getContents().add(supplier)
        	  purchaseOrder.setSupplier(supplier);
        	  
        	  SalesOrder salesOrder = Model1Factory.eINSTANCE.createSalesOrder();
        	  company.getSalesOrders().add(salesOrder);
          }  
    	  resource.getContents().add(company);
      }

      transaction.commit();
      // XXX session.close();
      enableConsole();
    }
    
    msg("Opening session");
    CDOSessionImpl session = (CDOSessionImpl)openModel1Session();
    
    session.getRevisionManager().setRuleManager(new CDOFetchRuleManagerThreadLocal());
    
    
    msg("Opening transaction");
    CDOTransactionImpl transaction = (CDOTransactionImpl)session.openTransaction(new ResourceSetImpl());
    
    CDOFeatureAnalyzerModelBased featureanalyzerModelBased = new CDOFeatureAnalyzerModelBased();
    
    transaction.setFeatureAnalyzer(featureanalyzerModelBased);
    
    transaction.setLoadRevisionCollectionChunkSize(10);
    
    msg("Getting resource");
    CDOResource resource = transaction.getResource("/test2");

    msg("Getting contents");
    EList<EObject> contents = resource.getContents();
    
    for (EObject eObject : contents)
    {
    	Company company = (Company) eObject;
    	for (PurchaseOrder purchaseOrder : company.getPurchaseOrders())
    	{
    		purchaseOrder.getSupplier();
    	}
    }
    assertEquals(featureanalyzerModelBased.getNbFetch(), 12);

    msg("Verifying name");
  }
}

Lines 37-40 Link Here

(-)src/org/eclipse/emf/internal/cdo/analyzer/NOOPFetchRuleManager.java (+6 lines)
37	{	37	{
38	return null;	38	return null;
39	}	39	}
		40
		41	public int getLoadRevisionCollectionChunkSize()
		42	{
		43	// TODO Auto-generated method stub
		44	return 1;
		45	}
40	}	46	}

Lines 11-21 Link Here

(-)src/org/eclipse/emf/internal/cdo/analyzer/CDOClusterOfFetchRule.java (-78 / +42 lines)
11	**************************************************************************/	11	**************************************************************************/
12	package org.eclipse.emf.internal.cdo.analyzer;	12	package org.eclipse.emf.internal.cdo.analyzer;
13		13
14	import java.util.HashMap;
15	import java.util.Iterator;
16	import java.util.Map;
17
18	import org.eclipse.emf.cdo.internal.protocol.analyzer.CDOFetchRule;
19	import org.eclipse.emf.cdo.protocol.model.CDOClass;	14	import org.eclipse.emf.cdo.protocol.model.CDOClass;
20	import org.eclipse.emf.cdo.protocol.model.CDOFeature;	15	import org.eclipse.emf.cdo.protocol.model.CDOFeature;
21	import org.eclipse.emf.internal.cdo.bundle.OM;	16	import org.eclipse.emf.internal.cdo.bundle.OM;
Lines 28-122 Link Here
28	{	23	{
29	private static final ContextTracer TRACER = new ContextTracer(OM.DEBUG, CDOClusterOfFetchRule.class);	24	private static final ContextTracer TRACER = new ContextTracer(OM.DEBUG, CDOClusterOfFetchRule.class);
30		25
31	private Map<CDOFeature, CDOFetchFeatureInfo> featureStats = new HashMap<CDOFeature, CDOFetchFeatureInfo>();
32
33	private Map<CDOClass, CDOFetchRule> fetchRules = new HashMap<CDOClass, CDOFetchRule>();
34		26
		27	private CDOFeatureInfo featureInfo = new CDOFeatureInfo();
		28
35	private CDOFeature rootFeature;	29	private CDOFeature rootFeature;
		30
		31	private CDOClass rootClass;
36		32
37	private long lastUpdate;	33	private long lastUpdate;
38		34
39	public CDOClusterOfFetchRule(CDOFeature rootFeature)	35	public CDOClusterOfFetchRule(CDOClass rootClass, CDOFeature rootFeature)
40	{	36	{
41	this.rootFeature = rootFeature;	37	this.rootFeature = rootFeature;
		38	this.rootClass = rootClass;
42	lastUpdate = System.currentTimeMillis();	39	lastUpdate = System.currentTimeMillis();
43	}	40	}
44		41
45	public boolean isActive()	42	/**
46	{	43	*
47	return !fetchRules.isEmpty();	44	*/
48	}	45	public int hashCode()
49		46	{
50	public Iterator<CDOFetchRule> iterator()	47	return rootFeature.hashCode();
51	{	48	}
52	return fetchRules.values().iterator();	49
53	}	50	/**
54		51	*
55	public synchronized CDOFetchFeatureInfo getFeatureStat(CDOFeature cdoFeature)	52	*/
56	{	53	public boolean equals(Object object)
57	CDOFetchFeatureInfo featureRule = featureStats.get(cdoFeature);	54	{
58	if (featureRule == null)	55	if (object instanceof CDOClusterOfFetchRule)
59	{	56	{
60	featureRule = new CDOFetchFeatureInfo();	57	CDOClusterOfFetchRule featureInfo = (CDOClusterOfFetchRule)object;
61	featureStats.put(cdoFeature, featureRule);	58	return featureInfo.rootClass == this.rootClass &&
62	}	59	featureInfo.rootFeature == this.rootFeature;
63		60	}
64	return featureRule;	61	return false;
65	}	62	}
66		63
67	public synchronized CDOFetchRule addFeatureRule(CDOClass cdoClass, CDOFeature cdoFeature)	64	/**
68	{	65	*
69	if (TRACER.isEnabled())	66	* @return
70	{	67	*/
71	TRACER.format("Adding new fetch rule : {0}.{1} from root feature {2}", cdoClass.getName(), cdoFeature.getName(),
72	rootFeature);
73	}
74
75	lastUpdate = System.currentTimeMillis();
76	CDOFetchRule fetchRule = getFetchRule(cdoClass);
77	fetchRule.addFeature(cdoFeature);
78	return fetchRule;
79	}
80
81	public synchronized CDOFetchRule removeFeatureRule(CDOClass cdoClass, CDOFeature cdoFeature)
82	{
83	if (TRACER.isEnabled())
84	{
85	TRACER.format("Removing fetch rule : {0}.{1} from root feature {2}", cdoClass.getName(), cdoFeature.getName(),
86	rootFeature);
87	}
88
89	lastUpdate = System.currentTimeMillis();
90
91	CDOFetchRule fetchRule = getFetchRule(cdoClass);
92	fetchRule.removeFeature(cdoFeature);
93	if (fetchRule.isEmpty())
94	{
95	fetchRules.remove(cdoClass);
96	}
97
98	return fetchRule;
99	}
100
101	public synchronized CDOFetchRule getFetchRule(CDOClass cdoFeature)
102	{
103	CDOFetchRule featureRule = fetchRules.get(cdoFeature);
104	if (featureRule == null)
105	{
106	featureRule = new CDOFetchRule(cdoFeature);
107	fetchRules.put(cdoFeature, featureRule);
108	}
109
110	return featureRule;
111	}
112
113	public long getLastUpdate()	68	public long getLastUpdate()
114	{	69	{
115	return lastUpdate;	70	return lastUpdate;
116	}	71	}
117		72	/**
		73	*
		74	* @return
		75	*/
118	public CDOFeature getRootFeature()	76	public CDOFeature getRootFeature()
119	{	77	{
120	return rootFeature;	78	return rootFeature;
121	}	79	}
		80
		81	public CDOFeatureInfo getFeatureInfo()
		82	{
		83
		84	return featureInfo;
		85	}
122	}	86	}




/***************************************************************************
 * Copyright (c) 2004 - 2007 Eike Stepper, Germany.
 * 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:
 *    Simon McDuff - initial API and implementation
 *    Eike Stepper - maintenance
 **************************************************************************/
package org.eclipse.emf.internal.cdo.analyzer;

import org.eclipse.emf.cdo.analyzer.CDOFetchRuleManager;
import org.eclipse.emf.cdo.internal.protocol.analyzer.CDOFetchRule;
import org.eclipse.emf.cdo.protocol.CDOID;

import java.util.Collection;
import java.util.List;

/**
 * @author Eike Stepper
 */
public class CDODynamicFetchRuleManager implements CDOFetchRuleManager
{
  private static final ThreadLocal<CDOFetchRuleManager> threadLocal = new ThreadLocal<CDOFetchRuleManager>();

  public CDODynamicFetchRuleManager()
  {
  }

  public static void join(CDOFetchRuleManager fetchRulemanager)
  {
    threadLocal.set(fetchRulemanager);
  }

  public static CDOFetchRuleManager getCurrent()
  {
    return threadLocal.get();
  }

  public static void leave()
  {
    threadLocal.set(null);
  }

  public CDOID getContext()
  {
    CDOFetchRuleManager analyzer = CDODynamicFetchRuleManager.getCurrent();
    return analyzer != null ? analyzer.getContext() : null;
  }

  public List<CDOFetchRule> getFetchRules(Collection<CDOID> ids)
  {
    CDOFetchRuleManager analyzer = CDODynamicFetchRuleManager.getCurrent();
    return analyzer != null ? analyzer.getFetchRules(ids) : null;
  }
}




/***************************************************************************
 * Copyright (c) 2004 - 2007 Eike Stepper, Germany.
 * 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:
 *    Simon McDuff - initial API and implementation
 *    Eike Stepper - maintenance
 **************************************************************************/
package org.eclipse.emf.internal.cdo.analyzer;

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;

import org.eclipse.emf.cdo.protocol.CDOID;
import org.eclipse.emf.cdo.protocol.model.CDOFeature;
import org.eclipse.emf.internal.cdo.bundle.OM;
import org.eclipse.net4j.internal.util.om.trace.ContextTracer;

/**
 * @author Eike Stepper
 */
public class CDOGraph
{
  private static final ContextTracer TRACER = new ContextTracer(OM.DEBUG, CDOGraph.class);

  private CDOGraphAnalyzer analyzer;

  private CDOClusterOfFetchRule featureRule;

  private List<CDOID> clusterOfObjects = new ArrayList<CDOID>();

  private long lastUpdated;

  private long creationTime;

  public CDOGraph(CDOGraphAnalyzer analyzer, CDOID rootID, CDOClusterOfFetchRule featureRule)
  {
    this.analyzer = analyzer;
    this.featureRule = featureRule;
    // Adding the root element
    add(rootID, null, rootID);
    creationTime = System.currentTimeMillis();
  }

  public List<CDOID> getObjects()
  {
    return clusterOfObjects;
  }

  public CDOClusterOfFetchRule getFeatureRule()
  {
    return featureRule;
  }

  public long getLastUpdated()
  {
    return lastUpdated;
  }

  public long getCreationTime()
  {
    return creationTime;
  }

  public CDOID getRoot()
  {
    return getObjects().get(0);
  }

  public void clean()
  {
    Iterator<CDOID> itr = clusterOfObjects.iterator();
    itr.next(); // Skip the Root!
    while (itr.hasNext())
    {
      analyzer.removeTrackingID(itr.next());
    }

    creationTime = System.currentTimeMillis();
  }

  public void update()
  {
    lastUpdated = System.currentTimeMillis();
  }

  public void add(CDOID fromID, CDOFeature feature, CDOID id)
  {
    // For now .. we do not need to calculate the path.. later we will do!!
    clusterOfObjects.add(id);
    analyzer.addTrackingID(id, this);
  }

  public void remove()
  {
    if (TRACER.isEnabled())
    {
      TRACER.format("Removing CDOGraph {0}", this);
    }

    for (CDOID id : clusterOfObjects)
    {
      analyzer.removeTrackingID(id);
    }

    analyzer.removeTracking(this);
  }
}




/***************************************************************************
 * Copyright (c) 2004 - 2007 Eike Stepper, Germany.
 * 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:
 *    Simon McDuff - initial API and implementation
 *    Eike Stepper - maintenance
 **************************************************************************/
package org.eclipse.emf.internal.cdo.analyzer;

import java.util.ArrayList;
import java.util.Collection;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;

import org.eclipse.emf.cdo.CDOView;
import org.eclipse.emf.cdo.analyzer.CDOFeatureAnalyzer;
import org.eclipse.emf.cdo.analyzer.CDOFetchRuleManager;
import org.eclipse.emf.cdo.internal.protocol.analyzer.CDOFetchRule;
import org.eclipse.emf.cdo.protocol.CDOID;
import org.eclipse.emf.cdo.protocol.model.CDOClass;
import org.eclipse.emf.cdo.protocol.model.CDOFeature;
import org.eclipse.emf.internal.cdo.InternalCDOObject;
import org.eclipse.emf.internal.cdo.bundle.OM;
import org.eclipse.emf.internal.cdo.util.FSMUtil;
import org.eclipse.net4j.internal.util.om.trace.ContextTracer;

/**
 * @author Eike Stepper
 */
public class CDODynamicFetchRuleAnalyzer implements CDOFeatureAnalyzer, CDOFetchRuleManager
{
  private static final ContextTracer TRACER = new ContextTracer(OM.DEBUG, CDODynamicFetchRuleAnalyzer.class);

  private static final long ELAPSE_TIME = 400L;

  private Map<CDOFeature, CDOClusterOfFetchRule> featureRules = new HashMap<CDOFeature, CDOClusterOfFetchRule>();

  private CDOGraphAnalyzer graphAnalyzer = new CDOGraphAnalyzer();

  private CDOGraph currentGraph;

  private long lastAccessTime;

  private boolean inUse;

  private InternalCDOObject lastRevision;

  private CDOView view;

  private boolean doesFetch;

  public CDODynamicFetchRuleAnalyzer(CDOView view)
  {
    this.view = view;
  }

  public CDOClusterOfFetchRule getCurrentFeatureRule()
  {
    return currentGraph.getFeatureRule();
  }

  public CDOGraph getCurrentGraph()
  {
    return currentGraph;
  }

  public void preTraverseFeature(InternalCDOObject cdoObject, CDOFeature feature, int index)
  {
    CDOClass cdoClass = cdoObject.cdoClass();
    doesFetch = false;
    CDODynamicFetchRuleManager.join(this);
    lastRevision = cdoObject;
    if (TRACER.isEnabled())
    {
      TRACER.format("preTraverseFeature : {0}.{1}", cdoClass.getName(), feature.getName());
    }

    // Do not handle these cases
    long currentTime = System.currentTimeMillis();
    long elapseTimeBeforeLastRequest = currentTime - lastAccessTime;
    lastAccessTime = currentTime;

    // Don`t handle containment relationship
    if (!feature.isReference())
    {
      return;
    }

    if (elapseTimeBeforeLastRequest > ELAPSE_TIME)
    {
      graphAnalyzer.clear();
    }

    // Purge old graph that we didn't update for specific elapse time
    graphAnalyzer.purge(ELAPSE_TIME * 2, ELAPSE_TIME * 2);

    CDOClusterOfFetchRule featureRule = getFeatureRule(cdoClass, feature);

    // Get the graph <cdoObject> belongs to
    currentGraph = graphAnalyzer.getGraph(cdoObject.cdoID(), featureRule);
    lastAccessTime = System.currentTimeMillis();

    if (currentGraph.getFeatureRule().getRootFeature() == feature)
    {
      if (graphAnalyzer.isTimeToRemove(currentGraph, lastAccessTime, ELAPSE_TIME))
      {
        // Clean it!!
        currentGraph.clean();
        return;
      }
    }

    // need to calculate currentFeature to calculate the connected graph
    if (feature.isMany() && index != 0)
    {
      return;
    }

    // Get the cluster of rule for that feature
    CDOClusterOfFetchRule currentFeatureRule = currentGraph.getFeatureRule();
    CDOFetchFeatureInfo infoOfFeature = currentFeatureRule.getFeatureStat(feature);
    infoOfFeature.updateTimeInfo(elapseTimeBeforeLastRequest);

    // Detect a new rule
    if (!infoOfFeature.isActive() && infoOfFeature.getTimeBeforeUsed() < ELAPSE_TIME)
    {
      currentFeatureRule.addFeatureRule(cdoClass, feature);
      infoOfFeature.setActive(true);
    }

    // Detect if the rule is still good!
    else if (infoOfFeature.isActive() && infoOfFeature.getTimeBeforeUsed() > ELAPSE_TIME)
    {
      // Unregister rules
      currentFeatureRule.removeFeatureRule(cdoClass, feature);
      infoOfFeature.setActive(false);
    }

    lastAccessTime = currentTime;
    inUse = true;
  }

  public void postTraverseFeature(InternalCDOObject cdoObject, CDOFeature feature, int index, Object object)
  {
    if (TRACER.isEnabled())
    {
      TRACER.format("postTraverseFeature : {0}.{1}", cdoObject.cdoClass(), feature.getName());
    }

    if (currentGraph != null)
    {
      // Adding return object to the link graph
      InternalCDOObject destObject = FSMUtil.adapt(object, view);
      currentGraph.add(cdoObject.cdoID(), feature, destObject.cdoID());

      // calculate latency time
      if (doesFetch == true)
      {
        CDOClusterOfFetchRule currentFeatureRule = currentGraph.getFeatureRule();
        CDOFetchFeatureInfo infoOfFeature = currentFeatureRule.getFeatureStat(feature);
        infoOfFeature.updateLatencyTime(System.currentTimeMillis() - lastAccessTime);
      }
    }

    lastAccessTime = System.currentTimeMillis();
    inUse = false;
    CDODynamicFetchRuleManager.leave();
  }

  public CDOID getContext()
  {
    return lastRevision.cdoID();
  }

  public synchronized CDOClusterOfFetchRule getFeatureRule(CDOClass cdoClass, CDOFeature cdoFeature)
  {
    CDOClusterOfFetchRule featureRule = featureRules.get(cdoFeature);
    if (featureRule == null)
    {
      featureRule = new CDOClusterOfFetchRule(cdoFeature);
      featureRules.put(cdoFeature, featureRule);
    }

    return featureRule;
  }

  public List<CDOFetchRule> getFetchRules(Collection<CDOID> ids)
  {
    doesFetch = true;
    if (!inUse || currentGraph == null)
    {
      return null;
    }

    List<CDOFetchRule> list = new ArrayList<CDOFetchRule>();
    for (Iterator<CDOFetchRule> it = currentGraph.getFeatureRule().iterator(); it.hasNext();)
    {
      CDOFetchRule fetchRule = it.next();
      list.add(fetchRule);
    }

    return list;
  }
}




/***************************************************************************
 * Copyright (c) 2004 - 2007 Eike Stepper, Germany.
 * 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:
 *    Simon McDuff - initial API and implementation
 *    Eike Stepper - maintenance
 **************************************************************************/
package org.eclipse.emf.internal.cdo.analyzer;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Map;

import org.eclipse.emf.cdo.protocol.CDOID;
import org.eclipse.emf.internal.cdo.bundle.OM;
import org.eclipse.net4j.internal.util.om.trace.ContextTracer;

/**
 * @author Eike Stepper
 */
public class CDOGraphAnalyzer
{
  private static final ContextTracer TRACER = new ContextTracer(OM.DEBUG, CDOGraphAnalyzer.class);

  private Map<CDOID, CDOGraph> idToGraphMap = new HashMap<CDOID, CDOGraph>();

  private HashSet<CDOGraph> uniqueGraphs = new HashSet<CDOGraph>();

  private long lastPurgeOperation;

  public CDOGraphAnalyzer()
  {
    lastPurgeOperation = System.currentTimeMillis();
  }

  public CDOGraph getGraph(CDOID fromID, CDOClusterOfFetchRule featureRule)
  {
    CDOGraph graph = idToGraphMap.get(fromID);
    if (graph == null)
    {
      graph = new CDOGraph(this, fromID, featureRule);
      uniqueGraphs.add(graph);
    }

    // Update is time value
    graph.update();
    return graph;
  }

  public void purge(long elapseTimeForPurging, long elapseTimeToClear)
  {
    long time = System.currentTimeMillis();
    if (time - lastPurgeOperation > elapseTimeForPurging)
    {
      if (TRACER.isEnabled())
      {
        TRACER.format("Purging graph {0}", this);
      }

      ArrayList<CDOGraph> listToRemove = new ArrayList<CDOGraph>();
      for (CDOGraph graph : uniqueGraphs)
      {
        if (isTimeToRemove(graph, time, elapseTimeToClear))
        {
          listToRemove.add(graph);
        }
      }

      for (CDOGraph graph : listToRemove)
      {
        graph.remove();
      }

      lastPurgeOperation = System.currentTimeMillis();
    }
  }

  public boolean isTimeToRemove(CDOGraph graph, long currentTimestamp, long elapseTimeToClear)
  {
    return currentTimestamp - graph.getLastUpdated() > elapseTimeToClear
        || currentTimestamp - graph.getFeatureRule().getLastUpdate() > elapseTimeToClear
        && currentTimestamp - graph.getCreationTime() > elapseTimeToClear;
  }

  public void addTrackingID(CDOID id, CDOGraph graph)
  {
    idToGraphMap.put(id, graph);
    graph.update();
  }

  public void removeTrackingID(CDOID id)
  {
    idToGraphMap.remove(id);
  }

  public void removeTracking(CDOGraph graph)
  {
    uniqueGraphs.remove(graph);
  }

  public void clear()
  {
    idToGraphMap.clear();
    uniqueGraphs.clear();
  }
}

Lines 11-16 Link Here

(-)src/org/eclipse/emf/internal/cdo/analyzer/CDOFetchFeatureInfo.java (-3 / +31 lines)
11	**************************************************************************/	11	**************************************************************************/
12	package org.eclipse.emf.internal.cdo.analyzer;	12	package org.eclipse.emf.internal.cdo.analyzer;
13		13
		14	import org.eclipse.emf.cdo.protocol.model.CDOClass;
		15	import org.eclipse.emf.cdo.protocol.model.CDOFeature;
		16
14	/**	17	/**
15	* @author Eike Stepper	18	* @author Eike Stepper
16	*/	19	*/
Lines 21-33 Link Here
21	private long latencyTime;	24	private long latencyTime;
22		25
23	private boolean active;	26	private boolean active;
24		27
25	public CDOFetchFeatureInfo()	28	private CDOClass cdoClass;
		29
		30	private CDOFeature cdoFeature;
		31
		32	public CDOFetchFeatureInfo(CDOClass cdoClass, CDOFeature cdoFeature)
26	{	33	{
27	active = false;	34	active = false;
28	latencyTime = -1;	35	latencyTime = -1;
		36	this.cdoClass = cdoClass;
		37	this.cdoFeature = cdoFeature;
		38	}
		39	public int hashCode()
		40	{
		41	return cdoFeature.hashCode();
		42	}
		43	public boolean equals(Object object)
		44	{
		45	if (object instanceof CDOFetchFeatureInfo)
		46	{
		47	CDOFetchFeatureInfo featureInfo = (CDOFetchFeatureInfo)object;
		48	return featureInfo.cdoClass == this.cdoClass &&
		49	featureInfo.cdoFeature == this.cdoFeature;
		50	}
		51	return false;
29	}	52	}
30
31	public boolean isActive()	53	public boolean isActive()
32	{	54	{
33	return active;	55	return active;
Lines 81-84 Link Here
81	setTimeBeforeUsed((getTimeBeforeUsed() + elapseTimeBeforeLastRequest) / 2);	103	setTimeBeforeUsed((getTimeBeforeUsed() + elapseTimeBeforeLastRequest) / 2);
82	}	104	}
83	}	105	}
		106	public CDOClass getCdoClass() {
		107	return cdoClass;
		108	}
		109	public CDOFeature getCdoFeature() {
		110	return cdoFeature;
		111	}
84	}	112	}




    {
      // At this point, fetch size is more than one.
      int fetchSize = fetchRules.size();
      out.writeInt(fetchSize);
      CDOID contextID = ruleManager.getContext();
      
      out.writeInt(fetchSize);
      out.writeInt(ruleManager.getLoadRevisionCollectionChunkSize());
      CDOIDImpl.write(out, contextID);
      
      for (CDOFetchRule fetchRule : fetchRules)
      {
        fetchRule.write(out);

Lines 28-31 Link Here

(-)src/org/eclipse/emf/cdo/analyzer/CDOFetchRuleManager.java (+3 lines)
28	public CDOID getContext();	28	public CDOID getContext();
29		29
30	public List<CDOFetchRule> getFetchRules(Collection<CDOID> ids);	30	public List<CDOFetchRule> getFetchRules(Collection<CDOID> ids);
		31
		32	public int getLoadRevisionCollectionChunkSize();
		33
31	}	34	}




/***************************************************************************
 * Copyright (c) 2004 - 2007 Eike Stepper, Germany.
 * 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:
 *    Simon McDuff - initial API and implementation
 *    Eike Stepper - maintenance
 **************************************************************************/
package org.eclipse.emf.internal.cdo.analyzer;

import java.util.ArrayList;
import java.util.Collection;
import java.util.List;

import org.eclipse.emf.cdo.internal.protocol.analyzer.CDOFetchRule;
import org.eclipse.emf.cdo.protocol.CDOID;
import org.eclipse.emf.cdo.protocol.model.CDOFeature;
import org.eclipse.emf.internal.cdo.InternalCDOObject;
import org.eclipse.emf.internal.cdo.bundle.OM;
import org.eclipse.net4j.internal.util.om.trace.ContextTracer;

/**
 * @author Eike Stepper
 */
public class CDOFeatureAnalyzerModelBased extends CDOAbstracFeatureRuleAnalyzer
{
	private static final ContextTracer TRACER = new ContextTracer(OM.DEBUG, CDOFeatureAnalyzerModelBased.class);
	
	CDOFeatureInfo featureInfos = new CDOFeatureInfo();
	
	/**
	 * 
	 */
	public void doPreTraverseFeature(InternalCDOObject cdoObject, CDOFeature feature, int index)
	{		 

	}
	
	/**
	 * 
	 */
	public void doPostTraverseFeature(InternalCDOObject cdoObject, CDOFeature feature, int index, Object value)
	{
		if (didFetch())
			featureInfos.activate(cdoObject.cdoClass(), feature);
	}
	
	/**
	 * 
	 */
	public CDOID getContext() 
	{
		// TODO Auto-generated method stu
		return null;
	}
	
	/**
	 * 
	 */
	public List<CDOFetchRule> getFetchRules(Collection<CDOID> ids) 
	{
		this.fetchData();
		
		List<CDOFetchRule> rules = new ArrayList<CDOFetchRule>();
		
		rules.addAll(featureInfos.getRules(this.lastTraverseCDOObject.cdoClass(), this.lastTraverseFeature));
		
		return rules;
	}

	

}




/***************************************************************************
 * Copyright (c) 2004 - 2007 Eike Stepper, Germany.
 * 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:
 *    Simon McDuff - initial API and implementation
 *    Eike Stepper - maintenance
 **************************************************************************/
package org.eclipse.emf.internal.cdo.analyzer;

import org.eclipse.emf.cdo.analyzer.CDOFeatureAnalyzer;
import org.eclipse.emf.cdo.analyzer.CDOFetchRuleManager;
import org.eclipse.emf.cdo.protocol.model.CDOFeature;
import org.eclipse.emf.internal.cdo.InternalCDOObject;
import org.eclipse.emf.internal.cdo.bundle.OM;
import org.eclipse.net4j.internal.util.om.trace.ContextTracer;

/**
 * @author Eike Stepper
 */
public abstract class CDOAbstracFeatureRuleAnalyzer implements CDOFeatureAnalyzer, CDOFetchRuleManager
{
	private static final ContextTracer TRACER = new ContextTracer(OM.DEBUG, CDOAbstracFeatureRuleAnalyzer.class);
	
	protected CDOFeature lastTraverseFeature;	  
	
	protected int lastTraverseIndex;

	protected long lastAccessTime;
	
	protected long lastElapseTimeBetweenOperations;
	
	protected InternalCDOObject lastTraverseCDOObject;
	
	protected long lastLatencyTime;
	
	protected int loadRevisionCollectionChunkSize;
	
	private boolean didFetch;
	
	private int nbFetch = 0;
	
	
	/**
	 * 
	 */
	public void preTraverseFeature(InternalCDOObject cdoObject, CDOFeature feature, int index) 
	{
	   if (TRACER.isEnabled())
	    {
	      TRACER.format("preTraverseFeature : {0}.{1}", cdoObject.cdoClass(), feature.getName());
	    }
	   
	    loadRevisionCollectionChunkSize =   cdoObject.cdoView().getLoadRevisionCollectionChunkSize();
	    
		// TODO Auto-generated method stub
		lastTraverseFeature = feature;
		
		lastTraverseCDOObject = cdoObject;
		
		lastTraverseIndex = index;
		
		lastElapseTimeBetweenOperations = System.currentTimeMillis() - lastAccessTime; 
		
		lastAccessTime = System.currentTimeMillis();
		
		didFetch = false;
		
		CDOFetchRuleManagerThreadLocal.join(this);

		doPreTraverseFeature( cdoObject,  feature,  index);
	}
	/**
	 * 
	 */
	protected void fetchData()
	{
		didFetch = true;
		nbFetch++;
	}
	/**
	 * 
	 * @return
	 */
	protected boolean didFetch()
	{
		return didFetch;
	}	
	/**
	 * 
	 * @param cdoObject
	 * @param feature
	 * @param index
	 */
	public void doPreTraverseFeature(InternalCDOObject cdoObject, CDOFeature feature, int index)
	{
		
	}
	/**
	 * 
	 */
	public void postTraverseFeature(InternalCDOObject cdoObject, CDOFeature feature, int index, Object value) 
	{
	    if (TRACER.isEnabled())
	    {
	      TRACER.format("postTraverseFeature : {0}.{1}", cdoObject.cdoClass(), feature.getName());
	    }		
	    try
	    {
	    	doPostTraverseFeature(cdoObject, feature, index, value);
	    }
	    finally
	    {
			CDOFetchRuleManagerThreadLocal.leave();	    	
			lastAccessTime = System.currentTimeMillis();
	    }
		
	}

	public void doPostTraverseFeature(InternalCDOObject cdoObject, CDOFeature feature, int index, Object value)
	{
		
	}
	public int getNbFetch()
	{
		return this.nbFetch;
	}
	public int getLoadRevisionCollectionChunkSize() 
	{
		return loadRevisionCollectionChunkSize;
	}	
}




/***************************************************************************
 * Copyright (c) 2004 - 2007 Eike Stepper, Germany.
 * 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:
 *    Simon McDuff - initial API and implementation
 *    Eike Stepper - maintenance
 **************************************************************************/
package org.eclipse.emf.internal.cdo.analyzer;

import java.util.ArrayList;
import java.util.Collection;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;

import org.eclipse.emf.cdo.CDOView;
import org.eclipse.emf.cdo.analyzer.CDOFeatureAnalyzer;
import org.eclipse.emf.cdo.analyzer.CDOFetchRuleManager;
import org.eclipse.emf.cdo.internal.protocol.CDOIDNull;
import org.eclipse.emf.cdo.internal.protocol.analyzer.CDOFetchRule;
import org.eclipse.emf.cdo.protocol.CDOID;
import org.eclipse.emf.cdo.protocol.model.CDOClass;
import org.eclipse.emf.cdo.protocol.model.CDOFeature;
import org.eclipse.emf.internal.cdo.InternalCDOObject;
import org.eclipse.emf.internal.cdo.bundle.OM;
import org.eclipse.emf.internal.cdo.util.FSMUtil;
import org.eclipse.net4j.internal.util.om.trace.ContextTracer;

/**
 * @author Eike Stepper
 */
public class CDOFeatureAnalyzerUI extends CDOAbstracFeatureRuleAnalyzer implements CDOFetchRuleManager
{
  private static final ContextTracer TRACER = new ContextTracer(OM.DEBUG, CDOFeatureAnalyzerUI.class);

  private static final long ELAPSE_TIME = 400L;
  
  private Map<CDOClusterOfFetchRule, CDOClusterOfFetchRule> featureRules = new HashMap<CDOClusterOfFetchRule, CDOClusterOfFetchRule>();

  private CDOClusterOfFetchRule currentClusterOfFetchRule;
  
  private long maxTimeBetweenOperation;
  
  public CDOFeatureAnalyzerUI()
  {
	  this(ELAPSE_TIME);
  }
  public CDOFeatureAnalyzerUI(long maxTimeBetweenOperation)
  {
	  this.maxTimeBetweenOperation = maxTimeBetweenOperation;
  }

  public void doPreTraverseFeature(InternalCDOObject cdoObject, CDOFeature feature, int index)
  {
    // Don`t handle containment relationship
    if (!feature.isReference())
    {
      return;
    }
    
    
    if (this.lastElapseTimeBetweenOperations > maxTimeBetweenOperation || currentClusterOfFetchRule == null)
    {
    	// The user interacted with the UI. Restart a new ClusterOfFetchRule
    	currentClusterOfFetchRule = getFeatureRule(cdoObject.cdoClass(), feature);
    }
    
  }
  
   /**
    * 
    */
  public void doPostTraverseFeature(InternalCDOObject cdoObject, CDOFeature feature, int index, Object object)
  {
    if (didFetch())
    {
    	currentClusterOfFetchRule.getFeatureInfo().activate(cdoObject.cdoClass(), feature);
    }
  }
  
  /**
   * 
   */
  public CDOID getContext()
  {
	
	if (this.lastTraverseFeature.isMany())
		return CDOIDNull.NULL;
	
    return lastTraverseCDOObject.cdoID();
  }

  /**
   * 
   * @param cdoClass
   * @param cdoFeature
   * @return
   */
  public synchronized CDOClusterOfFetchRule getFeatureRule(CDOClass cdoClass, CDOFeature cdoFeature)
  {
	CDOClusterOfFetchRule search  = new CDOClusterOfFetchRule(cdoClass, cdoFeature);
    CDOClusterOfFetchRule featureRule = featureRules.get(search);
    if (featureRule == null)
    {
      featureRule = search;
      featureRules.put(search, featureRule);
    }

    return featureRule;
  }

  public List<CDOFetchRule> getFetchRules(Collection<CDOID> ids)
  {
    boolean addRootFeature = true;
    
    this.fetchData();
    
    if (this.lastTraverseFeature.isMany())
    {
    	addRootFeature = false;
    }
    
    CDOClusterOfFetchRule search = new CDOClusterOfFetchRule(lastTraverseCDOObject.cdoClass(), lastTraverseFeature);

    CDOClusterOfFetchRule fetchOfRule = this.featureRules.get(search);
    
    if (fetchOfRule == null)
    	return null;
    
    Collection<CDOFetchRule> fetchRules = fetchOfRule.getFeatureInfo().getRules(null, null);
    
    List<CDOFetchRule> list = new ArrayList<CDOFetchRule>();
    
    for (CDOFetchRule fetchRule : fetchRules)
    {
      if (addRootFeature == true || (lastTraverseCDOObject.cdoClass() != fetchRule.getCDOClass()))
      {
    	  list.add(fetchRule);  
      }
    }
    
    return list;
  }
}




/***************************************************************************
 * Copyright (c) 2004 - 2007 Eike Stepper, Germany.
 * 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:
 *    Simon McDuff - initial API and implementation
 *    Eike Stepper - maintenance
 **************************************************************************/
package org.eclipse.emf.internal.cdo.analyzer;

import org.eclipse.emf.cdo.analyzer.CDOFetchRuleManager;
import org.eclipse.emf.cdo.internal.protocol.analyzer.CDOFetchRule;
import org.eclipse.emf.cdo.protocol.CDOID;

import java.util.Collection;
import java.util.List;

/**
 * @author Eike Stepper
 */
public class CDOFetchRuleManagerThreadLocal implements CDOFetchRuleManager
{
  private static final ThreadLocal<CDOFetchRuleManager> threadLocal = new ThreadLocal<CDOFetchRuleManager>();

  public CDOFetchRuleManagerThreadLocal()
  {
  }

  public static void join(CDOFetchRuleManager fetchRulemanager)
  {
    threadLocal.set(fetchRulemanager);
  }

  public static CDOFetchRuleManager getCurrent()
  {
    return threadLocal.get();
  }

  public static void leave()
  {
    threadLocal.set(null);
  }

  public CDOID getContext()
  {
    CDOFetchRuleManager analyzer = CDOFetchRuleManagerThreadLocal.getCurrent();
    return analyzer != null ? analyzer.getContext() : null;
  }

  public List<CDOFetchRule> getFetchRules(Collection<CDOID> ids)
  {
    CDOFetchRuleManager analyzer = CDOFetchRuleManagerThreadLocal.getCurrent();
    return analyzer != null ? analyzer.getFetchRules(ids) : null;
  }

  public int getLoadRevisionCollectionChunkSize() 
  {
	  CDOFetchRuleManager analyzer = CDOFetchRuleManagerThreadLocal.getCurrent();
	  return analyzer != null ? analyzer.getLoadRevisionCollectionChunkSize() : 0;
  }
}




/***************************************************************************
 * Copyright (c) 2004 - 2007 Eike Stepper, Germany.
 * 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:
 *    Simon McDuff - initial API and implementation
 *    Eike Stepper - maintenance
 **************************************************************************/

package org.eclipse.emf.internal.cdo.analyzer;

import java.util.Collection;
import java.util.HashMap;
import java.util.Map;

import org.eclipse.emf.cdo.internal.protocol.analyzer.CDOFetchRule;
import org.eclipse.emf.cdo.protocol.model.CDOClass;
import org.eclipse.emf.cdo.protocol.model.CDOFeature;
import org.eclipse.emf.internal.cdo.bundle.OM;
import org.eclipse.net4j.internal.util.om.trace.ContextTracer;
/**
 * @author Eike Stepper
 */
public class CDOFeatureInfo 
{
	private static final ContextTracer TRACER = new ContextTracer(OM.DEBUG, CDOFeatureInfo.class);
	
	private Map<CDOFetchFeatureInfo, CDOFetchFeatureInfo> featureStats = new HashMap<CDOFetchFeatureInfo, CDOFetchFeatureInfo>();
	private Map<CDOClass, CDOFetchRule> fetchRules = new HashMap<CDOClass, CDOFetchRule>();
	
	/**
	 * 
	 * @param cdoClass
	 * @param cdoFeature
	 * @return
	 */
    public synchronized CDOFetchFeatureInfo getFeatureStat(CDOClass cdoClass, CDOFeature cdoFeature)
	{
		CDOFetchFeatureInfo search = new CDOFetchFeatureInfo(cdoClass, cdoFeature);
	    CDOFetchFeatureInfo featureRule = featureStats.get(search);
	    if (featureRule == null)
	    {
	      featureRule = search;
	      featureStats.put(search, featureRule);
	    }
	    return featureRule;
	}
    /**
     * 
     * @param cdoClass
     * @param cdoFeature
     * @return
     */
    public boolean isActivate(CDOClass cdoClass, CDOFeature cdoFeature)
    {
		CDOFetchFeatureInfo search = new CDOFetchFeatureInfo(cdoClass, cdoFeature);
	    CDOFetchFeatureInfo featureRule = featureStats.get(search);
	    return (featureRule != null && featureRule.isActive());
    }
    /**
     * 
     * @param cdoClass
     * @param cdoFeature
     */
    public void activate(CDOClass cdoClass, CDOFeature cdoFeature)
    {
    	CDOFetchFeatureInfo info = getFeatureStat(cdoClass, cdoFeature);
    	if (!info.isActive())
    	{
    		info.setActive(true);
    		addRule(cdoClass, cdoFeature);
    	}
    }
    /**
     * 
     * @param cdoClass
     * @param cdoFeature
     */
    public void desactivate(CDOClass cdoClass, CDOFeature cdoFeature)
    {
    	CDOFetchFeatureInfo info = getFeatureStat(cdoClass, cdoFeature);
    	if (info.isActive())
    	{
    		info.setActive(false);
    		removeRule(cdoClass, cdoFeature);
    	}
    }
    /**
     * 
     * @param cdoClass
     * @param cdoFeature
     */
    private void addRule(CDOClass cdoClass, CDOFeature cdoFeature)
    {
    	if (TRACER.isEnabled())
    	{
    		TRACER.format("Adding a new rule : {0}.{1}", cdoClass.getName(), cdoFeature.getName());
    	}
    	CDOFetchRule fetchRule = fetchRules.get(cdoClass);
    	if (fetchRule == null)
    	{
    		fetchRule = new CDOFetchRule(cdoClass);
    		fetchRules.put(cdoClass, fetchRule);
    	}
    	fetchRule.addFeature(cdoFeature);
    	
    }
    /**
     * 
     * @param cdoClass
     * @param cdoFeature
     * @return
     */
    public Collection<CDOFetchRule> getRules(CDOClass cdoClass, CDOFeature cdoFeature)
    {
    	return fetchRules.values();
    }
    
    /**
     * 
     * @param cdoClass
     * @param cdoFeature
     */
    private void removeRule(CDOClass cdoClass, CDOFeature cdoFeature)
    {
    	if (TRACER.isEnabled())
    	{
    		TRACER.format("Removing rule : {0}.{1}", cdoClass.getName(), cdoFeature.getName());
    	}    	
    	CDOFetchRule fetchRule = fetchRules.get(cdoClass);
    	if (fetchRule == null)
    		return;
  		
    	fetchRule.removeFeature(cdoFeature);
    }    
}

Return to bug 202064

Added Link Here

(-)src/org/eclipse/emf/cdo/tests/FetchRuleAnalyzerTest.java (+121 lines)
1	/***************************************************************************
2	* Copyright (c) 2004 - 2007 Eike Stepper, Germany.
3	* All rights reserved. This program and the accompanying materials
4	* are made available under the terms of the Eclipse Public License v1.0
5	* which accompanies this distribution, and is available at
6	* http://www.eclipse.org/legal/epl-v10.html
7	*
8	* Contributors:
9	* Simon McDuff - initial API and implementation
10	**************************************************************************/
11	package org.eclipse.emf.cdo.tests;
12
13	import org.eclipse.emf.cdo.CDOSession;
14	import org.eclipse.emf.cdo.CDOState;
15	import org.eclipse.emf.cdo.CDOTransaction;
16	import org.eclipse.emf.cdo.eresource.CDOResource;
17	import org.eclipse.emf.cdo.tests.model1.Company;
18	import org.eclipse.emf.cdo.tests.model1.Model1Factory;
19	import org.eclipse.emf.cdo.tests.model1.PurchaseOrder;
20	import org.eclipse.emf.cdo.tests.model1.SalesOrder;
21	import org.eclipse.emf.cdo.tests.model1.Supplier;
22	import org.eclipse.emf.cdo.util.CDOUtil;
23
24	import org.eclipse.net4j.IBufferHandler;
25	import org.eclipse.net4j.IChannel;
26
27	import org.eclipse.emf.common.util.EList;
28	import org.eclipse.emf.common.util.URI;
29	import org.eclipse.emf.ecore.EObject;
30	import org.eclipse.emf.ecore.resource.ResourceSet;
31	import org.eclipse.emf.ecore.resource.impl.ResourceSetImpl;
32	import org.eclipse.emf.internal.cdo.CDOSessionImpl;
33	import org.eclipse.emf.internal.cdo.CDOTransactionImpl;
34	import org.eclipse.emf.internal.cdo.analyzer.CDOFeatureAnalyzerModelBased;
35	import org.eclipse.emf.internal.cdo.analyzer.CDOFetchRuleManagerThreadLocal;
36
37	import java.util.Date;
38
39	/**
40	* @author Eike Stepper
41	*/
42	public class FetchRuleAnalyzerTest extends AbstractCDOTest
43	{
44
45	public void testLoadObject() throws Exception
46	{
47	{
48	// disableConsole();
49	msg("Opening session");
50	CDOSession session = openModel1Session();
51
52	msg("Opening transaction");
53	CDOTransaction transaction = session.openTransaction(new ResourceSetImpl());
54
55	msg("Creating resource");
56	CDOResource resource = transaction.createResource("/test2");
57
58	msg("Creating supplier");
59
60	for (int i = 0 ; i< 10; i++)
61	{
62	Company company = Model1Factory.eINSTANCE.createCompany();
63	company.setCity("CITY" + String.valueOf(i));
64
65	for (int j = 0 ; j< 10; j++)
66	{
67	PurchaseOrder purchaseOrder = Model1Factory.eINSTANCE.createPurchaseOrder();
68	company.getPurchaseOrders().add(purchaseOrder);
69
70
71	Supplier supplier = Model1Factory.eINSTANCE.createSupplier();
72
73	// Should it detect supplier to make it persistent...
74	// I don't want to do resource.getContents().add(supplier)
75	purchaseOrder.setSupplier(supplier);
76
77	SalesOrder salesOrder = Model1Factory.eINSTANCE.createSalesOrder();
78	company.getSalesOrders().add(salesOrder);
79	}
80	resource.getContents().add(company);
81	}
82
83	transaction.commit();
84	// XXX session.close();
85	enableConsole();
86	}
87
88	msg("Opening session");
89	CDOSessionImpl session = (CDOSessionImpl)openModel1Session();
90
91	session.getRevisionManager().setRuleManager(new CDOFetchRuleManagerThreadLocal());
92
93
94	msg("Opening transaction");
95	CDOTransactionImpl transaction = (CDOTransactionImpl)session.openTransaction(new ResourceSetImpl());
96
97	CDOFeatureAnalyzerModelBased featureanalyzerModelBased = new CDOFeatureAnalyzerModelBased();
98
99	transaction.setFeatureAnalyzer(featureanalyzerModelBased);
100
101	transaction.setLoadRevisionCollectionChunkSize(10);
102
103	msg("Getting resource");
104	CDOResource resource = transaction.getResource("/test2");
105
106	msg("Getting contents");
107	EList<EObject> contents = resource.getContents();
108
109	for (EObject eObject : contents)
110	{
111	Company company = (Company) eObject;
112	for (PurchaseOrder purchaseOrder : company.getPurchaseOrders())
113	{
114	purchaseOrder.getSupplier();
115	}
116	}
117	assertEquals(featureanalyzerModelBased.getNbFetch(), 12);
118
119	msg("Verifying name");
120	}
121	}

Lines 85-93 Link Here

(-)src/org/eclipse/emf/internal/cdo/protocol/LoadRevisionRequest.java (-1 / +4 lines)
85	{	85	{
86	// At this point, fetch size is more than one.	86	// At this point, fetch size is more than one.
87	int fetchSize = fetchRules.size();	87	int fetchSize = fetchRules.size();
88	out.writeInt(fetchSize);
89	CDOID contextID = ruleManager.getContext();	88	CDOID contextID = ruleManager.getContext();
		89
		90	out.writeInt(fetchSize);
		91	out.writeInt(ruleManager.getLoadRevisionCollectionChunkSize());
90	CDOIDImpl.write(out, contextID);	92	CDOIDImpl.write(out, contextID);
		93
91	for (CDOFetchRule fetchRule : fetchRules)	94	for (CDOFetchRule fetchRule : fetchRules)
92	{	95	{
93	fetchRule.write(out);	96	fetchRule.write(out);