Пример #1
0
 /**
  * Convert an MVD to a string
  *
  * @param mvd the MVD to convert
  * @param rb database properties file
  * @param folderId id of the folder to contain it in
  * @throws Exception raised if an error occurred
  */
 public static String externalise(MVD mvd) throws Exception {
   int size = mvd.dataSize();
   byte[] data = new byte[size];
   int nBytes = mvd.serialise(data);
   assert nBytes == size : "MVD shorter than predicted";
   return Base64.encodeBytes(data, Base64.GZIP);
 }
Пример #2
0
 /**
  * Save an MVD to a file
  *
  * @param mvd the MVD to save
  * @param dst the file to save it to
  * @param rb database properties file
  * @param folderId id of the folder to contain it in
  * @throws Exception raised if an error occurred
  */
 public static void externalise(MVD mvd, File dst, int folderId, Properties rb) throws Exception {
   long start = System.nanoTime() / 1000;
   System.gc();
   long startMem = Runtime.getRuntime().freeMemory();
   int size = mvd.dataSize();
   byte[] data = new byte[size];
   int nBytes = mvd.serialise(data);
   assert nBytes == size : "MVD shorter than predicted";
   String str = Base64.encodeBytes(data, Base64.GZIP);
   if (rb == null) writeToFile(dst, str);
   else writeToDatabase(dst.getName(), str, mvd.description, folderId, rb);
   long end = System.nanoTime() / 1000;
   long endMem = Runtime.getRuntime().freeMemory();
   System.out.println("internalise took " + (end - start) + " microseconds");
   System.out.println("Memory used " + (startMem - endMem) + " bytes");
 }
Пример #3
0
 /**
  * Read the version table for an MVD from a byte array
  *
  * @param data the byte array containing the version definitions
  * @param p the start offset of the versions within data
  * @param mvd an mvd to add the version definitions to
  */
 private static void readVersionTable(byte[] data, int p, MVD mvd) throws Exception {
   short nVersions = readShort(data, p);
   p += 2;
   if (nVersions < 0) throw new MVDException("Invalid number of versions: " + nVersions);
   short setSize = readShort(data, p);
   p += 2;
   mvd.setVersionSetSize(setSize);
   for (short i = 0; i < nVersions; i++) {
     short group = readShort(data, p);
     p += 2;
     short backup = readShort(data, p);
     p += 2;
     short len = readShort(data, p);
     String shortName = readUtf8String(data, p);
     p += 2 + len;
     len = readShort(data, p);
     String longName = readUtf8String(data, p);
     p += 2 + len;
     mvd.addVersion(new Version(group, backup, shortName, longName));
   }
 }
Пример #4
0
 /**
  * Read the group table for an MVD from a byte array
  *
  * @param data the byte array containing the group definitions
  * @param p the start offset of the groups within data
  * @param mvd an mvd to add the group definitions to
  */
 private static void readGroupTable(byte[] data, int p, MVD mvd) throws Exception {
   short nGroups = readShort(data, p);
   p += 2;
   if (nGroups < 0) throw new MVDException("Invalid number of groups: " + nGroups);
   for (short i = 0; i < nGroups; i++) {
     short parent = readShort(data, p);
     p += 2;
     short len = readShort(data, p);
     String name = readUtf8String(data, p);
     p += 2 + len;
     mvd.addGroup(new Group(parent, name));
   }
 }
Пример #5
0
 /**
  * Read the pairs table for an MVD from a byte array
  *
  * @param data the byte array containing the version definitions
  * @param p the start offset of the versions within data
  * @param dataTableOffset offset within data of the pairs data
  * @param mvd an mvd to add the version definitions to
  */
 private static void readPairsTable(byte[] data, int p, int dataTableOffset, MVD mvd)
     throws Exception {
   // record any pairs declaring themselves as parents
   HashMap<Integer, Pair> parents = new HashMap<Integer, Pair>();
   HashMap<Integer, LinkedList<Pair>> orphans = new HashMap<Integer, LinkedList<Pair>>();
   int nPairs = readInt(data, p);
   p += 4;
   if (nPairs < 0) throw new MVDException("Invalid number of pairs: " + nPairs);
   for (int i = 0; i < nPairs; i++) {
     byte[] copy;
     Pair pair;
     BitSet versions = readVersionSet(mvd.versionSetSize, data, p);
     p += mvd.versionSetSize;
     int offset = readInt(data, p);
     p += 4;
     int len = readInt(data, p);
     int flag = len & Pair.TRANSPOSE_MASK;
     // clear top two bits
     len &= Pair.INVERSE_MASK;
     p += 4;
     if (flag == Pair.PARENT_FLAG) {
       // read special parent id field
       int pId = readInt(data, p);
       p += 4;
       // transpose parent
       copy = copyData(len, dataTableOffset + offset, data);
       pair = new Pair(versions, toChars(copy, mvd.encoding));
       Integer key = new Integer(pId);
       // check for orphans of this parent
       LinkedList<Pair> children = orphans.get(key);
       if (children != null) {
         ListIterator<Pair> iter = children.listIterator();
         // match them up with this parent
         while (iter.hasNext()) {
           Pair child = iter.next();
           child.setParent(pair);
           pair.addChild(child);
         }
         // now they're not orphans any more
         orphans.remove(key);
       }
       // always do this in case more children turn up
       parents.put(key, pair);
     } else if (flag == Pair.CHILD_FLAG) {
       // read special parent id field
       int pId = readInt(data, p);
       p += 4;
       // transpose child
       Integer key = new Integer(pId);
       Pair parent = parents.get(key);
       if (parent == null) {
         LinkedList<Pair> children = orphans.get(key);
         if (children == null) {
           children = new LinkedList<Pair>();
           orphans.put(key, children);
         }
         pair = new Pair(versions, null);
         children.add(pair);
       } else // parent available
       {
         pair = new Pair(versions, null);
         pair.setParent(parent);
         parent.addChild(pair);
       }
     } else {
       // no transposition
       copy = copyData(len, dataTableOffset + offset, data);
       pair = new Pair(versions, toChars(copy, mvd.encoding));
     }
     mvd.addPair(pair);
   }
 }