// Strategies for removing keys in the presence of a lookup
// system distributed as cached views. Reference type KeyVals
// means the caches immediately reflect new vals, but make
// removal of values trickier.
// One approach is to flag the KeyVals as obsolete or evacuated,
// then check this flag on every cached lookup, falling back to
// a lookup against the backing dictionary which may be accompanied
// by replacing the evacuated KeyVal. This has the advantage of laziness
// and avoiding scans or maintaining an index of the location of KeyVals
// so they can be efficiently removed on their actual removal from the
// dictionary, but incurs an extra boolean check for every lookup,
// which may be a bit expensive at this level where we're counting every op,
// and you'd still have to do a bit of dancing around for an evacuated KeyVal.
// We're close to having the infrastructure for that though, so it might be
// a path to explore more in the future.
// Another approach is to maintain an index of where all the keyvals are.
// This would make finding and updating them faster, but incur all the overhead,
// in terms of speed, memory, and code complexity, of maintaining the index itself.
// We don't want to do that right now.
// The approach we're going with for the moment is to just scan everything
// and remove matching KeyVals as soon as their key is deleted, on the premise
// that it's the simplest thing to do and key deletions are probably pretty rare.
public void Remove(object k)
{
state.Remove((Keyword)k);
// TODO: consider caching this
foreach (var x in GetComponents <ArcadiaBehaviour>())
{
x.RemoveCachedKey(k);
}
}
public void Remove(object k)
{
state.Remove(k);
// don't need to refresh anything
}
