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(), " Value types can only be stored embedded in parent objects."
);
}
}
public override Db4objects.Db4o.Internal.ClassMetadata ClassMetadata()
{
if (_classMetadata != null)
{
return(_classMetadata);
}
Read();
if (_bytes == null)
{
return(null);
}
Seek(0);
ObjectContainerBase stream = Container();
ObjectHeader objectHeader = new ObjectHeader(stream, _bytes);
_classMetadata = objectHeader.ClassMetadata();
if (_classMetadata != null)
{
if (stream._handlers.IclassCompare.IsAssignableFrom(_classMetadata.ClassReflector
()))
{
ReadThis(false);
}
}
return(_classMetadata);
}
internal virtual IReflectClass ClassReflector()
{
ReadClassMetadata();
if (_classMetadata == null)
{
return(null);
}
return(_classMetadata.ClassReflector());
}
public virtual bool SkipClass(ClassMetadata classMetadata)
{
if (classMetadata.GetName() == null)
{
return true;
}
IReflectClass claxx = classMetadata.ClassReflector();
if (Stream()._handlers.IclassInternal.IsAssignableFrom(claxx))
{
return true;
}
return false;
}
public void AddClassMetadata(ClassMetadata clazz)
{
Container().SetDirtyInSystemTransaction(this);
_classes.Add(clazz);
if (clazz.StateUnread())
{
_classMetadataByBytes.Put(clazz.i_nameBytes, clazz);
}
else
{
_classMetadataByClass.Put(clazz.ClassReflector(), clazz);
}
RegisterClassMetadataById(clazz);
}
protected void Analyze(ObjectContainerBase container, object obj, ArrayInfo info)
{
// TODO: Move as much analysis as possible to ReflectArray#analyze()
ArrayReflector(container).Analyze(obj, info);
IReflectClass claxx = ComponentType(container, obj);
Db4objects.Db4o.Internal.ClassMetadata classMetadata = container.ProduceClassMetadata
(claxx);
bool primitive = IsPrimitive(container.Reflector(), claxx, classMetadata);
if (primitive)
{
claxx = classMetadata.ClassReflector();
}
info.Primitive(primitive);
info.ReflectClass(claxx);
AnalyzeDimensions(container, obj, info);
}
internal virtual Db4objects.Db4o.Internal.ClassMetadata ReadClassMetadata()
{
if (_classMetadata == null)
{
Read();
if (_bytes != null)
{
Seek(0);
ObjectContainerBase stream = Container();
ObjectHeader objectHeader = new ObjectHeader(stream, _bytes);
_classMetadata = objectHeader.ClassMetadata();
if (_classMetadata != null)
{
if (stream._handlers.IclassCompare.IsAssignableFrom(_classMetadata.ClassReflector
()))
{
ReadThis(false);
}
}
}
}
return _classMetadata;
}
private bool IsTAAware(ClassMetadata classMetadata)
{
GenericReflector reflector = classMetadata.Reflector();
return reflector.ForClass(typeof(IActivatable)).IsAssignableFrom(classMetadata.ClassReflector
());
}
public void RefreshClassCache(ClassMetadata clazz, IReflectClass oldReflector)
{
if (clazz.StateUnread())
{
_classMetadataByBytes.Put(clazz.ReadName(_systemTransaction), clazz);
}
else
{
if (oldReflector != null)
{
_classMetadataByClass.Remove(oldReflector);
}
_classMetadataByClass.Put(clazz.ClassReflector(), clazz);
}
}
public ClassMetadata ReadClassMetadata(ClassMetadata classMetadata, IReflectClass
clazz)
{
if (classMetadata == null)
{
throw new ArgumentNullException();
}
if (!classMetadata.StateUnread())
{
return classMetadata;
}
_classMetadataCreationDepth++;
try
{
classMetadata.CreateConfigAndConstructor(_classMetadataByBytes, clazz);
IReflectClass claxx = classMetadata.ClassReflector();
if (claxx != null)
{
_classMetadataByClass.Put(claxx, classMetadata);
classMetadata.ReadThis();
classMetadata.CheckChanges();
_initClassMetadataOnUp.Add(classMetadata);
}
}
finally
{
_classMetadataCreationDepth--;
}
InitClassMetadataOnUp();
return classMetadata;
}
public virtual IReflectClass ClassReflector(IReflector reflector, ClassMetadata classMetadata
, bool isPrimitive)
{
return isPrimitive ? Handlers4.PrimitiveClassReflector(classMetadata, reflector) :
classMetadata.ClassReflector();
}
public virtual bool IsAssignableFrom(ClassMetadata other
)
{
return ClassReflector().IsAssignableFrom(other.ClassReflector());
}
public void OnClassRegistered(ClassMetadata clazz)
{
// if(Platform4.isDb4oClass(clazz.getName())) {
// return;
// }
IReflectClass reflectClass = clazz.ClassReflector();
if (this.ActivatableClass().IsAssignableFrom(reflectClass))
{
return;
}
if (this.HasNoActivatingFields(reflectClass))
{
return;
}
NotTransparentActivationEnabled diagnostic = new NotTransparentActivationEnabled(
clazz);
DiagnosticProcessor processor = this._container.Handlers.DiagnosticProcessor();
processor.OnDiagnostic(diagnostic);
}
private void AddFieldConstraint(ClassMetadata containingClass, FieldMetadata field
)
{
QConClass qcc = new QConClass(this._enclosing._trans, null, field.QField(this._enclosing
._trans), containingClass.ClassReflector());
this._enclosing.AddConstraint(qcc);
this._enclosing.ToConstraint(this._enclosing.i_constraints).Or(qcc);
}
internal virtual Db4objects.Db4o.Internal.ClassMetadata ReadClassMetadata()
{
if (_classMetadata == null)
{
Read();
if (_bytes != null)
{
Seek(0);
ObjectContainerBase stream = Container();
ObjectHeader objectHeader = new ObjectHeader(stream, _bytes);
_classMetadata = objectHeader.ClassMetadata();
if (_classMetadata != null)
{
if (stream._handlers.IclassCompare.IsAssignableFrom(_classMetadata.ClassReflector
()))
{
ReadThis(false);
}
}
}
}
return _classMetadata;
}
