Coverage Report

Coverage Report - org.kuali.student.common.messagebuilder.impl.SimpleBooleanMessageBuilder

Classes in this File

Line Coverage

Branch Coverage

Complexity

SimpleBooleanMessageBuilder

0/74

0/64

3.429

 package org.kuali.student.common.messagebuilder.impl;
 
 import java.util.ArrayList;
 import java.util.List;
 
 import org.kuali.student.common.messagebuilder.MessageTreeBuilder;
 import org.kuali.student.common.messagebuilder.booleanmessage.ast.BooleanNode;
 import org.kuali.student.common.messagebuilder.impl.exceptions.MessageBuilderException;
 
 /**
  * This class creates success messages for boolean binary tree nodes.
  *
  * Default display is a single line message (e.g. A OR (B AND (C OR D))).  
  * To display as multiple lines where each operator and message is on its own line.
  * set the following:
  * <pre>
  * INDENT_CHAR = ' '
  * INDENT_NUMBER_OF_SPACES = 4
  * BOOLEAN_OPERATOR_PREFIX = "\n"
  * BOOLEAN_OPERATOR_SUFFIX = "\n"
  * Example:
  * </pre>
  * <pre>
  *    MATH101
  * OR
  *        (MATH201
  *    AND
  *            (MATH301
  *        OR
  *            MATH401))
  * </pre>
  */
 public class SimpleBooleanMessageBuilder implements MessageTreeBuilder {
         // Default indentation character
         private final static char INDENT_CHAR = 0;
         // Default number of spaces to indent
         private final static int INDENT_NUMBER_OF_SPACES = 0;
         // Default indentation string
         private final static String INDENT_STRING = getString(INDENT_NUMBER_OF_SPACES, INDENT_CHAR);
         // Default boolean operator prefix string
         private final static String BOOLEAN_OPERATOR_PREFIX = " ";
         // Default boolean operator suffix string
         private final static String BOOLEAN_OPERATOR_SUFFIX = " ";
 
         // Indentation character
         private int indentCharacter = INDENT_CHAR;
         // Number of spaces to indent
         private int indentNumberOfSpaces = INDENT_NUMBER_OF_SPACES;
         // Indentation string
         private String indentString = INDENT_STRING;
         // Boolean operator prefix string
         private String booleanOperatorPrefix = BOOLEAN_OPERATOR_PREFIX;
         // Boolean operator suffix string
         private String booleanOperatorSuffix = BOOLEAN_OPERATOR_SUFFIX;
         
         /** Boolean operators to use in creating the success message */
         private BooleanOperators booleanOperators;
 
         /**
          * Creates a success message builder with boolean operators to use in 
          * building the success message.
          * 
          * @param andOperator AND logical operator
          * @param orOperator OR logical operator
          */
         public SimpleBooleanMessageBuilder(String andOperator, String orOperator) {
                 this.booleanOperators = new BooleanOperators(andOperator, orOperator);
         }
 
         /**
          * Creates a success message builder with boolean operators to use in 
          * building the success message.
          * 
          * @param bo Boolean operators to build success message
          */
         public SimpleBooleanMessageBuilder(BooleanOperators bo) {
                 this.booleanOperators = bo;
         }
 
         public void setIndentCharacter(int indentChar) {
                 this.indentCharacter = indentChar;
         }
 
         public void setIndentNumberOfSpaces(int indentNumberOfSpaces) {
                 this.indentNumberOfSpaces = indentNumberOfSpaces;
         }
 
         public void setIndentString(String indentString) {
                 this.indentString = indentString;
         }
 
         public void setBooleanOperatorPrefix(String booleanOperatorPrefix) {
                 this.booleanOperatorPrefix = booleanOperatorPrefix;
         }
 
         public void setBooleanOperatorSuffix(String booleanOperatorSuffix) {
                 this.booleanOperatorSuffix = booleanOperatorSuffix;
         }
 
         /**
          * Builds and sets the success message for each of the boolean nodes 
          * (binary tree) in the <code>nodeList</code>.
          * 
          * @param nodeList List of boolean nodes 
          * @return Complete success message 
          */
         public String buildMessage(List<BooleanNode> nodeList) throws MessageBuilderException {
                 // List must only contain one root node
                 List<BooleanNode> rootNodeList = new ArrayList<BooleanNode>();
                 for(BooleanNode node : nodeList) {
                         if(node.getParent() == null) {
                                 rootNodeList.add(node);
                         }
                         buildMessage(node);
                 }
                 if(rootNodeList.size() > 1) {
                         throw new MessageBuilderException("Node list contains more than one root node: " + rootNodeList);
                 }
                 return rootNodeList.get(0).getNodeMessage();
         }
 
         /**
          * Builds and sets the success message for a single 
          * boolean <code>node</code> (b-tree node).
          * 
          * @param node Boolean node
          */
         public String buildMessage(final BooleanNode node) {
                 // AND node
                 if(node.getLabel().equals("*")) {
                         buildAndNodeSuccessMessage(node);
                 } 
                 // OR node
                 else if(node.getLabel().equals("+")) {
                         buildOrNodeSuccessMessage(node);
                 }
                 return node.getNodeMessage();
         }
 
         /**
          * Builds a success message for an AND node (b-tree node) where 
          * left node and right node are true.
          * 
          * @param node Boolean node
          */
         private void buildAndNodeSuccessMessage(BooleanNode node) {
                 if(node.getLabel().equals("*") && 
                                 node.getLeftNode() != null && 
                                 node.getRightNode() != null &&
                                 node.getLeftNode().getNodeMessage() != null && 
                                 node.getRightNode().getNodeMessage() != null) {
                         String preIndent = "";
                         if(node.getLeftNode().getChildCount() == 0) {
                                 preIndent = getIndent(node, 0);
                         }
                         String postIndent = "";
                         if(node.getRightNode().getChildCount() == 0) {
                                 postIndent = getIndent(node, 0);
                         }
 
                         String logMessage = this.indentString + node.getLeftNode().getNodeMessage() + 
                                 this.booleanOperatorPrefix + 
                                 preIndent + this.booleanOperators.getAndOperator() + 
                                 this.booleanOperatorSuffix + 
                                 postIndent + this.indentString + node.getRightNode().getNodeMessage();
 
                         if(node.getParent() != null && 
                                         ((node.getLabel().equals("+") && 
                                                         node.getParent().getLabel().equals("*")) || 
                                                         (node.getLabel().equals("*") && 
                                                                         node.getParent().getLabel().equals("+")))) {
                                 logMessage = node.getLeftNode().getNodeMessage() + 
                                         this.booleanOperatorPrefix + 
                                         preIndent + this.booleanOperators.getAndOperator() + 
                                         this.booleanOperatorSuffix + 
                                         postIndent + this.indentString + node.getRightNode().getNodeMessage();
                                     logMessage = preIndent + "(" + logMessage + ")";
                         }
                         node.setNodeMessage(logMessage);
                 }
         }
 
         /**
          * Builds a success message for an OR node (b-tree node) where 
          * left node and right node are true.
          * 
          * @param node
          */
         private void buildOrNodeSuccessMessage(BooleanNode node) {
                 // OR2
                 if(node.getLabel().equals("+") &&
                                 node.getLeftNode() != null && 
                                 node.getRightNode() != null &&
                                 node.getLeftNode().getNodeMessage() != null && 
                                 node.getRightNode().getNodeMessage() != null) {
                         String preIndent = "";
                         if(node.getLeftNode().getChildCount() == 0) {
                                 preIndent = getIndent(node, 0);
                         }
                         String postIndent = "";
                         if(node.getRightNode().getChildCount() == 0) {
                                 postIndent = getIndent(node, 0);
                         }
 
                         String logMessage = this.indentString + node.getLeftNode().getNodeMessage() + 
                         this.booleanOperatorPrefix + 
                                 preIndent + this.booleanOperators.getOrOperator() + 
                                 this.booleanOperatorSuffix + 
                                 postIndent + this.indentString + node.getRightNode().getNodeMessage();
 
                         if(node.getParent() != null && 
                                         ((node.getLabel().equals("+") && 
                                                         node.getParent().getLabel().equals("*")) || 
                                                         (node.getLabel().equals("*") && 
                                                                         node.getParent().getLabel().equals("+")))) {
                                 logMessage = node.getLeftNode().getNodeMessage() + 
                                         this.booleanOperatorPrefix + 
                                         preIndent + this.booleanOperators.getOrOperator() + 
                                         this.booleanOperatorSuffix + 
                                         postIndent + this.indentString + node.getRightNode().getNodeMessage();
                                     logMessage = preIndent + "(" + logMessage + ")";
                         }
                         node.setNodeMessage(logMessage);
                 } 
         }
         
         private int parentCount;
         
         private void countParents(BooleanNode node) {
                 if(node.getParent() != null) {
                         this.parentCount++;
                         countParents(node.getParent());
                 }
         }
         
         private String getIndent(BooleanNode node, int multiplier) {
                 this.parentCount = 0;
                 countParents(node);
                 if(this.parentCount > 0) {
                         return getString(this.parentCount * this.indentNumberOfSpaces + multiplier, (char) this.indentCharacter);
                 }
                 return "";
         }
         
         private static String getString(int charCount, char indentChr) {
                 char[] chr = new char[charCount];
                 for(int i=0; i<chr.length; i++) {
                         chr[i] = indentChr;
                 }
                 return String.valueOf(chr);
         }
 }

1		package org.kuali.student.common.messagebuilder.impl;
2
3		import java.util.ArrayList;
4		import java.util.List;
5
6		import org.kuali.student.common.messagebuilder.MessageTreeBuilder;
7		import org.kuali.student.common.messagebuilder.booleanmessage.ast.BooleanNode;
8		import org.kuali.student.common.messagebuilder.impl.exceptions.MessageBuilderException;
9
10		/**
11		* This class creates success messages for boolean binary tree nodes.
12		*
13		* Default display is a single line message (e.g. A OR (B AND (C OR D))).
14		* To display as multiple lines where each operator and message is on its own line.
15		* set the following:
16		* <pre>
17		* INDENT_CHAR = ' '
18		* INDENT_NUMBER_OF_SPACES = 4
19		* BOOLEAN_OPERATOR_PREFIX = "\n"
20		* BOOLEAN_OPERATOR_SUFFIX = "\n"
21		* Example:
22		* </pre>
23		* <pre>
24		* MATH101
25		* OR
26		* (MATH201
27		* AND
28		* (MATH301
29		* OR
30		* MATH401))
31		* </pre>
32		*/
33		public class SimpleBooleanMessageBuilder implements MessageTreeBuilder {
34		// Default indentation character
35		private final static char INDENT_CHAR = 0;
36		// Default number of spaces to indent
37		private final static int INDENT_NUMBER_OF_SPACES = 0;
38		// Default indentation string
39	0	private final static String INDENT_STRING = getString(INDENT_NUMBER_OF_SPACES, INDENT_CHAR);
40		// Default boolean operator prefix string
41		private final static String BOOLEAN_OPERATOR_PREFIX = " ";
42		// Default boolean operator suffix string
43		private final static String BOOLEAN_OPERATOR_SUFFIX = " ";
44
45		// Indentation character
46	0	private int indentCharacter = INDENT_CHAR;
47		// Number of spaces to indent
48	0	private int indentNumberOfSpaces = INDENT_NUMBER_OF_SPACES;
49		// Indentation string
50	0	private String indentString = INDENT_STRING;
51		// Boolean operator prefix string
52	0	private String booleanOperatorPrefix = BOOLEAN_OPERATOR_PREFIX;
53		// Boolean operator suffix string
54	0	private String booleanOperatorSuffix = BOOLEAN_OPERATOR_SUFFIX;
55
56		/** Boolean operators to use in creating the success message */
57		private BooleanOperators booleanOperators;
58
59		/**
60		* Creates a success message builder with boolean operators to use in
61		* building the success message.
62		*
63		* @param andOperator AND logical operator
64		* @param orOperator OR logical operator
65		*/
66	0	public SimpleBooleanMessageBuilder(String andOperator, String orOperator) {
67	0	this.booleanOperators = new BooleanOperators(andOperator, orOperator);
68	0	}
69
70		/**
71		* Creates a success message builder with boolean operators to use in
72		* building the success message.
73		*
74		* @param bo Boolean operators to build success message
75		*/
76	0	public SimpleBooleanMessageBuilder(BooleanOperators bo) {
77	0	this.booleanOperators = bo;
78	0	}
79
80		public void setIndentCharacter(int indentChar) {
81	0	this.indentCharacter = indentChar;
82	0	}
83
84		public void setIndentNumberOfSpaces(int indentNumberOfSpaces) {
85	0	this.indentNumberOfSpaces = indentNumberOfSpaces;
86	0	}
87
88		public void setIndentString(String indentString) {
89	0	this.indentString = indentString;
90	0	}
91
92		public void setBooleanOperatorPrefix(String booleanOperatorPrefix) {
93	0	this.booleanOperatorPrefix = booleanOperatorPrefix;
94	0	}
95
96		public void setBooleanOperatorSuffix(String booleanOperatorSuffix) {
97	0	this.booleanOperatorSuffix = booleanOperatorSuffix;
98	0	}
99
100		/**
101		* Builds and sets the success message for each of the boolean nodes
102		* (binary tree) in the <code>nodeList</code>.
103		*
104		* @param nodeList List of boolean nodes
105		* @return Complete success message
106		*/
107		public String buildMessage(List<BooleanNode> nodeList) throws MessageBuilderException {
108		// List must only contain one root node
109	0	List<BooleanNode> rootNodeList = new ArrayList<BooleanNode>();
110	0	for(BooleanNode node : nodeList) {
111	0	if(node.getParent() == null) {
112	0	rootNodeList.add(node);
113		}
114	0	buildMessage(node);
115		}
116	0	if(rootNodeList.size() > 1) {
117	0	throw new MessageBuilderException("Node list contains more than one root node: " + rootNodeList);
118		}
119	0	return rootNodeList.get(0).getNodeMessage();
120		}
121
122		/**
123		* Builds and sets the success message for a single
124		* boolean <code>node</code> (b-tree node).
125		*
126		* @param node Boolean node
127		*/
128		public String buildMessage(final BooleanNode node) {
129		// AND node
130	0	if(node.getLabel().equals("*")) {
131	0	buildAndNodeSuccessMessage(node);
132		}
133		// OR node
134	0	else if(node.getLabel().equals("+")) {
135	0	buildOrNodeSuccessMessage(node);
136		}
137	0	return node.getNodeMessage();
138		}
139
140		/**
141		* Builds a success message for an AND node (b-tree node) where
142		* left node and right node are true.
143		*
144		* @param node Boolean node
145		*/
146		private void buildAndNodeSuccessMessage(BooleanNode node) {
147	0	if(node.getLabel().equals("*") &&
148		node.getLeftNode() != null &&
149		node.getRightNode() != null &&
150		node.getLeftNode().getNodeMessage() != null &&
151		node.getRightNode().getNodeMessage() != null) {
152	0	String preIndent = "";
153	0	if(node.getLeftNode().getChildCount() == 0) {
154	0	preIndent = getIndent(node, 0);
155		}
156	0	String postIndent = "";
157	0	if(node.getRightNode().getChildCount() == 0) {
158	0	postIndent = getIndent(node, 0);
159		}
160
161	0	String logMessage = this.indentString + node.getLeftNode().getNodeMessage() +
162		this.booleanOperatorPrefix +
163		preIndent + this.booleanOperators.getAndOperator() +
164		this.booleanOperatorSuffix +
165		postIndent + this.indentString + node.getRightNode().getNodeMessage();
166
167	0	if(node.getParent() != null &&
168		((node.getLabel().equals("+") &&
169		node.getParent().getLabel().equals("*")) \|\|
170		(node.getLabel().equals("*") &&
171		node.getParent().getLabel().equals("+")))) {
172	0	logMessage = node.getLeftNode().getNodeMessage() +
173		this.booleanOperatorPrefix +
174		preIndent + this.booleanOperators.getAndOperator() +
175		this.booleanOperatorSuffix +
176		postIndent + this.indentString + node.getRightNode().getNodeMessage();
177	0	logMessage = preIndent + "(" + logMessage + ")";
178		}
179	0	node.setNodeMessage(logMessage);
180		}
181	0	}
182
183		/**
184		* Builds a success message for an OR node (b-tree node) where
185		* left node and right node are true.
186		*
187		* @param node
188		*/
189		private void buildOrNodeSuccessMessage(BooleanNode node) {
190		// OR2
191	0	if(node.getLabel().equals("+") &&
192		node.getLeftNode() != null &&
193		node.getRightNode() != null &&
194		node.getLeftNode().getNodeMessage() != null &&
195		node.getRightNode().getNodeMessage() != null) {
196	0	String preIndent = "";
197	0	if(node.getLeftNode().getChildCount() == 0) {
198	0	preIndent = getIndent(node, 0);
199		}
200	0	String postIndent = "";
201	0	if(node.getRightNode().getChildCount() == 0) {
202	0	postIndent = getIndent(node, 0);
203		}
204
205	0	String logMessage = this.indentString + node.getLeftNode().getNodeMessage() +
206		this.booleanOperatorPrefix +
207		preIndent + this.booleanOperators.getOrOperator() +
208		this.booleanOperatorSuffix +
209		postIndent + this.indentString + node.getRightNode().getNodeMessage();
210
211	0	if(node.getParent() != null &&
212		((node.getLabel().equals("+") &&
213		node.getParent().getLabel().equals("*")) \|\|
214		(node.getLabel().equals("*") &&
215		node.getParent().getLabel().equals("+")))) {
216	0	logMessage = node.getLeftNode().getNodeMessage() +
217		this.booleanOperatorPrefix +
218		preIndent + this.booleanOperators.getOrOperator() +
219		this.booleanOperatorSuffix +
220		postIndent + this.indentString + node.getRightNode().getNodeMessage();
221	0	logMessage = preIndent + "(" + logMessage + ")";
222		}
223	0	node.setNodeMessage(logMessage);
224		}
225	0	}
226
227		private int parentCount;
228
229		private void countParents(BooleanNode node) {
230	0	if(node.getParent() != null) {
231	0	this.parentCount++;
232	0	countParents(node.getParent());
233		}
234	0	}
235
236		private String getIndent(BooleanNode node, int multiplier) {
237	0	this.parentCount = 0;
238	0	countParents(node);
239	0	if(this.parentCount > 0) {
240	0	return getString(this.parentCount * this.indentNumberOfSpaces + multiplier, (char) this.indentCharacter);
241		}
242	0	return "";
243		}
244
245		private static String getString(int charCount, char indentChr) {
246	0	char[] chr = new char[charCount];
247	0	for(int i=0; i<chr.length; i++) {
248	0	chr[i] = indentChr;
249		}
250	0	return String.valueOf(chr);
251		}
252		}