Mercurial > hg > Applications > JavaLite

changeset 100:bf35bebd55ab

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
restore generic (not necearry...)
author kono
date Sat, 19 Jan 2008 10:31:19 +0900
parents 91560a83a1fd
children 3409453bef30
files src/lite/ITLNodeParser.java src/lite/ITLSolverTest.java src/sbdd/BDDSatisfier.java src/sbdd/SBDDTest.java
diffstat 4 files changed, 64 insertions(+), 64 deletions(-) [+]
line wrap: on
line diff
--- a/src/lite/ITLNodeParser.java	Sat Jan 19 10:26:45 2008 +0900
+++ b/src/lite/ITLNodeParser.java	Sat Jan 19 10:31:19 2008 +0900
@@ -12,25 +12,25 @@
 import sbdd.SBDDFactory;
 
 
-public class ITLNodeParser extends MacroNodeParser<ITLSolver> {
+public class ITLNodeParser<Node extends ITLSolver> extends MacroNodeParser<Node> {
 
-	public ITLNodeFactoryInterface<ITLSolver> logicITLSolverFactory;
-	public ITLNodeScanner<ITLSolver> scanner;
-	public ITLCommander<ITLSolver> parseCommand;
-	public ITLSolver emptyNode;
-	private ITLSolver periodNode;
+	public ITLNodeFactoryInterface<Node> logicNodeFactory;
+	public ITLNodeScanner<Node> scanner;
+	public ITLCommander<Node> parseCommand;
+	public Node emptyNode;
+	private Node periodNode;
 	public String help = "";
 	
-	public ITLNodeParser(ITLNodeFactoryInterface<ITLSolver> lf) {
+	public ITLNodeParser(ITLNodeFactoryInterface<Node> lf) {
 
 		super(lf);
-		logicITLSolverFactory = lf;
+		logicNodeFactory = lf;
 		initialize();
 
-		Token<ITLSolver> emptyToken = dict.reserve("empty",TokenID.Empty);
-		emptyNode = emptyToken.value = logicITLSolverFactory.emptyNode();
+		Token<Node> emptyToken = dict.reserve("empty",TokenID.Empty);
+		emptyNode = emptyToken.value = logicNodeFactory.emptyNode();
 		
-		parseCommand = new ITLCommander<ITLSolver>(lf,this);
+		parseCommand = new ITLCommander<Node>(lf,this);
 		
 			define("not(P)","~P");                               // not
 			define("P->Q","(not(P);Q))",101);                         // imply
@@ -55,15 +55,15 @@
 			define("finite"," ~((true & false)))");                 // 
 			// define("length(I)", "true",50,command);            // length operator
 			define("length(I)", "empty",50,                          // length operator
-					new Command<ITLSolver>() {
-						public ITLSolver exec(ITLSolver predicate, ITLSolver value, LinkedList<ITLSolver> args) {
-	                        ITLSolver n = value;
+					new Command<Node>() {
+						public Node exec(Node predicate, Node value, LinkedList<Node> args) {
+	                        Node n = value;
 	                        int length = Integer.parseInt(args.get(0).toString());
 	                        for(int i =0;i<length;i++) {
-	                            n = logicITLSolverFactory.nextNode(n);
-	                            n=logicITLSolverFactory.andNode(
-	                            		logicITLSolverFactory.notNode(
-	                            			logicITLSolverFactory.emptyNode())
+	                            n = logicNodeFactory.nextNode(n);
+	                            n=logicNodeFactory.andNode(
+	                            		logicNodeFactory.notNode(
+	                            			logicNodeFactory.emptyNode())
 	                                		,n);
 	                        }
 	                        return n;
@@ -105,7 +105,7 @@
 			
 			define("^(r)","r"); // interval variable (we cannot handle now)
 			
-			periodNode = logicITLSolverFactory.variableNode(".", true);
+			periodNode = logicNodeFactory.variableNode(".", true);
 			define("help","true",50,parseCommand);
 			define("show","true",50,parseCommand);
 			define("states","true",50,parseCommand);
@@ -113,12 +113,12 @@
 			define("clear","true",50,parseCommand);
 			// only one of the is true (should allow all false case?)
 			define("share(L)","[](share0(L))");
-			define("share0(L)","true",50, new Command<ITLSolver>() {
+			define("share0(L)","true",50, new Command<Node>() {
 				@SuppressWarnings("unchecked")
-				public ITLSolver exec(ITLSolver predicate, ITLSolver value, LinkedList<ITLSolver> args) {
-					ITLSolver allElse = (ITLSolver)SBDDFactory.trueSolver;
-					ITLSolver allFalse = (ITLSolver)SBDDFactory.trueSolver;
-					value= (ITLSolver)SBDDFactory.falseSolver;
+				public Node exec(Node predicate, Node value, LinkedList<Node> args) {
+					Node allElse = (Node)SBDDFactory.trueSolver;
+					Node allFalse = (Node)SBDDFactory.trueSolver;
+					value= (Node)SBDDFactory.falseSolver;
 					LinkedList<ITLSolver> list = args.get(0).arguments();
 					if (list==null) {
 						error("sahre: missing [] argument");
@@ -126,15 +126,15 @@
 					}
 					if (list.isEmpty()) return value;
 					for(ITLSolver n:  list) {
-						ITLSolver n1 = (ITLSolver)n;
-						value = logicITLSolverFactory.bddNode(n1, allElse, value);
-						allElse = logicITLSolverFactory.bddNode(n1, 
-								(ITLSolver)SBDDFactory.falseSolver,allElse);
-						allFalse = logicITLSolverFactory.andNode(
-								logicITLSolverFactory.notNode(n1), allFalse);
+						Node n1 = (Node)n;
+						value = logicNodeFactory.bddNode(n1, allElse, value);
+						allElse = logicNodeFactory.bddNode(n1, 
+								(Node)SBDDFactory.falseSolver,allElse);
+						allFalse = logicNodeFactory.andNode(
+								logicNodeFactory.notNode(n1), allFalse);
 					}
 					//return value;
-					return logicITLSolverFactory.orNode(value,allFalse);
+					return logicNodeFactory.orNode(value,allFalse);
 				}
 			});
 
@@ -147,10 +147,10 @@
 
 	@Override
 	public void initialize() {
-		dict = new Dictionary<ITLSolver>();
-		scope = new LogicNodeScope<ITLSolver>(null,dict);
+		dict = new Dictionary<Node>();
+		scope = new LogicNodeScope<Node>(null,dict);
 		initReservedWord();
-		scanner = new ITLNodeScanner<ITLSolver>(dict);
+		scanner = new ITLNodeScanner<Node>(dict);
 		super.scanner = scanner;
 
 		dict.reserve("&",TokenID.Chop);
@@ -174,65 +174,65 @@
 	}
 
 	@Override
-	public ITLSolver expr2() {
-		ITLSolver n = exprI2();
+	public Node expr2() {
+		Node n = exprI2();
 		while(nextToken.type==TokenID.And) {
 			nextToken();
-			n = logicITLSolverFactory.andNode(n, exprI2()) ;
+			n = logicNodeFactory.andNode(n, exprI2()) ;
 		}
 		return n;
 	}
 
 	@Override
-	public ITLSolver expr3() {
+	public Node expr3() {
 		if (nextToken.type == TokenID.Next) {
 			nextToken();
-			return logicITLSolverFactory.nextNode(expr3());
+			return logicNodeFactory.nextNode(expr3());
 		}
-		ITLSolver n = super.expr3();
+		Node n = super.expr3();
 		while(nextToken.type==TokenID.Question) {
 			nextToken();
-			ITLSolver cond = n;
-			ITLSolver high = expr3();
+			Node cond = n;
+			Node high = expr3();
 			if (nextToken.type!=TokenID.Colon) {
 				error(": expected");
-				return logicITLSolverFactory.trueNode();
+				return logicNodeFactory.trueNode();
 			}
 			nextToken();
-			ITLSolver low = expr3();
-			n = logicITLSolverFactory.orNode(
-					logicITLSolverFactory.andNode(cond, high),
-					logicITLSolverFactory.andNode(logicITLSolverFactory.notNode(cond), low));
+			Node low = expr3();
+			n = logicNodeFactory.orNode(
+					logicNodeFactory.andNode(cond, high),
+					logicNodeFactory.andNode(logicNodeFactory.notNode(cond), low));
 		}
 		return n;
 	}
 
 	
 	@Override
-	public ITLSolver term() {
+	public Node term() {
 		if (nextToken.type==TokenID.BParen) {
-			ITLSolver predicate = periodNode;
+			Node predicate = periodNode;
 			nextToken();
-			LinkedList<ITLSolver> arg = arguments();
-			return logicITLSolverFactory.predicateNode(predicate, arg);
+			LinkedList<Node> arg = arguments();
+			return logicNodeFactory.predicateNode(predicate, arg);
 		}
 		return super.term();
 	}
 	
-	public ITLSolver exprI2() {
-		ITLSolver n = exprM1();
+	public Node exprI2() {
+		Node n = exprM1();
 		while(nextToken.type == TokenID.Chop) {
 			nextToken();
-			n = logicITLSolverFactory.chopNode(n, exprM1());
+			n = logicNodeFactory.chopNode(n, exprM1());
 		}
 		return n;
 	}
 
 
 	@Override
-	protected LinkedList<ITLSolver> arguments() {
-		ITLSolver n;
-		LinkedList<ITLSolver> arg = new LinkedList<ITLSolver>();
+	protected LinkedList<Node> arguments() {
+		Node n;
+		LinkedList<Node> arg = new LinkedList<Node>();
 		while(nextToken.type!=TokenID.CloseParen&&nextToken.type!=TokenID.CloseBParen) {
 			if (nextToken.type==TokenID.NULL) break;
 			n = exprI2();
--- a/src/lite/ITLSolverTest.java	Sat Jan 19 10:26:45 2008 +0900
+++ b/src/lite/ITLSolverTest.java	Sat Jan 19 10:31:19 2008 +0900
@@ -4,16 +4,16 @@
 
 public class ITLSolverTest {
 
-	static ITLNodeParser p;
+	static ITLNodeParser<ITLSolver> p;
 	static ITLNodeScanner<ITLSolver> scan;
 	
 	private ITLSatisfier sat;
-	private ITLNodeParser parser;
+	private ITLNodeParser<ITLSolver> parser;
 	
 	public static void main(String arg[]) {
 		ITLNodeFactoryInterface<ITLSolver> lf = new ITLNodeFactory();
 		
-		p = new ITLNodeParser(lf);
+		p = new ITLNodeParser<ITLSolver>(lf);
 		
 		System.out.println(p.parse("p , ~ q"));
 		System.out.println(p.parse("p=q"));
@@ -45,7 +45,7 @@
 	
 	ITLSolverTest() {
 		ITLNodeFactoryInterface<ITLSolver> lf = new ITLNodeFactory();
-		parser =new ITLNodeParser(lf);
+		parser =new ITLNodeParser<ITLSolver>(lf);
 		sat = new ITLSatisfier(parser.emptyNode);
 	}
 
--- a/src/sbdd/BDDSatisfier.java	Sat Jan 19 10:26:45 2008 +0900
+++ b/src/sbdd/BDDSatisfier.java	Sat Jan 19 10:31:19 2008 +0900
@@ -20,7 +20,7 @@
 public class BDDSatisfier extends ITLSatisfier implements ExecutorInterface<ITLSolver> {
 
 
-	public ITLNodeParser p;
+	public ITLNodeParser<ITLSolver> p;
 	public SBDDFactory sf;
 
 	public  LinkedList<SBDDEntry> queue;
@@ -46,7 +46,7 @@
 	
 		
 	public void init() {
-		p = new ITLNodeParser(new ITLNodeFactory()); 
+		p = new ITLNodeParser<ITLSolver>(new ITLNodeFactory());
 		sf = new SBDDFactory();
 		edge = 0;
 	}
--- a/src/sbdd/SBDDTest.java	Sat Jan 19 10:26:45 2008 +0900
+++ b/src/sbdd/SBDDTest.java	Sat Jan 19 10:31:19 2008 +0900
@@ -12,7 +12,7 @@
 public class SBDDTest {
 
 
-	ITLNodeParser p;
+	ITLNodeParser<ITLSolver> p;
 	BDDSatisfier sat;
 	SBDDFactory sf;