public override void Visit(OrExpression expression)
{
_expressionString.Append(" (");
Visit(expression.Left);
_expressionString.Append(" || ");
Visit(expression.Right);
_expressionString.Append(") ");
}
public virtual void Visit(OrExpression expression)
{
expression.Left().Accept(this);
var left = _constraint;
expression.Right().Accept(this);
left.Or(_constraint);
_constraint = left;
}
private Expression CreateExpression(List <Token> tokens)
{
Expression currExpression = null;
if (mTokenIdx >= tokens.Count)
{
return(currExpression);
}
if (tokens[mTokenIdx].mType == eTokenType.TOK_CONDITION)
{
currExpression = new ConditionExpression(tokens[mTokenIdx].mIndex);
mExpressions.Add(currExpression);
}
else if (tokens[mTokenIdx].mType == eTokenType.TOK_OPEN_PAREN)
{
mTokenIdx += 1;
currExpression = CreateExpression(tokens);
}
else if (tokens[mTokenIdx].mType == eTokenType.TOK_NOT)
{
mTokenIdx += 1;
Expression childExpression = CreateExpression(tokens);
Expression expression = new NotExpression(childExpression);
mExpressions.Add(expression);
currExpression = expression;
}
// Right Expressions
if (mTokenIdx + 1 >= tokens.Count)
{
return(currExpression);
}
mTokenIdx += 1;
if (tokens[mTokenIdx].mType == eTokenType.TOK_AND)
{
mTokenIdx += 1;
Expression childA = currExpression;
Expression childB = CreateExpression(tokens);
Expression expression = new AndExpression(childA, childB);
mExpressions.Add(expression);
currExpression = expression;
}
else if (tokens[mTokenIdx].mType == eTokenType.TOK_OR)
{
mTokenIdx += 1;
Expression childA = currExpression;
Expression childB = CreateExpression(tokens);
Expression expression = new OrExpression(childA, childB);
mExpressions.Add(expression);
currExpression = expression;
}
return(currExpression);
}
public void TestRightTrueEvaluate()
{
var expression = new OrExpression(
Mock.Of <IExpression>(e => e.Evaluate(It.IsAny <IDictionary <string, object> >()) == (object)false),
Mock.Of <IExpression>(e => e.Evaluate(It.IsAny <IDictionary <string, object> >()) == (object)true),
ExpressiveOptions.None);
Assert.AreEqual(true, expression.Evaluate(null));
}
public override IList GetDataSource()
{
ICriteria crit = DBConnection.Session.CreateCriteria(PersistentType);
if (tipos == null || tipos.Count == 0)
{
crit.Add(new EqExpression("Supertipo", tipo));
}
else if (tipos.Count == 1)
{
crit.Add(new EqExpression("Supertipo", tipos[0]));
}
else
{
if (tipos.Count > 1)
{
OrExpression orExp = null;
ICriterion eqTipo1;
EqExpression eqTipo2;
int i = 0;
for (int j = 0; j < tipos.Count - 1; j++)
{
if (orExp == null)
{
eqTipo1 = new EqExpression("Supertipo", tipos[j]);
}
else
{
eqTipo1 = orExp;
}
eqTipo2 = new EqExpression("Supertipo", tipos[j + 1]);
orExp = new OrExpression(eqTipo1, eqTipo2);
}
crit.Add(orExp);
/*EqExpression eqTipo1 = new EqExpression("Supertipo", tipo);
* EqExpression eqTipoNC = new EqExpression("Supertipo", TiposComprobantesList.NotaCredito);
* OrExpression orExp = new OrExpression(eqTipo1, eqTipoNC);
* crit.Add(orExp);*/
}
}
if (!String.IsNullOrEmpty(estado))
{
crit.Add(new EqExpression("Estado", estado));
}
if (emisionHoy)
{
DateTime fechaDesde = DateTime.Now.Date;
DateTime fechaHasta = DateTime.Now.Date.AddDays(1);
crit.Add(Expression.Between("Emision", fechaDesde, fechaHasta));
}
emisionHoy = false;
return(crit.List());
}
private void DoTestEvaluate(IExpression a, IExpression b, bool expected)
{
// Arrange
IExpression expression = new OrExpression(a, b);
// Act
bool result = expression.Evaluate(null);
// Assert
Assert.AreEqual(expected, result);
}
private static PythonNode Wrap(OrExpression exp, PythonNode parent)
{
var result = new OrExpressionNode(exp)
{
Parent = parent
};
result.AddChild(Wrap(exp.Left, result));
result.AddChild(Wrap(exp.Right, result));
return(result);
}
public void ParseAndOrExpression()
{
IExpression expression = ParseExpression("k==1 && l==1 || j==1");
Assert.IsNotNull(expression);
Assert.IsInstanceOfType(expression, typeof(OrExpression));
OrExpression orexpr = (OrExpression)expression;
Assert.IsInstanceOfType(orexpr.LeftExpression, typeof(AndExpression));
Assert.IsInstanceOfType(orexpr.RightExpression, typeof(CompareExpression));
}
public void Implements_IsEquivalentTo_Correctly(OrExpression first, FilterExpression other, bool expected, string reason)
{
_outputHelper.WriteLine($"First instance : {first}");
_outputHelper.WriteLine($"Second instance : {other}");
// Act
bool actual = first.IsEquivalentTo(other);
// Assert
actual.Should()
.Be(expected, reason);
}
public void Should_parse_OrExpression(string input, OrExpression expected)
{
// Arrange
_outputHelper.WriteLine($"input : '{input}'");
TokenList <FilterToken> tokens = _tokenizer.Tokenize(input);
// Act
OrExpression expression = FilterTokenParser.Or.Parse(tokens);
// Assert
AssertThatShould_parse(expression, expected);
}
public Expression VisitAndConvert(IExpression expression)
{
return(expression switch
{
AndExpression andExpression => VisitAndConvert(andExpression),
CompareExpression compareExpression => VisitAndConvert(compareExpression),
InExpression inExpression => VisitAndConvert(inExpression),
NotExpression notExpression => VisitAndConvert(notExpression),
OrExpression orExpression => VisitAndConvert(orExpression),
AssignExpression assignExpression => VisitAndConvert(assignExpression),
_ => null
});
public void Equals_should_behave_has_expected(OrExpression first, object other, bool expected, string reason)
{
_outputHelper.WriteLine($"First instance : {first}");
_outputHelper.WriteLine($"Second instance : {other}");
// Act
bool actual = first.Equals(other);
// Assert
actual.Should()
.Be(expected, reason);
}
public void Visit(OrExpression expression)
{
var parentArgs = _visitStack.Peek() as QueryPhaseArgs;
var leftArts = new QueryPhaseArgs();
VisitChild(expression.Left, leftArts);
var rightArgs = new QueryPhaseArgs();
VisitChild(expression.Right, rightArgs);
parentArgs.RowResult = leftArts.RowResult || rightArgs.RowResult;
}
public virtual object Walk(OrExpression node)
{
if (Enter(node))
{
node.LeftExpression.Accept(this);
if (node.RightExpression != null)
{
node.RightExpression.Accept(this);
}
}
Exit(node);
return(null);
}
public void TestShortCircuit()
{
var rightHandMock = new Mock <IExpression>();
var expression = new OrExpression(
Mock.Of <IExpression>(e => e.Evaluate(It.IsAny <IDictionary <string, object> >()) == (object)true),
rightHandMock.Object,
new Context(ExpressiveOptions.None));
expression.Evaluate(null);
rightHandMock.Verify(e => e.Evaluate(It.IsAny <IDictionary <string, object> >()), Times.Never);
}
public void Visit(OrExpression expression)
{
foreach (var queryExpression in expression.Expressions)
{
var matcher = new InMemoryRowMatcher(_row, queryExpression, _tableIdentifier);
if (matcher.IsMatch())
{
return;
}
}
_isMatch = false;
}
public void Visit(OrExpression expression)
{
foreach (var queryExpression in expression.Expressions)
{
var matcher = new InMemoryRowMatcher(_row, queryExpression, _tableIdentifier);
if (matcher.IsMatch())
{
return;
}
}
_isMatch = false;
}
/// <summary>
/// Serialize the <see cref="OrExpression"/>
/// </summary>
/// <param name="orExpression">The <see cref="OrExpression"/> to serialize</param>
/// <returns>The <see cref="JObject"/></returns>
private JObject Serialize(OrExpression orExpression)
{
var jsonObject = new JObject();
jsonObject.Add("classKind", this.PropertySerializerMap["classKind"](Enum.GetName(typeof(CDP4Common.CommonData.ClassKind), orExpression.ClassKind)));
jsonObject.Add("excludedDomain", this.PropertySerializerMap["excludedDomain"](orExpression.ExcludedDomain.OrderBy(x => x, this.guidComparer)));
jsonObject.Add("excludedPerson", this.PropertySerializerMap["excludedPerson"](orExpression.ExcludedPerson.OrderBy(x => x, this.guidComparer)));
jsonObject.Add("iid", this.PropertySerializerMap["iid"](orExpression.Iid));
jsonObject.Add("modifiedOn", this.PropertySerializerMap["modifiedOn"](orExpression.ModifiedOn));
jsonObject.Add("revisionNumber", this.PropertySerializerMap["revisionNumber"](orExpression.RevisionNumber));
jsonObject.Add("term", this.PropertySerializerMap["term"](orExpression.Term.OrderBy(x => x, this.guidComparer)));
jsonObject.Add("thingPreference", this.PropertySerializerMap["thingPreference"](orExpression.ThingPreference));
return(jsonObject);
}
/// <see cref="IUsuarioDao.BuscarUsuarios(Usuario)" />
public IList BuscarUsuarios(Usuario templateUsuario)
{
ICriteria criteria = this.HibernateTemplate.Session.CreateCriteria(typeof(Usuario));
OrExpression orExpression = new OrExpression(
new LikeExpression("nombre", templateUsuario.Nombre, MatchMode.Anywhere),
new OrExpression(
new LikeExpression("apodo", templateUsuario.Nombre, MatchMode.Anywhere),
new LikeExpression("nombreCompleto", templateUsuario.Nombre, MatchMode.Anywhere)
)
);
criteria.Add(orExpression);
criteria.AddOrder(new Order("nombre", true));
return(criteria.List());
}
public void Constructor()
{
var termA = new FuzzyTerm("TermA", new MembershipFunction());
var termB = new FuzzyTerm("TermB", new MembershipFunction());
var varA = new FuzzyVariable("Variable A", null, termA);
var varB = new FuzzyVariable("Variable B", null, termB);
var exprA = new ValueExpression(varA, termA);
var exprB = new ValueExpression(varB, termB);
var sut = new OrExpression(exprA, exprB);
Assert.AreEqual(exprA, sut.LeftExpression);
Assert.AreEqual(exprB, sut.RightExpression);
}
public ExprNode ParseLogicalOrExpression()
{
var exp = new OrExpression
{
Token = Next(),
LeftExpression = ParseLogicalAndExpression()
};
if (Next().IsNot(TokenType.LogicalOr))
{
return(exp.LeftExpression);
}
Match(TokenType.LogicalOr);
exp.RightExpression = ParseLogicalOrExpression();
return(exp);
}
public void It_Should_OR_Two_Arguments(bool expected, bool expr1, bool expr2)
{
// Arrange
var expr = new OrExpression();
// Act
var result = expr.Eval(new TemplateContext(), new List <Option <ILiquidValue> >()
{
new LiquidBoolean(expr1),
new LiquidBoolean(expr2)
}).SuccessValue <LiquidBoolean>().BoolValue;
// Assert
Assert.That(result, Is.EqualTo(expected));
}
private IExpression ParseOrLogicalExpression()
{
IExpression expr = this.ParseAndLogicalExpression();
if (expr == null)
{
return(null);
}
while (this.TryParseToken(TokenType.Name, "or"))
{
expr = new OrExpression(expr, this.ParseAndLogicalExpression());
}
return(expr);
}
private IExpression GetExpression <T>(string expressionOne, string expressionTwo)
{
IExpression expression = null;
var eOne = new TerminalExpression(expressionOne);
var eTwo = new TerminalExpression(expressionTwo);
if (typeof(T) == typeof(AndExpression))
{
expression = new AndExpression(eOne, eTwo);
}
else if (typeof(T) == typeof(OrExpression))
{
expression = new OrExpression(eOne, eTwo);
}
return(expression);
}
public void Main()
{
IExpression person1 = new TerminalExpression.TerminalExpression("Kushagra");
IExpression person2 = new TerminalExpression.TerminalExpression("Lokesh");
IExpression isSingle = new OrExpression(person1, person2);
IExpression vikram = new TerminalExpression.TerminalExpression("Vikram");
IExpression committed = new TerminalExpression.TerminalExpression("Committed");
IExpression isCommitted = new AndExpression(vikram, committed);
Console.WriteLine(isSingle.Interpret("Kushagra"));
Console.WriteLine(isSingle.Interpret("Lokesh"));
Console.WriteLine(isSingle.Interpret("Achint"));
Console.WriteLine(isCommitted.Interpret("Committed, Vikram"));
Console.WriteLine(isCommitted.Interpret("Single, Vikram"));
}
public void Reduce_OrWithRightConstantOperand()
{
var expr =
new OrExpression(0, 1,
new AttributeAccessExpression(0, 0, "a"),
new ConstantExpression(0, 2, new IntValue(1)));
var reduced = expr.Accept(_visitor);
Assert.IsInstanceOfType(reduced, typeof(ConstantExpression));
var constant = (ConstantExpression)reduced;
Assert.IsFalse(constant.Value.IsNull);
Assert.AreEqual(0, constant.Line);
Assert.AreEqual(2, constant.Column);
}
public void Reduce_OrWithBothOperandsNull()
{
var expr =
new OrExpression(0, 1,
new ConstantExpression(0, 0, new IntValue(null)),
new ConstantExpression(0, 2, new IntValue(null)));
var reduced = expr.Accept(_visitor);
Assert.IsInstanceOfType(reduced, typeof(ConstantExpression));
var constant = (ConstantExpression)reduced;
Assert.IsTrue(constant.Value.IsNull);
Assert.AreEqual(0, constant.Line);
Assert.AreEqual(0, constant.Column);
}
public void Disjunction_of_multiple_equality_comparisons_is_parsed_into_OrExpression_with_corresponding_property_names_and_values()
{
var pageCount = 123;
var expression = _parser.Parse <Book>(
x => x.AuthorName == "An author name" ||
x.Title == GetTitle() ||
x.PageCount == pageCount ||
x.Isbn == "123-456-789");
var expectedExpression = new OrExpression(
new EqualsExpression(new PropertyExpression("AuthorName", typeof(string)), new ValueExpression("An author name")),
new EqualsExpression(new PropertyExpression("Title", typeof(string)), new ValueExpression("a title")),
new EqualsExpression(new PropertyExpression("PageCount", typeof(int)), new ValueExpression(123)),
new EqualsExpression(new PropertyExpression("Isbn", typeof(string)), new ValueExpression("123-456-789")));
Assert.AreEqual(expectedExpression, expression);
}
private static QueryExpression ParseOr(EntityConfiguration configuration, Tokenizer tokenizer)
{
if (tokenizer.Current == null)
{
throw new InvalidOperationException("Invalid expression!");
}
var expression = ParseAnd(configuration, tokenizer);
while (tokenizer.Current?.Type == TokenType.Or)
{
tokenizer.MoveNext();
expression = new OrExpression(expression, ParseAnd(configuration, tokenizer));
}
return(expression);
}
public void OrBoolean__CorrectValuesReturned(bool lhsValue, bool rhsValue, bool expected)
{
BooleanLiteralExpression lhs = Utilities.GetBoolLitExpression(lhsValue);
BooleanLiteralExpression rhs = Utilities.GetBoolLitExpression(rhsValue);
OrExpression orExpr = new OrExpression(lhs, rhs, 0, 0);
IInterpreterBoolean parent = Substitute.For <IInterpreterBoolean>();
parent.DispatchBoolean(lhs, Arg.Any <List <object> >()).Returns(lhsValue);
parent.DispatchBoolean(rhs, Arg.Any <List <object> >()).Returns(rhsValue);
BooleanHelper booleanHelper = Utilities.GetBooleanHelper(parent);
bool res = booleanHelper.OrBoolean(orExpr, new List <object>());
Assert.AreEqual(expected, res);
}
public override Element VisitBoolStatementExp(SqlParser.BoolStatementExpContext context)
{
var left = Visit(context.l);
int x = 2;
while (x < context.ChildCount)
{
var right = Visit(context.GetChild(x));
left = new OrExpression(CreateParseInfo(context))
{
Left = left, Right = right
};
x += 2;
}
return(left);
}
void IExpressionVisitor.Visit(OrExpression expression)
{
Label labelTrue = generator.DefineLabel();
Label labelEnd = generator.DefineLabel();
expression.LeftChildExpression.AcceptInternal(this);
if (expression.ResultType != DataType.Logic)
{
expression.TrueValue.AcceptInternal(this);
generator.Emit(OpCodes.Ceq);
}
generator.IfTrueGoto(labelTrue);
expression.RightChildExpression.AcceptInternal(this);
generator.Goto(labelEnd);
generator.MarkLabel(labelTrue);
expression.TrueValue.AcceptInternal(this);
generator.MarkLabel(labelEnd);
}
public void GetAndEvaluateOrExpression()
{
OrExpression expression = OrExpression.Instance;
Assert.IsNotNull(expression);
Machine machine = new Machine();
machine.Push(true);
machine.Push(true);
expression.Evaluate(machine);
Assert.AreEqual(1, machine.StackCount);
Assert.IsTrue((bool)machine.Pop());
Assert.AreEqual(0, machine.StackCount);
machine.Push(true);
machine.Push(false);
expression.Evaluate(machine);
Assert.AreEqual(1, machine.StackCount);
Assert.IsTrue((bool)machine.Pop());
Assert.AreEqual(0, machine.StackCount);
machine.Push(false);
machine.Push(true);
expression.Evaluate(machine);
Assert.AreEqual(1, machine.StackCount);
Assert.IsTrue((bool)machine.Pop());
Assert.AreEqual(0, machine.StackCount);
machine.Push(false);
machine.Push(false);
expression.Evaluate(machine);
Assert.AreEqual(1, machine.StackCount);
Assert.IsFalse((bool)machine.Pop());
Assert.AreEqual(0, machine.StackCount);
}
public void VisitOr()
{
var valueExpr1 =
new ValueExpression(
new FuzzyVariable("MyFuzzyVariable1", new NumericVariable("MyNumVariable1")),
new FuzzyTerm("MyTerm1", new MembershipFunction()));
var valueExpr2 =
new ValueExpression(
new FuzzyVariable("MyFuzzyVariable2", new NumericVariable("MyNumVariable2")),
new FuzzyTerm("MyTerm2", new MembershipFunction()));
var orExpr = new OrExpression(valueExpr1, valueExpr2);
var sut = new ToStringVisitor();
var result = sut.Visit(orExpr);
Assert.AreEqual("MyFuzzyVariable1=MyTerm1 || MyFuzzyVariable2=MyTerm2", result);
result = orExpr.Accept(sut);
Assert.AreEqual("MyFuzzyVariable1=MyTerm1 || MyFuzzyVariable2=MyTerm2", result);
}
public void Accept()
{
var termA = new FuzzyTerm("TermA", new MembershipFunction());
var termB = new FuzzyTerm("TermB", new MembershipFunction());
var varA = new FuzzyVariable("Variable A", null, termA);
var varB = new FuzzyVariable("Variable B", null, termB);
var mocks = new MockRepository();
var visitor = mocks.StrictMock<IExpressionVisitor<int>>();
var sut = new OrExpression(new ValueExpression(varA, termA), new ValueExpression(varB, termB));
Expect.Call(visitor.Visit(sut)).Return(42);
mocks.ReplayAll();
var result = sut.Accept(visitor);
Assert.AreEqual(42, result);
mocks.VerifyAll();
}
public virtual object Walk(OrExpression node)
{
if (Enter(node))
{
node.LeftExpression.Accept(this);
if (node.RightExpression != null)
node.RightExpression.Accept(this);
}
Exit(node);
return null;
}
public SingleExpression(TextReader reader)
{
while (reader.Peek() != -1)
{
char c = (char)reader.Peek();
if (c == '(')
{
reader.Read();
Expression = new SingleExpression(reader);
if ((char)reader.Read() != ')')
throw new Exception("Expected )");
}
else if (c == ')')
{
return;
}
else if (c == '[')
{
reader.Read();
Expression = new RangeExpression(reader);
if ((char)reader.Read() != ']')
throw new Exception("Expected ]");
}
else if (c == '{')
{
reader.Read();
Expression = new RepeatExpression(reader) { Expression = Expression };
if ((char)reader.Read() != '}')
throw new Exception("Expected }");
}
else if (c == '|')
{
reader.Read();
Expression = new OrExpression { Left = Expression, Right = new SingleExpression(reader) };
}
else if (c == '.')
{
reader.Read();
Expression = new ConcatExpression { Left = Expression, Right = new SingleExpression(reader).Expression };
}
else if (c == '*')
{
reader.Read();
Expression = new StarExpression { Expression = Expression };
}
else if (c == '+')
{
reader.Read();
Expression = new PlusExpression { Expression = Expression };
}
else
{
throw new Exception("Unexpected " + c);
}
}
}
public void VisitOr()
{
var variable1 = new FuzzyVariable("MyFuzzyVariable1", new NumericVariable("MyNumVariable1"));
var variable2 = new FuzzyVariable("MyFuzzyVariable2", new NumericVariable("MyNumVariable2"));
var valueExpr1 =
new ValueExpression(
variable1,
new FuzzyTerm("MyTerm1", new MembershipFunction()));
var valueExpr2 =
new ValueExpression(
variable2,
new FuzzyTerm("MyTerm2", new MembershipFunction()));
var orExpr = new OrExpression(valueExpr1, valueExpr2);
var sut = new GetInvolvedVariables();
var result = sut.Visit(orExpr);
Assert.AreEqual(2, result.Count);
Assert.IsTrue(result.Contains(variable1));
Assert.IsTrue(result.Contains(variable2));
result = orExpr.Accept(sut);
Assert.AreEqual(2, result.Count);
Assert.IsTrue(result.Contains(variable1));
Assert.IsTrue(result.Contains(variable2));
}
public virtual void PostWalk(OrExpression node) { }
public override void PostWalk(OrExpression node) { }
public override void Exit(OrExpression node)
{
level--;
}
public virtual void Exit(OrExpression node)
{
}
private Expression CreateExpression(List<Token> tokens)
{
Expression currExpression = null;
if (mTokenIdx >= tokens.Count)
{
return currExpression;
}
if (tokens[mTokenIdx].mType == eTokenType.TOK_CONDITION)
{
currExpression = new ConditionExpression(tokens[mTokenIdx].mIndex);
mExpressions.Add(currExpression);
}
else if (tokens[mTokenIdx].mType == eTokenType.TOK_OPEN_PAREN)
{
mTokenIdx += 1;
currExpression = CreateExpression(tokens);
}
else if (tokens[mTokenIdx].mType == eTokenType.TOK_NOT)
{
mTokenIdx += 1;
Expression childExpression = CreateExpression(tokens);
Expression expression = new NotExpression(childExpression);
mExpressions.Add(expression);
currExpression = expression;
}
// Right Expressions
if (mTokenIdx + 1 >= tokens.Count)
{
return currExpression;
}
mTokenIdx += 1;
if (tokens[mTokenIdx].mType == eTokenType.TOK_AND)
{
mTokenIdx += 1;
Expression childA = currExpression;
Expression childB = CreateExpression(tokens);
Expression expression = new AndExpression(childA, childB);
mExpressions.Add(expression);
currExpression = expression;
}
else if (tokens[mTokenIdx].mType == eTokenType.TOK_OR)
{
mTokenIdx += 1;
Expression childA = currExpression;
Expression childB = CreateExpression(tokens);
Expression expression = new OrExpression(childA, childB);
mExpressions.Add(expression);
currExpression = expression;
}
return currExpression;
}
public ExprNode ParseLogicalOrExpression()
{
var exp = new OrExpression
{
Token = Next(),
LeftExpression = ParseLogicalAndExpression()
};
if (Next().IsNot(TokenType.LogicalOr))
return exp.LeftExpression;
Match(TokenType.LogicalOr);
exp.RightExpression = ParseLogicalOrExpression();
return exp;
}
// OrExpression
public override bool Walk(OrExpression node) { return Location >= node.StartIndex && Location <= node.EndIndex; }
public override object Walk(OrExpression node)
{
var lv = node.LeftExpression.Accept(this);
Func<object> rvThunk = () => node.RightExpression.Accept(this);
return OpOr(lv, rvThunk);
}
private string GetExpression(OrExpression expression, ref List<OleDbParameter> parameters)
{
return " ( " + GetExpressionDispatch(expression.Children[0], ref parameters) + " OR " +
GetExpressionDispatch(expression.Children[1], ref parameters) + " ) ";
}
internal DateTime AllowAccess(string portName, string moduleName, string username)
{
AssertionExpression resourceAccessAssertion = new AssertionExpression(
new AtomicAssertion(
localAuthority,
new AtomicClaim(
new ResourceAccessFact(
new StringPrincipal("port:" + portName),
new StringPrincipal("mod:" + moduleName),
new PrincipalVariable("$grp"),
new IntegerVariable("$from"),
new IntegerVariable("$to"),
new IntegerVariable("$day"),
new VerbVariable("$amode"),
new IntegerVariable("prio")))));
AssertionExpression groupMembershipAssertion = new AssertionExpression(
new AtomicAssertion(
localAuthority,
new AtomicClaim(
new UserGroupMembershipFact(
new StringPrincipal("usr:"******"$grp")))));
DateTime currTime = DateTime.Now;
int currMinute = currTime.Hour * 100 | currTime.Minute;
Expression minutesMoreThanFrom = new ConstraintExpression(new LessThanOrEqualConstraint(new IntegerVariable("$from"), new IntegerHolder(currMinute)));
Expression minutesLessThanTo = new ConstraintExpression(new LessThanOrEqualConstraint(new IntegerHolder(currMinute), new IntegerVariable("$to")));
Expression minutesInRange = new AndExpression(minutesMoreThanFrom, minutesLessThanTo);
int currDayOfWeek = (int) currTime.DayOfWeek;
Expression noDayOfWeekRestriction = new NotExpression(new ConstraintExpression(new InequalityConstraint(new IntegerVariable("$day"), new IntegerHolder(-1))));
Expression dayOfWeekMatches = new NotExpression(new ConstraintExpression(new InequalityConstraint(new IntegerVariable("$day"), new IntegerHolder(currDayOfWeek))));
Expression dayOfWeekAllowed = new OrExpression(noDayOfWeekRestriction, dayOfWeekMatches);
Query query = new Query(
new AndExpression(
resourceAccessAssertion,
groupMembershipAssertion,
minutesInRange,
dayOfWeekAllowed));
QueryContext context = new QueryContext(localAuthority, policyAssertions, query,
DateTime.UtcNow, new PrincipalIdentifier[] { }, new Uri[] { }, 0, false);
ReadOnlyCollection<Answer> answers = new Microsoft.Secpal.Authorization.QueryEngine().ExecuteQuery(context);
//logger.Log("\nquery: " + query + "\n");
//logger.Log("answers: {0}", answers.Count.ToString());
//foreach (Answer answer in answers)
// logger.Log(answer.Substitution.ToString());
return (answers.Count > 0) ? DateTime.MaxValue : DateTime.MinValue;
}
public virtual bool Enter(OrExpression node)
{
return true;
}
public void Disjunction_of_multiple_equality_comparisons_is_parsed_into_OrExpression_with_corresponding_property_names_and_values()
{
var pageCount = 123;
var expression = _parser.Parse<Book>(
x => x.AuthorName == "An author name" ||
x.Title == GetTitle() ||
x.PageCount == pageCount ||
x.Isbn == "123-456-789");
var expectedExpression = new OrExpression(
new EqualsExpression(new PropertyExpression("AuthorName", typeof(string)), new ValueExpression("An author name")),
new EqualsExpression(new PropertyExpression("Title", typeof(string)), new ValueExpression("a title")),
new EqualsExpression(new PropertyExpression("PageCount", typeof(int)), new ValueExpression(123)),
new EqualsExpression(new PropertyExpression("Isbn", typeof(string)), new ValueExpression("123-456-789")));
Assert.AreEqual(expectedExpression, expression);
}
public override bool Enter(OrExpression node)
{
Print("OrExpression");
level++;
return true;
}
IExpression OrExpression(IBlockNode Scope = null)
{
var left = XorExpression(Scope);
if (laKind != BitwiseOr)
return left;
Step();
var ae = new OrExpression();
ae.LeftOperand = left;
ae.RightOperand = OrExpression(Scope);
return ae;
}
// OrExpression
public override bool Walk(OrExpression node) { return false; }
IExpression ParseAsmOrExpression(IBlockNode Scope, IStatement Parent)
{
var left = ParseAsmXorExpression(Scope, Parent);
while (laKind == BitwiseOr)
{
Step();
var e = new OrExpression();
e.LeftOperand = left;
e.RightOperand = ParseAsmXorExpression(Scope, Parent);
left = e;
}
return left;
}
// OrExpression
public virtual bool Walk(OrExpression node) { return true; }
public ISymbolValue Visit(OrExpression x)
{
return E_MathOp(x);
}
private static AstExpression ParseExpression(Dictionary<string, Pivots.Pivot> pivotVsPivotValues,
GetChoiceDelegate get_choice_fn, string expression) {
AstExpression result = null;
var rxResult = Pivots.ExpressionRx.Match(expression);
if (rxResult.Success) {
var state = ExpressionState.None;
AstExpression current = null;
bool invert = false;
foreach (var item in rxResult.Groups[1].Captures.Cast<Capture>().Select(each => each.Value.Trim()).Where(each => !string.IsNullOrEmpty(each))) {
switch (item[0]) {
case '!':
if (result != null && state == ExpressionState.None) {
throw new ClrPlusException("Invalid expression. (not expression must be separated from previous expression with an operator)");
}
if (item.Length % 2 != 0)
invert = !invert;
continue;
case '&':
case ',':
case '\\':
case '/':
if (state != ExpressionState.None) {
throw new ClrPlusException("Invalid expression. (May not state two operators in a row)");
}
if (result == null) {
throw new ClrPlusException("Invalid expression. (may not start with an operator)");
}
state = ExpressionState.HasAnd;
continue;
case '|':
case '+':
if (state != ExpressionState.None) {
throw new ClrPlusException("Invalid expression. (May not state two operators in a row)");
}
if (result == null) {
throw new ClrPlusException("Invalid expression. (may not start with an operator)");
}
state = ExpressionState.HasOr;
continue;
case '(':
if (result != null && state == ExpressionState.None) {
throw new ClrPlusException("Invalid expression. (nested expression must be separated from previous expression with an operator)");
}
if (item.EndsWith(")")) {
// parse nested expression.
current = ParseExpression(pivotVsPivotValues, get_choice_fn, item.Substring(1, item.Length - 2));
break;
}
throw new ClrPlusException("Mismatched '(' in expression");
default:
if (!Pivots.WordRx.IsMatch(item)) {
throw new ClrPlusException("Invalid characters in expression");
}
if (result != null && state == ExpressionState.None) {
throw new ClrPlusException("Invalid expression. (expression must be separated from previous expression with an operator)");
}
// otherwise, it's the word we're looking for.
//
string choice;
string pivot;
if (get_choice_fn(item, out choice, out pivot)) {
current = new PivotExpression(pivot, choice, false);
break;
}
else if (item.ToLowerInvariant() == "true") {
current = TrueExpression.instance;
break;
}
else if (item.ToLowerInvariant() == "false") {
current = FalseExpression.instance;
break;
}
throw new ClrPlusException(string.Format("Unmatched configuration choice '{0}", item));
}
if (invert)
current = current.Invert();
switch (state) {
case ExpressionState.None:
result = current;
continue;
case ExpressionState.HasAnd:
result = new AndExpression(result, current);
break;
case ExpressionState.HasOr:
result = new OrExpression(result, current);
break;
}
current = null;
state = ExpressionState.None;
}
}
if (result == null)
result = TrueExpression.instance;
return result;
}
public void Visit(OrExpression x)
{
}
