public void TestInit()
{
_driver = GetDriver();
_testAccessCount = 0;
_target = new KeyCollection<TestModel, int>(_driver,
_GetTestModelByKey);
}
/// <summary>
/// Contract for driver
/// </summary>
/// <param name="driver">The driver</param>
private static void _ContractForDriver(ISterlingDriver driver)
{
if (driver == null)
{
throw new ArgumentNullException("driver");
}
}
public SterlingContentStore(ISterlingDatabase db, ISterlingDriver driver)
{
Contract.Requires <ArgumentNullException>(db != null, "db");
Contract.Requires <ArgumentNullException>(driver != null, "driver");
Instance = db.RegisterDatabase <ContentStoreDB>("ContentStore", driver);
}
public void TestInit()
{
_driver = GetDriver();
_testAccessCount = 0;
_target = new KeyCollection <TestModel, int>(_driver,
_GetTestModelByKey);
}
/// <summary>
/// Contract for driver
/// </summary>
/// <param name="driver">The driver</param>
private static void _ContractForDriver(ISterlingDriver driver)
{
if (driver == null)
{
throw new ArgumentNullException("driver");
}
}
/// <summary>
/// Initialize the key collection
/// </summary>
/// <param name="driver">Driver</param>
/// <param name="resolver">The resolver for loading the object</param>
public KeyCollection(ISterlingDriver driver, Func <TKey, T> resolver)
{
this._driver = driver;
this._resolver = resolver;
_DeserializeKeys();
this.IsDirty = false;
}
/// <summary>
/// Register a database type with the system
/// </summary>
/// <typeparam name="T">The type of the database to register</typeparam>
public ISterlingDatabaseInstance RegisterDatabase <T>(ISterlingDriver driver) where T : BaseDatabaseInstance
{
_RequiresActivation();
_logManager.Log(SterlingLogLevel.Information,
string.Format("Sterling is registering database {0}", typeof(T)),
null);
if ((from d in _databases where d.Value.Item1.Equals(typeof(T)) select d).Count() > 0)
{
throw new SterlingDuplicateDatabaseException(typeof(T));
}
var database = (ISterlingDatabaseInstance)Activator.CreateInstance(typeof(T));
if (driver == null)
{
driver = new MemoryDriver(database, _serializer, _logManager.Log);
}
else
{
driver.Database = database;
driver.DatabaseSerializer = _serializer;
driver.Log = _logManager.Log;
}
((BaseDatabaseInstance)database).Serializer = _serializer;
((BaseDatabaseInstance)database).RegisterTypeResolvers();
((BaseDatabaseInstance)database).RegisterPropertyConverters();
((BaseDatabaseInstance)database).PublishTables(driver);
_databases.Add(database.Name, new Tuple <Type, ISterlingDatabaseInstance>(typeof(T), database));
return(database);
}
/// <summary>
/// Get types path
/// </summary>
/// <param name="basePath"></param>
/// <param name="databaseName"></param>
/// <param name="driver"></param>
/// <returns></returns>
public string GetTypesPath(string basePath, string databaseName, ISterlingDriver driver)
{
_ContractForBasePath(basePath);
_ContractForDatabaseName(databaseName);
_ContractForDriver(driver);
return(Path.Combine(GetDatabasePath(basePath, databaseName, driver), TYPE));
}
/// <summary>
/// Initialize the key collection
/// </summary>
/// <param name="driver">Driver</param>
/// <param name="resolver">The resolver for loading the object</param>
public KeyCollection(ISterlingDriver driver, Func <TKey, T> resolver)
{
_driver = driver;
_resolver = resolver;
_DeserializeKeysAsync().Wait();
IsDirty = false;
}
/// <summary>
/// Construct
/// </summary>
/// <param name="driver">Sterling driver</param>
/// <param name="resolver">The resolver for the instance</param>
/// <param name="key">The resolver for the key</param>
public TableDefinition(ISterlingDriver driver, Func <TKey, T> resolver, Func <T, TKey> key)
{
this._driver = driver;
this.FetchKey = key;
this._resolver = resolver;
this._isDirty = obj => true;
this.KeyList = new KeyCollection <T, TKey>(driver, resolver);
this.Indexes = new ConcurrentDictionary <string, IIndexCollection>();
}
/// <summary>
/// Construct
/// </summary>
/// <param name="driver">Sterling driver</param>
/// <param name="resolver">The resolver for the instance</param>
/// <param name="key">The resolver for the key</param>
public TableDefinition(ISterlingDriver driver, Func <TKey, T> resolver, Func <T, TKey> key)
{
_driver = driver;
FetchKey = key;
_resolver = resolver;
_isDirty = obj => true;
KeyList = new KeyCollection <T, TKey>(driver, resolver);
Indexes = new Dictionary <string, IIndexCollection>();
}
public void Init()
{
_driver = GetDriver();
_testModels = new List <TestModel>(3);
for (var x = 0; x < 3; x++)
{
_testModels.Add(TestModel.MakeTestModel());
}
_testAccessCount = 0;
_target = new IndexCollection <TestModel, string, int>("TestIndex", _driver,
tm => tm.Data, _GetTestModelByKey);
}
/// <summary>
/// Call to publish tables
/// </summary>
internal void PublishTables(ISterlingDriver driver)
{
this.Driver = driver;
foreach (var table in RegisterTables())
{
if (!this.TableDefinitions.TryAdd(table.TableType, table))
{
throw new SterlingDuplicateTypeException(table.TableType, this.Name);
}
}
this.Driver.PublishTables(this.TableDefinitions);
}
public void Init()
{
_driver = GetDriver();
_testModels = new List<TestModel>(3);
for(var x = 0; x < 3; x++)
{
_testModels.Add(TestModel.MakeTestModel());
}
_testAccessCount = 0;
_target = new IndexCollection<TestModel, string, int>("TestIndex",_driver,
tm => tm.Data , _GetTestModelByKey);
}
/// <summary>
/// Get the path for a database
/// </summary>
/// <param name="basePath">The base path</param>
/// <param name="databaseName">The database name</param>
/// <param name="driver"The driver></param>
/// <returns>The path</returns>
public string GetDatabasePath(string basePath, string databaseName, ISterlingDriver driver)
{
_ContractForBasePath(basePath);
_ContractForDatabaseName(databaseName);
_ContractForDriver(driver);
driver.Log(SterlingLogLevel.Verbose,
string.Format("Path Provider: Database Path Request: {0}", databaseName), null);
var path = Path.Combine(basePath, databaseName) + "/";
driver.Log(SterlingLogLevel.Verbose, string.Format("Resolved database path from {0} to {1}",
databaseName, path), null);
return(path);
}
/// <summary>
/// Call to publish tables
/// </summary>
internal void PublishTables(ISterlingDriver driver)
{
Driver = driver;
lock (((ICollection)TableDefinitions).SyncRoot)
{
foreach (var table in RegisterTables())
{
if (TableDefinitions.ContainsKey(table.TableType))
{
throw new SterlingDuplicateTypeException(table.TableType, Name);
}
TableDefinitions.Add(table.TableType, table);
}
}
Driver.PublishTables(TableDefinitions);
}
/// <summary>
/// Call to publish tables
/// </summary>
internal void PublishTables(ISterlingDriver driver)
{
using (LockAsync().Result)
{
Driver = driver;
foreach (var table in RegisterTables())
{
if (TableDefinitions.ContainsKey(table.TableType))
{
throw new SterlingDuplicateTypeException(table.TableType, Name);
}
TableDefinitions.Add(table.TableType, table);
}
Driver.PublishTables(TableDefinitions, this.Database.TypeResolver.ResolveTableType);
}
}
/// <summary>
/// Register a database type with the system
/// </summary>
/// <typeparam name="T">The type of the database to register</typeparam>
public ISterlingDatabaseInstance RegisterDatabase <T>(string instanceName, ISterlingDriver driver)
where T : BaseDatabaseInstance
{
_RequiresActivation();
LogManager.Log(SterlingLogLevel.Information,
string.Format("Sterling is registering database {0}", typeof(T)),
null);
var existing = _databases.Values.FirstOrDefault(tuple => tuple.Item1 == typeof(T));
if (existing != null)
{
return(existing.Item2);
}
var instance = (BaseDatabaseInstance)Activator.CreateInstance(typeof(T));
instance.Database = this;
if (driver == null)
{
driver = new MemoryDriver();
}
driver.DatabaseInstanceName = instanceName;
driver.DatabaseSerializer = _serializer;
driver.Log = LogManager.Log;
instance.Serializer = _serializer;
instance.RegisterTypeResolvers();
instance.RegisterPropertyConverters();
instance.PublishTables(driver);
_databases.Add(instanceName, new Tuple <Type, ISterlingDatabaseInstance>(typeof(T), instance));
return(instance);
}
public void Cleanup()
{
_driver.PurgeAsync().Wait();
_driver = null;
}
/// <summary>
/// Initialize the key collection
/// </summary>
/// <param name="name">Index name</param>
/// <param name="driver">Sterling driver</param>
/// <param name="indexer">How to resolve the index</param>
/// <param name="resolver">The resolver for loading the object</param>
public IndexCollection(string name, ISterlingDriver driver,
Func <T, Tuple <TIndex1, TIndex2> > indexer, Func <TKey, T> resolver)
: base(name, driver, indexer, resolver)
{
IsTuple = true;
}
public void Cleanup()
{
_driver.PurgeAsync().Wait();
_driver = null;
}
/// <summary>
/// Get types path
/// </summary>
/// <param name="basePath"></param>
/// <param name="databaseName"></param>
/// <param name="driver"></param>
/// <returns></returns>
public string GetTypesPath(string basePath, string databaseName, ISterlingDriver driver)
{
_ContractForBasePath(basePath);
_ContractForDatabaseName(databaseName);
_ContractForDriver(driver);
return Path.Combine(GetDatabasePath(basePath, databaseName, driver), TYPE);
}
/// <summary>
/// Gets the path to a specific instance
/// </summary>
/// <param name="basePath">Base path</param>
/// <param name="databaseName">The database</param>
/// <param name="tableType">The type of the table</param>
/// <param name="driver">The driver</param>
/// <param name="keyIndex">The key index</param>
/// <returns>The path</returns>
public string GetInstancePath(string basePath, string databaseName, Type tableType, ISterlingDriver driver, int keyIndex)
{
_ContractForBasePath(basePath);
_ContractForDatabaseName(databaseName);
_ContractForTableType(tableType);
_ContractForDriver(driver);
return Path.Combine(GetInstanceFolder(basePath, databaseName, tableType, driver, keyIndex), keyIndex.ToString());
}
/// <summary>
/// Get keys path
/// </summary>
/// <param name="basePath"></param>
/// <param name="databaseName"></param>
/// <param name="tableType"></param>
/// <param name="driver"></param>
/// <returns></returns>
public string GetKeysPath(string basePath, string databaseName, Type tableType, ISterlingDriver driver)
{
_ContractForBasePath(basePath);
_ContractForDatabaseName(databaseName);
_ContractForTableType(tableType);
_ContractForDriver(driver);
return(Path.Combine(GetTablePath(basePath, databaseName, tableType, driver), KEY));
}
/// <summary>
/// Gets the path to a specific instance
/// </summary>
/// <param name="basePath">Base path</param>
/// <param name="databaseName">The database</param>
/// <param name="tableType">The type of the table</param>
/// <param name="driver">The driver</param>
/// <param name="keyIndex">The key index</param>
/// <returns>The path</returns>
public string GetInstancePath(string basePath, string databaseName, Type tableType, ISterlingDriver driver, int keyIndex)
{
_ContractForBasePath(basePath);
_ContractForDatabaseName(databaseName);
_ContractForTableType(tableType);
_ContractForDriver(driver);
return(Path.Combine(GetInstanceFolder(basePath, databaseName, tableType, driver, keyIndex), keyIndex.ToString()));
}
public string GetIndexPath(string basePath, string databaseName, Type tableType, ISterlingDriver driver, string indexName)
{
_ContractForBasePath(basePath);
_ContractForDatabaseName(databaseName);
_ContractForTableType(tableType);
_ContractForDriver(driver);
_ContractForIndexName(indexName);
return(Path.Combine(GetTablePath(basePath, databaseName, tableType, driver), string.Format("{0}.idx", indexName)));
}
/// <summary>
/// Initialize the key collection
/// </summary>
/// <param name="name">name of the index</param>
/// <param name="driver">Sterling driver</param>
/// <param name="indexer">How to resolve the index</param>
/// <param name="resolver">The resolver for loading the object</param>
public IndexCollection(string name, ISterlingDriver driver, Func <T, TIndex> indexer, Func <TKey, T> resolver)
{
Driver = driver;
_Setup(name, indexer, resolver);
}
public string GetIndexPath(string basePath, string databaseName, Type tableType, ISterlingDriver driver, string indexName)
{
_ContractForBasePath(basePath);
_ContractForDatabaseName(databaseName);
_ContractForTableType(tableType);
_ContractForDriver(driver);
_ContractForIndexName(indexName);
return Path.Combine(GetTablePath(basePath, databaseName, tableType, driver), string.Format("{0}.idx", indexName));
}
/// <summary>
/// Get the path for a database
/// </summary>
/// <param name="basePath">The base path</param>
/// <param name="databaseName">The database name</param>
/// <param name="driver"The driver></param>
/// <returns>The path</returns>
public string GetDatabasePath(string basePath, string databaseName, ISterlingDriver driver)
{
_ContractForBasePath(basePath);
_ContractForDatabaseName(databaseName);
_ContractForDriver(driver);
driver.Log(SterlingLogLevel.Verbose,
string.Format("Path Provider: Database Path Request: {0}", databaseName), null);
var path = Path.Combine(basePath, databaseName) + "/";
driver.Log(SterlingLogLevel.Verbose, string.Format("Resolved database path from {0} to {1}",
databaseName, path), null);
return path;
}
/// <summary>
/// Get keys path
/// </summary>
/// <param name="basePath"></param>
/// <param name="databaseName"></param>
/// <param name="tableType"></param>
/// <param name="driver"></param>
/// <returns></returns>
public string GetKeysPath(string basePath, string databaseName, Type tableType, ISterlingDriver driver)
{
_ContractForBasePath(basePath);
_ContractForDatabaseName(databaseName);
_ContractForTableType(tableType);
_ContractForDriver(driver);
return Path.Combine(GetTablePath(basePath, databaseName, tableType, driver), KEY);
}
