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); }