public static BufferFile InitializeBufferFileInStream(System.IO.Stream fromfile, int buffersize, long StartSeek) { BufferFile result = new BufferFile(fromfile, buffersize, StartSeek); result.SetHeader(); return(result); }
void ReadHeader() { byte[] header = new byte[this.headersize]; this.fromfile.Seek(this.seekStart, System.IO.SeekOrigin.Begin); this.fromfile.Read(header, 0, this.headersize); int index = 0; // check prefix foreach (byte b in HEADERPREFIX) { if (header[index] != b) { throw new LinkedFileException("invalid header prefix"); } index++; } // skip version (for now) index++; // read buffersize this.buffersize = BufferFile.Retrieve(header, index); index += BufferFile.INTSTORAGE; this.FreeListHead = BufferFile.RetrieveLong(header, index); this.SanityCheck(); this.headerDirty = false; }
public static BufferFile SetupFromExistingStream(System.IO.Stream fromfile, int buffersize, long StartSeek) { BufferFile result = new BufferFile(fromfile, buffersize, StartSeek); // dummy buffer size for now result.ReadHeader(); return(result); }
public void Load(byte[] serialization) { int index = 0; int byteCount = serialization.Length; if (this.values.Count != 0 || this.keys.Count != 0) { throw new BplusTreeException("load into nonempty xBucket not permitted"); } while (index < byteCount) { // get key prefix and key int keylength = BufferFile.Retrieve(serialization, index); index += BufferFile.INTSTORAGE; byte[] keybytes = new byte[keylength]; Array.Copy(serialization, index, keybytes, 0, keylength); string keystring = BplusTree.BytesToString(keybytes); index += keylength; // get value prefix and value int valuelength = BufferFile.Retrieve(serialization, index); index += BufferFile.INTSTORAGE; byte[] valuebytes = new byte[valuelength]; Array.Copy(serialization, index, valuebytes, 0, valuelength); // record new key and value this.keys.Add(keystring); this.values.Add(valuebytes); index += valuelength; } if (index != byteCount) { throw new BplusTreeException("bad byte count in serialization " + byteCount); } }
public static LinkedFile SetupFromExistingStream(System.IO.Stream fromfile, long StartSeek) { LinkedFile result = new LinkedFile(100, StartSeek); // dummy buffer size for now result.fromfile = fromfile; result.ReadHeader(); result.buffers = BufferFile.SetupFromExistingStream(fromfile, StartSeek + result.headersize); return(result); }
public long StoreNewChunk(byte[] fromArray, int startingAt, int length) { // get the first buffer as result value long currentBufferNumber = this.AllocateBuffer(); //System.Diagnostics.Debug.WriteLine(" allocating chunk starting at "+currentBufferNumber); long result = currentBufferNumber; if (length < 0 || startingAt < 0) { throw new LinkedFileException("cannot store negative length chunk (" + startingAt + "," + length + ")"); } int endingAt = startingAt + length; // special case: zero length chunk if (endingAt > fromArray.Length) { throw new LinkedFileException("array doesn't have this much data: " + endingAt); } int index = startingAt; // store header with length information byte[] buffer = new byte[this.buffersize]; BufferFile.Store(length, buffer, 0); int fromIndex = startingAt; int firstLength = this.buffersize - BufferFile.INTSTORAGE; int stored = 0; if (firstLength > length) { firstLength = length; } Array.Copy(fromArray, fromIndex, buffer, BufferFile.INTSTORAGE, firstLength); stored += firstLength; fromIndex += firstLength; byte currentBufferType = HEAD; // store any remaining buffers (no length info) while (stored < length) { // store current buffer and get next block number long nextBufferNumber = this.AllocateBuffer(); this.SetBuffer(currentBufferNumber, currentBufferType, buffer, 0, buffer.Length, nextBufferNumber); currentBufferNumber = nextBufferNumber; currentBufferType = BODY; int nextLength = this.buffersize; if (stored + nextLength > length) { nextLength = length - stored; } Array.Copy(fromArray, fromIndex, buffer, 0, nextLength); stored += nextLength; fromIndex += nextLength; } // store final buffer this.SetBuffer(currentBufferNumber, currentBufferType, buffer, 0, buffer.Length, NULLBUFFERPOINTER); return(result); }
public static LinkedFile InitializeLinkedFileInStream(System.IO.Stream fromfile, int buffersize, long startSeek) { LinkedFile result = new LinkedFile(buffersize, startSeek); result.fromfile = fromfile; result.SetHeader(); // buffersize should be increased by overhead... result.buffers = BufferFile.InitializeBufferFileInStream(fromfile, buffersize + BUFFEROVERHEAD, startSeek + result.headersize); return(result); }
byte[] ParseBuffer(long bufferNumber, out byte type, out long nextBufferNumber) { byte[] thebuffer = new byte[this.buffersize]; byte[] fullbuffer = new byte[this.buffersize + BUFFEROVERHEAD]; this.buffers.GetBuffer(bufferNumber, fullbuffer, 0, fullbuffer.Length); type = fullbuffer[0]; nextBufferNumber = BufferFile.RetrieveLong(fullbuffer, 1); Array.Copy(fullbuffer, BUFFEROVERHEAD, thebuffer, 0, this.buffersize); return(thebuffer); }
public byte[] MakeHeader() { byte[] result = new byte[this.headersize]; HEADERPREFIX.CopyTo(result, 0); result[HEADERPREFIX.Length] = VERSION; int index = HEADERPREFIX.Length + 1; BufferFile.Store(this.buffersize, result, index); index += BufferFile.INTSTORAGE; BufferFile.Store(this.FreeListHead, result, index); return(result); }
void SetBuffer(long buffernumber, byte type, byte[] thebuffer, int start, int length, long nextBufferNumber) { //System.Diagnostics.Debug.WriteLine(" storing chunk type "+type+" at "+buffernumber); if (this.buffersize < length) { throw new LinkedFileException("buffer size too small " + this.buffersize + "<" + length); } byte[] fullbuffer = new byte[length + BUFFEROVERHEAD]; fullbuffer[0] = type; BufferFile.Store(nextBufferNumber, fullbuffer, 1); if (thebuffer != null) { Array.Copy(thebuffer, start, fullbuffer, BUFFEROVERHEAD, length); } this.buffers.SetBuffer(buffernumber, fullbuffer, 0, fullbuffer.Length); }
public byte[] GetChunk(long headBufferNumber) { // get the head, interpret the length byte buffertype; long nextBufferNumber; byte[] buffer = this.ParseBuffer(headBufferNumber, out buffertype, out nextBufferNumber); int length = BufferFile.Retrieve(buffer, 0); if (length < 0) { throw new LinkedFileException("negative length block? must be garbage: " + length); } if (buffertype != HEAD) { throw new LinkedFileException("first buffer not marked HEAD"); } byte[] result = new byte[length]; // read in the data from the first buffer int firstLength = this.buffersize - BufferFile.INTSTORAGE; if (firstLength > length) { firstLength = length; } Array.Copy(buffer, BufferFile.INTSTORAGE, result, 0, firstLength); int stored = firstLength; while (stored < length) { // get the next buffer long thisBufferNumber = nextBufferNumber; buffer = this.ParseBuffer(thisBufferNumber, out buffertype, out nextBufferNumber); int nextLength = this.buffersize; if (length - stored < nextLength) { nextLength = length - stored; } Array.Copy(buffer, 0, result, stored, nextLength); stored += nextLength; } return(result); }
public byte[] Dump() { ArrayList allbytes = new ArrayList(); int byteCount = 0; for (int index = 0; index < this.keys.Count; index++) { string thisKey = (string)this.keys[index]; byte[] thisValue = (byte[])this.values[index]; byte[] keyprefix = new byte[BufferFile.INTSTORAGE]; byte[] keybytes = BplusTree.StringToBytes(thisKey); BufferFile.Store(keybytes.Length, keyprefix, 0); allbytes.Add(keyprefix); allbytes.Add(keybytes); byte[] valueprefix = new byte[BufferFile.INTSTORAGE]; BufferFile.Store(thisValue.Length, valueprefix, 0); allbytes.Add(valueprefix); allbytes.Add(thisValue); } foreach (object thing in allbytes) { byte[] thebytes = (byte[])thing; byteCount += thebytes.Length; } int outindex = 0; byte[] result = new byte[byteCount]; foreach (object thing in allbytes) { byte[] thebytes = (byte[])thing; int thelength = thebytes.Length; Array.Copy(thebytes, 0, result, outindex, thelength); outindex += thelength; } if (outindex != byteCount) { throw new BplusTreeException("error counting bytes in dump " + outindex + "!=" + byteCount); } return(result); }