View Javadoc

1   package org.sourceforge.jemm.client;
2   
3   import org.sourceforge.jemm.database.ClassId;
4   import org.sourceforge.jemm.database.ClassInfo;
5   import org.sourceforge.jemm.database.ClientId;
6   import org.sourceforge.jemm.database.ClientThreadId;
7   import org.sourceforge.jemm.database.Database;
8   import org.sourceforge.jemm.database.DatabaseDebugIF;
9   import org.sourceforge.jemm.database.EnumId;
10  import org.sourceforge.jemm.database.EnumInfo;
11  import org.sourceforge.jemm.database.GetObjectResp;
12  import org.sourceforge.jemm.database.LockAcquiredListener;
13  import org.sourceforge.jemm.database.ObjectSyncData;
14  import org.sourceforge.jemm.database.ObjectSyncResp;
15  import org.sourceforge.jemm.database.StructureModifiedException;
16  import org.sourceforge.jemm.lifecycle.TypeRequest;
17  import org.sourceforge.jemm.lifecycle.TypeResponse;
18  import org.sourceforge.jemm.types.ID;
19  
20  /**
21   * A database implementation that passes through all calls
22   * onto the database given in the constructor.
23   * 
24   * @author Paul Keeble
25   *
26   */
27  public abstract class DelegatingDatabase implements Database {
28  	private Database delegate;
29  	
30  	public DelegatingDatabase(Database delegate) {
31  		this.delegate = delegate;
32  	}
33  	public void acquireLock(ClientThreadId threadId, ID jemmId) {
34  		delegate.acquireLock(threadId, jemmId);
35  	}
36  	public ClassInfo getClassInfo(ClientId clientId, ClassId classId) {
37  		return delegate.getClassInfo(clientId, classId);
38  	}
39  	public DatabaseDebugIF getDebugInterface() {
40  		return delegate.getDebugInterface();
41  	}
42  	public EnumInfo getEnumInfo(ClientId clientId, EnumId enumId) {
43  		return delegate.getEnumInfo(clientId, enumId);
44  	}
45  	public GetObjectResp getObject(ClientId clientId, ID jemmId) {
46  		return delegate.getObject(clientId, jemmId);
47  	}
48  	public ID getRoot(ClientId clientId, String rootName) {
49  		return delegate.getRoot(clientId, rootName);
50  	}
51  	public ID newObject(ClientId clientId, ClassId classId) {
52  		return delegate.newObject(clientId, classId);
53  	}
54  	public void referenceCleared(ClientId clientId, ID... ids) {
55  		delegate.referenceCleared(clientId, ids);
56  	}	
57  	public ClassId registerClass(ClientId clientId, ClassInfo classInfo) throws StructureModifiedException {
58  		return delegate.registerClass(clientId, classInfo);
59  	}
60  	public EnumId registerEnum(ClientId clientId, EnumInfo enumInfo) throws StructureModifiedException {
61  		return delegate.registerEnum(clientId, enumInfo);
62  	}
63  	public void releaseLock(ClientThreadId threadId, ID jemmId) {
64  		delegate.releaseLock(threadId, jemmId);
65  	}
66  	public void removeLockAcquiredListener(ClientId clientId) {
67  		delegate.removeLockAcquiredListener(clientId);
68  	}
69  	public void setClientLockAcquiredListener(ClientId clientId,
70  			LockAcquiredListener listener) {
71  		delegate.setClientLockAcquiredListener(clientId, listener);
72  	}
73  	public void setRoot(ClientId clientId, String rootName, ID newValue) {
74  		delegate.setRoot(clientId, rootName, newValue);
75  	}
76  	public ID setRootIfNull(ClientId clientId, String rootName, ID newValue) {
77  		return delegate.setRootIfNull(clientId, rootName, newValue);
78  	}
79  	public ObjectSyncResp synchroniseObject(ClientId clientId, ID jemmId,
80  			ObjectSyncData syncData) {
81  		return delegate.synchroniseObject(clientId, jemmId, syncData);
82  	}
83  	@Override public void clientDisconnect(ClientId clientId) {
84  		delegate.clientDisconnect(clientId);		
85  	}
86  	@Override public TypeResponse<?> processTypeRequest(ClientId clientId,
87  			ClassId classId, ID objId, TypeRequest<?> request) {
88  		return delegate.processTypeRequest(clientId, classId, objId, request);
89  	}
90  }