public virtual IEnumerator IterateJoins()
{
if (i_joins == null)
{
return(Iterators.EmptyIterator);
}
return(i_joins.GetEnumerator());
}
internal virtual void EvaluateChildren()
{
IEnumerator i = i_childrenCandidates.GetEnumerator();
while (i.MoveNext())
{
((QCandidates)i.Current).Evaluate();
}
}
private IConstraint AddInterfaceConstraint(IReflectClass claxx)
{
Collection4 classes = Stream().ClassCollection().ForInterface(claxx);
if (classes.Size() == 0)
{
QConClass qcc = new QConClass(_trans, null, null, claxx);
AddConstraint(qcc);
return(qcc);
}
IEnumerator i = classes.GetEnumerator();
IConstraint constr = null;
while (i.MoveNext())
{
ClassMetadata classMetadata = (ClassMetadata)i.Current;
IReflectClass classMetadataClaxx = classMetadata.ClassReflector();
if (classMetadataClaxx != null)
{
if (!classMetadataClaxx.IsInterface())
{
if (constr == null)
{
constr = Constrain(classMetadataClaxx);
}
else
{
constr = constr.Or(Constrain(classMetadata.ClassReflector()));
}
}
}
}
return(constr);
}
public void WriteBatchedMessages()
{
lock (Lock())
{
if (_batchedMessages.IsEmpty())
{
return;
}
Msg msg;
MsgD multibytes = Msg.WriteBatchedMessages.GetWriterForLength(Transaction, _batchedQueueLength
);
multibytes.WriteInt(_batchedMessages.Size());
IEnumerator iter = _batchedMessages.GetEnumerator();
while (iter.MoveNext())
{
msg = (Msg)iter.Current;
if (msg == null)
{
multibytes.WriteInt(0);
}
else
{
multibytes.WriteInt(msg.PayLoad().Length());
multibytes.PayLoad().Append(msg.PayLoad()._buffer);
}
}
WriteMessageToSocket(multibytes);
ClearBatchedObjects();
}
}
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();
}
/// <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 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 virtual IEnumerator AllNodeIds(Transaction systemTrans)
{
Collection4 allNodeIDs = new Collection4();
TraverseAllNodes(systemTrans, new _IVisitor4_527(allNodeIDs));
return(allNodeIDs.GetEnumerator());
}
public virtual void TestIterator()
{
string[] expected = new string[] { "1", "2", "3" };
Collection4 c = NewCollection(expected);
Iterator4Assert.AreEqual(expected, c.GetEnumerator());
}
private void DeleteAndReadd(IObjectContainer db, Collection4 removed)
{
IEnumerator removeIter = removed.GetEnumerator();
while (removeIter.MoveNext())
{
db.Delete(removeIter.Current);
}
db.Commit();
IEnumerator readdIter = removed.GetEnumerator();
while (readdIter.MoveNext())
{
db.Store(readdIter.Current);
}
db.Commit();
}
public override bool Identity()
{
var ret = false;
var i = i_evaluators.GetEnumerator();
while (i.MoveNext())
{
if (((QE)i.Current).Identity())
{
ret = true;
}
else
{
return(false);
}
}
return(ret);
}
public virtual void TestInvalidIteratorException()
{
Collection4 c = NewCollection(new string[] { "1", "2" });
IEnumerator i = c.GetEnumerator();
Assert.IsTrue(i.MoveNext());
c.Add("3");
Assert.Expect(typeof(InvalidIteratorException), new _ICodeBlock_200(i));
}
private void CollectLeaves(Collection4 leaves, Collection4 joins)
{
IEnumerator i = joins.GetEnumerator();
while (i.MoveNext())
{
QConJoin join = ((QConJoin)i.Current);
CollectLeavesFromJoin(leaves, join);
}
}
internal void CheckChanges()
{
IEnumerator i = _classes.GetEnumerator();
while (i.MoveNext())
{
((ClassMetadata)i.Current).CheckChanges();
}
}
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 Run()
{
dontRemove = true;
Collection4 copy = new Collection4(_containers);
IEnumerator i = copy.GetEnumerator();
while (i.MoveNext())
{
((ObjectContainerBase)i.Current).ShutdownHook();
}
}
private IEnumerator Ids(IEnumerable <PartialCollectionReplicationTestCase.Data> data
)
{
Collection4 ids = new Collection4();
foreach (PartialCollectionReplicationTestCase.Data d in data)
{
ids.Add(d.Id());
}
return(ids.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 WriteCachedDirty()
{
IEnumerator i = _dirtyClassMetadata.GetEnumerator();
while (i.MoveNext())
{
PersistentBase dirty = (PersistentBase)i.Current;
dirty.Write(SystemTransaction());
dirty.NotCachedDirty();
}
_dirtyClassMetadata.Clear();
}
private CompositeIterator4 NewIterator()
{
var iterators = new Collection4();
iterators.Add(IntArrays4.NewIterator(new[] { 1, 2, 3 }));
iterators.Add(IntArrays4.NewIterator(new int[] {}));
iterators.Add(IntArrays4.NewIterator(new[] { 4 }));
iterators.Add(IntArrays4.NewIterator(new[] { 5, 6 }));
var iterator = new CompositeIterator4(iterators.GetEnumerator());
return(iterator);
}
public virtual void TraverseMutable(IVisitor4 visitor)
{
var currentContent = new Collection4();
TraverseLocked(new _IVisitor4_51(currentContent));
var i = currentContent.GetEnumerator();
while (i.MoveNext())
{
visitor.Visit(i.Current);
}
}
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 void OnDiagnostic(IDiagnostic d)
{
if (_listeners == null)
{
return;
}
IEnumerator i = _listeners.GetEnumerator();
while (i.MoveNext())
{
((IDiagnosticListener)i.Current).OnDiagnostic(d);
}
}
/// <exception cref="System.IO.IOException"></exception>
public virtual int WriteVersions(string file, bool writeTrash)
{
int count = 0;
int rcount = 0;
string lastFileName = file + "0";
string rightFileName = file + "R";
File4.Copy(lastFileName, rightFileName);
IEnumerator syncIter = _writes.GetEnumerator();
while (syncIter.MoveNext())
{
rcount++;
Collection4 writesBetweenSync = (Collection4)syncIter.Current;
RandomAccessFile rightRaf = new RandomAccessFile(rightFileName, "rw");
IEnumerator singleForwardIter = writesBetweenSync.GetEnumerator();
while (singleForwardIter.MoveNext())
{
CrashSimulatingWrite csw = (CrashSimulatingWrite)singleForwardIter.Current;
csw.Write(rightFileName, rightRaf, false);
}
rightRaf.Close();
IEnumerator singleBackwardIter = writesBetweenSync.GetEnumerator();
while (singleBackwardIter.MoveNext())
{
count++;
CrashSimulatingWrite csw = (CrashSimulatingWrite)singleBackwardIter.Current;
string currentFileName = file + "W" + count;
File4.Copy(lastFileName, currentFileName);
RandomAccessFile raf = new RandomAccessFile(currentFileName, "rw");
csw.Write(currentFileName, raf, writeTrash);
raf.Close();
lastFileName = currentFileName;
}
File4.Copy(rightFileName, rightFileName + rcount);
lastFileName = rightFileName;
}
return(count);
}
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());
}
private bool AllCanBeSearchedByIndex(Collection4 leaves)
{
IEnumerator i = leaves.GetEnumerator();
while (i.MoveNext())
{
QCon leaf = ((QCon)i.Current);
if (!leaf.CanLoadByIndex())
{
return(false);
}
}
return(true);
}
/// <summary>Determines if a candidate ReflectClass is a collection</summary>
/// <param name="candidate">candidate ReflectClass</param>
/// <returns>true if a candidate ReflectClass is a collection.</returns>
public virtual bool IsCollection(IReflectClass candidate)
{
//candidate = candidate.getDelegate();
IEnumerator i = _collectionPredicates.GetEnumerator();
while (i.MoveNext())
{
if (((IReflectClassPredicate)i.Current).Match(candidate))
{
return(true);
}
}
return(_delegate.IsCollection(candidate.GetDelegate()));
}
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 ServerMessageDispatcherImpl FindThread(int a_threadID)
{
lock (_dispatchers)
{
IEnumerator i = _dispatchers.GetEnumerator();
while (i.MoveNext())
{
ServerMessageDispatcherImpl serverThread = (ServerMessageDispatcherImpl)i.Current;
if (serverThread._threadID == a_threadID)
{
return(serverThread);
}
}
}
return(null);
}
private IReflectClass EnsureClassInitialised(int id)
{
IReflectClass ret = EnsureClassAvailability(id);
while (_pendingClasses.Size() > 0)
{
Collection4 pending = _pendingClasses;
_pendingClasses = new Collection4();
IEnumerator i = pending.GetEnumerator();
while (i.MoveNext())
{
EnsureClassRead(((int)i.Current));
}
}
return(ret);
}
