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

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