static PolicyOperator()
{
var logicalAnd = new Logical_And();
LOGICAL_AND = new LogicalAnd <T>(logicalAnd, LogicalAndDelegate());
TokenOperatorMap[LOGICAL_AND.GetHashCode()] = LOGICAL_AND;
var logicalOr = new LogicalOr();
LOGICAL_OR = new LogicalOr <T>(logicalOr, LogicalOrDelegate());
TokenOperatorMap[LOGICAL_OR.GetHashCode()] = LOGICAL_OR;
var size = new Size();
SIZE = new Size <T>(size, SizeDelegate());
TokenOperatorMap[SIZE.GetHashCode()] = SIZE;
var logicalNot = new Logical_Not();
LOGICAL_NOT = new Not <T>(logicalNot, LogicalNotDelegate());
TokenOperatorMap[LOGICAL_NOT.GetHashCode()] = LOGICAL_NOT;
var uriValid = new Uri_Valid();
URI_VALIDATE = new UriValid <T>(uriValid);
TokenOperatorMap[URI_VALIDATE.GetHashCode()] = URI_VALIDATE;
}
public static ObservableCollection <LogicalBase> CreateXorShemaFrame()
{
LogicalBase or = new LogicalOr();
LogicalBase andOne = new LogicalAnd();
LogicalBase not = new LogicalNot();
LogicalBase andTwo = new LogicalAnd();
LogicalBase spaceOne = new LogicalSpace();
LogicalBase spaceTwo = new LogicalSpace();
or.Outputs[0].AttachObserver(andTwo.Inputs[0]);
not.Outputs[0].AttachObserver(andTwo.Inputs[1]);
not.Inputs[0].AttachObservable(andOne.Outputs[0]);
spaceOne.Outputs[0].AttachObserver(or.Inputs[0]);
spaceOne.Outputs[0].AttachObserver(andOne.Inputs[0]);
spaceTwo.Outputs[0].AttachObserver(or.Inputs[1]);
spaceTwo.Outputs[0].AttachObserver(andOne.Inputs[1]);
return(new ObservableCollection <LogicalBase>()
{
or, not, andOne, andTwo, spaceOne, spaceTwo
});
}
public override bool Visit(LogicalOr node)
{
traverse(node.left);
outputCode(" | ", false, false);
traverse(node.right);
//Visit((LogicalBinaryExpression) node);
return(true);
}
public void CreatingMultiInputsElementOr()
{
LogicalBase or = new LogicalOr(3);
Switch switchOne = new Switch();
Switch switchTwo = new Switch();
Switch switchThree = new Switch();
or.Inputs[0].AttachObservable(switchOne.Output);
or.Inputs[1].AttachObservable(switchTwo.Output);
or.Inputs[2].AttachObservable(switchThree.Output);
switchOne.Switching();
Assert.AreEqual(true, or.Outputs[0].SignalValue);
}
public void LogicalOrWorkTest()
{
Switch switchOne = new Switch();
Switch switchTwo = new Switch();
LogicalBase or = new LogicalOr();
switchOne.Output.AttachObserver(or.Inputs[0]);
switchTwo.Output.AttachObserver(or.Inputs[1]);
switchOne.Switching();
Assert.AreEqual(true, or.Outputs[0].SignalValue);
switchTwo.Switching();
Assert.AreEqual(true, or.Outputs[0].SignalValue);
switchOne.Switching();
Assert.AreEqual(true, or.Outputs[0].SignalValue);
switchTwo.Switching();
Assert.AreEqual(false, or.Outputs[0].SignalValue);
}
void LogicOr(out Expression exp)
{
Expression second;
LogicAnd(out exp);
while (la.kind == 26)
{
Get();
Token tok = t;
LogicAnd(out second);
if (!ExpectBool(exp, tok, false))
{
return;
}
if (!ExpectBool(second, tok, true))
{
return;
}
exp = new LogicalOr((TypedExpression <bool>)exp, (TypedExpression <bool>)second);
}
}
object Evaluate(LogicalOr o)
{
return((bool)Evaluate(o.Left) || (bool)Evaluate(o.Right));
}
public virtual T Visit(LogicalOr node)
{
return(Visit((LogicalBinaryExpression)node));
}
public virtual void Visit(LogicalOr node)
{
}
public override bool Visit(LogicalOr node)
{
Visit((LogicalBinaryExpression)node);
return(true);
}
public override BaseType Visit(LogicalOr node)
{
StoreExpr(node);
EnsureOfType <BoolType>(node.Left.Accept(this), node.Right.Accept(this));
return(new BoolType());
}
public virtual T Visit(LogicalOr node)
{
return(VisitBinary(node));
}
public virtual void Visit(LogicalOr node)
{
}
void LogicOr(out Expression exp)
{
Expression second;
LogicAnd(out exp);
while (la.kind == 26) {
Get();
Token tok = t;
LogicAnd(out second);
if (!ExpectBool(exp, tok, false)) { return; }
if (!ExpectBool(second, tok, true)) { return; }
exp = new LogicalOr((TypedExpression<bool>)exp, (TypedExpression<bool>)second);
}
}
private Expression ParseOrExpression(TokenSet followers)
//^ ensures followers[this.currentToken] || this.currentToken == Token.EndOfFile;
{
TokenSet followerOrOr = followers|Token.Or;
Expression result = this.ParseAndExpression(followerOrOr);
while (this.currentToken == Token.Or) {
SourceLocationBuilder slb = new SourceLocationBuilder(result.SourceLocation);
this.GetNextToken();
Expression operand2 = this.ParseAndExpression(followerOrOr);
slb.UpdateToSpan(operand2.SourceLocation);
result = new LogicalOr(result, operand2, slb);
}
//^ assume followers[this.currentToken] || this.currentToken == Token.EndOfFile;
return result;
}
public override string Visit(LogicalOr node)
{
return(VisitBinary("||", node));
}
