user/src/com/google/gwt/requestfactory/server/RequestState.java - gwt - Git at Google

 /*
  * Copyright 2010 Google Inc.
  *
  * Licensed under the Apache License, Version 2.0 (the "License"); you may not
  * use this file except in compliance with the License. You may obtain a copy of
  * the License at
  *
  * http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
  * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
  * License for the specific language governing permissions and limitations under
  * the License.
  */
 package com.google.gwt.requestfactory.server;

 import com.google.gwt.autobean.server.AutoBeanFactoryMagic;
 import com.google.gwt.autobean.shared.AutoBean;
 import com.google.gwt.autobean.shared.AutoBeanCodex;
 import com.google.gwt.autobean.shared.Splittable;
 import com.google.gwt.autobean.shared.ValueCodex;
 import com.google.gwt.autobean.shared.impl.StringQuoter;
 import com.google.gwt.requestfactory.server.SimpleRequestProcessor.IdToEntityMap;
 import com.google.gwt.requestfactory.shared.BaseProxy;
 import com.google.gwt.requestfactory.shared.EntityProxy;
 import com.google.gwt.requestfactory.shared.ValueProxy;
 import com.google.gwt.requestfactory.shared.impl.Constants;
 import com.google.gwt.requestfactory.shared.impl.EntityCodex;
 import com.google.gwt.requestfactory.shared.impl.IdFactory;
 import com.google.gwt.requestfactory.shared.impl.MessageFactoryHolder;
 import com.google.gwt.requestfactory.shared.impl.SimpleProxyId;
 import com.google.gwt.requestfactory.shared.messages.IdMessage;
 import com.google.gwt.requestfactory.shared.messages.IdMessage.Strength;

 import java.util.ArrayList;
 import java.util.Collections;
 import java.util.IdentityHashMap;
 import java.util.Iterator;
 import java.util.List;
 import java.util.Map;

 /**
  * Encapsulates all state relating to the processing of a single request so that
  * the SimpleRequestProcessor can be stateless.
  */
 class RequestState implements EntityCodex.EntitySource {
   final IdToEntityMap beans = new IdToEntityMap();
   private final Map<Object, SimpleProxyId<?>> domainObjectsToId;
   private final IdFactory idFactory;
   private final ServiceLayer service;
   private final Resolver resolver;

   public RequestState(RequestState parent) {
     idFactory = parent.idFactory;
     domainObjectsToId = parent.domainObjectsToId;
     service = parent.service;
     resolver = new Resolver(this);
   }

   public RequestState(final ServiceLayer service) {
     this.service = service;
     idFactory = new IdFactory() {
       @Override
       public boolean isEntityType(Class<?> clazz) {
         return EntityProxy.class.isAssignableFrom(clazz);
       }

       @Override
       public boolean isValueType(Class<?> clazz) {
         return ValueProxy.class.isAssignableFrom(clazz);
       }

       @Override
       @SuppressWarnings("unchecked")
       protected <P extends BaseProxy> Class<P> getTypeFromToken(String typeToken) {
         return (Class<P>) service.resolveClass(typeToken);
       }

       @Override
       protected String getTypeToken(Class<? extends BaseProxy> clazz) {
         return service.resolveTypeToken(clazz);
       }
     };
     domainObjectsToId = new IdentityHashMap<Object, SimpleProxyId<?>>();
     resolver = new Resolver(this);
   }

   /**
    * Turn a domain value into a wire format message.
    */
   public Splittable flatten(Object domainValue) {
     Splittable flatValue;
     if (ValueCodex.canDecode(domainValue.getClass())) {
       flatValue = ValueCodex.encode(domainValue);
     } else {
       flatValue = new SimpleRequestProcessor(service).createOobMessage(Collections.singletonList(domainValue));
     }
     return flatValue;
   }

   /**
    * Get or create a BaseProxy AutoBean for the given id.
    */
   public <Q extends BaseProxy> AutoBean<Q> getBeanForPayload(
       SimpleProxyId<Q> id, Object domainObject) {
     @SuppressWarnings("unchecked")
     AutoBean<Q> toReturn = (AutoBean<Q>) beans.get(id);
     if (toReturn == null) {
       toReturn = createProxyBean(id, domainObject);
     }
     return toReturn;
   }

   /**
    * EntityCodex support.
    */
   public <Q extends BaseProxy> AutoBean<Q> getBeanForPayload(
       Splittable serializedProxyId) {
     IdMessage idMessage = AutoBeanCodex.decode(MessageFactoryHolder.FACTORY,
         IdMessage.class, serializedProxyId).as();
     @SuppressWarnings("unchecked")
     AutoBean<Q> toReturn = (AutoBean<Q>) getBeansForPayload(
         Collections.singletonList(idMessage)).get(0);
     return toReturn;
   }

   /**
    * Get or create BaseProxy AutoBeans for a list of id-bearing messages.
    */
   public List<AutoBean<? extends BaseProxy>> getBeansForPayload(
       List<? extends IdMessage> idMessages) {
     List<SimpleProxyId<?>> ids = new ArrayList<SimpleProxyId<?>>(
         idMessages.size());
     for (IdMessage idMessage : idMessages) {
       SimpleProxyId<?> id;
       if (Strength.SYNTHETIC.equals(idMessage.getStrength())) {
         Class<? extends BaseProxy> clazz = service.resolveClass(idMessage.getTypeToken());
         id = idFactory.allocateSyntheticId(clazz, idMessage.getSyntheticId());
       } else {
         String decodedId = idMessage.getServerId() == null ? null
             : SimpleRequestProcessor.fromBase64(idMessage.getServerId());
         id = idFactory.getId(idMessage.getTypeToken(), decodedId,
             idMessage.getClientId());
       }
       ids.add(id);
     }
     return getBeansForIds(ids);
   }

   public IdFactory getIdFactory() {
     return idFactory;
   }

   public Resolver getResolver() {
     return resolver;
   }

   /**
    * EntityCodex support. This method is identical to
    * {@link IdFactory#getHistoryToken(SimpleProxyId)} except that it
    * base64-encodes the server ids.
    * <p>
    * XXX: Merge this with AbstsractRequestContext's implementation
    */
   public Splittable getSerializedProxyId(SimpleProxyId<?> stableId) {
     AutoBean<IdMessage> bean = MessageFactoryHolder.FACTORY.id();
     IdMessage ref = bean.as();
     ref.setTypeToken(service.resolveTypeToken(stableId.getProxyClass()));
     if (stableId.isSynthetic()) {
       ref.setStrength(Strength.SYNTHETIC);
       ref.setSyntheticId(stableId.getSyntheticId());
     } else if (stableId.isEphemeral()) {
       ref.setStrength(Strength.EPHEMERAL);
       ref.setClientId(stableId.getClientId());
     } else {
       ref.setServerId(SimpleRequestProcessor.toBase64(stableId.getServerId()));
     }
     return AutoBeanCodex.encode(bean);
   }

   public ServiceLayer getServiceLayer() {
     return service;
   }

   /**
    * If the given domain object has been previously associated with an id,
    * return it
    */
   public SimpleProxyId<?> getStableId(Object domain) {
     return domainObjectsToId.get(domain);
   }

   /**
    * EntityCodex support.
    */
   public boolean isEntityType(Class<?> clazz) {
     return idFactory.isEntityType(clazz);
   }

   /**
    * EntityCodex support.
    */
   public boolean isValueType(Class<?> clazz) {
     return idFactory.isValueType(clazz);
   }

   /**
    * Creates an AutoBean for the given id, tracking a domain object.
    */
   private <Q extends BaseProxy> AutoBean<Q> createProxyBean(
       SimpleProxyId<Q> id, Object domainObject) {
     AutoBean<Q> toReturn = AutoBeanFactoryMagic.createBean(id.getProxyClass(),
         SimpleRequestProcessor.CONFIGURATION);
     toReturn.setTag(Constants.STABLE_ID, id);
     toReturn.setTag(Constants.DOMAIN_OBJECT, domainObject);
     beans.put(id, toReturn);
     return toReturn;
   }

   /**
    * Returns the AutoBeans corresponding to the given ids, or creates them if
    * they do not yet exist.
    */
   private List<AutoBean<? extends BaseProxy>> getBeansForIds(
       List<SimpleProxyId<?>> ids) {
     List<Class<?>> domainClasses = new ArrayList<Class<?>>(ids.size());
     List<Object> domainIds = new ArrayList<Object>(ids.size());
     List<SimpleProxyId<?>> idsToLoad = new ArrayList<SimpleProxyId<?>>();

     /*
      * Create proxies for ephemeral or synthetic ids that we haven't seen. Queue
      * up the domain ids for entities that need to be loaded.
      */
     for (SimpleProxyId<?> id : ids) {
       Class<?> domainClass = service.resolveDomainClass(id.getProxyClass());
       if (beans.containsKey(id)) {
         // Already have a proxy for this id, no-op
       } else if (id.isEphemeral() || id.isSynthetic()) {
         // Create a new domain object for the short-lived id
         Object domain = service.createDomainObject(domainClass);
         if (domain == null) {
           throw new UnexpectedException("Could not create instance of "
               + domainClass.getCanonicalName(), null);
         }
         AutoBean<? extends BaseProxy> bean = createProxyBean(id, domain);
         beans.put(id, bean);
         domainObjectsToId.put(domain, id);
       } else {
         // Decode the domain parameter
         Splittable split = StringQuoter.split(id.getServerId());
         Class<?> param = service.getIdType(domainClass);
         Object domainParam;
         if (ValueCodex.canDecode(param)) {
           domainParam = ValueCodex.decode(param, split);
         } else {
           domainParam = new SimpleRequestProcessor(service).decodeOobMessage(
               param, split).get(0);
         }

         // Enqueue
         domainClasses.add(service.resolveDomainClass(id.getProxyClass()));
         domainIds.add(domainParam);
         idsToLoad.add(id);
       }
     }

     // Actually load the data
     if (!domainClasses.isEmpty()) {
       assert domainClasses.size() == domainIds.size()
           && domainClasses.size() == idsToLoad.size();
       List<Object> loaded = service.loadDomainObjects(domainClasses, domainIds);
       if (idsToLoad.size() != loaded.size()) {
         throw new UnexpectedException("Expected " + idsToLoad.size()
             + " objects to be loaded, got " + loaded.size(), null);
       }

       Iterator<Object> itLoaded = loaded.iterator();
       for (SimpleProxyId<?> id : idsToLoad) {
         Object domain = itLoaded.next();
         domainObjectsToId.put(domain, id);
         AutoBean<? extends BaseProxy> bean = createProxyBean(id, domain);
         beans.put(id, bean);
       }
     }

     // Construct the return value
     List<AutoBean<? extends BaseProxy>> toReturn = new ArrayList<AutoBean<? extends BaseProxy>>(
         ids.size());
     for (SimpleProxyId<?> id : ids) {
       toReturn.add(beans.get(id));
     }
     return toReturn;
   }
 }
	/*
	* Copyright 2010 Google Inc.
	*
	* Licensed under the Apache License, Version 2.0 (the "License"); you may not
	* use this file except in compliance with the License. You may obtain a copy of
	* the License at
	*
	* http://www.apache.org/licenses/LICENSE-2.0
	*
	* Unless required by applicable law or agreed to in writing, software
	* distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
	* WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
	* License for the specific language governing permissions and limitations under
	* the License.
	*/
	package com.google.gwt.requestfactory.server;

	import com.google.gwt.autobean.server.AutoBeanFactoryMagic;
	import com.google.gwt.autobean.shared.AutoBean;
	import com.google.gwt.autobean.shared.AutoBeanCodex;
	import com.google.gwt.autobean.shared.Splittable;
	import com.google.gwt.autobean.shared.ValueCodex;
	import com.google.gwt.autobean.shared.impl.StringQuoter;
	import com.google.gwt.requestfactory.server.SimpleRequestProcessor.IdToEntityMap;
	import com.google.gwt.requestfactory.shared.BaseProxy;
	import com.google.gwt.requestfactory.shared.EntityProxy;
	import com.google.gwt.requestfactory.shared.ValueProxy;
	import com.google.gwt.requestfactory.shared.impl.Constants;
	import com.google.gwt.requestfactory.shared.impl.EntityCodex;
	import com.google.gwt.requestfactory.shared.impl.IdFactory;
	import com.google.gwt.requestfactory.shared.impl.MessageFactoryHolder;
	import com.google.gwt.requestfactory.shared.impl.SimpleProxyId;
	import com.google.gwt.requestfactory.shared.messages.IdMessage;
	import com.google.gwt.requestfactory.shared.messages.IdMessage.Strength;

	import java.util.ArrayList;
	import java.util.Collections;
	import java.util.IdentityHashMap;
	import java.util.Iterator;
	import java.util.List;
	import java.util.Map;

	/**
	* Encapsulates all state relating to the processing of a single request so that
	* the SimpleRequestProcessor can be stateless.
	*/
	class RequestState implements EntityCodex.EntitySource {
	final IdToEntityMap beans = new IdToEntityMap();
	private final Map<Object, SimpleProxyId<?>> domainObjectsToId;
	private final IdFactory idFactory;
	private final ServiceLayer service;
	private final Resolver resolver;

	public RequestState(RequestState parent) {
	idFactory = parent.idFactory;
	domainObjectsToId = parent.domainObjectsToId;
	service = parent.service;
	resolver = new Resolver(this);
	}

	public RequestState(final ServiceLayer service) {
	this.service = service;
	idFactory = new IdFactory() {
	@Override
	public boolean isEntityType(Class<?> clazz) {
	return EntityProxy.class.isAssignableFrom(clazz);
	}

	@Override
	public boolean isValueType(Class<?> clazz) {
	return ValueProxy.class.isAssignableFrom(clazz);
	}

	@Override
	@SuppressWarnings("unchecked")
	protected <P extends BaseProxy> Class<P> getTypeFromToken(String typeToken) {
	return (Class<P>) service.resolveClass(typeToken);
	}

	@Override
	protected String getTypeToken(Class<? extends BaseProxy> clazz) {
	return service.resolveTypeToken(clazz);
	}
	};
	domainObjectsToId = new IdentityHashMap<Object, SimpleProxyId<?>>();
	resolver = new Resolver(this);
	}

	/**
	* Turn a domain value into a wire format message.
	*/
	public Splittable flatten(Object domainValue) {
	Splittable flatValue;
	if (ValueCodex.canDecode(domainValue.getClass())) {
	flatValue = ValueCodex.encode(domainValue);
	} else {
	flatValue = new SimpleRequestProcessor(service).createOobMessage(Collections.singletonList(domainValue));
	}
	return flatValue;
	}

	/**
	* Get or create a BaseProxy AutoBean for the given id.
	*/
	public <Q extends BaseProxy> AutoBean<Q> getBeanForPayload(
	SimpleProxyId<Q> id, Object domainObject) {
	@SuppressWarnings("unchecked")
	AutoBean<Q> toReturn = (AutoBean<Q>) beans.get(id);
	if (toReturn == null) {
	toReturn = createProxyBean(id, domainObject);
	}
	return toReturn;
	}

	/**
	* EntityCodex support.
	*/
	public <Q extends BaseProxy> AutoBean<Q> getBeanForPayload(
	Splittable serializedProxyId) {
	IdMessage idMessage = AutoBeanCodex.decode(MessageFactoryHolder.FACTORY,
	IdMessage.class, serializedProxyId).as();
	@SuppressWarnings("unchecked")
	AutoBean<Q> toReturn = (AutoBean<Q>) getBeansForPayload(
	Collections.singletonList(idMessage)).get(0);
	return toReturn;
	}

	/**
	* Get or create BaseProxy AutoBeans for a list of id-bearing messages.
	*/
	public List<AutoBean<? extends BaseProxy>> getBeansForPayload(
	List<? extends IdMessage> idMessages) {
	List<SimpleProxyId<?>> ids = new ArrayList<SimpleProxyId<?>>(
	idMessages.size());
	for (IdMessage idMessage : idMessages) {
	SimpleProxyId<?> id;
	if (Strength.SYNTHETIC.equals(idMessage.getStrength())) {
	Class<? extends BaseProxy> clazz = service.resolveClass(idMessage.getTypeToken());
	id = idFactory.allocateSyntheticId(clazz, idMessage.getSyntheticId());
	} else {
	String decodedId = idMessage.getServerId() == null ? null
	: SimpleRequestProcessor.fromBase64(idMessage.getServerId());
	id = idFactory.getId(idMessage.getTypeToken(), decodedId,
	idMessage.getClientId());
	}
	ids.add(id);
	}
	return getBeansForIds(ids);
	}

	public IdFactory getIdFactory() {
	return idFactory;
	}

	public Resolver getResolver() {
	return resolver;
	}

	/**
	* EntityCodex support. This method is identical to
	* {@link IdFactory#getHistoryToken(SimpleProxyId)} except that it
	* base64-encodes the server ids.
	* <p>
	* XXX: Merge this with AbstsractRequestContext's implementation
	*/
	public Splittable getSerializedProxyId(SimpleProxyId<?> stableId) {
	AutoBean<IdMessage> bean = MessageFactoryHolder.FACTORY.id();
	IdMessage ref = bean.as();
	ref.setTypeToken(service.resolveTypeToken(stableId.getProxyClass()));
	if (stableId.isSynthetic()) {
	ref.setStrength(Strength.SYNTHETIC);
	ref.setSyntheticId(stableId.getSyntheticId());
	} else if (stableId.isEphemeral()) {
	ref.setStrength(Strength.EPHEMERAL);
	ref.setClientId(stableId.getClientId());
	} else {
	ref.setServerId(SimpleRequestProcessor.toBase64(stableId.getServerId()));
	}
	return AutoBeanCodex.encode(bean);
	}

	public ServiceLayer getServiceLayer() {
	return service;
	}

	/**
	* If the given domain object has been previously associated with an id,
	* return it
	*/
	public SimpleProxyId<?> getStableId(Object domain) {
	return domainObjectsToId.get(domain);
	}

	/**
	* EntityCodex support.
	*/
	public boolean isEntityType(Class<?> clazz) {
	return idFactory.isEntityType(clazz);
	}

	/**
	* EntityCodex support.
	*/
	public boolean isValueType(Class<?> clazz) {
	return idFactory.isValueType(clazz);
	}

	/**
	* Creates an AutoBean for the given id, tracking a domain object.
	*/
	private <Q extends BaseProxy> AutoBean<Q> createProxyBean(
	SimpleProxyId<Q> id, Object domainObject) {
	AutoBean<Q> toReturn = AutoBeanFactoryMagic.createBean(id.getProxyClass(),
	SimpleRequestProcessor.CONFIGURATION);
	toReturn.setTag(Constants.STABLE_ID, id);
	toReturn.setTag(Constants.DOMAIN_OBJECT, domainObject);
	beans.put(id, toReturn);
	return toReturn;
	}

	/**
	* Returns the AutoBeans corresponding to the given ids, or creates them if
	* they do not yet exist.
	*/
	private List<AutoBean<? extends BaseProxy>> getBeansForIds(
	List<SimpleProxyId<?>> ids) {
	List<Class<?>> domainClasses = new ArrayList<Class<?>>(ids.size());
	List<Object> domainIds = new ArrayList<Object>(ids.size());
	List<SimpleProxyId<?>> idsToLoad = new ArrayList<SimpleProxyId<?>>();

	/*
	* Create proxies for ephemeral or synthetic ids that we haven't seen. Queue
	* up the domain ids for entities that need to be loaded.
	*/
	for (SimpleProxyId<?> id : ids) {
	Class<?> domainClass = service.resolveDomainClass(id.getProxyClass());
	if (beans.containsKey(id)) {
	// Already have a proxy for this id, no-op
	} else if (id.isEphemeral() \|\| id.isSynthetic()) {
	// Create a new domain object for the short-lived id
	Object domain = service.createDomainObject(domainClass);
	if (domain == null) {
	throw new UnexpectedException("Could not create instance of "
	+ domainClass.getCanonicalName(), null);
	}
	AutoBean<? extends BaseProxy> bean = createProxyBean(id, domain);
	beans.put(id, bean);
	domainObjectsToId.put(domain, id);
	} else {
	// Decode the domain parameter
	Splittable split = StringQuoter.split(id.getServerId());
	Class<?> param = service.getIdType(domainClass);
	Object domainParam;
	if (ValueCodex.canDecode(param)) {
	domainParam = ValueCodex.decode(param, split);
	} else {
	domainParam = new SimpleRequestProcessor(service).decodeOobMessage(
	param, split).get(0);
	}

	// Enqueue
	domainClasses.add(service.resolveDomainClass(id.getProxyClass()));
	domainIds.add(domainParam);
	idsToLoad.add(id);
	}
	}

	// Actually load the data
	if (!domainClasses.isEmpty()) {
	assert domainClasses.size() == domainIds.size()
	&& domainClasses.size() == idsToLoad.size();
	List<Object> loaded = service.loadDomainObjects(domainClasses, domainIds);
	if (idsToLoad.size() != loaded.size()) {
	throw new UnexpectedException("Expected " + idsToLoad.size()
	+ " objects to be loaded, got " + loaded.size(), null);
	}

	Iterator<Object> itLoaded = loaded.iterator();
	for (SimpleProxyId<?> id : idsToLoad) {
	Object domain = itLoaded.next();
	domainObjectsToId.put(domain, id);
	AutoBean<? extends BaseProxy> bean = createProxyBean(id, domain);
	beans.put(id, bean);
	}
	}

	// Construct the return value
	List<AutoBean<? extends BaseProxy>> toReturn = new ArrayList<AutoBean<? extends BaseProxy>>(
	ids.size());
	for (SimpleProxyId<?> id : ids) {
	toReturn.add(beans.get(id));
	}
	return toReturn;
	}
	}