public INumberMatch Initialize(
IValueGetter valueGetter,
CompareOperation compareOperation,
int match,
bool inverted = false,
int defaultValue = 0)
{
_match = match;
_valueGetter = valueGetter;
_compareOperation = compareOperation;
_inverted = inverted;
_defaultValue = defaultValue;
switch (compareOperation)
{
case CompareOperation.Equals:
_testFunc = (ruleResult, number) => number == _match;
break;
case CompareOperation.Less:
_testFunc = (ruleResult, number) => number < _match;
break;
case CompareOperation.Greater:
_testFunc = (ruleResult, number) => number > _match;
break;
default:
throw new Exception("Number match does not know how to compare numbers using " + compareOperation);
}
return(this);
}
public override void CopyFrom(Action copy)
{
base.CopyFrom(copy);
Value = (copy as ActionConditionBufferSize).Value;
Operation = (copy as ActionConditionBufferSize).Operation;
}
public static bool Calculate <T> (T value1, CompareOperation operation, T value2)
where T : IComparable <T>, IEquatable <T>
{
//OPTIMIZE: box化,unbox化が走るので、気になるならTをstructにするなど
switch (operation)
{
case CompareOperation.Equal:
return(value1.Equals(value2));
case CompareOperation.NotEqual:
return(!value1.Equals(value2));
case CompareOperation.Greater:
return(value1.CompareTo(value2) > 0);
case CompareOperation.Less:
return(value1.CompareTo(value2) < 0);
case CompareOperation.GreaterThanOrEqualTo:
return(value1.CompareTo(value2) >= 0);
case CompareOperation.LessThanOrEqualTo:
return(value1.CompareTo(value2) <= 0);
default:
Debug.LogErrorFormat("unexpected operation type {0}", operation);
return(true);
}
}
public Var_CompareOp(IEffect effectA, int con, CompareOperation op)
{
EffectA = effectA;
EffectB = null;
ConstantInt = con;
this.op = op;
}
public static string ToShortString(this CompareOperation operation)
{
switch (operation)
{
case CompareOperation.Equal:
return("EQ");
case CompareOperation.NotEqual:
return("NOT");
case CompareOperation.Greater:
return("GT");
case CompareOperation.Less:
return("LT");
case CompareOperation.GreaterThanOrEqualTo:
return("GTE");
case CompareOperation.LessThanOrEqualTo:
return("LTE");
default:
Debug.LogErrorFormat("unexpected operation type {0}", operation);
return("");
}
}
public static string ToMarkString(this CompareOperation operation)
{
switch (operation)
{
case CompareOperation.Equal:
return("==");
case CompareOperation.NotEqual:
return("!=");
case CompareOperation.Greater:
return(">");
case CompareOperation.Less:
return("<");
case CompareOperation.GreaterThanOrEqualTo:
return(">=");
case CompareOperation.LessThanOrEqualTo:
return("<=");
default:
Debug.LogErrorFormat("unexpected operation type {0}", operation);
return("");
}
}
public static ReportConditionDef AddAttributeCondition(this ReportDef def, Guid leftSourceId, Guid leftAttrId,
CompareOperation condition, Guid rightSourceId, Guid rightAttrId)
{
Check(def);
CheckSourceAttribute(def, leftSourceId, leftAttrId);
CheckSourceAttribute(def, rightSourceId, rightAttrId);
var conditionId = Guid.NewGuid();
var conditionDef = new ReportConditionDef
{
Id = conditionId,
Operation = ExpressionOperation.And,
LeftAttribute = new ReportAttributeDef {
SourceId = leftSourceId, AttributeId = leftAttrId
},
Condition = condition,
RightPart = new ReportConditionRightAttributeDef
{
Attribute = new ReportAttributeDef
{
SourceId = rightSourceId,
AttributeId = rightAttrId
}
}
};
def.Conditions.Add(conditionDef);
return(conditionDef);
}
public static bool TryGet(ExpressionType expressionType, out CompareOperation compareOperation)
{
switch (expressionType) {
case ExpressionType.Equal:
compareOperation = CompareOperation.Equal;
return true;
case ExpressionType.NotEqual:
compareOperation = CompareOperation.NotEqual;
return true;
case ExpressionType.GreaterThan:
compareOperation = CompareOperation.GreaterThan;
return true;
case ExpressionType.GreaterThanOrEqual:
compareOperation = CompareOperation.GreaterThanOrEqual;
return true;
case ExpressionType.LessThan:
compareOperation = CompareOperation.LessThan;
return true;
case ExpressionType.LessThanOrEqual:
compareOperation = CompareOperation.LessThanOrEqual;
return true;
}
compareOperation = CompareOperation.Equal;
return false;
}
public static bool EvaluateCompareExpression(int target, int compareValue, CompareOperation operation)
{
switch (operation)
{
case CompareOperation.Equal:
return(target == compareValue);
case CompareOperation.NotEqual:
return(target != compareValue);
case CompareOperation.GreaterThan:
return(target > compareValue);
case CompareOperation.GreaterOrEqualThan:
return(target >= compareValue);
case CompareOperation.LessThan:
return(target < compareValue);
case CompareOperation.LessOrEqualThan:
return(target <= compareValue);
default:
throw new Exception("Unknown Operation");
}
}
public void Comparison_Objects(TestObject a, CompareOperation operation, TestObject b, TestExceptionType eType)
{
IComparable objA = (IComparable)a.GetObject();
IComparable objB = (IComparable)b.GetObject();
this.RunTest(() => this.Checker.Comparison(objA, operation, objB), eType);
}
public static TokenType GetOperatorTokenType(CompareOperation operation)
{
switch (operation)
{
case CompareOperation.Equal:
return(TokenType.Equal);
case CompareOperation.NotEqual:
return(TokenType.NotEqual);
case CompareOperation.Greater:
return(TokenType.Greater);
case CompareOperation.GreaterOrEqual:
return(TokenType.GreaterOrEqual);
case CompareOperation.Less:
return(TokenType.Less);
case CompareOperation.LessOrEqual:
return(TokenType.LessOrEqual);
default:
throw new ArgumentOutOfRangeException(nameof(operation), operation, "Unknown enumeration value.");
}
}
public override void LoadParameters(System.IO.BinaryReader reader)
{
//GameManager.DebugLog("Loading Modify");
base.LoadParameters(reader);
target_resource_index = reader.ReadInt32();
operation_resource_index = reader.ReadInt32();
target = (ResourceSource)reader.ReadInt32();
param1 = (ResourceSource)reader.ReadInt32();
param2 = (ResourceSource)reader.ReadInt32();;
operation = (CompareOperation)reader.ReadInt32();
action_mod = reader.ReadString();
bool_mod = reader.ReadBoolean();
text_mod = reader.ReadString();
number_mod = reader.ReadInt32();
action_mod2 = reader.ReadString();
bool_mod2 = reader.ReadBoolean();
text_mod2 = reader.ReadString();
number_mod2 = reader.ReadInt32();
//trigger = (CGME.InterfaceEvent)Enum.Parse(typeof(InterfaceEvent),reader.ReadString());
}
public static bool Compare <T>(this CompareOperation operation, T a, T b) where T : IComparable
{
bool bothNull = a == null && b == null;
switch (operation)
{
case CompareOperation.Equal:
return(bothNull || (a != null && a.CompareTo(b) == 0));
case CompareOperation.Greater:
return(!bothNull && a != null && a.CompareTo(b) > 0);
case CompareOperation.GreaterEqual:
return(bothNull || (a != null && a.CompareTo(b) >= 0));
case CompareOperation.Less:
return(!bothNull && (a == null || a.CompareTo(b) < 0));
case CompareOperation.LessEqual:
return(bothNull || a == null || a.CompareTo(b) <= 0);
default:
throw new ArgumentOutOfRangeException(nameof(operation), operation, null);
}
}
public override void LoadParameters(System.IO.BinaryReader reader)
{
base.LoadParameters(reader);
Value = reader.ReadInt32();
Operation = (CompareOperation)reader.ReadInt32();
}
/// <inheritdoc />
public override string ToEncodedString()
{
const string filterPattern = @"{{""type"":""RowFilter"",""op"":""{0}"",""comparator"":{{{1}}}}}";
return(string.Format(CultureInfo.InvariantCulture, filterPattern, CompareOperation.ToCodeName(),
Comparator.ToEncodedString()));
}
static void Main(string[] args)
{
CompareOperation op = ComparingTwo;
ComparingTwo(6, 3);
Console.ReadKey();
}
public IEnumerable<IKey> Match(string path, CompareOperation operation, object value)
{
ITableIndex index;
if (_indexes.TryGetValue(path, out index))
return index.Match(operation, value);
return Key.EmptyKeys;
}
public void Comparison_Floats(
float a,
CompareOperation operation,
float b,
float precision,
TestExceptionType eType)
{
this.RunTest(() => this.Checker.Comparison(a, operation, b, precision), eType);
}
public void Comparison_Doubles(
double a,
CompareOperation operation,
double b,
double precision,
TestExceptionType eType)
{
this.RunTest(() => this.Checker.Comparison(a, operation, b, precision), eType);
}
public bool Comparison(
double a,
CompareOperation operation,
double b,
double precision,
string message,
params object[] args)
{
return(true);
}
public bool Comparison(
float a,
CompareOperation operation,
float b,
float precision,
string message,
params object[] args)
{
return(true);
}
/// <summary>
/// Show a message if the specified values do not compare in the specified way.
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="a">The first value to compare.</param>
/// <param name="operation">The <see cref="CompareOperation" /> to perform.</param>
/// <param name="b">The second value to compare.</param>
/// <param name="message">The message to show.</param>
/// <param name="args">The arguments to the message to display.</param>
/// <returns>
/// True only if the assert condition passed. Otherwise false.
/// </returns>
public bool Comparison <T>(T a, CompareOperation operation, T b, string message, params object[] args)
where T : IComparable
{
return(this.Check(
AssertType.Compare,
operation.Compare(a, b),
message,
args,
"Compare check failed. [{0} {1} {2}]",
a,
operation.GetOperation(),
b));
}
private bool CompareText(ResourceText target, ResourceText op1, CompareOperation operation)
{
switch (operation)
{
case CompareOperation.Equals: return(target.Value == op1.Value);
default:
GameManager.DebugLog("Error - operator invalid");
break;
}
return(false);
}
public override string ToEncodedString()
{
const string filterPattern =
@"{{""type"":""DependentColumnFilter"",""op"":""{0}"",""family"":""{1}"",""qualifier"":""{2}"",""dropDependentColumn"":{3},""comparator"":{{{4}}}}}";
return(string.Format(
CultureInfo.InvariantCulture,
filterPattern,
CompareOperation.ToCodeName(),
Convert.ToBase64String(Family),
Convert.ToBase64String(Qualifier),
DropDependentColumn.ToString(CultureInfo.InvariantCulture).ToLowerInvariant(),
Comparator.ToEncodedString()));
}
public override string ToEncodedString()
{
const string filterPattern =
@"{{""type"":""SingleColumnValueFilter"",""op"":""{0}"",""family"":""{1}"",""qualifier"":""{2}"",""ifMissing"":{3},""latestVersion"":{4},""comparator"":{{{5}}}}}";
return(string.Format(
CultureInfo.InvariantCulture,
filterPattern,
CompareOperation.ToCodeName(),
Convert.ToBase64String(Family),
Convert.ToBase64String(Qualifier),
FilterIfMissing.ToString(CultureInfo.InvariantCulture).ToLowerInvariant(),
LatestVersion.ToString(CultureInfo.InvariantCulture).ToLowerInvariant(),
Comparator.ToEncodedString()));
}
public static bool CompareTo(this object @this, CompareOperation operation, object obj)
{
switch (operation)
{
case CompareOperation.GreaterThan:
return(@this.CompareTo(obj) > 0);
case CompareOperation.GreaterThanOrEquals:
return(@this.CompareTo(obj) >= 0);
case CompareOperation.LessThan:
return(@this.CompareTo(obj) < 0);
case CompareOperation.LessThanOrEquals:
return(@this.CompareTo(obj) <= 0);
case CompareOperation.Contains:
return(@this.IsContains(obj));
case CompareOperation.NotContains:
return([email protected](obj));
case CompareOperation.StartsWith:
return(@this.IsStartsWith(obj));
case CompareOperation.EndsWith:
return(@this.IsEndsWith(obj));
case CompareOperation.In:
return(@this.IsIn(obj));
case CompareOperation.NotIn:
return([email protected](obj));
case CompareOperation.IsNull:
return(@this == null && obj == null);
case CompareOperation.NotNull:
return(@this != null || obj != null);
case CompareOperation.NotEquals:
return(@this.IsNotEquals(obj));
default:
case CompareOperation.Equals:
return(@this.IsEquals(obj));
}
}
/// <summary>
/// Show a message if the specified values do not compare in the specified way.
/// </summary>
/// <param name="a">The first value to compare.</param>
/// <param name="operation">The <see cref="CompareOperation" /> to perform.</param>
/// <param name="b">The second value to compare.</param>
/// <param name="precision">The acceptable difference when comparing the floating point value.</param>
/// <param name="message">The message to show.</param>
/// <param name="args">The arguments to the message to display.</param>
/// <returns>
/// True only if the assert condition passed. Otherwise false.
/// </returns>
public bool Comparison(
double a,
CompareOperation operation,
double b,
double precision,
string message,
params object[] args)
{
return(this.Check(
AssertType.Compare,
operation.Compare(a, b, precision),
message,
args,
"Compare check failed. [{0} {1} {2}]",
a,
operation.GetOperation(),
b));
}
private string GetFilterPattern(CompareOperation operation)
{
switch (operation)
{
case CompareOperation.Contains:
case CompareOperation.NotContains:
return(ContainsPattern);
case CompareOperation.StartsWith:
return(StartsWithPattern);
case CompareOperation.EndsWith:
return(EndsWithPattern);
default:
return(string.Empty);
}
}
public static CompareOperation ParseOperation(XElement element)
{
var result = new CompareOperation();
result.OperationType = element.Name.LocalName;
result.FieldName = (from product in element.Elements("FieldRef")
select product.Attribute("Name").Value
).FirstOrDefault();
result.ValueType = (from product in element.Elements("Value")
select product.Attribute("Type").Value
).FirstOrDefault();
result.Value = (from product in element.Elements("Value")
select product.Value
).FirstOrDefault();
return(result);
}
protected virtual string GetOperator(CompareOperation operation)
{
switch (operation)
{
case CompareOperation.NotEquals:
return(" <> ");
case CompareOperation.GreaterThanOrEquals:
return(" >= ");
case CompareOperation.GreaterThan:
return(" > ");
case CompareOperation.LessThanOrEquals:
return(" <= ");
case CompareOperation.LessThan:
return(" < ");
case CompareOperation.In:
return(" IN ");
case CompareOperation.NotIn:
return(" NOT IN ");
case CompareOperation.Contains:
case CompareOperation.StartsWith:
case CompareOperation.EndsWith:
return(" LIKE ");
case CompareOperation.NotContains:
return(" NOT LIKE ");
case CompareOperation.IsNull:
return(" IS NULL ");
case CompareOperation.NotNull:
return(" IS NOT NULL ");
default:
return(" = ");
}
}
private bool CompareNumber(ResourceNumber target, ResourceNumber op1, CompareOperation operation)
{
//GameManager.DebugLog("Comparing: " + target.Value + " " + operation + " " + op1.Value);
//GameManager.DebugLog((target.Value >= op1.Value).ToString());
switch (operation)
{
case CompareOperation.Equals: return(target.Value == op1.Value);
case CompareOperation.Larger: return(target.Value > op1.Value);
case CompareOperation.LargerOrEqual: return(target.Value >= op1.Value);
case CompareOperation.Smaller: return(target.Value < op1.Value);
case CompareOperation.SmallerOrEqual: return(target.Value <= op1.Value);
}
return(false);
}
public void SetConditionOperation(Guid id, string value)
{
CompareOperation exp;
if (CompareOperation.TryParse(value, out exp))
{
if (Context == null || Context.Def == null || Context.Def.Conditions == null)
{
return;
}
var condition = FindConditionDef(Context.Def, id) as ReportConditionDef;
if (condition == null)
{
return;
}
condition.Condition = exp;
}
}
public void Compare(PropertyPath path, CompareOperation compareOperation, object value)
{
_expressions.Push(new CompareIndexExpression(path, compareOperation, value));
}
private bool TryBinaryAnalyzeCompare(CompareOperation operation, Expression right)
{
if (_propertyPath == null) return false;
var path = _propertyPath;
var pathString = _propertyPath.GetUniqueName();
_propertyPath = null;
if (_entityMap == null) return false;
if (operation == CompareOperation.Equal
&& string.Equals(pathString, _entityMap.KeyName, StringComparison.InvariantCulture)) {
_executor.EqualKey(((ConstantExpression) right).Value);
return true;
}
var index = _entityMap.Indexes.FirstOrDefault(i => string.Equals(i.UniqueName, pathString, StringComparison.InvariantCulture));
if (index == null) return false;
_executor.Compare(path, operation, ((ConstantExpression)right).Value);
return true;
}
public override void Reset() {
base.Reset();
storeValue = 0f;
compareOperation = CompareOperation.None;
compareToValue = 0f;
compareAbsValues = false;
isTrueEvent = null;
isFalseEvent = null;
valueChangedEvent = null;
}
public CompareIndexExpression(PropertyPath path, CompareOperation compareOperation, object value)
{
_path = path;
_compareOperation = compareOperation;
_value = value;
}
