ServiceBase.java

package fr.lteconsulting.hexa.client.comm;

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

import com.google.gwt.core.client.JavaScriptObject;
import com.google.gwt.core.client.JsArray;
import com.google.gwt.core.client.JsArrayString;
import fr.lteconsulting.hexa.client.comm.callparams.BooleanMarshall;
import fr.lteconsulting.hexa.client.comm.callparams.DoubleMarshall;
import fr.lteconsulting.hexa.client.comm.callparams.HexaDateMarshall;
import fr.lteconsulting.hexa.client.comm.callparams.HexaDateTimeMarshall;
import fr.lteconsulting.hexa.client.comm.callparams.HexaTimeMarshall;
import fr.lteconsulting.hexa.client.comm.callparams.ITableMarshall;
import fr.lteconsulting.hexa.client.comm.callparams.IntMarshall;
import fr.lteconsulting.hexa.client.comm.callparams.JSOMarshall;
import fr.lteconsulting.hexa.client.comm.callparams.StringMarshall;

public class ServiceBase
{
	protected AcceptsRPCRequests srv = null;
	protected String interfaceChecksum = null;

	// marshalls
	protected static BooleanMarshall booleanMarshall = new BooleanMarshall();
	protected static IntMarshall intMarshall = new IntMarshall();
	protected static StringMarshall stringMarshall = new StringMarshall();
	protected static JSOMarshall jsoMarshall = new JSOMarshall();
	protected static HexaDateTimeMarshall dateTimeMarshall = new HexaDateTimeMarshall();
	protected static HexaDateMarshall dateMarshall = new HexaDateMarshall();
	protected static HexaTimeMarshall timeMarshall = new HexaTimeMarshall();
	protected static DoubleMarshall doubleMarshall = new DoubleMarshall();
	protected static ITableMarshall itableMarshall = new ITableMarshall();

	protected void setConfig( AcceptsRPCRequests srv, String interfaceChecksum )
	{
		this.srv = srv;
		this.interfaceChecksum = interfaceChecksum;
	}

	public String getInterfaceChecksum()
	{
		return interfaceChecksum;
	}

	public AcceptsRPCRequests getCachedServerComm()
	{
		return srv;
	}

	public abstract class Proxy<T>
	{
		abstract public T create( GenericJSO jso );
	}

	class ArrayJSOProxy<T> extends SimplifiedList<T>
	{
		T[] internal;

		Proxy<T> proxy;

		GenericJSO fields;
		int nbFields;

		JsArray<GenericJSO> rows;
		int lenght;

		@SuppressWarnings( "unchecked" )
		public ArrayJSOProxy( GenericJSO jso, Proxy<T> proxy )
		{
			this.proxy = proxy;

			fields = jso.getGenericJSO( "fields" );
			nbFields = fields.length();

			rows = jso.getArray( "rows" );
			lenght = rows.length();

			if( lenght > 0 )
				internal = (T[]) new Object[lenght];
		}

		private native void setJso( JavaScriptObject obj, JsArrayString fields, JavaScriptObject source )
		/*-{
			for( i=0; i<fields.length; i++ )
				obj[fields[i]] = source[i];
		}-*/;

		@Override
		public T get( int index )
		{
			T item = internal[index];
			if( item != null )
				return item;

			GenericJSO row = rows.get( index );

			JavaScriptObject fake = JavaScriptObject.createObject().cast();
			for( int f = 0; f < nbFields; f++ )
				setJso( fake, (JsArrayString) fields.cast(), (JavaScriptObject) row.cast() );

			item = proxy.create( (GenericJSO) fake.cast() );
			internal[index] = item;

			return item;
		}

		@Override
		public boolean isEmpty()
		{
			return lenght == 0;
		}

		@Override
		public Iterator<T> iterator()
		{
			return new It();
		}

		@Override
		public ListIterator<T> listIterator()
		{
			assert false;
			return null;
		}

		@Override
		public ListIterator<T> listIterator( int index )
		{
			assert false;
			return null;
		}

		@Override
		public int size()
		{
			return lenght;
		}

		@Override
		public List<T> subList( int fromIndex, int toIndex )
		{
			assert false;
			return null;
		}

		class It implements Iterator<T>
		{
			int curIndex = 0;

			@Override
			public boolean hasNext()
			{
				return curIndex < lenght;
			}

			@Override
			public T next()
			{
				return get( curIndex++ );
			}

			@Override
			public void remove()
			{
				assert false;
			}

		}
	}

	protected boolean isOptimizedArray( GenericJSO jso )
	{
		try
		{
			String magic = jso.getString( "magic" );
			if( magic != null && magic.equals( "ar2ra" ) )
				return true;
		}
		catch( Exception e )
		{
			return false;
		}

		return false;
	}

	protected <T> List<T> deserializeArray( JsArray<GenericJSO> jsoss, Proxy<T> proxy )
	{
		if( isOptimizedArray( (GenericJSO) jsoss.cast() ) )
		{
			GenericJSO jso = (GenericJSO) jsoss.cast();

			return new ArrayJSOProxy<T>( jso, proxy );

			/*
			 * GenericJSO fields = jso.getGenericJSO( "fields" ); int nbFields =
			 * fields.length();
			 * 
			 * ArrayList<T> result = new ArrayList<T>();
			 * 
			 * JsArray<GenericJSO> rows = jso.getArray( "rows" ); int lenght =
			 * rows.length(); for( int i=0; i<lenght; i++ ) { GenericJSO row =
			 * rows.get( i );
			 * 
			 * // make up a jso ok for the proxy // it is an object with values
			 * indexed by field names GenericJSO item =
			 * JavaScriptObject.createObject().cast();
			 * 
			 * for( int f=0; f<nbFields; f++ ) //item.setObject(
			 * fields.getStringByIdx( f ), row.getGenericJSOByIdx( f ) ); set(
			 * (JavaScriptObject) item.cast(), (JsArrayString) fields.cast(),
			 * (JavaScriptObject) row.cast() );
			 * 
			 * result.add( proxy.create( item ) ); }
			 * 
			 * return result;
			 */
		}
		else
		{
			ArrayList<T> list = new ArrayList<T>();
			int length = jsoss.length();
			for( int i = 0; i < length; i++ )
				list.add( proxy.create( jsoss.get( i ) ) );
			return list;
		}
	}

	private native void set( JavaScriptObject obj, JsArrayString fields, JavaScriptObject source )
	/*-{
		for( i=0; i<fields.length; i++ )
			obj[fields[i]] = source[i];
	}-*/;
}

abstract class SimplifiedList<T> implements List<T>
{
	@Override
	public boolean add( T e )
	{
		assert false;
		return false;
	}

	@Override
	public void add( int index, T element )
	{
		assert false;
	}

	@Override
	public boolean addAll( Collection<? extends T> c )
	{
		assert false;
		return false;
	}

	@Override
	public boolean addAll( int index, Collection<? extends T> c )
	{
		assert false;
		return false;
	}

	@Override
	public void clear()
	{
		assert false;
	}

	@Override
	public boolean contains( Object o )
	{
		assert false;
		return false;
	}

	@Override
	public boolean containsAll( Collection<?> c )
	{
		assert false;
		return false;
	}

	@Override
	public int indexOf( Object o )
	{
		assert false;
		return 0;
	}

	@Override
	public int lastIndexOf( Object o )
	{
		assert false;
		return 0;
	}

	@Override
	public boolean remove( Object o )
	{
		assert false;
		return false;
	}

	@Override
	public T remove( int index )
	{
		assert false;
		return null;
	}

	@Override
	public boolean removeAll( Collection<?> c )
	{
		assert false;
		return false;
	}

	@Override
	public boolean retainAll( Collection<?> c )
	{
		assert false;
		return false;
	}

	@Override
	public T set( int index, T element )
	{
		assert false;
		return null;
	}

	@Override
	public Object[] toArray()
	{
		assert false;
		return null;
	}

	@Override
	public <U> U[] toArray( U[] a )
	{
		assert false;
		return null;
	}
}