private static void ValidateExistsOperator(FilterTerm.Operator op)
{
if (op != FilterTerm.Operator.Exists && op != FilterTerm.Operator.NotExists)
{
throw new InvalidOperationException(string.Format("You can only apply {0} or {1} operators to numbers having no value", FilterTerm.Operator.Exists, FilterTerm.Operator.NotExists));
}
}
/// <summary>
/// Adds comparison term. Only specified Operators supported:
/// <ul>
/// <li>GreaterThan</li>
/// <li>GreaterThanOrEqual</li>
/// <li>LessThan</li>
/// <li>LessThanOrEqual</li>
/// <li>Equal</li>
/// </ul>
/// </summary>
/// <param name="op">Operator to apply.</param>
/// <param name="date">Value to compare with.</param>
public override void AddTerm(FilterTerm.Operator op, DateTime date)
{
DateTime roundedDate = new DateTime(date.Year, date.Month, date.Day, date.Hour, date.Minute, date.Second);
switch (op)
{
case FilterTerm.Operator.GreaterThan:
base.AddTerm(FilterTerm.Operator.GreaterThanOrEqual, roundedDate.AddSeconds(1));
break;
case FilterTerm.Operator.GreaterThanOrEqual:
base.AddTerm(FilterTerm.Operator.GreaterThanOrEqual, roundedDate);
break;
case FilterTerm.Operator.LessThan:
base.AddTerm(FilterTerm.Operator.LessThan, roundedDate);
break;
case FilterTerm.Operator.LessThanOrEqual:
base.AddTerm(FilterTerm.Operator.LessThan, roundedDate.AddSeconds(1));
break;
case FilterTerm.Operator.Equal:
base.AddTerm(FilterTerm.Operator.GreaterThanOrEqual, roundedDate);
base.AddTerm(FilterTerm.Operator.LessThan, roundedDate.AddSeconds(1));
break;
default:
throw new NotSupportedException("This operation is not supported: " + op);
}
}
/// <summary>
/// Add new filtering term. Supplied terms are AND'ed.
/// </summary>
/// <param name="op">Filtering operator. In case of null value it can only be either Exists or NotExists.</param>
/// <param name="value">Value to compare with.</param>
public void AddTerm(FilterTerm.Operator op, double?value = null)
{
if (value.HasValue)
{
searcher.AddTerm(op, value.Value);
return;
}
ValidateExistsOperator(op);
existsOperator = op;
}
public void Comparison <T>(string name, FilterTerm.Operator @operator, T value)
{
var term = Root.Term(Resolve(name));
switch (@operator)
{
case FilterTerm.Operator.Exists:
term.Exists();
break;
case FilterTerm.Operator.NotExists:
term.NotExists();
break;
default:
term.Operate(@operator, value);
break;
}
}
/// <summary>
/// Add new filtering term.
/// </summary>
/// <param name="op">Filtering operator.</param>
/// <param name="value">Value to compare with.</param>
public virtual void AddTerm(FilterTerm.Operator op, T value)
{
T old;
var operatorNotExists = !terms.TryGetValue(op, out old);
switch (op)
{
case FilterTerm.Operator.Exists:
if (terms.ContainsKey(FilterTerm.Operator.NotExists))
{
throw new InvalidOperationException("Cannot contain both " + op + " and " + FilterTerm.Operator.NotExists + " terms.");
}
if (operatorNotExists)
{
terms.Add(op, value);
}
break;
case FilterTerm.Operator.NotExists:
if (terms.ContainsKey(FilterTerm.Operator.Exists))
{
throw new InvalidOperationException("Cannot contain both " + op + " and " + FilterTerm.Operator.Exists + " terms.");
}
if (operatorNotExists)
{
terms.Add(op, value);
}
break;
case FilterTerm.Operator.Equal:
case FilterTerm.Operator.NotEqual:
if (operatorNotExists)
{
terms.Add(op, value);
}
else
{
throw new InvalidOperationException("Cannot contain more than one " + op + " term.");
}
break;
case FilterTerm.Operator.GreaterThan:
case FilterTerm.Operator.GreaterThanOrEqual:
if (operatorNotExists)
{
terms.Add(op, value);
}
else if (old.CompareTo(value) < 0)
{
// new > old
terms[op] = value;
}
break;
case FilterTerm.Operator.LessThan:
case FilterTerm.Operator.LessThanOrEqual:
if (operatorNotExists)
{
terms.Add(op, value);
}
else if (old.CompareTo(value) > 0)
{
// new < old
terms[op] = value;
}
break;
}
}
/// <summary>
/// Clear internal term collection.
/// </summary>
public void Clear()
{
searcher.Terms.Clear();
existsOperator = FilterTerm.Operator.None;
}
public static Tuple <string, object, FilterTerm.Operator> Get(string field,
object value, FilterTerm.Operator oper = FilterTerm.Operator.Equal)
{
return(new Tuple <string, object, FilterTerm.Operator>(field, value, oper));
}
