Mercurial > hg > Applications > JavaLite

changeset 98:5bd5c58edfd0

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
make ant happy with public interface ITLNodeFactoryInterface<T extends ITLSolver> extends LogicNodeFactoryInterface<T>
author kono
date Sat, 19 Jan 2008 10:26:32 +0900
parents 07a36431aa14
children 91560a83a1fd
files build.xml src/lite/ITLCommander.java src/lite/ITLNodeFactoryInterface.java src/lite/ITLNodeParser.java src/lite/ITLSolverTest.java src/sbdd/BDDSatisfier.java src/sbdd/SBDDTest.java
diffstat 7 files changed, 71 insertions(+), 68 deletions(-) [+]
line wrap: on
line diff
--- a/build.xml	Sat Jan 19 00:45:24 2008 +0900
+++ b/build.xml	Sat Jan 19 10:26:32 2008 +0900
@@ -7,7 +7,10 @@
   <property name="test" value="sbdd/SBDDTest"/>
 
   <target name="build">
-    <javac encoding="UTF-8" srcdir="src">
+    <javac encoding="UTF-8" srcdir="src" >
+        <sourcepath>
+	 <pathelement path="src"/>
+        </sourcepath>
     </javac>
   </target>
 
--- a/src/lite/ITLCommander.java	Sat Jan 19 00:45:24 2008 +0900
+++ b/src/lite/ITLCommander.java	Sat Jan 19 10:26:32 2008 +0900
@@ -13,12 +13,12 @@
 
 
 	private ITLNodeFactoryInterface<Node> lf;
-	private ITLNodeParser<Node> parser;
+	private ITLNodeParser parser;
 	public BDDSatisfier sat;
 	private TreeMap<Integer,Node> examples;
 	private BDDDiagnosis diag;
 
-	public ITLCommander(ITLNodeFactoryInterface<Node> lf, ITLNodeParser<Node> parser) {
+	public ITLCommander(ITLNodeFactoryInterface<Node> lf, ITLNodeParser parser) {
 		this.lf = lf;
 		this.parser = parser;
 		this.examples = new TreeMap<Integer,Node>();
--- a/src/lite/ITLNodeFactoryInterface.java	Sat Jan 19 00:45:24 2008 +0900
+++ b/src/lite/ITLNodeFactoryInterface.java	Sat Jan 19 10:26:32 2008 +0900
@@ -2,7 +2,7 @@
 
 import parser.LogicNodeFactoryInterface;
 
-public interface ITLNodeFactoryInterface<T> 
+public interface ITLNodeFactoryInterface<T extends ITLSolver> 
       extends LogicNodeFactoryInterface<T> {
 
 	public T chopNode(T former, T later) ;
--- a/src/lite/ITLNodeParser.java	Sat Jan 19 00:45:24 2008 +0900
+++ b/src/lite/ITLNodeParser.java	Sat Jan 19 10:26:32 2008 +0900
@@ -12,25 +12,25 @@
 import sbdd.SBDDFactory;
 
 
-public class ITLNodeParser<Node extends ITLSolver> extends MacroNodeParser<Node> {
+public class ITLNodeParser extends MacroNodeParser<ITLSolver> {
 
-	public ITLNodeFactoryInterface<Node> logicNodeFactory;
-	public ITLNodeScanner<Node> scanner;
-	public ITLCommander<Node> parseCommand;
-	public Node emptyNode;
-	private Node periodNode;
+	public ITLNodeFactoryInterface<ITLSolver> logicITLSolverFactory;
+	public ITLNodeScanner<ITLSolver> scanner;
+	public ITLCommander<ITLSolver> parseCommand;
+	public ITLSolver emptyNode;
+	private ITLSolver periodNode;
 	public String help = "";
 	
-	public ITLNodeParser(ITLNodeFactoryInterface<Node> lf) {
+	public ITLNodeParser(ITLNodeFactoryInterface<ITLSolver> lf) {
 
 		super(lf);
-		logicNodeFactory = lf;
+		logicITLSolverFactory = lf;
 		initialize();
 
-		Token<Node> emptyToken = dict.reserve("empty",TokenID.Empty);
-		emptyNode = emptyToken.value = logicNodeFactory.emptyNode();
+		Token<ITLSolver> emptyToken = dict.reserve("empty",TokenID.Empty);
+		emptyNode = emptyToken.value = logicITLSolverFactory.emptyNode();
 		
-		parseCommand = new ITLCommander<Node>(lf,this);
+		parseCommand = new ITLCommander<ITLSolver>(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<Node>() {
-						public Node exec(Node predicate, Node value, LinkedList<Node> args) {
-	                        Node n = value;
+					new Command<ITLSolver>() {
+						public ITLSolver exec(ITLSolver predicate, ITLSolver value, LinkedList<ITLSolver> args) {
+	                        ITLSolver n = value;
 	                        int length = Integer.parseInt(args.get(0).toString());
 	                        for(int i =0;i<length;i++) {
-	                            n = logicNodeFactory.nextNode(n);
-	                            n=logicNodeFactory.andNode(
-	                            		logicNodeFactory.notNode(
-	                            			logicNodeFactory.emptyNode())
+	                            n = logicITLSolverFactory.nextNode(n);
+	                            n=logicITLSolverFactory.andNode(
+	                            		logicITLSolverFactory.notNode(
+	                            			logicITLSolverFactory.emptyNode())
 	                                		,n);
 	                        }
 	                        return n;
@@ -105,7 +105,7 @@
 			
 			define("^(r)","r"); // interval variable (we cannot handle now)
 			
-			periodNode = logicNodeFactory.variableNode(".", true);
+			periodNode = logicITLSolverFactory.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<Node>() {
+			define("share0(L)","true",50, new Command<ITLSolver>() {
 				@SuppressWarnings("unchecked")
-				public Node exec(Node predicate, Node value, LinkedList<Node> args) {
-					Node allElse = (Node)SBDDFactory.trueSolver;
-					Node allFalse = (Node)SBDDFactory.trueSolver;
-					value= (Node)SBDDFactory.falseSolver;
+				public ITLSolver exec(ITLSolver predicate, ITLSolver value, LinkedList<ITLSolver> args) {
+					ITLSolver allElse = (ITLSolver)SBDDFactory.trueSolver;
+					ITLSolver allFalse = (ITLSolver)SBDDFactory.trueSolver;
+					value= (ITLSolver)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) {
-						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);
+						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);
 					}
 					//return value;
-					return logicNodeFactory.orNode(value,allFalse);
+					return logicITLSolverFactory.orNode(value,allFalse);
 				}
 			});
 
@@ -147,10 +147,10 @@
 
 	@Override
 	public void initialize() {
-		dict = new Dictionary<Node>();
-		scope = new LogicNodeScope<Node>(null,dict);
+		dict = new Dictionary<ITLSolver>();
+		scope = new LogicNodeScope<ITLSolver>(null,dict);
 		initReservedWord();
-		scanner = new ITLNodeScanner<Node>(dict);
+		scanner = new ITLNodeScanner<ITLSolver>(dict);
 		super.scanner = scanner;
 
 		dict.reserve("&",TokenID.Chop);
@@ -174,65 +174,65 @@
 	}
 
 	@Override
-	public Node expr2() {
-		Node n = exprI2();
+	public ITLSolver expr2() {
+		ITLSolver n = exprI2();
 		while(nextToken.type==TokenID.And) {
 			nextToken();
-			n = logicNodeFactory.andNode(n, exprI2()) ;
+			n = logicITLSolverFactory.andNode(n, exprI2()) ;
 		}
 		return n;
 	}
 
 	@Override
-	public Node expr3() {
+	public ITLSolver expr3() {
 		if (nextToken.type == TokenID.Next) {
 			nextToken();
-			return logicNodeFactory.nextNode(expr3());
+			return logicITLSolverFactory.nextNode(expr3());
 		}
-		Node n = super.expr3();
+		ITLSolver n = super.expr3();
 		while(nextToken.type==TokenID.Question) {
 			nextToken();
-			Node cond = n;
-			Node high = expr3();
+			ITLSolver cond = n;
+			ITLSolver high = expr3();
 			if (nextToken.type!=TokenID.Colon) {
 				error(": expected");
-				return logicNodeFactory.trueNode();
+				return logicITLSolverFactory.trueNode();
 			}
 			nextToken();
-			Node low = expr3();
-			n = logicNodeFactory.orNode(
-					logicNodeFactory.andNode(cond, high),
-					logicNodeFactory.andNode(logicNodeFactory.notNode(cond), low));
+			ITLSolver low = expr3();
+			n = logicITLSolverFactory.orNode(
+					logicITLSolverFactory.andNode(cond, high),
+					logicITLSolverFactory.andNode(logicITLSolverFactory.notNode(cond), low));
 		}
 		return n;
 	}
 
 	
 	@Override
-	public Node term() {
+	public ITLSolver term() {
 		if (nextToken.type==TokenID.BParen) {
-			Node predicate = periodNode;
+			ITLSolver predicate = periodNode;
 			nextToken();
-			LinkedList<Node> arg = arguments();
-			return logicNodeFactory.predicateNode(predicate, arg);
+			LinkedList<ITLSolver> arg = arguments();
+			return logicITLSolverFactory.predicateNode(predicate, arg);
 		}
 		return super.term();
 	}
 	
-	public Node exprI2() {
-		Node n = exprM1();
+	public ITLSolver exprI2() {
+		ITLSolver n = exprM1();
 		while(nextToken.type == TokenID.Chop) {
 			nextToken();
-			n = logicNodeFactory.chopNode(n, exprM1());
+			n = logicITLSolverFactory.chopNode(n, exprM1());
 		}
 		return n;
 	}
 
 
 	@Override
-	protected LinkedList<Node> arguments() {
-		Node n;
-		LinkedList<Node> arg = new LinkedList<Node>();
+	protected LinkedList<ITLSolver> arguments() {
+		ITLSolver n;
+		LinkedList<ITLSolver> arg = new LinkedList<ITLSolver>();
 		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 00:45:24 2008 +0900
+++ b/src/lite/ITLSolverTest.java	Sat Jan 19 10:26:32 2008 +0900
@@ -4,16 +4,16 @@
 
 public class ITLSolverTest {
 
-	static ITLNodeParser<ITLSolver> p;
+	static ITLNodeParser p;
 	static ITLNodeScanner<ITLSolver> scan;
 	
 	private ITLSatisfier sat;
-	private ITLNodeParser<ITLSolver> parser;
+	private ITLNodeParser parser;
 	
 	public static void main(String arg[]) {
 		ITLNodeFactoryInterface<ITLSolver> lf = new ITLNodeFactory();
 		
-		p = new ITLNodeParser<ITLSolver>(lf);
+		p = new ITLNodeParser(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<ITLSolver>(lf);
+		parser =new ITLNodeParser(lf);
 		sat = new ITLSatisfier(parser.emptyNode);
 	}
 
--- a/src/sbdd/BDDSatisfier.java	Sat Jan 19 00:45:24 2008 +0900
+++ b/src/sbdd/BDDSatisfier.java	Sat Jan 19 10:26:32 2008 +0900
@@ -20,7 +20,7 @@
 public class BDDSatisfier extends ITLSatisfier implements ExecutorInterface<ITLSolver> {
 
 
-	public ITLNodeParser<ITLSolver> p;
+	public ITLNodeParser p;
 	public SBDDFactory sf;
 
 	public  LinkedList<SBDDEntry> queue;
@@ -46,7 +46,7 @@
 	
 		
 	public void init() {
-		p = new ITLNodeParser<ITLSolver>(new ITLNodeFactory());
+		p = new ITLNodeParser(new ITLNodeFactory()); 
 		sf = new SBDDFactory();
 		edge = 0;
 	}
--- a/src/sbdd/SBDDTest.java	Sat Jan 19 00:45:24 2008 +0900
+++ b/src/sbdd/SBDDTest.java	Sat Jan 19 10:26:32 2008 +0900
@@ -12,7 +12,7 @@
 public class SBDDTest {
 
 
-	ITLNodeParser<ITLSolver> p;
+	ITLNodeParser p;
 	BDDSatisfier sat;
 	SBDDFactory sf;