Acting System Submission

.classpath

@@ -7,5 +7,6 @@
 	<classpathentry kind="con" path="org.eclipse.fx.ide.jdt.core.JAVAFX_CONTAINER"/>
 	<classpathentry kind="lib" path="lib/java-cup-11b-runtime.jar"/>
 	<classpathentry kind="lib" path="lib/java-cup-11b.jar"/>
+	<classpathentry kind="lib" path="jarlib/javassist.jar"/>
 	<classpathentry kind="output" path="bin"/>
 </classpath>

src/sneps/acts/Achieve.java

@@ -0,0 +1,95 @@
+package sneps.acts;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+
+import sneps.exceptions.NodeNotFoundInNetworkException;
+import sneps.exceptions.NotAPropositionNodeException;
+import sneps.network.ActNode;
+import sneps.network.Agenda;
+import sneps.network.Network;
+import sneps.network.Node;
+import sneps.network.PropositionNode;
+import sneps.network.VariableNode;
+import sneps.network.classes.CaseFrame;
+import sneps.network.classes.Relation;
+import sneps.network.classes.Wire;
+import sneps.network.classes.setClasses.ChannelSet;
+import sneps.network.classes.setClasses.NodeSet;
+import sneps.snebr.Context;
+import sneps.snebr.Controller;
+import sneps.snip.Runner;
+import sneps.snip.channels.Channel;
+import sneps.snip.channels.RuleToConsequentChannel;
+import sneps.snip.matching.LinearSubstitutions;
+
+public class Achieve extends ActNode{
+	public Achieve() {
+		super();
+	}
+	public void act() throws NotAPropositionNodeException, NodeNotFoundInNetworkException{
+		NodeSet planGoals = new NodeSet();
+		ChannelSet c=new ChannelSet();
+		switch(agenda) {
+		case START:
+			PropositionNode p = (PropositionNode) this.getDownCableSet().getDownCable("obj").getNodeSet().getNode(0);
+			Context context=Controller.getCurrentContext();
+			Boolean asserted=context.isAsserted(p);
+			if(asserted) {
+				return;
+			} else {
+				try {
+					agenda = Agenda.FIND_PLANS;
+					Runner.addToActStack(this);
+					VariableNode x = Network.buildVariableNode();
+					Relation r1 = Relation.plan;
+					Relation r2 = Relation.goal;
+					ArrayList<Wire> array= new ArrayList<>();
+					array.add(new Wire(r1,x));
+					array.add(new Wire(r2,p));
+					Node planGoal = Network.buildMolecularNode(array, CaseFrame.planGoal);
+					planGoals.addNode(planGoal);
+					RuleToConsequentChannel rtcc = new RuleToConsequentChannel(new LinearSubstitutions(), new LinearSubstitutions(),
+							Controller.getCurrentContext().getName(), this, planGoal, true);
+					planGoal.receiveRequest(rtcc);
+					c.addChannel(rtcc);
+
+
+				} catch(Exception e) {
+					System.out.println("SOMETHING WENT WRONG!! EXCEPTION THROWN FROM ACTNODE.JAVA 8");						
+				}
+			}
+			break;
+		case FIND_PLANS:
+			ArrayList<PropositionNode> temp = processReports(c);
+			ArrayList<ActNode> plans=new ArrayList<ActNode>();
+			for(Node t:temp) {
+				plans.add((ActNode)t);
+			}
+			if(!plans.isEmpty()) {
+				try {
+					agenda = Agenda.DONE;
+					ArrayList<Wire> array1=new ArrayList<Wire>();
+					Relation r1 = Relation.obj;
+					Relation r2 = Relation.action;
+					for(int i = 0; i < plans.size(); i++) {
+						array1.add(new Wire(r1,plans.get(i)));
+					}
+					array1.add(new Wire(r2,new DoOne()));
+					ActNode doOne = (ActNode) Network.buildMolecularNode(array1, CaseFrame.act);
+					doOne.restartAgenda();
+					Runner.addToActStack(doOne);
+				} catch(Exception e) {
+					System.out.println("SOMETHING WENT WRONG!! EXCEPTION THROWN FROM ACTNODE.JAVA 9");
+				}
+			} else {
+				System.out.println("Planning Algorithm will conclude the plans");
+			}
+			break;
+		default:
+			System.out.print("UNIDENTIFIED AGENDA FOR ACHIEVE!!");
+			return;
+		}
+	}
+
+}

src/sneps/acts/Believe.java

@@ -0,0 +1,54 @@
+package sneps.acts;
+
+import java.util.HashSet;
+import java.util.Set;
+
+import sneps.exceptions.ContextNameDoesntExistException;
+import sneps.exceptions.ContradictionFoundException;
+import sneps.exceptions.DuplicatePropositionException;
+import sneps.exceptions.NodeNotFoundInNetworkException;
+import sneps.exceptions.NotAPropositionNodeException;
+import sneps.network.ActNode;
+import sneps.network.PropositionNode;
+import sneps.snebr.Controller;
+import sneps.snebr.Support;
+import sneps.snip.Report;
+import sneps.snip.matching.LinearSubstitutions;
+
+
+public class Believe extends ActNode {
+
+
+
+	public Believe() {
+		super();
+	}
+
+	public void act() throws NotAPropositionNodeException, NodeNotFoundInNetworkException {
+		PropositionNode p = (PropositionNode) this.getDownCableSet().getDownCable("obj").getNodeSet().getNode(0);
+		try {
+			Controller.addPropToContext(Controller.getCurrentContext().getName(), p.getId());
+		} catch (NotAPropositionNodeException e) {
+			// TODO Auto-generated catch block
+			System.out.println("SOMETHING WENT WRONG!!, TRYING TO ASSERT NOT A PROPOSITION");
+		} catch (DuplicatePropositionException e) {
+			// TODO Auto-generated catch block
+			System.out.println("SOMETHING WENT WRONG!!, PROPOSITION ALREADY ASSERTED");
+		} catch (NodeNotFoundInNetworkException e) {
+			// TODO Auto-generated catch block
+			System.out.println("SOMETHING WENT WRONG!!");
+		} catch (ContradictionFoundException e) {
+			// TODO Auto-generated catch block
+			System.out.println("SOMETHING WENT WRONG!!, CONTRADICTING PROPOSITION IN BELIEF SPACE");
+		} catch (ContextNameDoesntExistException e) {
+			// TODO Auto-generated catch block
+			System.out.println("SOMETHING WENT WRONG!!");
+		}
+		p.setBasicSupport();
+		Set<Support> ss = new HashSet<>();
+		ss.add(p.getBasicSupport());
+		Report r = new Report(new LinearSubstitutions(), ss, true, Controller.getCurrentContext().getName());
+		p.broadcastReport(r);
+
+	}
+}

src/sneps/acts/Disbelieve.java

@@ -0,0 +1,40 @@
+	package sneps.acts;
+
+import java.util.HashSet;
+import java.util.Set;
+
+import sneps.exceptions.ContextNameDoesntExistException;
+import sneps.exceptions.ContradictionFoundException;
+import sneps.exceptions.DuplicatePropositionException;
+import sneps.exceptions.NodeNotFoundInNetworkException;
+import sneps.exceptions.NodeNotFoundInPropSetException;
+import sneps.exceptions.NotAPropositionNodeException;
+import sneps.network.ActNode;
+import sneps.network.PropositionNode;
+import sneps.snebr.Controller;
+import sneps.snebr.Support;
+import sneps.snip.Report;
+import sneps.snip.matching.LinearSubstitutions;
+
+public class Disbelieve extends ActNode {
+
+
+	public Disbelieve() {
+		super();
+	}
+
+	@Override
+	public void act() throws NotAPropositionNodeException, NodeNotFoundInNetworkException {
+		PropositionNode p = (PropositionNode) this.getDownCableSet().getDownCable("obj").getNodeSet().getNode(0);
+		try {
+			Controller.removePropositionFromAllContexts(p);
+		} catch (NodeNotFoundInPropSetException | NotAPropositionNodeException | NodeNotFoundInNetworkException e) {
+			// TODO Auto-generated catch block
+			System.out.println("SOMETHING WENT WRONG!! PROPOSITION NOT FOUND");
+		}
+
+
+
+	}
+
+}

src/sneps/acts/DoAll.java

@@ -0,0 +1,29 @@
+package sneps.acts;
+
+import java.util.Random;
+import sneps.network.classes.setClasses.NodeSet;
+import sneps.snip.Runner;
+import sneps.network.ActNode;
+
+public class DoAll extends ActNode {
+
+	private static DoAll actuator;
+
+	public DoAll() {
+		super();
+	}
+
+	public void act() {
+		Random rand = new Random();
+		NodeSet acts = this.getDownCableSet().getDownCable("obj").getNodeSet();
+		NodeSet actsCopy = new NodeSet();
+		actsCopy.addAll(acts);
+		while(!actsCopy.isEmpty()) {
+			int nextActIndex = rand.nextInt(actsCopy.size());
+			ActNode nextAct = (ActNode) actsCopy.getNode(nextActIndex);
+			nextAct.restartAgenda();
+			Runner.addToActStack(nextAct);
+			actsCopy.removeNode(nextAct);
+		}
+	}	
+}

src/sneps/acts/DoOne.java

@@ -0,0 +1,25 @@
+package sneps.acts;
+
+import java.util.Random;
+import sneps.network.ActNode;
+import sneps.network.classes.setClasses.NodeSet;
+import sneps.snip.Runner;
+
+public class DoOne extends ActNode {
+	private static DoOne actuator;
+
+	public DoOne() {
+		super();
+	}
+
+	public void act() {
+		Random rand = new Random();
+		NodeSet possibleActs = this.getDownCableSet().getDownCable("obj").getNodeSet();
+		int actIndex = rand.nextInt(possibleActs.size());
+		ActNode act = (ActNode) possibleActs.getNode(actIndex);
+		act.restartAgenda();
+		Runner.addToActStack(act);
+	}
+
+
+}

src/sneps/acts/SNIF.java

@@ -0,0 +1,81 @@
+package sneps.acts;
+
+import java.util.ArrayList;
+
+import sneps.acts.DoOne;
+import sneps.network.ActNode;
+import sneps.network.Agenda;
+import sneps.network.Network;
+import sneps.network.Node;
+import sneps.network.PropositionNode;
+import sneps.network.classes.CaseFrame;
+import sneps.network.classes.Relation;
+import sneps.network.classes.Wire;
+import sneps.network.classes.setClasses.ChannelSet;
+import sneps.network.classes.setClasses.NodeSet;
+import sneps.network.classes.setClasses.ReportSet;
+import sneps.snebr.Controller;
+import sneps.snip.Runner;
+import sneps.snip.channels.AntecedentToRuleChannel;
+import sneps.snip.matching.LinearSubstitutions;
+
+public class SNIF extends ActNode {
+	public SNIF() {
+		super();
+	}
+	public void act(){
+		NodeSet guards = new NodeSet();
+		ChannelSet c=new ChannelSet();
+		switch(agenda) {
+		case START:
+			agenda = Agenda.TEST;
+
+			for(Node n: getDownCableSet().getDownCable("obj").getNodeSet()) {
+				guards.addAll(((Node) n).getDownCableSet().getDownCable("guard").getNodeSet());
+			}
+			for(Node guard: guards) {
+				AntecedentToRuleChannel atrc=new AntecedentToRuleChannel(new LinearSubstitutions(), new LinearSubstitutions(),Controller.getCurrentContext().getName(), this, guard, true);
+				guard.receiveRequest(atrc);
+				c.addChannel(atrc);
+			}
+			break;
+		case TEST:
+			try{
+				agenda = Agenda.DONE;
+				NodeSet allActs = getDownCableSet().getDownCable("obj").getNodeSet();
+				ArrayList<ActNode> possibleActs = new ArrayList<>();
+				ArrayList<PropositionNode> satisfiedGaurds = processReports(c);
+				for(Node act: allActs) {
+					boolean containsAll = true;
+					for(Node n: ((Node) act).getDownCableSet().getDownCable("guard").getNodeSet()) {
+						if(!satisfiedGaurds.contains(n)) {
+							containsAll = false;
+							break;
+						}
+					}
+					if(containsAll) {
+						possibleActs.add((ActNode) act);
+					}
+				}
+				ArrayList<Wire> array= new ArrayList<>();
+				Relation r1 = Relation.obj;
+				Relation r2 = Relation.action;
+				for(int i = 0; i < possibleActs.size(); i++) {
+					array.add(new Wire(r1,possibleActs.get(i)));
+				}
+				array.add(new Wire(r2,new DoOne()));
+				ActNode doOne = (ActNode) Network.buildMolecularNode(array, CaseFrame.act);
+				doOne.restartAgenda();
+				Runner.addToActStack(doOne);
+			} catch(Exception e) {
+				System.out.println("SOMETHING WENT WRONG!! EXCEPTION THROWN FROM ACTNODE.JAVA 10");
+			}
+			break;
+		default:
+			System.out.print("UNIDENTIFIED AGENDA FOR SNiF!!");
+			return;
+		}
+	}
+
+
+}