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); }