// Direction = V
// Direction = H
public bool AddMove(int Index, int Position, Direction Direction, out string clo)
{
clo = "non";
//closeLine(Index, Position, v, Ori).
VariableTerm aClo = new VariableTerm();
FPEngine.SetPredicate(new Close_Line_4(new IntegerTerm(Index), new IntegerTerm(Position), new IntegerTerm((int)Direction), aClo, new ReturnCs(FPEngine)));
if (FPEngine.Call())
{
clo = (string)aClo.ToCsObject();
FPEngine.Success();
}
Term[] argss = { new IntegerTerm(Index), new IntegerTerm(Position), new IntegerTerm((int)Direction) };
StructureTerm newLine = new StructureTerm(SymbolTerm.MakeSymbol("line", 3), argss);
FPEngine.SetPredicate(new Assert_1(newLine, new ReturnCs(FPEngine)));
if (FPEngine.Call())
{
FPEngine.Success();
return true;
}
else
return false;
}
public SpSplitArgument(IOperandTerm s1, IOperandTerm s2, VariableToken varId, VariableTerm num)
{
TargetStr = s1;
Split = s2;
Var = varId;
Num = num;
}
public SpForNextArgment(VariableTerm var, IOperandTerm start, IOperandTerm end, IOperandTerm step)
{
Cnt = var;
Start = start;
End = end;
Step = step;
}
public SpArraySortArgument(VariableTerm var, SortOrder order, IOperandTerm num1, IOperandTerm num2)
{
VarToken = var;
Order = order;
Num1 = num1;
Num2 = num2;
}
public SpVarSetArgument(VariableTerm var, IOperandTerm termSrc, IOperandTerm start, IOperandTerm end)
{
VariableDest = var;
Term = termSrc;
Start = start;
End = end;
}
public SpForNextArgment(VariableTerm var, IOperandTerm start, IOperandTerm end, IOperandTerm step)
{
this.Cnt = var;
this.Start = start;
this.End = end;
this.Step = step;
}
static FunctionMethodTerm CallnameTarget = null; // "$$$"
public static void Initialize()
{
formatCurlyBrace = new FormatCurlyBrace();
formatPercent = new FormatPercent();
formatYenAt = new FormatYenAt();
VariableToken nameID = GlobalStatic.VariableData.GetSystemVariableToken("NAME");
VariableToken callnameID = GlobalStatic.VariableData.GetSystemVariableToken("CALLNAME");
IOperandTerm[] zeroArg = new IOperandTerm[] { new SingleTerm(0) };
VariableTerm target = new VariableTerm(GlobalStatic.VariableData.GetSystemVariableToken("TARGET"), zeroArg);
VariableTerm master = new VariableTerm(GlobalStatic.VariableData.GetSystemVariableToken("MASTER"), zeroArg);
VariableTerm player = new VariableTerm(GlobalStatic.VariableData.GetSystemVariableToken("PLAYER"), zeroArg);
VariableTerm assi = new VariableTerm(GlobalStatic.VariableData.GetSystemVariableToken("ASSI"), zeroArg);
VariableTerm nametarget = new VariableTerm(nameID, new IOperandTerm[] { target });
VariableTerm callnamemaster = new VariableTerm(callnameID, new IOperandTerm[] { master });
VariableTerm callnameplayer = new VariableTerm(callnameID, new IOperandTerm[] { player });
VariableTerm nameassi = new VariableTerm(nameID, new IOperandTerm[] { assi });
VariableTerm callnametarget = new VariableTerm(callnameID, new IOperandTerm[] { target });
NameTarget = new FunctionMethodTerm(formatPercent, new IOperandTerm[] { nametarget, null, null });
CallnameMaster = new FunctionMethodTerm(formatPercent, new IOperandTerm[] { callnamemaster, null, null });
CallnamePlayer = new FunctionMethodTerm(formatPercent, new IOperandTerm[] { callnameplayer, null, null });
NameAssi = new FunctionMethodTerm(formatPercent, new IOperandTerm[] { nameassi, null, null });
CallnameTarget = new FunctionMethodTerm(formatPercent, new IOperandTerm[] { callnametarget, null, null });
}
public void SetTransporter(ExpressionMediator exm)
{
for (int i = 0; i < Arguments.Length; i++)
{
if (Arguments[i] == null)
{
continue;
}
if (isRef[i])
{
VariableTerm vTerm = (VariableTerm)Arguments[i];
if (vTerm.Identifier.IsCharacterData)
{
Int64 charaNo = vTerm.GetElementInt(0, exm);
if ((charaNo < 0) || (charaNo >= GlobalStatic.VariableData.CharacterList.Count))
{
throw new CodeEE("キャラクタ配列変数" + vTerm.Identifier.Name + "の第１引数(" + charaNo.ToString() + ")はキャラ登録番号の範囲外です");
}
TransporterRef[i] = (Array)vTerm.Identifier.GetArrayChara((int)charaNo);
}
else
{
TransporterRef[i] = (Array)vTerm.Identifier.GetArray();
}
}
else if (Arguments[i].GetOperandType() == typeof(Int64))
{
TransporterInt[i] = Arguments[i].GetIntValue(exm);
}
else
{
TransporterStr[i] = Arguments[i].GetStrValue(exm);
}
}
}
///////////////////////////////////////////////////////////
public MapLookupTerm(VariableTerm map, ExpressionList indices)
{
Debug.Assert(map != null);
Debug.Assert(indices != null);
this.function = MapLookup.getMapLookup();
this.map = map;
this.indices = indices;
}
public SpArrayShiftArgument(VariableTerm var, IOperandTerm num1, IOperandTerm num2, IOperandTerm num3, IOperandTerm num4)
{
VarToken = var;
Num1 = num1;
Num2 = num2;
Num3 = num3;
Num4 = num4;
}
public AggregateExpression Count(VariableTerm variable)
{
var aggregate = _distinctAggregate
? (ISparqlAggregate) new CountDistinctAggregate(variable)
: new CountAggregate(variable);
return(new AggregateExpression(aggregate));
}
/* FIN ATRIBUTOS */
/* METODO QUE CREA UN LABERINTO DESDE PROLOG E INICIALIZA EL ATRIBUTO REPRESENTACIONLABERINTO Y LABERINTO
* LA CANTIDAD DE TROFEOS ESTA DADA POR EL NIVEL DE DIFICULTAD ENTRE 0 Y 10, NADA DE TROFEOS O LLENO.
*/
public void crearLaberinto(int dimensionX, int dimensionY, int nivelDificultad)
{
Term nil = SymbolTerm.MakeSymbol("0");
bool resultado;
//laberinto(L,DimX,DimY,Dificultad,MinimosCaminosSalida(noImplementado))
Predicate predicate;
VariableTerm laberintoCompleto;
Laberinto_5 lab;
/* INSTANCIAS */
VariableTerm laberinto = new VariableTerm();
VariableTerm trofeos = new VariableTerm();
VariableTerm inicio = new VariableTerm();
VariableTerm final = new VariableTerm();
IntegerTerm dimX = new IntegerTerm(dimensionX);
IntegerTerm dimY = new IntegerTerm(dimensionY);
IntegerTerm dificultad = new IntegerTerm(nivelDificultad);
if (pInterface == null)
{
pInterface = new PrologInterface();
}
/* FIN */
//MIENTRAS NO GENERE UN RESULTADO INTENTARA CREAR UN LABERINTO
do
{
/* === INSTANCIAS Y EJECUCION PARA LA CREACION DEL LABERINTO MEDIANTE PROLOG === */
laberintoCompleto = new VariableTerm();
lab = new Laberinto_5(laberintoCompleto, dimX, dimY, dificultad, nil, new ReturnCs(pInterface));
predicate = lab;
pInterface.SetPredicate(predicate);
resultado = pInterface.Call();
/* === FINALIZA INSTANCIAS Y EJECUCIONES === */
if (resultado)
{
/* === ASIGNACION DE ATRIBUTOS DE CLASE === */
predicate = new Get_Lab_2(laberintoCompleto, laberinto, new ReturnCs(pInterface));
pInterface.SetPredicate(predicate);
pInterface.Call();
predicate = new Get_Trof_2(laberintoCompleto, trofeos, new ReturnCs(pInterface));
pInterface.SetPredicate(predicate);
pInterface.Call();
predicate = new Get_Inicio_2(laberintoCompleto, inicio, new ReturnCs(pInterface));
pInterface.SetPredicate(predicate);
pInterface.Call();
predicate = new Get_Final_2(laberintoCompleto, final, new ReturnCs(pInterface));
pInterface.SetPredicate(predicate);
pInterface.Call();
/* === FIN ASIGNACION === */
RepresentacionLaberinto = laberintoCompleto.Dereference();
Console.WriteLine(RepresentacionLaberinto.ToString());
Laberinto = new Laberinto((ListTerm)laberinto.Dereference(), (ListTerm)trofeos.Dereference(), ((IntegerTerm)inicio.Dereference()).IntValue(), ((IntegerTerm)final.Dereference()).IntValue(), dimensionX, dimensionY);
}
} while (!resultado);
}
public void SparqlExpressionsXPathReplaceNullInCanParallelise2()
{
// when
var find = new VariableTerm("find");
var replace = new ConstantTerm(new StringNode(null, "replacement"));
ReplaceFunction func = new ReplaceFunction(new VariableTerm("term"), find, replace);
// then
var canParallelise = func.CanParallelise;
}
public void CanBuildSelectSumWithHaving()
{
// given
var o = new VariableTerm("o");
// when
var query = QueryBuilder.Select(ex => ex.Sum(o)).As("sum")
.Where(BuildSPOPattern)
.Having(ex => ex.Variable("sum") > 10)
.BuildQuery();
// then
Assert.Equal("?sum > 10", query.Having.Expression.ToString().Trim());
}
public void SparqlCountDistinctHasDistinctModifier()
{
// given
var term = new VariableTerm("var");
var aggregate = new CountDistinctAggregate(term);
// when
var arguments = aggregate.Arguments.ToArray();
// then
Assert.Equal(2, arguments.Length);
Assert.True(arguments[0] is DistinctModifier);
Assert.Same(term, arguments[1]);
}
public static IOperandTerm ReduceUnaryTerm(OperatorCode op, IOperandTerm o1)
{
OperatorMethod method = null;
if (op == OperatorCode.Increment || op == OperatorCode.Decrement)
{
VariableTerm var = o1 as VariableTerm;
if (var == null)
{
throw new CodeEE("変数以外をインクリメントすることはできません");
}
if (var.Identifier.IsConst)
{
throw new CodeEE("変更できない変数をインクリメントすることはできません");
}
}
if (o1.GetOperandType() == typeof(Int64))
{
if (op == OperatorCode.Plus)
{
return(o1);
}
OperatorMethod operator_method = null;
if (unaryDic.TryGetValue(op, out operator_method))
{
method = operator_method;
}
}
if (method != null)
{
return(new FunctionMethodTerm(method, new IOperandTerm[] { o1 }));
}
string errMes = "";
if (o1.GetOperandType() == typeof(Int64))
{
errMes += "数値型";
}
else if (o1.GetOperandType() == typeof(string))
{
errMes += "文字列型";
}
else
{
errMes += "不定型";
}
errMes += "に単項演算子\'" + OperatorManager.ToOperatorString(op) + "\'は適用できません";
throw new CodeEE(errMes);
}
public void CanBuildSelectSumWithGrouping()
{
// given
var o = new VariableTerm("o");
// when
var query = QueryBuilder.Select(ex => ex.Sum(o)).As("sum")
.Where(BuildSPOPattern)
.GroupBy("s")
.BuildQuery();
// then
Assert.Equal("sum", query.Variables.Single().Name);
Assert.Equal("s", query.GroupBy.Variables.Single());
}
public AggregateExpression GroupConcat(VariableTerm variable, string separator = " ")
{
GroupConcatAggregate aggregate;
if (separator != " ")
{
aggregate = new GroupConcatAggregate(variable, Constant(separator).Expression, _distinctAggregate);
}
else
{
aggregate = new GroupConcatAggregate(variable, _distinctAggregate);
}
return(new AggregateExpression(aggregate));
}
/// <summary>
/// Counts the results.
/// </summary>
/// <param name="context">Evaluation Context.</param>
/// <param name="bindingIDs">Binding IDs over which the Aggregate applies.</param>
/// <returns></returns>
public override IValuedNode Apply(SparqlEvaluationContext context, IEnumerable <int> bindingIDs)
{
int c;
HashSet <IValuedNode> values = new HashSet <IValuedNode>();
if (_varname != null)
{
// Ensure the COUNTed variable is in the Variables of the Results
if (!context.Binder.Variables.Contains(_varname))
{
throw new RdfQueryException("Cannot use the Variable " + _expr.ToString() + " in a COUNT Aggregate since the Variable does not occur in a Graph Pattern");
}
// Just Count the number of results where the variable is bound
VariableTerm varExpr = (VariableTerm)_expr;
foreach (int id in bindingIDs)
{
IValuedNode temp = varExpr.Evaluate(context, id);
if (temp != null)
{
values.Add(temp);
}
}
c = values.Count;
}
else
{
// Count the distinct non-null results
foreach (int id in bindingIDs)
{
try
{
IValuedNode temp = _expr.Evaluate(context, id);
if (temp != null)
{
values.Add(temp);
}
}
catch
{
// Ignore errors
}
}
c = values.Count;
}
return(new LongNode(null, c));
}
/// <summary>
/// Checks the equality of objects.
/// </summary>
/// <param name="obj">Object to be checked.</param>
/// <returns>True if the objects are equal, false otherwise.</returns>
public override bool Equals(object obj)
{
if (obj == this)
{
return(true);
}
VariableTerm other = obj as VariableTerm;
if (other == null)
{
return(false);
}
return(NameId == other.NameId);
}
/// <summary>
/// Counts the results
/// </summary>
/// <param name="context">Evaluation Context</param>
/// <param name="bindingIDs">Binding IDs over which the Aggregate applies</param>
/// <returns></returns>
public override IValuedNode Apply(SparqlEvaluationContext context, IEnumerable <int> bindingIDs)
{
int c = 0;
if (this._varname != null)
{
//Ensure the COUNTed variable is in the Variables of the Results
if (!context.Binder.Variables.Contains(this._varname))
{
throw new RdfQueryException("Cannot use the Variable " + this._expr.ToString() + " in a COUNT Aggregate since the Variable does not occur in a Graph Pattern");
}
//Just Count the number of results where the variable is bound
VariableTerm varExpr = (VariableTerm)this._expr;
foreach (int id in bindingIDs)
{
if (varExpr.Evaluate(context, id) != null)
{
c++;
}
}
}
else
{
//Count the number of results where the result in not null/error
foreach (int id in bindingIDs)
{
try
{
if (this._expr.Evaluate(context, id) != null)
{
c++;
}
}
catch
{
//Ignore errors
}
}
}
return(new LongNode(null, c));
}
public void SparqlVarNames()
{
var names = new List <string>
{
"?var",
"$var",
"var"
};
foreach (var name in names)
{
var var = new SparqlVariable(name);
Assert.Equal("var", var.Name);
var varPat = new VariablePattern(name);
Assert.Equal("var", varPat.VariableName);
var varTerm = new VariableTerm(name);
Assert.Equal("var", varTerm.Variables.First());
}
}
public void SparqlVarNames()
{
List <String> names = new List <String>
{
"?var",
"$var",
"var"
};
foreach (String name in names)
{
SparqlVariable var = new SparqlVariable(name);
Assert.AreEqual("var", var.Name);
VariablePattern varPat = new VariablePattern(name);
Assert.AreEqual("var", varPat.VariableName);
VariableTerm varTerm = new VariableTerm(name);
Assert.AreEqual("var", varTerm.Variables.First());
}
}
/// <summary>
/// Counts the results
/// </summary>
/// <param name="context">Evaluation Context</param>
/// <param name="bindingIDs">Binding IDs over which the Aggregate applies</param>
/// <returns></returns>
public override IValuedNode Apply(SparqlEvaluationContext context, IEnumerable <int> bindingIDs)
{
int c = 0;
if (this._varname != null)
{
//Just Count the number of results where the variable is bound
VariableTerm varExpr = (VariableTerm)this._expr;
foreach (int id in bindingIDs)
{
if (varExpr.Evaluate(context, id) != null)
{
c++;
}
}
}
else
{
//Count the number of results where the result in not null/error
foreach (int id in bindingIDs)
{
try
{
if (this._expr.Evaluate(context, id) != null)
{
c++;
}
}
catch
{
//Ignore errors
}
}
}
return(new LongNode(null, c));
}
public void Clear()
{
VariableTerm Index = new VariableTerm();
VariableTerm Position = new VariableTerm();
VariableTerm Direction = new VariableTerm();
Term[] argss = { Index, Position, Direction };
StructureTerm newLine = new StructureTerm(SymbolTerm.MakeSymbol("line", 3), argss);
FPEngine.SetPredicate(new Retractall_1(newLine, new ReturnCs(FPEngine)));
if (FPEngine.Call())
{
FPEngine.Success();
}
}
/// <summary>
/// Creates a new COUNT Aggregate
/// </summary>
/// <param name="expr">Variable Expression</param>
public CountAggregate(VariableTerm expr)
: base(expr)
{
this._varname = expr.ToString().Substring(1);
}
/// <summary>
/// Creates a new NMAX Aggregate
/// </summary>
/// <param name="expr">Variable Expression</param>
/// <param name="distinct">Whether a DISTINCT modifier applies</param>
public NumericMaxAggregate(VariableTerm expr, bool distinct)
: base(expr, distinct)
{
_varname = expr.ToString().Substring(1);
}
/// <summary>
/// Creates a new NMAX Aggregate
/// </summary>
/// <param name="expr">Variable Expression</param>
public NumericMaxAggregate(VariableTerm expr)
: this(expr, false)
{
}
public string go(bool FirstRed, GameLevel RedPlayer, GameLevel YellowPlayer)
{
List<int> Indexes = GenerateArray(7);
List<int> Positions = GenerateArray(6);
#region Create Terms Indexes and Positions
ListTerm lindexes = new ListTerm(new IntegerTerm(Indexes[0]),
new ListTerm(new IntegerTerm(Indexes[1]),
new ListTerm(new IntegerTerm(Indexes[2]),
new ListTerm(new IntegerTerm(Indexes[3]),
new ListTerm(new IntegerTerm(Indexes[4]),
new ListTerm(new IntegerTerm(Indexes[5]),
new ListTerm(new IntegerTerm(Indexes[6]), SymbolTerm.MakeSymbol("[]"))))))));
ListTerm lpositions = new ListTerm(new IntegerTerm(Positions[0]),
new ListTerm(new IntegerTerm(Positions[1]),
new ListTerm(new IntegerTerm(Positions[2]),
new ListTerm(new IntegerTerm(Positions[3]),
new ListTerm(new IntegerTerm(Positions[4]),
new ListTerm(new IntegerTerm(Positions[5]), SymbolTerm.MakeSymbol("[]")))))));
#endregion
FPEngine.SetPredicate(new Deldb_0(new ReturnCs(FPEngine)));
if (!FPEngine.Call())
{
aReturnString = "false";
return aReturnString;
}
FPEngine.Success();
StructureTerm a;
Term[] args = { lpositions };
a = new StructureTerm(SymbolTerm.MakeSymbol("availablePositions", 1), args);
FPEngine.SetPredicate(new Assert_1(a, new ReturnCs(FPEngine)));
if (FPEngine.Call())
{
FPEngine.Success();
Term[] argss = { lindexes };
a = new StructureTerm(SymbolTerm.MakeSymbol("availableIndexs", 1), argss);
FPEngine.SetPredicate(new Assert_1(a, new ReturnCs(FPEngine)));
if (FPEngine.Call())
{
FPEngine.Success();
S();
VariableTerm Index = new VariableTerm();
VariableTerm Position = new VariableTerm();
VariableTerm Dir = new VariableTerm();
VariableTerm Team = new VariableTerm();
VariableTerm Orientation = new VariableTerm();
String aDirection;
if (FirstRed)
switch (RedPlayer)
{
case GameLevel.Easy:
FPEngine.SetPredicate(new Go_5(Index, Position, Dir, Team, Orientation, new ReturnCs(FPEngine)));
break;
case GameLevel.Normal:
FPEngine.SetPredicate(new GoSmart_5(Index, Position, Dir, Team, Orientation, new ReturnCs(FPEngine)));
break;
case GameLevel.Hard:
break;
}
else
switch (YellowPlayer)
{
case GameLevel.Easy:
FPEngine.SetPredicate(new Go_5(Index, Position, Dir, Team, Orientation, new ReturnCs(FPEngine)));
break;
case GameLevel.Normal:
FPEngine.SetPredicate(new GoSmart_5(Index, Position, Dir, Team, Orientation, new ReturnCs(FPEngine)));
break;
case GameLevel.Hard:
break;
}
if (!FPEngine.Call())
{
aReturnString = "false";
return aReturnString;
}
this.aIndex = (int)Index.ToCsObject();
this.aPosition = (int)Position.ToCsObject();
this.aDirection = (Direction)Dir.ToCsObject();
string or = (string)Orientation.ToCsObject();
if (or == "left")
this.Ori = Ori.left;
else if (or == "leftright")
this.Ori = Ori.leftright;
else if (or == "rightleft")
this.Ori = Ori.rightleft;
else if (or == "right")
this.Ori = Ori.right;
else if (or == "up")
this.Ori = Ori.up;
else if (or == "updown")
this.Ori = Ori.updown;
else if (or == "downup")
this.Ori = Ori.downup;
else if (or == "down")
this.Ori = Ori.down;
else if (or == "non")
this.Ori = Ori.non;
FPEngine.Success();
aReturnString = (string)Team.ToCsObject();
return aReturnString;
}
}
aReturnString = "false";
return aReturnString;
}
private void S()
{
VariableTerm l1 = new VariableTerm();
VariableTerm l2 = new VariableTerm();
VariableTerm l3 = new VariableTerm();
FPEngine.SetPredicate(new Available_Indexs_1(l1, new ReturnCs(FPEngine)));
if (FPEngine.Call())
{
object m = 0;
FPEngine.Success();
}
int l = 0;
}
private static ISparqlExpression BuildFunctionExpression(SingleValueFunctionCallNode functionOperator)
{
var funcName = functionOperator.Name;
string[] funcNames = { "contains", "endswith", "startswith", "length", "tolower", "toupper",
"substring", "replace", "concat", "indexof", "trim", "year", "day","month", "hour", "minute",
"second", "now", "ceiling", "floor", "round", };
if (!funcNames.Contains(funcName))
{
throw new NotImplementedException($"Function {funcName} not implemented.");
}
if (funcName == "now") // NOW() in sparql does not work, will generate this now in .net instead.
{
ISparqlExpression exp = new NowFunction();
return((new UnaryExpressionFilter(exp)).Expression);
}
var parameter = functionOperator.Parameters.ElementAt(0);
ISparqlExpression valueTerm = null;
if (parameter.GetType() == typeof(SingleValuePropertyAccessNode))
{
valueTerm = new VariableTerm($"?{(parameter as SingleValuePropertyAccessNode).Property.Name}");
}
else if (parameter.GetType() == typeof(SingleValueFunctionCallNode))
{
valueTerm = BuildFunctionExpression(parameter as SingleValueFunctionCallNode);
}
if (funcName == "length")
{
return((new UnaryExpressionFilter(new StrLenFunction(valueTerm))).Expression);
}
else if (funcName == "tolower")
{
return((new UnaryExpressionFilter(new LCaseFunction(valueTerm))).Expression);
}
else if (funcName == "toupper")
{
return((new UnaryExpressionFilter(new UCaseFunction(valueTerm))).Expression);
}
else if (funcName == "year")
{
return((new UnaryExpressionFilter(new YearFunction(valueTerm))).Expression);
}
else if (funcName == "day")
{
return((new UnaryExpressionFilter(new DayFunction(valueTerm))).Expression);
}
else if (funcName == "month")
{
return((new UnaryExpressionFilter(new MonthFunction(valueTerm))).Expression);
}
else if (funcName == "hour")
{
return((new UnaryExpressionFilter(new HoursFunction(valueTerm))).Expression);
}
else if (funcName == "minute")
{
return((new UnaryExpressionFilter(new MinutesFunction(valueTerm))).Expression);
}
else if (funcName == "second")
{
return((new UnaryExpressionFilter(new SecondsFunction(valueTerm))).Expression);
}
else if (funcName == "ceiling")
{
return((new UnaryExpressionFilter(new CeilFunction(valueTerm))).Expression);
}
else if (funcName == "floor")
{
return((new UnaryExpressionFilter(new FloorFunction(valueTerm))).Expression);
}
else if (funcName == "round")
{
return((new UnaryExpressionFilter(new RoundFunction(valueTerm))).Expression);
}
else
{
var constant = functionOperator.Parameters.ElementAt(1) as ConstantNode;
ConstantTerm constantTerm = new ConstantTerm(CreateLiteralNode(constant));
if (funcName == "contains")
{
return((new UnaryExpressionFilter(new ContainsFunction(valueTerm, constantTerm))).Expression);
}
else if (funcName == "endswith")
{
return((new UnaryExpressionFilter(new StrEndsFunction(valueTerm, constantTerm))).Expression);
}
else if (funcName == "startswith")
{
return((new UnaryExpressionFilter(new StrStartsFunction(valueTerm, constantTerm))).Expression);
}
else if (funcName == "concat")
{
return((new UnaryExpressionFilter(new ConcatFunction(new List <ISparqlExpression> {
valueTerm, constantTerm
}))).Expression);
}
else if (funcName == "indexof")
{
throw new NotImplementedException("Sparql does not have counterpart of indexof function.");
}
else if (funcName == "trim")
{
throw new NotImplementedException("Sparql needs regex to do trim.");
}
else if (funcName == "substring")
{
if (functionOperator.Parameters.Count() > 2)
{
var constant2 = functionOperator.Parameters.ElementAt(2) as ConstantNode;
ConstantTerm constantTerm2 = new ConstantTerm(CreateLiteralNode(constant2));
return((new UnaryExpressionFilter(new SubStrFunction(valueTerm, constantTerm, constantTerm2))).Expression);
}
else
{
return((new UnaryExpressionFilter(new SubStrFunction(valueTerm, constantTerm))).Expression);
}
}
else if (funcName == "replace")
{
var constant2 = functionOperator.Parameters.ElementAt(2) as ConstantNode;
ConstantTerm constantTerm2 = new ConstantTerm(CreateLiteralNode(constant2));
return((new UnaryExpressionFilter(new ReplaceFunction(valueTerm, constantTerm, constantTerm2))).Expression);
}
}
return(null);
}
public AggregateExpression Min(VariableTerm variable)
{
var aggregate = new MinAggregate(variable, _distinctAggregate);
return(new AggregateExpression(aggregate));
}
public AggregateExpression Avg(VariableTerm variable)
{
var aggregate = new AverageAggregate(variable, _distinctAggregate);
return(new AggregateExpression(aggregate));
}
public AggregateExpression Sum(VariableTerm variable)
{
var sumAggregate = new SumAggregate(variable, _distinctAggregate);
return(new AggregateExpression(sumAggregate));
}
