From: jprocter <jprocter@compbio.dundee.ac.uk>
Date: Thu, 14 Dec 2006 18:41:20 +0000 (+0000)
Subject: refactoring org to uk
X-Git-Tag: Release_0.2~234
X-Git-Url: http://source.jalview.org/gitweb/?a=commitdiff_plain;h=3b92275c26c14a678519f1d7d2ffaa477eb76cdb;p=vamsas.git

refactoring org to uk

git-svn-id: https://svn.lifesci.dundee.ac.uk/svn/repository/trunk@286 be28352e-c001-0410-b1a7-c7978e42abec
---

diff --git a/src/uk/ac/vamsas/test/simpleclient/ArchiveClient.java b/src/uk/ac/vamsas/test/simpleclient/ArchiveClient.java
new file mode 100644
index 0000000..4e0e68b
--- /dev/null
+++ b/src/uk/ac/vamsas/test/simpleclient/ArchiveClient.java
@@ -0,0 +1,293 @@
+/**
+ * 
+ */
+package uk.ac.vamsas.test.simpleclient;
+
+import java.io.File;
+import java.io.IOException;
+import java.util.Date;
+import java.util.Hashtable;
+import java.util.Vector;
+
+import org.apache.commons.logging.Log;
+import org.apache.commons.logging.LogFactory;
+import org.exolab.castor.xml.MarshalException;
+import org.exolab.castor.xml.ValidationException;
+import org.vamsas.test.objects.Core;
+
+import uk.ac.vamsas.client.ClientHandle;
+import uk.ac.vamsas.client.IVorbaIdFactory;
+import uk.ac.vamsas.client.SessionHandle;
+import uk.ac.vamsas.client.UserHandle;
+import uk.ac.vamsas.client.Vobject;
+import uk.ac.vamsas.client.VorbaId;
+import uk.ac.vamsas.client.simpleclient.AppDataOutputStream;
+import uk.ac.vamsas.client.simpleclient.FileWatcher;
+import uk.ac.vamsas.client.simpleclient.IdFactory;
+import uk.ac.vamsas.client.simpleclient.SessionFile;
+import uk.ac.vamsas.client.simpleclient.SimpleDocBinding;
+import uk.ac.vamsas.client.simpleclient.SimpleDocument;
+import uk.ac.vamsas.client.simpleclient.VamsasArchive;
+import uk.ac.vamsas.client.simpleclient.VamsasArchiveReader;
+import uk.ac.vamsas.client.simpleclient.VamsasFile;
+import uk.ac.vamsas.objects.core.AppData;
+import uk.ac.vamsas.objects.core.ApplicationData;
+import uk.ac.vamsas.objects.core.User;
+import uk.ac.vamsas.objects.core.VamsasDocument;
+import uk.ac.vamsas.objects.utils.AppDataReference;
+import uk.ac.vamsas.objects.utils.DocumentStuff;
+import uk.ac.vamsas.objects.utils.ProvenanceStuff;
+import uk.ac.vamsas.objects.utils.SeqSet;
+import uk.ac.vamsas.objects.utils.document.VersionEntries;
+
+/**
+ * @author jimp
+ *  test the VamsasFile routines for watching, reading and updating a vamsas document jar file.
+ *  simple document access base class.
+ */
+public class ArchiveClient extends IdFactory {
+  
+  private Log log = LogFactory.getLog(ArchiveClient.class);
+  // protected UserHandle user=null;
+  // protected ClientHandle me = new ClientHandle("ArchiveClient","0.01");
+  VamsasFile vsess;
+  
+  /**
+   * @param user
+   * @param vsess
+   */
+  public ArchiveClient(UserHandle user, VamsasFile vsess) {
+    super(new SessionHandle("vamsasfile://"+vsess.getVamsasFile()), new ClientHandle("ArchiveClient","0.01"), user);
+    this.vsess = vsess;
+    valid();
+  }
+  private void _openVsess(File vsess) {
+    try {
+      this.vsess = new VamsasFile(vsess);
+    }
+    catch (Exception e) {
+      log.error("Couldn't open session for file "+vsess,e);
+      this.vsess = null;
+    }
+  }
+  public ArchiveClient(String username, String organization, File vsess) {
+    super(new SessionHandle("vamsasfile://"+vsess), new ClientHandle("ArchiveClient","0.01"), new UserHandle(username, organization));
+    _openVsess(vsess);
+    valid();
+  }
+  public ArchiveClient(String username, String organization, String clientName, String clientVersion, File vsess) {
+    super(new SessionHandle("vamsasfile://"+vsess), new ClientHandle(clientName, clientVersion), new UserHandle(username, organization));
+    _openVsess(vsess);
+    valid();
+  }
+  public void valid() {
+    if (vsess==null)
+      throw new Error("ArchiveClient instance is invalid!.");
+  }
+  /**
+   * set this to false if watch loop should end immediately
+   */
+  protected boolean watchForChange=true;
+  public static int WATCH_SLEEP=300;
+  /**
+   * watch the document file for updates.
+   * @param time - length of time to watch for.
+   * @return read only IO interface for session document.
+   */
+  public ClientDoc watch(long time) {
+    valid();
+    vsess.unLock(); // doh.
+    FileWatcher watcher = new FileWatcher(vsess.getVamsasFile());
+    // watcher.setState();
+    watchForChange=true;
+    long endtime=System.currentTimeMillis()+time;
+    try {
+      uk.ac.vamsas.client.simpleclient.Lock doclock;
+      do {
+        doclock=watcher.getChangedState();
+        if (doclock==null)
+          Thread.sleep(WATCH_SLEEP);
+      } while (watchForChange && doclock==null && (time==0 || endtime>System.currentTimeMillis())); // tuning.
+      if (doclock==null)
+        return null;
+      else {
+        return getUpdateable(vsess.getLock(doclock));
+        /*VamsasArchiveReader varc = new VamsasArchiveReader(vsess.getVamsasFile());
+        return _getReadonly(varc);*/
+      }
+    } catch (Exception e) {
+      log.error("Whilst watching file "+vsess.getVamsasFile(), e);
+    }
+    return null;
+  }
+
+  // from ClientDocument.getClientAppdata
+  private AppData[] getAppData(VamsasDocument doc) {
+    if (doc==null) {
+      log.debug("extractAppData called for null document object");
+      return null;
+    }
+    AppData appsGlobal=null, usersData=null;
+    Vector apldataset = AppDataReference.getUserandApplicationsData(
+        doc, this.getUserHandle(), this.getClientHandle());
+    if (apldataset!=null) {
+      if (apldataset.size()>0) {
+        AppData clientdat = (AppData) apldataset.get(0);
+        if (clientdat instanceof ApplicationData) {
+          appsGlobal = (ApplicationData) clientdat;
+          if (apldataset.size()>1) {
+            clientdat = (AppData) apldataset.get(1);
+            if (clientdat instanceof User) {
+              usersData = (User) clientdat;
+            }
+            if (apldataset.size()>2)
+              log.info("Ignoring additional ("+(apldataset.size()-2)+") AppDatas returned by document appdata query.");
+          } 
+        } else {
+          log.warn("Unexpected entry in AppDataReference query: id="+clientdat.getVorbaId()+" type="+clientdat.getClass().getName());
+        }
+        apldataset.removeAllElements(); // destroy references.
+      }
+    }
+    return new AppData[] { appsGlobal, usersData};
+  }
+  
+  protected ClientDoc _getReadonly(VamsasArchiveReader vreader) throws IOException, ValidationException, MarshalException {
+    valid();
+    if (vreader!=null) {
+      SimpleDocBinding docb = new SimpleDocBinding();
+      docb.setVorba(this);
+      VamsasDocument d;
+      d = docb.getVamsasDocument(vreader);
+      
+      if (d!=null) {
+        ClientDoc creader = new ClientDoc(d, null, vreader, getClientHandle().getClientUrn(), getProvenanceUser(), getVorbaIdHash());
+        return creader;
+      }
+    }
+    return null;
+  }  
+  /**
+   * from SimpleClient
+   * @return user field for a provenance entry
+   */
+  protected String getProvenanceUser() {
+    return new String(getUserHandle().getFullName()+" ["+getClientHandle().getClientUrn()+"]");
+  }
+  
+  public ClientDoc getUpdateable() {
+    return getUpdateable(null);
+  }
+  public ClientDoc getUpdateable(uk.ac.vamsas.client.simpleclient.Lock lock) {
+    getVorbaIdHash().clear();
+    valid();
+    try {
+      // patiently wait for a lock on the document.
+      long tries=5000;
+      while (lock==null && ((lock=vsess.getLock())==null || !lock.isLocked()) && --tries>0) {
+//        Thread.sleep(1);
+        log.debug("Trying to get a document lock for the "+tries+"'th time.");
+      }
+      VamsasArchive varc = new VamsasArchive(vsess, true, false); // read archive, write as vamsasDocument, don't erase original contents.
+      varc.setVorba(this);
+      VamsasDocument d = varc.getVamsasDocument(getProvenanceUser(), "Created new document.", VersionEntries.latestVersion()); // VAMSAS: provenance user and client combined
+      
+      if (d==null) {
+        log.warn("Backing out from opening a VamsasArchive writable IO session");
+        varc.cancelArchive();
+        return null;
+      }      
+      ClientDoc cdoc = new ClientDoc(d, varc, varc.getOriginalArchiveReader(), getClientHandle().getClientUrn(), getProvenanceUser(), getVorbaIdHash());
+      return cdoc;
+      // do appHandle?
+    } catch (Exception e) {
+      log.error("Failed to get Updateable version of "+vsess.getVamsasFile(), e);
+    }
+    return null;
+  }
+  /**
+   * trust client to not do anything stupid to the document roots which will now be written to the archive.
+   * @param cdoc
+   * @return true if write was a success.
+   */
+  public boolean doUpdate(ClientDoc cdoc) {
+    valid();
+    if (cdoc==null) {
+      log.warn("Invalid ClientDoc passed to uk.ac.vamsas.test.simpleclient.doUpdate()");
+      return false;
+    }
+    if (cdoc.iohandler==null) {
+      log.warn("Read only ClientDoc object passed to uk.ac.vamsas.test.simpleclient.doUpdate()");
+      return false;
+    }
+    if (cdoc.iohandler.getVorba()!=this) {
+      log.error("Mismatch between ClientDoc instances and ArchiveClient instances!");
+      return false;
+    }
+    try {
+      // do any appDatas first.
+      if (cdoc.iohandler.transferRemainingAppDatas())
+        log.debug("Remaining appdatas were transfered.");
+      cdoc.updateDocumentRoots();
+      cdoc.iohandler.putVamsasDocument(cdoc.doc);
+      cdoc.iohandler.closeArchive();
+      this.extantids.clear();// we forget our ids after we close the document.
+      cdoc.iohandler=null;
+      cdoc = null;
+      vsess.unLock();
+    } catch (Exception e) {
+      log.warn("While updating archive in "+vsess.getVamsasFile(),e);
+      return false;
+    }
+    return true;
+  }
+  /**
+   * @param args
+   */
+  public static void usage() {
+    throw new Error("Usage: Username Organization VamsasFile [command,args]*");
+  }
+  public static void main(String[] args) {
+    // really simple.
+    if (args.length<3)
+      usage();
+    
+    ArchiveClient client = new ArchiveClient(args[0],args[1], new File(args[2]));
+    ClientDoc cdoc=null;
+    // sanity test.
+    try {
+      cdoc = client.getUpdateable();
+      // ArchiveReports.reportDocument(cdoc.doc, cdoc.getReader(), true, System.out);
+      System.out.println("Report Roots :");
+      ArchiveReports.rootReport(cdoc.getVamsasRoots(), true, System.out);
+      cdoc.addVamsasRoot(Core.getDemoVamsas());
+      System.out.println("Doing update.");
+      client.doUpdate(cdoc);
+      cdoc.closeDoc();
+      cdoc = null;
+      int u=5;
+      while (--u>0) {
+        System.out.println("Watch for more... ("+u+" left)");
+        ClientDoc ucdoc = client.watch(0000);
+        if (ucdoc!=null) {
+          System.out.println("****\nUpdate detected at "+new Date());
+          ArchiveReports.reportDocument(ucdoc.doc, ucdoc.getReader(), true, System.out);
+          ucdoc.closeDoc();
+          ucdoc=null;
+        } else {
+          System.out.println("!!!! Null document update detected at "+new Date());
+        }
+      }
+    }
+    catch (Exception e) {
+      client.log.error("Broken!", e);
+    }
+    System.out.println("Finished at "+new Date());
+  }
+  public uk.ac.vamsas.client.Vobject getObject(VorbaId id) {
+    Hashtable idhash = this.getVorbaIdHash();
+    if (idhash!=null && idhash.containsKey(id))
+      return (Vobject) idhash.get(id);
+    return null;
+    }
+}
diff --git a/src/uk/ac/vamsas/test/simpleclient/ArchiveReader.java b/src/uk/ac/vamsas/test/simpleclient/ArchiveReader.java
new file mode 100644
index 0000000..68e6ff4
--- /dev/null
+++ b/src/uk/ac/vamsas/test/simpleclient/ArchiveReader.java
@@ -0,0 +1,51 @@
+package uk.ac.vamsas.test.simpleclient;
+
+import java.io.BufferedInputStream;
+import java.io.File;
+import java.io.InputStream;
+import java.io.InputStreamReader;
+
+
+import uk.ac.vamsas.client.simpleclient.VamsasArchiveReader;
+import uk.ac.vamsas.objects.core.VAMSAS;
+import uk.ac.vamsas.objects.core.VamsasDocument;
+
+public class ArchiveReader {
+  /**
+   * tests VamsasArchiveReader archive reader on a vamsas jar file
+   * @param args
+   */
+  public static void main(String args[]) {
+    
+    try {
+      File av = new File(args[0]);
+      VamsasArchiveReader var = new VamsasArchiveReader(av);
+      VAMSAS roots[]=null;
+      if (var.isValid()) {
+        InputStreamReader vdoc = new InputStreamReader(var.getVamsasDocumentStream());
+        VamsasDocument doc = VamsasDocument.unmarshal(vdoc);
+        if (ArchiveReports.reportDocument(doc, var, true, System.out)) {
+          roots = doc.getVAMSAS();
+        }
+      } else {
+        InputStream vxmlis = var.getVamsasXmlStream();
+        
+        if (vxmlis!=null) { // Might be an old vamsas file.
+          BufferedInputStream ixml = new BufferedInputStream(var.getVamsasXmlStream());
+          InputStreamReader vxml = new InputStreamReader(ixml);
+          VAMSAS root;
+          // unmarshal seems to always close the stream (should check this)
+          if ((root = VAMSAS.unmarshal(vxml))!=null) {
+            System.out.println("Read a root.");
+            roots = new VAMSAS[1];
+            roots[0] = root;
+          }
+        }
+      }
+      if (!ArchiveReports.rootReport(roots, true, System.out))
+        System.err.print(args[0]+" is not a valid vamsas archive.");
+    } catch (Exception e) {
+      e.printStackTrace(System.err);
+    }
+  }
+}
diff --git a/src/uk/ac/vamsas/test/simpleclient/ArchiveReports.java b/src/uk/ac/vamsas/test/simpleclient/ArchiveReports.java
new file mode 100644
index 0000000..94d06bf
--- /dev/null
+++ b/src/uk/ac/vamsas/test/simpleclient/ArchiveReports.java
@@ -0,0 +1,187 @@
+package uk.ac.vamsas.test.simpleclient;
+
+import java.io.InputStream;
+import java.io.PrintStream;
+import java.io.PrintWriter;
+
+
+import uk.ac.vamsas.client.ClientDocument;
+import uk.ac.vamsas.client.Vobject;
+import uk.ac.vamsas.client.simpleclient.VamsasArchiveReader;
+import uk.ac.vamsas.objects.core.Alignment;
+import uk.ac.vamsas.objects.core.AppData;
+import uk.ac.vamsas.objects.core.ApplicationData;
+import uk.ac.vamsas.objects.core.DataSet;
+import uk.ac.vamsas.objects.core.Entry;
+import uk.ac.vamsas.objects.core.Instance;
+import uk.ac.vamsas.objects.core.Provenance;
+import uk.ac.vamsas.objects.core.Tree;
+import uk.ac.vamsas.objects.core.User;
+import uk.ac.vamsas.objects.core.VAMSAS;
+import uk.ac.vamsas.objects.core.VamsasDocument;
+/**
+ * this class contains static methods for writing info to stdout about a vamsas document
+ * Methods have a 'cascade' switch to indicate if sub-objects should have info printed on them.
+ * Methods return true or false - indicating if the Vobject was valid or not
+ * TODO: LATER: propagate true/false return so that an invalid vamsas Vobject invalidates the whole document
+ * @author jimp
+ *
+ */
+public class ArchiveReports {
+    /**
+     * print an informative summary on a VamsasDocument
+     * @param outstr TODO
+     * @param document - the document itself
+     * @param archive - document source archive for resolving any appData refs
+     * @return
+     */
+  public static boolean reportProvenance(Provenance p, PrintStream outstr) {
+    if (p==null) {
+      outstr.println("No Provenance");
+      return false;
+    }
+    Entry[] pe = p.getEntry();
+    for (int i=0; i<pe.length; i++)
+      outstr.println(pe[i].getDate()+"\t'"+pe[i].getUser()+"'\t"+pe[i].getApp()+"\t'"+pe[i].getAction()+"'");
+    return true;
+  }
+  public static boolean appDataEntryReport(AppData appD, VamsasArchiveReader archive, boolean cascade, PrintStream outstr) {
+    if (appD!=null) {
+      boolean nulldata=false;
+      if (appD.getDataReference()!=null) {
+        String appData=appD.getDataReference();
+        if (appData==null) { outstr.println("Empty DataReference - not valid ?"); } 
+        else 
+          if (appData.length()>1) {
+          outstr.print("a reference ("+appData+")");
+          InputStream jstrm;
+          if ((jstrm=archive.getAppdataStream(appData))!=null)
+            outstr.println(" which resolves to a JarEntry.");
+          else {
+            outstr.println(" which does not resolve to a JarEntry.");
+            outstr.println("Unresolved appdata reference '"+appData+"'");
+          }
+        } else {
+          nulldata=true;
+        }
+      } else {
+        if (appD.getData()==null)
+          nulldata &= true;
+          else
+          outstr.println("an embedded chunk of "+appD.getData().length+" bytes.");
+      }
+      if (nulldata)
+        outstr.println("Null AppData reference/data chunk.");
+    }
+    return true;
+  }
+  
+  public static boolean appDataReport(ApplicationData appD, VamsasArchiveReader archive, boolean cascade, PrintStream outstr) {
+    if (appD!=null) {
+      // Report on root appData
+      appDataEntryReport(appD, archive, cascade, outstr);
+      if (appD.getInstanceCount()>0) {
+        Instance inst[] = appD.getInstance();
+        for (int i=0,j=inst.hashCode(); i<j; i++) {
+          outstr.println("Data for App Instance URN: '"+inst[i].getUrn());
+          appDataEntryReport(inst[i],archive,cascade,outstr);
+        }
+      }
+      if (appD.getUserCount()>0) {
+        User users[] = appD.getUser();
+        for (int i=0,j=users.length; i<j; i++) {
+          outstr.println("Data for User '"+users[i].getFullname()+"' of '"+users[i].getOrganization()+"'");
+          appDataEntryReport(users[i], archive, cascade, outstr);
+        }
+      }
+    }
+
+    return true;
+  }
+  public static boolean reportDocument(VamsasDocument document, VamsasArchiveReader archive, boolean cascade, PrintStream outstr) {
+    if (document!=null) {
+      outstr.println("Vamsas Document version '"+document.getVersion()+"'");
+      reportProvenance(document.getProvenance(), outstr);
+      outstr.print("Document contains "+document.getVAMSASCount()+" VAMSAS Elements and "+document.getApplicationDataCount()+" Application data elements.\n");
+      if (document.getVAMSASCount()>0 && cascade)
+        rootReport(document.getVAMSAS(), true, outstr);
+      if (document.getApplicationDataCount()>0) {
+        outstr.print("There are "+document.getApplicationDataCount()+" ApplicationData references.\n");
+        ApplicationData appd[] = document.getApplicationData();
+        for (int i=0,j=appd.length; i<j; i++) {
+          outstr.print("Application "+i+": '"+appd[i].getName()+"'\nVersion '"+appd[i].getVersion()+"'\n");
+          outstr.print("AppData is :");
+          appDataReport(appd[i], archive, cascade, outstr);
+        }
+          
+      }
+      return true;
+    } else {
+      outstr.println("Document Object is null");
+    }
+    return false;
+  }
+
+  /**
+   * summarises all the datasets in a vamsas document.
+   * @param roots
+   * @param cascade TODO
+   * @param outstr TODO
+   * @return
+   */
+  public static boolean rootReport(VAMSAS[] roots, boolean cascade, PrintStream outstr) {
+    if (roots!=null) {
+      for (int i=0; i<roots.length; i++) {
+        VAMSAS r = roots[i];
+        int ds, tr;
+        outstr.print("Vamsas Root "+i+" (id="
+            +((r.getId()!=null) ? r.getId():"<none>")
+            +") contains "+(ds=r.getDataSetCount())+" DataSets, "
+            + (tr=r.getTreeCount())+" Global trees\n");
+        if (cascade) {
+          for (int j=0; j<ds; j++) {
+            outstr.println("Dataset "+j);
+            cascade = datasetReport(r.getDataSet(j), true, outstr) && cascade ;
+          }
+          for (int j=0; j<tr; j++) {
+            outstr.println("Global tree "+j);
+            cascade = treeReport(r.getTree(j), true, outstr) && cascade;
+          }
+        }
+      }
+      return true;
+    }
+    return false;
+  }
+  public static boolean datasetReport(DataSet ds, boolean cascade, PrintStream outstr) {
+    if (cascade)
+      reportProvenance(ds.getProvenance(), outstr);
+    outstr.println("Dataset contains : "+ds.getSequenceCount()
+        +" sequences, "+ds.getAlignmentCount()+" alignments and "+ds.getTreeCount()+" trees.");
+    if (cascade)
+      alignmentReport(ds.getAlignment(), true, outstr);
+    return true;
+  }
+  public static boolean alignmentReport(Alignment[] al, boolean cascade, PrintStream outstr) {
+    boolean val=true;
+    if (al!=null && al.length>0) {
+      for (int i=0; i<al.length; i++) {
+        outstr.println("Alignment "+i+(al[i].isRegistered() ? " ("+al[i].getVorbaId()+")" : " (unregistered)"));
+        if (cascade)
+          reportProvenance(al[i].getProvenance(), outstr);
+        outstr.println("Involves "+al[i].getAlignmentSequenceCount()+" sequences, has "
+            +al[i].getAlignmentAnnotationCount()+" annotations and "+al[i].getTreeCount()+" trees.");
+        if (cascade) {
+          for (int t=0; t<al[i].getTreeCount(); t++)
+            treeReport(al[i].getTree(t), true, outstr);
+        }
+      }
+    }
+    return val;
+  }
+  public static boolean treeReport(Tree t, boolean cascade, PrintStream outstr) {
+    outstr.println("Tree: '"+t.getTitle()+"'");
+    return !cascade || reportProvenance(t.getProvenance(), outstr);
+  }
+
+}
diff --git a/src/uk/ac/vamsas/test/simpleclient/ArchiveStreamReader.java b/src/uk/ac/vamsas/test/simpleclient/ArchiveStreamReader.java
new file mode 100644
index 0000000..d3fe14f
--- /dev/null
+++ b/src/uk/ac/vamsas/test/simpleclient/ArchiveStreamReader.java
@@ -0,0 +1,53 @@
+package uk.ac.vamsas.test.simpleclient;
+
+import java.io.BufferedInputStream;
+import java.io.File;
+import java.io.InputStream;
+import java.io.InputStreamReader;
+
+
+import uk.ac.vamsas.client.simpleclient.SessionFile;
+import uk.ac.vamsas.client.simpleclient.VamsasArchiveReader;
+import uk.ac.vamsas.client.simpleclient.VamsasFile;
+import uk.ac.vamsas.objects.core.VAMSAS;
+import uk.ac.vamsas.objects.core.VamsasDocument;
+
+public class ArchiveStreamReader {
+  /**
+   * tests VamsasArchiveReader archive reader on a vamsas jar file opened as a stream
+   * @param args
+   */
+  public static void main(String args[]) {
+    
+    try {
+      VamsasFile av = new VamsasFile(new File(args[0]));
+      VamsasArchiveReader var = new VamsasArchiveReader(av.getLock());
+      VAMSAS roots[]=null;
+      if (var.isValid()) {
+        InputStreamReader vdoc = new InputStreamReader(var.getVamsasDocumentStream());
+        VamsasDocument doc = VamsasDocument.unmarshal(vdoc);
+        if (ArchiveReports.reportDocument(doc, var, true, System.out)) {
+          roots = doc.getVAMSAS();
+        }
+      } else {
+        InputStream vxmlis = var.getVamsasXmlStream();
+        
+        if (vxmlis!=null) { // Might be an old vamsas file.
+          BufferedInputStream ixml = new BufferedInputStream(var.getVamsasXmlStream());
+          InputStreamReader vxml = new InputStreamReader(ixml);
+          VAMSAS root;
+          // unmarshal seems to always close the stream (should check this)
+          if ((root = VAMSAS.unmarshal(vxml))!=null) {
+            System.out.println("Read a root.");
+            roots = new VAMSAS[1];
+            roots[0] = root;
+          }
+        }
+      }
+      if (!ArchiveReports.rootReport(roots, true, System.out))
+        System.err.print(args[0]+" is not a valid vamsas archive.");
+    } catch (Exception e) {
+      e.printStackTrace(System.err);
+    }
+  }
+}
diff --git a/src/uk/ac/vamsas/test/simpleclient/ArchiveWatcher.java b/src/uk/ac/vamsas/test/simpleclient/ArchiveWatcher.java
new file mode 100644
index 0000000..d784a8e
--- /dev/null
+++ b/src/uk/ac/vamsas/test/simpleclient/ArchiveWatcher.java
@@ -0,0 +1,106 @@
+package uk.ac.vamsas.test.simpleclient;
+
+import java.io.File;
+
+import org.apache.commons.logging.Log;
+import org.apache.commons.logging.LogFactory;
+
+import uk.ac.vamsas.client.ClientHandle;
+import uk.ac.vamsas.client.simpleclient.FileWatcher;
+import uk.ac.vamsas.client.simpleclient.Lock;
+import uk.ac.vamsas.client.simpleclient.SimpleDocument;
+import uk.ac.vamsas.client.simpleclient.VamsasArchiveReader;
+import uk.ac.vamsas.client.simpleclient.VamsasFile;
+import uk.ac.vamsas.objects.core.VamsasDocument;
+/**
+ * demo of archive watching process - should mimic the clientsfileTest watcher/monitor process.
+ * @author jimp
+ *
+ */
+public class ArchiveWatcher {
+  private static Log log = LogFactory.getLog(ArchiveWatcher.class);
+  private static CommandProcessor cproc=new CommandProcessor();
+  static {
+    cproc.addCommand("new", 0, "no args");
+    cproc.addCommand("delete", 0, "no args");    
+    cproc.addCommand("watch", 0, "no args");
+    cproc.addCommand("file", 1, "Need vamsas archive as argument.");    
+  }
+  
+  public static void main(String[] args) {
+    try {
+      
+      if (args!=null && args.length>0) {
+        File archive = new File(args[0]);
+        log.info("Watching file "+args[0]);
+        int argc=1;
+        while (argc < args.length) {
+          // vars needed for operations
+          ClientHandle ch;
+          int com = cproc.getCommand(args, argc);
+          argc++;
+          switch (com) {
+          case 0:
+            // new
+            log.info("Doing locked deletion and new-file creation.");
+            {
+              if (!archive.exists())
+                archive.createNewFile();
+              VamsasFile sf = new VamsasFile(archive);
+              Lock l = sf.getLock();
+              archive.delete();
+              archive.createNewFile();
+              sf.unLock();
+            }
+            break;
+          case 1:
+            // delete
+            log.info("Deleting "+archive+" without locking it first.");
+            archive.delete();
+            break;
+          case 2:
+            // watch
+            log.info("Endlessly Watching file "+archive);
+            /*        if (!archive.exists())
+                      archive.createNewFile();
+             */       // watch the new file... - taken straight from ClientsFileTest
+            FileWatcher w = new FileWatcher(archive);
+            while (true) {              
+              // get watcher's lock to ensure state change is fixed for retrieval
+              Lock chlock = w.getChangedState();
+              if (chlock != null) {
+                log.info("Got lock on "+archive+(archive.exists() ? " exists l="+archive.length() : "(non existant)"));
+                if (archive.length()>0) {
+                  VamsasArchiveReader vreader = new VamsasArchiveReader(archive);
+                  SimpleDocument sdoc = new SimpleDocument("testing vamsas watcher");
+                  try {
+                    VamsasDocument d = sdoc.getVamsasDocument(vreader);
+                    if (d!=null) {
+                      ArchiveReports.reportDocument(d, vreader, false, System.out);
+                    }
+                    System.out.println("Update at "+System.currentTimeMillis()+"\n\n********************************************************\n");
+                  } catch (Exception e) {
+                    log.error("Unmarshalling failed.",e);
+                  }
+                  vreader.close();
+                  w.setState();
+                }
+              }
+            }
+            // break;
+          case 3: // set file
+            archive = new File(args[argc++]);
+            break;
+          case 4:
+            break;
+            default:
+              log.warn("Unknown command  + "+args[argc++]);
+          }
+        }
+      }
+    } catch (Exception e) {
+      log.error(e);
+    }
+    
+  }
+}
diff --git a/src/uk/ac/vamsas/test/simpleclient/ArchiveWriter.java b/src/uk/ac/vamsas/test/simpleclient/ArchiveWriter.java
new file mode 100644
index 0000000..528ae46
--- /dev/null
+++ b/src/uk/ac/vamsas/test/simpleclient/ArchiveWriter.java
@@ -0,0 +1,182 @@
+package uk.ac.vamsas.test.simpleclient;
+
+import java.io.File;
+import java.io.InputStream;
+import java.io.InputStreamReader;
+import java.io.PrintWriter;
+import java.text.DateFormat;
+import java.util.Date;
+import java.util.Hashtable;
+import java.util.Vector;
+
+import org.apache.commons.logging.Log;
+import org.apache.commons.logging.LogFactory;
+der;
+import uk.ac.vamsas.objects.core.Alignment;
+import uk.ac.vamsas.objects.core.ApplicationData;
+import uk.ac.vamsas.objects.core.Entry;
+import uk.ac.vamsas.objects.core.Instance;
+import uk.ac.vamsas.objects.core.Provenance;
+import uk.ac.vamsas.objects.core.VAMSAS;
+import uk.ac.vamsas.objects.core.VamsasDocument;
+import uk.ac.vamsas.objects.ut
+import uk.ac.vamsas.client.simpleclient.VamsasArchive;
+import uk.ac.vamsas.client.simpleclient.VamsasArchiveReader;
+ils.ProvenanceStuff;
+
+public class ArchiveWriter {
+  
+  /**
+   * Test program for writing archive files.
+   * form is ArchiveWriter new/modified argive command list
+   */
+  
+  static Log log = LogFactory.getLog(ArchiveWriter.class);
+    
+  private static void mergeVecs(Object[] destvec, Object[] svec1, Object[] svec2) {
+    int i;
+    for (i=0; i<svec1.length; i++)
+      destvec[i] = svec1[i];
+    for (int j=0; j<svec2.length; i++, j++)
+      destvec[i] = svec2[j];
+  }
+  // Merge appDataReferences require transfer of jar entries, perhaps with a renaming of the entry.
+  // Merge appDatas require eventually unique URNS
+  // TODO: merging global appdata from different documents where same app has written them causes conflict
+  
+  public static Hashtable hashOfAppDatas(Hashtable ht, Instance[] appdatas) {
+    if (ht==null)
+      ht = new Hashtable();
+    for (int i=0, j=appdatas.length; i<j; i++) {
+      if (!ht.containsKey(appdatas[i].getUrn())) {
+        Hashtable aphash = new Hashtable();
+        ht.put(appdatas[i].getUrn(), aphash);
+        aphash.put(appdatas[i], appdatas[i].getDataReference());
+      } else {
+        // ensure urns and references are unique
+        
+        
+      }
+          
+    }
+    return ht;
+  }
+  /**
+   * safely copies an appData from one archive to another.
+   * @param darc destination archive
+   * @param dest destination document Vobject
+   * @param sarc source archive reader
+   * @param entry application data to be copied from source archive
+   */
+  public static void addAppDataEntry(VamsasArchive darc, VamsasDocument dest,  VamsasArchiveReader sarc, ApplicationData entry) {
+    // TODO: fix instances
+    // check uniqueness of instance's[] entry.urn amongst dest.ApplicationData[].getInstances[].urn 
+    //  check uniqueness of entry.user[].urn amongst dest.ApplicationData[].user[].urn
+    // check uniqueness of entry.user
+    // entry.getAppDataChoice().getData() or getDataReference is unique
+    ApplicationData newo = new ApplicationData();
+    for (int i=0, j=dest.getApplicationDataCount(); i<j; i++) {
+      ApplicationData o = dest.getApplicationData()[i];
+      // ensure new urn is really unique
+      //String urn = entry.getUrn();
+      int v = 1;
+      //while (o.getUrn().equals(urn)) {
+      //  urn = entry.getUrn()+v++;      
+     // }
+      // uniqueness of urn
+      // check each user ApplicationData
+      // uniqueness (again)
+      // copy over valid objects
+      // 
+    }
+  }
+  /**
+   * Copy new datasets and appdatas from one vamsas document to another.
+   * @param darc
+   * @param dest
+   * @param sarc
+   * @param source
+   * @return true if merge was successful.
+   */
+  public static boolean mergeDocs(VamsasArchive darc, VamsasDocument dest,  VamsasArchiveReader sarc, VamsasDocument source) {
+    log.debug("mergeDocs entered.");
+    // search for appDatas in cdoc
+    VAMSAS[] newr = new VAMSAS[dest.getVAMSASCount()+source.getVAMSASCount()];
+    mergeVecs(newr, dest.getVAMSAS(), source.getVAMSAS());
+    dest.setVAMSAS(newr);
+    /** TODO: LATER: should verify that all ids really are unique in newly merged document. If not then what ?
+     *  investigate possibility of having an id translation between appDatas and the core document - 
+     *  the mapping is stored when an external application performs a merge, but when the owning 
+     *  Application accesses the Vobject, the vorba_id is updated to the new one when it writes its 
+     *  references in to its appdata again
+     */
+    if (source.getApplicationDataCount()>0) {
+      ApplicationData[] newdat = new ApplicationData[source.getApplicationDataCount()+dest.getApplicationDataCount()];
+      ApplicationData[] sappd = source.getApplicationData();
+      // check refs and update/modify if necessary
+      for (int i=0; i<sappd.length; i++) {
+        addAppDataEntry(darc, dest, sarc, sappd[i]);
+      }
+      
+    }
+    
+    return true; // success    
+  }
+  
+  private static CommandProcessor cproc;
+  static {
+    cproc.addCommand("new", 0, "no args");
+    cproc.addCommand("add", 1, "Need another vamsas document archive filename as argument.");    
+    cproc.addCommand("repair", 0, "no args");
+    cproc.addCommand("list", 0, "no args");    
+    cproc.addCommand("monitor", 0, "no args");    
+  }
+  
+  public static void main(String argv[]) {
+    /**
+     * TODO: switches for setting user identities for writing to vamsas document
+     */ 
+    if (argv.length<1) {
+      log.fatal("Usage : <archive to create> [(commands)]");
+      return;
+    }
+    File newarch = new File(argv[0]);
+    int argpos = 0;
+    try {
+      // test fully fledged doc construction
+      VamsasArchive varc = new VamsasArchive(newarch, true);
+      VamsasDocument docroot;
+      docroot = new VamsasDocument();
+      docroot.setProvenance(ProvenanceStuff.newProvenance("ArchiveWriter", "user", "Created new Vamsas Document"));
+      while (++argpos<argv.length) {
+        File archive = new File(argv[argpos]);
+        InputStream istream;
+        if (archive.exists()) {
+          VamsasArchiveReader vdoc = new VamsasArchiveReader(archive);
+          if (vdoc.isValid()) {
+            istream = vdoc.getVamsasDocumentStream(); 
+            if (istream!=null) {
+              VamsasDocument cdocroot = VamsasDocument.unmarshal(new InputStreamReader(istream));
+              if (cdocroot!=null) 
+                mergeDocs(varc, docroot, vdoc, cdocroot);
+            } else 
+              log.warn("Unexpectedly null document stream from existing document "+archive);
+          } else {
+              // updating an oldformat stream ?
+              if ((istream = vdoc.getVamsasXmlStream())!=null) {
+                // make a new vamsas document from the vamsas.xml entry
+                VAMSAS root = VAMSAS.unmarshal(new InputStreamReader(istream)); // TODO: verify only one VAMSAS element per vamsas.xml entry.
+                docroot.getProvenance().addEntry(ProvenanceStuff.newProvenanceEntry("ArchiveWriter", "user", "added vamsas.xml from "+argv[argpos-1]));
+                docroot.addVAMSAS(root);
+              }
+          }
+        } else {
+          // Begin a new vamsas document
+          PrintWriter docwriter = varc.getDocumentOutputStream();
+        }
+      }
+    } catch (Exception e) {
+      log.error("Whilst manipulating "+argv[0], e);
+    }
+  }
+}
diff --git a/src/uk/ac/vamsas/test/simpleclient/ClientDoc.java b/src/uk/ac/vamsas/test/simpleclient/ClientDoc.java
new file mode 100644
index 0000000..990d58a
--- /dev/null
+++ b/src/uk/ac/vamsas/test/simpleclient/ClientDoc.java
@@ -0,0 +1,356 @@
+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.");
+    }
+  }
+  
+}
\ No newline at end of file
diff --git a/src/uk/ac/vamsas/test/simpleclient/ClientsFileTest.java b/src/uk/ac/vamsas/test/simpleclient/ClientsFileTest.java
new file mode 100644
index 0000000..9d76bfb
--- /dev/null
+++ b/src/uk/ac/vamsas/test/simpleclient/ClientsFileTest.java
@@ -0,0 +1,311 @@
+package uk.ac.vamsas.test.simpleclient;
+
+import java.io.File;
+import java.util.Iterator;
+import java.util.Vector;
+
+
+import uk.ac.vamsas.client.ClientHandle;
+import uk.ac.vamsas.client.simpleclient.ClientsFile;
+import uk.ac.vamsas.client.simpleclient.FileWatcher;
+import uk.ac.vamsas.client.simpleclient.Lock;
+
+public class ClientsFileTest {
+  private static CommandProcessor cproc;
+
+  private static Vector commands;
+  static {
+    cproc = new CommandProcessor();
+    ClientsFileTest.commands = new Vector();
+    ClientsFileTest.commands.add(new String("add"));
+    cproc.addCommand("add", 2, "for the Client's 'Name' and 'Version'");
+    ClientsFileTest.commands.add(new String("remove"));
+    cproc.addCommand("remove", 3, "for the Client's 'Name', Version and URN");
+    ClientsFileTest.commands.add(new String("list"));
+    cproc.addCommand("list", 0, "no args needed");
+    ClientsFileTest.commands.add(new String("clear"));
+    cproc.addCommand("clear", 0, "no args needed");
+    ClientsFileTest.commands.add(new String("watch"));
+    cproc.addCommand("watch", 0, "no args needed");
+    ClientsFileTest.commands.add(new String("monitor"));
+    cproc.addCommand("monitor", 2, "for the Client's 'Name' and 'Version'");
+  }
+
+  private static void complainArgs(int argl, int argpos, String cmd,
+      int argneed, String msg) {
+    if (argl - argpos < argneed)
+      throw new Error(cmd + " needs " + argneed + " arguments : " + msg);
+  }
+
+  public static void main(String[] args) {
+    java.io.File cf = new java.io.File(args[0]);
+    System.out.println("Connecting to clientFile " + args[0]);
+    ClientsFile cfhand;
+    try {
+      cfhand = new ClientsFile(cf);
+    } catch (Exception e) {
+      e.printStackTrace(System.err);
+      return;
+    }
+    int argc = 1;
+    while (argc < args.length) {
+      // vars needed for operations
+      ClientHandle ch;
+      int com = cproc.getCommand(args, argc);
+      argc++;
+      switch (com) {
+      case 0:
+        // Add
+        int pos = cfhand.addClient(ch = new ClientHandle(args[argc],
+            args[argc + 1]));
+        argc += 2;
+        if (pos != 0)
+          System.out.println("Client added at " + pos + " as urn:"
+              + ch.getClientUrn());
+        else
+          System.out.println("Client was not added.");
+        break;
+      case 1:
+        // remove
+        ch = new ClientHandle(args[argc], args[argc + 1]);
+        ch.setClientUrn(args[argc + 2]);
+        argc += 3;
+        cfhand.removeClient(ch, null);
+        System.out.println("Client removed (apparently)");
+        break;
+      case 2:
+        // list
+        ClientHandle[] chlist = cfhand.retrieveClientList();
+        if (chlist != null) {
+          for (int chi = 0, che = chlist.length; chi < che; chi++) {
+            System.out.println("Client " + chi + " ("
+                + chlist[chi].getClientName() + " " + chlist[chi].getVersion()
+                + " " + chlist[chi].getClientUrn() + ")");
+          }
+        } else {
+          System.out.println("Client list is empty.");
+        }
+        break;
+      case 3:
+        // clear
+        //cfhand.get = null;
+        //cf.delete();
+        try {
+          
+          cfhand.clearList();
+          
+        } catch (Exception e) {
+          System.err.println("Failed on new empty clientfile creation!");
+          e.printStackTrace(System.err);
+        }
+        break;
+      case 4:
+        // watch
+        FileWatcher w = new FileWatcher(cf);
+        while (cf.exists()) {
+          // get watcher's lock to ensure state change is fixed for retrieval
+          Lock chlock = w.getChangedState();
+          if (chlock != null) {
+            ClientHandle[] cl = cfhand.retrieveClientList(chlock);
+            System.out.println("-- Watching " + cf.getName());
+            //while (w.hasChanged())
+            //  ;
+            if (cl != null) {
+              for (int chi = 0, che = cl.length; chi < che; chi++) {
+                System.out.println("Client " + chi + " ("
+                    + cl[chi].getClientName() + " " + cl[chi].getVersion()
+                    + " " + cl[chi].getClientUrn() + ")");
+              }
+            } else {
+              System.out.println("Client list is empty.");
+            }
+          }
+
+        }
+        break;
+      case 5:
+        // monitor
+        int clpos = cfhand.addClient(ch = new ClientHandle(args[argc],
+            args[argc + 1]));
+        argc += 2;
+        if (clpos != 0)
+          System.out.println("Monitor Client added at " + clpos + " as urn:"
+              + ch.getClientUrn());
+        else {
+          System.err.println("Monitor Client was not added.");
+          break;
+        }
+        FileWatcher mon = new FileWatcher(cf);
+        while (cf.exists()) {
+          // get watcher's lock to ensure state change is fixed for retrieval
+          Lock chlock = mon.getChangedState();
+          if (chlock != null) {
+            ClientHandle[] cl = cfhand.retrieveClientList(chlock);
+            System.out.println("-- Monitor " + cf.getName());
+            //while (w.hasChanged())
+            //  ;
+            int newpos = -1;
+            if (cl != null) {
+              for (int chi = 0, che = cl.length; chi < che; chi++) {
+                if (ch.equals(cl[chi]))
+                  newpos = chi + 1;
+              }
+            }
+            if (newpos == -1) {
+              // add self again to cleared list.
+              newpos = cfhand.addClient(ch);
+              mon.setState();
+              if (newpos == 0) {
+                System.err
+                    .println("Monitor client could not be re-added to list.");
+                break;
+              }
+            }
+            if (newpos != clpos) {
+              System.out.println("Monitor client moved from " + clpos + " to "
+                  + newpos);
+              clpos = newpos;
+            }
+          }
+        }
+        break;
+      default:
+        if (com == -1) {
+          System.err
+              .println("Unknown command : " + args[argc++] + "*Ignored!*");
+        } else
+          System.err.println("Command " + args[argc++]
+              + " *Ignored!* - its not implemented.");
+      }
+      
+      for (int j = 0; j < 900000; j++) {
+        Integer i = Integer.getInteger("1");
+        Integer q = i;
+      }
+    }
+
+  }
+
+  /*      Iterator coms = commands.iterator();
+   int com=-1;
+   while ((coms!=null) && coms.hasNext()) {
+   com++;
+   if (args[argc].toLowerCase().equals((String) coms.next())) {
+   System.out.println("Doing "+args[argc]);
+   ClientHandle ch;
+   argc++;
+   switch (com) {
+   case 0:
+   // Add
+   ClientsFileTest.complainArgs(args.length, argc, "add", 2, "for the Client's 'Name' and 'Version'");
+   int pos = cfhand.addClient(ch=new ClientHandle(args[argc],args[argc+1]));
+   argc+=2;
+   if (pos!=0)
+   System.out.println("Client added at "+pos+" as urn:"+ch.getClientUrn());
+   else
+   System.out.println("Client was not added.");
+   break;
+   case 1:
+   // remove
+   ClientsFileTest.complainArgs(args.length, argc, "remove", 3, "for the Client's 'Name', Version and URN");
+   ch=new ClientHandle(args[argc], args[argc+1]);
+   ch.setClientUrn(args[argc+2]);
+   argc+=3;
+   cfhand.removeClient(ch, null);
+   System.out.println("Client removed (apparently)");
+   break;
+   case 2:
+   // list
+   ClientHandle[] chlist = cfhand.retrieveClientList();
+   if (chlist!=null) {
+   for (int chi=0,che=chlist.length; chi<che; chi++) {
+   System.out.println("Client "+chi+" ("+chlist[chi].getClientName()+" "+chlist[chi].getVersion()+" "+chlist[chi].getClientUrn()+")");
+   }
+   } else {
+   System.out.println("Client list is empty.");
+   }
+   break;
+   case 3:
+   // clear
+   cfhand = null;
+   cf.delete();
+   try {
+   cf.createNewFile();
+   cfhand = new ClientsFile(cf);
+   }
+   catch (Exception e) {
+   System.err.println("Failed on new empty clientfile creation!");
+   e.printStackTrace(System.err);
+   }
+   break;
+   case 4:
+   // watch
+   FileWatcher w=new FileWatcher(cf);
+   while (cf.exists()) {
+   // get watcher's lock to ensure state change is fixed for retrieval
+   Lock chlock=w.getChangedState();
+   if (chlock!=null) {
+   ClientHandle[] cl = cfhand.retrieveClientList(chlock);
+   System.out.println("-- Watching "+cf.getName());
+   //while (w.hasChanged())
+   //  ;
+   if (cl!=null) {
+   for (int chi=0,che=cl.length; chi<che; chi++) {
+   System.out.println("Client "+chi+" ("+cl[chi].getClientName()+" "+cl[chi].getVersion()+" "+cl[chi].getClientUrn()+")");
+   }
+   } else {
+   System.out.println("Client list is empty.");
+   }
+   }
+   
+   }
+   break;
+   case 5:
+   // monitor
+   ClientsFileTest.complainArgs(args.length, argc, "monitor", 2, "for the Client's 'Name' and 'Version'");
+   int clpos = cfhand.addClient(ch=new ClientHandle(args[argc],args[argc+1]));
+   argc+=2;
+   if (clpos!=0)
+   System.out.println("Monitor Client added at "+clpos+" as urn:"+ch.getClientUrn());
+   else {
+   System.err.println("Monitor Client was not added.");
+   break;
+   }
+   FileWatcher mon=new FileWatcher(cf);
+   while (cf.exists()) {
+   // get watcher's lock to ensure state change is fixed for retrieval
+   Lock chlock=mon.getChangedState();
+   if (chlock!=null) {
+   ClientHandle[] cl = cfhand.retrieveClientList(chlock);
+   System.out.println("-- Monitor "+cf.getName());
+   //while (w.hasChanged())
+   //  ;
+   int newpos=-1;
+   if (cl!=null) {
+   for (int chi=0,che=cl.length; chi<che; chi++) {
+   if (ch.equals(cl[chi]))
+   newpos=chi+1;
+   }
+   }
+   if (newpos==-1) {
+   // add self again to cleared list.
+   newpos=cfhand.addClient(ch);
+   mon.setState();
+   if (newpos==0) {
+   System.err.println("Monitor client could not be re-added to list.");
+   break;
+   }
+   }
+   if (newpos!=clpos) {
+   System.out.println("Monitor client moved from "+clpos+" to "+newpos);
+   clpos=newpos;
+   }
+   }
+   }
+   
+   }
+   coms = null;
+   }
+   } */
+
+}
diff --git a/src/uk/ac/vamsas/test/simpleclient/CommandProcessor.java b/src/uk/ac/vamsas/test/simpleclient/CommandProcessor.java
new file mode 100644
index 0000000..3b53068
--- /dev/null
+++ b/src/uk/ac/vamsas/test/simpleclient/CommandProcessor.java
@@ -0,0 +1,65 @@
+package uk.ac.vamsas.test.simpleclient;
+
+import java.util.Iterator;
+import java.util.Vector;
+
+public class CommandProcessor {
+  /**
+   * this is not getOPT!!!! - processes a *series* of space separated commands - some of which take arguments.
+   */
+  private Vector commands;
+  /* static {
+    ClientsFileTest.commands=new Vector();
+    ClientsFileTest.commands.add(new String("add"));
+    ClientsFileTest.commands.add(new String("remove"));
+    ClientsFileTest.commands.add(new String("list"));    
+    ClientsFileTest.commands.add(new String("clear"));
+    ClientsFileTest.commands.add(new String("watch"));    
+    ClientsFileTest.commands.add(new String("monitor"));    
+  } */
+
+  public int addCommand(String cmd, int argneed, String complainString) {
+    int cnum=0;
+    if (commands==null)
+      commands = new Vector();
+    else 
+      cnum = commands.size();
+    Vector cv = new Vector();
+    cv.add(new String(cmd));
+    cv.add(new Integer(argneed));
+    cv.add(new String(complainString));
+    commands.add(cv);
+    return cnum;
+  }
+ 
+  /**
+   * Integer argl, Integer argpos, String cmd, Integer argneed, String msg in vector
+   */
+  public void complainArgs(int argl, int argpos, Vector ca) {
+    int argneed = ((Integer) ca.get(1)).intValue();
+    if (argl-argpos<argneed)
+      throw new Error(((String) ca.get(0))+" at position "+argpos+" needs "+argneed+" arguments : "+(String) ca.get(2));
+  }
+  /**
+   * find and verify a command
+   * @param args argstring
+   * @param argpos position to check for command
+   * @return matching command or -1
+   */
+  public int getCommand(String[]args, int argpos) {
+    Iterator coms = commands.iterator();
+    int com=-1, argc;
+    argc=argpos;
+    while ((coms!=null) && coms.hasNext()) {
+      com++;
+      Vector comnext = (Vector) coms.next();
+      if (args[argc].toLowerCase().equals((String) comnext.get(0))) {
+        if (comnext.size()>2)
+          complainArgs(args.length, argc+1, comnext);
+        return com;
+      }
+    }
+    return -1;
+        
+  }
+}
diff --git a/src/uk/ac/vamsas/test/simpleclient/VamsasArchive.java b/src/uk/ac/vamsas/test/simpleclient/VamsasArchive.java
new file mode 100644
index 0000000..d682f10
--- /dev/null
+++ b/src/uk/ac/vamsas/test/simpleclient/VamsasArchive.java
@@ -0,0 +1,206 @@
+package uk.ac.vamsas.test.simpleclient;
+
+import java.io.File;
+import java.io.ObjectOutputStream;
+
+import org.apache.commons.logging.Log;
+import org.apache.commons.logging.LogFactory;
+import org.vamsas.test.objects.Core;
+
+import uk.ac.vamsas.client.simpleclient.Lock;
+import uk.ac.vamsas.client.simpleclient.SessionFile;
+import uk.ac.vamsas.client.simpleclient.SimpleDocument;
+import uk.ac.vamsas.client.simpleclient.VamsasArchiveReader;
+import uk.ac.vamsas.client.simpleclient.VamsasFile;
+import uk.ac.vamsas.objects.core.ApplicationData;
+import uk.ac.vamsas.objects.core.User;
+import uk.ac.vamsas.objects.core.VAMSAS;
+import uk.ac.vamsas.objects.core.VamsasDocument;
+
+public class VamsasArchive {
+  /**
+   * test the org.vamsas.simpleclient.vamsasArchive class
+   */
+  static Log log = LogFactory.getLog(VamsasArchive.class);
+  public static ApplicationData makeDemoAppdata(uk.ac.vamsas.client.simpleclient.VamsasArchive va, String apname, String userName, String userOrg) {
+    if (va==null)
+      return null;
+    VamsasArchiveReader vread=null;
+    try {
+      vread = va.getOriginalArchiveReader();
+    }
+    catch (Exception e) {
+      log.error("Failed to get original archive reader!",e);
+      return null;
+    }
+    ApplicationData appdata = new ApplicationData();
+    appdata.setName("uk.ac.vamsas.test.simpleclient.VamsasArchive");
+    appdata.setData(new String("this is some test data.").getBytes());
+    User apuser = new User();
+    apuser.setFullname(userName);
+    apuser.setOrganization(userOrg);
+    String appdata_ref = "vamsas:"+apname+"/"+apuser.getOrganization()+"/"+apuser.getFullname();
+    SimpleDocument sdoc = new SimpleDocument("test.simpleclient.VamsasArchive");
+    if (vread!=null) {
+      VamsasDocument orignalnew;
+      try {
+        orignalnew = sdoc.getVamsasDocument(vread);
+        log.info("*** Dump follows ***");
+        
+        ArchiveReports.reportDocument(orignalnew, vread, false, System.out);
+        log.info("*** Dump precedes ***");
+      } catch (Exception e) {
+        log.info("makeDemoAppdata: Problems accessing original document");
+      }
+      
+      log.info("Reading (and avoiding references to) original data");
+      if (vread.getAppdataStream(appdata_ref)!=null) {
+        // transfer over
+        try {
+          va.transferAppDataEntry(appdata_ref);
+        } catch (Exception e) {
+          log.warn("Exception when transferring appdata reference : "+appdata_ref, e);
+        }
+        int i=0;
+        while (vread.getAppdataStream(appdata_ref+"/"+Integer.toString(++i))!=null) {
+          try {
+            // copy over another duplicate.
+            va.transferAppDataEntry(appdata_ref+"/"+Integer.toString(i));
+          } catch (Exception e) {
+            log.warn("Exception when transferring appdata reference : "+appdata_ref, e);
+          }
+        }
+        // this one must be unique!
+        appdata_ref+="/"+Integer.toString(i);
+      }
+    }
+    
+    log.info("Adding new data stuff.");
+    log.info("Writing an apdata reference using AppDataStream interface.");
+    apuser.setDataReference(appdata_ref);
+    appdata.addUser(apuser);
+    appdata.setVersion("noggin");
+    //TODO: write instance appdata  appdata.setUrn("program:/the.nog/");
+    try {
+      ObjectOutputStream ost = new ObjectOutputStream(va.getAppDataStream(appdata_ref));
+      ost.writeObject(appdata);
+      ost.close();
+    } catch (Exception e) {
+      log.warn("Couldn't write appdata reference "+appdata_ref);
+    }
+    return appdata;
+  }
+  public static void main(String args[]) {
+    
+    try {
+      File av;
+      if (args.length>0)
+        av = new File(args[0]);
+      else
+        av = new File("test/vamsas.zip");
+      log.info("Opening archive "+av);
+      uk.ac.vamsas.client.simpleclient.VamsasArchive varchive = new uk.ac.vamsas.client.simpleclient.VamsasArchive(av, true);
+      
+      VAMSAS[] roots = (VAMSAS[]) varchive.getOriginalRoots();
+      
+      if (roots!=null) {
+        log.info("Report on Original roots in archive:");
+        ArchiveReports.rootReport(roots, true, System.out);
+      }
+      log.info("Getting current vamsas document.");
+      VamsasDocument doc = varchive.getVamsasDocument();
+      ArchiveReports.reportDocument(doc, varchive.getOriginalArchiveReader(), true, System.out); // not modified document so references will still be valid
+      // do some stuff
+      log.info("Retrieving backup");
+      File backup = varchive.backupFile();
+      if (backup==null)
+        log.info(av+" is a New Archive.");
+      else 
+        log.info(av+" has been backed up as "+backup);
+      File newf=new File(av.getAbsolutePath()+"_new.zip");
+      VamsasFile sfile = new VamsasFile(newf);
+      /* if (newf.exists()) {
+        int q=1;
+        do {
+          newf=new File(av.getAbsolutePath()+"_"+q+++"_new.zip");
+        }
+        while (newf.exists()); 
+      } */
+      if (newf.exists()) {
+        log.info("Removing existing "+newf);
+        newf.delete();
+      }
+        
+      log.info("Now writing new Archive into "+newf.getAbsolutePath());
+      uk.ac.vamsas.client.simpleclient.VamsasArchive va=null;
+      { // hold lock over deletion and write of new archive.
+        //Lock wlock = sfile.getLock();
+        //newf.delete(); // clear out old file.
+        sfile.getLock();
+        va = new uk.ac.vamsas.client.simpleclient.VamsasArchive(newf, true, true, sfile);
+        // open another and...
+        ApplicationData appdata = makeDemoAppdata(va, 
+            "uk.ac.vamsas.test.simpleclient.VamsasArchive", "arnold Bugger esq", "disOrganised");
+        log.info("Preparing to write new document.");
+        doc.addApplicationData(appdata);
+        doc.addVAMSAS(Core.getDemoVamsas());
+        va.putVamsasDocument(doc); // gets stream and puts it.
+        va.closeArchive();
+        sfile.unLock();
+      }
+      log.info("Dump of new vamsas document :");
+      log.info("Testing update: ");
+      {
+        Lock lock=sfile.getLock();
+        if (lock==null)
+          while ((lock=sfile.getLock())==null) {
+            log.info("Waiting for lock.");
+            Thread.sleep(100);
+          }
+        VamsasArchiveReader vreader = new VamsasArchiveReader(sfile.getVamsasFile());// lock); // cannot do new JarFile on a locked file. // newf);
+        SimpleDocument sdoc = new SimpleDocument("testing new vamsas write");
+        ArchiveReports.reportDocument(sdoc.getVamsasDocument(vreader), vreader, true, System.out);
+        sfile.unLock();
+      }
+      // backup.delete(); // tidy up
+      
+      log.info("Now Cancelling write to original archive "+av);
+      if (varchive.cancelArchive())
+        log.info("Successfully cancelled.");
+      else
+        log.info("Didn't cancel.");
+      long t=System.currentTimeMillis()+200; while (t>System.currentTimeMillis());
+      log.info("Now testing archive update.");
+      va = new uk.ac.vamsas.client.simpleclient.VamsasArchive(newf, false, true, sfile);
+      doc = va.getVamsasDocument();
+      doc.addVAMSAS(Core.getDemoVamsas());
+      doc.addApplicationData(makeDemoAppdata(va, 
+          "uk.ac.vamsas.test.simpleclient.VamsasArchive", "another old Bugger esq", "rescinded"));
+      if (va.transferRemainingAppDatas())
+        log.info("Remain appdatas were transferred.");
+      else
+        log.warn("No appdatas were transferred. This is wrong.");
+      va.putVamsasDocument(doc);
+      va.closeArchive();
+      sfile.unLock();
+      log.info("Testing update: ");
+      {
+        Lock lock=sfile.getLock();
+        if (lock==null)
+          while ((lock=sfile.getLock())==null)
+            log.info("Waiting for lock.");
+        // VamsasArchiveReader vreader = new VamsasArchiveReader(lock);
+        VamsasArchiveReader vreader = new VamsasArchiveReader(newf);
+        
+        SimpleDocument sdoc = new SimpleDocument("testing vamsas update");
+        VamsasDocument finaldoc = sdoc.getVamsasDocument(vreader);
+        if (finaldoc!=null)
+          ArchiveReports.reportDocument(finaldoc, vreader, true, System.out);
+        else 
+          log.error("Null Document Read from "+newf);
+      }
+    } catch (Exception e) {
+      e.printStackTrace(System.err);
+    }
+  }
+}
diff --git a/src/uk/ac/vamsas/test/simpleclient/simpleapp/VamsasClient.java b/src/uk/ac/vamsas/test/simpleclient/simpleapp/VamsasClient.java
index a5c37e8..860f3af 100644
--- a/src/uk/ac/vamsas/test/simpleclient/simpleapp/VamsasClient.java
+++ b/src/uk/ac/vamsas/test/simpleclient/simpleapp/VamsasClient.java
@@ -14,8 +14,6 @@ import java.util.jar.JarOutputStream;
 
 import javax.swing.JInternalFrame;
 
-import org.vamsas.test.simpleclient.ArchiveClient;
-import org.vamsas.test.simpleclient.ClientDoc;
 
 import uk.ac.vamsas.client.UserHandle;
 import uk.ac.vamsas.client.simpleclient.FileWatcher;
@@ -23,6 +21,8 @@ import uk.ac.vamsas.client.simpleclient.VamsasArchive;
 import uk.ac.vamsas.client.simpleclient.VamsasFile;
 import uk.ac.vamsas.objects.core.Entry;
 import uk.ac.vamsas.objects.core.VamsasDocument;
+import uk.ac.vamsas.test.simpleclient.ArchiveClient;
+import uk.ac.vamsas.test.simpleclient.ClientDoc;
 
 /**
  * @author jimp
diff --git a/src/uk/ac/vamsas/test/simpleclient/simpleapp/VamsasDatastore.java b/src/uk/ac/vamsas/test/simpleclient/simpleapp/VamsasDatastore.java
index aa2081f..7d74186 100644
--- a/src/uk/ac/vamsas/test/simpleclient/simpleapp/VamsasDatastore.java
+++ b/src/uk/ac/vamsas/test/simpleclient/simpleapp/VamsasDatastore.java
@@ -19,7 +19,6 @@
 
 package uk.ac.vamsas.test.simpleclient.simpleapp;
 
-import org.vamsas.test.simpleclient.ClientDoc;
 
 
 import java.io.*;
@@ -36,6 +35,7 @@ import uk.ac.vamsas.client.Vobject;
 import uk.ac.vamsas.client.VorbaId;
 import uk.ac.vamsas.objects.core.*;
 import uk.ac.vamsas.objects.utils.DocumentStuff;
+import uk.ac.vamsas.test.simpleclient.ClientDoc;
 
 /*
  *