public static Boolean isBooleanLogic(dataLogic input)
{
switch (input)
{
case dataLogic.OR:
case dataLogic.AND:
return(true);
default:
return(false);
}
}
/// <summary>
/// V3.5> Experimentalna funkcija - na osnovu tipa vrsi konverziju
/// </summary>
/// <param name="input">Ulazni string</param>
/// <param name="targetType">Tip</param>
/// <param name="logic">The logic.</param>
/// <returns></returns>
/// <remarks>
/// Koristi se i 2013a
/// </remarks>
public static Object getDataTypeSafe(this Object input, Type targetType, dataLogic logic = dataLogic.skip)
{
if (targetType == typeof(Type))
{
return(input);
}
targetType = imbDataExecutor.getRecommandedType(logic, targetType);
if (input == null)
{
input = "";
}
if (targetType == typeof(String))
{
return(input.ToString());
}
if (targetType == typeof(Int32))
{
return(input.ToString().getInt32Safe(0)); // getInt32Safe(input.ToString(), 0);
}
if (targetType == typeof(Double))
{
return(input.ToString().getDoubleSafe(0)); // getDoubleSafe(input.ToString(), 0);
}
if (targetType == typeof(Boolean))
{
Boolean boolOut = false;
Boolean.TryParse(input.ToString(), out boolOut);
return(boolOut);
}
if (targetType == typeof(List <Int32>))
{
return(rangeStringToIndexList(input as String, 1000));
}
if (targetType.IsEnum)
{
return(targetType.getEnumByName(input as String));
}
return(input);
}
public static Type getRecommandedType(dataLogic logic, Type defaultType)
{
switch (logic)
{
case dataLogic.OR:
case dataLogic.AND:
return(typeof(Boolean));
case dataLogic.plus:
case dataLogic.minus:
return(typeof(Int32));
case dataLogic.divide:
case dataLogic.combine:
return(typeof(Double));
default:
return(defaultType);
break;
}
}
/// <summary>
/// Izvrsava jednostavnu logiku - i prosledjuje kompleksnoj ako je potrebno
/// </summary>
/// <param name="logic"></param>
/// <param name="operandA">Domacin, target</param>
/// <param name="operandB">Nova vrednost</param>
/// <returns></returns>
public static Object executeLogic(dataLogic logic, Object operandA, Object operandB)
{
Object output = operandA;
String strA = "";
String strB = "";
switch (logic)
{
case dataLogic.set:
return(operandB);
break;
case dataLogic.setIfEmpty:
if (operandA == null)
{
return(operandB);
}
else
{
if (String.IsNullOrEmpty(operandA.ToString()))
{
return(operandB);
}
else
{
return(operandA);
}
}
break;
default:
break;
}
return(output);
}
/// <summary>
/// Vraća NCalc string oblik logike
/// </summary>
/// <param name="logic"></param>
/// <returns></returns>
public static String getStringOperator(dataLogic logic)
{
switch (logic)
{
case dataLogic.OR:
return("||");
case dataLogic.AND:
return("&&");
default:
case dataLogic.plus:
return("+");
case dataLogic.minus:
return("-");
case dataLogic.divide:
return("/");
case dataLogic.combine:
return("*");
}
}
/// <summary>
/// Izvršava operaciju nad višelinijskim stringom
/// </summary>
/// <param name="logic"></param>
/// <param name="operandA"></param>
/// <param name="operandB"></param>
/// <returns></returns>
public static String executeMultilineLogic(dataLogic logic, String operandA, String operandB)
{
String output = "";
if (operandB == "")
{
return(operandA);
}
List <String> listA_el = new List <string>();
listA_el.AddRange(operandA.Split(Environment.NewLine.ToCharArray(), StringSplitOptions.RemoveEmptyEntries));
List <String> listB_el = new List <string>();
listB_el.AddRange(operandB.Split(Environment.NewLine.ToCharArray(), StringSplitOptions.RemoveEmptyEntries));
Int32 limit = listA_el.Count();
if (limit == 0)
{
limit = listB_el.Count();
}
switch (logic)
{
case dataLogic.mlSumLong:
if (listB_el.Count() > limit)
{
limit = listB_el.Count();
}
break;
case dataLogic.mlSumShort:
if (listB_el.Count() < limit)
{
limit = listB_el.Count();
}
break;
}
Int32 a;
Int32 x;
Int32 y;
for (a = 0; a < limit; a++)
{
try
{
x = Convert.ToInt32(listA_el[a]);
}
catch
{
x = 0;
}
try
{
y = Convert.ToInt32(listB_el[a]);
}
catch
{
y = 0;
}
output = output + (x + y).ToString() + Environment.NewLine;
}
return(output);
}
public static List <Object> combineArray(List <Object> tmpListString, List <Object> tmpListStringB, dataLogic logic)
{
List <Object> output = tmpListString;
switch (logic)
{
case dataLogic.plus:
foreach (Object child in tmpListStringB)
{
tmpListString.Add(child);
}
output = tmpListString;
break;
case dataLogic.minus:
foreach (Object child in tmpListStringB)
{
tmpListString.Remove(child);
}
output = tmpListString;
break;
case dataLogic.combine:
List <Object> combined = new List <Object>();
foreach (Object child in tmpListString)
{
if (!combined.Contains(child))
{
combined.Add(child);
}
}
foreach (Object child in tmpListStringB)
{
if (!combined.Contains(child))
{
combined.Add(child);
}
}
output = combined;
break;
case dataLogic.divide:
List <Object> tmpCombined = combineArray(tmpListString, tmpListStringB, dataLogic.combine);
foreach (Object child in tmpCombined)
{
tmpListString.Remove(child);
}
output = tmpListString;
break;
}
return(output);
}
public static Object executeComplexLogic(dataLogic logic, Object operandA, Object operandB)
{
Object output = null;
Type typeA = operandA.GetType();
Type typeB = operandB.GetType();
Object safeA = operandA.getDataTypeSafe(typeA);
Object safeB = operandB.getDataTypeSafe(typeB);
typeA = safeA.GetType();
typeB = safeB.GetType();
String typeNameA = typeA.Name;
String nOp = getStringOperator(logic);
switch (typeNameA)
{
case "Int32":
case "Double":
case "Decimal":
case "Float":
case "Boolean":
try
{
output = Compute(safeA.ToString() + nOp + safeB.ToString());
}
catch
{
output = operandB;
}
break;
case "String":
switch (logic)
{
default:
case dataLogic.plus:
output = safeA.ToString() + safeB.ToString();
break;
case dataLogic.minus:
output = safeB.ToString() + safeA.ToString();
break;
}
break;
}
if (output != null)
{
return(output);
}
if (typeA != typeB)
{
return(null);
}
return(output);
}
/// <summary>
/// Privremeni string wrapper
/// </summary>
/// <param name="logic"></param>
/// <param name="operandA"></param>
/// <param name="operandB"></param>
/// <returns></returns>
public static String executeLogic(dataLogic logic, String operandA, String operandB)
{
return(executeLogic(logic, operandA as Object, operandB as Object) as String);
}
