public void Update(TimeSpan frameTime)
{
List <object> toRemove = new List <object>();
foreach (KeyValuePair <ValueAccess, Dictionary <object, ValueChangeRequest> > buffer in
FieldChangeBuffer.BufferedChanges)
{
ValueAccess access = buffer.Key;
foreach (KeyValuePair <object, ValueChangeRequest> instanceBuffer in buffer.Value)
{
object instance = instanceBuffer.Key;
if (CheckShouldRemove(access, instance, instanceBuffer.Value))
{
toRemove.Add(instanceBuffer.Key);
}
else if (!instanceBuffer.Value.RequestProcessed)
{
access.GetHandler(instance)?.Invoke(instanceBuffer.Value.RequestedValue);
instanceBuffer.Value.RequestProcessed = true;
}
}
toRemove.ForEach(o => buffer.Value.Remove(o));
toRemove.Clear();
}
m_RailClient.Update();
}
private bool CheckShouldRemove(
ValueAccess access,
object instance,
ValueChangeRequest buffer)
{
if (buffer.RequestProcessed && Equals(buffer.RequestedValue, buffer.LatestActualValue))
{
return(true);
}
object currentValue = access.Get(instance);
if (Equals(currentValue, buffer.LatestActualValue))
{
return(false);
}
if (buffer.RequestProcessed)
{
return(true);
}
buffer.LatestActualValue = currentValue;
return(false);
}
public void RaiseRelationReadEvent(
DomainObject domainObject,
IRelationEndPointDefinition relationEndPointDefinition,
ReadOnlyDomainObjectCollectionAdapter <DomainObject> relatedObjects,
ValueAccess valueAccess)
{
}
internal void AddOutputValue(ValueAccess valueAccess)
{
_elements.Add(new OutputValueTemplateElement
{
ValueAccess = valueAccess
});
}
public virtual void RelationReading(
ClientTransaction clientTransaction,
DomainObject domainObject,
IRelationEndPointDefinition relationEndPointDefinition,
ValueAccess valueAccess)
{
}
public virtual void RelationRead(
ClientTransaction clientTransaction,
DomainObject domainObject,
IRelationEndPointDefinition relationEndPointDefinition,
ReadOnlyDomainObjectCollectionAdapter <DomainObject> relatedObjects,
ValueAccess valueAccess)
{
}
public virtual void RelationRead(
ClientTransaction clientTransaction,
DomainObject domainObject,
IRelationEndPointDefinition relationEndPointDefinition,
DomainObject relatedObject,
ValueAccess valueAccess)
{
// Handled by Begin event
}
/// <summary>
/// Initializes a new instance of the <see cref="ValueAccessComparisonValidator"/> class.
/// </summary>
/// <param name="valueAccess">The <see cref="ValueAccess"/> to use when extracting the comparison operand.</param>
/// <param name="comparisonOperator">The <see cref="ComparisonOperator"/> that specifies the kind of
/// comparison to perform.</param>
/// <param name="messageTemplate">The message template to use when logging validation failures.</param>
/// <param name="negated">Indicates if the validation logic represented by the validator should be negated.</param>
public ValueAccessComparisonValidator(ValueAccess valueAccess,
ComparisonOperator comparisonOperator,
string messageTemplate,
bool negated)
: this(valueAccess, comparisonOperator, messageTemplate, null, negated)
{
this.valueAccess = valueAccess;
this.comparisonOperator = comparisonOperator;
}
/// <summary>
/// Initializes a new instance of the <see cref="ValueAccessComparisonValidator"/> class.
/// </summary>
/// <param name="valueAccess">The <see cref="ValueAccess"/> to use when extracting the comparison operand.</param>
/// <param name="comparisonOperator">The <see cref="ComparisonOperator"/> that specifies the kind of
/// comparison to perform.</param>
/// <param name="messageTemplate">The message template to use when logging validation failures.</param>
/// <param name="tag">The tag that describes the purpose of the validator.</param>
public ValueAccessComparisonValidator(ValueAccess valueAccess,
ComparisonOperator comparisonOperator,
string messageTemplate,
string tag)
: this(valueAccess, comparisonOperator, messageTemplate, tag, false)
{
this.valueAccess = valueAccess;
this.comparisonOperator = comparisonOperator;
}
public ValueAccessComparisonValidator(ValueAccess valueAccess, ComparisonOperator comparisonOperator, string messageTemplate, string tag, bool negated) : base(messageTemplate, tag, negated)
{
if (valueAccess == null)
{
throw new ArgumentNullException("valueAccess");
}
this.valueAccess = valueAccess;
this.comparisonOperator = comparisonOperator;
}
/// <summary>
/// Initializes a new instance of the <see cref="ValueAccessComparisonValidator"/> class.
/// </summary>
/// <param name="valueAccess">The <see cref="ValueAccess"/> to use when extracting the comparison operand.</param>
/// <param name="comparisonOperator">The <see cref="ComparisonOperator"/> that specifies the kind of
/// comparison to perform.</param>
/// <param name="messageTemplate">The message template to use when logging validation failures.</param>
/// <param name="negated">Indicates if the validation logic represented by the validator should be negated.</param>
public ValueAccessComparisonValidator(ValueAccess valueAccess,
ComparisonOperator comparisonOperator,
string messageTemplate,
bool negated)
: this(valueAccess, comparisonOperator, messageTemplate, null, negated)
{
this.valueAccess = valueAccess;
this.comparisonOperator = comparisonOperator;
}
public object GetValueWithoutEvents(PropertyDefinition propertyDefinition, ValueAccess valueAccess = ValueAccess.Current)
{
ArgumentUtility.CheckNotNull("propertyDefinition", propertyDefinition);
CheckNotDiscarded();
var propertyValue = GetPropertyValue(propertyDefinition);
return(GetValueWithoutEvents(propertyValue, valueAccess));
}
/// <summary>
/// Initializes a new instance of the <see cref="ValueAccessComparisonValidator"/> class.
/// </summary>
/// <param name="valueAccess">The <see cref="ValueAccess"/> to use when extracting the comparison operand.</param>
/// <param name="comparisonOperator">The <see cref="ComparisonOperator"/> that specifies the kind of
/// comparison to perform.</param>
/// <param name="messageTemplate">The message template to use when logging validation failures.</param>
/// <param name="tag">The tag that describes the purpose of the validator.</param>
public ValueAccessComparisonValidator(ValueAccess valueAccess,
ComparisonOperator comparisonOperator,
string messageTemplate,
string tag)
: this(valueAccess, comparisonOperator, messageTemplate, tag, false)
{
this.valueAccess = valueAccess;
this.comparisonOperator = comparisonOperator;
}
private object GetValueWithoutEvents(PropertyValue propertyValue, ValueAccess valueAccess)
{
if (valueAccess == ValueAccess.Current)
{
return(propertyValue.Value);
}
else
{
return(propertyValue.OriginalValue);
}
}
/// <summary>
/// <para>Initializes a new instance of the <see cref="ValueAccessValidator"/> class with an upper bound constraint.</para>
/// </summary>
/// <param name="valueAccess">The <see cref="ValueAccess"/> to use when extracting values from the
/// validated objects.</param>
/// <param name="valueValidator">The <see cref="Validator"/> to use when validating the values extracted
/// from the validated objects.</param>
/// <exception cref="ArgumentNullException">when <paramref name="valueAccess"/> is <see langword="null"/>.</exception>
/// <exception cref="ArgumentNullException">when <paramref name="valueValidator"/> is <see langword="null"/>.</exception>
public ValueAccessValidator(ValueAccess valueAccess, Validator valueValidator)
: base(null, null)
{
if (null == valueAccess)
throw new ArgumentNullException("valueAccess");
if (null == valueValidator)
throw new ArgumentNullException("valueValidator");
this.valueAccess = valueAccess;
this.valueValidator = valueValidator;
}
internal void Append(ValueAccess valueAccess)
{
if (Next == null)
{
Next = valueAccess;
}
else
{
Next.Append(valueAccess);
}
}
public void Parse_return_OutputValueTemplateElement_for_property_in_template()
{
TemplateModel templateModel = _parser.Parse("{{ Name }}");
TemplateElement[] elements = templateModel.Elements.ToArray();
Assert.AreEqual(1, elements.Length);
var element = (OutputValueTemplateElement)elements[0];
ValueAccess valueAccess = element.ValueAccess;
Assert.AreEqual("Name", valueAccess.Name);
}
public override void RelationReading(
ClientTransaction clientTransaction,
DomainObject domainObject,
IRelationEndPointDefinition relationEndPointDefinition,
ValueAccess valueAccess)
{
ArgumentUtility.CheckNotNull("clientTransaction", clientTransaction);
ArgumentUtility.CheckNotNull("domainObject", domainObject);
ArgumentUtility.CheckNotNull("relationEndPointDefinition", relationEndPointDefinition);
PropertyReading(clientTransaction, domainObject, relationEndPointDefinition.PropertyInfo);
}
public ValueAccessValidator(ValueAccess valueAccess, Validator valueValidator) : base(null, null)
{
if (valueAccess == null)
{
throw new ArgumentNullException("valueAccess");
}
if (valueValidator == null)
{
throw new ArgumentNullException("valueValidator");
}
this.valueAccess = valueAccess;
this.valueValidator = valueValidator;
}
//TODO move to TemplateEvaluator
internal object GetValue(ValueAccess valueAccess)
{
ValueAccess currentValueAccess = valueAccess;
object value = _source;
do
{
value = value.GetType().GetProperty(currentValueAccess.Name).GetValue(value);
currentValueAccess = currentValueAccess.Next;
} while (currentValueAccess != null);
return(value);
}
public void RaiseRelationReadEvent(
DomainObject domainObject,
IRelationEndPointDefinition relationEndPointDefinition,
ReadOnlyDomainObjectCollectionAdapter <DomainObject> relatedObjects,
ValueAccess valueAccess)
{
ArgumentUtility.CheckNotNull("domainObject", domainObject);
ArgumentUtility.CheckNotNull("relationEndPointDefinition", relationEndPointDefinition);
ArgumentUtility.CheckNotNull("relatedObjects", relatedObjects);
_extensionCollection.RelationRead(_clientTransaction, domainObject, relationEndPointDefinition, relatedObjects, valueAccess);
_listenerCollection.RelationRead(_clientTransaction, domainObject, relationEndPointDefinition, relatedObjects, valueAccess);
}
public object GetValue(PropertyDefinition propertyDefinition, ValueAccess valueAccess = ValueAccess.Current)
{
ArgumentUtility.CheckNotNull("propertyDefinition", propertyDefinition);
CheckNotDiscarded();
var propertyValue = GetPropertyValue(propertyDefinition);
RaisePropertyValueReadingNotification(propertyDefinition, valueAccess);
object value = GetValueWithoutEvents(propertyValue, valueAccess);
RaisePropertyValueReadNotification(propertyDefinition, value, valueAccess);
return(value);
}
/// <summary>
/// Initializes a new instance of the <see cref="ValueAccessComparisonValidator"/> class.
/// </summary>
/// <param name="valueAccess">The <see cref="ValueAccess"/> to use when extracting the comparison operand.</param>
/// <param name="comparisonOperator">The <see cref="ComparisonOperator"/> that specifies the kind of
/// comparison to perform.</param>
/// <param name="messageTemplate">The message template to use when logging validation failures.</param>
/// <param name="tag">The tag that describes the purpose of the validator.</param>
/// <param name="negated">Indicates if the validation logic represented by the validator should be negated.</param>
public ValueAccessComparisonValidator(ValueAccess valueAccess,
ComparisonOperator comparisonOperator,
string messageTemplate,
string tag,
bool negated)
: base(messageTemplate, tag, negated)
{
if (valueAccess == null)
{
throw new ArgumentNullException("valueAccess");
}
this.valueAccess = valueAccess;
this.comparisonOperator = comparisonOperator;
}
public void RelationReading(
ClientTransaction clientTransaction,
DomainObject domainObject,
IRelationEndPointDefinition relationEndPointDefinition,
ValueAccess valueAccess)
{
if (s_log.IsDebugEnabled())
{
s_log.DebugFormat(
"{0} RelationReading: {1} ({2}, {3})",
clientTransaction.ID,
relationEndPointDefinition.PropertyName,
valueAccess,
GetDomainObjectString(domainObject));
}
}
public void Parse_return_OutputValueTemplateElement_for_property_dot_property()
{
TemplateModel templateModel = _parser.Parse("{{ Model.Name }}");
TemplateElement[] elements = templateModel.Elements.ToArray();
Assert.AreEqual(1, elements.Length);
var element = (OutputValueTemplateElement)elements[0];
ValueAccess modelValueAccess = element.ValueAccess;
Assert.AreEqual("Model", modelValueAccess.Name);
ValueAccess nameValueAccess = modelValueAccess.Next;
Assert.AreEqual("Name", nameValueAccess.Name);
Assert.IsNull(nameValueAccess.Next);
}
public void Parse_return_TextTemplateElement_and_OutputValueTemplateElement()
{
TemplateModel templateModel = _parser.Parse("text{{ Count }}");
TemplateElement[] elements = templateModel.Elements.ToArray();
Assert.AreEqual(2, elements.Length);
var textTemplateElement = (TextTemplateElement)elements[0];
Assert.AreEqual("text", textTemplateElement.Text);
var outputValueTemplateElement = (OutputValueTemplateElement)elements[1];
ValueAccess valueAccess = outputValueTemplateElement.ValueAccess;
Assert.AreEqual("Count", valueAccess.Name);
Assert.IsNull(valueAccess.Next);
}
public void Parse_return_ConditionTemplateElement_for_property_dot_property()
{
TemplateModel templateModel = _parser.Parse("{{ #if Model.Flag }}{{ /if }}");
TemplateElement[] elements = templateModel.Elements.ToArray();
Assert.AreEqual(1, elements.Length);
var conditionTemplateElement = (ConditionTemplateElement)elements[0];
ValueAccess modelValueAccess = conditionTemplateElement.ValueAccess;
Assert.AreEqual("Model", modelValueAccess.Name);
ValueAccess flagValueAccessNext = modelValueAccess.Next;
Assert.AreEqual("Flag", flagValueAccessNext.Name);
Assert.IsNull(flagValueAccessNext.Next);
}
public void RelationRead(
ClientTransaction clientTransaction,
DomainObject domainObject,
IRelationEndPointDefinition relationEndPointDefinition,
ReadOnlyDomainObjectCollectionAdapter <DomainObject> relatedObjects,
ValueAccess valueAccess)
{
if (s_log.IsDebugEnabled())
{
var domainObjectsString = relatedObjects.IsDataComplete ? GetDomainObjectsString(relatedObjects) : "<data not loaded>";
s_log.DebugFormat(
"{0} RelationRead: {1} ({2}, {3}): {4}",
clientTransaction.ID,
relationEndPointDefinition.PropertyName,
valueAccess,
domainObject.ID,
domainObjectsString);
}
}
public void Parse_return_OutputValueTemplateElement_for_property_dot_property_dot_property()
{
TemplateModel templateModel = _parser.Parse("{{ First.Second.Third }}");
TemplateElement[] elements = templateModel.Elements.ToArray();
Assert.AreEqual(1, elements.Length);
var element = (OutputValueTemplateElement)elements[0];
ValueAccess firstValueAccess = element.ValueAccess;
Assert.AreEqual("First", firstValueAccess.Name);
ValueAccess secondValueAccess = firstValueAccess.Next;
Assert.AreEqual("Second", secondValueAccess.Name);
ValueAccess thirdValueAccess = secondValueAccess.Next;
Assert.AreEqual("Third", thirdValueAccess.Name);
Assert.IsNull(thirdValueAccess.Next);
}
/// <summary>
/// Initializes a new instance of the <see cref="ValueAccessComparisonValidator"/> class.
/// </summary>
/// <param name="valueAccess">The <see cref="ValueAccess"/> to use when extracting the comparison operand.</param>
/// <param name="comparisonOperator">The <see cref="ComparisonOperator"/> that specifies the kind of
/// comparison to perform.</param>
public ValueAccessComparisonValidator(ValueAccess valueAccess, ComparisonOperator comparisonOperator)
: this(valueAccess, comparisonOperator, null, null)
{ }
/// <summary>
/// <para>Initializes a new instance of the <see cref="MemberAccessValidator{T}"/> class.</para>
/// </summary>
/// <param name="valueAccess">The <see cref="ValueAccess"/> to use when accessing the
/// value of the validated member.</param>
/// <param name="valueValidator">The <see cref="Validator"/> to validate the value of the
/// validated member.</param>
protected MemberAccessValidator(ValueAccess valueAccess, Validator valueValidator)
: base(null, null)
{
this.valueAccessValidator = new ValueAccessValidator(valueAccess, valueValidator);
Validator = valueValidator;
}
/// <summary>
/// Initializes a new instance of the <see cref="PropertyComparisonValidator"/> class.
/// </summary>
/// <param name="valueAccess">The <see cref="ValueAccess"/> to use to extract the value to compare.</param>
/// <param name="comparisonOperator">The <see cref="ComparisonOperator"/> representing the kind of comparison to perform.</param>
/// <param name="negated">Indicates if the validation logic represented by the validator should be negated.</param>
public PropertyComparisonValidator(ValueAccess valueAccess, ComparisonOperator comparisonOperator, bool negated)
: base(valueAccess, comparisonOperator, null, negated)
{ }
/// <summary>
/// Initializes a new instance of the <see cref="PropertyComparisonValidator"/> class.
/// </summary>
/// <param name="valueAccess">The <see cref="ValueAccess"/> to use to extract the value to compare.</param>
/// <param name="comparisonOperator">The <see cref="ComparisonOperator"/> representing the kind of comparison to perform.</param>
public PropertyComparisonValidator(ValueAccess valueAccess, ComparisonOperator comparisonOperator)
: base(valueAccess, comparisonOperator)
{ }
public void RelationRead(ClientTransaction clientTransaction, DomainObject domainObject, IRelationEndPointDefinition relationEndPointDefinition, DomainObject relatedObject, ValueAccess valueAccess)
{
throw CreateException();
}
public void PropertyValueRead(ClientTransaction clientTransaction, DomainObject domainObject, PropertyDefinition propertyDefinition, object value, ValueAccess valueAccess)
{
throw CreateException();
}
protected MemberAccessValidator(ValueAccess valueAccess, Validator valueValidator)
: base((string)null, (string)null)
{
this.valueAccessValidator = new ValueAccessValidator(valueAccess, valueValidator);
}
public PropertyComparisonValidator(ValueAccess valueAccess, ComparisonOperator comparisonOperator) : base(valueAccess, comparisonOperator)
{
}
