private void OnObjectDataAccessManagerAdded(ObjectDataAccessManager odam) { m_objectAccess.Add(odam.Id, odam); odam.LayerDataRemoved -= this.Odam_LayerDataRemoved; odam.LayerDataRemoved += this.Odam_LayerDataRemoved; odam.LayerDataSet -= this.Odam_LayerDataSet; odam.LayerDataSet += this.Odam_LayerDataSet; }
internal ObjectDataAccessManager EnsureDataAccess(Guid id) { if (!m_objectAccess.TryGetValue(id, out ObjectDataAccessManager accessManager)) { accessManager = new ObjectDataAccessManager(this, id); } return(accessManager); }
/// <summary> /// Directly set an object (indicated by id) property (indicated by property name) on the override layer (0-<see cref="OverrideLayerCount"/>) with the value specified. /// </summary> public bool SetOverridePropertyValue(int layer, Guid id, string property, object value) { if (!m_objectAccess.TryGetValue(id, out ObjectDataAccessManager accessManager)) { accessManager = new ObjectDataAccessManager(this, id); } return(accessManager.SetOverrideValue(layer, property, value)); }
private void SetBaselineData(ObjectEvaluation objectEvaluation) { ObjectDataAccessManager accessManager = EnsureDataAccess(objectEvaluation.Id); foreach (KeyValuePair <string, object> property in objectEvaluation.ValueStorage) { accessManager.SetBaselineValue(property.Key, property.Value); } //#error using it foreach (ObjectEvaluation ancillary in objectEvaluation.AncillaryElements) { this.SetBaselineData(ancillary); } foreach (KeyValuePair <string, ObjectEvaluation> childObject in objectEvaluation.ChildObjectStorage) { accessManager.SetBaselineValue(childObject.Key, childObject.Value.Id); this.SetBaselineData(childObject.Value); } foreach (KeyValuePair <string, ObjectEvaluation.ListInfo> listProp in objectEvaluation.InsertGenerationLists) { if ((listProp.Value.Elements?.Length ?? 0) == 0) { continue; } Type elementType = listProp.Value.ElementType ?? listProp.Value.Elements[0].GetType(); Type listAccessType = typeof(StrataPropertyListAccess <>).MakeGenericType(elementType); // In order to keep some kind of strong access of the method (for refactoring & compiling errors), using object // as a sort of unknown sinceit's just to get nameof. string methodName = nameof(StrataPropertyListAccess <object> .GenerateStorageForBaselineListAccess); object storage = ReflectionXT.RunStaticMethod(listAccessType, methodName, (object)(listProp.Value.Elements)); this.SetBaselinePropertyValue(objectEvaluation.Id, listProp.Key, storage); } }
private void OnObjectDataAccessManagerRemoved(ObjectDataAccessManager odam) { m_objectAccess.Remove(odam.Id); odam.LayerDataRemoved -= this.Odam_LayerDataRemoved; odam.LayerDataSet -= this.Odam_LayerDataSet; }
public void SetObjectWithProperties <T> (Guid objectId, T source) { Type sourceType = source.GetType(); PropertyInfo[] allSettableProperties = sourceType .GetProperties(BindingFlags.Public | BindingFlags.Instance | BindingFlags.SetProperty) .Where(p => !(p.GetAttributes <StrataIgnoreAttribute>().FirstOrDefault()?.WhenOutput ?? false)) .ToArray(); ObjectDataAccessManager odam = this.GetAccessManager(objectId); if (odam == null) { return; } foreach (PropertyInfo settableProperty in allSettableProperties) { if (odam.SearchForFirstOverrideLayerIndexSet(this.OverrideLayerCount - 1, settableProperty.Name, out int overrideLayerIndex)) { _SetPropWithStratum(settableProperty, objectId, m_overrideStorageLayers[overrideLayerIndex]); } else if (odam.HasBaselineValueSet(settableProperty.Name)) { _SetPropWithStratum(settableProperty, objectId, m_baselineStorageLayer); } } void _SetPropWithStratum(PropertyInfo _propToSet, Guid _objId, Stratum _layer) { if (_layer.TryGetValue(objectId, out PseudoPropertyBag storedPropBag) && storedPropBag.TryGetValue(_propToSet.Name, out object storedPropValue)) { // Go through this BONKERS process to determine if it's list access backed data and set it that way if (typeof(IEnumerable).IsAssignableFrom(_propToSet.PropertyType)) { // Is it ListAccess backed? Type propValueType = storedPropValue.GetType(); if (propValueType.IsGenericType && propValueType.GetGenericTypeDefinition() == typeof(ObservableCollectionX <>) && propValueType.GenericTypeArguments[0].IsGenericType && propValueType.GenericTypeArguments[0].GetGenericTypeDefinition() == typeof(StratabaseListInsertion <>)) { // Ok it is, now use reflection to generate a StrataPropertyListAccess Type itemType = propValueType.GenericTypeArguments[0].GenericTypeArguments[0]; var listAccess = (IDisposable)this.InvokeTemplatedMethod( nameof(GenerateListPropertyAccess), itemType, _objId, _propToSet.Name ); // If we succeeded in making a list access, then grab the cache and try to set the value if (listAccess != null) { IList elements = listAccess.GetComplexPropertyValue <IList>(nameof(StrataPropertyListAccess <int> .Elements)); if (elements != null) { // Here's the tricky bit, we either are setting an array - or - we're setting something we assume // activator.create instance can make for us, is an IList, which we can then add the items to. if (_propToSet.PropertyType.IsArray) { Array final = Array.CreateInstance(_propToSet.PropertyType.GenericTypeArguments[0], elements.Count); for (int index = 0; index < elements.Count; ++index) { final.SetValue(elements[index], index); } _propToSet.SetValue(source, final); } else if (typeof(IList).IsAssignableFrom(_propToSet.PropertyType)) { IList final = (IList)Activator.CreateInstance(_propToSet.PropertyType); foreach (object obj in elements) { final.Add(obj); } _propToSet.SetValue(source, final); } } // Don't forget to dispose of hte list access listAccess.Dispose(); return; } } } // Otherwise, try and see if the type is assignable, and assign it if it is if (_propToSet.PropertyType.IsAssignableFrom(storedPropValue.GetType())) { _propToSet.SetValue(source, storedPropValue); } } } }