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