Attachment #77950 for bug #202064

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




/***************************************************************************
 * 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.cdo.protocol.analyzer;

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

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

/**
 * @author Eike Stepper
 */
public interface IFetchRuleManager
{
  public static final IFetchRuleManager NOOP = new NOOPFetchRuleManager();

  public CDOID getContext();

  public List<CDOFetchRule> getFetchRules(Collection<CDOID> ids);
}




/***************************************************************************
 * 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.cdo.protocol.analyzer;

import org.eclipse.emf.cdo.internal.protocol.analyzer.NOOPFeatureAnalyzer;
import org.eclipse.emf.cdo.protocol.model.CDOFeature;
import org.eclipse.emf.cdo.protocol.revision.CDORevision;

/**
 * @author Eike Stepper
 */
public interface IFeatureAnalyzer
{
  public static final IFeatureAnalyzer NOOP = new NOOPFeatureAnalyzer();

  public void preTraverseFeature(CDORevision revision, CDOFeature feature, int index);

  public void postTraverseFeature(CDORevision revision, CDOFeature feature, int index);
}




/***************************************************************************
 * 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.cdo.internal.protocol.analyzer;

import org.eclipse.emf.cdo.internal.protocol.bundle.OM;
import org.eclipse.emf.cdo.protocol.model.CDOClass;
import org.eclipse.emf.cdo.protocol.model.CDOFeature;

import org.eclipse.net4j.internal.util.om.trace.ContextTracer;

import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;

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

  private CDOClass cdoClass;

  private CDOFeature cdoFeature;

  private Map<CDOFeature, CDOFetchFeatureStat> featureStats = new HashMap<CDOFeature, CDOFetchFeatureStat>();

  private Map<CDOClass, CDOFetchRule> fetchRules = new HashMap<CDOClass, CDOFetchRule>();

  public CDOFeatureRule(CDOClass cdoClass, CDOFeature cdoFeature)
  {
    this.cdoClass = cdoClass;
    this.cdoFeature = cdoFeature;
  }

  public CDOClass getCDOClass()
  {
    return cdoClass;
  }

  public CDOFeature getCDOFeature()
  {
    return cdoFeature;
  }

  public Iterator<CDOFetchRule> iterator()
  {
    return fetchRules.values().iterator();
  }

  public synchronized CDOFetchFeatureStat getFeatureStat(CDOFeature cdoFeature)
  {
    CDOFetchFeatureStat featureRule = featureStats.get(cdoFeature);
    if (featureRule == null)
    {
      featureRule = new CDOFetchFeatureStat();
      featureStats.put(cdoFeature, featureRule);
    }

    return featureRule;
  }

  public synchronized CDOFetchRule addFeatureRule(CDOClass cdoClass, CDOFeature cdoFeature)
  {
    if (TRACER.isEnabled())
    {
      TRACER.format("Adding new fetch rule : {0}.{1} from root {2}.{3}", cdoClass.getName(), cdoFeature.getName(),
          this.cdoClass.getName(), this.cdoFeature.getName());
    }

    CDOFetchRule fetchRule = getFetchRule(cdoClass);
    fetchRule.addFeature(cdoFeature);
    return fetchRule;

  }

  public synchronized CDOFetchRule removeFeatureRule(CDOClass cdoClass, CDOFeature cdoFeature)
  {
    if (TRACER.isEnabled())
    {
      TRACER.format("Adding new fetch rule : {0}.{1} from root {2}.{3}", cdoClass.getName(), cdoFeature.getName(),
          this.cdoClass.getName(), this.cdoFeature.getName());
    }

    CDOFetchRule fetchRule = getFetchRule(cdoClass);
    fetchRule.removeFeature(cdoFeature);
    if (fetchRule.isEmpty())
    {
      fetchRules.remove(cdoClass);
    }

    return fetchRule;
  }

  public synchronized CDOFetchRule getFetchRule(CDOClass cdoFeature)
  {
    CDOFetchRule featureRule = fetchRules.get(cdoFeature);
    if (featureRule == null)
    {
      featureRule = new CDOFetchRule(cdoFeature);
      fetchRules.put(cdoFeature, featureRule);
    }

    return featureRule;
  }
}




/***************************************************************************
 * 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.cdo.internal.protocol.analyzer;

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

import org.eclipse.emf.cdo.protocol.CDOID;
import org.eclipse.emf.cdo.protocol.analyzer.IFetchRuleManager;

/**
 * @author Eike Stepper
 */
public class CDOFetchRuleManager implements IFetchRuleManager
{
  public CDOFetchRuleManager()
  {
  }

  public CDOID getContext()
  {
    return CDOFeatureAnalyzer.getCurrent().getContext();
  }

  public List<CDOFetchRule> getFetchRules(Collection<CDOID> ids)
  {
    return CDOFeatureAnalyzer.getCurrent().getFetchRules(ids);
  }
}




/***************************************************************************
 * 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.cdo.internal.protocol.analyzer;

import org.eclipse.emf.cdo.protocol.analyzer.IFeatureAnalyzer;
import org.eclipse.emf.cdo.protocol.model.CDOFeature;
import org.eclipse.emf.cdo.protocol.revision.CDORevision;

/**
 * @author Eike Stepper
 */
public class NOOPFeatureAnalyzer implements IFeatureAnalyzer
{
  public NOOPFeatureAnalyzer()
  {
  }

  public void preTraverseFeature(CDORevision cdoClass, CDOFeature feature, int index)
  {
  }

  public void postTraverseFeature(CDORevision cdoClass, CDOFeature feature, int index)
  {
  }
}




/***************************************************************************
 * 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.cdo.internal.protocol.analyzer;

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

import org.eclipse.emf.cdo.internal.protocol.CDOIDNull;
import org.eclipse.emf.cdo.protocol.CDOID;
import org.eclipse.emf.cdo.protocol.analyzer.IFetchRuleManager;

/**
 * @author Eike Stepper
 */
public class NOOPFetchRuleManager implements IFetchRuleManager
{
  public CDOID getContext()
  {
    return CDOIDNull.NULL;
  }

  public List<CDOFetchRule> getFetchRules(Collection<CDOID> ids)
  {
    return null;
  }

  @Deprecated
  public List<CDOFetchRule> getFetchRules(CDOID id)
  {
    return 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.cdo.internal.protocol.analyzer;

/**
 * @author Eike Stepper
 */
public class CDOFetchFeatureStat
{
  private CDOFetchRule fetchRule;

  private long timeBeforeUsed;

  private long latencyTime;

  public CDOFetchFeatureStat()
  {
  }

  public boolean isValid()
  {
    return fetchRule != null;
  }

  public long getTimeBeforeUsed()
  {
    return timeBeforeUsed;
  }

  public void setTimeBeforeUsed(long timeBeforeUsed)
  {
    this.timeBeforeUsed = timeBeforeUsed;
  }

  public long getLatencyTime()
  {
    return latencyTime;
  }

  public void setLatencyTime(long latencyTime)
  {
    this.latencyTime = latencyTime;
  }

  public CDOFetchRule getFetchRule()
  {
    return fetchRule;
  }

  public void setFetchRule(CDOFetchRule fetchRule)
  {
    this.fetchRule = fetchRule;
  }
}




/***************************************************************************
 * 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.cdo.internal.protocol.analyzer;

import org.eclipse.emf.cdo.internal.protocol.bundle.OM;
import org.eclipse.emf.cdo.protocol.CDOID;
import org.eclipse.emf.cdo.protocol.analyzer.IFeatureAnalyzer;
import org.eclipse.emf.cdo.protocol.analyzer.IFetchRuleManager;
import org.eclipse.emf.cdo.protocol.model.CDOClass;
import org.eclipse.emf.cdo.protocol.model.CDOFeature;
import org.eclipse.emf.cdo.protocol.revision.CDORevision;

import org.eclipse.net4j.internal.util.om.trace.ContextTracer;

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

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

  private static final long ELAPSE_TIME = 400L;

  private static final ThreadLocal<CDOFeatureAnalyzer> threadLocal = new ThreadLocal<CDOFeatureAnalyzer>();

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

  private CDOFeatureRule lastFeatureRule;

  private long lastAccessTime;

  private boolean inUse;

  private CDORevision lastRevision;

  public CDOFeatureAnalyzer()
  {
  }

  public CDOFeatureRule getCurrentFeatureRule()
  {
    return lastFeatureRule;
  }

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

  public void preTraverseFeature(CDORevision revision, CDOFeature feature, int index)
  {
    CDOClass cdoClass = revision.getCDOClass();
    threadLocal.set(this);
    lastRevision = revision;

    if (TRACER.isEnabled())
    {
      TRACER.format("preTraverseFeature : {0}.{1}", cdoClass.getName(), feature.getName());
    }

    // Do not handle these cases
    long currentTime = System.currentTimeMillis();
    if (!feature.isReference() || feature.isContainment() || feature.isMany() && index != 0)
    {
      lastAccessTime = currentTime;
      return;
    }

    long elapseTimeBeforeLastRequest = currentTime - lastAccessTime;
    if (elapseTimeBeforeLastRequest > ELAPSE_TIME || lastFeatureRule == null)
    {
      CDOFeatureRule featureRule = getFeatureRule(cdoClass, feature);
      lastFeatureRule = featureRule;
    }

    CDOFetchFeatureStat stat = lastFeatureRule.getFeatureStat(feature);
    if (stat.getTimeBeforeUsed() != 0)
    {
      stat.setTimeBeforeUsed((stat.getTimeBeforeUsed() + elapseTimeBeforeLastRequest) / 2);
    }
    else
    {
      stat.setTimeBeforeUsed(elapseTimeBeforeLastRequest);
    }

    if (!stat.isValid() && stat.getTimeBeforeUsed() < CDOFeatureAnalyzer.ELAPSE_TIME)
    {
      CDOFetchRule fetchRule = lastFeatureRule.addFeatureRule(cdoClass, feature);
      stat.setFetchRule(fetchRule);
    }
    else if (stat.isValid() && stat.getTimeBeforeUsed() > CDOFeatureAnalyzer.ELAPSE_TIME)
    {
      // Unregister rules
      lastFeatureRule.removeFeatureRule(cdoClass, feature);
      stat.setFetchRule(null);
    }

    lastAccessTime = currentTime;
    inUse = true;
  }

  public void postTraverseFeature(CDORevision revision, CDOFeature feature, int index)
  {
    if (TRACER.isEnabled())
    {
      TRACER.format("postTraverseFeature : {0}.{1}", revision.getCDOClass(), feature.getName());
    }

    lastAccessTime = System.currentTimeMillis();
    inUse = false;
    threadLocal.set(null);
  }

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

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

    return featureRule;
  }

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

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

    return list;
  }
}

Lines 15-21 Link Here

(-)META-INF/MANIFEST.MF (-1 lines)
15	org.eclipse.emf.cdo.internal.protocol.model.resource;version="0.8.0",	15	org.eclipse.emf.cdo.internal.protocol.model.resource;version="0.8.0",
16	org.eclipse.emf.cdo.internal.protocol.revision;version="0.8.0",	16	org.eclipse.emf.cdo.internal.protocol.revision;version="0.8.0",
17	org.eclipse.emf.cdo.protocol;version="0.8.0",	17	org.eclipse.emf.cdo.protocol;version="0.8.0",
18	org.eclipse.emf.cdo.protocol.analyzer;version="0.8.0",
19	org.eclipse.emf.cdo.protocol.model;version="0.8.0",	18	org.eclipse.emf.cdo.protocol.model;version="0.8.0",
20	org.eclipse.emf.cdo.protocol.model.core;version="0.8.0",	19	org.eclipse.emf.cdo.protocol.model.core;version="0.8.0",
21	org.eclipse.emf.cdo.protocol.model.resource;version="0.8.0",	20	org.eclipse.emf.cdo.protocol.model.resource;version="0.8.0",




import org.eclipse.net4j.util.io.ExtendedDataOutputStream;

import java.io.IOException;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;


    if (fetchSize > 0)
    {
      contextID = CDOIDImpl.read(in);
      
      if (PROTOCOL.isEnabled()) PROTOCOL.format("Reading fetch rules for context {0}", contextID);      
      
      for (int i = 0; i < fetchSize; i++)
      {
        CDOFetchRule fetchRule = new CDOFetchRule(in, getPackageManager());
        fetchRules.put(fetchRule.getCDOClass(), fetchRule);

      }

    }
  }

  @Override
  protected void responding(ExtendedDataOutputStream out) throws IOException
  {
	  
    Session session = getSession();
    
    List<CDORevisionImpl> additionalRevisions = new ArrayList<CDORevisionImpl>();
    
    HashSet<CDOID> revisions = new HashSet<CDOID>();
    
    if (PROTOCOL.isEnabled()) PROTOCOL.format("Writing {0} revisions", ids.length);
    
    
    // Need to fetch the rule first.
    if (!contextID.isNull() && fetchRules.size() > 0)
    {
      if (PROTOCOL.isEnabled()) PROTOCOL.format("Collecting more objects based on rules");
      //System.out.println("Collecting more objects based on rules");
      // Should be more benefits to have referenceChunk more than 1.
      // Hope the consumer thought about that !!! 
      CDORevisionImpl revisionContext = getRevision(contextID);
      
      collectRevisionsByRule(revisionContext, referenceChunk, revisions, additionalRevisions, new HashSet<CDOFetchRule>());
    }

    
    
    for (CDOID id : ids)
    {
      CDORevisionImpl revision = getRevision(id);
      revision.write(out, session, referenceChunk);
      revisions.add( revision.getID() );
      session.collectContainedRevisions(revision, referenceChunk, revisions, additionalRevisions);
    }

    
    out.writeInt(additionalRevisions.size());
    
    if (PROTOCOL.isEnabled()) PROTOCOL.format("Writing {0} additional revisions", additionalRevisions.size());
    //System.out.println("ADDITIONAL REVISION" + additionalRevisions.size());
    for (CDORevisionImpl revision : additionalRevisions)
    {
      revision.write(out, session, referenceChunk);
    }

  }

  private void collectRevisionsByRule(CDORevisionImpl revision, int referenceChunk,
		  Set<CDOID> revisions, List<CDORevisionImpl> additionalRevisions, 
		  Set<CDOFetchRule> workingFetchRules)
  {
    CDOFetchRule fetchRule = fetchRules.get(revision.getCDOClass());
    if (fetchRule == null || workingFetchRules.contains(fetchRule))

    }

    workingFetchRules.add(fetchRule);
    
    RevisionManager revisionManager = getSessionManager().getRepository().getRevisionManager();
    for (CDOFeature feature : fetchRule.getFeatures())
    {

          if (value instanceof CDOID)
          {
            CDOID id = (CDOID)value;
            if (!id.isNull() && !revisions.contains(id))
            {
            	CDORevisionImpl containedRevision = revisionManager.getRevision(id, referenceChunk);
            	
            	revisions.add(containedRevision.getID());
            	additionalRevisions.add(containedRevision);
            	
            	collectRevisionsByRule(containedRevision, referenceChunk, revisions, additionalRevisions, workingFetchRules);
            }
          }
        }
      }

        if (value instanceof CDOID)
        {
          CDOID id = (CDOID)value;
          if (!id.isNull() && !revisions.contains(id))
          {
            CDORevisionImpl containedRevision = revisionManager.getRevision(id, referenceChunk);
        	
            revisions.add(containedRevision.getID());
        	additionalRevisions.add(containedRevision);
        	
        	collectRevisionsByRule(containedRevision, referenceChunk, revisions, additionalRevisions, workingFetchRules);
          }
        }
      }





import java.text.MessageFormat;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.concurrent.ConcurrentHashMap;

    {
      return id;
    }
    
    if (knownObjects.contains(id))
    {
      // TODO On client-side add a check if the id is really known!
      return id;
    }
    
    knownObjects.add(id);
    Repository repository = sessionManager.getRepository();
    CDOClassRef type = repository.getTypeManager().getObjectType(StoreUtil.getReader(), id);
    return CDOIDImpl.create(id.getValue(), type);
    
  }

  /**
   * TODO I can't see how recursion is controlled/limited
   */
  public void collectContainedRevisions(CDORevisionImpl revision, int referenceChunk,
      Set<CDOID> revisions, List<CDORevisionImpl> additionalRevisions)
  {
    RevisionManager revisionManager = getSessionManager().getRepository().getRevisionManager();
    CDOClassImpl cdoClass = revision.getCDOClass();

        if (value instanceof CDOID)
        {
          CDOID id = (CDOID)value;
          if (!id.isNull() && !revisions.contains(id))
          {
            if (containedRevisions.get(id) == null)
            {
              CDORevisionImpl containedRevision = revisionManager.getRevision(id, referenceChunk);
              revisions.add(id);
              additionalRevisions.add(containedRevision);
              
              collectContainedRevisions(containedRevision, referenceChunk, revisions, additionalRevisions);
          }
        }
      }




 **************************************************************************/
package org.eclipse.emf.internal.cdo;

import java.text.MessageFormat;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Set;

import org.eclipse.emf.cdo.CDOState;
import org.eclipse.emf.cdo.CDOView;
import org.eclipse.emf.cdo.CDOViewEvent;
import org.eclipse.emf.cdo.CDOViewResourcesEvent;
import org.eclipse.emf.cdo.analyzer.CDOFeatureAnalyzer;
import org.eclipse.emf.cdo.eresource.CDOResource;
import org.eclipse.emf.cdo.eresource.EresourceFactory;
import org.eclipse.emf.cdo.eresource.impl.CDOResourceImpl;

import org.eclipse.emf.cdo.internal.protocol.revision.CDORevisionImpl;
import org.eclipse.emf.cdo.protocol.CDOID;
import org.eclipse.emf.cdo.protocol.CDOIDTyped;
import org.eclipse.emf.cdo.protocol.analyzer.IFeatureAnalyzer;
import org.eclipse.emf.cdo.protocol.model.CDOClass;
import org.eclipse.emf.cdo.protocol.model.CDOClassRef;
import org.eclipse.emf.cdo.protocol.revision.CDORevisionResolver;
import org.eclipse.emf.cdo.protocol.util.TransportException;
import org.eclipse.emf.cdo.util.CDOUtil;
import org.eclipse.emf.cdo.util.ReadOnlyException;

import org.eclipse.net4j.internal.util.om.trace.ContextTracer;
import org.eclipse.net4j.signal.IFailOverStrategy;
import org.eclipse.net4j.util.ImplementationError;

import org.eclipse.emf.common.notify.Adapter;
import org.eclipse.emf.common.notify.Notification;
import org.eclipse.emf.common.notify.Notifier;

import org.eclipse.emf.internal.cdo.protocol.ResourcePathRequest;
import org.eclipse.emf.internal.cdo.util.FSMUtil;
import org.eclipse.emf.internal.cdo.util.ModelUtil;
import org.eclipse.net4j.internal.util.om.trace.ContextTracer;
import org.eclipse.net4j.signal.IFailOverStrategy;
import org.eclipse.net4j.util.ImplementationError;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Set;

/**
 * @author Eike Stepper


  private int loadRevisionCollectionChunkSize = 1;

  private CDOFeatureAnalyzer featureAnalyzer = CDOFeatureAnalyzer.NOOP;

  private Map<CDOID, InternalCDOObject> objects = new HashMap<CDOID, InternalCDOObject>();


    this.loadRevisionCollectionChunkSize = loadRevisionCollectionChunkSize;
  }

  public CDOFeatureAnalyzer getFeatureAnalyzer()
  {
    return featureAnalyzer;
  }

  public void setFeatureAnalyzer(CDOFeatureAnalyzer featureAnalyzer)
  {
    this.featureAnalyzer = featureAnalyzer == null ? CDOFeatureAnalyzer.NOOP : featureAnalyzer;
  }

  public CDOTransactionImpl toTransaction()




 **************************************************************************/
package org.eclipse.emf.internal.cdo;

import java.text.MessageFormat;
import java.util.HashSet;
import java.util.Set;

import org.eclipse.emf.cdo.internal.protocol.model.CDOFeatureImpl;
import org.eclipse.emf.cdo.internal.protocol.revision.CDORevisionImpl;
import org.eclipse.emf.cdo.internal.protocol.revision.CDORevisionImpl.MoveableList;
import org.eclipse.emf.cdo.protocol.CDOID;
import org.eclipse.emf.cdo.protocol.model.CDOFeature;
import org.eclipse.emf.cdo.protocol.revision.CDOReferenceProxy;

import org.eclipse.net4j.internal.util.om.trace.ContextTracer;

import org.eclipse.emf.ecore.EClass;
import org.eclipse.emf.ecore.EObject;
import org.eclipse.emf.ecore.EStructuralFeature;

import org.eclipse.emf.internal.cdo.bundle.OM;
import org.eclipse.emf.internal.cdo.util.FSMUtil;
import org.eclipse.emf.internal.cdo.util.ModelUtil;
import org.eclipse.net4j.internal.util.om.trace.ContextTracer;
import java.text.MessageFormat;
import java.util.HashSet;
import java.util.Set;

/**
 * @author Eike Stepper

      TRACER.format("get({0}, {1}, {2})", cdoObject, cdoFeature, index);
    }

    view.getFeatureAnalyzer().preTraverseFeature(cdoObject, cdoFeature, index);
    CDORevisionImpl revision = getRevisionForReading(cdoObject);
    Object value = get(revision, cdoFeature, index);
    if (cdoFeature.isReference())

        CDOID id = (CDOID)value;
        loadAhead(revision, cdoFeature, id, index);
      }
      
      value = view.convertIDToObject(value);
    }
    
    view.getFeatureAnalyzer().postTraverseFeature(cdoObject, cdoFeature, index, value);
    return value;
  }





import org.eclipse.emf.cdo.internal.protocol.revision.CDORevisionResolverImpl;
import org.eclipse.emf.cdo.internal.protocol.revision.CDORevisionImpl.MoveableList;
import org.eclipse.emf.cdo.protocol.CDOID;
import org.eclipse.emf.cdo.analyzer.CDOFetchRuleManager;
import org.eclipse.emf.cdo.protocol.model.CDOFeature;
import org.eclipse.emf.cdo.protocol.revision.CDOReferenceProxy;
import org.eclipse.emf.cdo.protocol.util.TransportException;

{
  private CDOSessionImpl session;

  private CDOFetchRuleManager ruleManager = CDOFetchRuleManager.NOOP;

  public CDORevisionManagerImpl(CDOSessionImpl session)
  {

    }
  }

  public CDOFetchRuleManager getRuleManager()
  {
    return ruleManager;
  }

  public void setRuleManager(CDOFetchRuleManager ruleManager)
  {
    this.ruleManager = ruleManager;
  }




 **************************************************************************/
package org.eclipse.emf.internal.cdo.protocol;

import java.io.IOException;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.List;

import org.eclipse.emf.cdo.analyzer.CDOFetchRuleManager;
import org.eclipse.emf.cdo.internal.protocol.CDOIDImpl;
import org.eclipse.emf.cdo.internal.protocol.analyzer.CDOFetchRule;
import org.eclipse.emf.cdo.internal.protocol.revision.CDORevisionImpl;
import org.eclipse.emf.cdo.protocol.CDOID;
import org.eclipse.emf.cdo.protocol.CDOProtocolConstants;
import org.eclipse.emf.cdo.protocol.analyzer.IFetchRuleManager;

import org.eclipse.net4j.IChannel;
import org.eclipse.net4j.internal.util.om.trace.ContextTracer;
import org.eclipse.net4j.util.io.ExtendedDataInputStream;
import org.eclipse.net4j.util.io.ExtendedDataOutputStream;

import org.eclipse.emf.internal.cdo.CDORevisionManagerImpl;
import org.eclipse.emf.internal.cdo.CDOSessionImpl;
import org.eclipse.emf.internal.cdo.CDOSessionPackageManager;
import org.eclipse.emf.internal.cdo.bundle.OM;
import org.eclipse.net4j.IChannel;
import org.eclipse.net4j.internal.util.om.trace.ContextTracer;
import org.eclipse.net4j.util.io.ExtendedDataInputStream;
import org.eclipse.net4j.util.io.ExtendedDataOutputStream;
import java.util.Collections;
import java.util.List;

/**
 * @author Eike Stepper

      CDOIDImpl.write(out, id);
    }

    CDOFetchRuleManager ruleManager = getSession().getRevisionManager().getRuleManager();
    List<CDOFetchRule> fetchRules = ruleManager.getFetchRules(ids);
    if (fetchRules == null || fetchRules.size() <= 0)
    {
      out.writeInt(0);
    }
    else
    {
      // At this point, fetch size is more than one.    
      int fetchSize = fetchRules.size();
      out.writeInt(fetchSize);
      CDOID contextID = ruleManager.getContext();
      CDOIDImpl.write(out, contextID);
      for (CDOFetchRule fetchRule : fetchRules)
      {
        fetchRule.write(out);
        CDOIDImpl.write(out, contextID);
        for (CDOFetchRule fetchRule : fetchRules)
        {
          fetchRule.write(out);
        }
      }
    }
  }




 org.eclipse.emf.ecore.xmi;bundle-version="[2.3.0,3.0.0)",
 org.eclipse.emf.cdo.protocol;bundle-version="[0.8.0,0.9.0)";visibility:=reexport
Export-Package: org.eclipse.emf.cdo;version="0.8.0",
 org.eclipse.emf.cdo.analyzer;version="0.8.0",
 org.eclipse.emf.cdo.eresource;version="0.8.0",
 org.eclipse.emf.cdo.eresource.impl;version="0.8.0",
 org.eclipse.emf.cdo.eresource.util;version="0.8.0",
 org.eclipse.emf.cdo.util;version="0.8.0",
 org.eclipse.emf.internal.cdo;version="0.8.0",
 org.eclipse.emf.internal.cdo.analyzer;version="0.8.0",
 org.eclipse.emf.internal.cdo.protocol;version="0.8.0",
 org.eclipse.emf.internal.cdo.util;version="0.8.0"
Eclipse-LazyStart: true




/***************************************************************************
 * 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.internal.protocol.analyzer.CDOFetchRule;
import org.eclipse.emf.internal.cdo.bundle.OM;
import org.eclipse.net4j.internal.util.om.trace.ContextTracer;

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

  private long latencyTime;
  
  private boolean active;

  public CDOFetchFeatureInfo()
  {
	  active = false;
	  latencyTime = -1;
  }

  public boolean isActive()
  {
    return active;
  }
  public void setActive(boolean isActive)
  {
    active = isActive;
  }

  public long getTimeBeforeUsed()
  {
    return timeBeforeUsed;
  }

  public void setTimeBeforeUsed(long timeBeforeUsed)
  {
    this.timeBeforeUsed = timeBeforeUsed;
  }

  public long getLatencyTime()
  {
    return latencyTime;
  }
  /**
   * 
   * @param latencyTime
   */
  public void updateLatencyTime(long latencyTime)
  {
	  if (this.latencyTime == -1)
		  this.latencyTime = latencyTime;
	  else
		  this.latencyTime = (latencyTime + this.latencyTime) / 2;
  }
  /**
   * 
   * @param latencyTime
   */
  public void setLatencyTime(long latencyTime)
  {
    this.latencyTime = latencyTime;
  }
  /**
   * 
   * @param elapseTimeBeforeLastRequest
   */
  public void updateTimeInfo(long elapseTimeBeforeLastRequest)
  {
	  if (this.getTimeBeforeUsed() != 0)
	  {
		  this.setTimeBeforeUsed((this.getTimeBeforeUsed() + elapseTimeBeforeLastRequest) / 2);
	  }
	  else
	  {
		  this.setTimeBeforeUsed(elapseTimeBeforeLastRequest);
	  }
  }

}




/***************************************************************************
 * 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 cdoView;
  
  private boolean doesFetch;
  
  
  /**
   * 
   * @param view
   */
  public CDODynamicFetchRuleAnalyzer(CDOView view)
  {
	  cdoView = view;
  }
  
  /**
   * 
   * @return
   */
  public CDOClusterOfFetchRule getCurrentFeatureRule()
  {
    return currentGraph.getFeatureRule();
  }
  
  
  public CDOGraph getCurrentGraph()
  {
	  return this.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()) //|| feature.isContainment())
      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 = this.getFeatureRule(cdoClass, feature);
    
    // Get the graph <cdoObject> belongs to
    this.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() < CDODynamicFetchRuleAnalyzer.ELAPSE_TIME)
    {
      currentFeatureRule.addFeatureRule(cdoClass, feature);
      infoOfFeature.setActive(true);
    }
    // Detect if the rule is still good!
    else if (infoOfFeature.isActive() && infoOfFeature.getTimeBeforeUsed() > CDODynamicFetchRuleAnalyzer.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 dstCdoObject = FSMUtil.adapt(object, cdoView);
    	currentGraph.add(cdoObject.cdoID(), feature, dstCdoObject.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();
  }
  
  /**
   * 
   * @param cdoClass
   * @param cdoFeature
   * @return
   */
  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;
  }
  
  /**
   * Called when from LoadRevisionRequest
   */
  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.Collection;
import java.util.List;

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;

/**
 * @author Eike Stepper
 */
public class NOOPFetchRuleManager implements CDOFetchRuleManager
{
  public CDOID getContext()
  {
    return CDOIDNull.NULL;
  }

  public List<CDOFetchRule> getFetchRules(Collection<CDOID> ids)
  {
    return 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.Collection;
import java.util.List;

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.internal.cdo.bundle.OM;
import org.eclipse.net4j.internal.util.om.trace.ContextTracer;

/**
 * @author Eike Stepper
 */
public class CDODynamicFetchRuleManager implements CDOFetchRuleManager
{
  private static final ContextTracer TRACER = new ContextTracer(OM.DEBUG, CDODynamicFetchRuleManager.class);
  
  private static final ThreadLocal<CDOFetchRuleManager> threadLocal = new ThreadLocal<CDOFetchRuleManager>();
  
  public CDODynamicFetchRuleManager()
  {
	  
  }
  
  /**
   * 
   * @param fetchRulemanager
   */
  public static void join(CDOFetchRuleManager fetchRulemanager)
  {
	  threadLocal.set(fetchRulemanager);
  }
  /**
   * 
   * @return
   */
  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.cdo.analyzer;

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.internal.cdo.analyzer.NOOPFetchRuleManager;

/**
 * @author Eike Stepper
 */
public interface CDOFetchRuleManager
{
  public static final CDOFetchRuleManager NOOP = new NOOPFetchRuleManager();

  public CDOID getContext();

  public List<CDOFetchRule> getFetchRules(Collection<CDOID> ids);
}




/***************************************************************************
 * 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.HashMap;
import java.util.Iterator;
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 CDOClusterOfFetchRule
{
  public static final ContextTracer TRACER = new ContextTracer(OM.DEBUG, CDOClusterOfFetchRule.class);

  private Map<CDOFeature, CDOFetchFeatureInfo> featureStats = new HashMap<CDOFeature, CDOFetchFeatureInfo>();

  private Map<CDOClass, CDOFetchRule> fetchRules = new HashMap<CDOClass, CDOFetchRule>();
  
  private long lastUpdate;

  private CDOFeature rootFeature;
  /**
   * 
   * @param cdoClass
   * @param cdoFeature
   */
  public CDOClusterOfFetchRule(CDOFeature rootFeature)
  {
    lastUpdate = System.currentTimeMillis();
    this.rootFeature = rootFeature;
  }
  
  public boolean isActive()
  {
	  return !fetchRules.isEmpty();
  }
  /**
   * 
   * @return
   */
  public Iterator<CDOFetchRule> iterator()
  {
    return fetchRules.values().iterator();
  }

  /**
   * 
   * @param cdoFeature
   * @return
   */
  public synchronized CDOFetchFeatureInfo getFeatureStat(CDOFeature cdoFeature)
  {
    CDOFetchFeatureInfo featureRule = featureStats.get(cdoFeature);
    if (featureRule == null)
    {
      featureRule = new CDOFetchFeatureInfo();
      featureStats.put(cdoFeature, featureRule);
    }

    return featureRule;
  }

  /**
   * 
   * @param cdoClass
   * @param cdoFeature
   * @return
   */
  public synchronized CDOFetchRule addFeatureRule(CDOClass cdoClass, CDOFeature cdoFeature)
  {
    if (TRACER.isEnabled())
    {
      TRACER.format("Adding new fetch rule : {0}.{1} from root feature {2}", cdoClass.getName(), cdoFeature.getName(), rootFeature);
    }
    lastUpdate = System.currentTimeMillis();
    CDOFetchRule fetchRule = getFetchRule(cdoClass);
    fetchRule.addFeature(cdoFeature);
    return fetchRule;

  }

  /**
   * 
   * @param cdoClass
   * @param cdoFeature
   * @return
   */
  public synchronized CDOFetchRule removeFeatureRule(CDOClass cdoClass, CDOFeature cdoFeature)
  {
    if (TRACER.isEnabled())
    {
      TRACER.format("Removing fetch rule : {0}.{1} from root feature {2}", cdoClass.getName(), cdoFeature.getName(),rootFeature);
    }
    
    lastUpdate = System.currentTimeMillis();
    
    CDOFetchRule fetchRule = getFetchRule(cdoClass);
    fetchRule.removeFeature(cdoFeature);
    if (fetchRule.isEmpty())
    {
      fetchRules.remove(cdoClass);
    }
    return fetchRule;
  }

  /**
   * 
   * @param cdoFeature
   * @return
   */
  public synchronized CDOFetchRule getFetchRule(CDOClass cdoFeature)
  {
    CDOFetchRule featureRule = fetchRules.get(cdoFeature);
    if (featureRule == null)
    {
      featureRule = new CDOFetchRule(cdoFeature);
      fetchRules.put(cdoFeature, featureRule);
    }

    return featureRule;
  }
  
  /**
   * 
   * @return
   */
  public long getLastUpdate() 
  {
	return lastUpdate;
  }
  
  /**
   * 
   * @return
   */
  public CDOFeature getRootFeature() 
  {
	return rootFeature;
  }
}




/***************************************************************************
 * 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.protocol.model.CDOFeature;
import org.eclipse.emf.internal.cdo.InternalCDOObject;


/**
 * @author Eike Stepper
 */
public class NOOPFeatureAnalyzer implements CDOFeatureAnalyzer
{
  public NOOPFeatureAnalyzer()
  {
  }

  public void preTraverseFeature(InternalCDOObject cdoClass, CDOFeature feature, int index)
  {
  }

  public void postTraverseFeature(InternalCDOObject cdoClass, CDOFeature feature, int index, Object value)
  {
  }
}




/***************************************************************************
 * 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.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 CDOClusterOfFetchRule featureRule;
	  
	  private List<CDOID> clusterOfObjects = new ArrayList<CDOID>();
	  
	  private long lastUpdated;
	  
	  private long creationTime;
	  
	  private CDOGraphAnalyzer analyzer;
	  
	  /**
	   * 
	   * @param analyzer
	   * @param rootID
	   * @param featureRule
	   */
	  public CDOGraph(CDOGraphAnalyzer analyzer, CDOID rootID, CDOClusterOfFetchRule featureRule)
	  {
		  this.featureRule = featureRule;
		  this.analyzer = analyzer;
		  // Adding the root element
		  add(rootID, null, rootID);
		  creationTime = System.currentTimeMillis();
	  }
	  
	  /**
	   * 
	   */
	  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();
	  }
	  /**
	   * 
	   * @param cdoID
	   */
	  public void add(CDOID fromId,  CDOFeature feature, CDOID cdoID)
	  {
		  // For now .. we do not need to calculate the path.. later we will do!!
		  clusterOfObjects.add(cdoID);
		  analyzer.addTrackingID(cdoID, this);
	  }
	  public CDOID getRoot()
	  {
		  return getObjects().get(0);
	  }
	  /**
	   * 
	   * @return
	   */
	  public List<CDOID> getObjects()
	  {
		return this.clusterOfObjects;  
	  }
	  /***
	   * 
	   * @return
	   */
	  public CDOClusterOfFetchRule getFeatureRule() 
	  {
		return featureRule;
	  }
	  
	  /**
	   * 
	   */
	  public void remove()
	  {
		  if (TRACER.isEnabled())
		  {
			  TRACER.format("Removing CDOGraph {0}", this);
		  }
		  
		  for (CDOID cdoId : this.clusterOfObjects)
		  {
			  analyzer.removeTrackingID(cdoId);
		  }
		  analyzer.removeTracking(this);
	  }
      /**
       * 
       * @return
       */
	  public long getLastUpdated() 
	  {
		return lastUpdated;
	  }

	public long getCreationTime() {
		return creationTime;
	}
};




/***************************************************************************
 * 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.cdo.analyzer;

import org.eclipse.emf.cdo.protocol.model.CDOFeature;
import org.eclipse.emf.internal.cdo.InternalCDOObject;
import org.eclipse.emf.internal.cdo.analyzer.NOOPFeatureAnalyzer;


/**
 * @author Eike Stepper
 */
public interface CDOFeatureAnalyzer
{
  public static final CDOFeatureAnalyzer NOOP = new NOOPFeatureAnalyzer();

  public void preTraverseFeature(InternalCDOObject revision, CDOFeature feature, int index);

  public void postTraverseFeature(InternalCDOObject revision, CDOFeature feature, int index, Object value);
}




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

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

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.internal.cdo.CDOSessionImpl;
import org.eclipse.emf.internal.cdo.CDOViewImpl;
import org.eclipse.net4j.internal.util.concurrent.QueueWorkerWorkSerializer;

public class CDOReadAhead 
{
	 QueueWorkerWorkSerializer workerWork = new QueueWorkerWorkSerializer();
	 CDOViewImpl session;
	 
	 public CDOReadAhead(CDOViewImpl session)
	 {
		 this.session = session;
	 }
	 
	 /**
	  * 
	  * @return
	  */
	 public CDOViewImpl getSession()
	 {
		 return session;
	 }
	 
	 /**
	  * 
	  * @param cdoID
	  */
	 public void addID(Set<CDOID> cdoID)
	 {
		 CDODynamicFetchRuleAnalyzer  dynamic = ((CDODynamicFetchRuleAnalyzer)getSession().getFeatureAnalyzer()); 
		 
    	 if ( dynamic.getCurrentGraph().getFeatureRule().isActive())
    	 {
    		 workerWork.addWork( new ReceiverWork(cdoID));	 
    	 }
		 
	 }
	 
	
	 /**
	  * 
	  * @author Simon McDuff
	  *
	  */
	 private final class ReceiverWork implements Runnable
	 {
		 private final class Test implements CDOFetchRuleManager
		 {

			public CDOID getContext() 
			{
				// TODO Auto-generated method stub
				return context;
			}

			public List<CDOFetchRule> getFetchRules(Collection<CDOID> ids) 
			{
				// TODO Auto-generated method stub
			    List<CDOFetchRule> list = new ArrayList<CDOFetchRule>();
			    
			    for (Iterator<CDOFetchRule> it = graph.getFeatureRule().iterator(); it.hasNext();)
			    {
			      CDOFetchRule fetchRule = it.next();
			      list.add(fetchRule);
			    }
			    return list;
			}
		 }		 
		private Set<CDOID> cdoID;
		private CDODynamicFetchRuleAnalyzer dynamic;
		private CDOGraph graph;
		private CDOID context;
		private Test test = new Test();
	    private ReceiverWork(Set<CDOID> cdoID)
	    {
	    	 this.cdoID = cdoID;
	    	 dynamic = ((CDODynamicFetchRuleAnalyzer)getSession().getFeatureAnalyzer()); 
	    	 graph = dynamic.getCurrentGraph();
	    	 this.context = ((CDODynamicFetchRuleAnalyzer)getSession().getFeatureAnalyzer()).getContext();
	    }
	    public void run()
	    {
	    	CDODynamicFetchRuleManager.join(test);
	    	getSession().getSession().getRevisionManager().getRevisions(cdoID, getSession().getSession().getReferenceChunkSize());
	    }
	  }
	
}




/***************************************************************************
 * 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.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> fromIdToGraphMaps = new HashMap<CDOID, CDOGraph>();
	
	private HashSet<CDOGraph> uniqueGraphSet = new HashSet<CDOGraph>();
	private long lastPurgeOperation;
	
	public CDOGraphAnalyzer()
	{
		lastPurgeOperation = System.currentTimeMillis();
	}
	/**
	 * 
	 * @param fromID
	 * @return
	 */
	public CDOGraph getGraph(CDOID fromID, CDOClusterOfFetchRule featureRule)
	{
		CDOGraph graph = fromIdToGraphMaps.get(fromID);
		  
		if (graph == null)
		{		    		  
		  graph = new CDOGraph(this, fromID, featureRule);
		  uniqueGraphSet.add( graph );
		}
		
		// Update is time value
		graph.update();
		
		return graph;	  
	}
	

	/**
	 * 
	 * @param elapseTimeForPurging
	 * @param elapseTimeToClear
	 */
	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 : this.uniqueGraphSet)
			  {
				  if (isTimeToRemove(graph, time, elapseTimeToClear))
					  listToRemove.add(graph);
			  }
			  
			  for (CDOGraph graph : listToRemove)
			  {
				  graph.remove();
			  }
			  
			  lastPurgeOperation = System.currentTimeMillis();
		  }
	  }
	public boolean isTimeToRemove(CDOGraph cdoGraph, long currentTimestamp, long elapseTimeToClear)
	{
		  return (currentTimestamp - cdoGraph.getLastUpdated() > elapseTimeToClear || 
				  (currentTimestamp - cdoGraph.getFeatureRule().getLastUpdate() > elapseTimeToClear &&
						  currentTimestamp - cdoGraph.getCreationTime() > elapseTimeToClear));
	}
	/**
	 * 
	 * @param cdoID
	 */
	public void addTrackingID(CDOID cdoID, CDOGraph cdoGraph)
	{
		fromIdToGraphMaps.put(cdoID, cdoGraph);
		cdoGraph.update();
	}  
	/**
	 * 
	 * @param cdoID
	 */
	public void removeTrackingID(CDOID cdoID)
	{
		fromIdToGraphMaps.remove(cdoID);
	}
	/**
	 * 
	 * @param graph
	 */
	public void removeTracking(CDOGraph graph )
	{
		uniqueGraphSet.remove(graph);
	}
	public void clear()
	{
		fromIdToGraphMaps.clear();
		uniqueGraphSet.clear();
	}
}

Return to bug 202064

Removed Link Here

(-)src/org/eclipse/emf/cdo/internal/protocol/analyzer/CDOFeatureRule.java (-115 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	* Eike Stepper - maintenance
11	**************************************************************************/
12	package org.eclipse.emf.cdo.internal.protocol.analyzer;
13
14	import org.eclipse.emf.cdo.internal.protocol.bundle.OM;
15	import org.eclipse.emf.cdo.protocol.model.CDOClass;
16	import org.eclipse.emf.cdo.protocol.model.CDOFeature;
17
18	import org.eclipse.net4j.internal.util.om.trace.ContextTracer;
19
20	import java.util.HashMap;
21	import java.util.Iterator;
22	import java.util.Map;
23
24	/**
25	* @author Eike Stepper
26	*/
27	public class CDOFeatureRule
28	{
29	private static final ContextTracer TRACER = new ContextTracer(OM.DEBUG, CDOFeatureRule.class);
30
31	private CDOClass cdoClass;
32
33	private CDOFeature cdoFeature;
34
35	private Map<CDOFeature, CDOFetchFeatureStat> featureStats = new HashMap<CDOFeature, CDOFetchFeatureStat>();
36
37	private Map<CDOClass, CDOFetchRule> fetchRules = new HashMap<CDOClass, CDOFetchRule>();
38
39	public CDOFeatureRule(CDOClass cdoClass, CDOFeature cdoFeature)
40	{
41	this.cdoClass = cdoClass;
42	this.cdoFeature = cdoFeature;
43	}
44
45	public CDOClass getCDOClass()
46	{
47	return cdoClass;
48	}
49
50	public CDOFeature getCDOFeature()
51	{
52	return cdoFeature;
53	}
54
55	public Iterator<CDOFetchRule> iterator()
56	{
57	return fetchRules.values().iterator();
58	}
59
60	public synchronized CDOFetchFeatureStat getFeatureStat(CDOFeature cdoFeature)
61	{
62	CDOFetchFeatureStat featureRule = featureStats.get(cdoFeature);
63	if (featureRule == null)
64	{
65	featureRule = new CDOFetchFeatureStat();
66	featureStats.put(cdoFeature, featureRule);
67	}
68
69	return featureRule;
70	}
71
72	public synchronized CDOFetchRule addFeatureRule(CDOClass cdoClass, CDOFeature cdoFeature)
73	{
74	if (TRACER.isEnabled())
75	{
76	TRACER.format("Adding new fetch rule : {0}.{1} from root {2}.{3}", cdoClass.getName(), cdoFeature.getName(),
77	this.cdoClass.getName(), this.cdoFeature.getName());
78	}
79
80	CDOFetchRule fetchRule = getFetchRule(cdoClass);
81	fetchRule.addFeature(cdoFeature);
82	return fetchRule;
83
84	}
85
86	public synchronized CDOFetchRule removeFeatureRule(CDOClass cdoClass, CDOFeature cdoFeature)
87	{
88	if (TRACER.isEnabled())
89	{
90	TRACER.format("Adding new fetch rule : {0}.{1} from root {2}.{3}", cdoClass.getName(), cdoFeature.getName(),
91	this.cdoClass.getName(), this.cdoFeature.getName());
92	}
93
94	CDOFetchRule fetchRule = getFetchRule(cdoClass);
95	fetchRule.removeFeature(cdoFeature);
96	if (fetchRule.isEmpty())
97	{
98	fetchRules.remove(cdoClass);
99	}
100
101	return fetchRule;
102	}
103
104	public synchronized CDOFetchRule getFetchRule(CDOClass cdoFeature)
105	{
106	CDOFetchRule featureRule = fetchRules.get(cdoFeature);
107	if (featureRule == null)
108	{
109	featureRule = new CDOFetchRule(cdoFeature);
110	fetchRules.put(cdoFeature, featureRule);
111	}
112
113	return featureRule;
114	}
115	}

Removed Link Here

(-)src/org/eclipse/emf/cdo/internal/protocol/analyzer/CDOFetchFeatureStat.java (-63 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	* Eike Stepper - maintenance
11	**************************************************************************/
12	package org.eclipse.emf.cdo.internal.protocol.analyzer;
13
14	/**
15	* @author Eike Stepper
16	*/
17	public class CDOFetchFeatureStat
18	{
19	private CDOFetchRule fetchRule;
20
21	private long timeBeforeUsed;
22
23	private long latencyTime;
24
25	public CDOFetchFeatureStat()
26	{
27	}
28
29	public boolean isValid()
30	{
31	return fetchRule != null;
32	}
33
34	public long getTimeBeforeUsed()
35	{
36	return timeBeforeUsed;
37	}
38
39	public void setTimeBeforeUsed(long timeBeforeUsed)
40	{
41	this.timeBeforeUsed = timeBeforeUsed;
42	}
43
44	public long getLatencyTime()
45	{
46	return latencyTime;
47	}
48
49	public void setLatencyTime(long latencyTime)
50	{
51	this.latencyTime = latencyTime;
52	}
53
54	public CDOFetchRule getFetchRule()
55	{
56	return fetchRule;
57	}
58
59	public void setFetchRule(CDOFetchRule fetchRule)
60	{
61	this.fetchRule = fetchRule;
62	}
63	}

Removed Link Here

(-)src/org/eclipse/emf/cdo/internal/protocol/analyzer/CDOFeatureAnalyzer.java (-163 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	* Eike Stepper - maintenance
11	**************************************************************************/
12	package org.eclipse.emf.cdo.internal.protocol.analyzer;
13
14	import org.eclipse.emf.cdo.internal.protocol.bundle.OM;
15	import org.eclipse.emf.cdo.protocol.CDOID;
16	import org.eclipse.emf.cdo.protocol.analyzer.IFeatureAnalyzer;
17	import org.eclipse.emf.cdo.protocol.analyzer.IFetchRuleManager;
18	import org.eclipse.emf.cdo.protocol.model.CDOClass;
19	import org.eclipse.emf.cdo.protocol.model.CDOFeature;
20	import org.eclipse.emf.cdo.protocol.revision.CDORevision;
21
22	import org.eclipse.net4j.internal.util.om.trace.ContextTracer;
23
24	import java.util.ArrayList;
25	import java.util.Collection;
26	import java.util.HashMap;
27	import java.util.Iterator;
28	import java.util.List;
29	import java.util.Map;
30
31	/**
32	* @author Eike Stepper
33	*/
34	public class CDOFeatureAnalyzer implements IFeatureAnalyzer, IFetchRuleManager
35	{
36	private static final ContextTracer TRACER = new ContextTracer(OM.DEBUG, CDOFeatureAnalyzer.class);
37
38	private static final long ELAPSE_TIME = 400L;
39
40	private static final ThreadLocal<CDOFeatureAnalyzer> threadLocal = new ThreadLocal<CDOFeatureAnalyzer>();
41
42	private Map<CDOFeature, CDOFeatureRule> featureRules = new HashMap<CDOFeature, CDOFeatureRule>();
43
44	private CDOFeatureRule lastFeatureRule;
45
46	private long lastAccessTime;
47
48	private boolean inUse;
49
50	private CDORevision lastRevision;
51
52	public CDOFeatureAnalyzer()
53	{
54	}
55
56	public CDOFeatureRule getCurrentFeatureRule()
57	{
58	return lastFeatureRule;
59	}
60
61	public static CDOFeatureAnalyzer getCurrent()
62	{
63	return threadLocal.get();
64	}
65
66	public void preTraverseFeature(CDORevision revision, CDOFeature feature, int index)
67	{
68	CDOClass cdoClass = revision.getCDOClass();
69	threadLocal.set(this);
70	lastRevision = revision;
71
72	if (TRACER.isEnabled())
73	{
74	TRACER.format("preTraverseFeature : {0}.{1}", cdoClass.getName(), feature.getName());
75	}
76
77	// Do not handle these cases
78	long currentTime = System.currentTimeMillis();
79	if (!feature.isReference() \|\| feature.isContainment() \|\| feature.isMany() && index != 0)
80	{
81	lastAccessTime = currentTime;
82	return;
83	}
84
85	long elapseTimeBeforeLastRequest = currentTime - lastAccessTime;
86	if (elapseTimeBeforeLastRequest > ELAPSE_TIME \|\| lastFeatureRule == null)
87	{
88	CDOFeatureRule featureRule = getFeatureRule(cdoClass, feature);
89	lastFeatureRule = featureRule;
90	}
91
92	CDOFetchFeatureStat stat = lastFeatureRule.getFeatureStat(feature);
93	if (stat.getTimeBeforeUsed() != 0)
94	{
95	stat.setTimeBeforeUsed((stat.getTimeBeforeUsed() + elapseTimeBeforeLastRequest) / 2);
96	}
97	else
98	{
99	stat.setTimeBeforeUsed(elapseTimeBeforeLastRequest);
100	}
101
102	if (!stat.isValid() && stat.getTimeBeforeUsed() < CDOFeatureAnalyzer.ELAPSE_TIME)
103	{
104	CDOFetchRule fetchRule = lastFeatureRule.addFeatureRule(cdoClass, feature);
105	stat.setFetchRule(fetchRule);
106	}
107	else if (stat.isValid() && stat.getTimeBeforeUsed() > CDOFeatureAnalyzer.ELAPSE_TIME)
108	{
109	// Unregister rules
110	lastFeatureRule.removeFeatureRule(cdoClass, feature);
111	stat.setFetchRule(null);
112	}
113
114	lastAccessTime = currentTime;
115	inUse = true;
116	}
117
118	public void postTraverseFeature(CDORevision revision, CDOFeature feature, int index)
119	{
120	if (TRACER.isEnabled())
121	{
122	TRACER.format("postTraverseFeature : {0}.{1}", revision.getCDOClass(), feature.getName());
123	}
124
125	lastAccessTime = System.currentTimeMillis();
126	inUse = false;
127	threadLocal.set(null);
128	}
129
130	public CDOID getContext()
131	{
132	return lastRevision.getID();
133	}
134
135	public synchronized CDOFeatureRule getFeatureRule(CDOClass cdoClass, CDOFeature cdoFeature)
136	{
137	CDOFeatureRule featureRule = featureRules.get(cdoFeature);
138	if (featureRule == null)
139	{
140	featureRule = new CDOFeatureRule(cdoClass, cdoFeature);
141	featureRules.put(cdoFeature, featureRule);
142	}
143
144	return featureRule;
145	}
146
147	public List<CDOFetchRule> getFetchRules(Collection<CDOID> ids)
148	{
149	if (!inUse \|\| lastFeatureRule == null)
150	{
151	return null;
152	}
153
154	List<CDOFetchRule> list = new ArrayList<CDOFetchRule>();
155	for (Iterator<CDOFetchRule> it = lastFeatureRule.iterator(); it.hasNext();)
156	{
157	CDOFetchRule fetchRule = it.next();
158	list.add(fetchRule);
159	}
160
161	return list;
162	}
163	}

Lines 28-35 Link Here

(-)src/org/eclipse/emf/cdo/internal/server/protocol/LoadRevisionIndication.java (-23 / +55 lines)
28	import org.eclipse.net4j.util.io.ExtendedDataOutputStream;	28	import org.eclipse.net4j.util.io.ExtendedDataOutputStream;
29		29
30	import java.io.IOException;	30	import java.io.IOException;
		31	import java.util.ArrayList;
31	import java.util.HashMap;	32	import java.util.HashMap;
32	import java.util.HashSet;	33	import java.util.HashSet;
		34	import java.util.List;
33	import java.util.Map;	35	import java.util.Map;
34	import java.util.Set;	36	import java.util.Set;
35		37
Lines 79-117 Link Here
79	if (fetchSize > 0)	81	if (fetchSize > 0)
80	{	82	{
81	contextID = CDOIDImpl.read(in);	83	contextID = CDOIDImpl.read(in);
		84
		85	if (PROTOCOL.isEnabled()) PROTOCOL.format("Reading fetch rules for context {0}", contextID);
		86
82	for (int i = 0; i < fetchSize; i++)	87	for (int i = 0; i < fetchSize; i++)
83	{	88	{
84	CDOFetchRule fetchRule = new CDOFetchRule(in, getPackageManager());	89	CDOFetchRule fetchRule = new CDOFetchRule(in, getPackageManager());
85	fetchRules.put(fetchRule.getCDOClass(), fetchRule);	90	fetchRules.put(fetchRule.getCDOClass(), fetchRule);
		91
86	}	92	}
		93
87	}	94	}
88	}	95	}
89		96
90	@Override	97	@Override
91	protected void responding(ExtendedDataOutputStream out) throws IOException	98	protected void responding(ExtendedDataOutputStream out) throws IOException
92	{	99	{
		100
93	Session session = getSession();	101	Session session = getSession();
94	Map<CDOID, CDORevisionImpl> containedRevisions = new HashMap<CDOID, CDORevisionImpl>(0);	102
95		103	List<CDORevisionImpl> additionalRevisions = new ArrayList<CDORevisionImpl>();
		104
		105	HashSet<CDOID> revisions = new HashSet<CDOID>();
		106
96	if (PROTOCOL.isEnabled()) PROTOCOL.format("Writing {0} revisions", ids.length);	107	if (PROTOCOL.isEnabled()) PROTOCOL.format("Writing {0} revisions", ids.length);
97	for (CDOID id : ids)	108
		109
		110	// Need to fetch the rule first.
		111	if (!contextID.isNull() && fetchRules.size() > 0)
98	{	112	{
99	CDORevisionImpl revision = getRevision(id);	113	if (PROTOCOL.isEnabled()) PROTOCOL.format("Collecting more objects based on rules");
100	revision.write(out, session, referenceChunk);	114	//System.out.println("Collecting more objects based on rules");
101	session.collectContainedRevisions(revision, referenceChunk, containedRevisions);	115	// Should be more benefits to have referenceChunk more than 1.
		116	// Hope the consumer thought about that !!!
		117	CDORevisionImpl revisionContext = getRevision(contextID);
		118
		119	collectRevisionsByRule(revisionContext, referenceChunk, revisions, additionalRevisions, new HashSet<CDOFetchRule>());
102	}	120	}
103		121
104	if (!contextID.isNull() && fetchRules.size() > 0)	122
		123
		124	for (CDOID id : ids)
105	{	125	{
106	// TODO What is this good for? Why 1000?	126	CDORevisionImpl revision = getRevision(id);
107	int newReferenceChunk = Math.max(referenceChunk, 1000);	127	revision.write(out, session, referenceChunk);
108	CDORevisionImpl revisionContext = getRevision(contextID);	128	revisions.add( revision.getID() );
109	collectRevisionsByRule(revisionContext, newReferenceChunk, containedRevisions, new HashSet<CDOFetchRule>());	129	session.collectContainedRevisions(revision, referenceChunk, revisions, additionalRevisions);
110	}	130	}
111		131
112	out.writeInt(containedRevisions.size());	132
113	if (PROTOCOL.isEnabled()) PROTOCOL.format("Writing {0} additional revisions", containedRevisions.size());	133	out.writeInt(additionalRevisions.size());
114	for (CDORevisionImpl revision : containedRevisions.values())	134
		135	if (PROTOCOL.isEnabled()) PROTOCOL.format("Writing {0} additional revisions", additionalRevisions.size());
		136	//System.out.println("ADDITIONAL REVISION" + additionalRevisions.size());
		137	for (CDORevisionImpl revision : additionalRevisions)
115	{	138	{
116	revision.write(out, session, referenceChunk);	139	revision.write(out, session, referenceChunk);
117	}	140	}
Lines 123-129 Link Here
123	}	146	}
124		147
125	private void collectRevisionsByRule(CDORevisionImpl revision, int referenceChunk,	148	private void collectRevisionsByRule(CDORevisionImpl revision, int referenceChunk,
126	Map<CDOID, CDORevisionImpl> containedRevisions, Set<CDOFetchRule> workingFetchRules)	149	Set<CDOID> revisions, List<CDORevisionImpl> additionalRevisions,
		150	Set<CDOFetchRule> workingFetchRules)
127	{	151	{
128	CDOFetchRule fetchRule = fetchRules.get(revision.getCDOClass());	152	CDOFetchRule fetchRule = fetchRules.get(revision.getCDOClass());
129	if (fetchRule == null \|\| workingFetchRules.contains(fetchRule))	153	if (fetchRule == null \|\| workingFetchRules.contains(fetchRule))
Lines 132-137 Link Here
132	}	156	}
133		157
134	workingFetchRules.add(fetchRule);	158	workingFetchRules.add(fetchRule);
		159
135	RevisionManager revisionManager = getSessionManager().getRepository().getRevisionManager();	160	RevisionManager revisionManager = getSessionManager().getRepository().getRevisionManager();
136	for (CDOFeature feature : fetchRule.getFeatures())	161	for (CDOFeature feature : fetchRule.getFeatures())
137	{	162	{
Lines 145-155 Link Here
145	if (value instanceof CDOID)	170	if (value instanceof CDOID)
146	{	171	{
147	CDOID id = (CDOID)value;	172	CDOID id = (CDOID)value;
148	// TODO Missing here? if (!id.isNull() &&	173	if (!id.isNull() && !revisions.contains(id))
149	// !containedRevisions.containsKey(id))	174	{
150	CDORevisionImpl containedRevision = revisionManager.getRevision(id, referenceChunk);	175	CDORevisionImpl containedRevision = revisionManager.getRevision(id, referenceChunk);
151	containedRevisions.put(containedRevision.getID(), containedRevision);	176
152	collectRevisionsByRule(containedRevision, referenceChunk, containedRevisions, workingFetchRules);	177	revisions.add(containedRevision.getID());
		178	additionalRevisions.add(containedRevision);
		179
		180	collectRevisionsByRule(containedRevision, referenceChunk, revisions, additionalRevisions, workingFetchRules);
		181	}
153	}	182	}
154	}	183	}
155	}	184	}
Lines 159-169 Link Here
159	if (value instanceof CDOID)	188	if (value instanceof CDOID)
160	{	189	{
161	CDOID id = (CDOID)value;	190	CDOID id = (CDOID)value;
162	if (!id.isNull() && !containedRevisions.containsKey(id))	191	if (!id.isNull() && !revisions.contains(id))
163	{	192	{
164	CDORevisionImpl containedRevision = revisionManager.getRevision(id, referenceChunk);	193	CDORevisionImpl containedRevision = revisionManager.getRevision(id, referenceChunk);
165	containedRevisions.put(containedRevision.getID(), containedRevision);	194
166	collectRevisionsByRule(containedRevision, referenceChunk, containedRevisions, workingFetchRules);	195	revisions.add(containedRevision.getID());
		196	additionalRevisions.add(containedRevision);
		197
		198	collectRevisionsByRule(containedRevision, referenceChunk, revisions, additionalRevisions, workingFetchRules);
167	}	199	}
168	}	200	}
169	}	201	}

Lines 34-39 Link Here

(-)src/org/eclipse/emf/cdo/internal/server/Session.java (-9 / +10 lines)
34		34
35	import java.text.MessageFormat;	35	import java.text.MessageFormat;
36	import java.util.HashSet;	36	import java.util.HashSet;
		37	import java.util.List;
37	import java.util.Map;	38	import java.util.Map;
38	import java.util.Set;	39	import java.util.Set;
39	import java.util.concurrent.ConcurrentHashMap;	40	import java.util.concurrent.ConcurrentHashMap;
Lines 170-193 Link Here
170	{	171	{
171	return id;	172	return id;
172	}	173	}
173		174
174	if (knownObjects.contains(id))	175	if (knownObjects.contains(id))
175	{	176	{
176	// TODO On client-side add a check if the id is really known!	177	// TODO On client-side add a check if the id is really known!
177	return id;	178	return id;
178	}	179	}
179		180
180	knownObjects.add(id);	181	knownObjects.add(id);
181	Repository repository = sessionManager.getRepository();	182	Repository repository = sessionManager.getRepository();
182	CDOClassRef type = repository.getTypeManager().getObjectType(StoreUtil.getReader(), id);	183	CDOClassRef type = repository.getTypeManager().getObjectType(StoreUtil.getReader(), id);
183	return CDOIDImpl.create(id.getValue(), type);	184	return CDOIDImpl.create(id.getValue(), type);
		185
184	}	186	}
185		187
186	/**	188	/**
187	* TODO I can't see how recursion is controlled/limited	189	* TODO I can't see how recursion is controlled/limited
188	*/	190	*/
189	public void collectContainedRevisions(CDORevisionImpl revision, int referenceChunk,	191	public void collectContainedRevisions(CDORevisionImpl revision, int referenceChunk,
190	Map<CDOID, CDORevisionImpl> containedRevisions)	192	Set<CDOID> revisions, List<CDORevisionImpl> additionalRevisions)
191	{	193	{
192	RevisionManager revisionManager = getSessionManager().getRepository().getRevisionManager();	194	RevisionManager revisionManager = getSessionManager().getRepository().getRevisionManager();
193	CDOClassImpl cdoClass = revision.getCDOClass();	195	CDOClassImpl cdoClass = revision.getCDOClass();
Lines 201-214 Link Here
201	if (value instanceof CDOID)	203	if (value instanceof CDOID)
202	{	204	{
203	CDOID id = (CDOID)value;	205	CDOID id = (CDOID)value;
204	if (!id.isNull())	206	if (!id.isNull() && !revisions.contains(id))
205	{	207	{
206	if (containedRevisions.get(id) == null)
207	{
208	CDORevisionImpl containedRevision = revisionManager.getRevision(id, referenceChunk);	208	CDORevisionImpl containedRevision = revisionManager.getRevision(id, referenceChunk);
209	containedRevisions.put(id, containedRevision);	209	revisions.add(id);
210	collectContainedRevisions(containedRevision, referenceChunk, containedRevisions);	210	additionalRevisions.add(containedRevision);
211	}	211
		212	collectContainedRevisions(containedRevision, referenceChunk, revisions, additionalRevisions);
212	}	213	}
213	}	214	}
214	}	215	}

Removed Link Here

(-)src/org/eclipse/emf/cdo/protocol/analyzer/IFetchRuleManager.java (-31 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	* Eike Stepper - maintenance
11	**************************************************************************/
12	package org.eclipse.emf.cdo.protocol.analyzer;
13
14	import java.util.Collection;
15	import java.util.List;
16
17	import org.eclipse.emf.cdo.internal.protocol.analyzer.CDOFetchRule;
18	import org.eclipse.emf.cdo.internal.protocol.analyzer.NOOPFetchRuleManager;
19	import org.eclipse.emf.cdo.protocol.CDOID;
20
21	/**
22	* @author Eike Stepper
23	*/
24	public interface IFetchRuleManager
25	{
26	public static final IFetchRuleManager NOOP = new NOOPFetchRuleManager();
27
28	public CDOID getContext();
29
30	public List<CDOFetchRule> getFetchRules(Collection<CDOID> ids);
31	}

Lines 13-22 Link Here

(-)src/org/eclipse/emf/internal/cdo/CDOViewImpl.java (-17 / +15 lines)
13	**************************************************************************/	13	**************************************************************************/
14	package org.eclipse.emf.internal.cdo;	14	package org.eclipse.emf.internal.cdo;
15		15
		16	import java.text.MessageFormat;
		17	import java.util.ArrayList;
		18	import java.util.HashMap;
		19	import java.util.List;
		20	import java.util.Map;
		21	import java.util.Set;
		22
16	import org.eclipse.emf.cdo.CDOState;	23	import org.eclipse.emf.cdo.CDOState;
17	import org.eclipse.emf.cdo.CDOView;	24	import org.eclipse.emf.cdo.CDOView;
18	import org.eclipse.emf.cdo.CDOViewEvent;	25	import org.eclipse.emf.cdo.CDOViewEvent;
19	import org.eclipse.emf.cdo.CDOViewResourcesEvent;	26	import org.eclipse.emf.cdo.CDOViewResourcesEvent;
		27	import org.eclipse.emf.cdo.analyzer.CDOFeatureAnalyzer;
20	import org.eclipse.emf.cdo.eresource.CDOResource;	28	import org.eclipse.emf.cdo.eresource.CDOResource;
21	import org.eclipse.emf.cdo.eresource.EresourceFactory;	29	import org.eclipse.emf.cdo.eresource.EresourceFactory;
22	import org.eclipse.emf.cdo.eresource.impl.CDOResourceImpl;	30	import org.eclipse.emf.cdo.eresource.impl.CDOResourceImpl;
Lines 25-42 Link Here
25	import org.eclipse.emf.cdo.internal.protocol.revision.CDORevisionImpl;	33	import org.eclipse.emf.cdo.internal.protocol.revision.CDORevisionImpl;
26	import org.eclipse.emf.cdo.protocol.CDOID;	34	import org.eclipse.emf.cdo.protocol.CDOID;
27	import org.eclipse.emf.cdo.protocol.CDOIDTyped;	35	import org.eclipse.emf.cdo.protocol.CDOIDTyped;
28	import org.eclipse.emf.cdo.protocol.analyzer.IFeatureAnalyzer;
29	import org.eclipse.emf.cdo.protocol.model.CDOClass;	36	import org.eclipse.emf.cdo.protocol.model.CDOClass;
30	import org.eclipse.emf.cdo.protocol.model.CDOClassRef;	37	import org.eclipse.emf.cdo.protocol.model.CDOClassRef;
31	import org.eclipse.emf.cdo.protocol.revision.CDORevisionResolver;	38	import org.eclipse.emf.cdo.protocol.revision.CDORevisionResolver;
32	import org.eclipse.emf.cdo.protocol.util.TransportException;	39	import org.eclipse.emf.cdo.protocol.util.TransportException;
33	import org.eclipse.emf.cdo.util.CDOUtil;	40	import org.eclipse.emf.cdo.util.CDOUtil;
34	import org.eclipse.emf.cdo.util.ReadOnlyException;	41	import org.eclipse.emf.cdo.util.ReadOnlyException;
35
36	import org.eclipse.net4j.internal.util.om.trace.ContextTracer;
37	import org.eclipse.net4j.signal.IFailOverStrategy;
38	import org.eclipse.net4j.util.ImplementationError;
39
40	import org.eclipse.emf.common.notify.Adapter;	42	import org.eclipse.emf.common.notify.Adapter;
41	import org.eclipse.emf.common.notify.Notification;	43	import org.eclipse.emf.common.notify.Notification;
42	import org.eclipse.emf.common.notify.Notifier;	44	import org.eclipse.emf.common.notify.Notifier;
Lines 52-64 Link Here
52	import org.eclipse.emf.internal.cdo.protocol.ResourcePathRequest;	54	import org.eclipse.emf.internal.cdo.protocol.ResourcePathRequest;
53	import org.eclipse.emf.internal.cdo.util.FSMUtil;	55	import org.eclipse.emf.internal.cdo.util.FSMUtil;
54	import org.eclipse.emf.internal.cdo.util.ModelUtil;	56	import org.eclipse.emf.internal.cdo.util.ModelUtil;
55		57	import org.eclipse.net4j.internal.util.om.trace.ContextTracer;
56	import java.text.MessageFormat;	58	import org.eclipse.net4j.signal.IFailOverStrategy;
57	import java.util.ArrayList;	59	import org.eclipse.net4j.util.ImplementationError;
58	import java.util.HashMap;
59	import java.util.List;
60	import java.util.Map;
61	import java.util.Set;
62		60
63	/**	61	/**
64	* @author Eike Stepper	62	* @author Eike Stepper
Lines 78-84 Link Here
78		76
79	private int loadRevisionCollectionChunkSize = 1;	77	private int loadRevisionCollectionChunkSize = 1;
80		78
81	private IFeatureAnalyzer featureAnalyzer = IFeatureAnalyzer.NOOP;	79	private CDOFeatureAnalyzer featureAnalyzer = CDOFeatureAnalyzer.NOOP;
82		80
83	private Map<CDOID, InternalCDOObject> objects = new HashMap<CDOID, InternalCDOObject>();	81	private Map<CDOID, InternalCDOObject> objects = new HashMap<CDOID, InternalCDOObject>();
84		82
Lines 144-157 Link Here
144	this.loadRevisionCollectionChunkSize = loadRevisionCollectionChunkSize;	142	this.loadRevisionCollectionChunkSize = loadRevisionCollectionChunkSize;
145	}	143	}
146		144
147	public IFeatureAnalyzer getFeatureAnalyzer()	145	public CDOFeatureAnalyzer getFeatureAnalyzer()
148	{	146	{
149	return featureAnalyzer;	147	return featureAnalyzer;
150	}	148	}
151		149
152	public void setFeatureAnalyzer(IFeatureAnalyzer featureAnalyzer)	150	public void setFeatureAnalyzer(CDOFeatureAnalyzer featureAnalyzer)
153	{	151	{
154	this.featureAnalyzer = featureAnalyzer == null ? IFeatureAnalyzer.NOOP : featureAnalyzer;	152	this.featureAnalyzer = featureAnalyzer == null ? CDOFeatureAnalyzer.NOOP : featureAnalyzer;
155	}	153	}
156		154
157	public CDOTransactionImpl toTransaction()	155	public CDOTransactionImpl toTransaction()

Lines 10-24 Link Here

(-)src/org/eclipse/emf/internal/cdo/CDOStore.java (-11 / +9 lines)
10	**************************************************************************/	10	**************************************************************************/
11	package org.eclipse.emf.internal.cdo;	11	package org.eclipse.emf.internal.cdo;
12		12
		13	import java.text.MessageFormat;
		14	import java.util.HashSet;
		15	import java.util.Set;
		16
13	import org.eclipse.emf.cdo.internal.protocol.model.CDOFeatureImpl;	17	import org.eclipse.emf.cdo.internal.protocol.model.CDOFeatureImpl;
14	import org.eclipse.emf.cdo.internal.protocol.revision.CDORevisionImpl;	18	import org.eclipse.emf.cdo.internal.protocol.revision.CDORevisionImpl;
15	import org.eclipse.emf.cdo.internal.protocol.revision.CDORevisionImpl.MoveableList;	19	import org.eclipse.emf.cdo.internal.protocol.revision.CDORevisionImpl.MoveableList;
16	import org.eclipse.emf.cdo.protocol.CDOID;	20	import org.eclipse.emf.cdo.protocol.CDOID;
17	import org.eclipse.emf.cdo.protocol.model.CDOFeature;	21	import org.eclipse.emf.cdo.protocol.model.CDOFeature;
18	import org.eclipse.emf.cdo.protocol.revision.CDOReferenceProxy;	22	import org.eclipse.emf.cdo.protocol.revision.CDOReferenceProxy;
19
20	import org.eclipse.net4j.internal.util.om.trace.ContextTracer;
21
22	import org.eclipse.emf.ecore.EClass;	23	import org.eclipse.emf.ecore.EClass;
23	import org.eclipse.emf.ecore.EObject;	24	import org.eclipse.emf.ecore.EObject;
24	import org.eclipse.emf.ecore.EStructuralFeature;	25	import org.eclipse.emf.ecore.EStructuralFeature;
Lines 27-36 Link Here
27	import org.eclipse.emf.internal.cdo.bundle.OM;	28	import org.eclipse.emf.internal.cdo.bundle.OM;
28	import org.eclipse.emf.internal.cdo.util.FSMUtil;	29	import org.eclipse.emf.internal.cdo.util.FSMUtil;
29	import org.eclipse.emf.internal.cdo.util.ModelUtil;	30	import org.eclipse.emf.internal.cdo.util.ModelUtil;
30		31	import org.eclipse.net4j.internal.util.om.trace.ContextTracer;
31	import java.text.MessageFormat;
32	import java.util.HashSet;
33	import java.util.Set;
34		32
35	/**	33	/**
36	* @author Eike Stepper	34	* @author Eike Stepper
Lines 106-112 Link Here
106	TRACER.format("get({0}, {1}, {2})", cdoObject, cdoFeature, index);	104	TRACER.format("get({0}, {1}, {2})", cdoObject, cdoFeature, index);
107	}	105	}
108		106
109	view.getFeatureAnalyzer().preTraverseFeature(cdoObject.cdoRevision(), cdoFeature, index);	107	view.getFeatureAnalyzer().preTraverseFeature(cdoObject, cdoFeature, index);
110	CDORevisionImpl revision = getRevisionForReading(cdoObject);	108	CDORevisionImpl revision = getRevisionForReading(cdoObject);
111	Object value = get(revision, cdoFeature, index);	109	Object value = get(revision, cdoFeature, index);
112	if (cdoFeature.isReference())	110	if (cdoFeature.isReference())
Lines 116-126 Link Here
116	CDOID id = (CDOID)value;	114	CDOID id = (CDOID)value;
117	loadAhead(revision, cdoFeature, id, index);	115	loadAhead(revision, cdoFeature, id, index);
118	}	116	}
119		117
120	value = view.convertIDToObject(value);	118	value = view.convertIDToObject(value);
121	}	119	}
122		120
123	view.getFeatureAnalyzer().postTraverseFeature(cdoObject.cdoRevision(), cdoFeature, index);	121	view.getFeatureAnalyzer().postTraverseFeature(cdoObject, cdoFeature, index, value);
124	return value;	122	return value;
125	}	123	}
126		124

Lines 15-21 Link Here

(-)src/org/eclipse/emf/internal/cdo/CDORevisionManagerImpl.java (-4 / +4 lines)
15	import org.eclipse.emf.cdo.internal.protocol.revision.CDORevisionResolverImpl;	15	import org.eclipse.emf.cdo.internal.protocol.revision.CDORevisionResolverImpl;
16	import org.eclipse.emf.cdo.internal.protocol.revision.CDORevisionImpl.MoveableList;	16	import org.eclipse.emf.cdo.internal.protocol.revision.CDORevisionImpl.MoveableList;
17	import org.eclipse.emf.cdo.protocol.CDOID;	17	import org.eclipse.emf.cdo.protocol.CDOID;
18	import org.eclipse.emf.cdo.protocol.analyzer.IFetchRuleManager;	18	import org.eclipse.emf.cdo.analyzer.CDOFetchRuleManager;
19	import org.eclipse.emf.cdo.protocol.model.CDOFeature;	19	import org.eclipse.emf.cdo.protocol.model.CDOFeature;
20	import org.eclipse.emf.cdo.protocol.revision.CDOReferenceProxy;	20	import org.eclipse.emf.cdo.protocol.revision.CDOReferenceProxy;
21	import org.eclipse.emf.cdo.protocol.util.TransportException;	21	import org.eclipse.emf.cdo.protocol.util.TransportException;
Lines 39-45 Link Here
39	{	39	{
40	private CDOSessionImpl session;	40	private CDOSessionImpl session;
41		41
42	private IFetchRuleManager ruleManager = IFetchRuleManager.NOOP;	42	private CDOFetchRuleManager ruleManager = CDOFetchRuleManager.NOOP;
43		43
44	public CDORevisionManagerImpl(CDOSessionImpl session)	44	public CDORevisionManagerImpl(CDOSessionImpl session)
45	{	45	{
Lines 251-262 Link Here
251	}	251	}
252	}	252	}
253		253
254	public IFetchRuleManager getRuleManager()	254	public CDOFetchRuleManager getRuleManager()
255	{	255	{
256	return ruleManager;	256	return ruleManager;
257	}	257	}
258		258
259	public void setRuleManager(IFetchRuleManager ruleManager)	259	public void setRuleManager(CDOFetchRuleManager ruleManager)
260	{	260	{
261	this.ruleManager = ruleManager;	261	this.ruleManager = ruleManager;
262	}	262	}

Lines 10-37 Link Here

(-)src/org/eclipse/emf/internal/cdo/protocol/LoadRevisionRequest.java (-22 / +18 lines)
10	**************************************************************************/	10	**************************************************************************/
11	package org.eclipse.emf.internal.cdo.protocol;	11	package org.eclipse.emf.internal.cdo.protocol;
12		12
		13	import java.io.IOException;
		14	import java.util.ArrayList;
		15	import java.util.Collection;
		16	import java.util.Collections;
		17	import java.util.List;
		18
		19	import org.eclipse.emf.cdo.analyzer.CDOFetchRuleManager;
13	import org.eclipse.emf.cdo.internal.protocol.CDOIDImpl;	20	import org.eclipse.emf.cdo.internal.protocol.CDOIDImpl;
14	import org.eclipse.emf.cdo.internal.protocol.analyzer.CDOFetchRule;	21	import org.eclipse.emf.cdo.internal.protocol.analyzer.CDOFetchRule;
15	import org.eclipse.emf.cdo.internal.protocol.revision.CDORevisionImpl;	22	import org.eclipse.emf.cdo.internal.protocol.revision.CDORevisionImpl;
16	import org.eclipse.emf.cdo.protocol.CDOID;	23	import org.eclipse.emf.cdo.protocol.CDOID;
17	import org.eclipse.emf.cdo.protocol.CDOProtocolConstants;	24	import org.eclipse.emf.cdo.protocol.CDOProtocolConstants;
18	import org.eclipse.emf.cdo.protocol.analyzer.IFetchRuleManager;
19
20	import org.eclipse.net4j.IChannel;
21	import org.eclipse.net4j.internal.util.om.trace.ContextTracer;
22	import org.eclipse.net4j.util.io.ExtendedDataInputStream;
23	import org.eclipse.net4j.util.io.ExtendedDataOutputStream;
24
25	import org.eclipse.emf.internal.cdo.CDORevisionManagerImpl;	25	import org.eclipse.emf.internal.cdo.CDORevisionManagerImpl;
26	import org.eclipse.emf.internal.cdo.CDOSessionImpl;	26	import org.eclipse.emf.internal.cdo.CDOSessionImpl;
27	import org.eclipse.emf.internal.cdo.CDOSessionPackageManager;	27	import org.eclipse.emf.internal.cdo.CDOSessionPackageManager;
28	import org.eclipse.emf.internal.cdo.bundle.OM;	28	import org.eclipse.emf.internal.cdo.bundle.OM;
29		29	import org.eclipse.net4j.IChannel;
30	import java.io.IOException;	30	import org.eclipse.net4j.internal.util.om.trace.ContextTracer;
31	import java.util.ArrayList;	31	import org.eclipse.net4j.util.io.ExtendedDataInputStream;
32	import java.util.Collection;	32	import org.eclipse.net4j.util.io.ExtendedDataOutputStream;
33	import java.util.Collections;
34	import java.util.List;
35		33
36	/**	34	/**
37	* @author Eike Stepper	35	* @author Eike Stepper
Lines 77-100 Link Here
77	CDOIDImpl.write(out, id);	75	CDOIDImpl.write(out, id);
78	}	76	}
79		77
80	IFetchRuleManager ruleManager = getSession().getRevisionManager().getRuleManager();	78	CDOFetchRuleManager ruleManager = getSession().getRevisionManager().getRuleManager();
81	List<CDOFetchRule> fetchRules = ruleManager.getFetchRules(ids);	79	List<CDOFetchRule> fetchRules = ruleManager.getFetchRules(ids);
82	if (fetchRules == null \|\| fetchRules.size() == 0)	80	if (fetchRules == null \|\| fetchRules.size() <= 0)
83	{	81	{
84	out.writeInt(0);	82	out.writeInt(0);
85	}	83	}
86	else	84	else
87	{	85	{
		86	// At this point, fetch size is more than one.
88	int fetchSize = fetchRules.size();	87	int fetchSize = fetchRules.size();
89	out.writeInt(fetchSize);	88	out.writeInt(fetchSize);
90	if (fetchSize > 0)	89	CDOID contextID = ruleManager.getContext();
		90	CDOIDImpl.write(out, contextID);
		91	for (CDOFetchRule fetchRule : fetchRules)
91	{	92	{
92	CDOID contextID = ruleManager.getContext();	93	fetchRule.write(out);
93	CDOIDImpl.write(out, contextID);
94	for (CDOFetchRule fetchRule : fetchRules)
95	{
96	fetchRule.write(out);
97	}
98	}	94	}
99	}	95	}
100	}	96	}

Lines 13-23 Link Here

(-)META-INF/MANIFEST.MF (+2 lines)
13	org.eclipse.emf.ecore.xmi;bundle-version="[2.3.0,3.0.0)",	13	org.eclipse.emf.ecore.xmi;bundle-version="[2.3.0,3.0.0)",
14	org.eclipse.emf.cdo.protocol;bundle-version="[0.8.0,0.9.0)";visibility:=reexport	14	org.eclipse.emf.cdo.protocol;bundle-version="[0.8.0,0.9.0)";visibility:=reexport
15	Export-Package: org.eclipse.emf.cdo;version="0.8.0",	15	Export-Package: org.eclipse.emf.cdo;version="0.8.0",
		16	org.eclipse.emf.cdo.analyzer;version="0.8.0",
16	org.eclipse.emf.cdo.eresource;version="0.8.0",	17	org.eclipse.emf.cdo.eresource;version="0.8.0",
17	org.eclipse.emf.cdo.eresource.impl;version="0.8.0",	18	org.eclipse.emf.cdo.eresource.impl;version="0.8.0",
18	org.eclipse.emf.cdo.eresource.util;version="0.8.0",	19	org.eclipse.emf.cdo.eresource.util;version="0.8.0",
19	org.eclipse.emf.cdo.util;version="0.8.0",	20	org.eclipse.emf.cdo.util;version="0.8.0",
20	org.eclipse.emf.internal.cdo;version="0.8.0",	21	org.eclipse.emf.internal.cdo;version="0.8.0",
		22	org.eclipse.emf.internal.cdo.analyzer;version="0.8.0",
21	org.eclipse.emf.internal.cdo.protocol;version="0.8.0",	23	org.eclipse.emf.internal.cdo.protocol;version="0.8.0",
22	org.eclipse.emf.internal.cdo.util;version="0.8.0"	24	org.eclipse.emf.internal.cdo.util;version="0.8.0"
23	Eclipse-LazyStart: true	25	Eclipse-LazyStart: true

Added Link Here

(-)src/org/eclipse/emf/internal/cdo/analyzer/CDOFetchFeatureInfo.java (+95 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	* Eike Stepper - maintenance
11	**************************************************************************/
12	package org.eclipse.emf.internal.cdo.analyzer;
13
14	import org.eclipse.emf.cdo.internal.protocol.analyzer.CDOFetchRule;
15	import org.eclipse.emf.internal.cdo.bundle.OM;
16	import org.eclipse.net4j.internal.util.om.trace.ContextTracer;
17
18	/**
19	* @author Eike Stepper
20	*/
21	public class CDOFetchFeatureInfo
22	{
23	private static final ContextTracer TRACER = new ContextTracer(OM.DEBUG, CDOFetchFeatureInfo.class);
24
25	private long timeBeforeUsed;
26
27	private long latencyTime;
28
29	private boolean active;
30
31	public CDOFetchFeatureInfo()
32	{
33	active = false;
34	latencyTime = -1;
35	}
36
37	public boolean isActive()
38	{
39	return active;
40	}
41	public void setActive(boolean isActive)
42	{
43	active = isActive;
44	}
45
46	public long getTimeBeforeUsed()
47	{
48	return timeBeforeUsed;
49	}
50
51	public void setTimeBeforeUsed(long timeBeforeUsed)
52	{
53	this.timeBeforeUsed = timeBeforeUsed;
54	}
55
56	public long getLatencyTime()
57	{
58	return latencyTime;
59	}
60	/**
61	*
62	* @param latencyTime
63	*/
64	public void updateLatencyTime(long latencyTime)
65	{
66	if (this.latencyTime == -1)
67	this.latencyTime = latencyTime;
68	else
69	this.latencyTime = (latencyTime + this.latencyTime) / 2;
70	}
71	/**
72	*
73	* @param latencyTime
74	*/
75	public void setLatencyTime(long latencyTime)
76	{
77	this.latencyTime = latencyTime;
78	}
79	/**
80	*
81	* @param elapseTimeBeforeLastRequest
82	*/
83	public void updateTimeInfo(long elapseTimeBeforeLastRequest)
84	{
85	if (this.getTimeBeforeUsed() != 0)
86	{
87	this.setTimeBeforeUsed((this.getTimeBeforeUsed() + elapseTimeBeforeLastRequest) / 2);
88	}
89	else
90	{
91	this.setTimeBeforeUsed(elapseTimeBeforeLastRequest);
92	}
93	}
94
95	}

Added Link Here

(-)src/org/eclipse/emf/cdo/analyzer/CDOFetchRuleManager.java (+31 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	* Eike Stepper - maintenance
11	**************************************************************************/
12	package org.eclipse.emf.cdo.analyzer;
13
14	import java.util.Collection;
15	import java.util.List;
16
17	import org.eclipse.emf.cdo.internal.protocol.analyzer.CDOFetchRule;
18	import org.eclipse.emf.cdo.protocol.CDOID;
19	import org.eclipse.emf.internal.cdo.analyzer.NOOPFetchRuleManager;
20
21	/**
22	* @author Eike Stepper
23	*/
24	public interface CDOFetchRuleManager
25	{
26	public static final CDOFetchRuleManager NOOP = new NOOPFetchRuleManager();
27
28	public CDOID getContext();
29
30	public List<CDOFetchRule> getFetchRules(Collection<CDOID> ids);
31	}