/// <summary> /// Builds the properties for the labels's <see cref="ILabelModel"/> type. /// </summary> protected virtual void BuildModelProperties(IPropertyBuildContext <ILabel> context) { ValueGetterDelegate <Type> labelModelGetter = new ValueGetterDelegate <Type>( delegate { var type = context.CurrentInstance.LayoutParameter.Model.GetType(); while (!type.IsPublic) { type = type.BaseType; } return(type); }); ValueSetterDelegate <Type> labelModelSetter = new ValueSetterDelegate <Type>( delegate(Type value) { IGraph graph = context.Lookup(typeof(IGraph)) as IGraph; if (graph != null) { ILabelModel model = Activator.CreateInstance(value) as ILabelModel; if (model != null) { ILabelModelParameterFinder finder = model.Lookup(typeof(ILabelModelParameterFinder)) as ILabelModelParameterFinder; ILabelModelParameter parameter; ILabel subject = context.CurrentInstance; if (finder != null) { parameter = finder.FindBestParameter(subject, model, subject.GetLayout()); } else { parameter = model.CreateDefaultParameter(); } graph.SetLabelLayoutParameter(subject, parameter); } } }); ILabel currentLabel; currentLabel = context.CurrentInstance; if (currentLabel == null) { return; } if (currentLabel.Owner is IEdge) { context.AddEntry(EdgeLabelModelProperty, labelModelGetter, labelModelSetter, null); } if (currentLabel.Owner is INode) { context.AddEntry(NodeLabelModelProperty, labelModelGetter, labelModelSetter, null); } if (currentLabel.Owner is IPort) { context.AddEntry(PortLabelModelProperty, labelModelGetter, labelModelSetter, null); } }
/// <summary> /// Create and populate an instance of the cached type /// </summary> public object CreateInstance(byte[] key, ValueGetterDelegate valueGetter) { // Create an instance var instance = _ctor.Invoke(new object[] {}); // Deserialize key KeySetter(instance, key); // Chain return(PopulateInstance(key, valueGetter, instance)); }
internal static void AddNoteProperty <T>(PSObject pso, string propertyName, ValueGetterDelegate <T> valueGetter) { T local = default(T); try { local = valueGetter(); } catch (Exception exception) { CommandProcessorBase.CheckForSevereException(exception); PSEtwLog.LogAnalyticWarning(PSEventId.Serializer_PropertyGetterFailed, PSOpcode.Exception, PSTask.Serialization, PSKeyword.Serializer | PSKeyword.UseAlwaysAnalytic, new object[] { propertyName, (valueGetter.Target == null) ? string.Empty : valueGetter.Target.GetType().FullName, exception.ToString(), (exception.InnerException == null) ? string.Empty : exception.InnerException.ToString() }); } try { pso.Properties.Add(new PSNoteProperty(propertyName, local)); } catch (ExtendedTypeSystemException) { object obj1 = pso.Properties[propertyName].Value; } }
public IPropertyItem AddEntry <TValue>(string virtualPropertyName, ValueGetterDelegate <TValue> getter, ValueSetterDelegate <TValue> setter) { return(childContext.AddEntry(virtualPropertyName, getter, wrapper.decorate(setter))); }
public IPropertyItem AddEntry <TValue>(string virtualPropertyName, ValueGetterDelegate <TValue> getter, ValueSetterDelegate <TValue> setter, IEqualityComparer comparer) { return(context.AddEntry(virtualPropertyName, getter, decorate(setter), comparer)); }
/// <summary> /// Adds a given type and value getter function to the Value Getters /// </summary> /// <param name="type">The type to add the value getter function for</param> /// <param name="valueGetter">A value getter function</param> /// <returns>The <see cref="RendererSettingsBuilder"/> for chaining</returns> public RendererSettingsBuilder AddValueGetter(Type type, ValueGetterDelegate valueGetter) { ValueGetters.Add(type, valueGetter); return(this); }
/// <summary> /// Creates a new instance. /// </summary> /// <param name="getter">The getter to use.</param> public DelegateGetter(ValueGetterDelegate <T> getter) { this.getter = getter; }
/// <summary> /// Creates a new instance. /// </summary> /// <param name="getter">The getter to use.</param> /// <param name="predicate">The predicate to use.</param> public DelegateGetter(ValueGetterDelegate <T> getter, ValueGetterValidityPredicate predicate) { this.getter = getter; this.predicate = predicate; }
public IPropertyItem AddEntry <TValue>(string virtualPropertyName, ValueGetterDelegate <TValue> getter, ValueSetterDelegate <TValue> setter) { return(AddEntry(virtualPropertyName, new DelegateGetter <TValue>(getter), new DelegateSetter <TValue>(setter), null)); }
private static bool TryGetFromQueryString(IHttpRequest request, string paramName, ref T value, ValueGetterDelegate valueGetter) { if (request == null || string.IsNullOrEmpty(paramName) || string.IsNullOrEmpty(request.QueryString[paramName])) { return(false); } return(valueGetter(request.QueryString[paramName], out value)); }
public object PopulateInstance(byte[] key, ValueGetterDelegate valueGetter, object instance) { Dictionary <long, object> versions = new Dictionary <long, object>(); // Set families for (int index = 0; index < FieldNames.Length; index++) { var family = FamilyNames[index]; var field = FieldNames[index]; var values = valueGetter(family, field).ToArray(); if (!values.Any()) { continue; } // Default is most recent timestamp // Doc says even with an opposing retention policy // GC is background and opportunistic, therefore you may // received versions sometimes. var orderedValues = values.OrderByDescending(item => item.Timestamp); var cell = orderedValues.First(); // Find a serializer for this type var valueType = FieldTypes[field]; var serializer = GetSerializerForType(valueType); // Deserialize var actualValue = serializer.DeserializeField(valueType, cell.Value, TableEncoding); // Set the current field's value Setters[field](instance, actualValue); // Only BigField if (false && IsBigBoxed[field]) { // Need member var access = GetFieldAccess(MemberTypes[field]); // Store labels if (cell.Labels != null && cell.Labels.Any()) { var labels = access.LabelsGetter(instance); labels.AddRange(cell.Labels); } // Previous revisions var previousValues = orderedValues.Take(1); foreach (var value in previousValues) { // Collate versioned fields into a versioned object if (!versions.ContainsKey(value.Timestamp)) { versions.Add(value.Timestamp, _ctor.Invoke(new object[] { })); } // Get version for timestamp var version = versions[value.Timestamp]; // Set the current field's value Setters[field](version, value); // Field have labels? if (value.Labels != null && value.Labels.Any()) { var labels = access.LabelsGetter(version); labels.AddRange(value.Labels); } } } } if (versions.Any()) { // TODO: Store versions } return(instance); }