Class BinaryCasSerDes4.Deserializer

java.lang.Object
org.apache.uima.cas.impl.BinaryCasSerDes4.Deserializer
Enclosing class:
BinaryCasSerDes4

private class BinaryCasSerDes4.Deserializer extends Object
Class instantiated once per deserialization Multiple deserializations in parallel supported, with multiple instances of this
  • Field Details

    • baseCas

      private final CASImpl baseCas
    • ivCas

      private final CASImpl ivCas
    • bcsd

      private final BinaryCasSerDes bcsd
    • csds

      private final CommonSerDesSequential csds
    • deserIn

      private final DataInput deserIn
    • dataInputs

      private final DataInputStream[] dataInputs
    • inflaters

      private Inflater[] inflaters
    • currentFs

      private TOP currentFs
      the FS being deserialized
    • singleFsDefer

      private final List<Runnable> singleFsDefer
      Deferred actions to set Feature Slots of feature structures. the deferrals needed when deserializing a subtype of AnnotationBase before the sofa is known Also for Sofa creation where some fields are final
    • sofaNum

      private int sofaNum
      used for deferred creation
    • sofaName

      private String sofaName
    • sofaRef

      private Sofa sofaRef
    • heapStart

      private int heapStart
    • heapEnd

      private int heapEnd
    • fixupsNeeded

      private final List<Runnable> fixupsNeeded
      the "fixups" for relative heap refs actions set slot values
    • uimaSerializableFixups

      private final List<Runnable> uimaSerializableFixups
    • stringHeapObj

      private final StringHeap stringHeapObj
    • isDelta

      private final boolean isDelta
    • readCommonString

      private String[] readCommonString
    • only1CommonString

      private boolean only1CommonString
    • arrayLength_dis

      private final DataInputStream arrayLength_dis
    • heapRef_dis

      private final DataInputStream heapRef_dis
    • int_dis

      private final DataInputStream int_dis
    • byte_dis

      private final DataInputStream byte_dis
    • short_dis

      private final DataInputStream short_dis
    • typeCode_dis

      private final DataInputStream typeCode_dis
    • strOffset_dis

      private final DataInputStream strOffset_dis
    • strLength_dis

      private final DataInputStream strLength_dis
    • long_High_dis

      private final DataInputStream long_High_dis
    • long_Low_dis

      private final DataInputStream long_Low_dis
    • float_Mantissa_Sign_dis

      private final DataInputStream float_Mantissa_Sign_dis
    • float_Exponent_dis

      private final DataInputStream float_Exponent_dis
    • double_Mantissa_Sign_dis

      private final DataInputStream double_Mantissa_Sign_dis
    • double_Exponent_dis

      private final DataInputStream double_Exponent_dis
    • fsIndexes_dis

      private final DataInputStream fsIndexes_dis
    • strChars_dis

      private final DataInputStream strChars_dis
    • control_dis

      private final DataInputStream control_dis
    • strSeg_dis

      private final DataInputStream strSeg_dis
    • prevFsRefsByType

      private final int[][] prevFsRefsByType
      For differencing when reading. Also used for arrays to difference the 0th element. Can't use real fs for heap refs - may be forward refs not yet fixedup Hold prev instance of FS which have FSRef slots for each target typecode, only set if the type - has 1 or more non-array fsref - is a (subtype of) FSArray set for both 0 and non-0 values !! Different from form6 first index: key is type code 2nd index: key is slot-offset number (0-based) Also used for array refs, for the 1st entry in the array - feature slot 0 is used for this when reading (not when writing - could be made more uniform)
    • prevFsRefs

      private int[] prevFsRefs
    • prevFsByType

      private final TOP[] prevFsByType
      Used for differencing, except for HeapRef values which use above
    • prevFs

      private TOP prevFs
    • seq2fs

      private final Int2ObjHashMap<TOP,TOP> seq2fs
      convert between FSs and "sequential" numbers Note: This may be identity map, but may not in the case for V3 where some FSs are GC'd
  • Constructor Details

    • Deserializer

      Deserializer(CASImpl cas, DataInput deserIn, boolean isDelta) throws IOException
      Called after header was read and determined that this was a compressed binary
      Parameters:
      cas - CAS
      deserIn - input data
      Throws:
      IOException - passthru
  • Method Details

    • deserialize

      private void deserialize(CommonSerDes.Header h) throws IOException
      Throws:
      IOException
    • createCurrentFs

      private void createCurrentFs(TypeImpl type, CASImpl view)
    • readArray

      private TOP readArray(int iHeap, TypeImpl type) throws IOException
      Throws:
      IOException
    • readArrayLength

      private int readArrayLength() throws IOException
      Throws:
      IOException
    • readByKind

      private void readByKind(FeatureImpl feat, TypeImpl type) throws IOException
      If the fs is null, accumulate fixup operations, otherwise directly set this
      Parameters:
      feat -
      type -
      fs - - null or the fs whose slots are to be set
      Throws:
      IOException
    • readIndexedFeatureStructures

      private void readIndexedFeatureStructures() throws IOException
      Throws:
      IOException
    • maybeStoreOrDefer

      private void maybeStoreOrDefer(Consumer<TOP> storeAction)
      Maybe defers setting features for a Feature Structure if the FS isn't created yet (perhaps because it needs a sofa ref, not yet read)
      Parameters:
      storeAction -
      fs - - the Feature Structure or null if not yet created
    • maybeStoreOrDefer_slotFixups

      private void maybeStoreOrDefer_slotFixups(int tgtSeq, Consumer<TOP> r)
      FS Ref slots fixups
      Parameters:
      tgtSeq - the int value of the target seq number
      r - is sofa-or-lfs.setFeatureValue-or-setLocalSofaData(TOP ref-d-fs)
    • readFsxPart

      private void readFsxPart(IntVector fsIndexes) throws IOException
      Throws:
      IOException
    • setupReadStream

      private void setupReadStream(int slotIndex, int bytesCompr, int bytesOrig) throws IOException
      Throws:
      IOException
    • closeDataInputs

      private void closeDataInputs()
    • getInputStream

      private DataInput getInputStream(SlotKinds.SlotKind kind)
    • readVnumber

      private int readVnumber(DataInputStream dis) throws IOException
      Throws:
      IOException
    • readVlong

      private long readVlong(DataInputStream dis) throws IOException
      Throws:
      IOException
    • readIntoByteArray

      private void readIntoByteArray(byte[] ba) throws IOException
      Throws:
      IOException
    • readIntoShortArray

      private void readIntoShortArray(short[] sa) throws IOException
      Throws:
      IOException
    • readIntoDoubleArray

      private void readIntoDoubleArray(double[] da) throws IOException
      Throws:
      IOException
    • readIntoLongArray

      private void readIntoLongArray(long[] la) throws IOException
      Throws:
      IOException
    • readDiffWithPrevTypeSlot

      private int readDiffWithPrevTypeSlot(SlotKinds.SlotKind kind, FeatureImpl feat) throws IOException
      Difference with previously deserialized value of corresponding slot of previous FS for this type. Special handling: if the slot is a heap ref, we can't use the prevFs because the value may be a forward reference, not yet deserialized, and therefore unknown. For this case, we preserve the actual deserialized value in a lazyly constructed prevFsRef and use that. For arrays, only the prev 0 value is used (if available - otherwise 0 is used)
      Parameters:
      kind - - the slot kind being deserialized
      feat - - the feature (null for arrays)
      Returns:
      - the previous value, for differencing
      Throws:
      IOException
    • getPrevIntValue

      private int getPrevIntValue(SlotKinds.SlotKind kind, FeatureImpl feat)
      Common code for feature offset and array
      Parameters:
      kind -
      feat - feature or null for array access
      Returns:
    • savePrevHeapRef

      private void savePrevHeapRef(int typecode, int nbrOfSlots, int offset, int v)
    • readDiff

      private int readDiff(SlotKinds.SlotKind kind, int prev) throws IOException
      Throws:
      IOException
    • readDiff

      private int readDiff(DataInput in, int prev) throws IOException
      Throws:
      IOException
    • readLongOrDouble

      private long readLongOrDouble(SlotKinds.SlotKind kind, long prev) throws IOException
      Throws:
      IOException
    • readFloat

      private int readFloat() throws IOException
      Throws:
      IOException
    • decodeIntSign

      private int decodeIntSign(int v)
    • readDouble

      private long readDouble() throws IOException
      Throws:
      IOException
    • decodeDouble

      private long decodeDouble(long mants, int exponent)
    • readVlong

      private long readVlong(DataInput dis) throws IOException
      Throws:
      IOException
    • readString

      private String readString() throws IOException
      Throws:
      IOException
    • getPrevFsRef

      private int[] getPrevFsRef(TypeImpl type)
      lazy initialization of the prevFsRef info FSArray - only need slot 0 non-array - need all the slots
    • seq2fs

      private TOP seq2fs(int s)