public override void CompleteInterruptedTransaction(int transactionId1, int transactionId2
     )
 {
     if (!File.Exists(LockFileName(_fileName)))
     {
         return;
     }
     if (!LockFileSignalsInterruptedTransaction())
     {
         return;
     }
     var buffer = new ByteArrayBuffer(Const4.IntLength);
     OpenLogFile();
     Read(_logFile, buffer);
     var length = buffer.ReadInt();
     if (length > 0)
     {
         buffer = new ByteArrayBuffer(length);
         Read(_logFile, buffer);
         buffer.IncrementOffset(Const4.IntLength);
         ReadWriteSlotChanges(buffer);
     }
     DeleteLockFile();
     CloseLogFile();
     DeleteLogFile();
 }

 public virtual void WriteIndexEntry(IContext context, ByteArrayBuffer writer, object
     obj)
 {
     var slot = (Slot) obj;
     writer.WriteInt(slot.Address());
     writer.WriteInt(slot.Length());
 }

 public static SerializedGraph Read(ByteArrayBuffer buffer
     )
 {
     var id = buffer.ReadInt();
     var length = buffer.ReadInt();
     return new SerializedGraph(id, buffer.ReadBytes(length));
 }

 public UnmarshallingContext(Transaction transaction, ByteArrayBuffer buffer, ObjectReference
     @ref, int addToIDTree, bool checkIDTree) : base(transaction, buffer, null, @ref
         )
 {
     _addToIDTree = addToIDTree;
     _checkIDTree = checkIDTree;
 }

 private static ByteArrayBuffer Encode(Encoding charset, string @string)
 {
     ByteBuffer encoded = charset.Encode(CharBuffer.Wrap(@string));
     ByteArrayBuffer bab = new ByteArrayBuffer(encoded.Remaining());
     bab.Append(((byte[])encoded.Array()), encoded.Position(), encoded.Remaining());
     return bab;
 }

 // _key, _slot._address, _slot._length 
 public override object Read(ByteArrayBuffer buffer)
 {
     var id = buffer.ReadInt();
     var slot = new Slot
         (buffer.ReadInt(), buffer.ReadInt());
     return new IdSlotTree(id, slot);
 }

 protected override void WriteBuffer(ByteArrayBuffer buffer, bool shuttingDown)
 {
     base.WriteBuffer(buffer, shuttingDown);
     var systemData = SystemData();
     buffer.WriteInt(systemData.IdToTimestampIndexId());
     buffer.WriteInt(systemData.TimestampToIdIndexId());
 }

 private byte[] ReadName(LatinStringIO sio, ByteArrayBuffer reader)
 {
     var nameBytes = sio.Bytes(reader);
     reader.IncrementOffset(nameBytes.Length);
     nameBytes = Platform4.UpdateClassName(nameBytes);
     return nameBytes;
 }

 public virtual void WriteIndexEntry(IContext context, ByteArrayBuffer reader, object
     obj)
 {
     var mappedIDs = (MappedIDPair) obj;
     _origHandler.WriteIndexEntry(context, reader, mappedIDs.Orig());
     _mappedHandler.WriteIndexEntry(context, reader, mappedIDs.Mapped());
 }

 public virtual byte[] Bytes(ByteArrayBuffer buffer)
 {
     var len = buffer.ReadInt();
     len = BytesPerChar()*len;
     var res = new byte[len];
     Array.Copy(buffer._buffer, buffer._offset, res, 0, len);
     return res;
 }

 internal static void WriteShort(int a_short, ByteArrayBuffer a_bytes)
 {
     for (var i = 0; i < Const4.ShortBytes; i++)
     {
         a_bytes._buffer[a_bytes._offset++] = (byte) (a_short >> ((Const4.ShortBytes - 1 -
                                                                   i)*8));
     }
 }

 internal override object Read1(ByteArrayBuffer a_bytes)
 {
     var b1 = a_bytes.ReadByte();
     var b2 = a_bytes.ReadByte();
     var ret = (char) ((b1 & unchecked(0xff)) | ((b2 & unchecked(0xff))
                                                 << 8));
     return ret;
 }

		public MultipartReader(string contentType, MultipartReaderDelegate delegate_)
		{
			this.contentType = contentType;
			this.delegate_ = delegate_;
			this.buffer = new ByteArrayBuffer(1024);
			this.state = MultipartReader.MultipartReaderState.kAtStart;
			ParseContentType();
		}

 protected override void ReadBuffer(ByteArrayBuffer buffer, bool versionsAreConsistent
     )
 {
     base.ReadBuffer(buffer, versionsAreConsistent);
     var systemData = SystemData();
     systemData.IdToTimestampIndexId(buffer.ReadInt());
     systemData.TimestampToIdIndexId(buffer.ReadInt());
 }

 public override object ReadFloat(ByteArrayBuffer bytes)
 {
     var value = UnmarshallFloat(bytes);
     if (float.IsNaN(value))
     {
         return null;
     }
     return value;
 }

 public override object ReadDouble(ByteArrayBuffer buffer)
 {
     var value = UnmarshalDouble(buffer);
     if (double.IsNaN(value))
     {
         return null;
     }
     return value;
 }

 public override object ReadLong(ByteArrayBuffer buffer)
 {
     var value = buffer.ReadLong();
     if (value == long.MaxValue)
     {
         return null;
     }
     return value;
 }

 public virtual void WriteIndexEntry(IContext context, ByteArrayBuffer a_writer, object
     a_object)
 {
     if (a_object == null)
     {
         a_object = PrimitiveNull();
     }
     Write(a_object, a_writer);
 }

 protected virtual void ReadWriteSlotChanges(ByteArrayBuffer buffer)
 {
     var slotChanges = new LockedTree();
     slotChanges.Read(buffer, new SlotChange(0));
     if (WriteSlots(new _IVisitable_65(slotChanges)))
     {
         FlushDatabaseFile();
     }
 }

 public override object ReadShort(ByteArrayBuffer buffer)
 {
     var value = UnmarshallShort(buffer);
     if (value == short.MaxValue)
     {
         return null;
     }
     return value;
 }