public virtual IReflectClass ClassReflector(IReflector reflector, ClassMetadata classMetadata , bool isPrimitive) { return isPrimitive ? Handlers4.PrimitiveClassReflector(classMetadata, reflector) : classMetadata.ClassReflector(); }
public ModifiedAspectTraversalStrategy(ClassMetadata classMetadata, IList ancestors ) { _classDiffs = new ArrayList(); _classDiffs.Add(new HierarchyAnalyzer.Same(classMetadata)); Sharpen.Collections.AddAll(_classDiffs, ancestors); }
internal QCandidates(LocalTransaction a_trans, ClassMetadata a_classMetadata, QField a_field) { // Transaction necessary as reference to stream // root of the QCandidate tree // collection of all constraints // possible class information // possible field information // current executing constraint, only set where needed i_trans = a_trans; i_classMetadata = a_classMetadata; _field = a_field; if (a_field == null || a_field._fieldMetadata == null || !(a_field._fieldMetadata .GetHandler() is StandardReferenceTypeHandler)) { return; } var yc = ((StandardReferenceTypeHandler) a_field._fieldMetadata.GetHandler ()).ClassMetadata(); if (i_classMetadata == null) { i_classMetadata = yc; } else { yc = i_classMetadata.GetHigherOrCommonHierarchy(yc); if (yc != null) { i_classMetadata = yc; } } }
protected override bool Accept(ClassMetadata classmetadata) { #if CF || SILVERLIGHT return false; #else return NetReflector.ToNative(classmetadata.ClassReflector()) == typeof (DateTimeOffset); #endif }
public virtual IUpdateDepth Adjust(ClassMetadata clazz) { if (clazz.CascadesOnDeleteOrUpdate()) { return AdjustDepthToBorders().Descend(); } return Descend(); }
public override IActivationDepth Descend(ClassMetadata metadata) { if (_depth < 1) { return this; } return new FixedActivationDepth(_depth - 1, _mode ); }
public SodaQueryComparator(LocalObjectContainer container, ClassMetadata extent, Ordering[] orderings) { _container = container; _transaction = ((LocalTransaction) _container.Transaction); _extentType = extent; _orderings = orderings; ResolveFieldPaths(orderings); }
private int ConfiguredActivationDepth(ClassMetadata metadata) { var config = metadata.ConfigOrAncestorConfig(); if (config != null && _mode.IsActivate()) { return config.AdjustActivationDepth(_depth); } return _depth; }
protected override bool Accept(ClassMetadata classmetadata) { var isGuid = NetReflector.ToNative(classmetadata.ClassReflector()) == typeof (Guid); if (!isGuid) { classmetadata.TraverseDeclaredFields(reindexer); } return isGuid; }
public HierarchyAnalyzer(ClassMetadata storedClass, IReflectClass runtimeClass) { if (storedClass == null || runtimeClass == null) { throw new ArgumentNullException(); } _storedClass = storedClass; _runtimeClass = runtimeClass; _objectClass = runtimeClass.Reflector().ForClass(typeof (object)); }
public override IActivationDepth Descend(ClassMetadata metadata) { if (null == metadata) { return new LegacyActivationDepth(_depth - 1, _mode); } return new LegacyActivationDepth(DescendDepth (metadata), _mode); }
private int DescendDepth(ClassMetadata metadata) { var depth = ConfiguredActivationDepth(metadata) - 1; if (metadata.IsStruct()) { // We also have to instantiate structs completely every time. return Math.Max(1, depth); } return depth; }
protected override void ReadIndex(ObjectContainerBase stream, ClassMetadata clazz , ByteArrayBuffer reader) { var indexID = reader.ReadInt(); if (indexID == 0) { return; } clazz.Index().Read(stream, indexID); }
public virtual bool RebuildIndexForClass(LocalObjectContainer container, ClassMetadata classMetadata) { var ids = classMetadata.GetIDs(); for (var i = 0; i < ids.Length; i++) { RebuildIndexForObject(container, (int) ids[i]); } return ids.Length > 0; }
public override IReflectClass ClassReflector(IReflector reflector, ClassMetadata classMetadata, bool isPrimitive) { var primitiveClaxx = Handlers4.PrimitiveClassReflector(classMetadata, reflector ); if (primitiveClaxx != null) { return primitiveClaxx; } return base.ClassReflector(reflector, classMetadata, isPrimitive); }
public virtual void Write(Transaction trans, ClassMetadata clazz, ByteArrayBuffer writer) { writer.WriteShortString(trans, clazz.NameToWrite()); var intFormerlyKnownAsMetaClassID = 0; writer.WriteInt(intFormerlyKnownAsMetaClassID); writer.WriteIDOf(trans, clazz._ancestor); WriteIndex(trans, clazz, writer); writer.WriteInt(clazz.DeclaredAspectCount()); clazz.TraverseDeclaredAspects(new _IProcedure4_39(this, trans, clazz, writer)); }
public ClassMetadata Analyze(Type type) { ClassMetadata metadata = new ClassMetadata(type); foreach (IExtractor extractor in _extractors) { extractor.Extract(type, metadata, _heuristics); } return metadata; }
public void ShouldSetTypePropertyToPropertyArgument() { // Given // When var metadata = new ClassMetadata(typeof(Exception)); // Then metadata.Should().NotBeNull(); metadata.Type.Should().Be(typeof(Exception)); }
private int ProcessAspectsOf(ClassMetadata classMetadata, ITraverseAspectCommand command, int currentSlot, ITraverseAspectCommandProcessor processor) { var aspectCount = command.DeclaredAspectCount(classMetadata); for (var i = 0; i < aspectCount && !command.Cancelled(); i++) { processor.Process(command, classMetadata._aspects[i], currentSlot); currentSlot++; } return currentSlot; }
public virtual IActivationDepth ActivationDepthFor(ClassMetadata classMetadata, ActivationMode mode) { if (IsTAAware(classMetadata)) { return new NonDescendingActivationDepth(mode); } if (mode.IsPrefetch()) { return new FixedActivationDepth(1, mode); } return new DescendingActivationDepth(this, mode); }
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; }
protected override FieldMetadata FromSpec(RawFieldSpec spec, ObjectContainerBase stream, ClassMetadata containingClass) { var actualField = base.FromSpec(spec, stream, containingClass); if (spec == null) { return null; } if (spec.IndexID() != 0) { actualField.InitIndex(stream.SystemTransaction(), spec.IndexID()); } return actualField; }
public void Read(ObjectContainerBase stream, ClassMetadata clazz, ByteArrayBuffer reader) { clazz.SetAncestor(stream.ClassMetadataForID(reader.ReadInt())); // if(clazz.callConstructor()){ // // The logic further down checks the ancestor YapClass, whether // // or not it is allowed, not to call constructors. The ancestor // // YapClass may possibly have not been loaded yet. // clazz.createConstructor(true); // } clazz.CheckType(); ReadIndex(stream, clazz, reader); clazz._aspects = ReadAspects(stream, reader, clazz); }
internal FieldMetadata(ClassMetadata containingClass, IReflectField field, ClassMetadata fieldType) : this(containingClass) { Init(field.GetName()); _reflectField = field; _fieldType = fieldType; _fieldTypeID = fieldType.GetID(); // TODO: beautify !!! possibly pull up isPrimitive to ReflectField var isPrimitive = field is GenericField ? ((GenericField)field).IsPrimitive() : false; Configure(field.GetFieldType(), isPrimitive); CheckDb4oType(); SetAvailable(); }
internal void ReReadClassMetadata(ClassMetadata clazz) { if (clazz != null) { ReReadClassMetadata(clazz._ancestor); clazz.ReadName(_systemTransaction); clazz.ForceRead(); clazz.SetStateClean(); clazz.BitFalse(Const4.CheckedChanges); clazz.BitFalse(Const4.Reading); clazz.BitFalse(Const4.Continue); clazz.BitFalse(Const4.Dead); clazz.CheckChanges(); } }
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 GetClassMetadata(string name) { ClassMetadata classMetadata = (ClassMetadata)_classMetadataByBytes.Remove(GetNameBytes (name)); if (classMetadata == null) { classMetadata = FindInitializedClassByName(name); } if (classMetadata != null) { classMetadata = ReadClassMetadata(classMetadata, null); } return(classMetadata); }
public int ClassMetadataIdForName(string name) { ClassMetadata classMetadata = (ClassMetadata)_classMetadataByBytes.Get(GetNameBytes (name)); if (classMetadata == null) { classMetadata = FindInitializedClassByName(name); } if (classMetadata != null) { return(classMetadata.GetID()); } return(0); }
public override void Write(Transaction trans, ClassMetadata clazz, ClassAspect aspect , ByteArrayBuffer writer) { base.Write(trans, clazz, aspect, writer); if (!(aspect is FieldMetadata)) { return; } var field = (FieldMetadata) aspect; if (!HasBTreeIndex(field)) { return; } writer.WriteIDOf(trans, field.GetIndex(trans)); }
public virtual IActivationDepth ActivationDepthFor(ClassMetadata classMetadata, ActivationMode mode) { if (mode.IsPrefetch()) { return new LegacyActivationDepth(1, mode); } var globalLegacyActivationDepth = ConfigImpl(classMetadata).ActivationDepth(); var config = classMetadata.ConfigOrAncestorConfig(); var defaultDepth = null == config ? globalLegacyActivationDepth : config.AdjustActivationDepth (globalLegacyActivationDepth); return new LegacyActivationDepth(defaultDepth, mode); }
public virtual IReflectClass ReflectClassFromElementsEntry(ObjectContainerBase container , ArrayInfo info, int classID) { if (classID == 0) { return(null); } ClassMetadata classMetadata = container.ClassMetadataForID(classID); if (classMetadata == null) { return(null); } return(ClassReflector(container.Reflector(), classMetadata, info.Primitive())); }
public string ToString(ClassMetadata classMetadata) { var result = new StringBuilder(); if (Value is Criteria) { var criteria = Value as Criteria; result.Append(criteria.ToString(classMetadata)); } else { result.Append(OperationToString(classMetadata)); } return(result.ToString()); }
protected override FieldMetadata FromSpec(RawFieldSpec spec, ObjectContainerBase stream, ClassMetadata containingClass) { var actualField = base.FromSpec(spec, stream, containingClass); if (spec == null) { return(null); } if (spec.IndexID() != 0) { actualField.InitIndex(stream.SystemTransaction(), spec.IndexID()); } return(actualField); }
public virtual object ReadFieldValue(FieldMetadata field) { ReadBuffer(ObjectId()); if (Buffer() == null) { return(null); } ClassMetadata classMetadata = ReadObjectHeader(); if (classMetadata == null) { return(null); } return(ReadFieldValue(classMetadata, field)); }
public Msg ReplyFromServer() { int id = _payLoad.ReadInt(); string name = string.Empty; lock (ContainerLock()) { ClassMetadata classMetadata = Container().ClassMetadataForID(id); if (classMetadata != null) { name = classMetadata.GetName(); } } return(Msg.ClassNameForId.GetWriterForString(Transaction(), name)); }
/// <summary> /// Defines the point class /// </summary> /// <param name="virtualMachine">The VM to define for</param> public static (ClassType, ManagedFunction) DefinePointClass(VirtualMachine virtualMachine) { var intType = virtualMachine.TypeProvider.FindPrimitiveType(PrimitiveTypes.Int); var voidType = virtualMachine.TypeProvider.FindPrimitiveType(PrimitiveTypes.Void); var pointMetadata = new ClassMetadata("Point"); pointMetadata.DefineField(new FieldDefinition("x", intType, AccessModifier.Public)); pointMetadata.DefineField(new FieldDefinition("y", intType, AccessModifier.Public)); pointMetadata.CreateFields(); virtualMachine.ClassMetadataProvider.Add(pointMetadata); var pointType = virtualMachine.TypeProvider.FindClassType("Point"); return(pointType, CreateDefaultConstructor(virtualMachine, pointType)); }
private static TypeStatement NormalizeLiteralTypeStatement( TypeStatement type, ClassMetadata classMetadata, AbstractSyntaxTree ast, TypeOverrideDetails typeOverrideDetails ) { if (type.IsTypeQuery) { var(found, className, toGenerateNode) = GetNode( type.TypeQuery.Class, ast ); if (!found) { return(type); } var typeNode = toGenerateNode.Children.FirstOrDefault( a => a.IdentifierStr == type.TypeQuery.Type ); if (typeNode is not null) { var typedType = GenericTypeIdentifier.Identify( typeNode.Last, classMetadata, ast, typeOverrideDetails ); return(typedType); } } if (type.IsLiteral) { type.Name = GenerationIdentifiedTypes.CachedEntity; } var literalGenericTypes = type.GenericTypes.Where( a => a.IsLiteral ); foreach (var genericType in literalGenericTypes) { genericType.Name = GenerationIdentifiedTypes.CachedEntity; } return(type); }
// Our QConPath objects are just placeholders to fields, // so the parents are reachable. // If we find a "real" constraint, we throw the QPath // out and replace it with the other constraint. private void Morph(BooleanByRef removeExisting, QCon newConstraint, IReflectClass claxx) { bool mayMorph = true; if (claxx != null) { ClassMetadata yc = i_trans.Container().ProduceClassMetadata(claxx); if (yc != null) { IEnumerator i = IterateChildren(); while (i.MoveNext()) { QField qf = ((QCon)i.Current).GetField(); if (!yc.HasField(i_trans.Container(), qf.Name())) { mayMorph = false; break; } } } } // } if (mayMorph) { IEnumerator j = IterateChildren(); while (j.MoveNext()) { newConstraint.AddConstraint((QCon)j.Current); } if (HasJoins()) { IEnumerator k = IterateJoins(); while (k.MoveNext()) { QConJoin qcj = (QConJoin)k.Current; qcj.ExchangeConstraint(this, newConstraint); newConstraint.AddJoin(qcj); } } i_parent.ExchangeConstraint(this, newConstraint); removeExisting.value = true; } else { i_parent.AddConstraint(newConstraint); } }
public string ToString(ClassMetadata classMetadata) { var orderStr = new StringBuilder(); var i = 0; foreach (var subOrder in subOrders) { if (i > 0) { orderStr.Append(","); } orderStr.Append(subOrder.ToString(classMetadata)); i++; } return(orderStr.Length > 0 ? string.Format(" ORDER BY {0}", orderStr) : ""); }
private ObjectHeader(ObjectContainerBase container, ClassMetadata classMetadata, IReadWriteBuffer reader) { var classID = reader.ReadInt(); _marshallerFamily = ReadMarshallerFamily(reader, classID); classID = NormalizeID(classID); _classMetadata = (classMetadata != null ? classMetadata : container.ClassMetadataForID (classID)); // This check has been added to cope with defragment in debug mode: SlotDefragment#setIdentity() // will trigger calling this constructor with a source db class metadata and a target db stream, // thus _classMetadata==null. There may be a better solution, since this call is just meant to // skip the object header. _headerAttributes = SlotFormat().ReadHeaderAttributes((ByteArrayBuffer) reader); }
private static string UnionTypeCheck( Node node, ClassMetadata classMetadata ) { var firstNode = node.Children.FirstOrDefault( childNode => childNode.Kind != SyntaxKind.NullKeyword && childNode.Kind != SyntaxKind.UndefinedKeyword ); return(GetFromNode( firstNode, firstNode.Kind, classMetadata )); }
public virtual IActivationDepth ActivationDepthFor(ClassMetadata classMetadata, ActivationMode mode) { if (mode.IsPrefetch()) { return(new LegacyActivationDepth(1, mode)); } var globalLegacyActivationDepth = ConfigImpl(classMetadata).ActivationDepth(); var config = classMetadata.ConfigOrAncestorConfig(); var defaultDepth = null == config ? globalLegacyActivationDepth : config.AdjustActivationDepth (globalLegacyActivationDepth); return(new LegacyActivationDepth(defaultDepth, mode)); }
private FileUsageStatsCollector.InstanceUsage ClassSlotUsage(ClassMetadata clazz) { if (!clazz.HasClassIndex()) { return(new FileUsageStatsCollector.InstanceUsage(0, 0)); } IMiscCollector miscCollector = ((IMiscCollector)MiscCollectors[clazz.GetName()]); LongByRef slotUsage = new LongByRef(); LongByRef miscUsage = new LongByRef(); BTreeClassIndexStrategy index = (BTreeClassIndexStrategy)clazz.Index(); index.TraverseAll(_db.SystemTransaction(), new _IVisitor4_166(this, slotUsage, miscCollector , miscUsage)); return(new FileUsageStatsCollector.InstanceUsage(slotUsage.value, miscUsage.value )); }
public override void Write(Transaction trans, ClassMetadata clazz, ClassAspect aspect , ByteArrayBuffer writer) { base.Write(trans, clazz, aspect, writer); if (!(aspect is FieldMetadata)) { return; } var field = (FieldMetadata)aspect; if (!HasBTreeIndex(field)) { return; } writer.WriteIDOf(trans, field.GetIndex(trans)); }
private void CheckFieldTypeID() { int id = _fieldType != null?_fieldType.GetID() : 0; if (_fieldTypeID == 0) { _fieldTypeID = id; return; } if (id > 0 && id != _fieldTypeID) { // wrong type, refactoring, field should be turned off // TODO: it would be cool to log something here _fieldType = null; } }
/// <exception cref="System.Exception"></exception> public virtual void TestReflectField() { Store(new OldVersionReflectFieldAfterRefactorTestCase.ItemBefore(IdValue)); Reopen(); FileSession().StoredClass(typeof(OldVersionReflectFieldAfterRefactorTestCase.ItemBefore )).Rename(typeof(OldVersionReflectFieldAfterRefactorTestCase.ItemAfter).FullName ); Reopen(); ClassMetadata classMetadata = Container().ClassMetadataForName(typeof(OldVersionReflectFieldAfterRefactorTestCase.ItemAfter ).FullName); ByRef originalField = new ByRef(); classMetadata.TraverseDeclaredFields(new _IProcedure4_37(originalField)); Assert.AreEqual(typeof(int).FullName, ((FieldMetadata)originalField.value).GetStoredType ().GetName()); }
public void IterateTopLevelClasses(IVisitor4 visitor) { ClassMetadataIterator i = Iterator(); while (i.MoveNext()) { ClassMetadata classMetadata = i.CurrentClass(); if (!classMetadata.IsInternal()) { if (classMetadata.GetAncestor() == null) { visitor.Visit(classMetadata); } } } }
public static ITypeHandler4 CorrectHandlerVersion(IHandlerVersionContext context, ITypeHandler4 typeHandler, ClassMetadata classMetadata) { ITypeHandler4 correctHandlerVersion = CorrectHandlerVersion(context, typeHandler); if (typeHandler != correctHandlerVersion) { CorrectClassMetadataOn(correctHandlerVersion, classMetadata); if (correctHandlerVersion is ArrayHandler) { ArrayHandler arrayHandler = (ArrayHandler)correctHandlerVersion; CorrectClassMetadataOn(arrayHandler.DelegateTypeHandler(), classMetadata); } } return(correctHandlerVersion); }
public override bool CreateClassMetadata(ClassMetadata clazz, IReflectClass claxx , ClassMetadata superClazz) { Write(Msg.CreateClass.GetWriterForString(SystemTransaction(), Config().ResolveAliasRuntimeName (claxx.GetName()))); Msg resp = GetResponse(); if (resp == null) { return(false); } if (resp.Equals(Msg.Failed)) { // if the class can not be created on the server, send class meta to the server. SendClassMeta(claxx); resp = GetResponse(); } if (resp.Equals(Msg.Failed)) { if (ConfigImpl.ExceptionsOnNotStorable()) { throw new ObjectNotStorableException(claxx); } return(false); } if (!resp.Equals(Msg.ObjectToClient)) { return(false); } MsgObject message = (MsgObject)resp; StatefulBuffer bytes = message.Unmarshall(); if (bytes == null) { return(false); } bytes.SetTransaction(SystemTransaction()); if (!base.CreateClassMetadata(clazz, claxx, superClazz)) { return(false); } clazz.SetID(message.GetId()); clazz.ReadName1(SystemTransaction(), bytes); ClassCollection().AddClassMetadata(clazz); ClassCollection().ReadClassMetadata(clazz, claxx); return(true); }
public void TestDeallocationClassFields() { using (var container = this.CreateContainer()) { var gc = container.VirtualMachine.GarbageCollector; var intType = container.VirtualMachine.TypeProvider.FindPrimitiveType(PrimitiveTypes.Int); (var pointType, var pointConstructor) = TestHelpers.DefinePointClass(container.VirtualMachine); var listMetadata = new ClassMetadata("List"); listMetadata.DefineField(new FieldDefinition("head", pointType, AccessModifier.Public)); listMetadata.CreateFields(); container.VirtualMachine.ClassMetadataProvider.Add(listMetadata); var listType = container.VirtualMachine.TypeProvider.FindClassType("List"); var listConstructorFunction = TestHelpers.CreateDefaultConstructor(container.VirtualMachine, listType); var func = new ManagedFunction( new FunctionDefinition("main", new List <BaseType>(), intType), new List <BaseType>() { listType }, new List <Instruction>() { new Instruction(OpCodes.NewObject, ".constructor", listType, new List <BaseType>()), new Instruction(OpCodes.StoreLocal, 0), new Instruction(OpCodes.LoadLocal, 0), new Instruction(OpCodes.NewObject, ".constructor", pointType, new List <BaseType>()), new Instruction(OpCodes.StoreField, "List::head"), new Instruction(OpCodes.Call, "std.gc.collect", new List <BaseType>()), new Instruction(OpCodes.LoadInt, 0), new Instruction(OpCodes.Return) }); container.VirtualMachine.LoadFunctionsAsAssembly(new List <ManagedFunction>() { func, pointConstructor, listConstructorFunction }); var result = container.Execute(); Assert.AreEqual(1, gc.Deallocations.Count); Assert.AreEqual(0, gc.Deallocations[0].Count); } }
public static TypeStatement Identify( Node node, ClassMetadata classMetadata, TypeScriptAST ast, TypeOverrideDetails typeOverrideDetails ) { var typeIdentifier = TypeIdentifier.Identify( node, classMetadata ); var isTypeAlias = AliasTypeIdentifier.Identify( node, ast ); var aliasType = isTypeAlias ? AliasTypeStatementIdentifier.Identify( typeIdentifier, classMetadata, ast, typeOverrideDetails ) : null; var isLiteral = IsTypeLiteralRule.Check( node ) || TypeLiteralIdentifier.Identify( typeIdentifier ); var genericTypes = new List <TypeStatement>(); if (node is TypeReferenceNode referenceNode && referenceNode.TypeArguments != null && referenceNode.TypeArguments.Any()) { foreach (var typeArgument in referenceNode.TypeArguments) { if (typeArgument is Node typeArgumentNode) { genericTypes.Add( Identify( typeArgumentNode, classMetadata, ast, typeOverrideDetails ) ); } } }
public Update(ClassMetadata metadata) : base(90) { TableName = metadata.TableName; Alias = "t"; Fields = new List <string>(); foreach (var column in metadata.Columns.Select(c => c.Value).ToList()) { if (column.IsIdentifier || column.IsCustomColumn || (column.IsRelationship && column.RelationshipType == RelationshipType.OneToMany) ) { continue; } Fields.Add(column.ColumnName); } }
private FieldMetadata FieldMetadataFrom(QField qField, ClassMetadata type) { var existingField = qField.GetFieldMetadata(); if (existingField != null) { return(existingField); } var field = type.FieldMetadataForName(qField.Name()); if (field != null) { field.Alive(); } return(field); }
internal ClassMetadata ProduceClassMetadata(IReflectClass reflectClazz) { ClassMetadata classMetadata = ClassMetadataForReflectClass(reflectClazz); if (classMetadata != null) { return(classMetadata); } ClassMetadata classBeingCreated = (ClassMetadata)_creating.Get(reflectClazz); if (classBeingCreated != null) { return(classBeingCreated); } ClassMetadata newClassMetadata = new ClassMetadata(Container(), reflectClazz); _creating.Put(reflectClazz, newClassMetadata); try { if (!CreateClassMetadata(newClassMetadata, reflectClazz)) { return(null); } // ObjectContainerBase#createClassMetadata may add the ClassMetadata already, // so we have to check again if (!IsRegistered(reflectClazz)) { AddClassMetadata(newClassMetadata); _classInits.Process(newClassMetadata); } else { RegisterClassMetadataById(newClassMetadata); if (newClassMetadata.AspectsAreNull()) { _classInits.Process(newClassMetadata); } } Container().SetDirtyInSystemTransaction(this); } finally { _creating.Remove(reflectClazz); } return(newClassMetadata); }
internal ClassMetadata ClassMetadataForReflectClass(IReflectClass reflectClazz) { ClassMetadata cached = (ClassMetadata)_classMetadataByClass.Get(reflectClazz); if (cached != null) { return(cached); } ClassMetadata byName = (ClassMetadata)_classMetadataByName.Get(reflectClazz.GetName ()); if (byName != null) { return(byName); } return(ReadClassMetadata(reflectClazz)); }
public override void Defrag(ClassMetadata classMetadata, ClassAspect aspect, LatinStringIO sio, DefragmentContextImpl context) { context.IncrementStringOffset(sio); if (!(aspect is FieldMetadata)) { return; } if (((FieldMetadata)aspect).IsVirtual()) { return; } // handler ID context.CopyID(); // skip primitive/array/narray attributes context.IncrementOffset(1); }
private void AssociateYapClass(Transaction a_trans, object a_object) { if (a_object == null) { } else { //It seems that we need not result the following field //i_object = null; //i_comparator = Null.INSTANCE; //i_classMetadata = null; // FIXME: Setting the YapClass to null will prevent index use // If the field is typed we can guess the right one with the // following line. However this does break some SODA test cases. // Revisit! // if(i_field != null){ // i_classMetadata = i_field.getYapClass(); // } _classMetadata = a_trans.Container().ProduceClassMetadata(a_trans.Reflector().ForObject (a_object)); if (_classMetadata != null) { i_object = _classMetadata.GetComparableObject(a_object); if (a_object != i_object) { i_attributeProvider = _classMetadata.Config().QueryAttributeProvider(); _classMetadata = a_trans.Container().ProduceClassMetadata(a_trans.Reflector().ForObject (i_object)); } if (_classMetadata != null) { _classMetadata.CollectConstraints(a_trans, this, i_object, new _IVisitor4_84(this )); } else { AssociateYapClass(a_trans, null); } } else { AssociateYapClass(a_trans, null); } } }
public virtual void CheckClassHasFields(ClassMetadata classMetadata) { if (classMetadata.AspectsAreNull() || classMetadata.DeclaredAspectCount() == 0) { var name = classMetadata.GetName(); string[] ignoredPackages = {"java.util."}; for (var i = 0; i < ignoredPackages.Length; i++) { if (name.IndexOf(ignoredPackages[i]) == 0) { return; } } if (IsDb4oClass(classMetadata)) { return; } OnDiagnostic(new ClassHasNoFields(name)); } }
protected override void ReadIndex(ObjectContainerBase stream, ClassMetadata clazz , ByteArrayBuffer reader) { var indexID = reader.ReadInt(); if (!stream.MaintainsIndices() || !(stream is LocalObjectContainer)) { return; } if (Btree(clazz) != null) { return; } clazz.Index().Read(stream, ValidIndexId(indexID)); if (IsOldClassIndex(indexID)) { new ClassIndexesToBTrees_5_5().Convert((LocalObjectContainer) stream, indexID, Btree (clazz)); stream.SetDirtyInSystemTransaction(clazz); } }
protected virtual FieldMetadata FromSpec(RawFieldSpec spec, ObjectContainerBase stream , ClassMetadata containingClass) { if (spec == null) { return null; } var name = spec.Name(); if (spec.IsVirtualField()) { return stream._handlers.VirtualFieldByName(name); } if (spec.IsTranslator()) { return new TranslatedAspect(containingClass, name); } if (spec.IsField()) { return new FieldMetadata(containingClass, name, spec.FieldTypeID(), spec.IsPrimitive (), spec.IsArray(), spec.IsNArray()); } return new UnknownTypeHandlerAspect(containingClass, name); }