Question

Say, for example, I have a complex dynamically allocated structure (such as a binary tree) that needs to be written to a file made up of different sections. I would like to first write the size of the structure as a dword followed by the structure itself, however the size of the structure is only known after I have written the structure to the file. It is difficult, in this case, to pre-determine the size of the structure in memory.

Is it best to write the size as 0, then write the structure, then seek back and overwrite the size with the correct value? I don’t like that idea, though. Is there a better/proper way to do it?

Answer 1

Just an idea: write the data to a ByteArrayOutputStream, after that, you should be able to call size() to get the actual length in bytes and call toByteArray() to get the byte buffer, that can be written to a file.

---

Code example

public static void main (String[] args) throws java.lang.Exception {
  ArrayList objects = new ArrayList();
  objects.add("Hello World");
  objects.add(new Double(42.0));
  System.out.println(sizeof(objects));               
}

public static int sizeof(Serializable object) {
  ObjectOutputStream out = null;
  ByteArrayOutputStream baos = null;
  try {
    baos = new ByteArrayOutputStream();
    out = new ObjectOutputStream(baos);
    out.writeObject(object);
  } catch (Exception e) {
    e.printStackTrace();
  } finally {
    if (out != null) {
      try {
        out.close();
      } catch (Exception e) {
        e.printStackTrace();
      }
    }
  }

  return baos != null? baos.size() : -1;
}

This just demonstrate a sizeof emulator (which is different from the c implementation, because it calculates the size of a serialized object – the implementation for raw bytes would be slightly different).