public SparqlStrStarts(SparqlExpression str, SparqlExpression pattern)
{
switch (NullablePairExt.Get(str.Const, pattern.Const))
{
case NP.bothNull:
Operator = result => str.Operator(result).StartsWith(pattern.Operator(result));
TypedOperator =
result => str.TypedOperator(result).Change(o => o.StartsWith(pattern.Operator(result)));
AggregateLevel = SetAggregateLevel(str.AggregateLevel, pattern.AggregateLevel);
break;
case NP.leftNull:
Operator = result => str.Operator(result).StartsWith(pattern.Const.Content);
TypedOperator = result => str.TypedOperator(result).Change(o => o.StartsWith(pattern.Const.Content));
AggregateLevel = str.AggregateLevel;
break;
case NP.rigthNull:
Operator = result => ((string)str.Const.Content).StartsWith(pattern.Operator(result));
TypedOperator = result => str.Const.Change(o => o.StartsWith(pattern.Operator(result)));
AggregateLevel = pattern.AggregateLevel;
break;
case NP.bothNotNull:
Const = str.Const.Change(o => o.StartsWith(pattern.Const.Content));
break;
default:
throw new ArgumentOutOfRangeException();
}
}
public virtual void Create()
{
var lc = l.Const;
var rc = r.Const;
switch (NullablePairExt.Get(lc, rc))
{
case NP.bothNull:
Operator = result => @operator(l.Operator(result), r.Operator(result));
TypedOperator = result => ApplyTyped(l.TypedOperator(result), r.TypedOperator(result));
AggregateLevel = SetAggregateLevel(l.AggregateLevel, r.AggregateLevel);
break;
case NP.leftNull:
Operator = result => @operator(l.Operator(result), rc.Content);
TypedOperator = result => ApplyTyped(l.TypedOperator(result), rc);
AggregateLevel = l.AggregateLevel;
break;
case NP.rigthNull:
Operator = result => @operator(lc.Content, r.Operator(result));
TypedOperator = result => ApplyTyped(lc, r.TypedOperator(result));
AggregateLevel = r.AggregateLevel;
break;
case NP.bothNotNull:
Const = ApplyTyped(lc, rc);
break;
}
}
public SparqlStringLang(SparqlExpression literalExpression, SparqlExpression langExpression)
{
switch (NullablePairExt.Get(literalExpression.Const, langExpression.Const))
{
case NP.bothNull:
Operator = literalExpression.Operator;
TypedOperator = result => new OV_langstring((string)literalExpression.Operator(result), (string)langExpression.Operator(result));
AggregateLevel = SetAggregateLevel(literalExpression.AggregateLevel, langExpression.AggregateLevel);
break;
case NP.leftNull:
Operator = literalExpression.Operator;
TypedOperator = result => new OV_langstring((string)literalExpression.Operator(result), (string)langExpression.Const.Content);
AggregateLevel = literalExpression.AggregateLevel;
break;
case NP.rigthNull:
Operator = result => literalExpression.Const.Content;
TypedOperator = result => new OV_langstring((string)literalExpression.Const.Content, langExpression.Operator(result));
AggregateLevel = langExpression.AggregateLevel;
break;
case NP.bothNotNull:
Const = new OV_langstring((string)literalExpression.Const.Content, (string)langExpression.Const.Content);
break;
default:
throw new ArgumentOutOfRangeException();
}
}
public SparqlStrAfter(SparqlExpression str, SparqlExpression pattern)
{
// TODO: Complete member initialization
//str.SetExprType(ExpressionTypeEnum.@stringOrWithLang);
//pattern.SetExprType(ExpressionTypeEnum.@stringOrWithLang);
// SetExprType(ExpressionTypeEnum.@stringOrWithLang);
switch (NullablePairExt.Get(str.Const, pattern.Const))
{
case NP.bothNull:
Operator = result => StringAfter(str.Operator(result), pattern.Operator(result));
AggregateLevel = SetAggregateLevel(str.AggregateLevel, pattern.AggregateLevel);
TypedOperator = result => str.TypedOperator(result).Change(o => StringAfter(o, (string)pattern.TypedOperator(result).Content));
break;
case NP.leftNull:
Operator = result => StringAfter(str.Operator(result), (string) pattern.Const.Content);
TypedOperator = result => pattern.Const.Change(o => StringAfter(str.Operator(result), o));
AggregateLevel = str.AggregateLevel;
break;
case NP.rigthNull:
Operator = result => StringAfter((string) str.Const.Content, pattern.Operator(result));
TypedOperator = result => str.Const.Change(o => StringAfter(o, (string)pattern.Operator(result).Content));
AggregateLevel = pattern.AggregateLevel;
break;
case NP.bothNotNull:
Const = new OV_bool(StringAfter((string) str.Const.Content, (string) pattern.Const.Content));
break;
default:
throw new ArgumentOutOfRangeException();
}
}
public SparqlStrDataType(SparqlExpression sparqlExpression1, SparqlExpression sparqlExpression2, NodeGenerator q)
{
// TODO: Complete member initialization
switch (NullablePairExt.Get(sparqlExpression1.Const, sparqlExpression2.Const))
{
case NP.bothNull:
TypedOperator = result => q.CreateLiteralNode((string)sparqlExpression1.Operator(result), (string)sparqlExpression2.Operator(result));
Operator = res => sparqlExpression1.Operator(res);
AggregateLevel = SetAggregateLevel(sparqlExpression1.AggregateLevel, sparqlExpression2.AggregateLevel);
break;
case NP.leftNull:
TypedOperator = result => q.CreateLiteralNode((string)sparqlExpression1.Operator(result), (string)sparqlExpression2.Const.Content);
Operator = res => sparqlExpression1.Operator(res);
AggregateLevel = sparqlExpression1.AggregateLevel;
break;
case NP.rigthNull:
TypedOperator = result => q.CreateLiteralNode((string)sparqlExpression1.Const.Content, (string)sparqlExpression2.Operator(result));
Operator = res => sparqlExpression1.Const.Content;
AggregateLevel = sparqlExpression2.AggregateLevel;
break;
case NP.bothNotNull:
Const = q.CreateLiteralNode((string)sparqlExpression1.Const.Content, (string)sparqlExpression2.Const.Content);
break;
default:
throw new ArgumentOutOfRangeException();
}
}
public SparqlStrBefore(SparqlExpression str, SparqlExpression pattern)
{
switch (NullablePairExt.Get(str.Const, pattern.Const))
{
case NP.bothNull:
Operator = result => StringBefore(str.Operator(result), pattern.Operator(result));
AggregateLevel = SetAggregateLevel(str.AggregateLevel, pattern.AggregateLevel);
TypedOperator = result => str.TypedOperator(result).Change(o => StringBefore(o, (string)pattern.TypedOperator(result).Content));
break;
case NP.leftNull:
Operator = result => StringBefore(str.Operator(result), (string)pattern.Const.Content);
TypedOperator = result => pattern.Const.Change(o => StringBefore(str.Operator(result), o));
AggregateLevel = str.AggregateLevel;
break;
case NP.rigthNull:
Operator = result => StringBefore((string)str.Const.Content, pattern.Operator(result));
TypedOperator = result => str.Const.Change(o => StringBefore(o, (string)pattern.Operator(result).Content));
AggregateLevel = pattern.AggregateLevel;
break;
case NP.bothNotNull:
Const = new OV_bool(StringBefore((string)str.Const.Content, (string)pattern.Const.Content));
break;
default:
throw new ArgumentOutOfRangeException();
}
}
public SparqlLangMatches(SparqlExpression value, SparqlExpression langExpression)
{
// value.SetExprType(ObjectVariantEnum.Str); //todo lang
// langExpression.SetExprType(ObjectVariantEnum.Str); //todo lang
switch (NullablePairExt.Get(value.Const, langExpression.Const))
{
case NP.bothNull:
Operator = result =>
{
var lang = value.Operator(result);
var langRange = langExpression.Operator(result);
return(Equals(langRange.Content, "*")
? !string.IsNullOrWhiteSpace(langRange.Content)
: Equals(lang, langRange));
};
AggregateLevel = SetAggregateLevel(value.AggregateLevel, langExpression.AggregateLevel);
break;
case NP.leftNull:
var rlang = langExpression.Const.Content;
Operator = result =>
{
var lang = value.Operator(result);
return(Equals(rlang, "*")
? !string.IsNullOrWhiteSpace(lang)
: Equals(lang, rlang));
};
AggregateLevel = value.AggregateLevel;
break;
case NP.rigthNull:
var llang = value.Const.Content;
if ((llang).Equals("*"))
{
Operator = result => !string.IsNullOrWhiteSpace(langExpression.Operator(result));
}
else
{
Operator = result => Equals(llang, langExpression.Operator(result));
}
AggregateLevel = langExpression.AggregateLevel;
break;
case NP.bothNotNull:
var ll = value.Const.Content;
var rl = langExpression.Const.Content;
Const = new OV_bool(Equals(rl, "*")
? !string.IsNullOrWhiteSpace((string)ll)
: Equals(ll, rl));
break;
default:
throw new ArgumentOutOfRangeException();
}
TypedOperator = result => new OV_bool(Operator(result));
}
// private SparqlExpression sparqlExpression;
public SparqlToString(SparqlExpression child) : base(child.AggregateLevel, child.IsStoreUsed)
{
var childConst = child.Const;
if (childConst != null)
{
Const = new OV_string(childConst.Content.ToString());
}
else
{
Operator = result => child.Operator(result).ToString();
TypedOperator = result => new OV_string(child.Operator(result).ToString());
}
}
public SparqlInCollectionExpression(SparqlExpression itemExpression, List <SparqlExpression> collection)
{
var cConsts = collection.Select(expression => expression.Const).ToArray();
if (itemExpression.Const != null)
{
if (cConsts.Contains(itemExpression.Const))
{
Const = new OV_bool(true);
return;
}
if (cConsts.All(c => c != null))
{
Const = new OV_bool(false);
return;
}
AggregateLevel = SetAggregateLevel(collection.Select(c => c.AggregateLevel).ToArray());
}
else
{
AggregateLevel = SetAggregateLevel(itemExpression.AggregateLevel,
SetAggregateLevel(collection.Select(c => c.AggregateLevel).ToArray()));
}
Operator = result =>
{
var o = itemExpression.Operator(result);
return(collection.Any(element => element.Operator(result).Equals(o)));
};
TypedOperator = o => new OV_bool(Operator(o));
//SetExprType(ObjectVariantEnum.Bool);
}
public SparqlTz(SparqlExpression value) : base(value.AggregateLevel, value.IsStoreUsed)
{
if (value.Const != null)
{
var f = value.Const.Content;
if (f is DateTimeOffset)
{
Const = new OV_string(((DateTimeOffset)f).Offset.ToString());
}
else if (f is DateTime)
{
Const = new OV_string("");
}
throw new ArgumentException();
}
else
{
Operator = result =>
{
var f = value.Operator(result);
if (f is DateTimeOffset)
{
return(((DateTimeOffset)f).Offset.ToString());
}
else if (f is DateTime)
{
return("");
}
throw new ArgumentException();
};
TypedOperator = result => new OV_string(Operator(result));
}
}
public SparqlLCase(SparqlExpression value) : base(value.AggregateLevel, value.IsStoreUsed)
{
if (value.Const != null)
{
Const = value.Const.Change(o => o.ToLower());
}
else
{
Operator = result => value.Operator(result).ToLower();
TypedOperator = result => value.TypedOperator(result).Change(o => o.ToLower());
}
}
protected void Create(SparqlExpression value)
{
if (value.Const != null)
{
Const = new OV_string(CreateHash((string)value.Const.Content));
}
else
{
Operator = result => CreateHash(value.Operator(result));
TypedOperator = result => new OV_string(Operator(result));
}
}
public SparqlMonth(SparqlExpression value) : base(value.AggregateLevel, value.IsStoreUsed)
{
if (value.Const != null)
{
Const = new OV_int(GetMonth(value.Const.Content));
}
else
{
Operator = result => GetMonth(value.Operator(result));
TypedOperator = result => new OV_int(Operator(result));
}
}
public SparqlUri(SparqlExpression value, RdfQuery11Translator q) : base(value.AggregateLevel, value.IsStoreUsed)
{
if (value.Const != null)
{
Const = new OV_iri(q.prolog.GetFromString((string)value.Const.Content));
}
else
{
Operator = result => new OV_iri(q.prolog.GetFromString((string)value.Operator(result).Content));
//SetExprType(ObjectVariantEnum.Iri);
TypedOperator =
result => new OV_iri(q.prolog.GetFromString((string)value.TypedOperator(result).Content));
}
}
public SparqlEncodeForUri(SparqlExpression value, RdfQuery11Translator q) : base(value.AggregateLevel, value.IsStoreUsed)
{
//SetExprType(ObjectVariantEnum.Str);
// value.SetExprType(ExpressionTypeEnum.stringOrWithLang);
if (value.Const != null)
{
Const = new OV_string(HttpUtility.UrlEncode((string)value.Const.Content));
}
else
{
Operator = result => HttpUtility.UrlEncode((string)value.Operator(result).Content);
TypedOperator = result => new OV_string(Operator(result));
}
}
public void SetStartPosition(SparqlExpression value)
{
startExpression = value;
switch (NullablePairExt.Get(strExpression.Const, startExpression.Const))
{
case NP.bothNull:
Operator = result => strExpression.Operator(result).Substring(startExpression.Operator(result));
TypedOperator =
result =>
strExpression.TypedOperator(result)
.Change(o => o.Substring(startExpression.Operator(result)));
AggregateLevel = SetAggregateLevel(strExpression.AggregateLevel, startExpression.AggregateLevel);
break;
case NP.leftNull:
Operator = result => strExpression.Operator(result).Substring(startExpression.Const.Content);
TypedOperator =
result => startExpression.Const.
Change(o => strExpression.Operator(result).Substring(o));
AggregateLevel = strExpression.AggregateLevel;
break;
case NP.rigthNull:
Operator = result => ((string)strExpression.Const.Content).Substring(startExpression.Operator(result));
TypedOperator = result => strExpression.Const.Change(o => o.Substring(startExpression.Operator(result)));
AggregateLevel = startExpression.AggregateLevel;
break;
case NP.bothNotNull:
Const = strExpression.Const.Change(o => o.Substring(startExpression.Const.Content));
break;
default:
throw new ArgumentOutOfRangeException();
}
}
public SparqlUnaryExpression(Func <dynamic, dynamic> @operator, SparqlExpression child)
: base(child.AggregateLevel, child.IsStoreUsed)
{
var childConst = child.Const;
if (childConst != null)
{
Const = childConst.Change(@operator(childConst.Content));
}
else
{
Operator = result => @operator(child.Operator(result));
TypedOperator = results => child.TypedOperator(results).Change(@operator);
}
}
public SparqlOrExpression(SparqlExpression l, SparqlExpression r)
{
//l.SetExprType(ObjectVariantEnum.Bool);
//r.SetExprType(ObjectVariantEnum.Bool);
//SetExprType(ObjectVariantEnum.Bool);
switch (NullablePairExt.Get(l.Const, r.Const))
{
case NP.bothNull:
Operator = res => l.Operator(res) || r.Operator(res);
AggregateLevel = SetAggregateLevel(l.AggregateLevel, r.AggregateLevel);
break;
case NP.leftNull:
if ((bool)l.Const.Content)
{
Const = new OV_bool(true);
}
else
{
Operator = r.Operator;
AggregateLevel = r.AggregateLevel;
}
break;
case NP.rigthNull:
if ((bool)r.Const.Content)
{
Const = new OV_bool(true);
}
else
{
Operator = l.Operator;
AggregateLevel = l.AggregateLevel;
}
break;
case NP.bothNotNull:
Const = new OV_bool((bool)l.Const.Content || (bool)r.Const.Content);
break;
default:
throw new ArgumentOutOfRangeException();
}
TypedOperator = result => new OV_bool(Operator(result));
}
internal void SetRegex(SparqlExpression patternExpression)
{
var varConst = variableExpression.Const;
var patternConst = patternExpression.Const;
Regex regex;
switch (NullablePairExt.Get(patternConst, varConst))
{
case NP.bothNull:
break;
case NP.leftNull:
Operator = result =>
{
var pattern = patternExpression.TypedOperator(result).Content;
regex = CreateRegex((string)pattern);
return(regex.IsMatch((string)varConst.Content));
};
AggregateLevel = patternExpression.AggregateLevel;
break;
case NP.rigthNull:
regex = CreateRegex((string)patternConst.Content);
if (varConst != null)
{
Const = new OV_bool(regex.IsMatch((string)varConst.Content));
}
else
{
Operator = result => regex.IsMatch(variableExpression.Operator(result));
AggregateLevel = variableExpression.AggregateLevel;
}
break;
case NP.bothNotNull:
regex = CreateRegex((string)patternConst.Content);
Const = new OV_bool(regex.IsMatch((string)variableExpression.Const.Content));
break;
default:
throw new ArgumentOutOfRangeException();
}
TypedOperator = result => new OV_bool(Operator(result));
}
public SparqlBnode(SparqlExpression value, RdfQuery11Translator q) : base(value.AggregateLevel, value.IsStoreUsed)
{
//IsDistinct = value.IsDistinct;
//value.SetExprType(ObjectVariantEnum.Str);
//SetExprType(ObjectVariantEnum.Iri);
var litConst = value.Const;
if (litConst != null)
{
Operator =
TypedOperator = result => q.Store.NodeGenerator.CreateBlankNode(value.Const.Content + result.Id);
}
else
{
Operator =
TypedOperator = result => q.Store.NodeGenerator.CreateBlankNode(value.Operator(result) + result.Id);
//OvConstruction = o => q.Store.NodeGenerator.CreateBlankNode((string) o);
}
}
public SparqlIf(SparqlExpression conditionExpression1, SparqlExpression sparqlExpression2, SparqlExpression sparqlExpression3)
{
switch (NullableTripleExt.Get(conditionExpression1.Const, sparqlExpression2.Const, sparqlExpression3.Const))
{
case NT.AllNull:
Operator = result =>
{
var condition = conditionExpression1.Operator(result);
if (condition is bool)
{
return((bool)condition ? sparqlExpression2.Operator(result) : sparqlExpression3.Operator(result));
}
throw new ArgumentException();
};
TypedOperator = result =>
{
var condition = conditionExpression1.Operator(result);
if (condition is bool)
{
return((bool)condition ? sparqlExpression2.TypedOperator(result) : sparqlExpression3.TypedOperator(result));
}
throw new ArgumentException();
};
AggregateLevel = SetAggregateLevel(conditionExpression1.AggregateLevel, sparqlExpression2.AggregateLevel, sparqlExpression3.AggregateLevel);
break;
case NT.FirstNotNull:
if ((bool)conditionExpression1.Const.Content)
{
Operator = sparqlExpression2.Operator;
TypedOperator = sparqlExpression2.TypedOperator;
}
else
{
Operator = sparqlExpression3.Operator;
TypedOperator = sparqlExpression3.TypedOperator;
}
AggregateLevel = SetAggregateLevel(sparqlExpression2.AggregateLevel, sparqlExpression3.AggregateLevel);
break;
case NT.SecondNotNull:
Operator = result =>
{
var condition = conditionExpression1.Operator(result);
if (condition is bool)
{
return((bool)condition ? sparqlExpression2.Const.Content : sparqlExpression3.Operator(result));
}
throw new ArgumentException();
};
TypedOperator = result =>
{
var condition = conditionExpression1.Operator(result);
if (condition is bool)
{
return((bool)condition ? sparqlExpression2.Const : sparqlExpression3.TypedOperator(result));
}
throw new ArgumentException();
};
AggregateLevel = SetAggregateLevel(conditionExpression1.AggregateLevel, sparqlExpression3.AggregateLevel);
break;
case NT.ThirdNotNull:
Operator = result =>
{
var condition = conditionExpression1.Operator(result);
if (condition is bool)
{
return((bool)condition ? sparqlExpression2.Operator(result) : sparqlExpression3.Const.Content);
}
throw new ArgumentException();
};
TypedOperator = result =>
{
var condition = conditionExpression1.Operator(result);
if (condition is bool)
{
return((bool)condition ? sparqlExpression2.TypedOperator(result) : sparqlExpression3.Const);
}
throw new ArgumentException();
};
AggregateLevel = SetAggregateLevel(conditionExpression1.AggregateLevel, sparqlExpression2.AggregateLevel);
break;
case (NT)252: //~NT.ThirdNotNull:
if ((bool)conditionExpression1.Const.Content)
{
Const = sparqlExpression2.Const;
}
else
{
Operator = sparqlExpression3.Operator;
TypedOperator = sparqlExpression3.TypedOperator;
}
AggregateLevel = sparqlExpression3.AggregateLevel;
break;
case (NT)253: //~NT.SecondNotNull:
if ((bool)conditionExpression1.Const.Content)
{
Operator = sparqlExpression2.Operator;
TypedOperator = sparqlExpression2.TypedOperator;
}
else
{
Const = sparqlExpression3.Const;
}
AggregateLevel = sparqlExpression2.AggregateLevel;
break;
case (NT)254: //~NT.FirstNotNull:
Operator = result =>
{
var condition = conditionExpression1.Operator(result);
if (condition is bool)
{
return((bool)condition ? sparqlExpression2.Const.Content : sparqlExpression3.Const.Content);
}
throw new ArgumentException();
};
TypedOperator = result =>
{
var condition = conditionExpression1.Operator(result);
if (condition is bool)
{
return((bool)condition ? sparqlExpression2.Const : sparqlExpression3.Const);
}
throw new ArgumentException();
};
AggregateLevel = conditionExpression1.AggregateLevel;
break;
case (NT)255: //~NT.AllNull:
Const = (bool)conditionExpression1.Const.Content ? sparqlExpression2.Const : sparqlExpression3.Const;
AggregateLevel = VariableDependenceGroupLevel.Const;
break;
default:
throw new ArgumentOutOfRangeException();
}
}
// private SparqlUriNode sparqlUriNode;
public SparqlFunctionCall(string sparqlUriNode, SparqlArgs sparqlArgs) : base(SetAggregateLevel(sparqlArgs[0].AggregateLevel), sparqlArgs.Any(expression => expression.IsStoreUsed))
{
// TODO: Complete member initialization
// this.sparqlUriNode = sparqlUriNode;
SparqlExpression arg = sparqlArgs[0];
Func <object, dynamic> f = null;
Func <dynamic, ObjectVariants> ctor = null;
if (Equals(sparqlUriNode, SpecialTypesClass.Bool))
{
f = o =>
{
if (o is string)
{
return(bool.Parse((string)o));
}
if (o is double || o is int || o is float || o is decimal)
{
return(Math.Abs(Convert.ToDouble(o)) > 0);
}
if (o is bool)
{
return((bool)o);
}
throw new ArgumentException();
};
ctor = o => new OV_bool(o);
}
else if (Equals(sparqlUriNode, SpecialTypesClass.Double))
{
f = o =>
{
if (o is string)
{
return(double.Parse(((string)o).Replace(".", ",")));
}
if (o is double || o is int || o is float || o is decimal)
{
return(Convert.ToDouble(o));
}
throw new ArgumentException();
};
ctor = o => new OV_double(o);
}
else if (Equals(sparqlUriNode, SpecialTypesClass.Float))
{
ctor = o => new OV_float(o);
f = o =>
{
var s = o as string;
if (s != null)
{
return(float.Parse(s.Replace(".", ",")));
}
if (o is double || o is int || o is float || o is decimal)
{
return((float)Convert.ToDouble(o));
}
throw new ArgumentException();
};
}
else if (Equals(sparqlUriNode, SpecialTypesClass.Decimal))
{
ctor = o => new OV_decimal(o);
f = o =>
{
var s = o as string;
if (s != null)
{
return(new OV_decimal((decimal.Parse(s.Replace(".", ",")))));
}
if (o is double || o is int || o is float || o is decimal)
{
return(new OV_decimal(Convert.ToDecimal(o)));
}
throw new ArgumentException();
};
}
else if (Equals(sparqlUriNode, SpecialTypesClass.Int))
{
ctor = o => new OV_int(o);
f = o =>
{
var s = o as string;
if (s != null)
{
return(new OV_int((int.Parse(s))));
}
if (o is double || o is int || o is float || o is decimal)
{
return(new OV_int(Convert.ToInt32(o)));
}
throw new ArgumentException();
};
}
else if (Equals(sparqlUriNode, SpecialTypesClass.DateTime))
{
ctor = o => new OV_dateTime(o);
f = o =>
{
var s = o as string;
if (s != null)
{
return(new OV_dateTime(DateTime.Parse(s)));
}
if (o is DateTime)
{
return(o);
}
throw new ArgumentException();
};
}
else if (Equals(sparqlUriNode, SpecialTypesClass.String))
{
ctor = o => new OV_string(o);
f = o => o.ToString();
}
else
{
throw new NotImplementedException("mathod call " + sparqlUriNode);
}
if (arg.Const != null)
{
Const = ctor(f(arg.Const.Content));
}
else
{
Operator = result => f(arg.Operator(result));
TypedOperator = result => ctor(Operator(result));
}
}
internal void SetLength(SparqlExpression lengthExpression)
{
switch (NullableTripleExt.Get(strExpression.Const, startExpression.Const, lengthExpression.Const))
{
case NT.AllNull:
TypedOperator = result => strExpression.TypedOperator(result).Change(o => o.Substring(startExpression.Operator(result), lengthExpression.Operator(result)));
Operator = result => strExpression.Operator(result).Substring(startExpression.Operator(result), lengthExpression.Operator(result));
AggregateLevel = SetAggregateLevel(strExpression.AggregateLevel, startExpression.AggregateLevel, lengthExpression.AggregateLevel);
break;
case NT.FirstNotNull:
TypedOperator = result => strExpression.Const.Change(o => o.Substring(startExpression.Operator(result), lengthExpression.Operator(result)));
Operator = result => ((string)strExpression.Const.Content).Substring(startExpression.Operator(result), lengthExpression.Operator(result));
AggregateLevel = SetAggregateLevel(startExpression.AggregateLevel, lengthExpression.AggregateLevel);
break;
case NT.SecondNotNull:
TypedOperator = result => strExpression.TypedOperator(result).Change(o => o.Substring(startExpression.Const.Content, lengthExpression.Operator(result)));
Operator = result => strExpression.Operator(result).Substring(startExpression.Const.Content, lengthExpression.Operator(result));
AggregateLevel = SetAggregateLevel(strExpression.AggregateLevel, lengthExpression.AggregateLevel);
break;
case NT.ThirdNotNull:
TypedOperator = result => strExpression.TypedOperator(result).Change(o => o.Substring(startExpression.Operator(result), lengthExpression.Const.Content));
Operator = result => strExpression.Operator(result).Substring(startExpression.Operator(result), lengthExpression.Const.Content);
AggregateLevel = SetAggregateLevel(strExpression.AggregateLevel, startExpression.AggregateLevel);
break;
case (NT)254: //~ NT.FirstNotNull
TypedOperator = result => strExpression.TypedOperator(result).Change(o => o.Substring(startExpression.Const.Content, lengthExpression.Const.Content));
Operator = result => strExpression.Operator(result).Substring(startExpression.Const.Content, lengthExpression.Const.Content);
AggregateLevel = strExpression.AggregateLevel;
break;
case (NT)253: //~NT.SecondNotNull
TypedOperator = result => strExpression.Const.Change(o => o.Substring(startExpression.Operator(result), lengthExpression.Const.Content));
Operator = result => ((string)strExpression.Const.Content).Substring(startExpression.Operator(result), (int)lengthExpression.Const.Content);
AggregateLevel = startExpression.AggregateLevel;
break;
case (NT)252: //~ NT.ThirdNotNull
TypedOperator = result => strExpression.Const.Change(o => o.Substring(startExpression.Const.Content, lengthExpression.Operator(result)));
Operator = result => ((string)strExpression.Const.Content).Substring((int)startExpression.Const.Content, lengthExpression.Operator(result));
AggregateLevel = lengthExpression.AggregateLevel;
break;
case (NT)255: //~NT.AllNull
Const = strExpression.Const.Change(o => o.Substring(startExpression.Const.Content, lengthExpression.Const.Content));
break;
default:
throw new ArgumentOutOfRangeException();
}
}
public void Create()
{
if (parametersExpression == null)
{
switch (
NullableTripleExt.Get(stringExpression.Const, patternExpression.Const, replacementExpression.Const))
{
case NT.AllNull:
Operator = res =>
((string)stringExpression.Operator(res)).Replace(
(string)patternExpression.Operator(res),
(string)replacementExpression.Operator(res));
TypedOperator =
res => stringExpression.TypedOperator(res)
.Change(o => ((string)o).Replace((string)patternExpression.Operator(res),
(string)replacementExpression.Operator(res)));
break;
case NT.FirstNotNull:
Operator = res =>
((string)stringExpression.Const.Content).Replace(
(string)patternExpression.Operator(res),
(string)replacementExpression.Operator(res));
TypedOperator =
res => stringExpression.Const
.Change(o => ((string)o).Replace((string)patternExpression.Operator(res),
(string)replacementExpression.Operator(res)));
break;
case NT.SecondNotNull:
Operator = res =>
((string)stringExpression.Operator(res)).Replace(
(string)patternExpression.Const.Content,
(string)replacementExpression.Operator(res));
TypedOperator =
res => stringExpression.TypedOperator(res)
.Change(o => ((string)o).Replace((string)patternExpression.Const.Content,
(string)replacementExpression.Operator(res)));
break;
case NT.ThirdNotNull:
Operator = res =>
((string)stringExpression.Operator(res)).Replace(
(string)patternExpression.Operator(res),
(string)replacementExpression.Const.Content);
TypedOperator =
res => stringExpression.TypedOperator(res)
.Change(o => ((string)o).Replace((string)patternExpression.Operator(res),
(string)replacementExpression.Const.Content));
break;
case ~NT.FirstNotNull:
Operator = res =>
((string)stringExpression.Operator(res)).Replace(
(string)patternExpression.Const.Content,
(string)replacementExpression.Const.Content);
TypedOperator =
res => stringExpression.TypedOperator(res)
.Change(o => ((string)o).Replace((string)patternExpression.Const.Content,
(string)replacementExpression.Const.Content));
break;
case ~NT.SecondNotNull:
Operator = res =>
((string)stringExpression.Const.Content).Replace(
(string)patternExpression.Operator(res),
(string)replacementExpression.Const.Content);
TypedOperator =
res => stringExpression.Const
.Change(o => ((string)o).Replace((string)patternExpression.Operator(res),
(string)replacementExpression.Const.Content));
break;
case ~NT.ThirdNotNull:
Operator = res =>
((string)stringExpression.Const.Content).Replace(
(string)patternExpression.Const.Content,
(string)replacementExpression.Operator(res));
TypedOperator =
res => stringExpression.Const
.Change(o => ((string)o).Replace((string)patternExpression.Const.Content,
(string)replacementExpression.Operator(res)));
break;
case ~NT.AllNull:
Const = stringExpression.Const
.Change(o => ((string)o).Replace((string)patternExpression.Const.Content,
(string)replacementExpression.Const.Content));
break;
default:
throw new ArgumentOutOfRangeException();
}
}
else
{
if (parametersExpression.Const != null)
{
var flags = GetRegexOptions((string)parametersExpression.Const.Content);
switch (
NullableTripleExt.Get(stringExpression.Const, patternExpression.Const,
replacementExpression.Const))
{
case NT.AllNull:
Operator = res => Regex.Replace(
(string)stringExpression.Operator(res),
(string)patternExpression.Operator(res),
(string)replacementExpression.Operator(res),
flags);
TypedOperator =
res => stringExpression.TypedOperator(res)
.Change(o => Regex.Replace(((string)o), (string)patternExpression.Operator(res),
(string)replacementExpression.Operator(res),
flags));
break;
case NT.FirstNotNull:
Operator = res => Regex.Replace(
((string)stringExpression.Const.Content),
(string)patternExpression.Operator(res),
(string)replacementExpression.Operator(res),
flags);
TypedOperator =
res => stringExpression.Const
.Change(o => Regex.Replace(((string)o), (string)patternExpression.Operator(res),
(string)replacementExpression.Operator(res),
flags));
break;
case NT.SecondNotNull:
Operator = res => Regex.Replace(
((string)stringExpression.Operator(res)),
(string)patternExpression.Const.Content,
(string)replacementExpression.Operator(res),
flags);
TypedOperator =
res => stringExpression.TypedOperator(res)
.Change(o => Regex.Replace(((string)o), (string)patternExpression.Const.Content,
(string)replacementExpression.Operator(res),
flags));
break;
case NT.ThirdNotNull:
Operator = res => Regex.Replace(
((string)stringExpression.Operator(res)),
(string)patternExpression.Operator(res),
(string)replacementExpression.Const.Content);
TypedOperator =
res => stringExpression.TypedOperator(res)
.Change(o => Regex.Replace(((string)o), (string)patternExpression.Operator(res),
(string)replacementExpression.Const.Content,
flags));
break;
case ~NT.FirstNotNull:
Operator = res => Regex.Replace(
((string)stringExpression.Operator(res)),
(string)patternExpression.Const.Content,
(string)replacementExpression.Const.Content,
flags);
TypedOperator =
res => stringExpression.TypedOperator(res)
.Change(o => Regex.Replace(((string)o), (string)patternExpression.Const.Content,
(string)replacementExpression.Const.Content,
flags));
break;
case ~NT.SecondNotNull:
Operator = res => Regex.Replace(
((string)stringExpression.Const.Content),
(string)patternExpression.Operator(res),
(string)replacementExpression.Const.Content);
TypedOperator =
res => stringExpression.Const
.Change(o => Regex.Replace(((string)o), (string)patternExpression.Operator(res),
(string)replacementExpression.Const.Content,
flags));
break;
case ~NT.ThirdNotNull:
Operator = res => Regex.Replace(
((string)stringExpression.Const.Content),
(string)patternExpression.Const.Content,
(string)replacementExpression.Operator(res),
flags);
TypedOperator =
res => stringExpression.Const
.Change(o => Regex.Replace(((string)o), (string)patternExpression.Const.Content,
(string)replacementExpression.Operator(res),
flags));
break;
case ~NT.AllNull:
Const = stringExpression.Const
.Change(o => Regex.Replace(((string)o), (string)patternExpression.Const.Content,
(string)replacementExpression.Const.Content,
flags));
break;
default:
throw new ArgumentOutOfRangeException();
}
}
else
{
switch (NullableTripleExt.Get(stringExpression.Const, patternExpression.Const,
replacementExpression.Const))
{
case NT.AllNull:
Operator = res => Regex.Replace(
(string)stringExpression.Operator(res),
(string)patternExpression.Operator(res),
(string)replacementExpression.Operator(res),
patternExpression.Operator(res));
TypedOperator =
res => stringExpression.TypedOperator(res)
.Change(o => Regex.Replace(((string)o), (string)patternExpression.Operator(res),
(string)replacementExpression.Operator(res),
patternExpression.Operator(res)));
break;
case NT.FirstNotNull:
Operator = res => Regex.Replace(
((string)stringExpression.Const.Content),
(string)patternExpression.Operator(res),
(string)replacementExpression.Operator(res),
patternExpression.Operator(res));
TypedOperator =
res => stringExpression.Const
.Change(o => Regex.Replace(((string)o), (string)patternExpression.Operator(res),
(string)replacementExpression.Operator(res),
patternExpression.Operator(res)));
break;
case NT.SecondNotNull:
Operator = res => Regex.Replace(
((string)stringExpression.Operator(res)),
(string)patternExpression.Const.Content,
(string)replacementExpression.Operator(res),
patternExpression.Operator(res));
TypedOperator =
res => stringExpression.TypedOperator(res)
.Change(o => Regex.Replace(((string)o), (string)patternExpression.Const.Content,
(string)replacementExpression.Operator(res),
patternExpression.Operator(res)));
break;
case NT.ThirdNotNull:
Operator = res => Regex.Replace(
((string)stringExpression.Operator(res)),
(string)patternExpression.Operator(res),
(string)replacementExpression.Const.Content);
TypedOperator =
res => stringExpression.TypedOperator(res)
.Change(o => Regex.Replace(((string)o), (string)patternExpression.Operator(res),
(string)replacementExpression.Const.Content,
patternExpression.Operator(res)));
break;
case ~NT.FirstNotNull:
Operator = res => Regex.Replace(
((string)stringExpression.Operator(res)),
(string)patternExpression.Const.Content,
(string)replacementExpression.Const.Content,
patternExpression.Operator(res));
TypedOperator =
res => stringExpression.TypedOperator(res)
.Change(o => Regex.Replace(((string)o), (string)patternExpression.Const.Content,
(string)replacementExpression.Const.Content,
patternExpression.Operator(res)));
break;
case ~NT.SecondNotNull:
Operator = res => Regex.Replace(
((string)stringExpression.Const.Content),
(string)patternExpression.Operator(res),
(string)replacementExpression.Const.Content);
TypedOperator =
res => stringExpression.Const
.Change(o => Regex.Replace(((string)o), (string)patternExpression.Operator(res),
(string)replacementExpression.Const.Content,
patternExpression.Operator(res)));
break;
case ~NT.ThirdNotNull:
Operator = res => Regex.Replace(
((string)stringExpression.Const.Content),
(string)patternExpression.Const.Content,
(string)replacementExpression.Operator(res),
patternExpression.Operator(res));
TypedOperator =
res => stringExpression.Const
.Change(o => Regex.Replace(((string)o), (string)patternExpression.Const.Content,
(string)replacementExpression.Operator(res),
patternExpression.Operator(res)));
break;
case ~NT.AllNull:
Operator = res =>
Regex.Replace((string)stringExpression.Const.Content, (string)patternExpression.Const.Content,
(string)replacementExpression.Const.Content,
patternExpression.Operator(res));
TypedOperator = res => stringExpression.Const
.Change(o => Regex.Replace(((string)o), (string)patternExpression.Const.Content,
(string)replacementExpression.Const.Content,
patternExpression.Operator(res)));
break;
default:
throw new ArgumentOutOfRangeException();
}
}
}
}
