public IEnumerator <TKey> GetEnumerator()
{
long prevProtectionCounter = 0;
var prevModificationCounter = 0;
long pos = 0;
while (true)
{
_keyValueTrProtector.Start();
if (pos == 0)
{
prevModificationCounter = _modificationCounter;
_keyValueTr.SetKeyPrefix(_prefix);
if (!_keyValueTr.FindFirstKey())
{
break;
}
}
else
{
if (_keyValueTrProtector.WasInterupted(prevProtectionCounter))
{
if (prevModificationCounter != _modificationCounter)
{
ThrowModifiedDuringEnum();
}
_keyValueTr.SetKeyPrefix(_prefix);
if (!_keyValueTr.SetKeyIndex(pos))
{
break;
}
}
else
{
if (!_keyValueTr.FindNextKey())
{
break;
}
}
}
prevProtectionCounter = _keyValueTrProtector.ProtectionCounter;
var keyBytes = _keyValueTr.GetKey();
var key = ByteArrayToKey(keyBytes);
yield return(key);
pos++;
}
}
public bool MoveNext()
{
if (!_seekNeeded)
{
_pos++;
}
if (_pos >= _count)
{
return(false);
}
_keyValueTrProtector.Start();
if (_keyValueTrProtector.WasInterupted(_prevProtectionCounter))
{
_manipulator.CheckModifiedDuringEnum(_prevModificationCounter);
_keyValueTr.SetKeyPrefix(_keyBytes);
Seek();
}
else if (_seekNeeded)
{
Seek();
}
else
{
if (_ascending)
{
_keyValueTr.FindNextKey();
}
else
{
_keyValueTr.FindPreviousKey();
}
}
_prevProtectionCounter = _keyValueTrProtector.ProtectionCounter;
return(true);
}
public bool MoveNext()
{
if (!_seekNeeded)
{
_pos++;
}
_keyValueTrProtector.Start();
if (_keyValueTrProtector.WasInterupted(_prevProtectionCounter))
{
_modificationCounter.CheckModifiedDuringEnum(_prevModificationCounter);
_keyValueTr.SetKeyPrefix(KeyBytes);
}
var ret = Seek();
_prevProtectionCounter = _keyValueTrProtector.ProtectionCounter;
return(ret);
}
public bool NextKey(out TKey key)
{
if (_seekState == SeekState.Ready)
{
_pos++;
}
if (_pos >= _count)
{
key = default(TKey);
return(false);
}
_keyValueTrProtector.Start();
if (_keyValueTrProtector.WasInterupted(_prevProtectionCounter))
{
_keyValueTr.SetKeyPrefix(_keyBytes);
Seek();
}
else if (_seekState != SeekState.Ready)
{
Seek();
}
else
{
if (_ascending)
{
_keyValueTr.FindNextKey();
}
else
{
_keyValueTr.FindPreviousKey();
}
}
_prevProtectionCounter = _keyValueTrProtector.ProtectionCounter;
//read key
var keyData = _keyValueTr.GetKeyAsByteArray();
var reader = new ByteArrayReader(keyData);
key = _keyReader(reader, null);
return(true);
}
public bool MoveNext()
{
if (_seekState == SeekState.Ready)
{
_pos++;
}
if (_pos >= _count)
{
Current = default;
return(false);
}
_keyValueTrProtector.Start();
if (_keyValueTrProtector.WasInterupted(_prevProtectionCounter))
{
if (_prevModificationCounter != _owner._modificationCounter)
{
ThrowModifiedDuringEnum();
}
_keyValueTr.SetKeyPrefix(_owner._prefix);
Seek();
}
else if (_seekState != SeekState.Ready)
{
Seek();
}
else
{
if (_ascending)
{
_keyValueTr.FindNextKey();
}
else
{
_keyValueTr.FindPreviousKey();
}
}
_prevProtectionCounter = _keyValueTrProtector.ProtectionCounter;
Current = _owner.ByteArrayToKey(_keyValueTr.GetKey());
return(true);
}
public bool NextKey(out TKey key)
{
if (!_seekNeeded)
{
_pos++;
}
if (_pos >= _count)
{
key = default(TKey);
return(false);
}
_keyValueTrProtector.Start();
if (_keyValueTrProtector.WasInterupted(_prevProtectionCounter))
{
if (_prevModificationCounter != _owner._modificationCounter)
{
ThrowModifiedDuringEnum();
}
_keyValueTr.SetKeyPrefix(_owner._prefix);
Seek();
}
else if (_seekNeeded)
{
Seek();
}
else
{
if (_ascending)
{
_keyValueTr.FindNextKey();
}
else
{
_keyValueTr.FindPreviousKey();
}
}
key = _owner.ByteArrayToKey(_keyValueTr.GetKeyAsByteArray());
return(true);
}
public IEnumerable <object> Enumerate(Type type)
{
if (type == typeof(object))
{
type = null;
}
else if (type != null)
{
AutoRegisterType(type);
}
ulong oid = 0;
ulong finalOid = _owner.GetLastAllocatedOid();
long prevProtectionCounter = 0;
while (true)
{
_keyValueTrProtector.Start();
if (oid == 0)
{
prevProtectionCounter = _keyValueTrProtector.ProtectionCounter;
_keyValueTr.SetKeyPrefix(ObjectDB.AllObjectsPrefix);
if (!_keyValueTr.FindFirstKey())
{
break;
}
}
else
{
if (_keyValueTrProtector.WasInterupted(prevProtectionCounter))
{
_keyValueTr.SetKeyPrefix(ObjectDB.AllObjectsPrefix);
oid++;
var key = BuildKeyFromOid(oid);
var result = _keyValueTr.Find(ByteBuffer.NewSync(key));
if (result == FindResult.Previous)
{
if (!_keyValueTr.FindNextKey())
{
result = FindResult.NotFound;
}
}
if (result == FindResult.NotFound)
{
oid--;
break;
}
}
else
{
if (!_keyValueTr.FindNextKey())
{
break;
}
}
prevProtectionCounter = _keyValueTrProtector.ProtectionCounter;
}
oid = ReadOidFromCurrentKeyInTransaction();
var o = GetObjFromObjCacheByOid(oid);
if (o != null)
{
if (type == null || type.IsInstanceOfType(o))
{
yield return(o);
}
continue;
}
TableInfo tableInfo;
var reader = ReadObjStart(oid, out tableInfo);
if (type != null && !type.IsAssignableFrom(tableInfo.ClientType))
{
continue;
}
var obj = ReadObjFinish(oid, tableInfo, reader);
yield return(obj);
}
if (_dirtyObjSet == null)
{
yield break;
}
var dirtyObjsToEnum = _dirtyObjSet.Where(p => p.Key > oid && p.Key <= finalOid).ToList();
dirtyObjsToEnum.Sort((p1, p2) =>
{
if (p1.Key < p2.Key)
{
return(-1);
}
if (p1.Key > p2.Key)
{
return(1);
}
return(0);
});
foreach (var dObjPair in dirtyObjsToEnum)
{
var obj = dObjPair.Value;
if (type != null && !type.IsInstanceOfType(obj))
{
continue;
}
yield return(obj);
}
}
void FreeContent(IReaderCtx readerCtx, int cfgId)
{
var config = (ODBDictionaryConfiguration)((IInstanceRegistry)readerCtx).FindInstance(cfgId);
var ctx = (DBReaderWithFreeInfoCtx)readerCtx;
if (config.FreeContent == null)
{
var method = ILBuilder.Instance
.NewMethod <Action <IInternalObjectDBTransaction, AbstractBufferedReader, IList <ulong> > >(
$"IDictFinder_Cfg_{cfgId}");
var ilGenerator = method.Generator;
var readerLoc = ilGenerator.DeclareLocal(typeof(IReaderCtx));
ilGenerator
.Ldarg(0)
.Ldarg(1)
.Ldarg(2)
.Newobj(() => new DBReaderWithFreeInfoCtx(null, null, null))
.Stloc(readerLoc);
Action <IILGen> readerOrCtx;
if (_valueHandler.NeedsCtx())
{
readerOrCtx = il => il.Ldloc(readerLoc);
}
else
{
readerOrCtx = il => il.Ldarg(1);
}
_valueHandler.FreeContent(ilGenerator, readerOrCtx);
ilGenerator.Ret();
config.FreeContent = method.Create();
}
var findIDictAction = (Action <IInternalObjectDBTransaction, AbstractBufferedReader, IList <ulong> >)config.FreeContent;
long prevProtectionCounter = 0;
long pos = 0;
while (true)
{
_keyValueTrProtector.Start();
if (pos == 0)
{
_keyValueTr.SetKeyPrefix(_prefix);
if (!_keyValueTr.FindFirstKey())
{
break;
}
}
else
{
if (_keyValueTrProtector.WasInterupted(prevProtectionCounter))
{
_keyValueTr.SetKeyPrefix(_prefix);
if (!_keyValueTr.SetKeyIndex(pos))
{
break;
}
}
else
{
if (!_keyValueTr.FindNextKey())
{
break;
}
}
}
prevProtectionCounter = _keyValueTrProtector.ProtectionCounter;
var valueBytes = _keyValueTr.GetValueAsByteArray();
var valueReader = new ByteArrayReader(valueBytes);
findIDictAction(ctx.GetTransaction(), valueReader, ctx.DictIds);
pos++;
}
}
public IEnumerable <object> Enumerate(Type type)
{
if (type == typeof(object))
{
type = null;
}
else if (type != null)
{
AutoRegisterType(type);
}
var taken = false;
ulong oid = 0;
ulong finalOid = _owner.GetLastAllocatedOid();
long prevProtectionCounter = 0;
try
{
while (true)
{
if (!taken)
{
_keyValueTrProtector.Start(ref taken);
}
if (oid == 0)
{
prevProtectionCounter = _keyValueTrProtector.ProtectionCounter;
_keyValueTr.SetKeyPrefix(ObjectDB.AllObjectsPrefix);
if (!_keyValueTr.FindFirstKey())
{
break;
}
}
else
{
if (_keyValueTrProtector.WasInterupted(prevProtectionCounter))
{
_keyValueTr.SetKeyPrefix(ObjectDB.AllObjectsPrefix);
oid++;
byte[] key = BuildKeyFromOid(oid);
if (_keyValueTr.FindKey(key, 0, key.Length, FindKeyStrategy.OnlyNext) == FindKeyResult.NotFound)
{
oid--;
break;
}
}
else
{
if (!_keyValueTr.FindNextKey())
{
break;
}
}
}
oid = ReadOidFromCurrentKeyInTransaction();
WeakReference weakObj;
if (_objCache.TryGetValue(oid, out weakObj))
{
var o = weakObj.Target;
if (o != null)
{
if (type == null || type.IsAssignableFrom(o.GetType()))
{
_keyValueTrProtector.Stop(ref taken);
yield return(o);
continue;
}
continue;
}
}
TableInfo tableInfo;
KeyValueDBValueReader reader = ReadObjStart(oid, out tableInfo);
if (type != null && !type.IsAssignableFrom(tableInfo.ClientType))
{
continue;
}
object obj = ReadObjFinish(oid, tableInfo, reader);
_keyValueTrProtector.Stop(ref taken);
yield return(obj);
}
}
finally
{
if (taken)
{
_keyValueTrProtector.Stop();
}
}
var dirtyObjsToEnum = _dirtyObjSet.Where(p => p.Key > oid && p.Key <= finalOid).ToList();
dirtyObjsToEnum.Sort((p1, p2) =>
{
if (p1.Key < p2.Key)
{
return(-1);
}
if (p1.Key > p2.Key)
{
return(1);
}
return(0);
});
foreach (var dObjPair in dirtyObjsToEnum)
{
object obj = dObjPair.Value;
if (type != null && !type.IsAssignableFrom(obj.GetType()))
{
continue;
}
yield return(obj);
}
}