private void DeleteAndReadd(IObjectContainer db, Collection4 removed)
{
var removeIter = removed.GetEnumerator();
while (removeIter.MoveNext())
{
db.Delete(removeIter.Current);
}
db.Commit();
var readdIter = removed.GetEnumerator();
while (readdIter.MoveNext())
{
db.Store(readdIter.Current);
}
db.Commit();
}
public virtual void TestSeries()
{
Collection4 calls = new Collection4();
IEnumerator series = Iterators.Series(string.Empty, new _IFunction4_11(calls)).GetEnumerator
();
Assert.IsTrue(series.MoveNext());
Assert.IsTrue(series.MoveNext());
Iterator4Assert.AreEqual(new object[] { string.Empty, "*" }, calls.GetEnumerator(
));
}
public virtual void TraverseMutable(IVisitor4 visitor)
{
Collection4 currentContent = new Collection4();
TraverseLocked(new _IVisitor4_51(currentContent));
IEnumerator i = currentContent.GetEnumerator();
while (i.MoveNext())
{
visitor.Visit(i.Current);
}
}
private CompositeIterator4 NewIterator()
{
Collection4 iterators = new Collection4();
iterators.Add(IntArrays4.NewIterator(new int[] { 1, 2, 3 }));
iterators.Add(IntArrays4.NewIterator(new int[] { }));
iterators.Add(IntArrays4.NewIterator(new int[] { 4 }));
iterators.Add(IntArrays4.NewIterator(new int[] { 5, 6 }));
CompositeIterator4 iterator = new CompositeIterator4(iterators.GetEnumerator());
return iterator;
}
public virtual void Run()
{
dontRemove = true;
Collection4 copy = new Collection4(_containers);
IEnumerator i = copy.GetEnumerator();
while (i.MoveNext())
{
((ObjectContainerBase)i.Current).ShutdownHook();
}
}
public virtual IEnumerator IteratorFor(object collection)
{
IDictionary map = (IDictionary)collection;
Collection4 result = new Collection4();
IEnumerator it = map.GetEnumerator();
while (it.MoveNext())
{
DictionaryEntry entry = (DictionaryEntry)it.Current;
result.Add(entry.Key);
result.Add(entry.Value);
}
return result.GetEnumerator();
}
public static IEnumerator Iterate(List4 list)
{
if (list == null)
{
return(EmptyIterator);
}
Collection4 collection = new Collection4();
while (list != null)
{
collection.Add(list._element);
list = ((List4)list._next);
}
return(collection.GetEnumerator());
}
/// <exception cref="System.Exception"></exception>
public virtual void TestClose()
{
var container = Db();
var session = FileSession();
var actual = new Collection4();
EventRegistry().Closing += new _IEventListener4_21(actual).OnEvent;
Fixture().Close();
if (IsEmbedded())
{
Iterator4Assert.AreEqual(new object[] {container, session}, actual.GetEnumerator
());
}
else
{
Assert.AreSame(container, actual.SingleElement());
}
}
/// <exception cref="System.Exception"></exception>
public virtual void TestClose()
{
IExtObjectContainer container = Db();
LocalObjectContainer session = FileSession();
Collection4 actual = new Collection4();
EventRegistry().Closing += new System.EventHandler<Db4objects.Db4o.Events.ObjectContainerEventArgs>
(new _IEventListener4_21(actual).OnEvent);
Fixture().Close();
if (IsEmbedded())
{
Iterator4Assert.AreEqual(new object[] { container, session }, actual.GetEnumerator
());
}
else
{
Assert.AreSame(container, actual.SingleElement());
}
}
public void WriteAllClasses()
{
Collection4 deadClasses = new Collection4();
IStoredClass[] storedClasses = StoredClasses();
for (int i = 0; i < storedClasses.Length; i++)
{
ClassMetadata clazz = (ClassMetadata)storedClasses[i];
clazz.SetStateDirty();
if (clazz.StateDead())
{
deadClasses.Add(clazz);
clazz.SetStateOK();
}
}
for (int i = 0; i < storedClasses.Length; i++)
{
ClassMetadata clazz = (ClassMetadata)storedClasses[i];
clazz.Write(_systemTransaction);
}
IEnumerator it = deadClasses.GetEnumerator();
while (it.MoveNext())
{
((ClassMetadata)it.Current).SetStateDead();
}
}
public ClassIDIterator(Collection4 classes) : base(classes.GetEnumerator())
{
}
private void EnsureAllClassesRead()
{
bool allClassesRead = false;
while (!allClassesRead)
{
Collection4 unreadClasses = new Collection4();
int numClasses = _classes.Size();
IEnumerator classIter = _classes.GetEnumerator();
while (classIter.MoveNext())
{
ClassMetadata clazz = (ClassMetadata)classIter.Current;
if (clazz.StateUnread())
{
unreadClasses.Add(clazz);
}
}
IEnumerator unreadIter = unreadClasses.GetEnumerator();
while (unreadIter.MoveNext())
{
ClassMetadata clazz = (ClassMetadata)unreadIter.Current;
clazz = ReadClassMetadata(clazz, null);
if (clazz.ClassReflector() == null)
{
clazz.ForceRead();
}
}
allClassesRead = (_classes.Size() == numClasses);
}
ApplyReadAs();
}
private bool Contains(Collection4 collectedAspects, FieldMetadata field)
{
var aspectIterator = collectedAspects.GetEnumerator();
while (aspectIterator.MoveNext())
{
if (((ClassAspect) aspectIterator.Current).Equals(field))
{
return true;
}
}
return false;
}
/// <exception cref="System.Exception"></exception>
public static void AssertAllSlotsFreed(LocalTransaction trans, BTree bTree, ICodeBlock
block)
{
LocalObjectContainer container = (LocalObjectContainer)trans.Container();
ITransactionalIdSystem idSystem = trans.IdSystem();
IEnumerator allSlotIDs = bTree.AllNodeIds(trans.SystemTransaction());
Collection4 allSlots = new Collection4();
while (allSlotIDs.MoveNext())
{
int slotID = ((int)allSlotIDs.Current);
Slot slot = idSystem.CurrentSlot(slotID);
allSlots.Add(slot);
}
Slot bTreeSlot = idSystem.CurrentSlot(bTree.GetID());
allSlots.Add(bTreeSlot);
Collection4 freedSlots = new Collection4();
IFreespaceManager freespaceManager = container.FreespaceManager();
container.InstallDebugFreespaceManager(new FreespaceManagerForDebug(new _ISlotListener_99
(freedSlots)));
block.Run();
container.InstallDebugFreespaceManager(freespaceManager);
Assert.IsTrue(freedSlots.ContainsAll(allSlots.GetEnumerator()));
}
public static IEnumerator Iterate(List4 list)
{
if (list == null)
{
return EmptyIterator;
}
Collection4 collection = new Collection4();
while (list != null)
{
collection.Add(list._element);
list = ((List4)list._next);
}
return collection.GetEnumerator();
}
internal virtual Db4objects.Db4o.Internal.Query.Processor.QCon ProduceTopLevelJoin
()
{
if (!HasJoins())
{
return this;
}
IEnumerator i = IterateJoins();
if (i_joins.Size() == 1)
{
i.MoveNext();
return ((Db4objects.Db4o.Internal.Query.Processor.QCon)i.Current).ProduceTopLevelJoin
();
}
Collection4 col = new Collection4();
while (i.MoveNext())
{
col.Ensure(((Db4objects.Db4o.Internal.Query.Processor.QCon)i.Current).ProduceTopLevelJoin
());
}
i = col.GetEnumerator();
i.MoveNext();
Db4objects.Db4o.Internal.Query.Processor.QCon qcon = (Db4objects.Db4o.Internal.Query.Processor.QCon
)i.Current;
if (col.Size() == 1)
{
return qcon;
}
while (i.MoveNext())
{
qcon = (Db4objects.Db4o.Internal.Query.Processor.QCon)qcon.And((IConstraint)i.Current
);
}
return qcon;
}
public virtual IEnumerator ExecuteSnapshot()
{
var r = CreateCandidateCollection();
var executionPath = ExecutionPath(r);
IEnumerator candidatesIterator = new Iterator4Impl(r.candidateCollection);
var snapshots = new Collection4();
while (candidatesIterator.MoveNext())
{
var candidates = (QCandidates) candidatesIterator.Current;
snapshots.Add(candidates.ExecuteSnapshot(executionPath));
}
var snapshotsIterator = snapshots.GetEnumerator();
var resultingIDs = new CompositeIterator4(snapshotsIterator);
if (!r.checkDuplicates)
{
return resultingIDs;
}
return CheckDuplicates(resultingIDs);
}
private bool AllHaveSamePath(Collection4 leaves)
{
IEnumerator i = leaves.GetEnumerator();
i.MoveNext();
QCon first = (QCon)i.Current;
while (i.MoveNext())
{
if (!HaveSamePath(first, (QCon)i.Current))
{
return false;
}
}
return true;
}
public virtual IEnumerator AllNodeIds(Transaction systemTrans)
{
Collection4 allNodeIDs = new Collection4();
TraverseAllNodes(systemTrans, new _IVisitor4_527(allNodeIDs));
return allNodeIDs.GetEnumerator();
}
private void AssertEntries(PersistentEntry[] expected, IEnumerator actual)
{
Collection4 checklist = new Collection4(actual);
Assert.AreEqual(expected.Length, checklist.Size());
for (int i = 0; i < expected.Length; ++i)
{
PersistentEntry e = expected[i];
PersistentEntry a = EntryByUid(checklist.GetEnumerator(), e.uid);
if (a != null)
{
AssertEqualEntries(e, a);
checklist.Remove(a);
}
}
Assert.IsTrue(checklist.IsEmpty(), checklist.ToString());
}
private void AssertCollection(string[] expected, Collection4 c)
{
Assert.AreEqual(expected.Length, c.Size());
Iterator4Assert.AreEqual(expected, c.GetEnumerator());
}
private void DisableAspectsBefore(Collection4 aspects, TypeHandlerAspect typeHandlerAspect
)
{
var disableFromVersion = aspects.IndexOf(typeHandlerAspect) + 1;
var i = aspects.GetEnumerator();
while (i.MoveNext())
{
var aspect = (ClassAspect) i.Current;
if (aspect == typeHandlerAspect)
{
break;
}
aspect.DisableFromAspectCountVersion(disableFromVersion);
}
}
private IEnumerator MapIdsToExecutionPath(IEnumerator singleObjectQueryIterator,
Collection4 executionPath)
{
if (executionPath == null)
{
return singleObjectQueryIterator;
}
IEnumerator res = singleObjectQueryIterator;
IEnumerator executionPathIterator = executionPath.GetEnumerator();
while (executionPathIterator.MoveNext())
{
string fieldName = (string)executionPathIterator.Current;
res = Iterators.Concat(Iterators.Map(res, new _IFunction4_205(this, fieldName)));
}
return res;
}
internal virtual void CreateCandidates(Collection4 a_candidateCollection)
{
IEnumerator j = a_candidateCollection.GetEnumerator();
while (j.MoveNext())
{
QCandidates candidates = (QCandidates)j.Current;
if (candidates.TryAddConstraint(this))
{
i_candidates = candidates;
return;
}
}
i_candidates = new QCandidates((LocalTransaction)i_trans, GetYapClass(), GetField
(), false);
i_candidates.AddConstraint(this);
a_candidateCollection.Add(i_candidates);
}
private bool AllCanBeSearchedByIndex(Collection4 leaves)
{
IEnumerator i = leaves.GetEnumerator();
while (i.MoveNext())
{
QCon leaf = ((QCon)i.Current);
if (!leaf.CanLoadByIndex())
{
return false;
}
}
return true;
}
internal virtual IConstraint Join1(Db4objects.Db4o.Internal.Query.Processor.QCon
a_with, bool a_and)
{
if (a_with is QConstraints)
{
int j = 0;
Collection4 joinHooks = new Collection4();
IConstraint[] constraints = ((QConstraints)a_with).ToArray();
for (j = 0; j < constraints.Length; j++)
{
joinHooks.Ensure(((Db4objects.Db4o.Internal.Query.Processor.QCon)constraints[j]).
JoinHook());
}
IConstraint[] joins = new IConstraint[joinHooks.Size()];
j = 0;
IEnumerator i = joinHooks.GetEnumerator();
while (i.MoveNext())
{
joins[j++] = Join((IConstraint)i.Current, a_and);
}
return new QConstraints(i_trans, joins);
}
Db4objects.Db4o.Internal.Query.Processor.QCon myHook = JoinHook();
Db4objects.Db4o.Internal.Query.Processor.QCon otherHook = a_with.JoinHook();
if (myHook == otherHook)
{
// You might like to check out, what happens, if you
// remove this line. It seems to open a bug in an
// StOr testcase.
return myHook;
}
QConJoin cj = new QConJoin(i_trans, myHook, otherHook, a_and);
myHook.AddJoin(cj);
otherHook.AddJoin(cj);
return cj;
}
private void CollectImplicitlyAndingJoins(Collection4 joins, QConObject constraintWithJoins
)
{
IEnumerator i = joins.GetEnumerator();
i.MoveNext();
IIndexedNodeWithRange last = NodeForConstraint((QCon)i.Current);
while (i.MoveNext())
{
IIndexedNodeWithRange node = NodeForConstraint((QCon)i.Current);
last = new AndIndexedLeaf(constraintWithJoins, node, last);
_nodes.Add(last);
}
}
private IEnumerator FieldNames(FieldValue fieldValue)
{
Collection4 coll = new Collection4();
IComparisonOperand curOp = fieldValue;
while (curOp is FieldValue)
{
FieldValue curField = (FieldValue)curOp;
coll.Prepend(curField.FieldName());
curOp = curField.Parent();
}
return coll.GetEnumerator();
}
public virtual IEnumerator Values()
{
Collection4 values = new Collection4();
for (IEnumerator sIter = cache.GetEnumerator(); sIter.MoveNext(); )
{
string s = ((string)sIter.Current);
values.Add(s);
}
return values.GetEnumerator();
}
private void CollectLeaves(Collection4 leaves, Collection4 joins)
{
IEnumerator i = joins.GetEnumerator();
while (i.MoveNext())
{
QConJoin join = ((QConJoin)i.Current);
CollectLeavesFromJoin(leaves, join);
}
}
private ClassAspect AspectByName(Collection4 aspects, string aspectName)
{
var i = aspects.GetEnumerator();
while (i.MoveNext())
{
var current = (ClassAspect) i.Current;
if (current.GetName().Equals(aspectName))
{
return current;
}
}
return null;
}