First checkin

git-svn-id: https://oreka.svn.sourceforge.net/svnroot/oreka/trunk@2 09dcff7a-b715-0410-9601-b79a96267cd0

11 files changed, 1255 insertions, 0 deletions

diff --git a/orkbasej/java/net/sf/oreka/serializers/DomSerializer.java b/orkbasej/java/net/sf/oreka/serializers/DomSerializer.java
new file mode 100644
index 0000000..ac64a13
--- /dev/null
+++ b/orkbasej/java/net/sf/oreka/serializers/DomSerializer.java
@@ -0,0 +1,186 @@
+/*
+ * Oreka -- A media capture and retrieval platform
+ * 
+ * Copyright (C) 2005, orecx LLC
+ *
+ * http://www.orecx.com
+ *
+ * This program is free software, distributed under the terms of
+ * the GNU General Public License.
+ * Please refer to http://www.gnu.org/copyleft/gpl.html
+ *
+ */
+
+
+
+package net.sf.oreka.serializers;
+
+
+import java.io.ByteArrayOutputStream;
+
+import javax.xml.transform.Result;
+import javax.xml.transform.Transformer;
+import javax.xml.transform.TransformerFactory;
+import javax.xml.transform.dom.DOMSource;
+import javax.xml.transform.stream.StreamResult;
+
+import net.sf.oreka.OrkException;
+import net.sf.oreka.OrkObject;
+import net.sf.oreka.OrkObjectFactory;
+
+import org.w3c.dom.Document;
+import org.w3c.dom.Element;
+import org.w3c.dom.Node;
+import org.w3c.dom.Text;
+
+public class DomSerializer extends OrkSerializer {
+
+	Node node = null;
+	Document document = null;
+	
+	public OrkObject deSerialize(Node node) throws OrkException
+	{
+		if (node == null)
+		{
+			throw (new OrkException("DomSerializer: null node was passed in"));
+		}
+		this.node = node;
+		deserialize = true;		// Set DeSerialize mode
+		OrkObject obj = OrkObjectFactory.instance().newOrkObject(node.getNodeName());
+		obj.define(this);
+		obj.validate();
+		return obj;
+	}
+	
+	public void serialize(Document document, Node node, OrkObject object) throws OrkException {
+		
+		if (node == null) {
+			throw ( new OrkException("DomSerializer: passed DOM node is null"));
+		}
+		if (document == null) {
+			throw ( new OrkException("DomSerializer: passed DOM document is null"));
+		}
+		this.document = document;
+		this.node = node;
+		
+		deserialize = false;		// Set Serialize mode
+		object.define(this);
+	}
+	
+	@Override
+	public void addClassName(String value) {
+		// TODO Auto-generated method stub
+		
+	}
+
+	@Override
+	void addString(String key, String value) {
+		
+		Element  newElem = document.createElement(key);
+		node.appendChild(newElem);
+
+		Text newText = document.createTextNode(value);
+		newElem.appendChild(newText);
+	}
+
+	@Override
+	String getString(String key, String oldValue, boolean required) throws OrkException {
+		
+		String value = null;
+		
+		// Find the right node
+		Node stringNode = findElementByName(node, key);
+
+		if(stringNode != null)
+		{
+			// Now, the string associated to element should be the first child (text element)
+			Node textNode = stringNode.getFirstChild();
+			if (textNode != null && textNode.getNodeType() == Node.TEXT_NODE) {
+				value = textNode.getNodeValue().trim();
+			}
+		}
+		if (value == null) {
+			if (required) {
+				throw(new OrkException("DomSerializer::GetString: required parameter missing:" + key));
+			}
+			value = oldValue;
+		}
+		return value;
+	}
+
+	@Override
+	public OrkObject objectValue(String key, OrkObject value, boolean required) throws OrkException {
+		
+		if (deserialize) {
+			return getObject(key, value, required);
+		}
+		else {
+			addObject(key, value);
+			return value;
+		}
+	}
+	
+	void addObject(String key, OrkObject value) throws OrkException {
+		
+		Element newElem = document.createElement(key);
+		node.appendChild(newElem);
+		DomSerializer ser = new DomSerializer();
+		ser.serialize(document, newElem, value);
+	}
+
+	OrkObject getObject(String key, OrkObject oldValue, boolean required) throws OrkException {
+		
+		OrkObject value = null;
+		
+		// Find the node corresponding to the object wanting to be populated
+		Node objectNode = findElementByName(node, key);
+
+		// Create a new serializer and affect it to this object
+		if (objectNode != null)
+		{
+			DomSerializer serializer = new DomSerializer();
+			value = serializer.deSerialize(objectNode);
+		}
+		if (value == null) {
+			 if (required) {
+				 throw(new OrkException("DomSerializer.getObject: required node missing:" + key));
+			 }
+			 value = oldValue;
+		}
+		return value;
+	}
+	
+	public Node findElementByName(Node node, String name)
+	{
+		Node child = node.getFirstChild();
+		while(child != null)
+		{
+			if (child.getNodeName().equalsIgnoreCase(name) && child.getNodeType() == Node.ELEMENT_NODE)
+			{
+				return child;
+			}
+			child = child.getNextSibling();
+		}
+		return null;
+	}
+
+	public static String NodeToString(Node node) {
+	
+		String result = null;
+		TransformerFactory xformerFactory = TransformerFactory.newInstance();
+		try {
+			Transformer xformer = xformerFactory.newTransformer();
+			xformer.setOutputProperty("indent", "yes");
+			ByteArrayOutputStream byteArray = new ByteArrayOutputStream();
+			Result output = new StreamResult(byteArray);
+			DOMSource source = new DOMSource(node);
+			xformer.transform(source,output);
+			result = byteArray.toString();
+		}
+		catch (Exception e) {
+			;
+		}
+		return result;
+	}
+	
+}
diff --git a/orkbasej/java/net/sf/oreka/serializers/KeyValueSerializer.java b/orkbasej/java/net/sf/oreka/serializers/KeyValueSerializer.java
new file mode 100644
index 0000000..bc65819
--- /dev/null
+++ b/orkbasej/java/net/sf/oreka/serializers/KeyValueSerializer.java
@@ -0,0 +1,47 @@
+/*
+ * Oreka -- A media capture and retrieval platform
+ * 
+ * Copyright (C) 2005, orecx LLC
+ *
+ * http://www.orecx.com
+ *
+ * This program is free software, distributed under the terms of
+ * the GNU General Public License.
+ * Please refer to http://www.gnu.org/copyleft/gpl.html
+ *
+ */
+
+package net.sf.oreka.serializers;
+
+import java.util.HashMap;
+
+import net.sf.oreka.*;
+
+public abstract class KeyValueSerializer extends OrkSerializer
+{	
+	HashMap<String, String> map;
+	
+	KeyValueSerializer()
+	{
+		map = new HashMap<String, String>();
+	}
+	
+	String getString(String key, String oldValue, boolean required) throws OrkException
+	{
+		String value = map.get(key.toLowerCase());
+		if (value == null)
+		{
+			if (required == true)
+			{
+				throw (new OrkException("Serializer.GetString: required parameter missing:" + key));
+			}
+			value = oldValue;
+		}
+		return value;
+	}
+	
+	public OrkObject objectValue(String key, OrkObject value, boolean required) throws OrkException
+	{
+		throw (new OrkException("KeyValueSerializer.objectValue: Nested objects not allowed for key-value serializers"));
+	}
+}
diff --git a/orkbasej/java/net/sf/oreka/serializers/OrkSerializer.java b/orkbasej/java/net/sf/oreka/serializers/OrkSerializer.java
new file mode 100644
index 0000000..f4b0d54
--- /dev/null
+++ b/orkbasej/java/net/sf/oreka/serializers/OrkSerializer.java
@@ -0,0 +1,239 @@
+/*
+ * Oreka -- A media capture and retrieval platform
+ * 
+ * Copyright (C) 2005, orecx LLC
+ *
+ * http://www.orecx.com
+ *
+ * This program is free software, distributed under the terms of
+ * the GNU General Public License.
+ * Please refer to http://www.gnu.org/copyleft/gpl.html
+ *
+ */
+
+package net.sf.oreka.serializers;
+
+import net.sf.oreka.*;
+
+/**
+ * 
+ * Base class for all serializers.
+ * Serializers have to implement their own serialize and deserialize methods
+ * since the data can be read from and written to many different formats
+ * 
+ * Enum and Boolean value are case insensitive (all enum values must be defined 
+ * lower case in the project, otherwise they won't be recognized at all)
+ *
+ */
+public abstract class OrkSerializer {
+	
+	boolean deserialize = false;
+	String classKey = "class";
+	
+	public void setClassKey(String classKey)
+	{
+		this.classKey = classKey;
+	}
+	
+	public int intValue(String key, int value, boolean required) throws OrkException
+	{
+		if (deserialize)
+		{
+			return getInt(key, value, required);
+		}
+		else
+		{
+			addInt(key, value);
+			return value;
+		}
+	}
+
+	public double doubleValue(String key, double value, boolean required) throws OrkException
+	{
+		if (deserialize)
+		{
+			return getDouble(key, value, required);
+		}
+		else
+		{
+			addDouble(key, value);
+			return value;
+		}		
+	}
+	
+	public String stringValue(String key, String value, boolean required ) throws OrkException
+	{
+		if (deserialize)
+		{
+			return getString(key, value, required);
+		}
+		else
+		{
+			addString(key, value);
+			return value;
+		}
+	}
+	
+	public boolean booleanValue(String key, boolean value, boolean required ) throws OrkException
+	{
+		if (deserialize)
+		{
+			return getBoolean(key, value, required);
+		}
+		else
+		{
+			addBoolean(key, value);
+			return value;
+		}
+	}
+	
+	public Enum enumValue(String key, Enum value, boolean required ) throws OrkException
+	{
+		if (deserialize)
+		{
+			return getEnum(key, value, required);
+		}
+		else
+		{
+			addEnum(key, value);
+			return value;
+		}
+	}
+	
+	public abstract OrkObject objectValue(String key, OrkObject value, boolean required ) throws OrkException;
+	
+	public abstract void addClassName(String value);
+	
+	void addInt(String key, int value)
+	{
+		String valueString = String.valueOf(value);
+		addString(key, valueString);
+	}
+	
+	void addDouble(String key, double value)
+	{
+		String valueString = String.valueOf(value);
+		addString(key, valueString);
+	}
+	
+	void addBoolean(String key, boolean value)
+	{
+		if(value)
+		{
+			addString(key, "true");
+		}
+		else
+		{
+			addString(key, "false");
+		}
+	}
+	
+	void addEnum(String key, Enum value)
+	{
+		addString(key, value.name());
+	}
+	
+	abstract void addString(String key, String value);
+
+	int getInt(String key, int oldValue, boolean required) throws OrkException
+	{
+		int value = 0;
+		String stringValue = getString(key, null, required);
+		
+		if (stringValue == null)
+		{
+			value = oldValue;
+		}
+		else
+		{
+			try
+			{
+				value = Integer.valueOf(stringValue);
+			}
+			catch (Exception e)
+			{
+				throw (new OrkException("Serializer: value:" + stringValue + " not an int for key:" + key));
+			}
+		}
+		return value;
+	}
+	
+	double getDouble(String key, double oldValue, boolean required) throws OrkException
+	{
+		double value = 0.0;
+		String stringValue = getString(key, null, required);
+		
+		if (stringValue == null)
+		{
+			value = oldValue;
+		}
+		else
+		{
+			try
+			{
+				value = Double.valueOf(stringValue);
+			}
+			catch (Exception e)
+			{
+				throw (new OrkException("Serializer: value:" + stringValue + " not a double for key:" + key));
+			}
+		}
+		return value;
+	}
+	
+	boolean getBoolean(String key, boolean oldValue, boolean required) throws OrkException
+	{
+		boolean value;
+		String stringValue = getString(key, null, required);
+
+		if (stringValue == null)
+		{
+			value = oldValue;
+		}
+		else
+		{
+			stringValue = stringValue.toLowerCase();
+			
+			if(	stringValue.equals("true") || stringValue.equals("yes") || stringValue.equals("1") )
+			{
+				value = true;
+			}
+			else if( stringValue.equals("false") || stringValue.equals("no") || stringValue.equals("0") )
+			{
+				value = false;
+			}
+			else
+			{
+				throw(new OrkException("Serializer: Invalid boolean value:" + stringValue + " for key:" + key));
+			}
+		}
+		return value;
+	}
+
+	Enum getEnum(String key, Enum oldValue, boolean required) throws OrkException
+	{
+		Enum value = null;
+		String stringValue = getString(key, null, required);
+
+		if (stringValue == null)
+		{
+			value = oldValue;
+		}
+		else
+		{
+			stringValue = stringValue.toLowerCase();
+			Class valueClass = oldValue.getClass();
+			try
+			{
+				value = Enum.valueOf(valueClass, stringValue);
+			}
+			catch (IllegalArgumentException e)
+			{
+				throw (new OrkException("Serializer: Invalid enum value:" + stringValue + " for parameter:" + key));
+			}
+		}
+		return value;
+	}
+	
+	abstract String getString(String key, String oldValue, boolean required ) throws OrkException;
+}
diff --git a/orkbasej/java/net/sf/oreka/serializers/ServletRequestSerializer.java b/orkbasej/java/net/sf/oreka/serializers/ServletRequestSerializer.java
new file mode 100644
index 0000000..8eded74
--- /dev/null
+++ b/orkbasej/java/net/sf/oreka/serializers/ServletRequestSerializer.java
@@ -0,0 +1,79 @@
+/*
+ * Oreka -- A media capture and retrieval platform
+ * 
+ * Copyright (C) 2005, orecx LLC
+ *
+ * http://www.orecx.com
+ *
+ * This program is free software, distributed under the terms of
+ * the GNU General Public License.
+ * Please refer to http://www.gnu.org/copyleft/gpl.html
+ *
+ */
+
+package net.sf.oreka.serializers;
+
+import javax.servlet.http.*;
+
+import net.sf.oreka.OrkException;
+import net.sf.oreka.OrkObject;
+import net.sf.oreka.OrkObjectFactory;
+
+public class ServletRequestSerializer extends OrkSerializer {
+
+	HttpServletRequest request = null;
+	final String classMarker = "cmd";
+	
+	public OrkObject deSerialize(HttpServletRequest request) throws OrkException
+	{
+		this.request = request;
+		deserialize = true;		// Set DeSerialize mode
+		
+		// Instanciate the right object
+		String classMarker2 = (String)request.getParameterNames().nextElement();
+		String orkClass = null;
+		if(classMarker2 != null)
+		{	
+			orkClass = request.getParameter(classMarker2);
+		}
+		if(orkClass == null) {
+			throw (new OrkException("ServletRequestSerializer.deSerialize: where is the command in:" + request.getQueryString()));
+		}
+
+		OrkObject obj = OrkObjectFactory.instance().newOrkObject(orkClass.toLowerCase());
+		obj.define(this);
+		obj.validate();
+		return obj;
+	}
+	
+	@Override
+	public void addClassName(String value) {
+		; // not needed, this serializer is only a de-serializer
+	}
+
+	@Override
+	void addString(String key, String value) {
+		; // not needed, this serializer is only a de-serializer
+	}
+
+	@Override
+	String getString(String key, String oldValue, boolean required) throws OrkException {
+		String value = request.getParameter(key);
+		if(value == null) {
+			if (required) {
+				throw (new OrkException("ServletRequestSerializer.getString: parameter not found:" + key));
+			}
+			else {
+				value = oldValue;
+			}
+		}
+		return value;
+	}
+
+	@Override
+	public OrkObject objectValue(String key, OrkObject value, boolean required) throws OrkException {
+		throw (new OrkException("ServletRequestSerializer.objectValue: Nested objects not allowed"));
+	}
+
+	
+}
diff --git a/orkbasej/java/net/sf/oreka/serializers/SingleLineSerializer.java b/orkbasej/java/net/sf/oreka/serializers/SingleLineSerializer.java
new file mode 100644
index 0000000..44f2fe3
--- /dev/null
+++ b/orkbasej/java/net/sf/oreka/serializers/SingleLineSerializer.java
@@ -0,0 +1,231 @@
+/*
+ * Oreka -- A media capture and retrieval platform
+ * 
+ * Copyright (C) 2005, orecx LLC
+ *
+ * http://www.orecx.com
+ *
+ * This program is free software, distributed under the terms of
+ * the GNU General Public License.
+ * Please refer to http://www.gnu.org/copyleft/gpl.html
+ *
+ */
+
+package net.sf.oreka.serializers;
+
+import net.sf.oreka.OrkException;
+import net.sf.oreka.OrkObject;
+import net.sf.oreka.OrkObjectFactory;
+
+/** 
+ * Serializer that generates and parses objects to and from a single line of text.
+ * key-value pairs are separated by spaces.
+ * key and values are separated by equal signs.
+ * example: message=doit what=run 
+ */
+public class SingleLineSerializer extends KeyValueSerializer
+{
+	StringBuffer output;
+	
+	public String serialize(OrkObject input) throws OrkException
+	{
+		output = new StringBuffer();
+		deserialize = false;		// Set Serialize mode
+		addClassName(input.getOrkClassName());
+		input.define(this);
+		return output.toString();
+	}
+	
+	enum SingleLineState {StartState, KeyState, ValueState};
+	
+	public OrkObject deSerialize(String input) throws OrkException
+	{
+		// read string and extract values into map
+		input = input.trim();
+
+		SingleLineState state = SingleLineState.StartState;
+
+		StringBuffer key = new StringBuffer();
+		StringBuffer value = new StringBuffer();
+		String firstValue = null;
+		
+		for(int i=0; i<input.length(); i++)
+		{
+			Character character = input.charAt(i);
+
+			switch(state)
+			{
+			case StartState:
+				if(character == ' ')
+				{
+					;	// ignore spaces
+				}
+				
+				else if ( Character.isLetterOrDigit(character) )
+				{
+					state = SingleLineState.KeyState;
+					key.append(character);
+				}
+				else
+				{
+					throw new OrkException("SingleLineSerializer.deSerialize: Cannot find key start, keys must be alphanum, wrong char:"  + character + " input:" + input);
+				}
+				break;
+				
+			case KeyState:
+				if( Character.isLetterOrDigit(character) )
+				{
+					key.append(character);
+				}
+				else if (character == '=')
+				{
+					state = SingleLineState.ValueState;
+					value = new StringBuffer();
+				}
+				else
+				{
+					throw new OrkException("SingleLineSerializer.deSerialize: Invalid key character, keys must be alphanum, wrong char:"  + character + " input:" + input);
+				}
+				break;
+			case ValueState:
+				if( character == '=')
+				{
+					throw new OrkException("SingleLineSerializer.deSerialize: equals sign misplaced at index:" + i + " in input:" + input);				
+				}
+				else if (character == ' ')
+				{
+					state = SingleLineState.StartState;
+				}
+				else
+				{
+					value.append(character);
+				}
+				break;
+			}	// switch(state)
+
+			if ( (state == SingleLineState.StartState) || (i == (input.length()-1)) )
+			{
+				if (key.length() > 0)
+				{
+					// Add pair to key-value map
+					map.put(key.toString().toLowerCase(), unEscapeSingleLine(value.toString()));
+					if (firstValue == null)
+					{
+						firstValue = value.toString().toLowerCase();
+					}
+					key = new StringBuffer();
+					value = new StringBuffer();
+				}
+			}
+		}
+
+		deserialize = true;		// Set DeSerialize mode
+		
+		OrkObject obj = OrkObjectFactory.instance().newOrkObject(firstValue);
+		obj.define(this);
+		obj.validate();
+		return obj;
+	}
+	
+	public void addClassName(String value)
+	{
+		addString(classKey, value);
+	}
+	
+	void addString(String key, String value)
+	{
+		String pair;
+		String escapedValue = escapeSingleLine(value);
+		pair = key + "=" + escapedValue + " ";
+		output.append(pair);
+	}
+
+	/**
+	 * Finds the Object Class from a serialized string. 
+	 * i.e. for a serialized object of the form:
+	 * 		message=dosomething when=now
+	 * it returns "dosomething"
+	 * 
+	 * @param input
+	 * @return
+	 */
+	/*
+	static String findClass(String input)
+	{
+		String result = "";
+		int equalsPosition = input.indexOf("=");
+		if (equalsPosition != -1)
+		{
+			int spacePostion = input.indexOf(" ");
+			if (spacePostion > equalsPosition)
+			{
+				result = input.substring(equalsPosition+1, spacePostion-1);
+			}
+			else
+			{
+				result = input.substring(equalsPosition+1, input.length() - 1);
+			}
+		}
+		return result.toLowerCase();
+	}
+	*/
+	
+	String escapeSingleLine(String in)
+	{		
+		StringBuffer out = new StringBuffer();
+		for(int i=0; i<in.length();i++)
+		{
+			char c = in.charAt(i);
+			if (c == ' ')
+			{
+				out.append("%s");
+			}
+			else if (c == ':')
+			{
+				out.append("%c");
+			}
+			else if (c == '%')
+			{
+				out.append("%p");
+			}
+			else
+			{
+				out.append(c);
+			}
+		}		
+		return out.toString();
+	}
+	
+	String unEscapeSingleLine(String in)
+	{
+		StringBuffer out = new StringBuffer();
+		int iin = 0;
+
+		while(iin<in.length())
+		{ 
+			if ( in.charAt(iin) == '%')
+			{
+				iin++;
+
+				switch (in.charAt(iin))
+				{
+				case 's':
+					out.append(' ');
+					break;
+				case 'c':
+					out.append(':');
+					break;
+				case 'p':
+					out.append('%');
+					break;
+				}
+			}
+			else
+			{
+				out.append(in.charAt(iin));
+			}
+			iin++;
+		}
+		return out.toString();
+	}
+}
diff --git a/orkbasej/java/net/sf/oreka/serializers/test/DomSerializerTest.java b/orkbasej/java/net/sf/oreka/serializers/test/DomSerializerTest.java
new file mode 100644
index 0000000..198da4d
--- /dev/null
+++ b/orkbasej/java/net/sf/oreka/serializers/test/DomSerializerTest.java
@@ -0,0 +1,82 @@
+/*
+ * Oreka -- A media capture and retrieval platform
+ * 
+ * Copyright (C) 2005, orecx LLC
+ *
+ * http://www.orecx.com
+ *
+ * This program is free software, distributed under the terms of
+ * the GNU General Public License.
+ * Please refer to http://www.gnu.org/copyleft/gpl.html
+ *
+ */
+
+package net.sf.oreka.serializers.test;
+
+import java.io.InputStream;
+
+import javax.xml.parsers.DocumentBuilder;
+import javax.xml.parsers.DocumentBuilderFactory;
+
+import junit.framework.Test;
+import junit.framework.TestCase;
+import junit.framework.TestSuite;
+import net.sf.oreka.OrkObject;
+import net.sf.oreka.OrkObjectFactory;
+import net.sf.oreka.messages.test.TestNestedMessage;
+import net.sf.oreka.messages.test.TestSubMessage;
+import net.sf.oreka.serializers.DomSerializer;
+
+import org.w3c.dom.Document;
+import org.w3c.dom.Element;
+
+
+
+public class DomSerializerTest extends TestCase {
+	
+	DocumentBuilder builder = null;
+	
+	public static void main (String[] args) {
+		junit.textui.TestRunner.run (suite());
+	}
+	protected void setUp() throws Exception {
+		OrkObjectFactory.instance().registerOrkObject(new TestNestedMessage());
+		OrkObjectFactory.instance().registerOrkObject(new TestSubMessage());		
+		DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
+		builder = factory.newDocumentBuilder();
+	}
+	public static Test suite() {
+		return new TestSuite(DomSerializerTest.class);
+	}
+	
+	public void testDeSerializeBasic() throws Exception
+	{
+		InputStream is = ClassLoader.getSystemClassLoader().getResourceAsStream ("net/sf/oreka/serializers/test/TestNestedMessage.xml");
+		Document doc = builder.parse(is);
+		DomSerializer ser = new DomSerializer();
+		OrkObject obj = ser.deSerialize(doc.getFirstChild());
+		assertTrue(((TestNestedMessage)obj).getIntParm() == 546);
+		
+		TestNestedMessage tnm = (TestNestedMessage)obj;
+		TestSubMessage tsm = tnm.getSubMsg();
+		assertTrue(tsm.getStringSubParm().equals("hello"));		
+	}
+	
+	public void testSerializeBasic() throws Exception
+	{
+		// This does a round trip serialization-deserialization in order to test serialization
+		TestNestedMessage tnm = new TestNestedMessage();
+		tnm.getSubMsg().setStringSubParm("le maure");
+		tnm.setDoubleParm(0.666);
+		Document doc = builder.newDocument();
+		Element  docNode = doc.createElement(tnm.getOrkClassName());
+		doc.appendChild(docNode);
+		
+		DomSerializer ser = new DomSerializer();
+		ser.serialize(doc, docNode, tnm);
+		//System.out.println(DomSerializer.NodeToString(doc));
+		OrkObject obj = ser.deSerialize(docNode);	
+		assertTrue(((TestNestedMessage)obj).getDoubleParm() == 0.666);
+		assertTrue(((TestNestedMessage)obj).getSubMsg().getStringSubParm() == "le maure");
+	}
+}
diff --git a/orkbasej/java/net/sf/oreka/serializers/test/NullHttpServletRequest.java b/orkbasej/java/net/sf/oreka/serializers/test/NullHttpServletRequest.java
new file mode 100644
index 0000000..71cb22f
--- /dev/null
+++ b/orkbasej/java/net/sf/oreka/serializers/test/NullHttpServletRequest.java
@@ -0,0 +1,163 @@
+/*
+ * Oreka -- A media capture and retrieval platform
+ * 
+ * Copyright (C) 2005, orecx LLC
+ *
+ * http://www.orecx.com
+ *
+ * This program is free software, distributed under the terms of
+ * the GNU General Public License.
+ * Please refer to http://www.gnu.org/copyleft/gpl.html
+ *
+ */
+
+package net.sf.oreka.serializers.test;
+
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.UnsupportedEncodingException;
+import java.security.Principal;
+import java.util.Enumeration;
+import java.util.Hashtable;
+import java.util.Locale;
+import java.util.Map;
+
+import javax.servlet.RequestDispatcher;
+import javax.servlet.ServletInputStream;
+import javax.servlet.http.Cookie;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpSession;
+
+public class NullHttpServletRequest implements HttpServletRequest
+{
+	public Hashtable<String, String> parameters = new Hashtable<String, String>();
+		
+	public void setParameter(String key, String value) {
+		parameters.put(key, value);
+	}
+	
+	public String getParameter(String key)	{
+		return (String)this.parameters.get(key);
+	}
+
+	public Enumeration getParameterNames(){
+		return this.parameters.elements();
+	}
+	
+	public Cookie[] getCookies() {return null;}
+	public String getMethod(){return null;}
+	public String getRequestURI(){return null;}
+	public String getServletPath(){return null;}
+	public String getPathInfo(){return null;}
+	public String getPathTranslated(){return null;}
+	public String getQueryString(){return null;}
+	public String getRemoteUser(){return null;}
+	public String getAuthType(){return null;}
+	public String getHeader(String name){return null;}
+	public int getIntHeader(String name){return 0;}
+	public long getDateHeader(String name){return 0;}
+	public Enumeration getHeaderNames(){return null;}
+	public HttpSession getSession(boolean create){return null;}
+	public String getRequestedSessionId(){return null;}
+	public boolean isRequestedSessionIdValid(){return false;}
+	public boolean isRequestedSessionIdFromCookie(){return false;}
+	public boolean isRequestedSessionIdFromUrl(){return false;}
+	public int getContentLength(){return 0;}
+	public String getContentType(){return null;}
+	public String getProtocol(){return null;}
+	public String getScheme(){return null;}
+	public String getServerName(){return null;}
+	public int getServerPort(){return 0;}
+	public String getRemoteAddr(){return null;}
+	public String getRemoteHost(){return null;}
+	public String getRealPath(String path){return null;}
+	public ServletInputStream getInputStream() throws IOException{return null;}
+	public String[] getParameterValues(String name){return null;}
+	public Enumeration getAttributeNames(){return null;}
+	public Object getAttribute(String name){return null;}
+	public HttpSession getSession(){return null;}
+	public BufferedReader getReader() throws IOException{return null;}
+	public String getCharacterEncoding(){return null;}
+	public void setAttribute(String name, Object o) {}
+	public boolean isRequestedSessionIdFromURL() {return false;}
+
+	public String getContextPath() {
+		// TODO Auto-generated method stub
+		return null;
+	}
+
+	public Enumeration getHeaders(String arg0) {
+		// TODO Auto-generated method stub
+		return null;
+	}
+
+	public StringBuffer getRequestURL() {
+		// TODO Auto-generated method stub
+		return null;
+	}
+
+	public Principal getUserPrincipal() {
+		// TODO Auto-generated method stub
+		return null;
+	}
+
+	public boolean isUserInRole(String arg0) {
+		// TODO Auto-generated method stub
+		return false;
+	}
+
+	public String getLocalAddr() {
+		// TODO Auto-generated method stub
+		return null;
+	}
+
+	public Locale getLocale() {
+		// TODO Auto-generated method stub
+		return null;
+	}
+
+	public Enumeration getLocales() {
+		// TODO Auto-generated method stub
+		return null;
+	}
+
+	public String getLocalName() {
+		// TODO Auto-generated method stub
+		return null;
+	}
+
+	public int getLocalPort() {
+		// TODO Auto-generated method stub
+		return 0;
+	}
+
+	public Map getParameterMap() {
+		// TODO Auto-generated method stub
+		return null;
+	}
+
+	public int getRemotePort() {
+		// TODO Auto-generated method stub
+		return 0;
+	}
+
+	public RequestDispatcher getRequestDispatcher(String arg0) {
+		// TODO Auto-generated method stub
+		return null;
+	}
+
+	public boolean isSecure() {
+		// TODO Auto-generated method stub
+		return false;
+	}
+
+	public void removeAttribute(String arg0) {
+		// TODO Auto-generated method stub
+		
+	}
+
+	public void setCharacterEncoding(String arg0) throws UnsupportedEncodingException {
+		// TODO Auto-generated method stub
+		
+	}
+}
\ No newline at end of file
diff --git a/orkbasej/java/net/sf/oreka/serializers/test/ServletRequestSerializerTest.java b/orkbasej/java/net/sf/oreka/serializers/test/ServletRequestSerializerTest.java
new file mode 100644
index 0000000..08260fb
--- /dev/null
+++ b/orkbasej/java/net/sf/oreka/serializers/test/ServletRequestSerializerTest.java
@@ -0,0 +1,45 @@
+/*
+ * Oreka -- A media capture and retrieval platform
+ * 
+ * Copyright (C) 2005, orecx LLC
+ *
+ * http://www.orecx.com
+ *
+ * This program is free software, distributed under the terms of
+ * the GNU General Public License.
+ * Please refer to http://www.gnu.org/copyleft/gpl.html
+ *
+ */
+
+package net.sf.oreka.serializers.test;
+
+import junit.framework.Test;
+import junit.framework.TestCase;
+import junit.framework.TestSuite;
+import net.sf.oreka.OrkObject;
+import net.sf.oreka.OrkObjectFactory;
+import net.sf.oreka.messages.test.TestMessage;
+import net.sf.oreka.serializers.ServletRequestSerializer;
+
+public class ServletRequestSerializerTest extends TestCase {
+	
+	public static void main (String[] args) {
+		junit.textui.TestRunner.run (suite());
+	}
+	protected void setUp() {
+		OrkObjectFactory.instance().registerOrkObject(new TestMessage());
+	}
+	public static Test suite() {
+		return new TestSuite(ServletRequestSerializerTest.class);
+	}
+	
+	public void testSerializeBasic() throws Exception
+	{
+		NullHttpServletRequest req = new NullHttpServletRequest();
+		ServletRequestSerializer ser = new ServletRequestSerializer();
+		req.setParameter("cmd", "test");
+		req.setParameter("intParm", "45");
+		OrkObject obj = ser.deSerialize(req);
+		assertTrue(((TestMessage)obj).getIntParm() == 45);
+	}
+}
diff --git a/orkbasej/java/net/sf/oreka/serializers/test/SingleLineSerializerTest.java b/orkbasej/java/net/sf/oreka/serializers/test/SingleLineSerializerTest.java
new file mode 100644
index 0000000..5520626
--- /dev/null
+++ b/orkbasej/java/net/sf/oreka/serializers/test/SingleLineSerializerTest.java
@@ -0,0 +1,172 @@
+/*
+ * Oreka -- A media capture and retrieval platform
+ * 
+ * Copyright (C) 2005, orecx LLC
+ *
+ * http://www.orecx.com
+ *
+ * This program is free software, distributed under the terms of
+ * the GNU General Public License.
+ * Please refer to http://www.gnu.org/copyleft/gpl.html
+ *
+ */
+
+package net.sf.oreka.serializers.test;
+
+import junit.framework.*;
+import net.sf.oreka.*;
+import net.sf.oreka.messages.*;
+import net.sf.oreka.messages.test.TestMessage;
+import net.sf.oreka.serializers.SingleLineSerializer;
+
+public class SingleLineSerializerTest extends TestCase  
+{
+	public static void main (String[] args) {
+		junit.textui.TestRunner.run (suite());
+	}
+	protected void setUp() {
+		OrkObjectFactory.instance().registerOrkObject(new TestMessage());
+	}
+	public static Test suite() {
+		return new TestSuite(SingleLineSerializerTest.class);
+	}
+	
+	public void testSerializeBasic() throws Exception
+	{
+		String output = null;
+		
+		TestMessage msg = new TestMessage();
+		SingleLineSerializer ser = new SingleLineSerializer();
+		
+		msg.setIntParm(6);
+		output = ser.serialize(msg);
+		System.out.println("\noutput:" + output);
+		assertTrue(output.toLowerCase().indexOf("intparm=6") != -1);
+		
+		msg.setIntParm(-5);
+		output = ser.serialize(msg);
+		System.out.println("\noutput:" + output);
+		assertTrue(output.toLowerCase().indexOf("intparm=-5") != -1);
+		
+		msg.setDoubleParm(7.7);
+		output = ser.serialize(msg);
+		System.out.println("\noutput:" + output);
+		assertTrue(output.toLowerCase().indexOf("doubleparm=7.7") != -1);
+		
+		msg.setBoolParm(true);
+		output = ser.serialize(msg);
+		System.out.println("\noutput:" + output);
+		assertTrue(output.toLowerCase().indexOf("boolparm=true") != -1);
+		
+		msg.setStringParm("hello");
+		output = ser.serialize(msg);
+		System.out.println("\noutput:" + output);
+		assertTrue(output.toLowerCase().indexOf("stringparm=hello") != -1);
+	}
+
+	public void testDeSerializeBasic() throws Exception
+	{
+		String input;
+		SingleLineSerializer ser = new SingleLineSerializer();
+		TestMessage msg;
+		
+		input = "class=test intparm=3";
+		msg = (TestMessage)ser.deSerialize(input);
+		assertTrue(msg.getIntParm() == 3);
+		
+		input = "class=test doubleparm=-14.6";
+		msg = (TestMessage)ser.deSerialize(input);
+		assertTrue(msg.getDoubleParm() == -14.6);
+		
+		input = "class=test boolparm=yes";
+		msg = (TestMessage)ser.deSerialize(input);
+		assertTrue(msg.isBoolParm());
+	}
+	
+	public void testDeSerializeBoolean() throws Exception
+	{
+		String input;
+		SingleLineSerializer ser = new SingleLineSerializer();
+		TestMessage msg;
+		
+		input = "class=test intparm=78 boolparm=no";
+		msg = (TestMessage)ser.deSerialize(input);
+		assertFalse(msg.isBoolParm());	
+		
+		input = "class=test intparm=78 boolparm=0";
+		msg = (TestMessage)ser.deSerialize(input);
+		assertFalse(msg.isBoolParm());
+		
+		input = "class=test intparm=78 boolparm=false";
+		msg = (TestMessage)ser.deSerialize(input);
+		assertFalse(msg.isBoolParm());
+		
+		input = "class=test intparm=78 boolparm=true";
+		msg = (TestMessage)ser.deSerialize(input);
+		assertTrue(msg.isBoolParm());
+		
+		input = "class=test intparm=78 boolparm=yes";
+		msg = (TestMessage)ser.deSerialize(input);
+		assertTrue(msg.isBoolParm());
+		
+		input = "class=test intparm=78 boolparm=1";
+		msg = (TestMessage)ser.deSerialize(input);
+		assertTrue(msg.isBoolParm());
+		
+		input = "class=test intparm=78 boolparm=asdf";
+		boolean threw = false;
+		try {
+			msg = (TestMessage)ser.deSerialize(input);
+		}
+		catch (OrkException e) {
+			threw = true;
+		}
+		assertTrue(threw);
+	}
+	
+	public void testDeSerializeRequired() throws Exception
+	{
+		String input;
+		SingleLineSerializer ser = new SingleLineSerializer();
+		TestMessage msg;
+		
+		input = "class=test";
+		boolean threw = false;
+		try {
+			msg = (TestMessage)ser.deSerialize(input);
+		}
+		catch (OrkException e) {
+			threw = true;
+		}
+		assertTrue(threw);
+	}
+	
+	public void testEnum() throws Exception
+	{
+		// deserialize
+		String input;
+		SingleLineSerializer ser = new SingleLineSerializer();
+		TestMessage msg;
+		
+		input = "class=test intparm=78 enumparm=value2";
+		msg = (TestMessage)ser.deSerialize(input);
+		assertTrue(msg.getEnumParm() == TestMessage.TestEnum.value2);	
+		
+		input = "class=test intparm=78 enumparm=garbage";
+		boolean threw = false;
+		try {
+			msg = (TestMessage)ser.deSerialize(input);
+		}
+		catch (OrkException e) {
+			threw = true;
+		}
+		assertTrue(threw);
+		
+		// serialize
+		String output = null;
+		msg.setEnumParm(TestMessage.TestEnum.value3);
+		output = ser.serialize(msg);
+		assertTrue(output.toLowerCase().indexOf("enumparm=value3") != -1);
+	}
+
+}
diff --git a/orkbasej/java/net/sf/oreka/serializers/test/TestMessageSimple.xml b/orkbasej/java/net/sf/oreka/serializers/test/TestMessageSimple.xml
new file mode 100644
index 0000000..20347c4
--- /dev/null
+++ b/orkbasej/java/net/sf/oreka/serializers/test/TestMessageSimple.xml
@@ -0,0 +1,5 @@
+<test>
+  <intParm>
+  546
+  </intParm>
+</test>
\ No newline at end of file
diff --git a/orkbasej/java/net/sf/oreka/serializers/test/TestNestedMessage.xml b/orkbasej/java/net/sf/oreka/serializers/test/TestNestedMessage.xml
new file mode 100644
index 0000000..0309449
--- /dev/null
+++ b/orkbasej/java/net/sf/oreka/serializers/test/TestNestedMessage.xml
@@ -0,0 +1,6 @@
+<testnested>
+  <intParm>546</intParm>
+  <testsub>
+  	<stringsubparm>hello</stringsubparm>
+  </testsub>
+</testnested>
\ No newline at end of file