bundles/org.simantics.acorn/src/org/simantics/acorn/lru/FileInfo.java

   1 package org.simantics.acorn.lru;
   2
   3 import java.nio.file.Path;
   4
   5 import org.simantics.acorn.FileCache;
   6 import org.simantics.acorn.exception.AcornAccessVerificationException;
   7 import org.simantics.acorn.exception.IllegalAcornStateException;
   8 import org.simantics.db.Database.Session.ResourceSegment;
   9 import org.simantics.utils.datastructures.Pair;
  10
  11 import gnu.trove.list.array.TByteArrayList;
  12
  13 public class FileInfo extends LRUObject<String, FileInfo> {
  14
  15         private TByteArrayList bytes;
  16
  17         // Stub
  18         public FileInfo(LRU<String, FileInfo> LRU, FileCache fileCache, Path readDir, String id, int offset, int length) throws AcornAccessVerificationException {
  19                 super(LRU, fileCache, id, readDir, id.toString() + ".extFile", offset, length, false, false);
  20                 LRU.map(this);
  21         }
  22
  23         // New
  24         public FileInfo(LRU<String, FileInfo> LRU, FileCache fileCache, String id, int size) throws AcornAccessVerificationException {
  25                 super(LRU, fileCache, id, LRU.getDirectory(), id.toString() + ".extFile", true, true);
  26                 this.bytes = new TByteArrayList(size);
  27                 LRU.insert(this, accessTime);
  28         }
  29
  30         public byte[] getResourceFile() throws AcornAccessVerificationException, IllegalAcornStateException {
  31
  32                 if(VERIFY) verifyAccess();
  33
  34                 makeResident();
  35                 return bytes.toArray();
  36         }
  37
  38
  39         public ResourceSegment getResourceSegment(final byte[] clusterUID, final int resourceIndex, final long segmentOffset, short segmentSize) throws AcornAccessVerificationException, IllegalAcornStateException {
  40
  41                 if(VERIFY) verifyAccess();
  42
  43                 makeResident();
  44                 try {
  45                         int segSize = segmentSize;
  46                         if (segSize < 0)
  47                                 segSize += 65536;
  48                         if (segmentSize == -1)
  49                                 segSize = Math.min(65535, bytes.size());
  50
  51                         final long valueSize = bytes.size();
  52                         final byte[] segment = bytes.toArray((int) segmentOffset, segSize);
  53
  54                         return new ResourceSegment() {
  55
  56                                 @Override
  57                                 public long getValueSize() {
  58                                         return valueSize;
  59                                 }
  60
  61                                 @Override
  62                                 public byte[] getSegment() {
  63                                         return segment;
  64                                 }
  65
  66                                 @Override
  67                                 public int getResourceIndex() {
  68                                         return resourceIndex;
  69                                 }
  70
  71                                 @Override
  72                                 public long getOffset() {
  73                                         return segmentOffset;
  74                                 }
  75
  76                                 @Override
  77                                 public byte[] getClusterId() {
  78                                         return clusterUID;
  79                                 }
  80                         };
  81                 } catch (Throwable t) {
  82                         throw new IllegalAcornStateException(t);
  83                 }
  84         }
  85
  86         public void updateData(byte[] newBytes, long offset, long pos, long size) throws AcornAccessVerificationException, IllegalAcornStateException {
  87
  88                 if(VERIFY) verifyAccess();
  89                 makeResident();
  90
  91                 if(size == 0) {
  92                         bytes.remove((int)offset, (int)(bytes.size()-offset));
  93                 } else {
  94                         bytes.fill((int) (offset + size), (int) (offset + size), (byte) 0);
  95                         bytes.set((int) offset, newBytes, (int) pos, (int) size);
  96                 }
  97
  98                 setDirty();
  99
 100         }
 101
 102         @Override
 103         public Pair<byte[], Integer> toBytes() {
 104                 byte[] result = bytes.toArray();
 105                 release();
 106                 return Pair.make(result, result.length);
 107         }
 108
 109         @Override
 110         protected void release() {
 111                 bytes = null;
 112         }
 113
 114         @Override
 115         public void fromFile(byte[] data) {
 116                 bytes = new TByteArrayList(data);
 117         }
 118
 119         @Override
 120         protected String getExtension() {
 121                 return "extFile";
 122         }
 123
 124         @Override
 125         protected boolean overwrite() {
 126                 return true;
 127         }
 128
 129 }