Inheritance diagram for Deveel.Data.Store.ScatteringFileStoreData:

Public Member Functions
	ScatteringFileStoreData (IFileSystem fileSystem, string basePath, string fileName, string fileExtention, int maxFileSlice)

void	Dispose ()

bool	Delete ()
	Deletes the data block. More...

void	Open (bool readOnly)
	Opens the data block and make it ready to be accessed. More...

void	Close ()
	Closes the block and make it unavailable. More...

int	Read (long position, byte[] buffer, int offset, int length)
	Reads a given amount of data from the block, starting at the absolute position given and copying into the provided buffer. More...

void	Write (long position, byte[] buffer, int offset, int length)
	Writes a given buffer into the block, starting at the absolute position given. More...

void	Flush ()
	Flushes the data written in the temporary store of the block to the underlying medium. More...

void	SetLength (long value)
	Sets the length of the data block. More...

Properties
string	BasePath `[get, private set]`

string	FileName `[get, private set]`

string	FileExtention `[get, private set]`

int	MaxFileSlice `[get, private set]`

IFileSystem	FileSystem `[get, private set]`

int	FileCount `[get]`

bool	IsOpen `[get, private set]`

bool	Exists `[get]`

long	Length `[get]`

bool	IsReadOnly `[get, private set]`

Properties inherited from Deveel.Data.Store.IStoreData
bool	Exists `[get]`
	Gets a value indicating whether the data block object exists. More...

long	Length `[get]`
	Gets the current length of the data block. More...

bool	IsReadOnly `[get]`
	Gets a value indicating whether the data block is in read-only mode. More...

Private Member Functions
	~ScatteringFileStoreData ()

string	SliceFileName (int i)

long	DiscoverSize ()

void	Dispose (bool disposing)

Private Attributes
readonly object	objectLock = new object()

List< FileStoreData >	fileSlices

long	trueFileLength

Detailed Description

Definition at line 23 of file ScatteringFileStoreData.cs.

Constructor & Destructor Documentation

Deveel.Data.Store.ScatteringFileStoreData.ScatteringFileStoreData	(	IFileSystem	fileSystem,
		string	basePath,
		string	fileName,
		string	fileExtention,
		int	maxFileSlice
	)

inline

Definition at line 28 of file ScatteringFileStoreData.cs.

                                                                                                                                          {
             if (fileSystem == null)
                 throw new ArgumentNullException("fileSystem");
 
             FileSystem = fileSystem;
             MaxFileSlice = maxFileSlice;
             FileExtention = fileExtention;
             FileName = fileName;
             BasePath = basePath;
             fileSlices = new List<FileStoreData>();
         }

Deveel.Data.Store.ScatteringFileStoreData.~ScatteringFileStoreData ( )

inlineprivate

Definition at line 40 of file ScatteringFileStoreData.cs.

                                    {
             Dispose(false);
         }

Member Function Documentation

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

inline

Closes the block and make it unavailable.

When IDisposable.Dispose is invoked this method is also called to prevent any operation before disposal.

Implements Deveel.Data.Store.IStoreData.

Definition at line 198 of file ScatteringFileStoreData.cs.

                             {
             lock (objectLock) {
                 foreach (var slice in fileSlices) {
                     slice.Close();
                 }
             }
         }

bool Deveel.Data.Store.ScatteringFileStoreData.Delete ( )

inline

Deletes the data block.

Returns: Returns true if the block was successfully deleted, or false otherwise.

Implements Deveel.Data.Store.IStoreData.

Definition at line 135 of file ScatteringFileStoreData.cs.

                              {
             // The number of files
             int countFiles = FileCount;
             // Delete each file from back to front
             for (int i = countFiles - 1; i >= 0; --i) {
                 string f = SliceFileName(i);
                 bool deleteSuccess = new FileStoreData(f).Delete();
                 if (!deleteSuccess)
                     return false;
             }
             return true;
         }

long Deveel.Data.Store.ScatteringFileStoreData.DiscoverSize ( )

inlineprivate

Definition at line 84 of file ScatteringFileStoreData.cs.

                                     {
             long runningTotal = 0;
 
             lock (objectLock) {
                 // Does the file exist?
                 int i = 0;
                 string f = SliceFileName(i);
                 while (FileSystem.FileExists(f)) {
                     var fileLength = FileSystem.GetFileSize(f);
 
                     runningTotal += fileLength;
 
                     ++i;
                     f = SliceFileName(i);
                 }
             }
 
             return runningTotal;
         }

void Deveel.Data.Store.ScatteringFileStoreData.Dispose ( bool disposing )

inlineprivate

Definition at line 104 of file ScatteringFileStoreData.cs.

                                              {
             if (disposing) {
                 foreach (var slice in fileSlices) {
                     if (slice != null)
                         slice.Dispose();
                 }
 
                 fileSlices.Clear();
                 fileSlices = null;
             }
         }

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

inline

Definition at line 116 of file ScatteringFileStoreData.cs.

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

void Deveel.Data.Store.ScatteringFileStoreData.Flush ( )

inline

Flushes the data written in the temporary store of the block to the underlying medium.

Implements Deveel.Data.Store.IStoreData.

Definition at line 267 of file ScatteringFileStoreData.cs.

                             {
             lock (objectLock) {
                 foreach (var slice in fileSlices) {
                     slice.Flush();
                 }
             }
         }

void Deveel.Data.Store.ScatteringFileStoreData.Open ( bool readOnly )

inline

Opens the data block and make it ready to be accessed.

Parameters

readOnly Indicates if the block must be open in read-only mode.

Implements Deveel.Data.Store.IStoreData.

Definition at line 148 of file ScatteringFileStoreData.cs.

                                         {
             lock (objectLock) {
                 // Does the file exist?
                 string f = SliceFileName(0);
                 bool openExisting = FileSystem.FileExists(f);
 
                 // If the file already exceeds the threshold and there isn't a secondary
                 // file then we need to convert the file.
                 if (openExisting && f.Length > MaxFileSlice) {
                     string f2 = SliceFileName(1);
                     if (FileSystem.FileExists(f2))
                         throw new IOException("File length exceeds maximum slice size setting.");
 
                     // We need to scatter the file.
                     if (readOnly)
                         throw new IOException("Unable to convert to a scattered store because Read-only.");                     
                 }
 
                 // Setup the first file slice
                 var slice = new FileStoreData(f);
                 slice.Open(readOnly);
 
                 fileSlices.Add(slice);
                 long runningLength = slice.Length;
 
                 // If we are opening a store that exists already, there may be other
                 // slices we need to setup.
                 if (openExisting) {
                     int i = 1;
                     string slicePart = SliceFileName(i);
                     while (FileSystem.FileExists(slicePart)) {
                         // Create the new slice information for this part of the file.
                         slice = new FileStoreData(slicePart);
                         slice.Open(readOnly);
 
                         fileSlices.Add(slice);
                         runningLength += slice.Length;
 
                         ++i;
                         slicePart = SliceFileName(i);
                     }
                 }
 
                 trueFileLength = runningLength;
                 IsOpen = true;
                 IsReadOnly = readOnly;
             }
 
         }

int Deveel.Data.Store.ScatteringFileStoreData.Read	(	long	position,
		byte[]	buffer,
		int	offset,
		int	length
	)

inline

Reads a given amount of data from the block, starting at the absolute position given and copying into the provided buffer.

Parameters

position	The absolute position within the data block from where to start reading.
buffer	The destination buffer where the data read will be filled in.
offset	The starting offset within the buffer where to start copying the data read.
length	The desired number of bytes to read from the data block.

Returns: Returns the actual number of bytes read from the data block or 0 if the end of the block was reached.

Implements Deveel.Data.Store.IStoreData.

Definition at line 206 of file ScatteringFileStoreData.cs.

                                                                               {
             // Reads the array (potentially across multiple slices).
             int count = 0;
             while (length > 0) {
                 int fileI = (int)(position / MaxFileSlice);
                 long fileP = (position % MaxFileSlice);
                 int fileLen = (int)System.Math.Min((long)length, MaxFileSlice - fileP);
 
                 FileStoreData slice;
                 lock (objectLock) {
                     // Return if out of bounds.
                     if (fileI < 0 || fileI >= fileSlices.Count) {
                         // Error if not open
                         if (!IsOpen)
                             throw new IOException("Store not open.");
 
                         return 0;
                     }
                     slice = fileSlices[fileI];
                 }
 
                 int readCount =slice.Read(fileP, buffer, offset, fileLen);
                 if (readCount == 0)
                     break;
 
                 position += readCount;
                 offset += readCount;
                 length -= readCount;
                 count += readCount;
             }
 
             return count;
         }

void Deveel.Data.Store.ScatteringFileStoreData.SetLength ( long value )

inline

Sets the length of the data block.

Parameters

value The new size to set for the data block.

If the value is less than Length this method will shrink the data block and trim the exceeding contents. If the value is more than Length then it is responsibility of the implementation of this contract to increase the contents.

Implements Deveel.Data.Store.IStoreData.

Definition at line 275 of file ScatteringFileStoreData.cs.

                                           {
             lock (objectLock) {
                 // The size we need to grow the data area
                 long totalSizeToGrow = value - trueFileLength;
                 // Assert that we aren't shrinking the data area size.
                 if (totalSizeToGrow < 0) {
                     throw new IOException("Unable to make the data area size " +
                                           "smaller for this type of store.");
                 }
 
                 while (totalSizeToGrow > 0) {
                     // Grow the last slice by this size
                     int last = fileSlices.Count - 1;
                     var slice = fileSlices[last];
                     long oldSliceLength = slice.Length;
                     long toGrow = System.Math.Min(totalSizeToGrow, (MaxFileSlice - oldSliceLength));
 
                     // Flush the buffer and set the length of the file
                     slice.SetLength(oldSliceLength + toGrow);
                     slice.Flush();
 
                     totalSizeToGrow -= toGrow;
                     // Create a new empty slice if we need to extend the data area
                     if (totalSizeToGrow > 0) {
                         string sliceFile = SliceFileName(last + 1);
 
                         slice = new FileStoreData(sliceFile);
                         slice.Open(false);
 
                         fileSlices.Add(slice);
                     }
                 }
                 trueFileLength = value;
             }
         }

string Deveel.Data.Store.ScatteringFileStoreData.SliceFileName ( int i )

inlineprivate

Definition at line 68 of file ScatteringFileStoreData.cs.

                                             {
             if (i == 0)
                 return FileSystem.CombinePath(BasePath, String.Format("{0}.{1}", FileName, FileExtention));
 
             var fn = new StringBuilder();
             fn.Append(FileName);
             fn.Append(".");
             if (i < 10) {
                 fn.Append("00");
             } else if (i < 100) {
                 fn.Append("0");
             }
             fn.Append(i);
             return Path.Combine(BasePath, fn.ToString());
         }

void Deveel.Data.Store.ScatteringFileStoreData.Write	(	long	position,
		byte[]	buffer,
		int	offset,
		int	length
	)

inline

Writes a given buffer into the block, starting at the absolute position given.

Parameters

position	The absolute position within the data block from where to start writing.
buffer	The data to write into the block.
offset	The starting offset within the buffer where to start writing data from.
length	The number of bytes to write into the data block.

Implements Deveel.Data.Store.IStoreData.

Definition at line 240 of file ScatteringFileStoreData.cs.

                                                                                 {
             // Writes the array (potentially across multiple slices).
             while (length > 0) {
                 var fileI = (int)(position / MaxFileSlice);
                 var fileP = (position % MaxFileSlice);
                 var fileLen = (int)System.Math.Min((long)length, MaxFileSlice - fileP);
 
                 FileStoreData slice;
                 lock (objectLock) {
                     // Return if out of bounds.
                     if (fileI < 0 || fileI >= fileSlices.Count) {
                         if (!IsOpen)
                             throw new IOException("Store not open.");
 
                         return;
                     }
                     slice = fileSlices[fileI];
                 }
 
                 slice.Write(fileP, buffer, offset, fileLen);
 
                 position += fileLen;
                 offset += fileLen;
                 length -= fileLen;
             }
         }

Member Data Documentation

List<FileStoreData> Deveel.Data.Store.ScatteringFileStoreData.fileSlices

private

Definition at line 25 of file ScatteringFileStoreData.cs.

readonly object Deveel.Data.Store.ScatteringFileStoreData.objectLock = new object()

private

Definition at line 24 of file ScatteringFileStoreData.cs.

long Deveel.Data.Store.ScatteringFileStoreData.trueFileLength

private

Definition at line 26 of file ScatteringFileStoreData.cs.

Property Documentation

string Deveel.Data.Store.ScatteringFileStoreData.BasePath

getprivate set

Definition at line 44 of file ScatteringFileStoreData.cs.

bool Deveel.Data.Store.ScatteringFileStoreData.Exists

get

Definition at line 121 of file ScatteringFileStoreData.cs.

int Deveel.Data.Store.ScatteringFileStoreData.FileCount

get

Definition at line 54 of file ScatteringFileStoreData.cs.

string Deveel.Data.Store.ScatteringFileStoreData.FileExtention

getprivate set

Definition at line 48 of file ScatteringFileStoreData.cs.

string Deveel.Data.Store.ScatteringFileStoreData.FileName

getprivate set

Definition at line 46 of file ScatteringFileStoreData.cs.

IFileSystem Deveel.Data.Store.ScatteringFileStoreData.FileSystem

getprivate set

Definition at line 52 of file ScatteringFileStoreData.cs.

bool Deveel.Data.Store.ScatteringFileStoreData.IsOpen

getprivate set

Definition at line 66 of file ScatteringFileStoreData.cs.

bool Deveel.Data.Store.ScatteringFileStoreData.IsReadOnly

getprivate set

Definition at line 133 of file ScatteringFileStoreData.cs.

long Deveel.Data.Store.ScatteringFileStoreData.Length

get

Definition at line 125 of file ScatteringFileStoreData.cs.

int Deveel.Data.Store.ScatteringFileStoreData.MaxFileSlice

getprivate set

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

Public Member Functions

Properties

Private Member Functions

Private Attributes

Detailed Description

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation

Property Documentation