Demo1Weaved demo = new Demo1Weaved(args);
		demo.runDemo();
	}

	/**
	 * Runs the actual demo with the given store implementation.
	 */
	public void runDemo() {
		try {
			
			Account account;
			// sets foo as a root object, foo and any objects
			Person storedPerson = (Person) store.getRoot("client");

			if (storedPerson == null) {
				System.out.println("person was null - storing new");
				// creates a model class - live until it goes out of scope.
				Person person = new Person("Fred");

				account = new SavingsAccount();
				person.setAccount(account);
				store.setRoot("client", person);
			} else {
				System.out.println("Person was valid");
				System.out.println("Adding " + POUND + "100");
				account = storedPerson.getAccount();
				account.deposit(100.0);
			}
			
			System.out.println("CurrentBalance=" + POUND + account.getBalance());
		} finally {

    	return ((SizeResponse) jemmOIF.processRequest(new SizeRequest())).getSize();
    }

    public Object[] toArray() {        
    	return ((ToArrayResponse) jemmOIF.processRequest(new ToArrayRequest())).getArray();
    }

    @SuppressWarnings("unchecked")
	public <T> T[] toArray(T[] a) {    	
    	Object[] curValues = toArray();
    	int size = curValues.length;
        if (a.length < size) { 
        	// target array is not large enough
            // Make a new array of a's runtime type, but my contents:
            return (T[]) Arrays.copyOf(curValues, size, a.getClass());
        }
        
        System.arraycopy(curValues, 0, a, 0, size);
        if (a.length > size)
            a[size] = null;
        return a;
    }
}

		int index = values.lastIndexOf(toFind);
		if(index != -1)
			return new ListIndexOfResponse(index);

		int count = 0;
		for (StoredValue value : values)
			if(value.isPotentialMatch(toFind))
				count++;
			
		if(count == 0)
			return new ListIndexOfResponse(-1);
		
		int itemIndex = 0;
		int[] possibleIndexes = new int[count];
		Object[] possibleValues = new Object[count];
		for(int i=values.size()-1; i>=0; i--) {

    public boolean addAll(int index, Collection<? extends K> c) {
    	List<StoredValue> list = new ArrayList<StoredValue>(c.size());
    	for (Object uValue : c)
    		list.add(new StoredValue(uValue));
    	
    	StoredValue[] values = list.toArray(new StoredValue[0]);
    	
        return ((ListAddAllResponse) jemmOIF.processRequest(new ListAddAllRequest(index,values))).isModified();

	}

	@Override
	public TypeResponse<?> processRequest(ClientId clientId, ClassId classId,
			ID id, TypeRequest<?> request) {

		if(request instanceof ClearRequest) {
			clear(clientId, id);
			return new VoidResponse();
		} else if(request instanceof SizeRequest) {
			return new SizeResponse(size(clientId,id));
		} else if(request instanceof ToArrayRequest) {

	}
	
	@Override
	public void entityEntered(MethodEvent e) {
		stackTracer.enterMethod(e.getOrigin(), new Descriptor(e.getDescriptor()));
	}

	@Override
	public void entityExited(MethodEvent e) {
		stackTracer.exitMethod(e.getOrigin(), new Descriptor(e.getDescriptor()));
	}

			if(e.getShadowData().isFieldInitialised(f.getDeclaringClass(), FieldType.OBJECT, f.getName())) {
				FieldKey fKey = new FieldKey(f.getDeclaringClass(),f.getName());
				FieldAccessor accessor = accessorFactory.create(fKey);
				result.put(fKey,(JEMMObject)accessor.getField(fKey));

		return new StoredMapObject(id,classId);
	}

	@Override
	public TypeResponse<?> processRequest(ClientId clientId, ClassId classId,
			ID id, TypeRequest<?> request) {

		if(request instanceof ClearRequest) {
			clear(clientId, id);
			return new VoidResponse();
		} else if(request instanceof MapGetRequest) {

	}

	@Override
	public void beginLock(LockEvent e) {
		lockTracer.beginLock(e.getOrigin(),e.getLock());
	}

	@Override
	public void endLock(LockEvent e) {
		lockTracer.endLock(e.getOrigin(),e.getLock());
	}

		for(int i=values.size()-1; i>=0; i--) {
			StoredValue value = values.get(i);
			if(value.isPotentialMatch(toFind)) {
				possibleIndexes[itemIndex] = i;
				possibleValues[itemIndex] = value.getValue();
				itemIndex++;
			}
		}
				
		return new ListIndexOfResponse(possibleIndexes,possibleValues);
	}

	/**
	 * Remote the object at the given index, moving subsequent values up. 
	 * @param index The index of the item to remove.
	 * @return The object that was held at the given index.
	 * @throws IndexOutOfBoundsException if the index is out of range (index < 0 || index >= size())
	 */
	public Object remove(int index) {

	}

	@Override
	public TypeResponse<?> processRequest(ClientId clientId, ClassId classId,
			ID id, TypeRequest<?> request) {

		if(request instanceof ClearRequest) {
			clear(clientId, id);
			return new VoidResponse();
		} else if(request instanceof SizeRequest) {

    	for (Iterator<ID> itr = objectAccessor.idIterator(); itr.hasNext();) {
			ID id = itr.next();
		
			try {
				gcLock.acquire(id);
				GCInfo info = gcIF.get(id);
				if(info.gcInitialise())

        result = prime * id.hashCode();
		return result;
	}

	@Override
	public boolean equals(Object obj) {
		if (this == obj)
			return true;
		if (obj == null)
			return false;
		if (getClass() != obj.getClass())
			return false;

        return (int) (dateRep ^ (dateRep >>> 32));
    }

    @Override
    public boolean equals(Object obj) {
        if (this == obj)
            return true;
        if (obj == null)
            return false;
        if (getClass() != obj.getClass())
            return false;

		return getId().hashCode();
	}

	@Override
	public boolean equals(Object obj) {
		if (this == obj)
			return true;
		if (obj == null)
			return false;
		if (getClass() != obj.getClass())
			return false;

				+ ((updatedFields == null) ? 0 : updatedFields.hashCode());
		return result;
	}

	@Override
	public boolean equals(Object obj) {
		if (this == obj)
			return true;
		if (obj == null)
			return false;
		if (getClass() != obj.getClass())
			return false;

		return result;
	}

	@Override
	public boolean equals(Object obj) {
		if (this == obj)
			return true;
		if (obj == null)
			return false;
		if (getClass() != obj.getClass())
			return false;

			pIdx = store.getPrimaryIndex(Long.class, EnumEntry.class);
			sIdx = store.getSecondaryIndex(pIdx,String.class,"className");
			this.idManager = idManager; 
		} catch (DatabaseException de) {
			throw new StorageEngineException("Error intitalising indexes on Class info storage",de);
		}
	}
	@Override
	public EnumId createEnumId() {

        return clientId.hashCode();
    }

    @Override
    public boolean equals(Object obj) {
        if (this == obj)
            return true;
        if (obj == null)
            return false;
        if (getClass() != obj.getClass())
            return false;

		Map<FieldKey,JEMMObject> result = new HashMap<FieldKey,JEMMObject>();
		
		FieldFilter filter = new JEMMObjectFilter();
		FieldIterator it = new FieldIterator(obj.getClass(),filter);
		
		for(Field f : it) {
			Entity e = new Entity(obj);
			if(e.getShadowData().isFieldInitialised(f.getDeclaringClass(), FieldType.OBJECT, f.getName())) {

	}

	@Override
	public boolean equals(Object obj) {
		if (this == obj)
			return true;
		if (obj == null)
			return false;
		if (getClass() != obj.getClass())
			return false;

		return delegate.registerEnum(enumInfo);
	}

	public void releaseLock(ClientThreadId threadId, ID jemmId) {
		delegate.releaseLock(threadId, jemmId);
	}

	public void removeLockAcquiredListener(ClientId clientId) {
		delegate.removeLockAcquiredListener(clientId);
	}

	public void setRoot(String rootName, JEMMObject newValue) {

	public void removeClientLockReference(ClientThreadId clientThreadId, ID objectId) {
		ClientId clientId = clientThreadId.getClientId();
		try {
			clientLocks.acquire(clientId);
		
			Set<ClientThreadIdRef> set = clientLockRefs.get(clientId);
			if(set != null) {

        ContainsResponse result = (ContainsResponse) jemmOIF.processRequest(new ContainsValueRequest(value));
        if(result.isFound())
        	return true;
        else
        	if(result.getPossibles() != null)
        		for (Object possible : result.getPossibles())
        			if(value.equals(possible))

	private StoredValue[] getValuesAsArray() {
		StoredValue[] keys = new StoredValue[size()];
		int index=0;
		MapHashedEntry current = head;
		while(current != null) {
			keys[index++] = current.value;

				return unwrapId((ID) o);
			else
				return o;
		}
		
		@SuppressWarnings("unchecked")
		@Override public <K> K encode(K value) {
			if(value instanceof ID)
				return (K) unwrapId((ID) value);

    EnumId registerEnum(ClientId clientId,EnumInfo enumInfo) throws StructureModifiedException;
    
    /**
     * Asynchronous request to acquire a lock.  This method will return immediately,
     * but the caller should wait until notified by the LockAcquiredListener callback. 
     * @param threadId The requesting thread. 
     * @param jemmId The id of the object to lock.
     */
    void acquireLock(ClientThreadId threadId,ID jemmId);
    
    /**
     * Register a lock listener
     * @param clientId The id of the client registering for lock notifications.
     * @param listener The listener to register.
     */
    void setClientLockAcquiredListener(ClientId clientId,LockAcquiredListener listener);
    
    /**
     * Remove a lock listener
     * @param clientId The lock listener to remove.
     */
    void removeLockAcquiredListener(ClientId clientId);
    
    /**
     * Release the given lock held by the thread.  
     * @param threadId The thread currently holding the lock. 
     * @param jemmId The id of the object to release.
     */
    void releaseLock(ClientThreadId threadId,ID jemmId);

	}

	@Override
	public GetObjectResp getObjectData() {
		return new GetObjectResp(getObjectId(),getClassId(),0,new HashMap<FieldInfo, Object>());
	}

	public void addAllInternal(Collection<StoredValue> keys) {

    protected RPCCallRespMessage makeSyncCall(Class<?> ifClass, String methodName,Class<?>[] parameterTypes,
            Object[] args) {
        RPCCallMessage callMessage = new RPCCallMessage(ThreadUtil.getThreadId(),false,

        ContainsResponse result = (ContainsResponse) jemmOIF.processRequest(new ContainsRequest(uValue));
        if(result.isFound())
        	return true;
        else
        	if(result.getPossibles() != null)
        		for (Object possible : result.getPossibles())
        			if(uValue.equals(possible))

	private JEMMObject createUserObject(GetObjectResp resp, ClassInfo ci) {
		try {
			Class<?> clazz = Class.forName(ci.className);
			Constructor<?> constructor =clazz.getDeclaredConstructor(new Class[]{ShadowUserObject.class});

				returnType = m.group(5);
			} else {
				throw new DescriptorParsingException("Descriptor (" + signature +") is invalid");
			}
		} catch(Exception e) {
			throw new DescriptorParsingException("Descriptor (" + signature +") is invalid",e);
		}
	}

        return (int) (dateRep ^ (dateRep >>> 32));
    }

    @Override
    public boolean equals(Object obj) {
        if (this == obj)
            return true;
        if (obj == null)
            return false;
        if (getClass() != obj.getClass())

	}

	@Override
	public GetObjectResp getObjectData() {
		return new GetObjectResp(getObjectId(),getClassId(),0,new HashMap<FieldInfo, Object>());
	}

	public Collection<StoredValue> getKeys() {

        return getObjectId().hashCode();
    }
    
    @Override
    public boolean equals(Object obj) {
        if(this == obj) 
            return true;
        if(obj == null)
            return false;
        if(!(obj instanceof StoredObject))

		return new StoredListObject(id,classId);
	}

	@Override
	public TypeResponse<?> processRequest(ClientId clientId, ClassId classId,
			ID id, TypeRequest<?> request) {

		if(request instanceof ClearRequest) {

        return (int) (idValue ^ (idValue >>> 32));
    }

    @Override
    public boolean equals(Object obj) {
        if (this == obj)
            return true;
        if (obj == null)
            return false;
        if (!(obj instanceof ID))

        return (int) (idValue ^ (idValue >>> 32));
    }

    @Override
    public boolean equals(Object obj) {
        if (this == obj)
            return true;
        if (obj == null)
            return false;
        if (!(obj instanceof ID))

	public void initialise(FieldKey fieldKey) {
		ShadowData sData = entity.getShadowData();
		Class<?> declaringClass = fieldKey.getClazz();
		String fieldName = fieldKey.getName();

		if (sData.isFieldInitialised(declaringClass, FieldType.OBJECT, fieldName))

	public Object getField(FieldKey fkey) {
		try {
			Class<?> c = fkey.getClazz();
			Field f = c.getDeclaredField(fkey.getName());
			f.setAccessible(true);

        return getObjectId().hashCode();
    }
    
    @Override
    public boolean equals(Object obj) {
        if(this == obj) 
            return true;
        if(obj == null)
            return false;
        if(!(obj instanceof StoredObject))

    		StoredValue[] potentialValueMatches = resp.getPotentialValueMatches();
    		
    		for (int i = 0; i < potentialKeyMatches.length && newKey != null; i++) {
				if(potentialKeyMatches[i].equals(key)) {

    }

    public int size() {
    	return ((SizeResponse) jemmOIF.processRequest(new SizeRequest())).getSize();
    }

    @SuppressWarnings("unchecked")
	public Collection<V> values() {

			CtMethod[] methods = clazz.getDeclaredMethods();
			for (int i = 0; i < methods.length; ++i) {
				CtMethod m = methods[i];

		if(distinctFromKeys != null && allKeysIn(req.getKeyDistinctFrom())) {
			head = new MapHashedEntry(req.getKey(),req.getValue(),head);
			return new MapPutResponse(true,null,null);			
		}

	public boolean addAll(int index,StoredValue[] newValues) {
		if(newValues.length == 0)
			return false;

		List<StoredValue> list = Arrays.asList(newValues);
		values.addAll(index,list);

	public boolean hasPotentialKeyMatches() {
		return potentialKeyMatches != null;
	}

	@Override
	public void visit(ValueVisitor visitor) {
		visitor.visit(potentialKeyMatches);
		visitor.visit(potentialValueMatches);
	}
}

	private MapReplaceKONResponse(boolean success,StoredValue[] potentialKeyMatches,
			StoredValue[] potentialValueMatches) {
		this.success = success;
		this.potentialKeyMatches = potentialKeyMatches;
		this.potentialValueMatches = potentialValueMatches;
	}
	
	public MapReplaceKONResponse(boolean success) {

			ShadowData data = entity.getShadowUserObject().getData();
			data.setField(fieldKey.getClazz(), FieldType.OBJECT, fieldKey.getName(), newValue);

			clientKeyIdx.delete(new ClientLockKey(clientThreadId,objectId));
		} catch (DatabaseException e) {
			throw new StorageEngineException("addClientLockReference(" + clientThreadId + "," 
					+ objectId + ")" ,e);
		}
	}

		underlyingDatabase.clientDisconnect(clientId);
	}

	@Override
	public TypeResponse<?> processTypeRequest(ClientId clientId,
			ClassId classId, ID objId, TypeRequest<?> request) {

    @Override public Set<java.util.Map.Entry<K, V>> entrySet() {
        throw new UnsupportedOperationException();
    }

    @SuppressWarnings("unchecked") 

		clientRefHandler.clientDisconnect(clientId);
	}

	@Override
	public TypeResponse<?> processTypeRequest(ClientId clientId,
			ClassId classId, ID objId, TypeRequest<?> request) {

			lastInterestAmount = 0;
			ConstructorLifecycle.endConstructor(this); 
		}catch(Throwable t) {
			ConstructorLifecycle.failedConstructor(this);
			//would in the real program throw t not a RuntimeException
			throw new RuntimeException(t);
		}
	}
	
    public SavingsAccount(ShadowUserObject jemmOIF) {

        return (int) (idValue ^ (idValue >>> 32));
    }

    @Override
    public boolean equals(Object obj) {
        if (this == obj)
            return true;
        if (obj == null)
            return false;
        if (!(obj instanceof ID))

	}

	@Override
	public TypeResponse<?> processRequest(ClientId clientId, ClassId classId,
			ID id, TypeRequest<?> request) {

		if(request instanceof ClearRequest) {

        return getObjectId().hashCode();
    }
    
    @Override
    public boolean equals(Object obj) {
        if(this == obj) 
            return true;
        if(obj == null)
            return false;
        if(!(obj instanceof StoredObject))

	public ListAddResponse encode(ValueEncoder encoder) {
		// immutable value type
		return this;
	}


	public boolean isModified() {
		return modified;
	}

	@Override public void visit(ValueVisitor visitor) {}
}