bundles/org.simantics.db.common/src/org/simantics/db/common/ByteFileWriter.java

   1 package org.simantics.db.common;\r
   2 \r
   3 import java.io.File;\r
   4 import java.io.FileNotFoundException;\r
   5 import java.io.FileOutputStream;\r
   6 import java.io.IOException;\r
   7 import java.nio.ByteBuffer;\r
   8 import java.nio.channels.FileChannel;\r
   9 \r
  10 import org.simantics.db.common.utils.Logger;\r
  11 \r
  12 final public class ByteFileWriter {\r
  13 \r
  14         public static int BUFFER = 65536;\r
  15 \r
  16     private FileChannel channel;\r
  17     private FileOutputStream out;\r
  18     \r
  19     byte[] bytes = new byte[BUFFER];\r
  20     ByteBuffer bb = ByteBuffer.wrap(bytes);\r
  21     int byteIndex = 0;\r
  22     \r
  23     public ByteFileWriter(File file) throws FileNotFoundException {\r
  24         out = new FileOutputStream(file);\r
  25                 channel = out.getChannel();\r
  26     }\r
  27         \r
  28     public void write(short s) {\r
  29 //      System.err.println("write " + s);\r
  30         if(byteIndex < (BUFFER-2)) {\r
  31                 bytes[byteIndex++] = (byte)(s&0xff);\r
  32                 bytes[byteIndex++] = (byte)((s>>>8)&0xff);\r
  33         } else {\r
  34                 int has = BUFFER-byteIndex;\r
  35                 if(has == 0) writeReset(BUFFER);\r
  36                 bytes[byteIndex++] = (byte)(s&0xff);\r
  37                 if(has == 1) writeReset(BUFFER);\r
  38                 bytes[byteIndex++] = (byte)((s>>>8)&0xff);\r
  39                 if(has == 2) writeReset(BUFFER);\r
  40         }\r
  41     }\r
  42 \r
  43     public void write(int i) {\r
  44 //      System.err.println("write " + i);\r
  45         if(byteIndex < (BUFFER-4)) {\r
  46                 bytes[byteIndex++] = (byte)(i&0xff);\r
  47                 bytes[byteIndex++] = (byte)((i>>>8)&0xff);\r
  48                 bytes[byteIndex++] = (byte)((i>>>16)&0xff);\r
  49                 bytes[byteIndex++] = (byte)((i>>>24)&0xff);\r
  50         } else {\r
  51                 int has = BUFFER-byteIndex;\r
  52                 if(has == 0) writeReset(BUFFER);\r
  53                 bytes[byteIndex++] = (byte)(i&0xff);\r
  54                 if(has == 1) writeReset(BUFFER);\r
  55                 bytes[byteIndex++] = (byte)((i>>>8)&0xff);\r
  56                 if(has == 2) writeReset(BUFFER);\r
  57                 bytes[byteIndex++] = (byte)((i>>>16)&0xff);\r
  58                 if(has == 3) writeReset(BUFFER);\r
  59                 bytes[byteIndex++] = (byte)((i>>>24)&0xff);\r
  60                 if(has == 4) writeReset(BUFFER);\r
  61         }\r
  62     }\r
  63 \r
  64     public void write(long l) {\r
  65 //      System.err.println("write " + l);\r
  66         if(byteIndex < (BUFFER-8)) {\r
  67                 bytes[byteIndex++] = (byte)(l&0xff);\r
  68                 bytes[byteIndex++] = (byte)((l>>>8)&0xff);\r
  69                 bytes[byteIndex++] = (byte)((l>>>16)&0xff);\r
  70                 bytes[byteIndex++] = (byte)((l>>>24)&0xff);\r
  71                 bytes[byteIndex++] = (byte)((l>>>32)&0xff);\r
  72                 bytes[byteIndex++] = (byte)((l>>>40)&0xff);\r
  73                 bytes[byteIndex++] = (byte)((l>>>48)&0xff);\r
  74                 bytes[byteIndex++] = (byte)((l>>>56)&0xff);\r
  75         } else {\r
  76                 int has = BUFFER-byteIndex;\r
  77                 if(has == 0) writeReset(BUFFER);\r
  78                 bytes[byteIndex++] = (byte)(l&0xff);\r
  79                 if(has == 1) writeReset(BUFFER);\r
  80                 bytes[byteIndex++] = (byte)((l>>>8)&0xff);\r
  81                 if(has == 2) writeReset(BUFFER);\r
  82                 bytes[byteIndex++] = (byte)((l>>>16)&0xff);\r
  83                 if(has == 3) writeReset(BUFFER);\r
  84                 bytes[byteIndex++] = (byte)((l>>>24)&0xff);\r
  85                 if(has == 4) writeReset(BUFFER);\r
  86                 bytes[byteIndex++] = (byte)((l>>>32)&0xff);\r
  87                 if(has == 5) writeReset(BUFFER);\r
  88                 bytes[byteIndex++] = (byte)((l>>>40)&0xff);\r
  89                 if(has == 6) writeReset(BUFFER);\r
  90                 bytes[byteIndex++] = (byte)((l>>>48)&0xff);\r
  91                 if(has == 7) writeReset(BUFFER);\r
  92                 bytes[byteIndex++] = (byte)((l>>>56)&0xff);\r
  93                 if(has == 8) writeReset(BUFFER);\r
  94         }\r
  95     }\r
  96     \r
  97         public void write(byte[] data) {\r
  98                 \r
  99                 int offset = 0;\r
 100                 int left = data.length;\r
 101                 int has = BUFFER-byteIndex;\r
 102                 \r
 103                 if(has > left) {\r
 104                         \r
 105                         System.arraycopy(data, 0, bytes, byteIndex, left);\r
 106                         byteIndex += left;\r
 107                         \r
 108                 } else if(has == left) {\r
 109 \r
 110                         System.arraycopy(data, 0, bytes, byteIndex, left);\r
 111                         writeReset(BUFFER);\r
 112                         \r
 113                 } else {\r
 114 \r
 115                         System.arraycopy(data, 0, bytes, byteIndex, has);\r
 116                         writeReset(BUFFER);\r
 117                         left -= has;\r
 118                         offset += has;\r
 119                         \r
 120                         while(left > 0) {\r
 121 \r
 122                                 int length = Math.min(left, BUFFER);\r
 123                                 System.arraycopy(data, offset, bytes, 0, length);\r
 124                                 offset += length;\r
 125                                 left -= length;\r
 126                                 \r
 127                                 if(length < BUFFER) byteIndex = length;\r
 128                                 else writeReset(BUFFER);\r
 129                                 \r
 130                         }\r
 131                         \r
 132                 }\r
 133                 \r
 134         }    \r
 135     \r
 136     public void commit() {\r
 137                 try {\r
 138                         if(byteIndex > 0) writeReset(byteIndex);\r
 139                         //channel.force(false);\r
 140                         out.close();\r
 141                 } catch (IOException e) {\r
 142                         Logger.defaultLogError(e);\r
 143                 }\r
 144     }\r
 145     \r
 146     private void writeReset(int size) {\r
 147         \r
 148         byteIndex = 0;\r
 149         bb.position(0);\r
 150         bb.limit(size);\r
 151         try {\r
 152                 \r
 153                 for(int got=0;got < size;) {\r
 154                         got += channel.write(bb);\r
 155                         if(got == -1) {\r
 156                                 new Exception().printStackTrace();\r
 157                                 return;\r
 158                         }\r
 159                 }\r
 160                 \r
 161                 } catch (IOException e) {\r
 162                         e.printStackTrace();\r
 163                 }\r
 164                 \r
 165     }\r
 166     \r
 167 }\r