'Best practice' - separating packages, classes, methods.

Question

I'm writing a few tools for handling classical propositional logic sentences.
I currently have a parser (using JavaCC)
Various reasoning methods (e.g. finding whether sentences are satisfiable or a contradition, whether two sentences are equivalent, converting to conjunctive/disjunctive normal form etc.)
I can export/import sentences to/from XML
I'm now coming to a tidying up stage. I'm using Eclipse 3.3 and within the project have 4 packages: logic, parser, xml, testing.
The tree data structures are created using the JavaCC parser - because I want to leave the JavaCC generated code alone as much as possible I've created a 'LogicOperations' class containing the methods.
I also have an 'Interpretation' class that holds a TRUE/FALSE value for each atom, e.g. if storing an example where a sentence is satisfiable (= evaluates to true).
Most of the methods that take an Interpretation as an argument are held inside the 'LogicOperations' class too currently.
So in a test class I might have
LogicParser parser = new LogicParser(new StringReader("a | (b & c) => !d"));
SimpleNode root = parser.query();
//displays the above String in it's tree form
root.dump();
// List atoms in sentence
System.out.println(Arrays.toString(LogicOperations.identifyAtoms(root)));
// Show models (interpretations where sentence is TRUE)
LogicOperations.printInterpretations(LogicOperations.models(root));
// is the sentence satisfiable?
System.out.println("Satisfiable: " + LogicOperations.isSatisfiable(root));
// is the sentence a contradiction?
System.out.println("Contradiction: " + LogicOperations.isContradiction(root));
// Is the sentence consistent (a tautology)
System.out.println("Consistent: " + LogicOperations.isConsistent(root));
System.out.println("CNF: " + LogicOperations.printCNF(root));
System.out.println("DNF: " + LogicOperations.printDNF(root));Question is - does separating out methods, classes and packages in this way seem the 'correct' way of doing things? It works, which is nice... but is it sloppy, lazy, bad practice, you name it...
If any example code is worth seeing let me know, but I'm mainly after advice before I go about tidying the code up.
Thanks in advance
Duncan

Answer 1

eknight wrote:
My intuition would be to be able to call:
root.isSatisfiable()Instead of having to go through a helper Method. The Functionality could still remain in LogicOperations, but I would encapsulate it all in the SimpleNode Class.
- Just MHOThe SimpleNode class is one of a number of classes generated by JavaCC. My thinking was that if there are any modifications to the grammar then SimpleNode would be regenerated and the additional methods would need to be added back in, whereas if they're in a separate class it would mean I wouldn't have to worry about it. In the same vein, I have the eval() method separate from SimpleNode, and most other methods rely on it for their output.
public static Boolean eval(SimpleNode root, Interpretation inter) {
     Boolean val = null;
     SimpleNode left = null;
     SimpleNode right = null;
     switch (root.jjtGetNumChildren()) {
     case 1:
          left = root.jjtGetChild(0);
          right = null;
          break;
     case 2:
          left = root.jjtGetChild(0);
          right = root.jjtGetChild(1);
          break;
     default:
          break;
     switch (root.getID()) {
     case LogicParserTreeConstants.JJTROOT:
          val = eval(left, inter);
          break;
     case LogicParserTreeConstants.JJTVOID:
          val = null;
          break;
     case LogicParserTreeConstants.JJTCOIMP:
          val = (eval(left, inter) == eval(right, inter));
          break;
     case LogicParserTreeConstants.JJTIMP:
          val = (!eval(left, inter) || eval(right, inter));
          break;
     case LogicParserTreeConstants.JJTOR:
          val = (eval(left, inter) || eval(right, inter));
          break;
     case LogicParserTreeConstants.JJTAND:
          val = (eval(left, inter) && eval(right, inter));
          break;
     case LogicParserTreeConstants.JJTNOT:
          val = !eval(left, inter);
          break;
     case LogicParserTreeConstants.JJTATOM:
          val = inter.get(root.getLabel());
          break;
     case LogicParserTreeConstants.JJTCONSTFALSE:
          val = false;
          break;
     case LogicParserTreeConstants.JJTCONSTTRUE:
          val = true;
          break;
     default:
          val = null;
          break;
     return val;
}