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