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);
}
public override bool CanSkip(ObjectReference @ref)
{
ClassMetadata clazz = @ref.ClassMetadata();
return(clazz.Reflector().ForClass(typeof(IActivatable)).IsAssignableFrom(clazz.ClassReflector
()) && !_query.IsModified(@ref.GetObject()));
}
private bool IsTAAware(ClassMetadata classMetadata)
{
GenericReflector reflector = classMetadata.Reflector();
return(reflector.ForClass(typeof(IActivatable)).IsAssignableFrom(classMetadata.ClassReflector
()));
}
public ClassMetadata ReadClassMetadata(ClassMetadata classMetadata, IReflectClass
clazz)
{
if (classMetadata == null)
{
throw new ArgumentNullException();
}
if (!classMetadata.StateUnread())
{
return(classMetadata);
}
_classMetadataCreationDepth++;
try
{
classMetadata.ResolveNameConfigAndReflector(this, clazz);
IReflectClass claxx = classMetadata.ClassReflector();
if (claxx != null)
{
_classMetadataByClass.Put(claxx, classMetadata);
classMetadata.ReadThis();
classMetadata.CheckChanges();
_initClassMetadataOnUp.Add(classMetadata);
}
}
finally
{
_classMetadataCreationDepth--;
}
InitClassMetadataOnUp();
return(classMetadata);
}
private void EnsureAllClassesRead()
{
bool allClassesRead = false;
while (!allClassesRead)
{
Collection4 unreadClasses = new Collection4();
int numClasses = _classes.Size();
IEnumerator classIter = _classes.GetEnumerator();
while (classIter.MoveNext())
{
ClassMetadata clazz = (ClassMetadata)classIter.Current;
if (clazz.StateUnread())
{
unreadClasses.Add(clazz);
}
}
IEnumerator unreadIter = unreadClasses.GetEnumerator();
while (unreadIter.MoveNext())
{
ClassMetadata clazz = (ClassMetadata)unreadIter.Current;
clazz = ReadClassMetadata(clazz, null);
if (clazz.ClassReflector() == null)
{
clazz.ForceRead();
}
}
allClassesRead = (_classes.Size() == numClasses);
}
ApplyReadAs();
}
public virtual IReflectClass ClassReflector(IReflector reflector, ClassMetadata classMetadata
, bool isPrimitive)
{
return(isPrimitive
? Handlers4.PrimitiveClassReflector(classMetadata, reflector)
: classMetadata.ClassReflector());
}
public virtual IReflectClass ClassReflector(IReflector reflector, ClassMetadata classMetadata
, bool isPrimitive)
{
return isPrimitive
? Handlers4.PrimitiveClassReflector(classMetadata, reflector)
: classMetadata.ClassReflector();
}
protected override bool Accept(ClassMetadata classmetadata)
{
#if CF || SILVERLIGHT
return(false);
#else
return(NetReflector.ToNative(classmetadata.ClassReflector()) == typeof(DateTimeOffset));
#endif
}
protected override bool Accept(ClassMetadata classmetadata)
{
#if CF || SILVERLIGHT
return false;
#else
return NetReflector.ToNative(classmetadata.ClassReflector()) == typeof (DateTimeOffset);
#endif
}
private static object ToEnum(IContext context, int classId, long enumValue)
{
ClassMetadata clazz = Container(context).ClassMetadataForID(classId);
Type enumType = NetReflector.ToNative(clazz.ClassReflector());
return(Enum.ToObject(enumType, enumValue));
}
public void Visit(object obj)
{
ClassMetadata classMetadata = (ClassMetadata)obj;
QConClass qcc = new QConClass(this._enclosing._trans, classMetadata.ClassReflector
());
this._enclosing.AddConstraint(qcc);
this._enclosing.ToConstraint(this._enclosing.i_constraints).Or(qcc);
}
protected override bool Accept(ClassMetadata classmetadata)
{
var isGuid = NetReflector.ToNative(classmetadata.ClassReflector()) == typeof (Guid);
if (!isGuid)
{
classmetadata.TraverseDeclaredFields(reindexer);
}
return isGuid;
}
protected override bool Accept(ClassMetadata classmetadata)
{
var isGuid = NetReflector.ToNative(classmetadata.ClassReflector()) == typeof(Guid);
if (!isGuid)
{
classmetadata.TraverseDeclaredFields(reindexer);
}
return(isGuid);
}
public virtual IList Analyze()
{
IList ancestors = new ArrayList();
ClassMetadata storedAncestor = _storedClass.GetAncestor();
IReflectClass runtimeAncestor = _runtimeClass.GetSuperclass();
while (storedAncestor != null)
{
if (runtimeAncestor == storedAncestor.ClassReflector())
{
ancestors.Add(new HierarchyAnalyzer.Same(storedAncestor));
}
else
{
do
{
ancestors.Add(new HierarchyAnalyzer.Removed(storedAncestor));
storedAncestor = storedAncestor.GetAncestor();
if (null == storedAncestor)
{
if (IsObject(runtimeAncestor))
{
return(ancestors);
}
ThrowUnsupportedAdd(runtimeAncestor);
}
if (runtimeAncestor == storedAncestor.ClassReflector())
{
ancestors.Add(new HierarchyAnalyzer.Same(storedAncestor));
break;
}
}while (storedAncestor != null);
}
storedAncestor = storedAncestor.GetAncestor();
runtimeAncestor = runtimeAncestor.GetSuperclass();
}
if (runtimeAncestor != null && (!IsObject(runtimeAncestor)))
{
ThrowUnsupportedAdd(runtimeAncestor);
}
return(ancestors);
}
public virtual void TestClassMetadataForName()
{
string className = CrossPlatformServices.FullyQualifiedName(typeof(InternalObjectContainerAPITestCase.Item
));
ClassMetadata clazz = ((IInternalObjectContainer)Db()).ClassMetadataForName(className
);
Assert.AreEqual(className, clazz.GetName());
Assert.AreEqual(Reflector().ForClass(typeof(InternalObjectContainerAPITestCase.Item
)), clazz.ClassReflector());
}
public virtual bool SkipClass(ClassMetadata classMetadata)
{
if (classMetadata.GetName() == null)
{
return true;
}
var 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);
}
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 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);
}
}
private void DeleteMembers(StatefulBuffer objectBytes)
{
ObjectHeader oh = new ObjectHeader(_clazz, objectBytes);
DeleteInfo info = (DeleteInfo)TreeInt.Find(_transaction._delete, _id);
if (info != null)
{
if (info._cascade > _cascade)
{
_cascade = info._cascade;
}
}
objectBytes.SetCascadeDeletes(_cascade);
DeleteContextImpl context = new DeleteContextImpl(objectBytes, oh, _clazz.ClassReflector
(), null);
_clazz.DeleteMembers(context, _typeInfo, true);
}
public override void LoadFromClassIndexes(ClassMetadataIterator iter)
{
// duplicates because of inheritance hierarchies
ByRef duplicates = new ByRef();
while (iter.MoveNext())
{
ClassMetadata classMetadata = iter.CurrentClass();
if (classMetadata.GetName() != null)
{
IReflectClass claxx = classMetadata.ClassReflector();
if (claxx == null || !(Stream()._handlers.IclassInternal.IsAssignableFrom(claxx)))
{
IClassIndexStrategy index = classMetadata.Index();
index.TraverseAll(_transaction, new _IVisitor4_130(this, duplicates));
}
}
}
}
private ClassMetadata DetectFieldType()
{
IReflectClass claxx = _containingClass.ClassReflector();
if (claxx == null)
{
return(null);
}
_reflectField = claxx.GetDeclaredField(_name);
if (_reflectField == null)
{
return(null);
}
IReflectClass fieldType = _reflectField.GetFieldType();
if (fieldType == null)
{
return(null);
}
return(Handlers4.ErasedFieldType(Container(), fieldType));
}
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);
}
public Collection4 ForInterface(IReflectClass claxx)
{
Collection4 col = new Collection4();
ClassMetadataIterator i = Iterator();
while (i.MoveNext())
{
ClassMetadata clazz = i.CurrentClass();
IReflectClass candidate = clazz.ClassReflector();
if (!candidate.IsInterface())
{
if (claxx.IsAssignableFrom(candidate))
{
col.Add(clazz);
IEnumerator j = new Collection4(col).GetEnumerator();
while (j.MoveNext())
{
ClassMetadata existing = (ClassMetadata)j.Current;
if (existing != clazz)
{
ClassMetadata higher = clazz.GetHigherHierarchy(existing);
if (higher != null)
{
if (higher == clazz)
{
col.Remove(existing);
}
else
{
col.Remove(clazz);
}
}
}
}
}
}
}
return(col);
}
internal virtual ClassMetadata ReadClassMetadata()
{
if (_classMetadata == null)
{
Read();
if (_bytes != null)
{
Seek(0);
ObjectContainerBase stream = Container();
var objectHeader = new ObjectHeader(stream, _bytes);
_classMetadata = objectHeader.ClassMetadata();
if (_classMetadata != null)
{
if (stream._handlers.IclassCompare.IsAssignableFrom(_classMetadata.ClassReflector
()))
{
ReadThis(false);
}
}
}
}
return(_classMetadata);
}
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 ClassMetadata ReadClassMetadata()
{
if (_classMetadata == null)
{
Read();
if (_bytes != null)
{
Seek(0);
ObjectContainerBase stream = Container();
var 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)
{
var reflector = classMetadata.Reflector();
return reflector.ForClass(typeof (IActivatable)).IsAssignableFrom(classMetadata.ClassReflector
());
}
protected override bool Accept(ClassMetadata classmetadata)
{
return(NetReflector.ToNative(classmetadata.ClassReflector()) == typeof(Guid));
}
protected override bool Accept(ClassMetadata classmetadata)
{
var type = NetReflector.ToNative(classmetadata.ClassReflector());
return type != null ? type.IsEnum : false;
}
protected override bool Accept(ClassMetadata classmetadata)
{
var type = NetReflector.ToNative(classmetadata.ClassReflector());
return(type != null ? type.IsEnum : false);
}
protected override bool Accept(ClassMetadata classmetadata)
{
return NetReflector.ToNative(classmetadata.ClassReflector()) == typeof(Guid);
}
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);
}
private void AddFieldConstraint(ClassMetadata containingClass, FieldMetadata field
)
{
var qcc = new QConClass(_enclosing._trans, null, field.QField(_enclosing
._trans), containingClass.ClassReflector());
_enclosing.AddConstraint(qcc);
_enclosing.ToConstraint(_enclosing.i_constraints).Or(qcc);
}
