public static string ConvertToColumnWithNumeric(string inputVariable, string val, string index)
{
var x = WarewolfDataEvaluationCommon.ParseLanguageExpression(inputVariable);
if (x.IsRecordSetNameExpression)
{
var outputval = x as LanguageAST.LanguageExpression.RecordSetNameExpression;
return(String.Format("[[{0}({1}).{2}]]", outputval.Item.Name, index, val));
}
return(inputVariable);
}
public static bool IsScalar(string assignVar)
{
try
{
var x = WarewolfDataEvaluationCommon.ParseLanguageExpression(assignVar, 0);
return(x.IsScalarExpression);
}
catch (Exception)
{
return(false);
}
}
public static bool IsRecordSetName(string a)
{
try
{
var x = WarewolfDataEvaluationCommon.ParseLanguageExpression(a, 0);
return(x.IsRecordSetNameExpression);
}
catch (Exception)
{
return(false);
}
}
public static bool IsRecordsetIdentifier(string assignVar)
{
try
{
var x = WarewolfDataEvaluationCommon.ParseLanguageExpression(assignVar);
return(x.IsRecordSetExpression);
}
catch (Exception)
{
return(false);
}
}
public bool HasRecordSet(string recordsetName)
{
var x = WarewolfDataEvaluationCommon.ParseLanguageExpression(recordsetName, 0);
if (x.IsRecordSetNameExpression)
{
var recsetName = x as LanguageAST.LanguageExpression.RecordSetNameExpression;
// ReSharper disable PossibleNullReferenceException
return(_env.RecordSets.ContainsKey(recsetName.Item.Name));
// ReSharper restore PossibleNullReferenceException
}
return(false);
}
string CalculateDestinationNameFromSourceName(string sourceName)
{
LanguageAST.LanguageExpression parsed = WarewolfDataEvaluationCommon.ParseLanguageExpression(sourceName, 0);
if (parsed.IsScalarExpression)
{
return(((LanguageAST.LanguageExpression.ScalarExpression)parsed).Item);
}
if (parsed.IsRecordSetExpression)
{
return(((LanguageAST.LanguageExpression.RecordSetExpression)parsed).Item.Column);
}
return(((LanguageAST.LanguageExpression.RecordSetNameExpression)parsed).Item.Name);
}
public static string ConvertToIndex(string outputVar, int i)
{
var output = WarewolfDataEvaluationCommon.ParseLanguageExpression(outputVar, 0);
if (output.IsRecordSetExpression)
{
var outputidentifier = (output as LanguageAST.LanguageExpression.RecordSetExpression).Item;
if (Equals(outputidentifier.Index, LanguageAST.Index.Star))
{
return("[[" + outputidentifier.Name + "(" + i + ")." + outputidentifier.Column + "]]");
}
}
return(outputVar);
}
public static string GetPositionColumnExpression(string recordset)
{
var rec = WarewolfDataEvaluationCommon.ParseLanguageExpression(recordset, 0);
if (rec.IsRecordSetExpression)
{
var index = (rec as LanguageAST.LanguageExpression.RecordSetExpression).Item;
return("[[" + index.Name + "(" + "*" + ")." + WarewolfDataEvaluationCommon.PositionColumn + "]]");
}
if (rec.IsRecordSetNameExpression)
{
var index = (rec as LanguageAST.LanguageExpression.RecordSetNameExpression).Item;
return("[[" + index.Name + "(" + "*" + ")." + WarewolfDataEvaluationCommon.PositionColumn + "]]");
}
return(recordset);
}
public static bool IsValidVariableExpression(string expression, out string errorMessage, int update)
{
errorMessage = "";
try
{
var x = WarewolfDataEvaluationCommon.ParseLanguageExpression(expression, update);
if (x.IsRecordSetExpression || x.IsScalarExpression)
{
return(true);
}
}
catch (Exception e)
{
errorMessage = e.Message;
return(false);
}
return(false);
}
public static string ValidateInput(string sourceName)
{
try
{
var parsed = WarewolfDataEvaluationCommon.ParseLanguageExpression(sourceName, 0);
if (parsed.IsComplexExpression)
{
var complex = (LanguageAST.LanguageExpression.ComplexExpression)parsed;
if (complex.Item
.Any(x => x.IsRecordSetNameExpression))
{
return("Cannot specify a Recordset as part of a comma seperated list of expressions");
}
if (complex.Item.Count() < 3 ||
complex.Item.Count() % 2 != 1 ||
// ReSharper disable MaximumChainedReferences
!Enumerable.Range(1, complex.Item.Count() - 1)
.Where(i => i % 2 == 1)
.Select(i =>
WarewolfDataEvaluationCommon.LanguageExpressionToString(
complex.Item.ElementAt(i)
) == ",")
.Aggregate((a, b) => a && b))
// ReSharper restore MaximumChainedReferences
{
return("Problem with input: expressions must be comma seperated");
}
}
else if (!parsed.IsRecordSetNameExpression &&
!parsed.IsRecordSetExpression &&
!parsed.IsScalarExpression &&
!parsed.IsWarewolfAtomAtomExpression)
{
return("Can only have a scalar, a RecordSet or a RecordSet with column qualification as input");
}
}
catch (Exception)
{
return("Unable to parse the Source Name");
}
return(null);
}
public string ToLast(string rawValue)
{
var output = WarewolfDataEvaluationCommon.ParseLanguageExpression(rawValue);
if (output.IsRecordSetExpression)
{
var outputidentifier = (output as LanguageAST.LanguageExpression.RecordSetExpression).Item;
var i = GetLength(outputidentifier.Name);
return("[[" + outputidentifier.Name + "(" + i + ")." + outputidentifier.Column + "]]");
}
if (output.IsRecordSetExpression)
{
var outputidentifier = (output as LanguageAST.LanguageExpression.RecordSetNameExpression).Item;
var i = GetLength(outputidentifier.Name);
if (Equals(outputidentifier.Index, LanguageAST.Index.Star))
{
return("[[" + outputidentifier.Name + "(" + i + ") " + "]]");
}
}
return(rawValue);
}
public string ToStar(string expression)
{
var exp = WarewolfDataEvaluationCommon.ParseLanguageExpression(expression, 0);
if (exp.IsRecordSetExpression)
{
var rec = exp as LanguageAST.LanguageExpression.RecordSetExpression;
if (rec != null)
{
return("[[" + rec.Item.Name + "(*)." + rec.Item.Column + "]]");
}
}
if (exp.IsRecordSetNameExpression)
{
var rec = exp as LanguageAST.LanguageExpression.RecordSetNameExpression;
if (rec != null)
{
return("[[" + rec.Item.Name + "(*)" + "]]");
}
}
return(expression);
}
public JsonMappingCompoundTo(
IExecutionEnvironment env,
JsonMappingTo compound)
{
_env = env;
Compound = compound;
Evaluations = new List <JsonMappingEvaluated>();
if (!IsCompound)
{
Evaluations.Add(new JsonMappingEvaluated(_env, compound.SourceName));
}
else
{
if (WarewolfDataEvaluationCommon.ParseLanguageExpression(Compound.SourceName, 0).IsRecordSetNameExpression)
{
Evaluations = new List <JsonMappingEvaluated> {
new JsonMappingEvaluated(_env, Compound.SourceName)
};
}
else
{
// we know this is a comma seperated list of expressions
Evaluations =
// ReSharper disable MaximumChainedReferences
((LanguageAST.LanguageExpression.ComplexExpression)WarewolfDataEvaluationCommon.ParseLanguageExpression(Compound.SourceName, 0))
.Item
.Where(x => !x.IsWarewolfAtomAtomExpression)
.Select(WarewolfDataEvaluationCommon.LanguageExpressionToString)
.Select(x =>
new JsonMappingEvaluated(_env, x))
.ToList();
} // ReSharper restore MaximumChainedReferences
}
}
