/// <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);
}
