X-Git-Url: http://source.jalview.org/gitweb/?a=blobdiff_plain;f=src%2Fuk%2Fac%2Fvamsas%2Ftest%2Fsimpleclient%2FClientDoc.java;h=0772cb32ad3d7bf49bbdc74d87deb2d28fa1c22c;hb=844ccad5a3fcbedec17b2af66d460f31abc7cff1;hp=990d58adc92e11b47de17f21b484bdb5adc1cbc4;hpb=6f33f705957d674dc2ab6c994a6ea87f7a91f40f;p=vamsas.git diff --git a/src/uk/ac/vamsas/test/simpleclient/ClientDoc.java b/src/uk/ac/vamsas/test/simpleclient/ClientDoc.java index 990d58a..0772cb3 100644 --- a/src/uk/ac/vamsas/test/simpleclient/ClientDoc.java +++ b/src/uk/ac/vamsas/test/simpleclient/ClientDoc.java @@ -1,356 +1,434 @@ -package uk.ac.vamsas.test.simpleclient; - -import java.util.Hashtable; -import java.util.Vector; - -import org.apache.commons.logging.Log; -import org.apache.commons.logging.LogFactory; - -import uk.ac.vamsas.client.IClientAppdata; -import uk.ac.vamsas.client.Vobject; -import uk.ac.vamsas.client.VorbaId; -import uk.ac.vamsas.client.simpleclient.ClientDocument; -import uk.ac.vamsas.client.simpleclient.VamsasArchive; -import uk.ac.vamsas.client.simpleclient.VamsasArchiveReader; -import uk.ac.vamsas.objects.core.Entry; -import uk.ac.vamsas.objects.core.VAMSAS; -import uk.ac.vamsas.objects.core.VamsasDocument; -import uk.ac.vamsas.objects.utils.ProvenanceStuff; - -// simple holder to pass to client. -public class ClientDoc extends uk.ac.vamsas.client.ClientDocument { - /* (non-Javadoc) - * @see uk.ac.vamsas.client.IClientDocument#getClientAppdata() - */ - public IClientAppdata getClientAppdata() { - throw new Error("Appdata access is not implemented in the test.simpleclient.ClientDoc instance."); // TODO Auto-generated method stub - } - protected boolean isModified=false; - private Log log = LogFactory.getLog(ClientDoc.class); - protected VamsasDocument doc; - public uk.ac.vamsas.objects.core.VAMSAS[] _VamsasRoots; - protected VamsasArchive iohandler=null; - protected VamsasArchiveReader reader=null; - private String user=null; - private String app=null; - - /** - * @param doc - * @param iohandler - * @param reader - * @param app - * @param user - */ - public ClientDoc(VamsasDocument doc, VamsasArchive iohandler, VamsasArchiveReader reader, String app, String user, Hashtable objrefs) { - super(objrefs, (iohandler!=null) ? iohandler.getVorba() : null); - this.doc = doc; - this.iohandler = iohandler; - this.reader = reader; - this.app = app; - this.user = user; - this.objrefs = objrefs; - _VamsasRoots = doc.getVAMSAS(); - } - // AppDataOutputStream appd; - //AppDataOutputStream userd; - /* (non-Javadoc) - * @see java.lang.Object#finalize() - */ - protected Entry getProvenanceEntry(String action) { - // VAMSAS: modify schema to allow referencing of user field (plus other issues, ClientUrn field, machine readable action, input parameters, additional data generated notes - Entry prov = ProvenanceStuff.newProvenanceEntry(app, user, action); - return prov; - } - public VAMSAS[] getVamsasRoots() { - if (doc==null) { - log.debug("Null document for getVamsasRoots(), returning null"); - return null; - } - if (iohandler==null) { - // LATER: decide on read-only status of ClientDocument object - log.warn("getVamsasRoots() called on possibly read-only document."); - } - if (_VamsasRoots!=null) - return _VamsasRoots; - VAMSAS[] roots = doc.getVAMSAS(); - if (roots == null) { - // Make a new one to return to client to get filled. - _VamsasRoots = new VAMSAS[] { new VAMSAS() }; - // Do provenance now. just in case. - doc.getProvenance().addEntry(getProvenanceEntry("Created new document root [id="+_VamsasRoots[0].getId()+"]")); - doc.addVAMSAS(_VamsasRoots[0]); - } else { - _VamsasRoots = new VAMSAS[roots.length]; - for (int r=0;r-1) { - if (isValidUpdate(newr[k], original[i])) { - modified=true; - rts.add(newr[k]); - newr[k]=null; - } else { - // LATER: try harder to merge ducument roots. - log.warn("Couldn't merge new VAMSAS root "+newr[k].getId()); - newr[k] = null; // LATER: this means we ignore mangled roots. NOT GOOD - } - } else { - // add in order. - rts.add(original[i]); - } - } - // add remaining (new) roots - for (int i=0,j=newr.length; i. + */ +package uk.ac.vamsas.test.simpleclient; + +import java.util.Hashtable; +import java.util.Vector; + +import org.apache.commons.logging.Log; +import org.apache.commons.logging.LogFactory; + +import uk.ac.vamsas.client.IClientAppdata; +import uk.ac.vamsas.client.Vobject; +import uk.ac.vamsas.client.VorbaId; +import uk.ac.vamsas.client.simpleclient.ClientDocument; +import uk.ac.vamsas.client.simpleclient.VamsasArchive; +import uk.ac.vamsas.client.simpleclient.VamsasArchiveReader; +import uk.ac.vamsas.objects.core.Entry; +import uk.ac.vamsas.objects.core.VAMSAS; +import uk.ac.vamsas.objects.core.VamsasDocument; +import uk.ac.vamsas.objects.utils.ProvenanceStuff; + +// simple holder to pass to client. +public class ClientDoc extends uk.ac.vamsas.client.ClientDocument { + /* + * (non-Javadoc) + * + * @see uk.ac.vamsas.client.IClientDocument#getClientAppdata() + */ + public IClientAppdata getClientAppdata() { + throw new Error( + "Appdata access is not implemented in the test.simpleclient.ClientDoc instance."); // TODO + // Auto-generated + // method + // stub + } + + protected boolean isModified = false; + + private Log log = LogFactory.getLog(ClientDoc.class); + + protected VamsasDocument doc; + + public uk.ac.vamsas.objects.core.VAMSAS[] _VamsasRoots; + + protected VamsasArchive iohandler = null; + + protected VamsasArchiveReader reader = null; + + private String user = null; + + private String app = null; + + /** + * @param doc + * @param iohandler + * @param reader + * @param app + * @param user + */ + public ClientDoc(VamsasDocument doc, VamsasArchive iohandler, + VamsasArchiveReader reader, String app, String user, Hashtable objrefs) { + super(objrefs, (iohandler != null) ? iohandler.getVorba() : null); + this.doc = doc; + this.iohandler = iohandler; + this.reader = reader; + this.app = app; + this.user = user; + this.objrefs = objrefs; + _VamsasRoots = doc.getVAMSAS(); + } + + // AppDataOutputStream appd; + // AppDataOutputStream userd; + /* + * (non-Javadoc) + * + * @see java.lang.Object#finalize() + */ + protected Entry getProvenanceEntry(String action) { + // VAMSAS: modify schema to allow referencing of user field (plus other + // issues, ClientUrn field, machine readable action, input parameters, + // additional data generated notes + Entry prov = ProvenanceStuff.newProvenanceEntry(app, user, action); + return prov; + } + + public VAMSAS[] getVamsasRoots() { + if (doc == null) { + log.debug("Null document for getVamsasRoots(), returning null"); + return null; + } + if (iohandler == null) { + // LATER: decide on read-only status of ClientDocument object + log.warn("getVamsasRoots() called on possibly read-only document."); + } + if (_VamsasRoots != null) + return _VamsasRoots; + VAMSAS[] roots = doc.getVAMSAS(); + if (roots == null) { + // Make a new one to return to client to get filled. + _VamsasRoots = new VAMSAS[] { new VAMSAS() }; + // Do provenance now. just in case. + doc.getProvenance().addEntry( + getProvenanceEntry("Created new document root [id=" + + _VamsasRoots[0].getId() + "]")); + doc.addVAMSAS(_VamsasRoots[0]); + } else { + _VamsasRoots = new VAMSAS[roots.length]; + for (int r = 0; r < roots.length; r++) + _VamsasRoots[r] = roots[r]; + } + return _VamsasRoots; + } + + private int _contains(VAMSAS root, VAMSAS[] docRoots) { + if (root == null) + return -1; + if (docRoots == null || docRoots.length == 0) + return -1; + VorbaId r_id = root.getVorbaId(); + for (int i = 0, j = docRoots.length; i < j; i++) { + VorbaId n_id = null; + if (docRoots[i] == root + || (docRoots[i] != null && (n_id = docRoots[i].getVorbaId()) != null && n_id + .equals(r_id))) + return i; + } + return -1; + } + + /** + * verify that newr version is really an intact version of the + * + * @param newVersion + * (may be modified) + * @param oldVersion + * @return true if newVersion is a valid root that preserves original + * references + */ + private boolean isValidUpdate(VAMSAS newVersion, final VAMSAS oldVersion) { + // ideal - this cascades down the two structures, ensuring that all ID'd + // objects in one are present in the other. + if (oldVersion == newVersion) { + // may be a virgin root element. + if (!newVersion.isRegistered()) + iohandler.getVorba().makeVorbaId(newVersion); + // Should retrieve original version and compare - unless local hashes can + // be used to determine if resultSet has been truncated. + // just do internal validation for moment. + if (newVersion.isValid()) + return true; + return false; + } else { + // redundant ? if (oldVersion.is__stored_in_document()) + if (!newVersion.isRegistered()) + iohandler.getVorba().makeVorbaId(newVersion); + if (newVersion.isValid()) + return true; + } + return false; + } + + /** + * /** merge old and new root vectors + * + * @param newr + * This array may be written to + * @param original + * @param the + * client document (usually this) which this root set belongs to. + * @return merged vector of vamsas roots + */ + private VAMSAS[] _combineRoots(VAMSAS[] newr, final VAMSAS[] original, + ClientDoc modflag) { + Vector rts = new Vector(); + boolean modified = false; + for (int i = 0, j = original.length; i < j; i++) { + int k = _contains(original[i], newr); + if (k > -1) { + if (isValidUpdate(newr[k], original[i])) { + modified = true; + rts.add(newr[k]); + newr[k] = null; + } else { + // LATER: try harder to merge ducument roots. + log.warn("Couldn't merge new VAMSAS root " + newr[k].getId()); + newr[k] = null; // LATER: this means we ignore mangled roots. NOT GOOD + } + } else { + // add in order. + rts.add(original[i]); + } + } + // add remaining (new) roots + for (int i = 0, j = newr.length; i < j; i++) { + if (newr[i] != null) { + rts.add(newr[i]); + modified = true; + } + } + newr = new VAMSAS[rts.size()]; + for (int i = 0, j = rts.size(); i < j; i++) + newr[i] = (VAMSAS) rts.get(i); + if (modflag != null) + modflag.isModified = modified; + return newr; + } + + /** + * update the document with new roots. LATER: decide: this affects the next + * call to getVamsasRoots() + * + * @see org.vamsas.IClientDocument.setVamsasRoots + */ + public void setVamsasRoots(VAMSAS[] newroots) { + if (doc == null) { + log.debug("setVamsasRoots called on null document."); + return; + } + VAMSAS[] newr; + if (newroots == null) { + log.debug("setVamsasRoots(null) - do nothing."); + return; + } + // are we dealing with same array ? + if (_VamsasRoots != newroots) { + // merge roots into local version. + newr = new VAMSAS[newroots.length]; + for (int i = 0; i < newr.length; i++) + newr[i] = newroots[i]; + newr = _combineRoots(newr, _VamsasRoots, this); + } else { + newr = new VAMSAS[_VamsasRoots.length]; + for (int i = 0; i < newr.length; i++) + newr[i] = _VamsasRoots[i]; + } + // actually compare with document root set for final combination (to ensure + // nothing is lost) + _VamsasRoots = _combineRoots(newr, doc.getVAMSAS(), this); + } + + /* + * (non-Javadoc) LATER: decide: this affects the next call to getVamsasRoots() + * + * @see + * uk.ac.vamsas.client.IClientDocument#addVamsasRoot(uk.ac.vamsas.objects. + * core.VAMSAS) + */ + public void addVamsasRoot(VAMSAS newroot) { + if (doc == null) { + log.debug("addVamsasRoots called on null document."); + return; + } + VAMSAS[] newroots = _combineRoots(new VAMSAS[] { newroot }, _VamsasRoots, + this); + _VamsasRoots = newroots; + } + + public VamsasArchiveReader getReader() { + return reader; + } + + private void _finalize() { + log.debug("finalizing clientDoc"); + if (doc != null) { + doc = null; + } + if (_VamsasRoots != null) { + for (int i = 0; i < _VamsasRoots.length; i++) + _VamsasRoots[i] = null; + _VamsasRoots = null; + + } + + if (reader != null) { + log.debug("Closing and removing reader reference"); + reader.close(); + reader = null; + } + if (iohandler != null) { + log.debug("Removing ioHandler reference."); + iohandler.cancelArchive(); + iohandler = null; + } + } + + protected void finalize() throws Throwable { + _finalize(); + super.finalize(); + } + + private java.util.Hashtable objrefs = null; + + public VorbaId[] registerObjects(Vobject[] unregistered) { + if (doc == null) { + log.warn("registerObjects[] called on null document."); + return null; + } + if (objrefs == null) { + log.warn("registerObjects[] called for null objrefs hasharray."); + return null; + } + if (unregistered != null) { + VorbaId ids[] = new VorbaId[unregistered.length]; + for (int i = 0, k = unregistered.length; i < k; i++) + if (unregistered[i] != null) { + log.warn("Null Vobject passed to registerObject[] at position " + i); + return null; + } else { + ids[i] = registerObject(unregistered[i]); + } + log.debug("Registered " + unregistered.length + " objects - total of " + + objrefs.size() + " ids."); + return ids; + } + return null; + } + + /* + * (non-Javadoc) + * + * @see + * uk.ac.vamsas.client.IClientDocument#registerObject(uk.ac.vamsas.client. + * Vobject) + */ + public VorbaId registerObject(Vobject unregistered) { + if (doc == null) { + log.warn("registerObjects called on null document."); + return null; + } + if (objrefs == null) { + log.warn("registerObjects called for null objrefs hasharray."); + return null; + } + if (iohandler == null) { + log.warn("registerObjects called for read only document."); + return null; + } + + if (unregistered != null) { + VorbaId id = this._registerObject(unregistered); + log.debug("Registered object - total of " + objrefs.size() + " ids."); + return id; + } + log.warn("Null Vobject passed to registerObject."); + return null; + } + + /* + * (non-Javadoc) + * + * @see + * uk.ac.vamsas.client.IClientDocument#getObject(uk.ac.vamsas.client.VorbaId) + */ + public Vobject getObject(VorbaId id) { + if (objrefs == null) { + log.debug("getObject called on null objrefs list."); + return null; + } + if (objrefs.containsKey(id.getId())) + return (Vobject) objrefs.get(id.getId()); + log.debug("Returning null Vobject reference for id " + id.getId()); + return null; + } + + /* + * (non-Javadoc) + * + * @see + * uk.ac.vamsas.client.IClientDocument#getObjects(uk.ac.vamsas.client.VorbaId + * []) + */ + public Vobject[] getObjects(VorbaId[] ids) { + if (objrefs == null) { + log.debug("getObject[] called on null objrefs list."); + return null; + } + Vobject[] vo = new Vobject[ids.length]; + for (int i = 0, j = ids.length; i < j; i++) + if (objrefs.containsKey(ids[i])) + vo[i] = (Vobject) objrefs.get(ids[i]); + else + log.debug("Returning null Vobject reference for id " + ids[i].getId()); + return vo; + } + + protected void updateDocumentRoots() { + if (doc == null) { + log + .error("updateDocumentRoots called on null document. Probably an implementation error."); + return; + } + if (isModified) { + if (_VamsasRoots != null) { + doc.setVAMSAS(_VamsasRoots); + _VamsasRoots = null; + } + } + } + + /** + * tell vamsas client to close the document and reset the object. Once closed, + * nothing can be done with the object. + * + */ + public void closeDoc() { + if (doc != null) { + log.debug("Closing open document."); + _finalize(); + } else { + log.warn("Ignoring closeDoc on invalid document."); + } + } + +}