C# Collection4.Size方法代码示例

 public virtual void TestDrainTo()
 {
     var queue = new BlockingQueue();
     queue.Add(new object());
     queue.Add(new object());
     var list = new Collection4();
     Assert.AreEqual(2, queue.DrainTo(list));
     Assert.AreEqual(2, list.Size());
     Assert.IsFalse(queue.HasNext());
 }

		/// <exception cref="System.Exception"></exception>
		public virtual void TestDrainTo()
		{
			IPausableBlockingQueue4 queue = new PausableBlockingQueue();
			queue.Add(new object());
			queue.Add(new object());
			queue.Pause();
			Collection4 list = new Collection4();
			Thread t = ExecuteAfter("Pausable queue drainer", 0, new _IRunnable_66(queue, list
				));
			Runtime4.SleepThrowsOnInterrupt(200);
			lock (list)
			{
				Assert.AreEqual(0, list.Size());
			}
			Assert.IsTrue(queue.HasNext());
			queue.Resume();
			t.Join();
			lock (list)
			{
				Assert.AreEqual(2, list.Size());
			}
			Assert.IsFalse(queue.HasNext());
		}

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

		private void AssertNotContainsNull(Collection4 c)
		{
			Assert.IsFalse(c.Contains(null));
			Assert.IsNull(c.Get(null));
			int size = c.Size();
			c.Ensure(null);
			Assert.AreEqual(size + 1, c.Size());
			c.Remove(null);
			Assert.AreEqual(size, c.Size());
		}

		private void AssertCollection(string[] expected, Collection4 c)
		{
			Assert.AreEqual(expected.Length, c.Size());
			Iterator4Assert.AreEqual(expected, c.GetEnumerator());
		}

 private ClassAspect[] ToClassAspectArray(Collection4 aspects)
 {
     var array = new ClassAspect[aspects.Size()];
     aspects.ToArray(array);
     for (var i = 0; i < array.Length; i++)
     {
         array[i].SetHandle(i);
     }
     return array;
 }

 private StaticField[] ToStaticFieldArray(Collection4 fields)
 {
     return (StaticField[]) fields.ToArray(new StaticField[fields.Size()]);
 }

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

		public static object[] ToArray(IEnumerator tests, IArrayFactory factory)
		{
			Collection4 elements = new Collection4(tests);
			return elements.ToArray(factory.NewArray(elements.Size()));
		}

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

 internal virtual IConstraint ToConstraint(Collection4 constraints)
 {
     if (constraints.Size() == 1)
     {
         return (IConstraint) constraints.SingleElement();
     }
     if (constraints.Size() > 0)
     {
         var constraintArray = new IConstraint[constraints.Size()];
         constraints.ToArray(constraintArray);
         return new QConstraints(_trans, constraintArray);
     }
     return null;
 }

 private void AssertContainsNull(Collection4 c)
 {
     Assert.IsTrue(c.Contains(null));
     Assert.IsNull(c.Get(null));
     var size = c.Size();
     c.Ensure(null);
     Assert.AreEqual(size, c.Size());
 }

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

		public virtual void TestMap()
		{
			int[] array = new int[] { 1, 2, 3 };
			Collection4 args = new Collection4();
			IEnumerator iterator = Iterators.Map(IntArrays4.NewIterator(array), new _IFunction4_149
				(args));
			Assert.IsNotNull(iterator);
			Assert.AreEqual(0, args.Size());
			for (int i = 0; i < array.Length; ++i)
			{
				Assert.IsTrue(iterator.MoveNext());
				Assert.AreEqual(i + 1, args.Size());
				Assert.AreEqual(array[i] * 2, iterator.Current);
			}
		}