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); }
// Simple // Collection // Complex // General //regression protected virtual Type[] Concat(Type[] x, Type[] y) { Collection4 c = new Collection4(x); c.AddAll(y); return((Type[])c.ToArray(new Type[c.Size()])); }
private IConstraint AddEvaluationToAllConstraints(QConEvaluation eval) { if (i_constraints.Size() == 0) { _trans.Container().ClassCollection().IterateTopLevelClasses(new _IVisitor4_139(this )); } IEnumerator i = IterateConstraints(); while (i.MoveNext()) { ((QCon)i.Current).AddConstraint(eval); } // FIXME: should return valid Constraint object return(null); }
public virtual int ClientCount() { lock (_dispatchers) { return(_dispatchers.Size()); } }
public virtual IReflectClass[] Collect() { Collection4 classes = new Collection4(); CollectKnownClasses(classes); return((IReflectClass[])classes.ToArray(new IReflectClass[classes.Size()])); }
internal virtual IConstraint ToConstraint(Collection4 constraints) { if (constraints.Size() == 1) { return((IConstraint)constraints.SingleElement()); } else { if (constraints.Size() > 0) { IConstraint[] constraintArray = new IConstraint[constraints.Size()]; constraints.ToArray(constraintArray); return(new QConstraints(_trans, constraintArray)); } } return(null); }
public static object[] CollectionToArray(ObjectContainerBase stream, object obj) { Collection4 col = FlattenCollection(stream, obj); object[] ret = new object[col.Size()]; col.ToArray(ret); return(ret); }
public virtual void AssertExpectations() { if (_unexpected.Size() > 0) { Assert.Fail("UNEXPECTED: " + _unexpected.ToString()); } for (int i = 0; i < _expected.Length; i++) { Assert.AreSame(Found, _expected[i]); } }
public virtual void TestTransparentActivationDoesNotImplyTransparentUpdate() { TransparentActivationSupportTestCase.Item item = new TransparentActivationSupportTestCase.Item (); Db().Store(item); Db().Commit(); item.Update(); Collection4 updated = CommitCapturingUpdatedObjects(Db()); Assert.AreEqual(0, updated.Size()); }
public virtual void TestDrainTo() { BlockingQueue queue = new BlockingQueue(); queue.Add(new object()); queue.Add(new object()); Collection4 list = new Collection4(); Assert.AreEqual(2, queue.DrainTo(list)); Assert.AreEqual(2, list.Size()); Assert.IsFalse(queue.HasNext()); }
private void CollectJoinedNode(QConObject constraintWithJoins) { Collection4 joins = CollectTopLevelJoins(constraintWithJoins); if (!CanJoinsBeSearchedByIndex(joins)) { return; } if (1 == joins.Size()) { _nodes.Add(NodeForConstraint((QCon)joins.SingleElement())); return; } CollectImplicitlyAndingJoins(joins, constraintWithJoins); }
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); }
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()); }
public virtual IConstraint[] ToArray() { lock (_cluster) { Collection4 all = new Collection4(); for (int i = 0; i < _constraints.Length; i++) { ClusterConstraint c = (ClusterConstraint)_constraints[i]; for (int j = 0; j < c._constraints.Length; j++) { all.Add(c._constraints[j]); } } IConstraint[] res = new IConstraint[all.Size()]; all.ToArray(res); return(res); } }
internal virtual QCon ProduceTopLevelJoin () { if (!HasJoins()) { return(this); } var i = IterateJoins(); if (i_joins.Size() == 1) { i.MoveNext(); return(((QCon)i.Current).ProduceTopLevelJoin ()); } var col = new Collection4(); while (i.MoveNext()) { col.Ensure(((QCon)i.Current).ProduceTopLevelJoin ()); } i = col.GetEnumerator(); i.MoveNext(); var qcon = (QCon )i.Current; if (col.Size() == 1) { return(qcon); } while (i.MoveNext()) { qcon = (QCon)qcon.And((IConstraint)i.Current ); } return(qcon); }
internal virtual IConstraint Join1(QCon a_with, bool a_and) { if (a_with is QConstraints) { var j = 0; var joinHooks = new Collection4(); var constraints = ((QConstraints)a_with).ToArray(); for (j = 0; j < constraints.Length; j++) { joinHooks.Ensure(((QCon)constraints[j]). JoinHook()); } var joins = new IConstraint[joinHooks.Size()]; j = 0; var i = joinHooks.GetEnumerator(); while (i.MoveNext()) { joins[j++] = Join((IConstraint)i.Current, a_and); } return(new QConstraints(i_trans, joins)); } var myHook = JoinHook(); var 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); } var cj = new QConJoin(i_trans, myHook, otherHook, a_and); myHook.AddJoin(cj); otherHook.AddJoin(cj); return(cj); }
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 int Size() { return(_containers.Size()); }
private void AssertCollection(string[] expected, Collection4 c) { Assert.AreEqual(expected.Length, c.Size()); Iterator4Assert.AreEqual(expected, c.GetEnumerator()); }
public virtual int NumSyncs() { return(_writes.Size()); }