/// <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 virtual void TestContainsAll() { Collection4TestCase.Item a = new Collection4TestCase.Item(42); Collection4TestCase.Item b = new Collection4TestCase.Item(a.id + 1); Collection4TestCase.Item c = new Collection4TestCase.Item(b.id + 1); Collection4TestCase.Item a_ = new Collection4TestCase.Item(a.id); Collection4 needle = new Collection4(); Collection4 haystack = new Collection4(); haystack.Add(a); needle.Add(a); needle.Add(b); Assert.IsFalse(haystack.ContainsAll(needle)); needle.Remove(b); Assert.IsTrue(haystack.ContainsAll(needle)); needle.Add(b); haystack.Add(b); Assert.IsTrue(haystack.ContainsAll(needle)); needle.Add(a_); Assert.IsTrue(haystack.ContainsAll(needle)); needle.Add(c); Assert.IsFalse(haystack.ContainsAll(needle)); needle.Clear(); Assert.IsTrue(haystack.ContainsAll(needle)); haystack.Clear(); Assert.IsTrue(haystack.ContainsAll(needle)); }
private IReflectClass EnsureClassAvailability(int id) { if (id == 0) { return(null); } IReflectClass ret = (IReflectClass)_classByID.Get(id); if (ret != null) { return(ret); } ByteArrayBuffer classreader = _stream.ReadStatefulBufferById(_trans, id); ClassMarshaller marshaller = MarshallerFamily()._class; RawClassSpec spec = marshaller.ReadSpec(_trans, classreader); string className = spec.Name(); ret = LookupByName(className); if (ret != null) { _classByID.Put(id, ret); _pendingClasses.Add(id); return(ret); } ReportMissingClass(className); ret = _builder.CreateClass(className, EnsureClassAvailability(spec.SuperClassID() ), spec.NumFields()); // step 1 only add to _classByID, keep the class out of _classByName and _classes _classByID.Put(id, ret); _pendingClasses.Add(id); return(ret); }
public virtual void TestContainsAll() { var a = new Item(42); var b = new Item(a.id + 1); var c = new Item(b.id + 1); var a_ = new Item(a.id); var needle = new Collection4(); var haystack = new Collection4(); haystack.Add(a); needle.Add(a); needle.Add(b); Assert.IsFalse(haystack.ContainsAll(needle)); needle.Remove(b); Assert.IsTrue(haystack.ContainsAll(needle)); needle.Add(b); haystack.Add(b); Assert.IsTrue(haystack.ContainsAll(needle)); needle.Add(a_); Assert.IsTrue(haystack.ContainsAll(needle)); needle.Add(c); Assert.IsFalse(haystack.ContainsAll(needle)); needle.Clear(); Assert.IsTrue(haystack.ContainsAll(needle)); haystack.Clear(); Assert.IsTrue(haystack.ContainsAll(needle)); }
public virtual void TestToString() { Collection4 c = new Collection4(); Assert.AreEqual("[]", c.ToString()); c.Add("foo"); Assert.AreEqual("[foo]", c.ToString()); c.Add("bar"); Assert.AreEqual("[foo, bar]", c.ToString()); }
public virtual void TestGetByIndex() { Collection4 c = new Collection4(); c.Add("one"); c.Add("two"); Assert.AreEqual("one", c.Get(0)); Assert.AreEqual("two", c.Get(1)); AssertIllegalIndex(c, -1); AssertIllegalIndex(c, 2); }
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 TestContains() { object a = new object(); Collection4 c = new Collection4(); c.Add(new object()); Assert.IsFalse(c.Contains(a)); c.Add(a); Assert.IsTrue(c.Contains(a)); c.Remove(a); Assert.IsFalse(c.Contains(a)); }
private void CollectStandaloneNode(QConObject conObject) { IndexedLeaf existing = FindLeafOnSameField(conObject); if (existing != null) { CollectImplicitAnd(conObject, existing, new IndexedLeaf(conObject)); } else { _nodes.Add(new IndexedLeaf(conObject)); } }
public virtual void TestReplace() { Collection4 c = new Collection4(); c.Replace("one", "two"); c.Add("one"); c.Add("two"); c.Add("three"); c.Replace("two", "two.half"); AssertCollection(new string[] { "one", "two.half", "three" }, c); c.Replace("two.half", "one"); c.Replace("one", "half"); AssertCollection(new string[] { "half", "one", "three" }, c); }
public void AddClassMetadata(ClassMetadata clazz) { Container().SetDirtyInSystemTransaction(this); _classes.Add(clazz); if (clazz.StateUnread()) { _classMetadataByBytes.Put(clazz.i_nameBytes, clazz); } else { _classMetadataByClass.Put(clazz.ClassReflector(), clazz); } RegisterClassMetadataById(clazz); }
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 virtual void TestIndexOf() { Collection4 c = new Collection4(); Assert.AreEqual(-1, c.IndexOf("notInCollection")); c.Add("one"); Assert.AreEqual(-1, c.IndexOf("notInCollection")); Assert.AreEqual(0, c.IndexOf("one")); c.Add("two"); c.Add("three"); Assert.AreEqual(0, c.IndexOf("one")); Assert.AreEqual(1, c.IndexOf("two")); Assert.AreEqual(2, c.IndexOf("three")); Assert.AreEqual(-1, c.IndexOf("notInCollection")); }
private bool AttachToExistingConstraints(Collection4 newConstraintsCollector, object obj, bool onlyForPaths) { bool found = false; IEnumerator j = IterateConstraints(); while (j.MoveNext()) { QCon existingConstraint = (QCon)j.Current; BooleanByRef removeExisting = new BooleanByRef(false); if (!onlyForPaths || (existingConstraint is QConPath)) { QCon newConstraint = existingConstraint.ShareParent(obj, removeExisting); if (newConstraint != null) { newConstraintsCollector.Add(newConstraint); AddConstraint(newConstraint); if (removeExisting.value) { RemoveConstraint(existingConstraint); } found = true; if (!onlyForPaths) { break; } } } } return(found); }
internal virtual void Process(ClassMetadata newClassMetadata) { if (_pending.Contains(newClassMetadata)) { return; } ClassMetadata ancestor = newClassMetadata.GetAncestor(); if (ancestor != null) { Process(ancestor); } _pending.Add(newClassMetadata); _members.Add(newClassMetadata); if (_running) { return; } _running = true; try { CheckInits(); _pending = new Collection4(); } finally { _running = false; } }
// do nothing public virtual void Delete(object obj) { IDrsUUID uuid = ProduceReference(obj, null, null).Uuid(); _uuidsDeletedSinceLastReplication.Add(uuid); Sharpen.Collections.Remove(_storedObjects, obj); }
public void OnEvent(object sender, ObjectInfoEventArgs args ) { ObjectEventArgs objectArgs = args; updated.Add(objectArgs.Object); }
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(); } }
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(); }
internal virtual void CacheDirty(Collection4 col) { if (!BitIsTrue(Const4.CachedDirty)) { BitTrue(Const4.CachedDirty); col.Add(this); } }
public virtual void AddListener(IDiagnosticListener listener) { if (_listeners == null) { _listeners = new Collection4(); } _listeners.Add(listener); }
internal virtual void AddJoin(QConJoin a_join) { if (i_joins == null) { i_joins = new Collection4(); } i_joins.Add(a_join); }
private void Unexpected(object obj) { if (_ignoreUnexpected) { return; } _unexpected.Add(obj); Ods("Unexpected: " + obj); }
public ExcludingReflector(Type[] excludedClasses) { _excludedClasses = new Collection4(); for (int claxxIndex = 0; claxxIndex < excludedClasses.Length; ++claxxIndex) { Type claxx = excludedClasses[claxxIndex]; _excludedClasses.Add(claxx.FullName); } }
public void AddToBatch(Msg msg) { lock (Lock()) { _batchedMessages.Add(msg); // the first INT_LENGTH is for buffer.length, and then buffer content. _batchedQueueLength += Const4.IntLength + msg.PayLoad().Length(); } }
private void AddServerMessageDispatcher(IServerMessageDispatcher dispatcher) { lock (_dispatchers) { _dispatchers.Add(dispatcher); CheckCaresAboutCommitted(); } TriggerClientConnected(dispatcher); }
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)); }
public void RegisterTypeHandler(ITypeHandlerPredicate predicate, ITypeHandler4 typeHandler ) { if (_registeredTypeHandlers == null) { _registeredTypeHandlers = new Collection4(); } _registeredTypeHandlers.Add(new TypeHandlerPredicatePair(predicate, typeHandler)); }
public virtual void TestRemove() { Collection4 c = NewCollection(new string[] { "1", "2", "3", "4" }); c.Remove("3"); AssertCollection(new string[] { "1", "2", "4" }, c); c.Remove("4"); AssertCollection(new string[] { "1", "2" }, c); c.Add("5"); AssertCollection(new string[] { "1", "2", "5" }, c); c.Remove("1"); AssertCollection(new string[] { "2", "5" }, c); c.Remove("2"); c.Remove("5"); AssertCollection(new string[] { }, c); c.Add("6"); AssertCollection(new string[] { "6" }, c); }
public ExcludingReflector(ByRef loaderClass, Type[] excludedClasses) { _excludedClasses = new Collection4(); for (var claxxIndex = 0; claxxIndex < excludedClasses.Length; ++claxxIndex) { var claxx = excludedClasses[claxxIndex]; _excludedClasses.Add(claxx.FullName); } }