/// <summary>
/// Initialize.
/// </summary>
/// <param name="file"></param>
/// <param name="dataBlocksMruManager"></param>
/// <param name="name"></param>
/// <param name="extraParams"></param>
protected void Initialize(File.IFile file, string name,
params KeyValuePair <string, object>[] extraParams)
{
this.Name = name;
KeyValuePair <string, object>[] p = extraParams;
Initialize(file, p);
}
public ConcurrentBTreeAlgorithm(File.IFile file,
System.Collections.IComparer comparer = null,
string name = null,
DataBlock.IDataBlockDriver dataBlockDriver = null,
bool isDataInKeySegment = true)
{
Collection = new Algorithm.BTree.BTreeAlgorithm(file, comparer, name, dataBlockDriver, isDataInKeySegment);
}
public BTreeAlgorithm(File.IFile file,
IComparer comparer,
string name,
IDataBlockDriver dataBlockDriver
)
: this(file, comparer, name, null, false)
{
}
public ConcurrentIOData GetInstance(File.IFile f, long size = 0)
{
if (f.Server != null && f.Server.Transaction != null)
{
return(GetInstance(f.Filename,
(TransactionRoot)
((TransactionBase)f.Server.Transaction).Root, size));
}
return(GetInstance(f.Filename, null, size));
}
/// <summary>
/// Returns the File object with its Name equal to Name argument
/// </summary>
/// <param name="name"></param>
/// <returns></returns>
public IFile GetFile(string name)
{
File.IFile r = (File.IFile)SystemFile;
if (r.Name == name || r.Filename == name)
{
return(r);
}
r = (File.IFile)FileSet[name];
if (r == null)
{
string s = NormalizePath(name);
r = (File.IFile)FileSet[s];
}
return(r);
}
public IndexedBlockRecycler(
File.IFile file, IComparer comparer, string name
)
{
IsDataLongInt = true;
var param = new[]
{
new KeyValuePair <string, object>("Comparer", comparer),
new KeyValuePair <string, object>("DataBlockDriver", null)
};
Name = name;
Initialize(file, param);
_segmentSize = file.CollectionGrowthSizeInNob * (int)DataBlockSize;
}
/// <summary>
/// Serialize an Object to the target DataBlock
/// </summary>
/// <param name="file"></param>
/// <param name="value"></param>
/// <param name="dataBlock"></param>
public void WriteObject(File.IFile file, object value, Sop.DataBlock dataBlock)
{
if (value == null)
{
throw new ArgumentNullException("value");
}
this.DataBlock = dataBlock;
if (value is IInternalPersistent)
{
((IInternalPersistent)value).Pack(file, this);
}
else
{
_serializer.Serialize(this.BaseStream, value);
this.Write(_buffer.GetBuffer(), 0, (int)this.BaseStream.Position);
}
}
protected internal override void Initialize(File.IFile file, params KeyValuePair <string, object>[] parameters)
{
base.Initialize(file, parameters);
if (FirstItem == null)
{
FirstItem = new LinkedItemOnDisk(file.DataBlockSize);
}
if (CurrentItem == null)
{
CurrentItem = FirstItem;
}
if (LastItem == null)
{
LastItem = new LinkedItemOnDisk(file.DataBlockSize);
}
//** don't call open here, let caller code do it to ensure proper "state" when Open is called!!
}
public BTreeAlgorithm(File.IFile file,
IComparer comparer,
string name,
IDataBlockDriver dataBlockDriver,
bool isDataInKeySegment
)
{
this.Name = name;
var p = new[]
{
new KeyValuePair <string, object>("comparer", comparer),
new KeyValuePair <string, object>("DataBlockDriver",
dataBlockDriver)
};
IsDataInKeySegment = isDataInKeySegment;
Initialize(file, p);
}
public LinkedListOnDisk(File.IFile container) : this(container, string.Empty)
{
}
public SharedBlockOnDiskList(File.IFile container,
params KeyValuePair <string, object>[] extraParams)
: base(container, string.Empty, extraParams)
{
}
public SharedBlockOnDiskList(File.IFile container) : base(container)
{
}
/// <summary>
/// Create Dictionary On Disk
/// </summary>
/// <param name="file"></param>
/// <returns></returns>
public static Algorithm.SortedDictionary.ISortedDictionaryOnDisk CreateDictionaryOnDisk(File.IFile file)
{
return(CreateDictionaryOnDisk(file, new BTreeDefaultComparer()));
}
/// <summary>
/// Create Dictionary On Disk
/// </summary>
/// <param name="file"></param>
/// <param name="comparer"></param>
/// <returns></returns>
public static Algorithm.SortedDictionary.ISortedDictionaryOnDisk CreateDictionaryOnDisk(File.IFile file, IComparer comparer)
{
return(CreateDictionaryOnDisk(file, comparer, string.Empty, file.Profile.IsDataInKeySegment));
}
public BTreeAlgorithm(File.IFile file, IComparer comparer)
: this(file, comparer, string.Empty)
{
}
/// <summary>
/// Initialize. NOTE: this function doesn't open the file.
/// </summary>
/// <param name="file"></param>
/// <param name="parameters"> </param>
protected internal virtual void Initialize(File.IFile file, params KeyValuePair <string, object>[] parameters)
{
if (file == null)
{
throw new ArgumentNullException("file");
}
if (transaction == null ||
(transaction is Transaction.Transaction &&
((Transaction.Transaction)transaction).Server != file.Server))
{
Transaction.ITransactionLogger trans = file.Transaction;
if (trans != null)
{
trans = ((Transaction.TransactionBase)trans).GetLeafChild();
}
if (trans == null ||
trans is Transaction.Transaction)
{
transaction = trans;
}
}
if (string.IsNullOrEmpty(this.Name))
{
var f = new FileInfo(file.Filename);
Name = string.Format("{0} Collection {1}", f.Name, ((Sop.OnDisk.File.File)file).GetNewStoreId());
}
if (MruMinCapacity == 0)
{
MruMinCapacity = file.Profile.MruMinCapacity;
}
if (MruMaxCapacity == 0)
{
MruMaxCapacity = file.Profile.MruMaxCapacity;
}
if (File == null)
{
File = file;
}
if (DataBlockSize == DataBlockSize.Unknown)
{
DataBlockSize = file.DataBlockSize;
}
HeaderData hd = null;
if (parameters != null && parameters.Length > 0)
{
foreach (KeyValuePair <string, object> o in parameters)
{
switch (o.Key)
{
case "HasMruSegments":
break;
case "HeaderData":
hd = (HeaderData)o.Value;
break;
default:
if (o.Key == "DataBlockDriver" && o.Value != null)
{
DataBlockDriver = (IDataBlockDriver)o.Value;
}
break;
}
}
}
if (DataBlockDriver == null)
{
DataBlockDriver = new DataBlockDriver(this, hd);
}
else
{
if (DataBlockDriver.HeaderData == null)
{
DataBlockDriver.HeaderData = hd ?? new HeaderData(DataBlockSize);
}
}
if (MruManager == null)
{
int min = MruMinCapacity;
int max = MruMaxCapacity;
//MruManager = new ConcurrentMruManager(min, max);
MruManager = new MruManager(min, max);
MruManager.SetDataStores(this, DataBlockDriver);
}
if (_diskBuffer == null)
{
_diskBuffer = CreateBlock(); //new Sop.DataBlock(DataBlockSize);
}
}
public virtual void Initialize(File.IFile file)
{
RealDictionary.Initialize(file);
}
public BTreeAlgorithm(File.IFile file)
: this(file, new BTreeDefaultComparer())
{
}
public FileRecycler(File.IFile file)
: base(file, new BTreeDefaultComparer())
{
}
public static Algorithm.SortedDictionary.ISortedDictionaryOnDisk CreateDictionaryOnDisk(File.IFile file, string name)
{
return(CreateDictionaryOnDisk(file, null, name, file.Profile.IsDataInKeySegment));
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="file"></param>
/// <param name="dataBlocksMruManager"></param>
protected CollectionOnDisk(File.IFile file)
{
Initialize(file, string.Empty);
}
public LinkedListOnDisk(File.IFile container, string name,
params KeyValuePair <string, object>[] extraParams)
{
Initialize(container, name, extraParams);
}
public BTreeAlgorithm(File.IFile file,
IComparer comparer,
string name)
: this(file, comparer, name, null)
{
}
public SdodWrapper(File.IFile file, System.Collections.IComparer comparer, string name,
bool isDataInKeySegment)
{
RealDictionary = new SortedDictionaryOnDisk(file, comparer, name, isDataInKeySegment);
}
/// <summary>
/// Create Dictionary On Disk
/// </summary>
/// <param name="file"></param>
/// <param name="comparer"></param>
/// <param name="name"></param>
/// <param name="isDataInKeySegment"> </param>
/// <returns></returns>
public static Algorithm.SortedDictionary.ISortedDictionaryOnDisk CreateDictionaryOnDisk(File.IFile file, IComparer comparer, string name,
bool isDataInKeySegment)
{
return
((Algorithm.SortedDictionary.ISortedDictionaryOnDisk)
ObjectFactory.Instance.GetDictionaryOnDisk(file, comparer, name, isDataInKeySegment));
}