public void CascadeActivation(IActivationContext context)
{
if (!Handlers4.IsCascading(_handler))
{
return;
}
ObjectContainerBase container = context.Container();
IEnumerator all = AllElements(container, context.TargetObject());
while (all.MoveNext())
{
context.CascadeActivationToChild(all.Current);
}
}
public virtual void Delete(ITypeHandler4 handler)
{
ITypeHandler4 correctHandlerVersion = HandlerRegistry.CorrectHandlerVersion(this,
handler);
int preservedCascadeDepth = CascadeDeleteDepth();
CascadeDeleteDepth(AdjustedDepth());
if (Handlers4.HandleAsObject(correctHandlerVersion))
{
DeleteObject();
}
else
{
correctHandlerVersion.Delete(this);
}
CascadeDeleteDepth(preservedCascadeDepth);
}
public virtual void WriteObjectWithCurrentState(ITypeHandler4 handler, object obj
)
{
if (Handlers4.UseDedicatedSlot(this, handler))
{
WriteObject(obj);
}
else
{
if (obj == null)
{
WriteNullReference(handler);
}
else
{
CreateIndirectionWithinSlot(handler);
handler.Write(this, obj);
}
}
}
public virtual IEnumerator ReferencesFrom(int id)
{
CollectIdContext context = CollectIdContext.ForID(_transaction, id);
ClassMetadata classMetadata = context.ClassMetadata();
if (null == classMetadata)
{
// most probably ClassMetadata reading
return(Iterators.EmptyIterator);
}
if (!classMetadata.HasIdentity())
{
throw new InvalidOperationException(classMetadata.ToString());
}
if (!Handlers4.IsCascading(classMetadata.TypeHandler()))
{
return(Iterators.EmptyIterator);
}
classMetadata.CollectIDs(context);
return(new TreeKeyIterator(context.Ids()));
}
private object WriteAndRead(object obj)
{
int imaginativeID = 500;
ObjectReference @ref = new ObjectReference(ClassMetadataForObject(obj), imaginativeID
);
@ref.SetObject(obj);
MarshallingContext marshallingContext = new MarshallingContext(Trans(), @ref, Container
().UpdateDepthProvider().ForDepth(int.MaxValue), true);
Handlers4.Write(@ref.ClassMetadata().TypeHandler(), marshallingContext, obj);
Pointer4 pointer = marshallingContext.AllocateSlot();
ByteArrayBuffer buffer = marshallingContext.ToWriteBuffer(pointer);
buffer.Seek(0);
// String str = new String(buffer._buffer);
// System.out.println(str);
UnmarshallingContext unmarshallingContext = new UnmarshallingContext(Trans(), @ref
, Const4.AddToIdTree, false);
unmarshallingContext.Buffer(buffer);
unmarshallingContext.ActivationDepth(new LegacyActivationDepth(5));
return(unmarshallingContext.Read());
}
private bool HasValueTypeBehavior(object obj)
{
bool isSimple = Platform4.IsSimple(obj.GetType());
if (isSimple)
{
return(true);
}
IReflectClass reflectClass = _container.Reflector().ForObject(obj);
if (Platform4.IsStruct(reflectClass))
{
return(true);
}
bool isEnum = Platform4.IsEnum(_container.Reflector(), reflectClass);
if (isEnum)
{
return(true);
}
ITypeHandler4 typeHandler = _container.TypeHandlerForClass(reflectClass);
return(Handlers4.IsValueType(typeHandler));
}
public override bool IsIndirectedWithinSlot(ITypeHandler4 handler)
{
return(Handlers4.IsVariableLength(handler));
}
internal virtual bool CreateChild(QCandidates a_candidates)
{
if (!_include)
{
return(false);
}
if (_fieldMetadata != null)
{
ITypeHandler4 handler = _fieldMetadata.GetHandler();
if (handler != null)
{
QueryingReadContext queryingReadContext = new QueryingReadContext(Transaction(),
MarshallerFamily().HandlerVersion(), _bytes, _key);
ITypeHandler4 arrayElementHandler = Handlers4.ArrayElementHandler(handler, queryingReadContext
);
if (arrayElementHandler != null)
{
int offset = queryingReadContext.Offset();
bool outerRes = true;
// The following construct is worse than not ideal.
// For each constraint it completely reads the
// underlying structure again. The structure could b
// kept fairly easy. TODO: Optimize!
IEnumerator i = a_candidates.IterateConstraints();
while (i.MoveNext())
{
QCon qcon = (QCon)i.Current;
QField qf = qcon.GetField();
if (qf == null || qf.Name().Equals(_fieldMetadata.GetName()))
{
QCon tempParent = qcon.Parent();
qcon.SetParent(null);
QCandidates candidates = new QCandidates(a_candidates.i_trans, null, qf);
candidates.AddConstraint(qcon);
qcon.SetCandidates(candidates);
ReadArrayCandidates(handler, queryingReadContext.Buffer(), arrayElementHandler, candidates
);
queryingReadContext.Seek(offset);
bool isNot = qcon.IsNot();
if (isNot)
{
qcon.RemoveNot();
}
candidates.Evaluate();
ByRef pending = ByRef.NewInstance();
bool[] innerRes = new bool[] { isNot };
candidates.Traverse(new _IVisitor4_160(innerRes, isNot, pending));
// Collect all pending subresults.
// We need to change
// the
// constraint here, so
// our
// pending collector
// uses
// the right
// comparator.
// We only keep one
// pending result
// for
// all array
// elements.
// and memorize,
// whether we had a
// true or a false
// result.
// or both.
if (isNot)
{
qcon.Not();
}
// In case we had pending subresults, we
// need to communicate
// them up to our root.
if (((Tree)pending.value) != null)
{
((Tree)pending.value).Traverse(new _IVisitor4_229(this));
}
if (!innerRes[0])
{
// Again this could be double triggering.
//
// We want to clean up the "No route"
// at some stage.
qcon.Visit(GetRoot(), qcon.Evaluator().Not(false));
outerRes = false;
}
qcon.SetParent(tempParent);
}
}
return(outerRes);
}
// We may get simple types here too, if the YapField was null
// in the higher level simple evaluation. Evaluate these
// immediately.
if (Handlers4.IsQueryLeaf(handler))
{
a_candidates.i_currentConstraint.Visit(this);
return(true);
}
}
}
if (_fieldMetadata == null)
{
return(false);
}
if (_fieldMetadata is NullFieldMetadata)
{
return(false);
}
_classMetadata.SeekToField(Transaction(), _bytes, _fieldMetadata);
Db4objects.Db4o.Internal.Query.Processor.QCandidate candidate = ReadSubCandidate(
a_candidates);
if (candidate == null)
{
return(false);
}
// fast early check for ClassMetadata
if (a_candidates.i_classMetadata != null && a_candidates.i_classMetadata.IsStronglyTyped
())
{
ITypeHandler4 handler = _fieldMetadata.GetHandler();
if (Handlers4.IsUntyped(handler))
{
handler = TypeHandlerFor(candidate);
}
if (handler == null)
{
return(false);
}
}
AddDependant(a_candidates.Add(candidate));
return(true);
}
public virtual object ReadObject(ITypeHandler4 handler)
{
return(Handlers4.ReadValueType(this, handler));
}
private bool IsTyped(FieldMetadata field)
{
return(!Handlers4.IsUntyped(field.GetHandler()));
}
internal virtual bool IsArray()
{
return(_fieldMetadata != null && Handlers4.HandlesArray(_fieldMetadata.GetHandler
()));
}
private bool IsUntypedByteArray(IBufferContext context)
{
return(Handlers4.IsUntyped(_handler) && HandleAsByteArray(context));
}
public virtual IReflectClass PrimitiveClassReflector(IReflector reflector)
{
return(Handlers4.PrimitiveClassReflector(_handler, reflector));
}
private bool CascadeDelete(IDeleteContext context)
{
// FIXME: ValueType could reference objects, shouldn't they be deleted too?
return(context.CascadeDelete() && Handlers4.IsCascading(_handler));
}
internal virtual bool IsQueryLeaf()
{
return(_fieldMetadata != null && Handlers4.IsQueryLeaf(_fieldMetadata.GetHandler(
)));
}
internal virtual bool IsClass()
{
return(_fieldMetadata == null || Handlers4.HandlesClass(_fieldMetadata.GetHandler
()));
}
public virtual IReflectClass ClassReflector(IReflector reflector, ClassMetadata classMetadata
, bool isPrimitive)
{
return(isPrimitive ? Handlers4.PrimitiveClassReflector(classMetadata, reflector) :
classMetadata.ClassReflector());
}
public virtual void WriteObject(ITypeHandler4 handler, object obj)
{
Handlers4.Write(handler, this, obj);
}
