/// <summary>
/// Member ClearInfoAbout
/// </summary>
/// <param name="rghvo">hvo</param><param name="chvo"/><param name="cia">cia</param>
public void ClearInfoAboutAll(int[] rghvo, int chvo, VwClearInfoAction cia)
{
m_cache.ClearInfoAboutAll(rghvo, chvo, cia);
}
/// <summary>
/// Member ClearInfoAbout
/// </summary>
/// <param name="rghvo">hvo</param><param name="chvo"/><param name="cia">cia</param>
public void ClearInfoAboutAll(int[] rghvo, int chvo, VwClearInfoAction cia)
{
m_cache.ClearInfoAboutAll(rghvo, chvo, cia);
}
/// <summary>
/// Member ClearInfoAbout
/// </summary>
/// <param name="hvo">hvo</param><param name="cia">cia</param>
public void ClearInfoAbout(int hvo, VwClearInfoAction cia)
{
m_cache.ClearInfoAbout(hvo, cia);
}
/// <summary>Member ClearInfoAbout</summary>
/// <param name='rghvo'>hvo</param>
/// <param name="chvo"></param>
/// <param name='cia'>cia</param>
public void ClearInfoAboutAll(int[] rghvo, int chvo, VwClearInfoAction cia)
{
(m_sda as IVwCacheDa).ClearInfoAboutAll(rghvo, chvo, cia);
}
/// <summary>
/// Member ClearInfoAbout
/// </summary>
/// <param name="hvo">hvo</param><param name="cia">cia</param>
public void ClearInfoAbout(int hvo, VwClearInfoAction cia)
{
m_cache.ClearInfoAbout(hvo, cia);
}
/// <summary>Member ClearInfoAbout</summary>
/// <param name='rghvo'>hvo</param>
/// <param name="chvo"></param>
/// <param name='cia'>cia</param>
public void ClearInfoAboutAll(int[] rghvo, int chvo, VwClearInfoAction cia)
{
CheckDisposed();
throw new NotImplementedException("'ClearInfoAboutAll' not implemented yet.");
}
/// <summary>
///
/// </summary>
/// <param name="hvo"></param>
/// <param name="cia"></param>
public void ClearInfoAbout(int hvo, VwClearInfoAction cia)
{
(m_sda as IVwCacheDa).ClearInfoAbout(hvo, cia);
}
public void ClearInfoAboutAll(int[] _rghvo, int chvo, VwClearInfoAction cia)
{
throw new NotImplementedException();
}
/// <summary>Member ClearInfoAbout</summary>
/// <param name='rghvo'>hvo</param>
/// <param name="chvo"></param>
/// <param name='cia'>cia</param>
public void ClearInfoAboutAll(int[] rghvo, int chvo, VwClearInfoAction cia)
{
CheckDisposed();
// This default implementation has no MetaDataCache and so can't do anything useful.
}
/// <summary>
/// Delete the objects which are the ids in the Set.
/// </summary>
public static void DeleteObjects(Set<int> idsToDel, FdoCache cache,
bool fRequiresFullRefreshOfViewInUndoRedo,
VwClearInfoAction vwClearInfoAction, bool fUndo, ProgressState state)
{
Set<int> realIdsToDel = new Set<int>();
foreach (int hvo in idsToDel)
{
if (cache.IsDummyObject(hvo))
continue; // don't try removing dummy object from cache. otherwise, you can't undo it.
realIdsToDel.Add(hvo);
}
if (realIdsToDel.Count == 0)
return;
if (fUndo && realIdsToDel.Count == 1 && fRequiresFullRefreshOfViewInUndoRedo || cache.DatabaseAccessor == null)
{
// Just one object...more efficient to to it directly, also, it lets many
// tests pass that would otherwise need a real database.
foreach (int hvo in realIdsToDel)
{
cache.DeleteObject(hvo);
}
}
else
{
IActionHandler acth = cache.ActionHandlerAccessor;
if (acth == null)
fUndo = false; // May be null if we are currently suppressing Subtasks
int iMin = 0;
int[] ids = realIdsToDel.ToArray();
int step = 50;
if (state != null)
{
// 600 4-digit ids, 500 5-digit ids, 428 6-digit ids, 375 7-digit ids
int cChunks = (ids.Length / 450) + 1;
step = 60 / cChunks;
if (step == 0)
step = 1;
}
while (iMin < ids.Length)
{
int iLim = iMin;
string hvoList = CmObject.MakePartialIdList(ref iLim, ids);
ObjectGroupUndoItem item;
if (iMin > 0 || iLim < ids.Length)
{
Set<int> idsDel = new Set<int>(iLim - iMin);
for (int i = iMin; i < iLim; ++i)
idsDel.Add(ids[i]);
item = new ObjectGroupUndoItem(idsDel, hvoList, cache,
fRequiresFullRefreshOfViewInUndoRedo, fUndo);
}
else
{
item = new ObjectGroupUndoItem(realIdsToDel, hvoList, cache,
fRequiresFullRefreshOfViewInUndoRedo, fUndo);
}
item.DoIt(vwClearInfoAction);
if (fUndo)
acth.AddAction(item);
if (state != null)
{
int percent = state.PercentDone + step;
state.PercentDone = percent;
state.Breath();
}
iMin = iLim;
}
}
}
public void ClearInfoAbout(int hvo, VwClearInfoAction cia)
{
throw new NotImplementedException();
}
/// <summary>
/// Delete the objects which are the ids in the Set.
/// </summary>
public static void DeleteObjects(Set<int> idsToDel, FdoCache cache, bool fRequiresFullRefreshOfViewInUndoRedo, VwClearInfoAction vwClearInfoAction)
{
DeleteObjects(idsToDel, cache, fRequiresFullRefreshOfViewInUndoRedo, vwClearInfoAction, true, null);
}
/// <summary>
/// Delete the objects which are the ids in the Set.
/// Includes creating a suitable Undo action.
/// </summary>
/// <param name="idsToDel">Set of object IDs to be deleted.</param>
/// <param name="cache"></param>
/// <param name="vwClearInfoAction">specifies the level of information to clear from the cache for each id.</param>
public static void DeleteObjects(Set<int> idsToDel, FdoCache cache, VwClearInfoAction vwClearInfoAction)
{
DeleteObjects(idsToDel, cache, true, vwClearInfoAction);
}
/// <summary>
/// This does the original delete. We do our best to fix the cache without Refresh,
/// though it's possible one or more deleted objects is still displayed somewhere
/// as part of a reference attribute.
/// </summary>
/// <param name="vwClearInfoAction">specifies the level of information that needs to be cleared from the cache for each object. </param>
/// <returns></returns>
public bool DoIt(VwClearInfoAction vwClearInfoAction)
{
Set<KeyValuePair<int, int>> modifiedOwningProps = new Set<KeyValuePair<int, int>>();
ISilDataAccess sda = m_cache.MainCacheAccessor;
foreach (int hvo in m_ids)
{
if (m_cache.IsDummyObject(hvo))
continue; // don't clear it from the cache, or we won't be able to Undo.
int hvoOwner = m_cache.GetOwnerOfObject(hvo);
if (hvoOwner != 0 && !m_ids.Contains(hvoOwner))
{
// It has an owner and the owner is not also being deleted.
int flid = m_cache.GetOwningFlidOfObject(hvo);
// If we don't get one, we can't clean up the owning property; presume it has not
// been loaded into the cache and doesn't need clearing.
// Since it is a set, it won't matter if the same pair is added repeatedly.
if (flid != 0)
modifiedOwningProps.Add(new KeyValuePair<int, int>(hvoOwner, flid));
}
}
// Forget anything we ever knew about the deleted objects and things they owned.
m_cache.VwCacheDaAccessor.ClearInfoAboutAll(m_ids.ToArray(), m_ids.Count, vwClearInfoAction);
// Delete all the objects at once
// TODO (SteveM and SteveM): This block should probably be moved to a new
// DbOps method.
IOleDbCommand odc = null;
IOleDbEncap dbAccess = m_cache.DatabaseAccessor;
dbAccess.CreateCommand(out odc);
try
{
// execute the command on groups of hvos
string sSqlCommand = "exec DeleteObjects '{0}'";
int iNextGroup = 0;
while (true)
{
string hvoList = CmObject.MakePartialIdList(ref iNextGroup, m_ids.ToArray());
if (hvoList == string.Empty)
break; // Finished with the list of objects to delete
COMException originalException = null;
int cFailures = 0;
while (true)
{
// Make sure there is a transaction or savepoint that we can rollback
bool fNewTransaction = !dbAccess.IsTransactionOpen();
string sSavePointName = string.Empty;
if (fNewTransaction)
dbAccess.BeginTrans();
else
dbAccess.SetSavePoint(out sSavePointName);
try
{
odc.ExecCommand(string.Format(sSqlCommand, hvoList),
(int)SqlStmtType.knSqlStmtStoredProcedure);
if (fNewTransaction)
dbAccess.CommitTrans();
break; // Successfully completed the call so get out of the loop
}
catch (COMException ex)
{
if (cFailures++ == 0)
originalException = ex;
// An error occured while executing the command. Rollback whatever
// we got so we don't keep the DB in a bad state.
if (fNewTransaction)
dbAccess.RollbackTrans();
else
dbAccess.RollbackSavePoint(sSavePointName);
if (cFailures == 4)
{
// Tried 4 times to complete this command, but it still failed,
// so just give up. Throw the first exception we got so we have
// a better idea of what started the problem.
throw originalException;
}
}
}
}
}
finally
{
DbOps.ShutdownODC(ref odc);
}
List<PropChangeInfo> propsToChange = new List<PropChangeInfo>();
// Now we've actually made the change, clean up the cache.
foreach (KeyValuePair<int, int> kvp in modifiedOwningProps)
{
int hvoOwner = kvp.Key;
int flid = kvp.Value;
int chvo;
int cpt = m_cache.MetaDataCacheAccessor.GetFieldType((uint)flid);
if (sda.get_IsPropInCache(hvoOwner, flid, cpt, 0))
{
// Since it is cached, we should fix the cache.
if (cpt == (int)CellarModuleDefns.kcptOwningAtom)
{
m_cache.VwCacheDaAccessor.CacheObjProp(hvoOwner, flid, 0);
propsToChange.Add(new PropChangeInfo(hvoOwner, flid, 0, 0, 1));
}
else
{
// Fix the vector or collection, removing ALL things in it that are in the
// delete collection.
int ihvoFirstDel = -1;
int ihvoLastDel = -1;
int[] contents;
int chvoMax = sda.get_VecSize(hvoOwner, flid);
using (ArrayPtr arrayPtr = MarshalEx.ArrayToNative(chvoMax, typeof(int)))
{
sda.VecProp(hvoOwner, flid, chvoMax, out chvo, arrayPtr);
Debug.Assert(chvo == chvoMax);
contents = (int[])MarshalEx.NativeToArray(arrayPtr, chvo, typeof(int));
}
// remove from currentValue all items in idsToDel
int iout = 0;
for (int i = 0; i < contents.Length; ++i)
{
if(!m_ids.Contains(contents[i]))
{
contents[iout++] = contents[i];
}
else
{
// object at i is being deleted.
ihvoLastDel = i;
if (ihvoFirstDel < 0)
ihvoFirstDel = i;
}
}
m_cache.VwCacheDaAccessor.CacheVecProp(hvoOwner, flid, contents, iout);
if (ihvoFirstDel >= 0) // Just possible the cache is out of date or already fixed.
{
// Fix the display of the owning property.
// We simulate a replace from the first to the last deleted object.
int chvoDel = ihvoLastDel - ihvoFirstDel + 1;
int chvoIns = chvoDel + iout - contents.Length;
propsToChange.Add(new PropChangeInfo(hvoOwner, flid, ihvoFirstDel, chvoIns, chvoDel));
}
}
}
else
{
// It's not in the cache. This SHOULD mean nothing cares about it changing, but
// sometimes we kick object info out of the cache for various reasons. Just in case,
// issue a complete PropChanged for it. If it's really not in use, it won't take long.
// (It may take a while to load, of course...but play safe. See LT-3945 for one problem.)
// This may not give a totally accurate number for chvoDel, of course...best we can do.
chvo = sda.get_VecSize(hvoOwner, flid); // will load it with correct current value
propsToChange.Add(new PropChangeInfo(hvoOwner, flid, 0, chvo, chvo));
}
}
// We save up all the prop changes until we've finished clearing things out of the cache
// because of problems like LT-7972, where a CmPicture and CmFile were deleted, and the
// PropChanged for deleting the CmFile triggered something that failed because we had not
// yet cleared the owner of the CmPicture.
foreach(PropChangeInfo info in propsToChange)
info.DoIt(sda);
return true;
}
/// <summary>Member ClearInfoAbout</summary>
/// <param name='rghvo'>hvo</param>
/// <param name="chvo"></param>
/// <param name='cia'>cia</param>
public void ClearInfoAboutAll(int[] rghvo, int chvo, VwClearInfoAction cia)
{
(m_sda as IVwCacheDa).ClearInfoAboutAll(rghvo, chvo, cia);
}
/// <summary>
///
/// </summary>
/// <param name="hvo"></param>
/// <param name="cia"></param>
public void ClearInfoAbout(int hvo, VwClearInfoAction cia)
{
(m_sda as IVwCacheDa).ClearInfoAbout(hvo, cia);
}
