internal bool AddLazyItems(ObjectId oid, ModelProperty property, IEnumerable <LazyValue> values, bool creating) { bool changed = false; GreenModelUpdateContext ctx = null; try { var slot = oid.Descriptor.GetSlot(property); do { ctx = this.BeginUpdate(); foreach (var value in values) { changed = ctx.Updater.AddItem(this.id, oid, slot, creating, false, -1, value); } } while (!this.EndUpdate(ctx)); } finally { this.FinalizeUpdate(ctx); } return(changed); }
public LazyEvalEntry(IModelObject symbol, ModelProperty property) { this.symbol = symbol; this.property = property; }
private void CreateProperties() { var allProperties = ArrayBuilder <ModelProperty> .GetInstance(); var properties = ArrayBuilder <ModelProperty> .GetInstance(); try { foreach (var baseDescriptor in this.AllBaseDescriptors.Reverse()) { foreach (var prop in baseDescriptor.allProperties) { if (!allProperties.Contains(prop)) { allProperties.Add(prop); if (prop.IsName) { this.nameProperty = prop; } if (prop.IsType) { this.typeProperty = prop; } } } } allProperties.AddRange(this.declaredProperties); foreach (var prop in this.declaredProperties) { if (prop.IsName) { this.nameProperty = prop; } if (prop.IsType) { this.typeProperty = prop; } } foreach (var prop in allProperties) { int nameIndex = properties.FindIndex(p => p.Name == prop.Name); if (nameIndex >= 0) { properties.RemoveAt(nameIndex); } foreach (var redefProp in prop.RedefinedProperties) { int index = properties.IndexOf(redefProp); if (index >= 0) { properties.RemoveAt(index); } } properties.Add(prop); } } finally { ImmutableInterlocked.InterlockedExchange(ref this.allProperties, allProperties.ToImmutableAndFree()); ImmutableInterlocked.InterlockedExchange(ref this.properties, properties.ToImmutableAndFree()); } }
public void MAttachProperty(ModelProperty property) { this.model.MAttachProperty(this.id, property); }
protected void SetLazyReference <TImmutableContext, TMutableContext, TImmutable, TMutable>(ModelProperty property, Func <TImmutableContext, IEnumerable <TImmutable> > immutableValue, Func <TMutableContext, IEnumerable <TMutable> > mutableValue) where TImmutableContext : ImmutableObject where TMutableContext : MutableObject where TImmutable : class where TMutable : class { this.model.SetLazyValue(this.id, property, LazyValue.CreateMulti(immutableValue, mutableValue), this.creating); }
public bool MHasDefaultValue(ModelProperty property) { return(this.model.MHasDefaultValue(this.id, property)); }
public T MGetValue <T>(ModelProperty property) where T : struct { T dummy = default; return(this.GetValue <T>(property, ref dummy)); }
protected void SetLazyValue <TContext, T>(ModelProperty property, Func <TContext, T> value) where TContext : IModelObject where T : struct { this.model.SetLazyValue(this.id, property, LazyValue.Create(value), this.creating); }
protected void SetLazyValue <TImmutableContext, TMutableContext, TImmutable, TMutable>(ModelProperty property, Func <TImmutableContext, TImmutable> immutableValue, Func <TMutableContext, TMutable> mutableValue) where TImmutableContext : ImmutableObject where TMutableContext : MutableObject where TImmutable : struct where TMutable : struct { this.model.SetLazyValue(this.id, property, LazyValue.Create(immutableValue, mutableValue), this.creating); }
protected T GetReference <T>(ModelProperty property) where T : class { return((T)this.model.GetValue(this.id, property)); }
protected Func <T> GetLazyValue <T>(ModelProperty property) where T : struct { return((Func <T>)(object) this.model.GetLazyValue(this.id, property)); }
protected void SetValue <T>(ModelProperty property, T value) where T : struct { this.model.SetValue(this.id, property, value, this.creating); }
public T MGetReference <T>(ModelProperty property) where T : class { return(this.GetReference <T>(property)); }
public T MGetValue <T>(ModelProperty property) where T : struct { return(this.GetValue <T>(property)); }
public object MGet(ModelProperty property) { return(this.model.MGet(this.id, property)); }
protected Func <T> GetLazyReference <T>(ModelProperty property) where T : class { return((Func <T>) this.model.GetLazyValue(this.id, property)); }
public bool MIsSet(ModelProperty property) { return(this.model.MIsSet(this.id, property)); }
protected void SetLazyReference <T>(ModelProperty property, Func <T> value) where T : class { this.model.SetLazyValue(this.id, property, LazyValue.Create(value), this.creating); }
public bool MHasConcreteValue(ModelProperty property) { return(this.model.MHasConcreteValue(this.id, property)); }
protected void SetLazyReference <TContext, T>(ModelProperty property, Func <TContext, IEnumerable <T> > value) where TContext : IModelObject where T : class { this.model.SetLazyValue(this.id, property, LazyValue.CreateMulti(value), this.creating); }
public T MGetReference <T>(ModelProperty property) where T : class { T dummy = null; return(this.GetReference <T>(property, ref dummy)); }
public void Initialize() { if (this.state == ModelPropertyInitState.Initialized) { return; } lock (ModelProperty.lockObject) { if (this.state == ModelPropertyInitState.Initialized) { return; } if (this.state == ModelPropertyInitState.None) { this.InitializeFlags(); } var subsettedPropertiesBuilder = ArrayBuilder <ModelProperty> .GetInstance(); var redefinedPropertiesBuilder = ArrayBuilder <ModelProperty> .GetInstance(); var oppositePropertiesBuilder = ArrayBuilder <ModelProperty> .GetInstance(); foreach (var annot in this.annotations) { if (annot is SubsetsAttribute) { SubsetsAttribute propAnnot = (SubsetsAttribute)annot; ModelObjectDescriptor descriptor = ModelObjectDescriptor.GetDescriptorForDescriptorType(propAnnot.DeclaringType); ModelProperty prop = descriptor.GetDeclaredProperty(propAnnot.PropertyName); if (prop == null) { throw new InvalidOperationException("Error subsetting property: " + this.FullDeclaredName + "->" + prop.FullDeclaredName + ". The subsetted property cannot be found."); } if ((descriptor == this.declaringDescriptor || this.declaringDescriptor.AllBaseDescriptors.Contains(descriptor))) { if (!this.IsUnique) { throw new InvalidOperationException("Error subsetting property: " + this.FullDeclaredName + "->" + prop.FullDeclaredName + ". The subsetting property must be a collection of unique values."); } if (!prop.IsUnique) { throw new InvalidOperationException("Error subsetting property: " + this.FullDeclaredName + "->" + prop.FullDeclaredName + ". The subsetted property must be a collection of unique values."); } subsettedPropertiesBuilder.Add(prop); } else { throw new InvalidOperationException("Error subsetting property: " + this.FullDeclaredName + "->" + prop.FullDeclaredName + ". The subsetted property must come from the current type or from a base type."); } } else if (annot is RedefinesAttribute) { RedefinesAttribute propAnnot = (RedefinesAttribute)annot; ModelObjectDescriptor descriptor = ModelObjectDescriptor.GetDescriptorForDescriptorType(propAnnot.DeclaringType); ModelProperty prop = descriptor.GetDeclaredProperty(propAnnot.PropertyName); if (prop == null) { throw new InvalidOperationException("Error redefining property: " + this.FullDeclaredName + "->" + prop.FullDeclaredName + ". The redefined property cannot be found."); } if ((descriptor == this.declaringDescriptor || this.declaringDescriptor.AllBaseDescriptors != null && this.declaringDescriptor.AllBaseDescriptors.Contains(descriptor))) { if (this.IsContainment && !prop.IsContainment) { throw new InvalidOperationException("Error redefining property: " + this.FullDeclaredName + "->" + prop.FullDeclaredName + ". The redefining property cannot be a containment if the redefined property is not a containment."); } redefinedPropertiesBuilder.Add(prop); } else { throw new InvalidOperationException("Error redefining property: " + this.FullDeclaredName + "->" + prop.FullDeclaredName + ". The redefined property must come from the current type or from a base type."); } } else if (annot is OppositeAttribute) { OppositeAttribute propAnnot = (OppositeAttribute)annot; ModelObjectDescriptor descriptor = ModelObjectDescriptor.GetDescriptorForDescriptorType(propAnnot.DeclaringType); ModelProperty prop = descriptor.GetDeclaredProperty(propAnnot.PropertyName); if (prop == null) { throw new InvalidOperationException("Error in setting opposite property: " + this.FullDeclaredName + "->" + propAnnot.DeclaringType + "." + propAnnot.PropertyName + ". The opposite property cannot be found."); } bool foundThisProperty = false; foreach (var oppositeAnnot in prop.annotations) { if (oppositeAnnot is OppositeAttribute) { OppositeAttribute propOppositeAnnot = (OppositeAttribute)oppositeAnnot; if (propOppositeAnnot.DeclaringType == this.declaringDescriptor.DescriptorType && propOppositeAnnot.PropertyName == this.name) { foundThisProperty = true; break; } } } if (foundThisProperty) { oppositePropertiesBuilder.Add(prop); } else { throw new InvalidOperationException("Error in setting opposite property: " + this.FullDeclaredName + "->" + prop.FullDeclaredName + ". Opposite properties must be mutual."); } } else if (annot is DerivedUnionAttribute) { if (!this.IsUnique) { throw new InvalidOperationException("Error in property: " + this.FullDeclaredName + ". A derived union property must be contain unique values."); } this.flags |= ModelPropertyFlags.DerivedUnion | ModelPropertyFlags.Readonly; } } subsettedProperties = subsettedPropertiesBuilder.ToImmutableAndFree(); redefinedProperties = redefinedPropertiesBuilder.ToImmutableAndFree(); oppositeProperties = oppositePropertiesBuilder.ToImmutableAndFree(); this.state = ModelPropertyInitState.Initialized; } }