private void BindActivatableToActivator(ObjectEventArgs oea)
{
object obj = oea.Object;
if (obj is IActivatable)
{
Db4objects.Db4o.Internal.Transaction transaction = (Db4objects.Db4o.Internal.Transaction
)oea.Transaction();
ObjectReference objectReference = transaction.ReferenceForObject(obj);
Bind(obj, ActivatorForObject(transaction, objectReference));
}
}
public object Get(Transaction trans, object onObject)
{
if (_containingClass == null)
{
return(null);
}
ObjectContainerBase container = Container();
if (container == null)
{
return(null);
}
lock (container.Lock())
{
// FIXME: The following is not really transactional.
// This will work OK for normal C/S and for
// single local mode but the transaction will
// be wrong for MTOC.
if (trans == null)
{
trans = container.Transaction;
}
container.CheckClosed();
ObjectReference @ref = trans.ReferenceForObject(onObject);
if (@ref == null)
{
return(null);
}
int id = @ref.GetID();
if (id <= 0)
{
return(null);
}
UnmarshallingContext context = new UnmarshallingContext(trans, @ref, Const4.AddToIdTree
, false);
context.ActivationDepth(new LegacyActivationDepth(1));
return(context.ReadFieldValue(this));
}
}
internal virtual void Analyze(Transaction trans)
{
_ref = trans.ReferenceForObject(_obj);
if (_ref != null)
{
_classMetadata = _ref.ClassMetadata();
return;
}
IReflectClass claxx = _container.Reflector().ForObject(_obj);
if (claxx == null)
{
NotStorable(_obj, claxx);
return;
}
if (!DetectClassMetadata(trans, claxx))
{
return;
}
if (IsValueType(_classMetadata))
{
NotStorable(_obj, _classMetadata.ClassReflector());
}
}
private bool DetectClassMetadata(Transaction trans, IReflectClass claxx)
{
_classMetadata = _container.GetActiveClassMetadata(claxx);
if (_classMetadata != null)
{
if (!_classMetadata.IsStorable())
{
NotStorable(_obj, claxx);
return false;
}
return true;
}
_classMetadata = _container.ProduceClassMetadata(claxx);
if (_classMetadata == null || !_classMetadata.IsStorable())
{
NotStorable(_obj, claxx);
return false;
}
// The following may return a reference if the object is held
// in a static variable somewhere ( often: Enums) that gets
// stored or associated on initialization of the ClassMetadata.
_ref = trans.ReferenceForObject(_obj);
return true;
}
private bool DetectClassMetadata(Transaction trans, IReflectClass claxx)
{
_classMetadata = _container.GetActiveClassMetadata(claxx);
if (_classMetadata != null)
{
if (!_classMetadata.IsStorable())
{
NotStorable(_obj, claxx);
return(false);
}
return(true);
}
_classMetadata = _container.ProduceClassMetadata(claxx);
if (_classMetadata == null || !_classMetadata.IsStorable())
{
NotStorable(_obj, claxx);
return(false);
}
// The following may return a reference if the object is held
// in a static variable somewhere ( often: Enums) that gets
// stored or associated on initialization of the ClassMetadata.
_ref = trans.ReferenceForObject(_obj);
return(true);
}
internal virtual void Analyze(Transaction trans)
{
_ref = trans.ReferenceForObject(_obj);
if (_ref != null)
{
_classMetadata = _ref.ClassMetadata();
return;
}
var claxx = _container.Reflector().ForObject(_obj);
if (claxx == null)
{
NotStorable(_obj, claxx);
return;
}
if (!DetectClassMetadata(trans, claxx))
{
return;
}
if (IsValueType(_classMetadata))
{
NotStorable(_obj, _classMetadata.ClassReflector());
}
}
internal virtual object Descend(Transaction trans, object obj, string[] path)
{
lock (_lock)
{
trans = CheckTransaction(trans);
ObjectReference @ref = trans.ReferenceForObject(obj);
if (@ref == null)
{
return null;
}
string fieldName = path[0];
if (fieldName == null)
{
return null;
}
ClassMetadata classMetadata = @ref.ClassMetadata();
ByRef foundField = new ByRef();
classMetadata.TraverseAllAspects(new _TraverseFieldCommand_693(fieldName, foundField
));
FieldMetadata field = (FieldMetadata)foundField.value;
if (field == null)
{
return null;
}
object child = @ref.IsActive() ? field.Get(trans, obj) : DescendMarshallingContext
(trans, @ref).ReadFieldValue(field);
if (path.Length == 1)
{
return child;
}
if (child == null)
{
return null;
}
string[] subPath = new string[path.Length - 1];
System.Array.Copy(path, 1, subPath, 0, path.Length - 1);
return Descend(trans, child, subPath);
}
}
public void Delete1(Transaction trans, object obj, bool userCall)
{
if (obj == null)
{
return;
}
ObjectReference @ref = trans.ReferenceForObject(obj);
if (@ref == null)
{
return;
}
if (userCall)
{
GenerateCallIDOnTopLevel();
}
AsTopLevelCall(new _IFunction4_565(this, @ref, obj, userCall), trans);
}
/// <summary>allows special handling for all Db4oType objects.</summary>
/// <remarks>
/// allows special handling for all Db4oType objects.
/// Redirected here from #set() so only instanceof check is necessary
/// in the #set() method.
/// </remarks>
/// <returns>object if handled here and #set() should not continue processing</returns>
public virtual IDb4oType Db4oTypeStored(Transaction trans, object obj)
{
if (!(obj is Db4oDatabase))
{
return null;
}
Db4oDatabase database = (Db4oDatabase)obj;
if (trans.ReferenceForObject(obj) != null)
{
return database;
}
ShowInternalClasses(true);
try
{
return database.Query(trans);
}
finally
{
ShowInternalClasses(false);
}
}
// overridden to do nothing in YapObjectCarrier
internal List4 StillTo1(Transaction trans, List4 still, object obj, IActivationDepth
depth)
{
if (obj == null || !depth.RequiresActivation())
{
return still;
}
ObjectReference @ref = trans.ReferenceForObject(obj);
if (@ref != null)
{
if (HandledInCurrentTopLevelCall(@ref))
{
return still;
}
FlagAsHandled(@ref);
return new List4(still, new ObjectContainerBase.PendingActivation(@ref, depth));
}
IReflectClass clazz = ReflectorForObject(obj);
if (clazz.IsArray())
{
if (!clazz.GetComponentType().IsPrimitive())
{
IEnumerator arr = ArrayHandler.Iterator(clazz, obj);
while (arr.MoveNext())
{
object current = arr.Current;
if (current == null)
{
continue;
}
ClassMetadata classMetadata = ClassMetadataForObject(current);
still = StillTo1(trans, still, current, depth.Descend(classMetadata));
}
}
return still;
}
else
{
if (obj is Entry)
{
still = StillTo1(trans, still, ((Entry)obj).key, depth);
still = StillTo1(trans, still, ((Entry)obj).value, depth);
}
else
{
if (depth.Mode().IsDeactivate())
{
// Special handling to deactivate .net structs
ClassMetadata metadata = ClassMetadataForObject(obj);
if (metadata != null && metadata.IsStruct())
{
metadata.ForceDeactivation(trans, depth, obj);
}
}
}
}
return still;
}
public bool IsStored(Transaction trans, object obj)
{
lock (_lock)
{
trans = CheckTransaction(trans);
if (obj == null)
{
return false;
}
ObjectReference @ref = trans.ReferenceForObject(obj);
if (@ref == null)
{
return false;
}
return !IsDeleted(trans, @ref.GetID());
}
}
internal bool IsActive(Transaction trans, object obj)
{
lock (_lock)
{
trans = CheckTransaction(trans);
if (obj != null)
{
ObjectReference @ref = trans.ReferenceForObject(obj);
if (@ref != null)
{
return @ref.IsActive();
}
}
return false;
}
}
public IObjectInfo GetObjectInfo(Transaction trans, object obj)
{
lock (_lock)
{
trans = CheckTransaction(trans);
return trans.ReferenceForObject(obj);
}
}
public int GetID(Transaction trans, object obj)
{
lock (_lock)
{
trans = CheckTransaction(trans);
CheckClosed();
if (obj == null)
{
return 0;
}
ObjectReference yo = trans.ReferenceForObject(obj);
if (yo != null)
{
return yo.GetID();
}
return 0;
}
}
public object Get(Transaction trans, object onObject)
{
if (_containingClass == null)
{
return null;
}
ObjectContainerBase container = Container();
if (container == null)
{
return null;
}
lock (container.Lock())
{
// FIXME: The following is not really transactional.
// This will work OK for normal C/S and for
// single local mode but the transaction will
// be wrong for MTOC.
if (trans == null)
{
trans = container.Transaction;
}
container.CheckClosed();
ObjectReference @ref = trans.ReferenceForObject(onObject);
if (@ref == null)
{
return null;
}
int id = @ref.GetID();
if (id <= 0)
{
return null;
}
UnmarshallingContext context = new UnmarshallingContext(trans, @ref, Const4.AddToIdTree
, false);
context.ActivationDepth(new LegacyActivationDepth(1));
return context.ReadFieldValue(this);
}
}
