Inheritance diagram for Deveel.Data.Store.SingleFileStore:

Public Member Functions
override 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...

override 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...

Public Member Functions inherited from Deveel.Data.Store.StoreBase
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...

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
override void	SetDataAreaSize (long length)

override void	OpenStore (bool readOnly)

override void	CloseStore ()

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

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

override void	Dispose (bool disposing)

Protected Member Functions inherited from Deveel.Data.Store.StoreBase
	StoreBase (bool isReadOnly)

void	ReadAreaHeader (long offset, long[] header)

void	SplitArea (long offset, long newBoundary)

int	ReadByte (long offset)

void	Write (long offset, byte value)

Package Functions
	SingleFileStore (SingleFileStoreSystem system, string name, int id)

void	Create (int bufferSize)

void	WriteTo (Stream stream)

Package Functions inherited from Deveel.Data.Store.StoreBase
IEnumerable< long >	FindAllocatedAreasNotIn (List< long > usedAreas)

Properties
string	Name `[get, private set]`

int	Id `[get, private set]`

bool	IsOpen `[get, private set]`

object	CheckPointLock `[get]`

override long	DataAreaEndOffset `[get]`

long	DataLength `[get]`

Properties inherited from Deveel.Data.Store.StoreBase
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 Attributes
SingleFileStoreSystem	system

Stream	dataStream

int	lockCount

bool	disposed

Detailed Description

Definition at line 25 of file SingleFileStore.cs.

Constructor & Destructor Documentation

Deveel.Data.Store.SingleFileStore.SingleFileStore	(	SingleFileStoreSystem	system,
		string	name,
		int	id
	)

inlinepackage

Definition at line 32 of file SingleFileStore.cs.

             : base(system.IsReadOnly) {
             this.system = system;
             Name = name;
             Id = id;
         }

Member Function Documentation

override void Deveel.Data.Store.SingleFileStore.CloseStore ( )

inlineprotectedvirtual

Implements Deveel.Data.Store.StoreBase.

Definition at line 99 of file SingleFileStore.cs.

                                              {
             lock (CheckPointLock) {
                 if (lockCount == 0)
                     IsOpen = false;
             }
         }

void Deveel.Data.Store.SingleFileStore.Create ( int bufferSize )

inlinepackage

Definition at line 66 of file SingleFileStore.cs.

                                              {
             lock (CheckPointLock) {
                 dataStream = new MemoryStream(bufferSize);
                 IsOpen = true;
             }
         }

override void Deveel.Data.Store.SingleFileStore.Dispose ( bool disposing )

inlineprotectedvirtual

Reimplemented from Deveel.Data.Store.StoreBase.

Definition at line 127 of file SingleFileStore.cs.

                                                         {
             if (!disposed) {
                 base.Dispose(disposing);
 
                 if (disposing) {
                     lock (CheckPointLock) {
                         if (dataStream != null)
                             dataStream.Dispose();
                     }
                 }
 
                 dataStream = null;
                 system = null;
                 IsOpen = false;
                 disposed = true;
             }
         }

override void Deveel.Data.Store.SingleFileStore.Lock ( )

inlinevirtual

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.StoreBase.

Definition at line 73 of file SingleFileStore.cs.

                                     {
             lockCount++;
         }

override void Deveel.Data.Store.SingleFileStore.OpenStore ( bool readOnly )

inlineprotectedvirtual

Implements Deveel.Data.Store.StoreBase.

Definition at line 85 of file SingleFileStore.cs.

                                                          {
             lock (CheckPointLock) {
                 dataStream = new MemoryStream();
 
                 var inputStream = system.LoadStoreData(Id);
                 if (inputStream != null) {
                     inputStream.Seek(0, SeekOrigin.Begin);
                     inputStream.CopyTo(dataStream);
                 }
 
                 IsOpen = true;
             }
         }

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

inlineprotectedvirtual

Implements Deveel.Data.Store.StoreBase.

Definition at line 106 of file SingleFileStore.cs.

                                                                                        {
             lock (CheckPointLock) {
                 if (dataStream == null || !IsOpen)
                     return 0;
 
                 dataStream.Seek(offset, SeekOrigin.Begin);
                 return dataStream.Read(buffer, index, length);
             }
         }

override void Deveel.Data.Store.SingleFileStore.SetDataAreaSize ( long length )

inlineprotectedvirtual

Implements Deveel.Data.Store.StoreBase.

Definition at line 59 of file SingleFileStore.cs.

                                                              {
             lock (CheckPointLock) {
                 if (dataStream != null)
                     dataStream.SetLength(length);
             }
         }

override void Deveel.Data.Store.SingleFileStore.Unlock ( )

inlinevirtual

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.StoreBase.

Definition at line 77 of file SingleFileStore.cs.

                                       {
             lockCount--;
         }

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

inlineprotectedvirtual

Implements Deveel.Data.Store.StoreBase.

Definition at line 116 of file SingleFileStore.cs.

                                                                                          {
             lock (CheckPointLock) {
                 if (dataStream != null && IsOpen) {
                     dataStream.Seek(offset, SeekOrigin.Begin);
                     dataStream.Write(buffer, index, length);
                 }
             }
         }

void Deveel.Data.Store.SingleFileStore.WriteTo ( Stream stream )

inlinepackage

Definition at line 145 of file SingleFileStore.cs.

                                              {
             lock (CheckPointLock) {
                 if (dataStream != null) {
                     dataStream.Seek(0, SeekOrigin.Begin);
                     dataStream.CopyTo(stream);
                 }
             }
         }

Member Data Documentation

Stream Deveel.Data.Store.SingleFileStore.dataStream

private

Definition at line 27 of file SingleFileStore.cs.

bool Deveel.Data.Store.SingleFileStore.disposed

private

Definition at line 125 of file SingleFileStore.cs.

int Deveel.Data.Store.SingleFileStore.lockCount

private

Definition at line 30 of file SingleFileStore.cs.

SingleFileStoreSystem Deveel.Data.Store.SingleFileStore.system

private

Definition at line 26 of file SingleFileStore.cs.

Property Documentation

object Deveel.Data.Store.SingleFileStore.CheckPointLock

getprivate

Definition at line 45 of file SingleFileStore.cs.

override long Deveel.Data.Store.SingleFileStore.DataAreaEndOffset

getprotected

Definition at line 49 of file SingleFileStore.cs.

long Deveel.Data.Store.SingleFileStore.DataLength

get

Definition at line 53 of file SingleFileStore.cs.

int Deveel.Data.Store.SingleFileStore.Id

getprivate set

Definition at line 41 of file SingleFileStore.cs.

bool Deveel.Data.Store.SingleFileStore.IsOpen

getprivate set

Definition at line 43 of file SingleFileStore.cs.

string Deveel.Data.Store.SingleFileStore.Name

getprivate set

Definition at line 39 of file SingleFileStore.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/SingleFileStore.cs

Public Member Functions

Protected Member Functions

Package Functions

Properties

Private Attributes

Detailed Description

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation

Property Documentation