public Compare(CompareType type, CompareOption option, string fieldName, params object[] compareValues)
{
this.Type = type;
this.Field = fieldName;
this.CompareValues = compareValues;
this.Option = option;
}
public Compare(CompareType type, CompareOption option, string fieldName, params object[] compareValues)
{
this.Type = type;
this.Field = fieldName;
this.CompareValues = compareValues;
this.Option = option;
}
public Compare(CompareType type, string fieldName, params object[] compareValues)
{
this.Type = type;
this.Field = fieldName;
this.CompareValues = compareValues;
this.Option = CompareOption.IgnoreEmptyString | CompareOption.ConvertDateTime;
}
public Compare(CompareType type, string fieldName, params object[] compareValues)
{
this.Type = type;
this.Field = fieldName;
this.CompareValues = compareValues;
this.Option = CompareOption.IgnoreEmptyString | CompareOption.ConvertDateTime;
}
/// <summary>
/// �õ��ֶαȽϵ�SQL���
/// </summary>
/// <param name="compare"></param>
/// <returns></returns>
public static string CompareOptionToString(CompareOption compare)
{
switch (compare)
{
case CompareOption.IsEqual:
return "=";
case CompareOption.IsMoreThan:
return ">";
case CompareOption.IsLessThan:
return "<";
case CompareOption.IsMoreThanOrEqual:
return ">=";
case CompareOption.IsLessThanOrEqual:
return "<=";
case CompareOption.IsNotEqual:
return "<>";
case CompareOption.IsSimilarThan:
return "like";
case CompareOption.IsNotSimilarThan:
return "not like";
}
return "";
}
public Option(CoreLib core)
{
this._core = core;
SearchOptions = new SearchOption();
CompareOptions = new CompareOption();
}
public static LPUnaryCompareOperator Create(CompareOption option, LPUser operand1)
{
var lpuco = new LPUnaryCompareOperator
{
Option = option
};
lpuco.operand.Add(operand1);
return(lpuco);
}
public Compare(string fieldName, params object[] compareValues)
{
this.Field = fieldName;
this.CompareValues = compareValues;
if (compareValues.Length > 2)
Type = CompareType.In;
else if (compareValues.Length == 2)
Type = CompareType.Between;
else
Type = CompareType.Equals;
this.Option = CompareOption.IgnoreEmptyString | CompareOption.ConvertDateTime;
}
public static LPBinaryCompareOperator Create(CompareOption option, LPUser operand1, LPUser operand2)
{
var lpbco = new LPBinaryCompareOperator
{
Option = option,
Type = operand1.Type
};
lpbco.operand.Add(operand1);
lpbco.operand.Add(operand2);
return(lpbco);
}
public static bool AllCompare(float[] lhs, float[] rhs, CompareOption comparison, out CompareResult compareResult)
{
compareResult = CompareResult.Equal;
if (ReferenceEquals(lhs, null) || ReferenceEquals(rhs, null)) return false;
if (lhs.Length != rhs.Length) return false;
bool allowLessThan = (comparison & CompareOption.LessThan) == CompareOption.LessThan;
bool allowEqual = (comparison & CompareOption.Equal) == CompareOption.Equal;
bool allowGreaterThan = (comparison & CompareOption.GreaterThan) == CompareOption.GreaterThan;
if (allowEqual && ReferenceEquals(lhs, rhs)) return true;
bool haveGreaterThan = false, haveLessThan = false;
for (int i = 0; i < lhs.Length; i++)
{
int val = lhs[i].CompareTo(rhs[i]);
if (val < 0)
{
haveLessThan = true;
if (!allowLessThan) return false;
if (haveGreaterThan)
{
compareResult = CompareResult.Unequal;
return allowGreaterThan || allowLessThan || allowEqual;
}
}
else if (val > 0)
{
haveGreaterThan = true;
if (!allowGreaterThan) return false;
if (haveLessThan)
{
compareResult = CompareResult.Unequal;
return allowGreaterThan || allowLessThan || allowEqual;
}
}
}
if (haveGreaterThan && haveLessThan) compareResult = CompareResult.Unequal;
else if (haveGreaterThan) compareResult = CompareResult.GreaterThan;
else if (haveLessThan) compareResult = CompareResult.LessThan;
else compareResult = CompareResult.Equal;
return (allowGreaterThan && haveGreaterThan) ||
(allowLessThan && haveLessThan) || allowEqual;
}
public Compare(string fieldName, params object[] compareValues)
{
this.Field = fieldName;
this.CompareValues = compareValues;
if (compareValues.Length > 2)
{
Type = CompareType.In;
}
else if (compareValues.Length == 2)
{
Type = CompareType.Between;
}
else
{
Type = CompareType.Equals;
}
this.Option = CompareOption.IgnoreEmptyString | CompareOption.ConvertDateTime;
}
public static KeyDescriptor Deserialize(BinaryReader reader)
{
DataType dataType = DataType.Deserialize(reader);
bool compressData = reader.ReadBoolean();
bool hasDefaultCompareOptions = reader.ReadBoolean();
CompareOption[] compareOptions = null;
if (!hasDefaultCompareOptions)
{
compareOptions = new CompareOption[dataType.IsPrimitive ? 1 : dataType.TypesCount];
for (int i = 0; i < compareOptions.Length; i++)
{
compareOptions[i] = CompareOption.Deserialize(reader);
}
}
return(new KeyDescriptor(dataType, compressData, compareOptions));
}
/// <summary>
/// 比较指定的值是不是在指定的范围内（默认 大于等于和小于等于）。
/// </summary>
/// <typeparam name="T">比较对象类型。</typeparam>
/// <param name="value">要测试的值。</param>
/// <param name="minValue">指定的范围最小值。</param>
/// <param name="maxValue">指定的范围最大值。</param>
/// <param name="compareOption">比较选项（默认 <see cref="CompareOption.GreaterEqAndLessEq"/>）。</param>
/// <returns></returns>
public static bool IsRange <T>(this T value, T minValue, T maxValue, CompareOption compareOption = CompareOption.GreaterEqAndLessEq) where T : struct, IComparable
{
bool result = false;
switch (compareOption)
{
case CompareOption.GreaterAndLess:
result = value.IsGreater(minValue) && value.IsLess(maxValue);
break;
case CompareOption.GreaterEqAndLess:
result = value.IsGreaterEqual(minValue) && value.IsLess(maxValue);
break;
case CompareOption.GreaterAndLessEq:
result = value.IsGreater(minValue) && value.IsLessEqual(maxValue);
break;
case CompareOption.GreaterEqAndLessEq:
result = value.IsGreaterEqual(minValue) && value.IsLessEqual(maxValue);
break;
}
return(result);
}
public bool Contains(DateTime dateTime, CompareOption compareOption = CompareOption.SemiClose)
{
if (compareOption == CompareOption.SemiClose && dateTime >= StartTime && dateTime < EndTime)
{
return(true);
}
if (compareOption == CompareOption.SemiOpen && dateTime > StartTime && dateTime <= EndTime)
{
return(true);
}
if (compareOption == CompareOption.OpenClose && dateTime >= StartTime && dateTime <= EndTime)
{
return(true);
}
if (compareOption == CompareOption.SemiOpenClose && dateTime > StartTime && dateTime < EndTime)
{
return(true);
}
return(false);
}
public Compare(string customCondition)
{
this.CustomCondition = customCondition;
this.Type = CompareType.Custom;
this.Option = CompareOption.IgnoreEmptyString | CompareOption.ConvertDateTime;
}
public ShapeManager(Shape shape, CompareOption option)
{
this.shape = shape;
this.option = option;
}
public static bool AllCompare(float[] lhs, float[] rhs, CompareOption comparison)
{
CompareResult compareResult;
return AllCompare(lhs, rhs, comparison, out compareResult);
}
/// <summary>
/// Initializes a new instance of the <see cref="Compare"/> class.
/// </summary>
/// <param name="option">The comparison option to use.</param>
/// <param name="value">The base value against which to compare all other values.</param>
public Compare(CompareOption option, Atom value)
{
m_value = value;
m_option = option;
}
// Methods
public RelationFieldMapping(string fieldName, string sourceFieldName)
{
this.fieldName = fieldName;
this.sourceFieldName = sourceFieldName;
this.compare = CompareOption.IsEqual;
}
private bool StringMatchesEnum(string p, CompareOption compareOption)
{
return((CompareOption)Enum.Parse(typeof(CompareOption), p, true) == compareOption);
}
public static bool AllCompare(float[] lhs, float[] rhs, CompareOption comparison)
{
CompareResult compareResult;
return(AllCompare(lhs, rhs, comparison, out compareResult));
}
public static bool AllCompare(float[] lhs, float[] rhs, CompareOption comparison, out CompareResult compareResult)
{
compareResult = CompareResult.Equal;
if (ReferenceEquals(lhs, null) || ReferenceEquals(rhs, null))
{
return(false);
}
if (lhs.Length != rhs.Length)
{
return(false);
}
bool allowLessThan = (comparison & CompareOption.LessThan) == CompareOption.LessThan;
bool allowEqual = (comparison & CompareOption.Equal) == CompareOption.Equal;
bool allowGreaterThan = (comparison & CompareOption.GreaterThan) == CompareOption.GreaterThan;
if (allowEqual && ReferenceEquals(lhs, rhs))
{
return(true);
}
bool haveGreaterThan = false, haveLessThan = false;
for (int i = 0; i < lhs.Length; i++)
{
int val = lhs[i].CompareTo(rhs[i]);
if (val < 0)
{
haveLessThan = true;
if (!allowLessThan)
{
return(false);
}
}
else if (val > 0)
{
haveGreaterThan = true;
if (!allowGreaterThan)
{
return(false);
}
}
}
if (haveGreaterThan && haveLessThan)
{
compareResult = CompareResult.Unequal;
}
else if (haveGreaterThan)
{
compareResult = CompareResult.GreaterThan;
}
else if (haveLessThan)
{
compareResult = CompareResult.LessThan;
}
else
{
compareResult = CompareResult.Equal;
}
return((allowGreaterThan && haveGreaterThan) ||
(allowLessThan && haveLessThan) || allowEqual);
}
public Compare(string customCondition)
{
this.CustomCondition = customCondition;
this.Type = CompareType.Custom;
this.Option = CompareOption.IgnoreEmptyString | CompareOption.ConvertDateTime;
}
internal static void CheckCompareOption(CompareOption compareOption, string p)
{
Assert.AreEqual <CompareOption>(compareOption, (CompareOption)Enum.Parse(typeof(CompareOption), p, true));
}
