private IEnumerable GetItems(string[] strings, KeyValuePair <string, string> keyValuePair, Type targetType, Type itemType)
{
IValueRetriever retriever = null;
foreach (var splitValue in strings)
{
var itemKeyValuePair = new KeyValuePair <string, string>(keyValuePair.Key, splitValue.Trim());
retriever = retriever ?? GetValueRetriever(itemKeyValuePair, targetType, itemType);
yield return(retriever?.Retrieve(itemKeyValuePair, targetType, itemType));
}
}
private static Condition internal_buildCondition(string modifier1, Name v1, string modifier2, Name v2, ComparisonOperator op)
{
IValueRetriever value1 = ConvertToValueRetriever(modifier1, v1);
IValueRetriever value2 = ConvertToValueRetriever(modifier2, v2);
if (value1.Equals(value2))
{
throw new InvalidOperationException("Both given property names are intrinsically equal. Condition would always return a constant result.");
}
if (value1.InnerName.IsPrimitive && value2.InnerName.IsPrimitive && !value1.HasModifier && !value2.HasModifier)
{
throw new InvalidOperationException("Both given property names are primitive values. Expected at least one non-primitive value.");
}
if (op == ComparisonOperator.Equal)
{
//May be a definition
if (value1.InnerName.IsVariable && !value1.HasModifier)
{
return(new EqualityDefinitionCondition(v1, value2));
}
if (value2.InnerName.IsVariable && !value2.HasModifier)
{
return(new EqualityDefinitionCondition(v2, value1));
}
}
if (value1.InnerName.IsPrimitive != value2.InnerName.IsPrimitive)
{
IValueRetriever prop = value1.InnerName.IsPrimitive ? value2 : value1;
string str = (value1.InnerName.IsPrimitive ? value1.InnerName : value2.InnerName).ToString();
op = v1.IsPrimitive ? op.Mirror() : op;
bool boolValue;
if (bool.TryParse(str, out boolValue))
{
switch (op)
{
case ComparisonOperator.Equal:
return(new PredicateCondition(prop, boolValue));
case ComparisonOperator.NotEqual:
return(new PredicateCondition(prop, !boolValue));
}
}
return(new PrimitiveComparisonCondition(prop, (Name)str, op));
}
return(new PropertyComparisonCondition(value1, value2, op));
}
public PredicateCondition(IValueRetriever p, bool expectedResult)
{
m_predicate = p;
m_invert = !expectedResult;
}
public void UnregisterValueRetriever(IValueRetriever valueRetriever)
{
_registeredValueRetrievers.Remove(valueRetriever);
}
public void RegisterValueRetriever(IValueRetriever valueRetriever)
{
_registeredValueRetrievers.Add(valueRetriever);
}
public void UnregisterValueRetriever(IValueRetriever valueRetriever)
{
_registeredValueRetrievers.Remove(valueRetriever);
}
internal static bool CanRetrieve <TProperty>(this IValueRetriever retriever, string value)
{
return(retriever.CanRetrieve(value, typeof(TProperty)));
}
public void RegisterValueRetriever(IValueRetriever valueRetriever)
{
_registeredValueRetrievers.Add(valueRetriever);
}
internal static TProperty GetValue <TProperty>(this IValueRetriever retriever, string value)
{
return((TProperty)retriever.GetValue(value, typeof(TProperty)));
}
internal static object GetValue(this IValueRetriever retriever, string value, Type propertyType)
{
return(retriever.Retrieve(new KeyValuePair <string, string>("Value", value), typeof(object), propertyType));
}
public void UnregisterValueRetriever(IValueRetriever valueRetriever)
{
ValueRetrievers.Unregister(valueRetriever);
}
public void RegisterValueRetriever(IValueRetriever valueRetriever)
{
ValueRetrievers.Register(valueRetriever);
}
public EqualityDefinitionCondition(Name variable, IValueRetriever other)
{
m_variable = variable;
m_other = other;
}
public PrimitiveComparisonCondition(IValueRetriever prop, Name value, ComparisonOperator op)
{
m_retriver = prop;
m_value = value;
m_operation = op;
}
public PropertyComparisonCondition(IValueRetriever property1, IValueRetriever property2, ComparisonOperator op)
{
Property1 = property1;
Property2 = property2;
Operator = op;
}
