/// ------------------------------------------------------------------------------------
/// <summary>
/// Initializes a new instance of the <see cref="T:InMemoryUndoAction"/> class.
/// </summary>
/// <param name="cacheBase">The cache base.</param>
/// ------------------------------------------------------------------------------------
public InMemoryUndoAction(CacheBase cacheBase)
{
m_CacheBase = cacheBase;
}
/// -----------------------------------------------------------------------------------
/// <summary>
/// Creates and initializes new instance of the <see cref="InMemoryFdoCache"/> class.
/// </summary>
/// <param name="wsFactProvider"></param>
/// -----------------------------------------------------------------------------------
protected InMemoryFdoCache(IWsFactoryProvider wsFactProvider)
{
m_fdoCache = new NewFdoCache();
m_fdoCache.TestMode = true;
IFwMetaDataCache metaCache = new MetaDataCache();
((NewFdoCache)m_fdoCache).MetaDataCache = metaCache;
LoadMetaData("Cellar");
LoadMetaData("LangProj");
LoadMetaData("Ling");
// create the DB-less cache
m_cacheBase = new NewCacheBase(metaCache);
((NewFdoCache)m_fdoCache).DataAccess = m_cacheBase;
// create a LgWritingSystemFactory and setup the default WSs
ILgWritingSystemFactory wsFactory = wsFactProvider.NewILgWritingSystemFactory;
// We don't want InstallLanguage being called in these tests.
wsFactory.BypassInstall = true;
m_cacheBase.WritingSystemFactory = wsFactory;
// only do this if it hasn't been done yet
s_wsHvos.En = SetupWs("en");
s_wsHvos.Es = SetupWs("es");
s_wsHvos.De = SetupWs("de");
s_wsHvos.Fr = SetupWs("fr");
s_wsHvos.Ipa = SetupWs("ipa");
s_wsHvos.XKal = SetupWs("xkal");
s_wsHvos.Ur = SetupWs("ur", true);
s_wsHvos.Grc = SetupWs("grc");
s_wsHvos.Hbo = SetupWs("hbo", true);
((NewFdoCache)m_fdoCache).WritingSystemFactory = wsFactory;
}
/// ------------------------------------------------------------------------------------
/// <summary>
/// Executes in two distinct scenarios.
///
/// 1. If disposing is true, the method has been called directly
/// or indirectly by a user's code via the Dispose method.
/// Both managed and unmanaged resources can be disposed.
///
/// 2. If disposing is false, the method has been called by the
/// runtime from inside the finalizer and you should not reference (access)
/// other managed objects, as they already have been garbage collected.
/// Only unmanaged resources can be disposed.
/// </summary>
/// <param name="disposing"></param>
/// <remarks>
/// If any exceptions are thrown, that is fine.
/// If the method is being done in a finalizer, it will be ignored.
/// If it is thrown by client code calling Dispose,
/// it needs to be handled by fixing the bug.
///
/// If subclasses override this method, they should call the base implementation.
/// </remarks>
/// ------------------------------------------------------------------------------------
protected virtual void Dispose(bool disposing)
{
//Debug.WriteLineIf(!disposing, "****************** " + GetType().Name + " 'disposing' is false. ******************");
// Must not be run more than once.
if (m_isDisposed)
return;
IFwMetaDataCache metaCache = null;
ILgWritingSystemFactory wsFactory = null;
if (disposing)
{
// Dispose managed resources here.
if (m_fdoCache != null)
{
metaCache = m_fdoCache.MetaDataCacheAccessor;
// Don't set these to null, since the Dispose method on the
// cache needs them to remove ChangeWatchers from them.
//(m_fdoCache as NewFdoCache).MetaDataCache = null;
//(m_fdoCache as NewFdoCache).DataAccess = null;
m_fdoCache.Dispose();
}
if (m_cacheBase != null)
{
wsFactory = m_cacheBase.WritingSystemFactory;
m_cacheBase.WritingSystemFactory = null;
m_cacheBase.Dispose();
}
}
// Dispose unmanaged resources here, whether disposing is true or false.
if (metaCache != null && Marshal.IsComObject(metaCache))
Marshal.ReleaseComObject(metaCache);
if (wsFactory != null)
wsFactory.Shutdown();
m_lp = null;
m_fdoCache = null;
m_acth = null;
m_cacheBase = null;
m_metaDataModulesLoaded = null;
m_isDisposed = true;
}
/// <summary>
/// Executes in two distinct scenarios.
///
/// 1. If disposing is true, the method has been called directly
/// or indirectly by a user's code via the Dispose method.
/// Both managed and unmanaged resources can be disposed.
///
/// 2. If disposing is false, the method has been called by the
/// runtime from inside the finalizer and you should not reference (access)
/// other managed objects, as they already have been garbage collected.
/// Only unmanaged resources can be disposed.
/// </summary>
/// <param name="disposing"></param>
/// <remarks>
/// If any exceptions are thrown, that is fine.
/// If the method is being done in a finalizer, it will be ignored.
/// If it is thrown by client code calling Dispose,
/// it needs to be handled by fixing the bug.
///
/// If subclasses override this method, they should call the base implementation.
/// </remarks>
protected override void Dispose(bool disposing)
{
//Debug.WriteLineIf(!disposing, "****************** " + GetType().Name + " 'disposing' is false. ******************");
// Must not be run more than once.
if (IsDisposed)
return;
if (disposing)
{
// Dispose managed resources here.
if (m_cacheBase != null)
m_cacheBase.Dispose();
if (m_fdoCache != null)
m_fdoCache.Dispose();
}
// Dispose unmanaged resources here, whether disposing is true or false.
m_fdoCache = null;
m_cacheBase = null;
m_mdc = null;
m_ode = null;
m_odde = null;
m_odc = null;
base.Dispose(disposing);
}
public void TearDown()
{
CheckDisposed();
m_fdoCache.Dispose();
m_cacheBase.Dispose();
m_cacheBase = null;
m_fdoCache = null;
m_mdc = null;
m_ode = null;
m_odde = null;
m_odc = null;
}
public void Setup()
{
CheckDisposed();
m_ode = new DynamicMock(typeof(IOleDbEncap));
m_odde = new DynamicMock(typeof(IVwOleDbDa));
m_mdc = new DynamicMock(typeof(IFwMetaDataCache));
m_odc = new DynamicMock(typeof(IOleDbCommand));
m_odc.Ignore("ExecCommand");
m_ode.SetupResult("CreateCommand", null,
new string[] { "SIL.FieldWorks.Common.COMInterfaces.IOleDbCommand&"},
new object[] { m_odc.MockInstance });
m_cacheBase = new CacheBase((IFwMetaDataCache)m_mdc.MockInstance);
if (m_fdoCache != null)
m_fdoCache.Dispose();
m_fdoCache = new DummyFdoCache((IOleDbEncap)m_ode.MockInstance,
(IFwMetaDataCache)m_mdc.MockInstance, (IVwOleDbDa)m_odde.MockInstance,
m_cacheBase);
}