Inheritance diagram for Deveel.Data.Store.StoreBase:

Classes
class	StoreArea
	An IArea that is backed by a StoreBase. More...

Public Member Functions
bool	Open ()

void	Close ()

void	Dispose ()

IArea	CreateArea (long size)
	Allocates a block of memory in the store of the specified size and returns an IArea object that can be used to initialize the contents of the area. More...

void	DeleteArea (long id)
	Deletes an area that was previously allocated by the CreateArea method by the area id. More...

IArea	GetArea (long id, bool readOnly)
	Returns an object that allows for the contents of an area (represented by the id parameter) to be Read. More...

abstract void	Lock ()
	This method is called before the start of a sequence of Write commands between consistant states of some data structure represented by the store. More...

abstract void	Unlock ()
	This method is called after the end of a sequence of Write commands between consistant states of some data structure represented by the store. More...

IEnumerable< long >	GetAllAreas ()
	Returns a complete list of pointers to all areas in the Store as long objects sorted from lowest pointer to highest. More...

Protected Member Functions
	StoreBase (bool isReadOnly)

void	ReadAreaHeader (long offset, long[] header)

void	SplitArea (long offset, long newBoundary)

abstract void	SetDataAreaSize (long length)

virtual void	Dispose (bool disposing)

abstract void	OpenStore (bool readOnly)

abstract void	CloseStore ()

int	ReadByte (long offset)

abstract int	Read (long offset, byte[] buffer, int index, int length)

void	Write (long offset, byte value)

abstract void	Write (long offset, byte[] buffer, int index, int length)

Package Functions
IEnumerable< long >	FindAllocatedAreasNotIn (List< long > usedAreas)

Properties
long	WildernessOffset `[get, set]`

bool	IsReadOnly `[get, private set]`

abstract long	DataAreaEndOffset `[get]`

bool	ClosedClean `[get, private set]`

Properties inherited from Deveel.Data.Store.IStore
bool	ClosedClean `[get]`
	Indicates if the store was closed cleanly last time was accessed. More...

Private Member Functions
	~StoreBase ()

void	CheckOffset (long offset)

void	ReadBins ()

void	WriteAllBins ()

void	WriteBinIndex (int index)

void	AddToBinChain (long pointer, long size)

void	RemoveFromBinChain (long offset, long size)

void	Free (long pointer)

long	GetPreviousAreaHeader (long offset, long[] header)

long	GetNextAreaHeader (long offset, long[] header)

void	ReboundArea (long offset, long[] header, bool writeHeaders)

void	CoalesceArea (long offset, long size)

void	CropArea (long offset, long allocatedSize)

long	Alloc (long size)

long	ExpandDataArea (long minSize)

void	Init ()

Static Private Member Functions
static int	MinimumBinSizeIndex (long size)

static bool	IsValidBoundarySize (long size)

Private Attributes
long[]	freeBinList

long	totalAllocatedSpace

readonly byte[]	binArea = new byte[128 * 8]

const long	ActiveFlag = Int64.MaxValue

const long	DeletedFlag = Int64.MinValue

const long	FixedAreaOffset = 128

const long	DataAreaOffset = 256 + 1024 + 32

const long	BinAreaOffset = 256

const int	Magic = 0x0AEAE91

readonly byte[]	headerBuf = new byte[16]

bool	disposed

Static Private Attributes
static readonly int[]	BinSizes

static readonly int	BinSizeEntries = BinSizes.Length

static readonly int	MaxBinSize = BinSizes[BinSizeEntries - 1]

Detailed Description

Definition at line 25 of file StoreBase.cs.

Constructor & Destructor Documentation

Deveel.Data.Store.StoreBase.StoreBase ( bool isReadOnly )

inlineprotected

Definition at line 61 of file StoreBase.cs.

                                              {
             freeBinList = new long[BinSizeEntries + 1];
             for (int i = 0; i < BinSizeEntries + 1; ++i) {
                 freeBinList[i] = -1L;
             }
 
             WildernessOffset = -1;
 
             IsReadOnly = isReadOnly;
         }

Deveel.Data.Store.StoreBase.~StoreBase ( )

inlineprivate

Definition at line 72 of file StoreBase.cs.

                      {
             Dispose(false);
         }

Member Function Documentation

void Deveel.Data.Store.StoreBase.AddToBinChain	(	long	pointer,
		long	size
	)

inlineprivate

Definition at line 125 of file StoreBase.cs.

                                                             {
             CheckOffset(pointer);
 
             // What bin would this area fit into?
             int binChainIndex = MinimumBinSizeIndex(size);
             var headerInfo = new long[2];
 
             long curOffset = freeBinList[binChainIndex];
 
             if (curOffset == -1) {
                 // If the bin chain has no elements,
                 headerInfo[0] = (size | DeletedFlag);
                 headerInfo[1] = -1;
 
                 ReboundArea(pointer, headerInfo, true);
                 freeBinList[binChainIndex] = pointer;
 
                 WriteBinIndex(binChainIndex);
             } else {
                 bool inserted = false;
                 long lastOffset = -1;
                 int searches = 0;
                 while (curOffset != -1 && inserted == false) {
                     // Get the current offset
                     ReadAreaHeader(curOffset, headerInfo);
 
                     long header = headerInfo[0];
                     long next = headerInfo[1];
 
                     // Assert - the header must have deleted flag
                     if ((header & DeletedFlag) == 0)
                         throw new IOException("Area not marked as deleted.");
 
                     long areaSize = header ^ DeletedFlag;
                     if (areaSize >= size || searches >= 12) {
                         // Insert if the area size is >= than the size we are adding.
                         // Set the previous header to point to this
                         long previous = lastOffset;
 
                         // Set up the deleted area
                         headerInfo[0] = (size | DeletedFlag);
                         headerInfo[1] = curOffset;
 
                         ReboundArea(pointer, headerInfo, true);
 
                         if (lastOffset != -1) {
                             // Set the previous input the chain to point to the deleted area
                             ReadAreaHeader(previous, headerInfo);
 
                             headerInfo[1] = pointer;
                             ReboundArea(previous, headerInfo, false);
                         } else {
                             // Otherwise set the head bin item
                             freeBinList[binChainIndex] = pointer;
                             WriteBinIndex(binChainIndex);
                         }
 
                         inserted = true;
                     }
 
                     lastOffset = curOffset;
                     curOffset = next;
                     ++searches;
                 }
 
                 // If we reach the end and we haven't inserted,
                 if (!inserted) {
                     // Set the new deleted area.
                     headerInfo[0] = (size | DeletedFlag);
                     headerInfo[1] = -1;
                     ReboundArea(pointer, headerInfo, true);
 
                     // Set the previous entry to this
                     ReadAreaHeader(lastOffset, headerInfo);
                     headerInfo[1] = pointer;
                     ReboundArea(lastOffset, headerInfo, false);
                 }
             }
         }

long Deveel.Data.Store.StoreBase.Alloc ( long size )

inlineprivate

Definition at line 408 of file StoreBase.cs.

                                       {
             if (size < 0)
                 throw new IOException("Negative size allocation");
 
             // Add 16 bytes for headers
             size = size + 16;
 
             // If size < 32, make size = 32
             if (size < 32)
                 size = 32;
 
             // Round all sizes up to the nearest 8
             long d = size & 0x07L;
             if (d != 0)
                 size = size + (8 - d);
 
             long realAllocSize = size;
 
             // Search the free bin list for the first bin that matches the given size.
             int binChainIndex;
             if (size > MaxBinSize) {
                 binChainIndex = BinSizeEntries;
             } else {
                 int i = MinimumBinSizeIndex(size);
                 binChainIndex = i;
             }
 
             // Search the bins until we find the first area that is the nearest fit to
             // the size requested.
             int foundBinIndex = -1;
             long prevOffset = -1;
             bool first = true;
             for (int i = binChainIndex;
                 i < BinSizeEntries + 1 && foundBinIndex == -1;
                 ++i) {
                 long curOffset = freeBinList[i];
                 if (curOffset != -1) {
                     if (!first) {
                         // Pick this..
                         foundBinIndex = i;
                         prevOffset = -1;
                     } else {
                         // Search this bin for the first that's big enough.
                         // We only search the first 12 entries input the bin before giving up.
 
                         long lastOffset = -1;
                         int searches = 0;
                         while (curOffset != -1 &&
                                foundBinIndex == -1 &&
                                searches < 12) {
 
                             var headerInfo = new long[2];
                             ReadAreaHeader(curOffset, headerInfo);
 
                             long areaSize = (headerInfo[0] & ActiveFlag);
 
                             // Is this area is greater or equal than the required size
                             // and is not the wilderness area, pick it.
                             if (curOffset != WildernessOffset && areaSize >= size) {
                                 foundBinIndex = i;
                                 prevOffset = lastOffset;
                             }
 
                             // Go to next input chain.
                             lastOffset = curOffset;
                             curOffset = headerInfo[1];
                             ++searches;
                         }
                     }
 
                 }
 
                 first = false;
             }
 
             // If no area can be recycled,
             if (foundBinIndex == -1) {
                 // Allocate a new area of the given size.
                 // If there is a wilderness, grow the wilderness area to the new size,
                 long workingOffset;
                 long sizeToGrow;
                 long currentAreaSize;
                 if (WildernessOffset != -1) {
                     workingOffset = WildernessOffset;
 
                     var headerInfo = new long[2];
                     ReadAreaHeader(WildernessOffset, headerInfo);
 
                     long wildernessSize = (headerInfo[0] & ActiveFlag);
 
                     // Remove this from the bins
                     RemoveFromBinChain(workingOffset, wildernessSize);
 
                     // For safety, we set wilderness_pointer to -1
                     WildernessOffset = -1;
                     sizeToGrow = size - wildernessSize;
                     currentAreaSize = wildernessSize;
                 } else {
                     // wilderness_pointer == -1 so add to the end of the data area.
                     workingOffset = DataAreaEndOffset;
                     sizeToGrow = size;
                     currentAreaSize = 0;
                 }
 
                 long expandedSize = 0;
                 if (sizeToGrow > 0) {
                     // Expand the data area to the new size.
                     expandedSize = ExpandDataArea(sizeToGrow);
                 }
 
                 // Coalesce the new area to the given size
                 CoalesceArea(workingOffset, currentAreaSize + expandedSize);
 
                 // crop the area
                 CropArea(workingOffset, size);
 
                 // Add to the total allocated space
                 totalAllocatedSpace += realAllocSize;
 
                 return workingOffset;
             } else {
                 // An area is taken from the bins,
                 long freeAreaOffset;
                 var headerInfo = new long[2];
 
                 // Remove this area from the bin chain and possibly add any excess space
                 // left over to a new bin.
                 if (prevOffset == -1) {
                     freeAreaOffset = freeBinList[foundBinIndex];
                     ReadAreaHeader(freeAreaOffset, headerInfo);
                     freeBinList[foundBinIndex] = headerInfo[1];
                     WriteBinIndex(foundBinIndex);
                 } else {
                     var headerInfo2 = new long[2];
                     ReadAreaHeader(prevOffset, headerInfo2);
                     freeAreaOffset = headerInfo2[1];
                     ReadAreaHeader(freeAreaOffset, headerInfo);
                     headerInfo2[1] = headerInfo[1];
                     ReboundArea(prevOffset, headerInfo2, false);
                 }
 
                 // Reset the header of the recycled area.
                 headerInfo[0] = (headerInfo[0] & ActiveFlag);
                 ReboundArea(freeAreaOffset, headerInfo, true);
 
                 // Crop the area to the given size.
                 CropArea(freeAreaOffset, size);
 
                 // Add to the total allocated space
                 totalAllocatedSpace += realAllocSize;
 
                 return freeAreaOffset;
             }
         }

void Deveel.Data.Store.StoreBase.CheckOffset ( long offset )

inlineprivate

Definition at line 82 of file StoreBase.cs.

                                               {
             if (offset < DataAreaOffset || offset >= DataAreaEndOffset) {
                 throw new IOException(String.Format("The offset is out of range ({0} > {1} > {2})", DataAreaOffset, offset,
                     DataAreaEndOffset));
             }
         }

void Deveel.Data.Store.StoreBase.Close ( )

inline

Definition at line 728 of file StoreBase.cs.

                             {
             lock (this) {
                 // Mark the file as closed
                 if (!IsReadOnly)
                     Write(16, 0);
 
                 CloseStore();
             }
         }

abstract void Deveel.Data.Store.StoreBase.CloseStore ( )

protectedpure virtual

Implemented in Deveel.Data.Store.SingleFileStore.

void Deveel.Data.Store.StoreBase.CoalesceArea	(	long	offset,
		long	size
	)

inlineprivate

Definition at line 361 of file StoreBase.cs.

                                                           {
             ByteBuffer.WriteInt8(size, headerBuf, 0);
 
             // ISSUE: Boundary alteration is a moment when corruption could occur.
             //   There are two seeks and writes here and when we are setting the
             //   end points, there is a risk of failure.
 
             Write(offset, headerBuf, 0, 8);
             Write((offset + size) - 8, headerBuf, 0, 8);
         }

IArea Deveel.Data.Store.StoreBase.CreateArea ( long size )

inline

Allocates a block of memory in the store of the specified size and returns an IArea object that can be used to initialize the contents of the area.

Parameters

size	The amount of memory to allocate.

Note that an area in the store is undefined until the IArea.Flush method is called in IArea.

Returns: Returns an IArea object that allows the area to be setup.

Exceptions

System.IO.IOException If not enough space available to create the area or the store is Read-only.

Implements Deveel.Data.Store.IStore.

Definition at line 755 of file StoreBase.cs.

                                            {
             lock (this) {
                 long pointer = Alloc(size);
                 return new StoreArea(this, pointer, pointer + 8, false, size);
             }
         }

void Deveel.Data.Store.StoreBase.CropArea	(	long	offset,
		long	allocatedSize
	)

inlineprivate

Definition at line 372 of file StoreBase.cs.

                                                                {
             // Get the header info
             var headerInfo = new long[2];
             ReadAreaHeader(offset, headerInfo);
 
             var header = headerInfo[0];
 
             var freeAreaSize = header;
             var sizeDifference = freeAreaSize - allocatedSize;
             var isWilderness = (offset == WildernessOffset);
 
             // If the difference is greater than 512 bytes, add the excess space to
             // a free bin.
 
             if ((isWilderness && sizeDifference >= 32) || sizeDifference >= 512) {
                 // Split the area into two areas.
                 SplitArea(offset, allocatedSize);
 
                 long leftOverPointer = offset + allocatedSize;
                 // Add this area to the bin chain
                 AddToBinChain(leftOverPointer, sizeDifference);
 
                 // If offset is the wilderness area, set this as the new wilderness
                 if (isWilderness ||
                     (leftOverPointer + sizeDifference) >= DataAreaEndOffset) {
                     WildernessOffset = leftOverPointer;
                 }
 
             } else {
                 // If offset is the wilderness area, set wilderness to -1
                 if (isWilderness) {
                     WildernessOffset = -1;
                 }
             }
         }

void Deveel.Data.Store.StoreBase.DeleteArea ( long id )

inline

Deletes an area that was previously allocated by the CreateArea method by the area id.

Parameters

id	The identifier of the area to delete.

Once an area is deleted the resources may be reclaimed. The behaviour of this method is undefined if the id doesn't represent a valid area.

Exceptions

IOException If the id is invalid or the area can not otherwise by deleted.

Implements Deveel.Data.Store.IStore.

Definition at line 762 of file StoreBase.cs.

                                         {
             lock (this) {
                 Free(id);
             }
         }

void Deveel.Data.Store.StoreBase.Dispose ( )

inline

Definition at line 738 of file StoreBase.cs.

                               {
             Dispose(true);
             GC.SuppressFinalize(this);
         }

virtual void Deveel.Data.Store.StoreBase.Dispose ( bool disposing )

inlineprotectedvirtual

Reimplemented in Deveel.Data.Store.SingleFileStore.

Definition at line 745 of file StoreBase.cs.

                                                        {
             if (!disposed) {
                 if (disposing) {
                     Close();
                 }
 
                 disposed = true;
             }
         }

long Deveel.Data.Store.StoreBase.ExpandDataArea ( long minSize )

inlineprivate

Definition at line 564 of file StoreBase.cs.

                                                   {
             long endOfDataArea = DataAreaEndOffset;
 
             // Round all sizes up to the nearest 8
             // We grow only by a small amount if the area is small, and a large amount
             // if the area is large.
             long overGrow = endOfDataArea / 64;
             long d = (overGrow & 0x07L);
             if (d != 0)
                 overGrow = overGrow + (8 - d);
 
             overGrow = System.Math.Min(overGrow, 262144L);
             if (overGrow < 1024)
                 overGrow = 1024;
 
             long growBy = minSize + overGrow;
             long newFileLength = endOfDataArea + growBy;
             SetDataAreaSize(newFileLength);
             return growBy;
         }

IEnumerable<long> Deveel.Data.Store.StoreBase.FindAllocatedAreasNotIn ( List< long > usedAreas )

inlinepackage

Definition at line 806 of file StoreBase.cs.

                                                                                  {
             // Sort the list
             var list = new List<long>(usedAreas);
             list.Sort();
 
             // The list of leaked areas
             var leakedAreas = new List<long>();
 
             int listIndex = 0;
 
             // What area are we looking for?
             long lookingFor = Int64.MaxValue;
             if (listIndex < list.Count) {
                 lookingFor = list[listIndex];
                 ++listIndex;
             }
 
             long endOfDataArea = DataAreaEndOffset;
             long[] header = new long[2];
 
             long offset = DataAreaOffset;
             while (offset < endOfDataArea) {
                 ReadAreaHeader(offset, header);
 
                 long areaSize = (header[0] & ActiveFlag);
                 bool areaFree = (header[0] & DeletedFlag) != 0;
 
                 if (offset == lookingFor) {
                     if (areaFree)
                         throw new IOException("Area is not allocated!");
 
                     // Update the 'looking_for' offset
                     if (listIndex < list.Count) {
                         lookingFor = (long)list[listIndex];
                         ++listIndex;
                     } else {
                         lookingFor = Int64.MaxValue;
                     }
                 } else if (offset > lookingFor) {
                     throw new IOException("IArea (offset = " + lookingFor + ") wasn't found input store!");
                 } else {
                     // An area that isn't input the list
                     if (!areaFree) {
                         // This is a leaked area.
                         // It isn't free and it isn't input the list
                         leakedAreas.Add(offset);
                     }
                 }
 
                 offset += areaSize;
             }
 
             return leakedAreas.ToArray();
         }

void Deveel.Data.Store.StoreBase.Free ( long pointer )

inlineprivate

Definition at line 245 of file StoreBase.cs.

                                         {
             // Get the area header
             var headerInfo = new long[2];
             ReadAreaHeader(pointer, headerInfo);
 
             if ((headerInfo[0] & DeletedFlag) != 0)
                 throw new IOException("Area already marked as unallocated.");
 
             // If (pointer + size) reaches the end of the header area, set this as the
             // wilderness.
             bool setAsWilderness = ((pointer + headerInfo[0]) >= DataAreaEndOffset);
 
             var rOffset = pointer;
             var freeingAreaSize = headerInfo[0];
             var rSize = freeingAreaSize;
 
             // Can this area coalesce?
             var headerInfo2 = new long[2];
             var leftPointer = GetPreviousAreaHeader(pointer, headerInfo2);
             var coalesc = false;
 
             if ((headerInfo2[0] & DeletedFlag) != 0) {
                 // Yes, we can coalesce left
                 long areaSize = (headerInfo2[0] & ActiveFlag);
 
                 rOffset = leftPointer;
                 rSize = rSize + areaSize;
 
                 // Remove left area from the bin
                 RemoveFromBinChain(leftPointer, areaSize);
                 coalesc = true;
             }
 
             if (!setAsWilderness) {
                 long rightPointer = GetNextAreaHeader(pointer, headerInfo2);
                 if ((headerInfo2[0] & DeletedFlag) != 0) {
                     // Yes, we can coalesce right
                     long areaSize = (headerInfo2[0] & ActiveFlag);
 
                     rSize = rSize + areaSize;
 
                     // Remove right from the bin
                     RemoveFromBinChain(rightPointer, areaSize);
                     setAsWilderness = (rightPointer == WildernessOffset);
                     coalesc = true;
                 }
             }
 
             // If we are coalescing parent areas
             if (coalesc)
                 CoalesceArea(rOffset, rSize);
 
             // Add this new area to the bin chain,
             AddToBinChain(rOffset, rSize);
 
             // Do we set this as the wilderness?
             if (setAsWilderness)
                 WildernessOffset = rOffset;
 
             totalAllocatedSpace -= freeingAreaSize;
         }

IEnumerable<long> Deveel.Data.Store.StoreBase.GetAllAreas ( )

inline

Returns a complete list of pointers to all areas in the Store as long objects sorted from lowest pointer to highest.

This should be used for diagnostics only because it may be difficult for this to be generated with some implementations. It is useful in a repair tool to determine if a pointer is valid or not.

Returns: Returns an implementation of IList that contains all the pointers (as long) to the areas from the lowest to the highest.

Implements Deveel.Data.Store.IStore.

Definition at line 785 of file StoreBase.cs.

                                                {
             var list = new List<long>();
 
             long endOfDataArea = DataAreaEndOffset;
 
             long[] header = new long[2];
             // The first header
             long offset = DataAreaOffset;
             while (offset < endOfDataArea) {
                 ReadAreaHeader(offset, header);
 
                 long areaSize = (header[0] & ActiveFlag);
                 if ((header[0] & DeletedFlag) == 0)
                     list.Add(offset);
 
                 offset += areaSize;
             }
 
             return list;
         }

IArea Deveel.Data.Store.StoreBase.GetArea	(	long	id,
		bool	readOnly
	)

inline

Returns an object that allows for the contents of an area (represented by the id parameter) to be Read.

Parameters

id	The identifier of the area to Read, or -1 for a 64 byte fixed area in the store.
readOnly	Indicates if the returned area must be read-only.

The behaviour of this method is undefined if the id doesn't represent a valid area.

When id is -1 then a fixed area (64 bytes in size) in the store is returned. The fixed area can be used to store important static information.

Returns: Returns an IArea object that allows access to the part of the store.

Exceptions

IOException If the id is invalid or the area can not otherwise be accessed.

Implements Deveel.Data.Store.IStore.

Definition at line 768 of file StoreBase.cs.

                                                      {
             // If this is the fixed area
             if (id == -1)
                 return new StoreArea(this, id, FixedAreaOffset, readOnly, 64);
 
             // Otherwise must be a regular area
             return new StoreArea(this, id, id, readOnly);
         }

long Deveel.Data.Store.StoreBase.GetNextAreaHeader	(	long	offset,
		long[]	header
	)

inlineprivate

Definition at line 325 of file StoreBase.cs.

                                                                    {
             Read(offset, headerBuf, 0, 8);
             long sz = ByteBuffer.ReadInt8(headerBuf, 0);
             sz = sz & ActiveFlag;
             long nextOffset = offset + sz;
 
             if (nextOffset >= DataAreaEndOffset) {
                 // Return a 0 sized block
                 header[0] = 0;
                 return -1;
             }
 
             Read(nextOffset, headerBuf, 0, 8);
             header[0] = ByteBuffer.ReadInt8(headerBuf, 0);
             return nextOffset;
         }

long Deveel.Data.Store.StoreBase.GetPreviousAreaHeader	(	long	offset,
		long[]	header
	)

inlineprivate

Definition at line 308 of file StoreBase.cs.

                                                                        {
             // If the offset is the start of the file area
             if (offset == DataAreaOffset) {
                 // Return a 0 sized block
                 header[0] = 0;
                 return -1;
             }
 
             Read(offset - 8, headerBuf, 0, 8);
             long sz = ByteBuffer.ReadInt8(headerBuf, 0);
             sz = sz & ActiveFlag;
             long previousPointer = offset - sz;
             Read(previousPointer, headerBuf, 0, 8);
             header[0] = ByteBuffer.ReadInt8(headerBuf, 0);
             return previousPointer;
         }

void Deveel.Data.Store.StoreBase.Init ( )

inlineprivate

Definition at line 615 of file StoreBase.cs.

                             {
             lock (this) {
                 SetDataAreaSize(DataAreaOffset);
 
                 using (var stream = new MemoryStream((int) BinAreaOffset)) {
                     using (BinaryWriter writer = new BinaryWriter(stream, Encoding.Unicode)) {
 
                         // The file MAGIC
                         writer.Write(Magic); // 0
 
                         // The file version
                         writer.Write(1); // 4
 
                         // The number of areas (chunks) input the file (currently unused)
                         writer.Write(-1L); // 8
 
                         // File open/close status byte
                         writer.Write((byte) 0); // 16
 
                         writer.Flush();
 
                         byte[] buffer = new byte[(int) DataAreaOffset];
                         byte[] temp = stream.ToArray();
                         Array.Copy(temp, 0, buffer, 0, temp.Length);
                         
                         for (int i = (int) BinAreaOffset; i < (int) DataAreaOffset; ++i) {
                             buffer[i] = 255;
                         }
 
                         Write(0, buffer, 0, buffer.Length);
                     }
                 }
             }
         }

static bool Deveel.Data.Store.StoreBase.IsValidBoundarySize ( long size )

inlinestaticprivate

Definition at line 609 of file StoreBase.cs.

                                                            {
             const long maxAreaSize = (long)Int32.MaxValue * 200;
             size = size & ActiveFlag;
             return ((size < maxAreaSize) && (size >= 24) && ((size & 0x07) == 0));
         }

abstract void Deveel.Data.Store.StoreBase.Lock ( )

pure virtual

This method is called before the start of a sequence of Write commands between consistant states of some data structure represented by the store.

This Lock mechanism is intended to inform the store when it is not safe to checkpoint the data in a log, ensuring that no partial updates are committed to a transaction log and the data can be restored in a consistant manner.

If the store does not implement a check point log or is otherwise not interested in consistant states of the data, then it is not necessary for this method to do anything.

This method prevents a check point from happening during some sequence of operations. This method should not Lock unless a check point is in progress. This method does not prevent concurrent writes to the store.

See also: Unlock

Implements Deveel.Data.Store.IStore.

Implemented in Deveel.Data.Store.SingleFileStore.

static int Deveel.Data.Store.StoreBase.MinimumBinSizeIndex ( long size )

inlinestaticprivate

Definition at line 89 of file StoreBase.cs.

                                                           {
             int i = Array.BinarySearch(BinSizes, (int)size);
             if (i < 0) {
                 i = -(i + 1);
             }
             return i;
         }

bool Deveel.Data.Store.StoreBase.Open ( )

inline

Definition at line 653 of file StoreBase.cs.

                            {
             lock (this) {
                 OpenStore(IsReadOnly);
 
                 // If it's small, initialize to empty
                 if (DataAreaEndOffset < DataAreaOffset)
                     Init();
 
                 byte[] readBuf = new byte[(int) BinAreaOffset];
                 Read(0, readBuf, 0, readBuf.Length);
 
                 using (var stream = new MemoryStream(readBuf)) {
                     using (var reader = new BinaryReader(stream)) {
 
                         int magic = reader.ReadInt32();
                         if (magic != Magic)
                             throw new IOException("Format invalid: Magic value is not as expected.");
 
                         int version = reader.ReadInt32();
                         if (version != 1)
                             throw new IOException("Format invalid: unrecognized version.");
 
                         reader.ReadInt64(); // ignore
                         byte status = reader.ReadByte();
                         ClosedClean = true;
 
                         if (status == 1) {
                             // This means the store wasn't closed cleanly.
                             ClosedClean = false;
                         }
                     }
                 }
 
                 // Read the bins
                 ReadBins();
 
                 // Mark the file as open
                 if (!IsReadOnly)
                     Write(16, 1);
 
                 long fileLength = DataAreaEndOffset;
                 if (fileLength <= 8) {
                     throw new IOException("Format invalid: File size is too small.");
                 }
 
                 // Set the wilderness offset.
                 if (fileLength == DataAreaOffset) {
                     WildernessOffset = -1;
                 } else {
                     Read(fileLength - 8, readBuf, 0, 8);
                     long lastBoundary = ByteBuffer.ReadInt8(readBuf, 0);
                     long lastAreaPointer = fileLength - lastBoundary;
 
                     if (lastAreaPointer < DataAreaOffset)
                         throw new IOException("File corrupt: last area offset is before data part of file.");
 
                     if (lastAreaPointer > fileLength - 8)
                         throw new IOException("File corrupt: last_area_pointer at the end of the file.");
 
                     Read(lastAreaPointer, readBuf, 0, 8);
 
                     long lastAreaHeader = ByteBuffer.ReadInt8(readBuf, 0);
 
                     // If this is a freed block, then set this are the wilderness offset.
                     if ((lastAreaHeader & DeletedFlag) != 0) {
                         WildernessOffset = lastAreaPointer;
                     } else {
                         WildernessOffset = -1;
                     }
                 }
 
                 return ClosedClean;
             }
         }

abstract void Deveel.Data.Store.StoreBase.OpenStore ( bool readOnly )

protectedpure virtual

Implemented in Deveel.Data.Store.SingleFileStore.

abstract int Deveel.Data.Store.StoreBase.Read	(	long	offset,
		byte[]	buffer,
		int	index,
		int	length
	)

protectedpure virtual

Implemented in Deveel.Data.Store.SingleFileStore.

void Deveel.Data.Store.StoreBase.ReadAreaHeader	(	long	offset,
		long[]	header
	)

inlineprotected

Definition at line 342 of file StoreBase.cs.

                                                                   {
             Read(offset, headerBuf, 0, 16);
             header[0] = ByteBuffer.ReadInt8(headerBuf, 0);
             header[1] = ByteBuffer.ReadInt8(headerBuf, 8);
         }

void Deveel.Data.Store.StoreBase.ReadBins ( )

inlineprivate

Definition at line 97 of file StoreBase.cs.

                                 {
             Read(BinAreaOffset, binArea, 0, 128 * 8);
             using (var bin = new MemoryStream(binArea)) {
                 using (BinaryReader input = new BinaryReader(bin)) {
                     for (int i = 0; i < 128; ++i) {
                         freeBinList[i] = input.ReadInt64();
                     }
                 }
             }
         }

int Deveel.Data.Store.StoreBase.ReadByte ( long offset )

inlineprotected

Definition at line 865 of file StoreBase.cs.

                                             {
             var buffer = new byte[1];
             var count = Read(offset, buffer, 0, 1);
             if (count == 0)
                 return -1;
 
             return buffer[0];
         }

void Deveel.Data.Store.StoreBase.ReboundArea	(	long	offset,
		long[]	header,
		bool	writeHeaders
	)

inlineprivate

Definition at line 350 of file StoreBase.cs.

                                                                                 {
             if (writeHeaders) {
                 ByteBuffer.WriteInt8(header[0], headerBuf, 0);
                 ByteBuffer.WriteInt8(header[1], headerBuf, 8);
                 Write(offset, headerBuf, 0, 16);
             } else {
                 ByteBuffer.WriteInt8(header[1], headerBuf, 8);
                 Write(offset + 8, headerBuf, 8, 8);
             }
         }

void Deveel.Data.Store.StoreBase.RemoveFromBinChain	(	long	offset,
		long	size
	)

inlineprivate

Definition at line 205 of file StoreBase.cs.

                                                                 {
             // What bin index should we be looking input?
             int binChainIndex = MinimumBinSizeIndex(size);
 
             var prevOffset = -1L;
             var curOffset = freeBinList[binChainIndex];
 
             // Search this bin for the offset
             // NOTE: This is an iterative search through the bin chain
             while (offset != curOffset) {
                 if (curOffset == -1)
                     throw new IOException("Area not found input bin chain.");
 
                 // Move to the next input the chain
                 var headerInfo = new long[2];
                 ReadAreaHeader(curOffset, headerInfo);
 
                 prevOffset = curOffset;
                 curOffset = headerInfo[1];
             }
 
             // Found the offset, so remove it,
             if (prevOffset == -1) {
                 var headerInfo = new long[2];
 
                 ReadAreaHeader(offset, headerInfo);
                 freeBinList[binChainIndex] = headerInfo[1];
                 WriteBinIndex(binChainIndex);
             } else {
                 var headerInfo = new long[2];
                 var headerInfo2 = new long[2];
 
                 ReadAreaHeader(prevOffset, headerInfo2);
                 ReadAreaHeader(offset, headerInfo);
                 headerInfo2[1] = headerInfo[1];
                 ReboundArea(prevOffset, headerInfo2, false);
             }
 
         }

abstract void Deveel.Data.Store.StoreBase.SetDataAreaSize ( long length )

protectedpure virtual

Implemented in Deveel.Data.Store.SingleFileStore.

void Deveel.Data.Store.StoreBase.SplitArea	(	long	offset,
		long	newBoundary
	)

inlineprotected

Definition at line 585 of file StoreBase.cs.

                                                                 {
             // Split the area pointed to by the offset.
             Read(offset, headerBuf, 0, 8);
             long curSize = ByteBuffer.ReadInt8(headerBuf, 0) & ActiveFlag;
             long leftSize = newBoundary;
             long rightSize = curSize - newBoundary;
 
             if (rightSize < 0)
                 throw new IOException("Could not split the area.");
 
             ByteBuffer.WriteInt8(leftSize, headerBuf, 0);
             ByteBuffer.WriteInt8(rightSize, headerBuf, 8);
 
             // ISSUE: Boundary alteration is a moment when corruption could occur.
             //   There are three seeks and writes here and when we are setting the
             //   end points, there is a risk of failure.
 
             // First set the boundary
             Write((offset + newBoundary) - 8, headerBuf, 0, 16);
             // Now set the end points
             Write(offset, headerBuf, 0, 8);
             Write((offset + curSize) - 8, headerBuf, 8, 8);
         }

abstract void Deveel.Data.Store.StoreBase.Unlock ( )

pure virtual

This method is called after the end of a sequence of Write commands between consistant states of some data structure represented by the store.

See the Lock method for a further description of the operation of this locking mechanism.

See also: Lock

Implements Deveel.Data.Store.IStore.

Implemented in Deveel.Data.Store.SingleFileStore.

void Deveel.Data.Store.StoreBase.Write	(	long	offset,
		byte	value
	)

inlineprotected

Definition at line 876 of file StoreBase.cs.

                                                       {
             Write(offset, new []{value}, 0, 1);
         }

abstract void Deveel.Data.Store.StoreBase.Write	(	long	offset,
		byte[]	buffer,
		int	index,
		int	length
	)

protectedpure virtual

Implemented in Deveel.Data.Store.SingleFileStore.

void Deveel.Data.Store.StoreBase.WriteAllBins ( )

inlineprivate

Definition at line 108 of file StoreBase.cs.

                                     {
             int p = 0;
             for (int i = 0; i < 128; ++i, p += 8) {
                 long val = freeBinList[i];
                 ByteBuffer.WriteInt8(val, binArea, p);
             }
 
             Write(BinAreaOffset, binArea, 0, 128 * 8);
         }

void Deveel.Data.Store.StoreBase.WriteBinIndex ( int index )

inlineprivate

Definition at line 118 of file StoreBase.cs.

                                               {
             int p = index * 8;
             long val = freeBinList[index];
             ByteBuffer.WriteInt8(val, binArea, p);
             Write(BinAreaOffset + p, binArea, p, 8);
         }

Member Data Documentation

const long Deveel.Data.Store.StoreBase.ActiveFlag = Int64.MaxValue

private

Definition at line 49 of file StoreBase.cs.

readonly byte [] Deveel.Data.Store.StoreBase.binArea = new byte[128 * 8]

private

Definition at line 29 of file StoreBase.cs.

const long Deveel.Data.Store.StoreBase.BinAreaOffset = 256

private

Definition at line 57 of file StoreBase.cs.

readonly int Deveel.Data.Store.StoreBase.BinSizeEntries = BinSizes.Length

staticprivate

Definition at line 46 of file StoreBase.cs.

readonly int [] Deveel.Data.Store.StoreBase.BinSizes

staticprivate

Initial value:

=
            {
                32, 64, 96, 128, 160, 192, 224, 256, 288, 320, 352, 384, 416, 448, 480,
                512, 544, 576, 608, 640, 672, 704, 736, 768, 800, 832, 864, 896, 928,
                960, 992, 1024, 1056, 1088, 1120, 1152, 1184, 1216, 1248, 1280, 1312,
                1344, 1376, 1408, 1440, 1472, 1504, 1536, 1568, 1600, 1632, 1664, 1696,
                1728, 1760, 1792, 1824, 1856, 1888, 1920, 1952, 1984, 2016, 2048, 2080,
                2144, 2208, 2272, 2336, 2400, 2464, 2528, 2592, 2656, 2720, 2784, 2848,
                2912, 2976, 3040, 3104, 3168, 3232, 3296, 3360, 3424, 3488, 3552, 3616,
                3680, 3744, 3808, 3872, 3936, 4000, 4064, 4128, 4384, 4640, 4896, 5152,
                5408, 5664, 5920, 6176, 6432, 6688, 6944, 7200, 7456, 7712, 7968, 8224,
                10272, 12320, 14368, 16416, 18464, 20512, 22560, 24608, 57376, 90144,
                122912, 155680, 1204256, 2252832
            }

Definition at line 31 of file StoreBase.cs.

const long Deveel.Data.Store.StoreBase.DataAreaOffset = 256 + 1024 + 32

private

Definition at line 55 of file StoreBase.cs.

const long Deveel.Data.Store.StoreBase.DeletedFlag = Int64.MinValue

private

Definition at line 50 of file StoreBase.cs.

bool Deveel.Data.Store.StoreBase.disposed

private

Definition at line 743 of file StoreBase.cs.

const long Deveel.Data.Store.StoreBase.FixedAreaOffset = 128

private

Definition at line 52 of file StoreBase.cs.

long [] Deveel.Data.Store.StoreBase.freeBinList

private

Definition at line 26 of file StoreBase.cs.

readonly byte [] Deveel.Data.Store.StoreBase.headerBuf = new byte[16]

private

Definition at line 348 of file StoreBase.cs.

const int Deveel.Data.Store.StoreBase.Magic = 0x0AEAE91

private

Definition at line 59 of file StoreBase.cs.

readonly int Deveel.Data.Store.StoreBase.MaxBinSize = BinSizes[BinSizeEntries - 1]

staticprivate

Definition at line 47 of file StoreBase.cs.

long Deveel.Data.Store.StoreBase.totalAllocatedSpace

private

Definition at line 27 of file StoreBase.cs.

Property Documentation

bool Deveel.Data.Store.StoreBase.ClosedClean

getprivate set

Definition at line 783 of file StoreBase.cs.

abstract long Deveel.Data.Store.StoreBase.DataAreaEndOffset

getprotected

Definition at line 80 of file StoreBase.cs.

bool Deveel.Data.Store.StoreBase.IsReadOnly

getprivate set

Definition at line 78 of file StoreBase.cs.

long Deveel.Data.Store.StoreBase.WildernessOffset

getsetprivate

Definition at line 76 of file StoreBase.cs.

The documentation for this class was generated from the following file:

/var/calculate/remote/distfiles/egit-src/deveeldb.git/src/deveeldb/Deveel.Data.Store/StoreBase.cs

Classes

Public Member Functions

Protected Member Functions

Package Functions

Properties

Private Member Functions

Static Private Member Functions

Private Attributes

Static Private Attributes

Detailed Description

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation

Property Documentation