Initial revision

rg2023 [2002-09-29 21:31:09]
Initial revision
Filename
csharpsrc/DAML/AssemblyInfo.cs
csharpsrc/DAML/DAML.csproj
csharpsrc/DAML/DAML.csproj.user
csharpsrc/DAML/DAML.sln
csharpsrc/DAML/DAML.suo
csharpsrc/DAML/DAMLConstants.cs
csharpsrc/DAML/DAMLContainer.cs
csharpsrc/DAML/DAMLProcess.cs
csharpsrc/DAML/DAMLProcessModel.cs
csharpsrc/DAML/DAMLServiceProfile.cs
csharpsrc/DAML/IIOPEXPathExprBuilder.cs
csharpsrc/DAML/IOPEXPathExprBuilderFactory.cs
csharpsrc/DAML/XPathExprBuilders.cs
diff --git a/csharpsrc/DAML/AssemblyInfo.cs b/csharpsrc/DAML/AssemblyInfo.cs
new file mode 100644
index 0000000..177a4f0
--- /dev/null
+++ b/csharpsrc/DAML/AssemblyInfo.cs
@@ -0,0 +1,58 @@
+using System.Reflection;
+using System.Runtime.CompilerServices;
+
+//
+// General Information about an assembly is controlled through the following
+// set of attributes. Change these attribute values to modify the information
+// associated with an assembly.
+//
+[assembly: AssemblyTitle("")]
+[assembly: AssemblyDescription("")]
+[assembly: AssemblyConfiguration("")]
+[assembly: AssemblyCompany("")]
+[assembly: AssemblyProduct("")]
+[assembly: AssemblyCopyright("")]
+[assembly: AssemblyTrademark("")]
+[assembly: AssemblyCulture("")]
+
+//
+// Version information for an assembly consists of the following four values:
+//
+//      Major Version
+//      Minor Version
+//      Build Number
+//      Revision
+//
+// You can specify all the values or you can default the Revision and Build Numbers
+// by using the '*' as shown below:
+
+[assembly: AssemblyVersion("1.0.*")]
+
+//
+// In order to sign your assembly you must specify a key to use. Refer to the
+// Microsoft .NET Framework documentation for more information on assembly signing.
+//
+// Use the attributes below to control which key is used for signing.
+//
+// Notes:
+//   (*) If no key is specified, the assembly is not signed.
+//   (*) KeyName refers to a key that has been installed in the Crypto Service
+//       Provider (CSP) on your machine. KeyFile refers to a file which contains
+//       a key.
+//   (*) If the KeyFile and the KeyName values are both specified, the
+//       following processing occurs:
+//       (1) If the KeyName can be found in the CSP, that key is used.
+//       (2) If the KeyName does not exist and the KeyFile does exist, the key
+//           in the KeyFile is installed into the CSP and used.
+//   (*) In order to create a KeyFile, you can use the sn.exe (Strong Name) utility.
+//       When specifying the KeyFile, the location of the KeyFile should be
+//       relative to the project output directory which is
+//       %Project Directory%\obj\<configuration>. For example, if your KeyFile is
+//       located in the project directory, you would specify the AssemblyKeyFile
+//       attribute as [assembly: AssemblyKeyFile("..\\..\\mykey.snk")]
+//   (*) Delay Signing is an advanced option - see the Microsoft .NET Framework
+//       documentation for more information on this.
+//
+[assembly: AssemblyDelaySign(false)]
+[assembly: AssemblyKeyFile("")]
+[assembly: AssemblyKeyName("")]
diff --git a/csharpsrc/DAML/DAML.csproj b/csharpsrc/DAML/DAML.csproj
new file mode 100644
index 0000000..d318992
--- /dev/null
+++ b/csharpsrc/DAML/DAML.csproj
@@ -0,0 +1,128 @@
+<VisualStudioProject>
+    <CSHARP
+        ProjectType = "Local"
+        ProductVersion = "7.0.9466"
+        SchemaVersion = "1.0"
+        ProjectGuid = "{D6D21127-BBC0-4407-A2D1-0D9B183E920B}"
+    >
+        <Build>
+            <Settings
+                ApplicationIcon = ""
+                AssemblyKeyContainerName = ""
+                AssemblyName = "DAML"
+                AssemblyOriginatorKeyFile = ""
+                DefaultClientScript = "JScript"
+                DefaultHTMLPageLayout = "Grid"
+                DefaultTargetSchema = "IE50"
+                DelaySign = "false"
+                OutputType = "Library"
+                RootNamespace = "PSL.DAML"
+                StartupObject = ""
+            >
+                <Config
+                    Name = "Debug"
+                    AllowUnsafeBlocks = "false"
+                    BaseAddress = "285212672"
+                    CheckForOverflowUnderflow = "false"
+                    ConfigurationOverrideFile = ""
+                    DefineConstants = "DEBUG;TRACE"
+                    DocumentationFile = ""
+                    DebugSymbols = "true"
+                    FileAlignment = "4096"
+                    IncrementalBuild = "true"
+                    Optimize = "false"
+                    OutputPath = "..\..\bin\"
+                    RegisterForComInterop = "false"
+                    RemoveIntegerChecks = "false"
+                    TreatWarningsAsErrors = "false"
+                    WarningLevel = "4"
+                />
+                <Config
+                    Name = "Release"
+                    AllowUnsafeBlocks = "false"
+                    BaseAddress = "285212672"
+                    CheckForOverflowUnderflow = "false"
+                    ConfigurationOverrideFile = ""
+                    DefineConstants = "TRACE"
+                    DocumentationFile = ""
+                    DebugSymbols = "false"
+                    FileAlignment = "4096"
+                    IncrementalBuild = "false"
+                    Optimize = "true"
+                    OutputPath = "bin\Release\"
+                    RegisterForComInterop = "false"
+                    RemoveIntegerChecks = "false"
+                    TreatWarningsAsErrors = "false"
+                    WarningLevel = "4"
+                />
+            </Settings>
+            <References>
+                <Reference
+                    Name = "System"
+                    AssemblyName = "System"
+                    HintPath = "..\..\..\..\..\WINDOWS\Microsoft.NET\Framework\v1.0.3705\System.dll"
+                />
+                <Reference
+                    Name = "System.Data"
+                    AssemblyName = "System.Data"
+                    HintPath = "..\..\..\..\..\WINDOWS\Microsoft.NET\Framework\v1.0.3705\System.Data.dll"
+                />
+                <Reference
+                    Name = "System.XML"
+                    AssemblyName = "System.XML"
+                    HintPath = "..\..\..\..\..\WINDOWS\Microsoft.NET\Framework\v1.0.3705\System.XML.dll"
+                />
+            </References>
+        </Build>
+        <Files>
+            <Include>
+                <File
+                    RelPath = "AssemblyInfo.cs"
+                    SubType = "Code"
+                    BuildAction = "Compile"
+                />
+                <File
+                    RelPath = "DAMLConstants.cs"
+                    SubType = "Code"
+                    BuildAction = "Compile"
+                />
+                <File
+                    RelPath = "DAMLContainer.cs"
+                    SubType = "Code"
+                    BuildAction = "Compile"
+                />
+                <File
+                    RelPath = "DAMLProcess.cs"
+                    SubType = "Code"
+                    BuildAction = "Compile"
+                />
+                <File
+                    RelPath = "DAMLProcessModel.cs"
+                    SubType = "Code"
+                    BuildAction = "Compile"
+                />
+                <File
+                    RelPath = "DAMLServiceProfile.cs"
+                    SubType = "Code"
+                    BuildAction = "Compile"
+                />
+                <File
+                    RelPath = "IIOPEXPathExprBuilder.cs"
+                    SubType = "Code"
+                    BuildAction = "Compile"
+                />
+                <File
+                    RelPath = "IOPEXPathExprBuilderFactory.cs"
+                    SubType = "Code"
+                    BuildAction = "Compile"
+                />
+                <File
+                    RelPath = "XPathExprBuilders.cs"
+                    SubType = "Code"
+                    BuildAction = "Compile"
+                />
+            </Include>
+        </Files>
+    </CSHARP>
+</VisualStudioProject>
+
diff --git a/csharpsrc/DAML/DAML.csproj.user b/csharpsrc/DAML/DAML.csproj.user
new file mode 100644
index 0000000..4089d2b
--- /dev/null
+++ b/csharpsrc/DAML/DAML.csproj.user
@@ -0,0 +1,48 @@
+<VisualStudioProject>
+    <CSHARP>
+        <Build>
+            <Settings ReferencePath = "" >
+                <Config
+                    Name = "Debug"
+                    EnableASPDebugging = "false"
+                    EnableASPXDebugging = "false"
+                    EnableUnmanagedDebugging = "false"
+                    EnableSQLServerDebugging = "false"
+                    RemoteDebugEnabled = "false"
+                    RemoteDebugMachine = ""
+                    StartAction = "Project"
+                    StartArguments = ""
+                    StartPage = ""
+                    StartProgram = ""
+                    StartURL = ""
+                    StartWorkingDirectory = ""
+                    StartWithIE = "false"
+                />
+                <Config
+                    Name = "Release"
+                    EnableASPDebugging = "false"
+                    EnableASPXDebugging = "false"
+                    EnableUnmanagedDebugging = "false"
+                    EnableSQLServerDebugging = "false"
+                    RemoteDebugEnabled = "false"
+                    RemoteDebugMachine = ""
+                    StartAction = "Project"
+                    StartArguments = ""
+                    StartPage = ""
+                    StartProgram = ""
+                    StartURL = ""
+                    StartWorkingDirectory = ""
+                    StartWithIE = "false"
+                />
+            </Settings>
+        </Build>
+        <OtherProjectSettings
+            CopyProjectDestinationFolder = ""
+            CopyProjectUncPath = ""
+            CopyProjectOption = "0"
+            ProjectView = "ProjectFiles"
+            ProjectTrust = "0"
+        />
+    </CSHARP>
+</VisualStudioProject>
+
diff --git a/csharpsrc/DAML/DAML.sln b/csharpsrc/DAML/DAML.sln
new file mode 100644
index 0000000..eb5d77f
--- /dev/null
+++ b/csharpsrc/DAML/DAML.sln
@@ -0,0 +1,21 @@
+Microsoft Visual Studio Solution File, Format Version 7.00
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "DAML", "DAML.csproj", "{D6D21127-BBC0-4407-A2D1-0D9B183E920B}"
+EndProject
+Global
+	GlobalSection(SolutionConfiguration) = preSolution
+		ConfigName.0 = Debug
+		ConfigName.1 = Release
+	EndGlobalSection
+	GlobalSection(ProjectDependencies) = postSolution
+	EndGlobalSection
+	GlobalSection(ProjectConfiguration) = postSolution
+		{D6D21127-BBC0-4407-A2D1-0D9B183E920B}.Debug.ActiveCfg = Debug|.NET
+		{D6D21127-BBC0-4407-A2D1-0D9B183E920B}.Debug.Build.0 = Debug|.NET
+		{D6D21127-BBC0-4407-A2D1-0D9B183E920B}.Release.ActiveCfg = Release|.NET
+		{D6D21127-BBC0-4407-A2D1-0D9B183E920B}.Release.Build.0 = Release|.NET
+	EndGlobalSection
+	GlobalSection(ExtensibilityGlobals) = postSolution
+	EndGlobalSection
+	GlobalSection(ExtensibilityAddIns) = postSolution
+	EndGlobalSection
+EndGlobal
diff --git a/csharpsrc/DAML/DAML.suo b/csharpsrc/DAML/DAML.suo
new file mode 100644
index 0000000..74c3051
Binary files /dev/null and b/csharpsrc/DAML/DAML.suo differ
diff --git a/csharpsrc/DAML/DAMLConstants.cs b/csharpsrc/DAML/DAMLConstants.cs
new file mode 100644
index 0000000..995523a
--- /dev/null
+++ b/csharpsrc/DAML/DAMLConstants.cs
@@ -0,0 +1,176 @@
+using System;
+
+namespace PSL.DAML
+{
+	public enum enuIOPEType
+	{
+		Input, // ServiceProfile entity
+		Output, // ServiceProfile entity
+		Precondition, // ServiceProfile entity
+		Effect, // ServiceProfile entity
+		ConditionalOutput, // ProcessModel entity
+		CoCondition, // ProcessModel entity
+		CoOutput, // ProcessModel entity
+		Parameter // ProcessModel entity
+	};
+
+	public class RDFProperty
+	{
+		private string m_strName = "";
+		private string m_strSubPropertyOf = "";
+		private string m_strDomain = "";
+		private string m_strRange = "";
+		private string m_strSameValueAs = "";
+
+		public RDFProperty()
+		{}
+
+		public string Name
+		{
+			get
+			{ return m_strName; }
+			set
+			{ m_strName = value; }
+		}
+		public string SubPropertyOf
+		{
+			get
+			{ return m_strSubPropertyOf; }
+			set
+			{ m_strSubPropertyOf = value; }
+		}
+
+		public string Domain
+		{
+			get
+			{ return m_strDomain; }
+			set
+			{ m_strDomain = value; }
+		}
+
+		public string Range
+		{
+			get
+			{ return m_strRange; }
+			set
+			{ m_strRange = value; }
+		}
+
+		public string SameValueAs
+		{
+			get
+			{ return m_strSameValueAs; }
+			set
+			{ m_strSameValueAs = value; }
+		}
+	}
+
+	public abstract class DAMLConstants
+	{
+		//*********************************************************************//
+
+		// Namespace constants usually present in DAML docs
+
+		//*********************************************************************//
+
+		public const string XMLNS = "xmlns";
+		// Known namespaces expected in Profile
+		public const string RDFS_NS = "rdfs";
+		public const string RDF_NS = "rdf";
+		public const string DAML_NS = "daml";
+		public const string SERVICE_NS = "service";
+		public const string PROCESS_NS = "process";
+		public const string PROFILE_NS = "profile";
+		public const string TIME_NS = "time";
+		public const string XSD_NS = "xsd";
+		public const string DEFAULT_NS = "DEFAULT_NS";
+		// Known elements expected in Profile
+		// DAML Constants (nodes)
+		public const string DAML_ONTOLOGY = DAML_NS + ":Ontology";
+		public const string DAML_VERSIONINFO = DAML_NS + ":versionInfo";
+		public const string DAML_IMPORTS = DAML_NS + ":imports";
+		public const string DAML_SAMEVALUESAS = DAML_NS + ":sameValuesAs";
+		public const string DAML_RESTRICTION = DAML_NS + ":Restriction";
+		public const string DAML_ON_PROPERTY = DAML_NS + ":onProperty";
+		public const string DAML_CARDINALITY = DAML_NS + ":cardinality";
+		public const string DAML_COLLECTION = DAML_NS + ":collection";
+		public const string DAML_INTERSECTION_OF = DAML_NS + ":intersectionOf";
+		public const string DAML_LIST_OF_INSTANCES_OF = DAML_NS + ":listOfInstancesOf";
+		// RDF Constants (attributes)
+		public const string RDF_RESOURCE = RDF_NS + ":resource";
+		public const string RDF_COMMENT = RDF_NS + ":comment";
+		public const string RDF_ID = RDF_NS + ":ID";
+		public const string RDF_PROPERTY = RDF_NS + ":Property";
+		public const string RDF_PARSE_TYPE = RDF_NS + ":parseType";
+		public const string RDF_ABOUT = RDF_NS + ":about";
+		// RDFS Constants (attributes)
+		public const string RDFS_SUBCLASSOF = RDFS_NS + ":subClassOf";
+		public const string RDFS_SUBPROPERTYOF = RDFS_NS + ":subPropertyOf";
+		public const string RDFS_DOMAIN = RDFS_NS + ":domain";
+		public const string RDFS_RANGE = RDFS_NS + ":range";
+
+		//*********************************************************************//
+
+		// DAML-S Service Profile constants
+
+		//*********************************************************************//
+
+		// Service Constants (nodes)
+		public const string SERVICE_PROFILE = SERVICE_NS + ":ServiceProfile";
+		public const string SERVICE_PRESENTED_BY = SERVICE_NS + ":isPresentedBy";
+		// Profile Constants (nodes)
+		public const string PROFILE_SERVICE_NAME = PROFILE_NS + ":serviceName";
+		public const string PROFILE_TEXT_DESC = PROFILE_NS + ":textDescription";
+		public const string PROFILE_INTENDED_PURPOSE = PROFILE_NS + ":intendedPurpose";
+		public const string PROFILE_PROVIDED_BY = PROFILE_NS + ":providedBy";
+		public const string PROFILE_REQUESTED_BY = PROFILE_NS + ":requestedBy";
+		public const string PROFILE_SERVICE_PROVIDER = PROFILE_NS + ":ServiceProvider";
+		public const string PROFILE_NAME = PROFILE_NS + ":name";
+		public const string PROFILE_PHONE = PROFILE_NS + ":phone";
+		public const string PROFILE_FAX = PROFILE_NS + ":fax";
+		public const string PROFILE_EMAIL = PROFILE_NS + ":email";
+		public const string PROFILE_PHYSICAL_ADDRESS = PROFILE_NS + ":physicalAddress";
+		public const string PROFILE_WEB_URL = PROFILE_NS + ":webURL";
+		public const string PROFILE_GEOG_RADIUS = PROFILE_NS + ":geographicRadius";
+		public const string PROFILE_QUALITY_RATING = PROFILE_NS + ":qualityRating";
+		public const string PROFILE_HAS_PROCESS = PROFILE_NS + ":has_process";
+		// Constants related to IOPEs
+		public const string PROFILE_PARAM_DESC = PROFILE_NS + ":ParameterDescription";
+		public const string PROFILE_PARAM_NAME = PROFILE_NS + ":parameterName";
+		public const string PROFILE_RESTRICTED_TO = PROFILE_NS + ":restrictedTo";
+		public const string PROFILE_REFERS_TO = PROFILE_NS + ":refersTo";
+		public const string PROFILE_CONDITION_DESC = PROFILE_NS + ":ConditionDescription";
+		public const string PROFILE_CONDITION_NAME = PROFILE_NS + ":conditionName";
+		public const string PROFILE_STATEMENT = PROFILE_NS + ":statement";
+		// Constants related to Processes
+		public const string PROCESS_SEQUENCE = PROCESS_NS + ":Sequence";
+		public const string PROCESS_CHOICE = PROCESS_NS + ":Choice";
+		// IOPE Constants - Inputs, Outputs, PreConditions, Effects
+		public const string INPUT = "input";
+		public const string OUTPUT = "output";
+		public const string PRECONDITION = "precondition";
+		public const string EFFECT = "effect";
+		// Additional IOPE Constants
+		public const string CONDITIONAL_OUTPUT = "conditionalOutput";
+		public const string CO_CONDITION = "coCondition";
+		public const string CO_OUTPUT = "coOutput";
+		public const string PARAMETER = "parameter";
+		// Misc constants used in ProcessModels
+		public const string PROCESS_COMPONENTS = "components";
+		public const string PROCESS_COMPOSED_OF = "composedOf";
+
+		//*********************************************************************//
+
+		// DAML-S Process Model constants
+
+		//*********************************************************************//
+
+		public const string DAML_CLASS = DAML_NS + ":Class";
+		public const string DAML_SIMPLE_PROCESS = "SimpleProcess";
+		public const string DAML_COMPOSITE_PROCESS = "CompositeProcess";
+		public const string DAML_ATOMIC_PROCESS = "AtomicProcess";
+
+		public DAMLConstants()
+		{}
+	}
+}
diff --git a/csharpsrc/DAML/DAMLContainer.cs b/csharpsrc/DAML/DAMLContainer.cs
new file mode 100644
index 0000000..a37a720
--- /dev/null
+++ b/csharpsrc/DAML/DAMLContainer.cs
@@ -0,0 +1,126 @@
+using System;
+using System.Xml;
+using System.Xml.XPath;
+using System.Collections;
+using System.Diagnostics;
+using System.Xml.Serialization;
+
+namespace PSL.DAML
+{
+	/// <summary>
+	/// Basic base class for all DAML Document containers e.g DAMLProcessModel
+	/// and DAMLServiceProfile
+	/// </summary>
+	public abstract class DAMLContainer
+	{
+		// Member variables
+		protected XmlDocument m_doc;
+		protected XmlNamespaceManager m_mgr;
+		protected EventLog m_EvtLog;
+
+		public DAMLContainer()
+		{}
+
+
+		// Need virtual methods to load from:
+		// file/unc path
+		// url/uri
+		// stream
+		// xml string - already implemented
+
+		/* Function loads an Xml Document from a (possibly large) string
+		 * Inputs: strXml - string containing document text
+		 * Return value: true on successful load
+		 *				 false otherwise
+		 */
+		public virtual bool LoadXml( string strXml )
+		{
+			bool bStatus = false;
+
+			try
+			{
+				m_doc.LoadXml( strXml );
+				// Move to root element
+				XmlNode root = m_doc.DocumentElement;
+				// Get attributes of root element
+				XmlAttributeCollection attColl = root.Attributes;
+				// TODO: Should use PopScope instead??
+				if( m_mgr != null )
+				{
+					//m_mgr.PopScope();
+					m_mgr = null;
+				}
+
+				m_mgr = new XmlNamespaceManager( m_doc.NameTable );
+				//m_mgr.PushScope();
+
+				for( int i = 0; i < attColl.Count; i++ )
+				{
+					// Extract all namespaces we can find in document root
+					// and add to namespace manager
+
+					string strValue = attColl[i].InnerText;
+
+					if( attColl[i].Prefix == DAMLConstants.XMLNS )
+						m_mgr.AddNamespace( attColl[i].LocalName, strValue );
+
+					// Add default namespace (if any) and add to namespace manager
+					if( attColl[i].Prefix == "" )
+						m_mgr.AddNamespace( DAMLConstants.DEFAULT_NS, strValue );
+				}
+
+				bStatus = true;
+			}
+			catch( Exception e )
+			{
+				m_EvtLog.WriteEntry( e.Message, EventLogEntryType.Error );
+			}
+
+			return bStatus;
+		}
+
+		/* Function returns an array of all the ontology imports defined in a
+		 * DAML document.
+		 *
+		 * Inputs: none
+		 * Return value: an array of Ontology imports defined in the document
+		 */
+		protected virtual string[] GetOntologyImports()
+		{
+			ArrayList arrImports = new ArrayList();
+
+			try
+			{
+				XmlNode root = m_doc.DocumentElement;
+				XmlNode node = root.SelectSingleNode( DAMLConstants.DAML_ONTOLOGY, m_mgr );
+
+				if( node == null )
+					return null;
+
+				XmlNodeList lstImports = node.SelectNodes( DAMLConstants.DAML_IMPORTS, m_mgr );
+
+				if( lstImports.Count == 0 )
+					return null;
+
+				// Go thru list of imports and get all rdf:resource attribute values
+				// these are the imports
+				for( int i = 0; i < lstImports.Count; i++ )
+				{
+					XmlAttributeCollection attColl = lstImports[i].Attributes;
+					foreach( XmlAttribute att in attColl )
+					{
+						if( att.Name == DAMLConstants.RDF_RESOURCE )
+							arrImports.Add( att.Value );
+					}
+				}
+			}
+			catch( Exception e )
+			{
+				m_EvtLog.WriteEntry( e.Message, EventLogEntryType.Error );
+			}
+
+			return (string[]) arrImports.ToArray( typeof( System.String ) );
+		}// End GetOntologyImports
+
+	}
+}
diff --git a/csharpsrc/DAML/DAMLProcess.cs b/csharpsrc/DAML/DAMLProcess.cs
new file mode 100644
index 0000000..4e5aea0
--- /dev/null
+++ b/csharpsrc/DAML/DAMLProcess.cs
@@ -0,0 +1,486 @@
+using System;
+using System.Collections;
+
+namespace PSL.DAML
+{
+	//
+	public enum enuProcessSubTaskType
+	{
+		Sequence, // process:Sequence attribute
+		Choice	// process:Choice attribute
+	};
+
+	public class DAMLProcess
+	{
+		// All Processes have...
+		protected enuProcessType m_Type = enuProcessType.AtomicProcess;
+		protected string m_strName = "";
+		// Map input names to number of restrictions
+		protected Hashtable m_InputRestrictionMap = new Hashtable();
+		// Composite processes only have...
+		protected enuProcessSubTaskType m_SubTaskType;
+
+		// Each of these types represented as an RDFProperty
+		// A collection of inputs
+		protected ArrayList m_arrInputs = new ArrayList();
+		// A collection of outputs
+		protected ArrayList m_arrOutputs = new ArrayList();
+		// A collection of preconditions
+		protected ArrayList m_arrPreconditions = new ArrayList();
+		// A collection of effects
+		protected ArrayList m_arrEffects = new ArrayList();
+		// A collection of ConditionalOutputs
+		protected ArrayList m_arrConditionalOutputs = new ArrayList();
+		// A collection of CoConditions
+		protected ArrayList m_arrCoConditions = new ArrayList();
+		// A collection of CoOutputs
+		protected ArrayList m_arrCoOutputs = new ArrayList();
+		// A collection of Parameters
+		protected ArrayList m_arrParameters = new ArrayList();
+		// A collection of sub-steps (applicable for composite processes only)
+		protected ArrayList m_arrSubProcesses = new ArrayList();
+
+		/* Constructor */
+		public DAMLProcess()
+		{
+		}
+
+		// Properties
+		public enuProcessType ProcessType
+		{
+			get
+			{ return m_Type; }
+			set
+			{ m_Type = value; }
+		}
+
+		// ONLY for Composite processes - should subclass to hide?
+		public enuProcessSubTaskType SubTaskType
+		{
+			get
+			{ return m_SubTaskType; }
+			set
+			{ m_SubTaskType = value; }
+		}
+
+		public string Name
+		{
+			get
+			{ return m_strName; }
+			set
+			{ m_strName = value; }
+		}
+
+		public RDFProperty[] Inputs
+		{
+			get
+			{ return (RDFProperty[]) m_arrInputs.ToArray( typeof(RDFProperty) ); }
+		}
+
+		public RDFProperty[] Outputs
+		{
+			get
+			{ return (RDFProperty[]) m_arrOutputs.ToArray( typeof(RDFProperty) ); }
+		}
+
+		public RDFProperty[] Preconditions
+		{
+			get
+			{ return (RDFProperty[]) m_arrPreconditions.ToArray( typeof(RDFProperty) ); }
+		}
+
+		public RDFProperty[] Effects
+		{
+			get
+			{ return (RDFProperty[]) m_arrEffects.ToArray( typeof(RDFProperty) ); }
+		}
+
+		public RDFProperty[] ConditionalOutputs
+		{
+			get
+			{ return (RDFProperty[]) m_arrConditionalOutputs.ToArray( typeof(RDFProperty) ); }
+		}
+
+		public RDFProperty[] CoConditions
+		{
+			get
+			{ return (RDFProperty[]) m_arrCoConditions.ToArray( typeof(RDFProperty) ); }
+		}
+
+		public RDFProperty[] CoOutputs
+		{
+			get
+			{ return (RDFProperty[]) m_arrCoOutputs.ToArray( typeof(RDFProperty) ); }
+		}
+
+		public RDFProperty[] Parameters
+		{
+			get
+			{ return (RDFProperty[]) m_arrParameters.ToArray( typeof(RDFProperty) ); }
+		}
+
+		public DAMLProcess[] SubProcesses
+		{
+			get
+			{ return (DAMLProcess[]) m_arrSubProcesses.ToArray( typeof(DAMLProcess) ); }
+		}
+
+		/* Function returns the cardinality restrictions on a given named
+		 * input.
+		 *
+		 * Input: strInputName - named input
+		 * Return value: the cardinality (if the input does not exist 0 returned)
+		 */
+		public int GetInputRestriction( string strInputName )
+		{
+			if( !m_InputRestrictionMap.ContainsKey( strInputName ) )
+				return 0;
+			else return (int) m_InputRestrictionMap[strInputName];
+		}
+
+		/* Procedure Adds an input to a DAMLProcess
+		 *
+		 * Inputs: data - RDFProperty details of the input
+		 */
+		public void AddInput( RDFProperty data )
+		{
+			m_arrInputs.Add( data );
+		}
+
+		/* Procedure Adds an array of inputs to a DAMLProcess
+		 *
+		 * Inputs: arrData - RDFProperty details of the inputs
+		 */
+		public void AddInput( RDFProperty[] arrData )
+		{
+			m_arrInputs.AddRange( arrData );
+		}
+
+		/* Procedure Adds an output to a DAMLProcess
+		 *
+		 * Inputs: data - RDFProperty details of the output
+		 */
+		public void AddOutput( RDFProperty data )
+		{
+			m_arrOutputs.Add( data );
+		}
+
+		/* Procedure Adds an array of outputs to a DAMLProcess
+		 *
+		 * Inputs: arrData - RDFProperty details of the outputs
+		 */
+		public void AddOutput( RDFProperty[] arrData )
+		{
+			m_arrOutputs.AddRange( arrData );
+		}
+
+		/* Procedure Adds a precondition to a DAMLProcess
+		 *
+		 * Inputs: data - RDFProperty details of the precondition
+		 */
+		public void AddPrecondition( RDFProperty data )
+		{
+			m_arrPreconditions.Add( data );
+		}
+
+		/* Procedure Adds an array of preconditions to a DAMLProcess
+		 *
+		 * Inputs: arrData - RDFProperty details of the preconditions
+		 */
+		public void AddPrecondition( RDFProperty[] arrData )
+		{
+			m_arrPreconditions.AddRange( arrData );
+		}
+
+		/* Procedure Adds an effect to a DAMLProcess
+		 *
+		 * Inputs: data - RDFProperty details of the effect
+		 */
+		public void AddEffect( RDFProperty data )
+		{
+			m_arrEffects.Add( data );
+		}
+
+		/* Procedure Adds an array of effects to a DAMLProcess
+		 *
+		 * Inputs: arrData - RDFProperty details of the effects
+		 */
+		public void AddEffect( RDFProperty[] arrData )
+		{
+			m_arrEffects.AddRange( arrData );
+		}
+
+		/* Procedure Adds a conditional output to a DAMLProcess
+		 *
+		 * Inputs: data - RDFProperty details of the conditional output
+		 */
+		public void AddConditionalOutput( RDFProperty data )
+		{
+			m_arrConditionalOutputs.Add( data );
+		}
+
+		/* Procedure Adds an array of conditional outputs to a DAMLProcess
+		 *
+		 * Inputs: arrData - RDFProperty details of the conditional outputs
+		 */
+		public void AddConditionalOutput( RDFProperty[] arrData )
+		{
+			m_arrConditionalOutputs.AddRange( arrData );
+		}
+
+		/* Procedure Adds a co-condition to a DAMLProcess
+		 *
+		 * Inputs: data - RDFProperty details of the co-condition
+		 */
+		public void AddCoCondition( RDFProperty data )
+		{
+			m_arrCoConditions.Add( data );
+		}
+
+		/* Procedure Adds an array of co-conditions to a DAMLProcess
+		 *
+		 * Inputs: arrData - RDFProperty details of the co-conditions
+		 */
+		public void AddCoCondition( RDFProperty[] arrData )
+		{
+			m_arrCoConditions.AddRange( arrData );
+		}
+
+		/* Procedure Adds a co-output to a DAMLProcess
+		 *
+		 * Inputs: data - RDFProperty details of the co-output
+		 */
+		public void AddCoOutput( RDFProperty data )
+		{
+			m_arrCoOutputs.Add( data );
+		}
+
+		/* Procedure Adds an array of co-outputs to a DAMLProcess
+		 *
+		 * Inputs: arrData - RDFProperty details of the co-outputs
+		 */
+		public void AddCoOutput( RDFProperty[] arrData )
+		{
+			m_arrCoOutputs.AddRange( arrData );
+		}
+
+		/* Procedure Adds a parameter to a DAMLProcess
+		 *
+		 * Inputs: data - RDFProperty details of the parameter
+		 */
+		public void AddParameter( RDFProperty data )
+		{
+			m_arrParameters.Add( data );
+		}
+
+		/* Procedure Adds an array of parameters to a DAMLProcess
+		 *
+		 * Inputs: arrData - RDFProperty details of the parameters
+		 */
+		public void AddParameter( RDFProperty[] arrData )
+		{
+			m_arrParameters.AddRange( arrData );
+		}
+
+		/* Procedure Adds a subprocess to a (composite) DAMLProcess
+		 *
+		 * Inputs: data - DAMLProcess details of the process
+		 *
+		 * Exceptions: throws InvalidOperationException if the process is not being
+		 *			   added to a Composite DAMLProcess. ONLY Composite DAMLProcesses
+		 *			   support subprocesses.
+		 */
+		public void AddSubProcess( DAMLProcess data )
+		{
+			if( ProcessType == enuProcessType.CompositeProcess )
+				m_arrSubProcesses.Add( data );
+			else throw new InvalidOperationException( "Only Composite Processes can have SubProcesses" );
+		}
+
+		/* Procedure Adds an array of subprocess to a (composite) DAMLProcess
+		 *
+		 * Inputs: arrData - DAMLProcess details of the processes
+		 *
+		 * Exceptions: throws InvalidOperationException if the processes are not being
+		 *			   added to a Composite DAMLProcess. ONLY Composite DAMLProcesses
+		 *			   support subprocesses.
+		 */
+		public void AddSubProcess( DAMLProcess[] arrData )
+		{
+			if( ProcessType == enuProcessType.CompositeProcess )
+				m_arrSubProcesses.AddRange( arrData );
+			else throw new InvalidOperationException( "Only Composite Processes can have SubProcesses" );
+		}
+
+		/* Procedure adds an input (cardinality) restriction
+		 *
+		 * Inputs: strInput - named input
+		 *		   nRestriction - cardinality of strInput
+		 */
+		public void AddInputRestriction( string strInput, int nRestriction )
+		{
+			m_InputRestrictionMap.Add( strInput, nRestriction );
+		}
+
+		/* Procedure clears all inputs
+		 */
+		public void ClearInputs()
+		{
+			m_arrInputs.Clear();
+		}
+
+		/* Procedure clears all outputs
+		 */
+		public void ClearOutputs()
+		{
+			m_arrOutputs.Clear();
+		}
+
+		/* Procedure clears all preconditions
+		 */
+		public void ClearPreconditons()
+		{
+			m_arrPreconditions.Clear();
+		}
+
+		/* Procedure clears all effects
+		 */
+		public void ClearEffects()
+		{
+			m_arrEffects.Clear();
+		}
+
+		/* Procedure clears all conditional outputs
+		 */
+		public void ClearConditionalOutputs()
+		{
+			m_arrConditionalOutputs.Clear();
+		}
+
+		/* Procedure clears all co-conditions
+		 */
+		public void ClearCoConditions()
+		{
+			m_arrCoConditions.Clear();
+		}
+
+		/* Procedure clears all co-outputs
+		 */
+		public void ClearCoOutputs()
+		{
+			m_arrCoOutputs.Clear();
+		}
+
+		/* Procedure clears all parameters
+		 */
+		public void ClearParameters()
+		{
+			m_arrParameters.Clear();
+		}
+
+		/* Procedure clears all sub processes
+		 */
+		public void ClearSubProcesses()
+		{
+			m_arrSubProcesses.Clear();
+		}
+
+		/* Procedure clears the input restriction map
+		 */
+		public void ClearRestrictionMap()
+		{
+			m_InputRestrictionMap.Clear();
+		}
+
+		/* Procedure clears all the constituent data structures used to store
+		 * process info
+		 */
+		public void ClearAll()
+		{
+			this.ClearCoConditions();
+			this.ClearConditionalOutputs();
+			this.ClearCoOutputs();
+			this.ClearEffects();
+			this.ClearInputs();
+			this.ClearOutputs();
+			this.ClearParameters();
+			this.ClearPreconditons();
+			this.ClearRestrictionMap();
+			this.ClearSubProcesses();
+		}
+
+		// HasXXXX
+		public bool HasInputs
+		{
+			get
+			{ return m_arrInputs.Count > 0; }
+		}
+
+		public bool HasOutputs
+		{
+			get
+			{ return m_arrOutputs.Count > 0; }
+		}
+
+		public bool HasPreconditions
+		{
+			get
+			{ return m_arrPreconditions.Count > 0; }
+		}
+		public bool HasEffects
+		{
+			get
+			{ return m_arrEffects.Count > 0; }
+		}
+
+		public bool HasConditionalOutputs
+		{
+			get
+			{ return m_arrConditionalOutputs.Count > 0; }
+		}
+
+		public bool HasCoConditions
+		{
+			get
+			{ return m_arrCoConditions.Count > 0; }
+		}
+		public bool HasCoOutputs
+		{
+			get
+			{ return m_arrCoOutputs.Count > 0; }
+		}
+		public bool HasParameters
+		{
+			get
+			{ return m_arrParameters.Count > 0; }
+		}
+
+		public bool HasSubProcesses
+		{
+			get
+			{
+				// Only Composite Processes can have subprocesses
+				if( ProcessType != enuProcessType.CompositeProcess )
+					return false;
+
+				return m_arrSubProcesses.Count > 0;
+			}
+		}
+
+		public bool HasData
+		{
+			get
+			{
+				bool bLVal = ( HasInputs || HasOutputs ) || ( HasPreconditions || HasEffects );
+				bool bRVal = ( HasConditionalOutputs || HasCoConditions ) || ( HasCoOutputs || HasParameters );
+				return ( bLVal || bRVal ) || HasSubProcesses;
+			}
+		}
+
+		public bool isEmpty
+		{
+			get
+			{ return !HasData; }
+		}
+	}
+}
diff --git a/csharpsrc/DAML/DAMLProcessModel.cs b/csharpsrc/DAML/DAMLProcessModel.cs
new file mode 100644
index 0000000..0bc4ad9
--- /dev/null
+++ b/csharpsrc/DAML/DAMLProcessModel.cs
@@ -0,0 +1,489 @@
+using System;
+using System.Xml;
+using System.Xml.XPath;
+using System.Collections;
+using System.Diagnostics;
+using System.Xml.Serialization;
+
+namespace PSL.DAML
+{
+	public enum enuProcessType
+	{
+		AtomicProcess,
+		CompositeProcess,
+		SimpleProcess
+	};
+
+	/// <summary>
+	/// Summary description for DAMLProcessModel.
+	/// </summary>
+	public class DAMLProcessModel:DAMLContainer
+	{
+		public const int DEFAULT_RESTRICTION = 1;
+
+		public DAMLProcessModel()
+		{
+			// Init inherited members
+			m_EvtLog = new EventLog( "Application" );
+			m_EvtLog.Source = "DAMLProcessModel";
+			m_doc = new XmlDocument();
+			m_mgr = null;
+		}
+
+
+		public string[] AtomicProcesses
+		{
+			get
+			{ return GetProcesses( enuProcessType.AtomicProcess ); }
+		}
+
+		public string[] CompositeProcesses
+		{
+			get
+			{ return GetProcesses( enuProcessType.CompositeProcess ); }
+		}
+
+		public string[] SimpleProcesses
+		{
+			get
+			{ return GetProcesses( enuProcessType.SimpleProcess ); }
+		}
+
+		public string[] AllProcesses
+		{
+			get
+			{
+				ArrayList arrProcesses = new ArrayList();
+
+				string[] arrAtomic = AtomicProcesses;
+				string[] arrComposite = CompositeProcesses;
+				string[] arrSimple = SimpleProcesses;
+
+				// Add all to our collection
+				arrProcesses.AddRange( arrAtomic );
+				arrProcesses.AddRange( arrComposite );
+				arrProcesses.AddRange( arrSimple );
+
+				return (string[]) arrProcesses.ToArray( typeof( System.String ) );
+			}
+		}
+
+		/* Function retrieves all the interesting data about a process given its name and
+		 * type.
+		 *
+		 * Interesting data:
+		 * Inputs, Outputs, Preconditions, Effects, Parameters, ConditionalOutputs,
+		 * Co-Conditions, Sub Processes (if process is a composite process)
+		 *
+		 * Inputs: strProcessName - named process
+		 *		   processType - process type (atomic, simple, composite)
+		 *
+		 * Return value: DAMLProcess containing all the relevant data
+		 */
+		public DAMLProcess GetProcessData( string strProcessName, enuProcessType processType )
+		{
+			DAMLProcess retVal = new DAMLProcess();
+
+			try
+			{
+				XmlNode root = m_doc.DocumentElement;
+				string strBaseUri = GetNamespaceBaseUri( DAMLConstants.PROCESS_NS );
+				string strUri = "";
+				strUri = strBaseUri;
+
+				switch( processType )
+				{
+					case enuProcessType.AtomicProcess: strUri += DAMLConstants.DAML_ATOMIC_PROCESS;
+						break;
+					case enuProcessType.CompositeProcess: strUri += DAMLConstants.DAML_COMPOSITE_PROCESS;
+						break;
+					case enuProcessType.SimpleProcess: strUri += DAMLConstants.DAML_SIMPLE_PROCESS;
+						break;
+					default:  throw new ArgumentException( "Invalid processType value" );
+				};
+
+				string strXPath = DAMLConstants.DAML_CLASS + "[@" + DAMLConstants.RDF_ID + "='" + strProcessName + "']" + "/" + DAMLConstants.RDFS_SUBCLASSOF + "[@" + DAMLConstants.RDF_RESOURCE + "='" + strUri + "']";
+
+				XmlNode processNode = root.SelectSingleNode( strXPath, m_mgr ).ParentNode;
+
+				// No such process exists so just exit - should throw exception since
+				// returned DAMLProcess is useless?
+				if( processNode == null )
+					return retVal;
+
+				// Set process name
+				retVal.Name = processNode.Attributes[DAMLConstants.RDF_ID].Value;
+				// Set process type
+				retVal.ProcessType = processType;
+
+				// Get inputs from querying RDFProperty nodes in document
+				strXPath = DAMLConstants.RDF_PROPERTY + "/" + DAMLConstants.RDFS_SUBPROPERTYOF + "[@" +  DAMLConstants.RDF_RESOURCE + "='" + strBaseUri + DAMLConstants.INPUT + "']" + "/" + "following-sibling::" + DAMLConstants.RDFS_DOMAIN + "[@" + DAMLConstants.RDF_RESOURCE + "='#" + strProcessName + "']";
+				XmlNodeList lstNodes = root.SelectNodes( strXPath, m_mgr );
+
+				foreach( XmlNode node in lstNodes )
+				{
+					RDFProperty data = GetNodeData( node );
+					retVal.AddInput( data );
+				}
+
+				// Get additional inputs from the process node itself
+				// they may be hidden under restictions tagged with
+				// daml:sameValueAs
+				strXPath =  DAMLConstants.DAML_CLASS + "[@" + DAMLConstants.RDF_ID + "='" + retVal.Name + "']" + "/" + DAMLConstants.RDFS_SUBCLASSOF + "/" + DAMLConstants.DAML_RESTRICTION + "/" + DAMLConstants.DAML_ON_PROPERTY + "[@" + DAMLConstants.RDF_RESOURCE + "='" + strBaseUri + DAMLConstants.INPUT + "']" + "/" + "following-sibling::" + DAMLConstants.DAML_SAMEVALUESAS;
+				lstNodes = root.SelectNodes( strXPath, m_mgr );
+
+				foreach( XmlNode node in lstNodes )
+				{
+					string strSameValueAs = node.Attributes[DAMLConstants.RDF_RESOURCE].Value;
+					strSameValueAs = strSameValueAs.Trim( new char[] {'#'} );
+
+					// Go get RDFProperty data
+					strXPath = DAMLConstants.RDF_PROPERTY + "[@" + DAMLConstants.RDF_ID + "='" + strSameValueAs + "']" + "/" + DAMLConstants.RDFS_DOMAIN;
+					XmlNode domainNode = root.SelectSingleNode( strXPath, m_mgr );
+
+					// Add to list of inputs
+					if( domainNode != null )
+					{
+						RDFProperty data = GetNodeData( domainNode );
+						retVal.AddInput( data );
+					}
+				}
+
+				// Get outputs
+				strXPath = DAMLConstants.RDF_PROPERTY + "/" + DAMLConstants.RDFS_SUBPROPERTYOF + "[@" +  DAMLConstants.RDF_RESOURCE + "='" + strBaseUri + DAMLConstants.OUTPUT + "']" + "/" + "following-sibling::" + DAMLConstants.RDFS_DOMAIN + "[@" + DAMLConstants.RDF_RESOURCE + "='#" + strProcessName + "']";
+				lstNodes = root.SelectNodes( strXPath, m_mgr );
+
+				foreach( XmlNode node in lstNodes )
+				{
+					RDFProperty data = GetNodeData( node );
+					retVal.AddOutput( data );
+				}
+
+				// Get preconditions
+				strXPath = DAMLConstants.RDF_PROPERTY + "/" + DAMLConstants.RDFS_SUBPROPERTYOF + "[@" +  DAMLConstants.RDF_RESOURCE + "='" + strBaseUri + DAMLConstants.PRECONDITION + "']" + "/" + "following-sibling::" + DAMLConstants.RDFS_DOMAIN + "[@" + DAMLConstants.RDF_RESOURCE + "='#" + strProcessName + "']";
+				lstNodes = root.SelectNodes( strXPath, m_mgr );
+
+				foreach( XmlNode node in lstNodes )
+				{
+					RDFProperty data = GetNodeData( node );
+					retVal.AddPrecondition( data );
+				}
+
+				// Get effects
+				strXPath = DAMLConstants.RDF_PROPERTY + "/" + DAMLConstants.RDFS_SUBPROPERTYOF + "[@" +  DAMLConstants.RDF_RESOURCE + "='" + strBaseUri + DAMLConstants.EFFECT + "']" + "/" + "following-sibling::" + DAMLConstants.RDFS_DOMAIN + "[@" + DAMLConstants.RDF_RESOURCE + "='#" + strProcessName + "']";
+				lstNodes = root.SelectNodes( strXPath, m_mgr );
+
+				foreach( XmlNode node in lstNodes )
+				{
+					RDFProperty data = GetNodeData( node );
+					retVal.AddEffect( data );
+				}
+
+				// Get conditional outputs
+				strXPath = DAMLConstants.RDF_PROPERTY + "/" + DAMLConstants.RDFS_SUBPROPERTYOF + "[@" +  DAMLConstants.RDF_RESOURCE + "='" + strBaseUri + DAMLConstants.CONDITIONAL_OUTPUT + "']" + "/" + "following-sibling::" + DAMLConstants.RDFS_DOMAIN + "[@" + DAMLConstants.RDF_RESOURCE + "='#" + strProcessName + "']";
+				lstNodes = root.SelectNodes( strXPath, m_mgr );
+
+				foreach( XmlNode node in lstNodes )
+				{
+					RDFProperty data = GetNodeData( node );
+					retVal.AddConditionalOutput( data );
+				}
+
+				// Get co-conditions
+				strXPath = DAMLConstants.RDF_PROPERTY + "/" + DAMLConstants.RDFS_SUBPROPERTYOF + "[@" +  DAMLConstants.RDF_RESOURCE + "='" + strBaseUri + DAMLConstants.CO_CONDITION + "']" + "/" + "following-sibling::" + DAMLConstants.RDFS_DOMAIN + "[@" + DAMLConstants.RDF_RESOURCE + "='#" + strProcessName + "']";
+				lstNodes = root.SelectNodes( strXPath, m_mgr );
+
+				foreach( XmlNode node in lstNodes )
+				{
+					RDFProperty data = GetNodeData( node );
+					retVal.AddCoCondition( data );
+				}
+
+				// Get co-outputs
+				strXPath = DAMLConstants.RDF_PROPERTY + "/" + DAMLConstants.RDFS_SUBPROPERTYOF + "[@" +  DAMLConstants.RDF_RESOURCE + "='" + strBaseUri + DAMLConstants.CO_OUTPUT + "']" + "/" + "following-sibling::" + DAMLConstants.RDFS_DOMAIN + "[@" + DAMLConstants.RDF_RESOURCE + "='#" + strProcessName + "']";
+				lstNodes = root.SelectNodes( strXPath, m_mgr );
+
+				foreach( XmlNode node in lstNodes )
+				{
+					RDFProperty data = GetNodeData( node );
+					retVal.AddCoOutput( data );
+				}
+
+				// Get parameters
+				strXPath = DAMLConstants.RDF_PROPERTY + "/" + DAMLConstants.RDFS_SUBPROPERTYOF + "[@" +  DAMLConstants.RDF_RESOURCE + "='" + strBaseUri + DAMLConstants.PARAMETER + "']" + "/" + "following-sibling::" + DAMLConstants.RDFS_DOMAIN + "[@" + DAMLConstants.RDF_RESOURCE + "='#" + strProcessName + "']";
+				lstNodes = root.SelectNodes( strXPath, m_mgr );
+
+				foreach( XmlNode node in lstNodes )
+				{
+					RDFProperty data = GetNodeData( node );
+					retVal.AddParameter( data );
+				}
+
+				// For each input, fill the process' InputRestrictionMap
+				// search on process name
+				if( retVal.HasInputs )
+				{
+					foreach( RDFProperty Input in retVal.Inputs )
+					{
+						int nRestriction = GetInputRestrictions( retVal.Name, Input.Name );
+						if( nRestriction == 0 )
+							nRestriction = DEFAULT_RESTRICTION;
+						retVal.AddInputRestriction( Input.Name, nRestriction );
+					}
+				}
+
+				// If we are dealing with a complex process we must go get
+				// the substeps - need to get process:<type> data
+				if( processType == enuProcessType.CompositeProcess )
+				{
+					retVal.SubTaskType = GetProcessSubTaskType( retVal.Name );
+					retVal.AddSubProcess( GetSubProcesses( retVal.Name ) );
+				}
+			}
+			catch( Exception e )
+			{
+				m_EvtLog.WriteEntry( e.Message, EventLogEntryType.Error );
+			}
+			return retVal;
+		}
+
+        /* Function extracts the RDFProperty data from an XmlNode. Function expects
+		 * specific RDFProperty information available.
+		 *
+		 * Inputs: node - the XmlNode to extract RDFProperty data
+		 *
+		 * Return values: the RDFProperty instance containing the node data
+		 */
+		private RDFProperty GetNodeData( XmlNode node )
+		{
+			// Go up to parent node
+			XmlNode propertyNode = node.ParentNode;
+			RDFProperty data = new RDFProperty();
+
+			// Set name
+			data.Name = propertyNode.Attributes[DAMLConstants.RDF_ID].Value;
+			// Set Domain
+			data.Domain = propertyNode.SelectSingleNode( DAMLConstants.RDFS_DOMAIN, m_mgr ).Attributes[DAMLConstants.RDF_RESOURCE].Value;
+			// Set Range
+			data.Range = propertyNode.SelectSingleNode( DAMLConstants.RDFS_RANGE, m_mgr ).Attributes[DAMLConstants.RDF_RESOURCE].Value;
+			// Set SubPropertyOf
+			data.SubPropertyOf = propertyNode.SelectSingleNode( DAMLConstants.RDFS_SUBPROPERTYOF, m_mgr ).Attributes[DAMLConstants.RDF_RESOURCE].Value;
+
+			// Fill in sameValueAs data (if any)
+			XmlNode sameValueAsNode = propertyNode.SelectSingleNode( DAMLConstants.DAML_SAMEVALUESAS, m_mgr );
+			if( sameValueAsNode != null )
+				data.SameValueAs = sameValueAsNode.Attributes[DAMLConstants.RDF_RESOURCE].Value;
+
+			return data;
+		}
+
+		/* Function retrieves the input restriction data given a process name and
+		 * a named input.
+		 *
+		 * Inputs: strProcessName - named process we are interested in
+		 *		   strInput - named input of the process
+		 */
+		private int GetInputRestrictions( string strProcessName, string strInput )
+		{
+			XmlNode root = m_doc.DocumentElement;
+
+			string strXPath = DAMLConstants.DAML_CLASS + "[@" + DAMLConstants.RDF_ID + "='" + strProcessName + "']" + "/" + DAMLConstants.RDFS_SUBCLASSOF + "/" + DAMLConstants.DAML_RESTRICTION + "/" + DAMLConstants.DAML_ON_PROPERTY + "[@" + DAMLConstants.RDF_RESOURCE + "='#" + strInput + "']";
+
+			XmlNode node = root.SelectSingleNode( strXPath, m_mgr );
+
+			if( node == null )
+				return 0;
+
+			XmlNode restrictionNode = node.ParentNode;
+			XmlNode cardinalityNode = restrictionNode.Attributes[DAMLConstants.DAML_CARDINALITY];
+			if( cardinalityNode == null )
+				return 0;
+			else return Int32.Parse( cardinalityNode.Value );
+		}
+
+		/* Private helper function used to extract URIs from our namespace
+		 * manager given a namespace prefix - even though the namespace manager is
+		 * *supposed* to be accessible like a hashtable (m_mgr[<prefixname>]) this
+		 * does not work, a for each construct is needed to iterate through all
+		 * entries in the namespace manager.
+		 *
+		 * Inputs: strNamespacePrefix - the namespace prefix we want to find the
+		 *								base Uri of
+		 *
+		 * Return values: the Basr Uri of the namespace prefix
+		 */
+		private string GetNamespaceBaseUri( string strNamespacePrefix )
+		{
+			string strBaseUri = "";
+
+			foreach( string prefix in m_mgr )
+			{
+				if( prefix == strNamespacePrefix )
+				{
+					strBaseUri = m_mgr.LookupNamespace( prefix );
+					break;
+				}
+			}
+
+			return strBaseUri;
+		}
+
+		/* Function returns the sub task type of a named process
+		 *
+		 * Inputs: strProcessName - named process
+		 *
+		 * Return values: the type of the named process' subtasks
+		 *				  sequence, choice etc.
+		 */
+		private enuProcessSubTaskType GetProcessSubTaskType( string strProcessName )
+		{
+			XmlNode root = m_doc.DocumentElement;
+			string strBaseUri = GetNamespaceBaseUri( DAMLConstants.PROCESS_NS );
+
+			string strXPath = DAMLConstants.DAML_CLASS + "[@" + DAMLConstants.RDF_ID + "='" + strProcessName + "']" + "/" + DAMLConstants.RDFS_SUBCLASSOF + "[@" + DAMLConstants.RDF_RESOURCE + "='" + strBaseUri + DAMLConstants.DAML_COMPOSITE_PROCESS + "']" + "/" + "following-sibling::" + DAMLConstants.RDFS_SUBCLASSOF;
+			XmlNode SubClassOfNode = root.SelectSingleNode( strXPath, m_mgr );
+
+			if( SubClassOfNode == null )
+				throw new Exception( "Complex process " + strProcessName + " data not found" );
+
+			// Get process:<type>
+			strXPath = ".//" + DAMLConstants.DAML_CLASS + "[@" + DAMLConstants.RDF_ABOUT + "]";
+			XmlNode dataNode = SubClassOfNode.SelectSingleNode( strXPath, m_mgr );
+
+			if( dataNode == null )
+				throw new Exception( "No process:<type> data provided for complex process " + strProcessName + " document is invalid" );
+
+			if( dataNode.Attributes[DAMLConstants.RDF_ABOUT].Value == DAMLConstants.PROCESS_CHOICE )
+				return enuProcessSubTaskType.Choice;
+			else return enuProcessSubTaskType.Sequence;
+		}
+
+		/* Function returns all the sub processes of a named process
+		 *
+		 * Inputs: strProcessName - named process
+		 *
+		 * Return values: an array of its sub processes
+		 */
+		private DAMLProcess[] GetSubProcesses( string strProcessName )
+		{
+			ArrayList lstSubProcesses = new ArrayList();
+
+			try
+			{
+				XmlNode root = m_doc.DocumentElement;
+				string strBaseUri = GetNamespaceBaseUri( DAMLConstants.PROCESS_NS );
+
+				string strXPath = DAMLConstants.DAML_CLASS + "[@" + DAMLConstants.RDF_ID + "='" + strProcessName + "']" + "/" + DAMLConstants.RDFS_SUBCLASSOF + "[@" + DAMLConstants.RDF_RESOURCE + "='" + strBaseUri + DAMLConstants.DAML_COMPOSITE_PROCESS + "']" + "/" + "following-sibling::" + DAMLConstants.RDFS_SUBCLASSOF;
+				XmlNode SubClassOfNode = root.SelectSingleNode( strXPath, m_mgr );
+
+				if( SubClassOfNode == null )
+					return (DAMLProcess[]) lstSubProcesses.ToArray( typeof(DAMLProcess) );
+
+				// Use fuzzy paths from here -> "//" operator looking for any matching
+				// child node - more expensive but intermediate nodes are not
+				// interesting/contain no info we can use
+
+				strXPath = ".//" + DAMLConstants.DAML_LIST_OF_INSTANCES_OF + "/" + DAMLConstants.DAML_CLASS;
+				XmlNodeList lstInstances = SubClassOfNode.SelectNodes( strXPath, m_mgr );
+
+				foreach( XmlNode node in lstInstances )
+				{
+					string strProcess = node.Attributes[DAMLConstants.RDF_ABOUT].Value;
+					strProcess = strProcess.Trim( new Char[] { '#' } );
+					enuProcessType processType = GetProcessType( strProcess );
+					DAMLProcess process = GetProcessData( strProcess, processType );
+					lstSubProcesses.Add( process );
+				}
+			}
+			catch( Exception e )
+			{
+				m_EvtLog.WriteEntry( e.Message, EventLogEntryType.Error );
+			}
+			return (DAMLProcess[]) lstSubProcesses.ToArray( typeof(DAMLProcess) );
+		}
+
+		/* Function returns the process type of a named process
+		 *
+		 * Inputs: strProcessName - named process
+		 *
+		 * Return values: the type of the named process (atomic, simple, composite)
+		 */
+		private enuProcessType GetProcessType( string strProcessName )
+		{
+			// process may be atomic, simple or complex
+			string strBaseUri = GetNamespaceBaseUri( DAMLConstants.PROCESS_NS );
+			XmlNode root = m_doc.DocumentElement;
+
+			string strXPathAtomicProcess = DAMLConstants.DAML_CLASS + "[@" + DAMLConstants.RDF_ID + "='" + strProcessName + "']" + "/" + DAMLConstants.RDFS_SUBCLASSOF + "[@" + DAMLConstants.RDF_RESOURCE + "='" + strBaseUri + DAMLConstants.DAML_ATOMIC_PROCESS + "']";
+			string strXPathSimpleProcess = DAMLConstants.DAML_CLASS + "[@" + DAMLConstants.RDF_ID + "='" + strProcessName + "']" + "/" + DAMLConstants.RDFS_SUBCLASSOF + "[@" + DAMLConstants.RDF_RESOURCE + "='" + strBaseUri + DAMLConstants.DAML_SIMPLE_PROCESS + "']";
+			string strXPathCompositeProcess = DAMLConstants.DAML_CLASS + "[@" + DAMLConstants.RDF_ID + "='" + strProcessName + "']" + "/" + DAMLConstants.RDFS_SUBCLASSOF + "[@" + DAMLConstants.RDF_RESOURCE + "='" + strBaseUri + DAMLConstants.DAML_COMPOSITE_PROCESS + "']";
+
+			XmlNode resultNode = root.SelectSingleNode( strXPathAtomicProcess, m_mgr );
+			if( resultNode != null )
+				return enuProcessType.AtomicProcess;
+
+			resultNode = root.SelectSingleNode( strXPathSimpleProcess, m_mgr );
+			if( resultNode != null )
+				return enuProcessType.SimpleProcess;
+
+			resultNode = root.SelectSingleNode( strXPathCompositeProcess, m_mgr );
+			if( resultNode != null )
+				return enuProcessType.CompositeProcess;
+
+			throw new Exception( "Process " + strProcessName + " does not exist" );
+		}
+
+		/* Function returns all the names of processes of a given type.
+		 *
+		 * Inputs: processType - types of processes to retrieve
+		 *
+		 * Return values: an array of process names of a given type (atomic, simple,
+		 *				  composite)
+		 */
+		private string[] GetProcesses( enuProcessType processType )
+		{
+			ArrayList arrProcess = new ArrayList();
+
+			try
+			{
+				XmlNode root = m_doc.DocumentElement;
+				string strProcessURI = GetNamespaceBaseUri( DAMLConstants.PROCESS_NS );
+				string strProcessType = "";
+
+				switch( processType )
+				{
+					case enuProcessType.AtomicProcess: strProcessType = DAMLConstants.DAML_ATOMIC_PROCESS;
+													   break;
+
+					case enuProcessType.CompositeProcess: strProcessType = DAMLConstants.DAML_COMPOSITE_PROCESS;
+														break;
+
+					case enuProcessType.SimpleProcess: strProcessType = DAMLConstants.DAML_SIMPLE_PROCESS;
+													   break;
+				};
+
+				string strXPath = DAMLConstants.DAML_CLASS + "/" + DAMLConstants.RDFS_SUBCLASSOF + "[@" + DAMLConstants.RDF_RESOURCE + "='" + strProcessURI + strProcessType + "']";
+
+				XmlNodeList lstProcess = root.SelectNodes( strXPath, m_mgr );
+
+				foreach( XmlNode processNode in lstProcess )
+				{
+					// Move up to parent
+					XmlNode parentNode = processNode.ParentNode;
+
+					string strValue = parentNode.Attributes[DAMLConstants.RDF_ID].Value;
+
+					if( strValue.Length > 0 )
+						arrProcess.Add( strValue );
+
+				}
+			}
+			catch( Exception e )
+			{
+				m_EvtLog.WriteEntry( e.Message, EventLogEntryType.Error );
+			}
+
+			return (string[]) arrProcess.ToArray( typeof( System.String ) );
+		}
+	}
+}
diff --git a/csharpsrc/DAML/DAMLServiceProfile.cs b/csharpsrc/DAML/DAMLServiceProfile.cs
new file mode 100644
index 0000000..7bd90bc
--- /dev/null
+++ b/csharpsrc/DAML/DAMLServiceProfile.cs
@@ -0,0 +1,1160 @@
+using System;
+using System.Xml;
+using System.Xml.XPath;
+using System.Collections;
+using System.Diagnostics;
+using System.Xml.Serialization;
+using PSL.DAML.Interfaces;
+
+namespace PSL.DAML
+{
+	// Value types representing IOPEs
+	public struct IOType
+	{
+		private string m_strParamDesc;
+		private string m_strParamName;
+		private string m_strRestrictedTo;
+		private string m_strRefersTo;
+
+		public bool isValid
+		{
+			get
+			{ return ( m_strParamDesc.Length > 0 && m_strParamName.Length > 0 ) && ( m_strRestrictedTo.Length > 0 && m_strRefersTo.Length > 0 ); }
+		}
+
+		public string ParameterDesc
+		{
+			get
+			{ return m_strParamDesc; }
+			set
+			{ m_strParamDesc = value; }
+		}
+
+		public string ParameterName
+		{
+			get
+			{ return m_strParamName; }
+			set
+			{ m_strParamName = value; }
+		}
+
+		public string RestrictedTo
+		{
+			get
+			{ return m_strRestrictedTo; }
+			set
+			{ m_strRestrictedTo = value; }
+		}
+
+		public string RefersTo
+		{
+			get
+			{ return m_strRefersTo; }
+			set
+			{ m_strRefersTo = value; }
+		}
+
+	}
+
+	public struct EPType
+	{
+		private string m_strConditionDesc;
+		private string m_strConditionName;
+		private string m_strStatement;
+		private string m_strRefersTo;
+
+		public bool isValid
+		{
+			get
+			{ return ( m_strConditionDesc.Length > 0 && m_strConditionName.Length > 0 ) && ( m_strStatement.Length > 0 && m_strRefersTo.Length > 0 ); }
+		}
+
+		public string ConditionDesc
+		{
+			get
+			{ return m_strConditionDesc; }
+			set
+			{ m_strConditionDesc = value; }
+		}
+
+		public string ConditionName
+		{
+			get
+			{ return m_strConditionName; }
+			set
+			{ m_strConditionName = value; }
+		}
+
+		public string Statement
+		{
+			get
+			{ return m_strStatement; }
+			set
+			{ m_strStatement = value; }
+		}
+
+		public string RefersTo
+		{
+			get
+			{ return m_strRefersTo; }
+			set
+			{ m_strRefersTo = value; }
+		}
+	}
+
+	public enum enuIOPESearchBy
+	{
+		PARAM_DESC,
+		PARAM_NAME,
+		COND_DESC,
+		COND_NAME,
+		REFERS_TO
+	};
+
+	/// <summary>
+	/// Summary description for DAMLServiceProfile.
+	/// </summary>
+	public class DAMLServiceProfile:DAMLContainer
+	{
+		/* Constructor */
+		public DAMLServiceProfile()
+		{
+			// Init inherited members
+			m_EvtLog = new EventLog( "Application" );
+			m_EvtLog.Source = "DAMLServiceProfile";
+			m_doc = new XmlDocument();
+			m_mgr = null;
+		}
+
+		// Properties
+		public string[] OntologyImports
+		{
+			get
+			{ return GetOntologyImports(); }
+		}
+
+		public string ServiceName
+		{
+			get
+			{ return GetServiceName(); }
+		}
+
+		public string ServiceProfile
+		{
+			get
+			{ return GetServiceProfile(); }
+		}
+
+		public string PresentedBy
+		{
+			get
+			{ return GetPresentedBy(); }
+		}
+
+		public string TextDescription
+		{
+			get
+			{ return GetTextDescription(); }
+		}
+
+		public string IntendedPurpose
+		{
+			get
+			{ return GetIntendedPurpose(); }
+		}
+
+		public string RequestedBy
+		{
+			get
+			{ return GetRequestedBy(); }
+		}
+
+		public string ServiceProvider
+		{
+			get
+			{ return GetServiceProvider(); }
+		}
+
+		public string ProfileName
+		{
+			get
+			{ return GetProfileName(); }
+		}
+
+		public string ProfilePhone
+		{
+			get
+			{ return GetProfilePhone(); }
+		}
+
+		public string ProfileFax
+		{
+			get
+			{ return GetProfileFax(); }
+		}
+
+		public string ProfileEmail
+		{
+			get
+			{ return GetProfileEmail(); }
+		}
+
+		public string PhysicalAddress
+		{
+			get
+			{ return GetPhysicalAddress(); }
+		}
+
+		public string WebUrl
+		{
+			get
+			{ return GetWebUrl(); }
+		}
+
+		public string GeographicRadius
+		{
+			get
+			{ return GetGeographicRadius(); }
+		}
+
+		public string QualityRating
+		{
+			get
+			{ return GetQualityRating(); }
+		}
+
+		public string ProcessModel
+		{
+			get
+			{ return GetProcessModel(); }
+		}
+
+		public IOType[] InputParameters
+		{
+			get
+			{ return GetInputParameters(); }
+		}
+
+		public IOType[] OutputParameters
+		{
+			get
+			{ return GetOutputParameters(); }
+		}
+
+		public EPType[] Preconditions
+		{
+			get
+			{ return GetPreconditions(); }
+		}
+
+		public EPType[] Effects
+		{
+			get
+			{ return GetEffects(); }
+		}
+
+
+		// Methods
+
+		/* Function returns the data of a named input
+		 *
+		 * Inputs: strName - name of input to retrieve data about
+		 *
+		 * Return value: the IOType data structure of the named input
+		 */
+		public IOType GetInputByName( string strName )
+		{
+			// Create Expression Builder instance
+			IIOPEXPathExprBuilder IBuilder = IOPEXPathExprBuilderFactory.CreateInstance( enuIOPEType.Input );
+			// Build XPath Expression
+			string strXPathExpr = DAMLConstants.SERVICE_PROFILE + IBuilder.BuildExpression( enuIOPESearchBy.PARAM_NAME, strName );
+			XmlNode root = m_doc.DocumentElement;
+			XmlNode node = root.SelectSingleNode( strXPathExpr, m_mgr );
+			node = node.ParentNode;
+
+			IOType ioData = GetIONodeData( node );
+
+			return ioData;
+		}
+
+		/* Function returns the data of a input based on its description
+		 *
+		 * Inputs: strDesc - description of input to retrieve data about
+		 *
+		 * Return value: the IOType data structure of the input
+		 */
+		public IOType GetInputByDescription( string strDesc )
+		{
+			// Create Expression Builder instance
+			IIOPEXPathExprBuilder IBuilder = IOPEXPathExprBuilderFactory.CreateInstance( enuIOPEType.Input );
+			// Build XPath Expression
+			string strXPathExpr = DAMLConstants.SERVICE_PROFILE + IBuilder.BuildExpression( enuIOPESearchBy.PARAM_DESC, strDesc );
+			XmlNode root = m_doc.DocumentElement;
+			XmlNode node = root.SelectSingleNode( strXPathExpr, m_mgr );
+
+			IOType ioData = GetIONodeData( node );
+
+			return ioData;
+		}
+
+		/* Function returns the data of a input based on a refersTo statement
+		 *
+		 * Inputs: strRef - reference of input to retrieve data about
+		 *
+		 * Return value: the IOType data structure of the input
+		 */
+		public IOType GetInputByReference( string strRef )
+		{
+			// Create Expression Builder instance
+			IIOPEXPathExprBuilder IBuilder = IOPEXPathExprBuilderFactory.CreateInstance( enuIOPEType.Input );
+			// Build XPath Expression
+			string strXPathExpr = DAMLConstants.SERVICE_PROFILE + IBuilder.BuildExpression( enuIOPESearchBy.REFERS_TO, strRef );
+			XmlNode root = m_doc.DocumentElement;
+			XmlNode node = root.SelectSingleNode( strXPathExpr, m_mgr );
+			node = node.ParentNode;
+
+			IOType ioData = GetIONodeData( node );
+
+			return ioData;
+		}
+
+		/* Function returns the data of a named output
+		 *
+		 * Inputs: strName - name of output to retrieve data about
+		 *
+		 * Return value: the IOType data structure of the named output
+		 */
+		public IOType GetOutputByName( string strName )
+		{
+			// Create Expression Builder instance
+			IIOPEXPathExprBuilder IBuilder = IOPEXPathExprBuilderFactory.CreateInstance( enuIOPEType.Output );
+			// Build XPath Expression
+			string strXPathExpr = DAMLConstants.SERVICE_PROFILE + IBuilder.BuildExpression( enuIOPESearchBy.PARAM_NAME, strName );
+			XmlNode root = m_doc.DocumentElement;
+			XmlNode node = root.SelectSingleNode( strXPathExpr, m_mgr );
+			node = node.ParentNode;
+
+			IOType ioData = GetIONodeData( node );
+
+			return ioData;
+		}
+
+		/* Function returns the data of a output based on its description
+		 *
+		 * Inputs: strDesc - description of output to retrieve data about
+		 *
+		 * Return value: the IOType data structure of the output
+		 */
+		public IOType GetOutputByDescription( string strDesc )
+		{
+			// Create Expression Builder instance
+			IIOPEXPathExprBuilder IBuilder = IOPEXPathExprBuilderFactory.CreateInstance( enuIOPEType.Output );
+			// Build XPath Expression
+			string strXPathExpr = DAMLConstants.SERVICE_PROFILE + IBuilder.BuildExpression( enuIOPESearchBy.PARAM_DESC, strDesc );
+			XmlNode root = m_doc.DocumentElement;
+			XmlNode node = root.SelectSingleNode( strXPathExpr, m_mgr );
+
+			IOType ioData = GetIONodeData( node );
+
+			return ioData;
+		}
+
+		/* Function returns the data of a output based on a refersTo statement
+		 *
+		 * Inputs: strRef - reference of output to retrieve data about
+		 *
+		 * Return value: the IOType data structure of the output
+		 */
+		public IOType GetOutputByReference( string strRef )
+		{
+			// Create Expression Builder instance
+			IIOPEXPathExprBuilder IBuilder = IOPEXPathExprBuilderFactory.CreateInstance( enuIOPEType.Output );
+			// Build XPath Expression
+			string strXPathExpr = DAMLConstants.SERVICE_PROFILE + IBuilder.BuildExpression( enuIOPESearchBy.REFERS_TO, strRef );
+			XmlNode root = m_doc.DocumentElement;
+			XmlNode node = root.SelectSingleNode( strXPathExpr, m_mgr );
+			node = node.ParentNode;
+
+			IOType ioData = GetIONodeData( node );
+
+			return ioData;
+		}
+
+		/* Function returns the data of a named precondition
+		 *
+		 * Inputs: strName - name of precondition to retrieve data about
+		 *
+		 * Return value: the EPType data structure of the named precondition
+		 */
+		public EPType GetPreconditionByName( string strName )
+		{
+			// Create Expression Builder instance
+			IIOPEXPathExprBuilder IBuilder = IOPEXPathExprBuilderFactory.CreateInstance( enuIOPEType.Precondition );
+			// Build XPath Expression
+			string strXPathExpr = DAMLConstants.SERVICE_PROFILE + IBuilder.BuildExpression( enuIOPESearchBy.COND_NAME, strName );
+			XmlNode root = m_doc.DocumentElement;
+			XmlNode node = root.SelectSingleNode( strXPathExpr, m_mgr );
+			node = node.ParentNode;
+
+			EPType epData = GetEPNodeData( node );
+
+			return epData;
+		}
+
+		/* Function returns the data of a precondition based on its description
+		 *
+		 * Inputs: strDesc - description of precondition to retrieve data about
+		 *
+		 * Return value: the EPType data structure of the precondition
+		 */
+		public EPType GetPreconditionByDescription( string strDesc )
+		{
+			// Create Expression Builder instance
+			IIOPEXPathExprBuilder IBuilder = IOPEXPathExprBuilderFactory.CreateInstance( enuIOPEType.Precondition );
+			// Build XPath Expression
+			string strXPathExpr = DAMLConstants.SERVICE_PROFILE + IBuilder.BuildExpression( enuIOPESearchBy.COND_DESC, strDesc );
+			XmlNode root = m_doc.DocumentElement;
+			XmlNode node = root.SelectSingleNode( strXPathExpr, m_mgr );
+
+			EPType epData = GetEPNodeData( node );
+
+			return epData;
+		}
+
+		/* Function returns the data of a precondition based on a refersTo statement
+		 *
+		 * Inputs: strRef - reference of precondition to retrieve data about
+		 *
+		 * Return value: the EPType data structure of the precondition
+		 */
+		public EPType GetPreconditionByReference( string strRef )
+		{
+			// Create Expression Builder instance
+			IIOPEXPathExprBuilder IBuilder = IOPEXPathExprBuilderFactory.CreateInstance( enuIOPEType.Precondition );
+			// Build XPath Expression
+			string strXPathExpr = DAMLConstants.SERVICE_PROFILE + IBuilder.BuildExpression( enuIOPESearchBy.REFERS_TO, strRef );
+			XmlNode root = m_doc.DocumentElement;
+			XmlNode node = root.SelectSingleNode( strXPathExpr, m_mgr );
+			node = node.ParentNode;
+
+			EPType epData = GetEPNodeData( node );
+
+			return epData;
+		}
+
+		/* Function returns the data of a named effect
+		 *
+		 * Inputs: strName - name of effect to retrieve data about
+		 *
+		 * Return value: the EPType data structure of the named effect
+		 */
+		public EPType GetEffectByName( string strName )
+		{
+			// Create Expression Builder instance
+			IIOPEXPathExprBuilder IBuilder = IOPEXPathExprBuilderFactory.CreateInstance( enuIOPEType.Effect );
+			// Build XPath Expression
+			string strXPathExpr = DAMLConstants.SERVICE_PROFILE + IBuilder.BuildExpression( enuIOPESearchBy.COND_NAME, strName );
+			XmlNode root = m_doc.DocumentElement;
+			XmlNode node = root.SelectSingleNode( strXPathExpr, m_mgr );
+			node = node.ParentNode;
+
+			EPType epData = GetEPNodeData( node );
+
+			return epData;
+		}
+
+		/* Function returns the data of an effect based on its description
+		 *
+		 * Inputs: strDesc - description of effect to retrieve data about
+		 *
+		 * Return value: the EPType data structure of the effect
+		 */
+		public EPType GetEffectByDescription( string strDesc )
+		{
+			// Create Expression Builder instance
+			IIOPEXPathExprBuilder IBuilder = IOPEXPathExprBuilderFactory.CreateInstance( enuIOPEType.Effect );
+			// Build XPath Expression
+			string strXPathExpr = DAMLConstants.SERVICE_PROFILE + IBuilder.BuildExpression( enuIOPESearchBy.COND_DESC, strDesc );
+			XmlNode root = m_doc.DocumentElement;
+			XmlNode node = root.SelectSingleNode( strXPathExpr, m_mgr );
+
+			EPType epData = GetEPNodeData( node );
+
+			return epData;
+		}
+
+		/* Function returns the data of an effect based on a refersTo statement
+		 *
+		 * Inputs: strRef - reference of effect to retrieve data about
+		 *
+		 * Return value: the EPType data structure of the effect
+		 */
+		public EPType GetEffectByReference( string strRef )
+		{
+			// Create Expression Builder instance
+			IIOPEXPathExprBuilder IBuilder = IOPEXPathExprBuilderFactory.CreateInstance( enuIOPEType.Effect );
+			// Build XPath Expression
+			string strXPathExpr = DAMLConstants.SERVICE_PROFILE + IBuilder.BuildExpression( enuIOPESearchBy.REFERS_TO, strRef );
+			XmlNode root = m_doc.DocumentElement;
+			XmlNode node = root.SelectSingleNode( strXPathExpr, m_mgr );
+			node = node.ParentNode;
+
+			EPType epData = GetEPNodeData( node );
+
+			return epData;
+		}
+
+		/* Function returs all the effects in a ServiceProfile
+		 *
+		 * Inputs: none
+		 *
+		 * Return values: an array of effects
+		 */
+		private EPType[] GetEffects()
+		{
+			ArrayList lstEffects = new ArrayList();
+
+			try
+			{
+				XmlNode root = m_doc.DocumentElement;
+
+				// Create Expression Builder instance
+				IIOPEXPathExprBuilder IBuilder = IOPEXPathExprBuilderFactory.CreateInstance( enuIOPEType.Effect );
+				// Build XPath Expression
+				string strXPathExpr = DAMLConstants.SERVICE_PROFILE + IBuilder.BuildExpression( enuIOPESearchBy.COND_DESC );
+
+				XmlNodeList nodeList = root.SelectNodes( strXPathExpr, m_mgr );
+
+				foreach( XmlNode descNode in nodeList )
+				{
+					EPType effect = GetEPNodeData( descNode );
+
+					if( effect.isValid )
+						lstEffects.Add( effect );
+				}
+
+			}
+			catch( Exception e )
+			{
+				m_EvtLog.WriteEntry( e.Message, EventLogEntryType.Error );
+			}
+
+			return (EPType[]) lstEffects.ToArray( typeof(EPType) );
+		}
+
+		/* Function returs all the preconditions in a ServiceProfile
+		 *
+		 * Inputs: none
+		 *
+		 * Return values: an array of preconditions
+		 */
+		private EPType[] GetPreconditions()
+		{
+			ArrayList lstPreconds = new ArrayList();
+
+			try
+			{
+				XmlNode root = m_doc.DocumentElement;
+
+				// Create Expression Builder instance
+				IIOPEXPathExprBuilder IBuilder = IOPEXPathExprBuilderFactory.CreateInstance( enuIOPEType.Precondition );
+				// Build XPath Expression
+				string strXPathExpr = DAMLConstants.SERVICE_PROFILE + IBuilder.BuildExpression( enuIOPESearchBy.COND_DESC );
+
+				XmlNodeList nodeList = root.SelectNodes( strXPathExpr, m_mgr );
+
+				foreach( XmlNode descNode in nodeList )
+				{
+					EPType precond = this.GetEPNodeData( descNode );
+
+					if( precond.isValid )
+						lstPreconds.Add( precond );
+				}
+
+			}
+			catch( Exception e )
+			{
+				m_EvtLog.WriteEntry( e.Message, EventLogEntryType.Error );
+			}
+
+			return (EPType[]) lstPreconds.ToArray( typeof(EPType) );
+		}
+
+		/* Function returs all the outputs in a ServiceProfile
+		 *
+		 * Inputs: none
+		 *
+		 * Return values: an array of outputs
+		 */
+		private IOType[] GetOutputParameters()
+		{
+			ArrayList lstOutputs = new ArrayList();
+
+			try
+			{
+				XmlNode root = m_doc.DocumentElement;
+
+				// Create Expression Builder instance
+				IIOPEXPathExprBuilder IBuilder = IOPEXPathExprBuilderFactory.CreateInstance( enuIOPEType.Output );
+				// Build XPath Expression
+				string strXPathExpr = DAMLConstants.SERVICE_PROFILE + IBuilder.BuildExpression( enuIOPESearchBy.PARAM_DESC );
+
+				XmlNodeList nodeList = root.SelectNodes( strXPathExpr, m_mgr );
+
+				foreach( XmlNode descNode in nodeList )
+				{
+					IOType output = GetIONodeData( descNode );
+
+					if( output.isValid )
+						lstOutputs.Add( output );
+				}
+
+			}
+			catch( Exception e )
+			{
+				m_EvtLog.WriteEntry( e.Message, EventLogEntryType.Error );
+			}
+
+			return (IOType[]) lstOutputs.ToArray( typeof(IOType) );
+		}
+
+		/* Function returs all the inputs in a ServiceProfile
+		 *
+		 * Inputs: none
+		 *
+		 * Return values: an array of inputs
+		 */
+		private IOType[] GetInputParameters()
+		{
+			ArrayList lstInputs = new ArrayList();
+
+			try
+			{
+				XmlNode root = m_doc.DocumentElement;
+
+				// Create Expression Builder instance
+				IIOPEXPathExprBuilder IBuilder = IOPEXPathExprBuilderFactory.CreateInstance( enuIOPEType.Input );
+				// Build XPath Expression
+				string strXPathExpr = DAMLConstants.SERVICE_PROFILE + IBuilder.BuildExpression( enuIOPESearchBy.PARAM_DESC );
+
+				XmlNodeList nodeList = root.SelectNodes( strXPathExpr, m_mgr );
+
+				foreach( XmlNode descNode in nodeList )
+				{
+					IOType input = GetIONodeData( descNode );
+
+					if( input.isValid )
+						lstInputs.Add( input );
+				}
+
+			}
+			catch( Exception e )
+			{
+				m_EvtLog.WriteEntry( e.Message, EventLogEntryType.Error );
+			}
+
+			return (IOType[]) lstInputs.ToArray( typeof(IOType) );
+		}
+
+		/* Function strips the IONode data from a description node
+		 *
+		 * Inputs: descNode - description node
+		 *
+		 * Return values: the IOType data retrieved
+		 */
+		private IOType GetIONodeData( XmlNode descNode )
+		{
+			IOType ioData = new IOType();
+
+			ioData.ParameterDesc = descNode.Attributes[DAMLConstants.RDF_ID].Value;
+
+			// Get Param name
+			XmlNode nameNode = descNode.SelectSingleNode( DAMLConstants.PROFILE_PARAM_NAME, m_mgr );
+			ioData.ParameterName = nameNode.InnerText;
+
+			// Get Param RestrictedTo
+			XmlNode restrictNode = descNode.SelectSingleNode( DAMLConstants.PROFILE_RESTRICTED_TO, m_mgr );
+			ioData.RestrictedTo = restrictNode.Attributes[DAMLConstants.RDF_RESOURCE].Value;
+
+			// Get Param RefersTo
+			XmlNode referNode = descNode.SelectSingleNode( DAMLConstants.PROFILE_REFERS_TO, m_mgr );
+			ioData.RefersTo = referNode.Attributes[DAMLConstants.RDF_RESOURCE].Value;
+
+			return ioData;
+		}
+
+		/* Function strips the EPNode data from a description node
+		 *
+		 * Inputs: descNode - description node
+		 *
+		 * Return values: the EPType data retrieved
+		 */
+		private EPType GetEPNodeData( XmlNode descNode )
+		{
+			EPType epData = new EPType();
+
+			epData.ConditionDesc = descNode.Attributes[DAMLConstants.RDF_ID].Value;
+
+			XmlNode nameNode = descNode.SelectSingleNode( DAMLConstants.PROFILE_CONDITION_NAME, m_mgr );
+			epData.ConditionName = nameNode.InnerText;
+
+			XmlNode stmntNode = descNode.SelectSingleNode( DAMLConstants.PROFILE_STATEMENT, m_mgr );
+			epData.Statement = stmntNode.Attributes[DAMLConstants.RDF_RESOURCE].Value;
+
+			XmlNode referNode = descNode.SelectSingleNode( DAMLConstants.PROFILE_REFERS_TO, m_mgr );
+			epData.RefersTo = referNode.Attributes[DAMLConstants.RDF_RESOURCE].Value;
+
+			return epData;
+		}
+
+		/* Function returns the process model uri from the service profile
+		 *
+		 * Inputs: none
+		 *
+		 * Return value: process model uri
+		 */
+		private string GetProcessModel()
+		{
+			string strRetVal = "";
+
+			try
+			{
+				XmlNode root = m_doc.DocumentElement;
+				XmlNode node = root.SelectSingleNode( DAMLConstants.SERVICE_PROFILE + "/" + DAMLConstants.PROFILE_HAS_PROCESS, m_mgr );
+
+				if( node == null )
+					return "";
+
+				strRetVal = node.Attributes[DAMLConstants.RDF_RESOURCE].Value;
+			}
+			catch( Exception e )
+			{
+				m_EvtLog.WriteEntry( e.Message, EventLogEntryType.Error );
+			}
+
+			return strRetVal;
+		}
+
+		/* Function returns the quality rating data from the service profile
+		 *
+		 * Inputs: none
+		 *
+		 * Return value: quality rating data
+		 */
+		private string GetQualityRating()
+		{
+			string strRetVal = "";
+
+			try
+			{
+				XmlNode root = m_doc.DocumentElement;
+				XmlNode node = root.SelectSingleNode( DAMLConstants.SERVICE_PROFILE + "/" + DAMLConstants.PROFILE_QUALITY_RATING, m_mgr );
+
+				if( node == null )
+					return "";
+
+				strRetVal = node.Attributes[DAMLConstants.RDF_RESOURCE].Value;
+			}
+			catch( Exception e )
+			{
+				m_EvtLog.WriteEntry( e.Message, EventLogEntryType.Error );
+			}
+
+			return strRetVal;
+		}
+
+		/* Function returns the geographical radius data from the service profile
+		 *
+		 * Inputs: none
+		 *
+		 * Return value: geographical radius data
+		 */
+		private string GetGeographicRadius()
+		{
+			string strRetVal = "";
+
+			try
+			{
+				XmlNode root = m_doc.DocumentElement;
+				XmlNode node = root.SelectSingleNode( DAMLConstants.SERVICE_PROFILE + "/" + DAMLConstants.PROFILE_GEOG_RADIUS, m_mgr );
+
+				if( node == null )
+					return "";
+
+				strRetVal = node.Attributes[DAMLConstants.RDF_RESOURCE].Value;
+			}
+			catch( Exception e )
+			{
+				m_EvtLog.WriteEntry( e.Message, EventLogEntryType.Error );
+			}
+
+			return strRetVal;
+		}
+
+		/* Function returns the web url data from the service profile
+		 *
+		 * Inputs: none
+		 *
+		 * Return value: web url data
+		 */
+		private string GetWebUrl()
+		{
+			string strRetVal = "";
+
+			try
+			{
+				XmlNode root = m_doc.DocumentElement;
+				XmlNode node = root.SelectSingleNode( DAMLConstants.SERVICE_PROFILE + "/" + DAMLConstants.PROFILE_PROVIDED_BY + "/" + DAMLConstants.PROFILE_SERVICE_PROVIDER + "/" + DAMLConstants.PROFILE_WEB_URL, m_mgr );
+
+				if( node == null )
+					return "";
+
+				strRetVal = node.InnerText;
+			}
+			catch( Exception e )
+			{
+				m_EvtLog.WriteEntry( e.Message, EventLogEntryType.Error );
+			}
+
+			return strRetVal;
+		}
+
+		/* Function returns the physical address data from the service profile
+		 *
+		 * Inputs: none
+		 *
+		 * Return value: physical address data
+		 */
+		private string GetPhysicalAddress()
+		{
+			string strRetVal = "";
+
+			try
+			{
+				XmlNode root = m_doc.DocumentElement;
+				XmlNode node = root.SelectSingleNode( DAMLConstants.SERVICE_PROFILE + "/" + DAMLConstants.PROFILE_PROVIDED_BY + "/" + DAMLConstants.PROFILE_SERVICE_PROVIDER + "/" + DAMLConstants.PROFILE_PHYSICAL_ADDRESS, m_mgr );
+
+				if( node == null )
+					return "";
+
+				strRetVal = node.InnerText;
+			}
+			catch( Exception e )
+			{
+				m_EvtLog.WriteEntry( e.Message, EventLogEntryType.Error );
+			}
+
+			return strRetVal;
+		}
+
+		/* Function returns the profile email data from the service profile
+		 *
+		 * Inputs: none
+		 *
+		 * Return value: profile email data
+		 */
+		private string GetProfileEmail()
+		{
+			string strRetVal = "";
+
+			try
+			{
+				XmlNode root = m_doc.DocumentElement;
+				XmlNode node = root.SelectSingleNode( DAMLConstants.SERVICE_PROFILE + "/" + DAMLConstants.PROFILE_PROVIDED_BY + "/" + DAMLConstants.PROFILE_SERVICE_PROVIDER + "/" + DAMLConstants.PROFILE_EMAIL, m_mgr );
+
+				if( node == null )
+					return "";
+
+				strRetVal = node.InnerText;
+			}
+			catch( Exception e )
+			{
+				m_EvtLog.WriteEntry( e.Message, EventLogEntryType.Error );
+			}
+
+			return strRetVal;
+		}
+
+		/* Function returns the profile fax data from the service profile
+		 *
+		 * Inputs: none
+		 *
+		 * Return value: profile fax data
+		 */
+		private string GetProfileFax()
+		{
+			string strRetVal = "";
+
+			try
+			{
+				XmlNode root = m_doc.DocumentElement;
+				XmlNode node = root.SelectSingleNode( DAMLConstants.SERVICE_PROFILE + "/" + DAMLConstants.PROFILE_PROVIDED_BY + "/" + DAMLConstants.PROFILE_SERVICE_PROVIDER + "/" + DAMLConstants.PROFILE_FAX, m_mgr );
+
+				if( node == null )
+					return "";
+
+				strRetVal = node.InnerText;
+			}
+			catch( Exception e )
+			{
+				m_EvtLog.WriteEntry( e.Message, EventLogEntryType.Error );
+			}
+
+			return strRetVal;
+		}
+
+		/* Function returns the profile phone data from the service profile
+		 *
+		 * Inputs: none
+		 *
+		 * Return value: profile phone data
+		 */
+		private string GetProfilePhone()
+		{
+			string strRetVal = "";
+
+			try
+			{
+				XmlNode root = m_doc.DocumentElement;
+				XmlNode node = root.SelectSingleNode( DAMLConstants.SERVICE_PROFILE + "/" + DAMLConstants.PROFILE_PROVIDED_BY + "/" + DAMLConstants.PROFILE_SERVICE_PROVIDER + "/" + DAMLConstants.PROFILE_PHONE, m_mgr );
+
+				if( node == null )
+					return "";
+
+				strRetVal = node.InnerText;
+			}
+			catch( Exception e )
+			{
+				m_EvtLog.WriteEntry( e.Message, EventLogEntryType.Error );
+			}
+
+			return strRetVal;
+		}
+
+		/* Function returns the profile name data from the service profile
+		 *
+		 * Inputs: none
+		 *
+		 * Return value: profile name data
+		 */
+		private string GetProfileName()
+		{
+			string strRetVal = "";
+
+			try
+			{
+				XmlNode root = m_doc.DocumentElement;
+				XmlNode node = root.SelectSingleNode( DAMLConstants.SERVICE_PROFILE + "/" + DAMLConstants.PROFILE_PROVIDED_BY + "/" + DAMLConstants.PROFILE_SERVICE_PROVIDER + "/" + DAMLConstants.PROFILE_NAME, m_mgr );
+
+				if( node == null )
+					return "";
+
+				strRetVal = node.InnerText;
+			}
+			catch( Exception e )
+			{
+				m_EvtLog.WriteEntry( e.Message, EventLogEntryType.Error );
+			}
+
+			return strRetVal;
+		}
+
+		/* Function returns the profile service provider data from the service profile
+		 *
+		 * Inputs: none
+		 *
+		 * Return value: profile service provider data
+		 */
+		private string GetServiceProvider()
+		{
+			string strRetVal = "";
+
+			try
+			{
+				XmlNode root = m_doc.DocumentElement;
+				XmlNode node = root.SelectSingleNode( DAMLConstants.SERVICE_PROFILE + "/" + DAMLConstants.PROFILE_PROVIDED_BY + "/" + DAMLConstants.PROFILE_SERVICE_PROVIDER, m_mgr );
+
+				if( node == null )
+					return "";
+
+				strRetVal = node.Attributes[DAMLConstants.RDF_ID].Value;
+
+			}
+			catch( Exception e )
+			{
+				m_EvtLog.WriteEntry( e.Message, EventLogEntryType.Error );
+			}
+
+			return strRetVal;
+		}
+
+		/* Function returns the profile RequestedBy data from the service profile
+		 *
+		 * Inputs: none
+		 *
+		 * Return value: profile RequestedBy data
+		 */
+		private string GetRequestedBy()
+		{
+			string strRetVal = "";
+
+			try
+			{
+				XmlNode root = m_doc.DocumentElement;
+				XmlNode node = root.SelectSingleNode( DAMLConstants.SERVICE_PROFILE + "/" + DAMLConstants.PROFILE_REQUESTED_BY, m_mgr );
+
+				if( node == null )
+					return "";
+
+				strRetVal = node.InnerText;
+			}
+			catch( Exception e )
+			{
+				m_EvtLog.WriteEntry( e.Message, EventLogEntryType.Error );
+			}
+
+			return strRetVal;
+		}
+
+		/* Function returns the profile IntendedPurpose data from the service profile
+		 *
+		 * Inputs: none
+		 *
+		 * Return value: profile IntendedPurpose data
+		 */
+		private string GetIntendedPurpose()
+		{
+			string strRetVal = "";
+
+			try
+			{
+				XmlNode root = m_doc.DocumentElement;
+				XmlNode node = root.SelectSingleNode( DAMLConstants.SERVICE_PROFILE + "/" + DAMLConstants.PROFILE_INTENDED_PURPOSE, m_mgr );
+
+				if( node == null )
+					return "";
+
+				strRetVal = node.InnerText;
+			}
+			catch( Exception e )
+			{
+				m_EvtLog.WriteEntry( e.Message, EventLogEntryType.Error );
+			}
+
+			return strRetVal;
+		}
+
+		/* Function returns the profile TextDescription data from the service profile
+		 *
+		 * Inputs: none
+		 *
+		 * Return value: profile TextDescription data
+		 */
+		private string GetTextDescription()
+		{
+			string strRetVal = "";
+
+			try
+			{
+				XmlNode root = m_doc.DocumentElement;
+				XmlNode node = root.SelectSingleNode( DAMLConstants.SERVICE_PROFILE + "/" + DAMLConstants.PROFILE_TEXT_DESC, m_mgr );
+
+				if( node == null )
+					return "";
+
+				strRetVal = node.InnerText;
+			}
+			catch( Exception e )
+			{
+				m_EvtLog.WriteEntry( e.Message, EventLogEntryType.Error );
+			}
+
+			return strRetVal;
+		}
+
+		/* Function returns the profile PresentedBy data from the service profile
+		 *
+		 * Inputs: none
+		 *
+		 * Return value: profile PresentedBy data
+		 */
+		private string GetPresentedBy()
+		{
+			string strRetVal = "";
+
+			try
+			{
+				XmlNode root = m_doc.DocumentElement;
+				XmlNode node = root.SelectSingleNode( DAMLConstants.SERVICE_PROFILE + "/" + DAMLConstants.SERVICE_PRESENTED_BY, m_mgr );
+
+				if( node == null )
+					return "";
+
+				strRetVal = node.Attributes[DAMLConstants.RDF_RESOURCE].Value;
+			}
+			catch( Exception e )
+			{
+				m_EvtLog.WriteEntry( e.Message, EventLogEntryType.Error );
+			}
+
+			return strRetVal;
+		}
+
+		/* Function returns the ServiceProfile data from the service profile
+		 *
+		 * Inputs: none
+		 *
+		 * Return value: ServiceProfile data
+		 */
+		private string GetServiceProfile()
+		{
+			string strRetVal = "";
+
+			try
+			{
+				XmlNode root = m_doc.DocumentElement;
+				XmlNode node = root.SelectSingleNode( DAMLConstants.SERVICE_PROFILE, m_mgr );
+
+				if( node == null )
+					return "";
+
+				strRetVal = node.Attributes[DAMLConstants.RDF_ID].Value;
+			}
+			catch( Exception e )
+			{
+				m_EvtLog.WriteEntry( e.Message, EventLogEntryType.Error );
+			}
+
+			return strRetVal;
+		}
+
+		/* Function returns the ServiceName data from the service profile
+		 *
+		 * Inputs: none
+		 *
+		 * Return value: ServiceName data
+		 */
+		private string GetServiceName()
+		{
+			string strRetVal = "";
+
+			try
+			{
+				XmlNode root = m_doc.DocumentElement;
+				XmlNode node = root.SelectSingleNode( DAMLConstants.SERVICE_PROFILE + "/" + DAMLConstants.PROFILE_SERVICE_NAME, m_mgr );
+
+				if( node == null )
+					return "";
+
+				strRetVal = node.InnerText;
+			}
+			catch( Exception e )
+			{
+				m_EvtLog.WriteEntry( e.Message, EventLogEntryType.Error );
+			}
+
+			return strRetVal;
+		}
+
+	}
+}
diff --git a/csharpsrc/DAML/IIOPEXPathExprBuilder.cs b/csharpsrc/DAML/IIOPEXPathExprBuilder.cs
new file mode 100644
index 0000000..2fb41fd
--- /dev/null
+++ b/csharpsrc/DAML/IIOPEXPathExprBuilder.cs
@@ -0,0 +1,15 @@
+using System;
+
+namespace PSL.DAML.Interfaces
+{
+	/// <summary>
+	/// Interface implemented by classes used to generart XPath expressions
+	/// for searching DAMLServiceProfile documents for inputs, outputs, preconditiond
+	/// and effects.
+	/// </summary>
+	public interface IIOPEXPathExprBuilder
+	{
+		string BuildExpression( enuIOPESearchBy filter );
+		string BuildExpression( enuIOPESearchBy filter, string strSearchKey );
+	}
+}
diff --git a/csharpsrc/DAML/IOPEXPathExprBuilderFactory.cs b/csharpsrc/DAML/IOPEXPathExprBuilderFactory.cs
new file mode 100644
index 0000000..ddb3768
--- /dev/null
+++ b/csharpsrc/DAML/IOPEXPathExprBuilderFactory.cs
@@ -0,0 +1,30 @@
+using System;
+using PSL.DAML.Interfaces;
+
+namespace PSL.DAML
+{
+	/// <summary>
+	/// Factory creates XPath expression builders
+	/// </summary>
+	public sealed class IOPEXPathExprBuilderFactory
+	{
+		private IOPEXPathExprBuilderFactory()
+		{}
+
+		public static IIOPEXPathExprBuilder CreateInstance( enuIOPEType builderType )
+		{
+			switch( builderType )
+			{
+				case enuIOPEType.Input: return new InputXPathExprBuilder();
+
+				case enuIOPEType.Output: return new OutputXPathExprBuilder();
+
+				case enuIOPEType.Precondition: return new PreconditionXPathExprBuilder();
+
+				case enuIOPEType.Effect: return new EffectXPathExprBuilder();
+
+				default: throw new ArgumentException( "Invalid/Unrecognized filter type" );
+			};
+		}
+	}
+}
diff --git a/csharpsrc/DAML/XPathExprBuilders.cs b/csharpsrc/DAML/XPathExprBuilders.cs
new file mode 100644
index 0000000..ef0cfaf
--- /dev/null
+++ b/csharpsrc/DAML/XPathExprBuilders.cs
@@ -0,0 +1,179 @@
+using System;
+using PSL.DAML.Interfaces;
+
+namespace PSL.DAML
+{
+	internal sealed class InputXPathExprBuilder:IIOPEXPathExprBuilder
+	{
+		/* Constructor */
+		internal InputXPathExprBuilder()
+		{}
+
+		/* Function */
+		public string BuildExpression( enuIOPESearchBy filter )
+		{
+			switch( filter )
+			{
+				case enuIOPESearchBy.PARAM_DESC: return  "/" + DAMLConstants.DEFAULT_NS + ":" + DAMLConstants.INPUT + "/" + DAMLConstants.PROFILE_PARAM_DESC;
+
+				case enuIOPESearchBy.PARAM_NAME: return "/" + DAMLConstants.DEFAULT_NS + ":" + DAMLConstants.INPUT + "/" + DAMLConstants.PROFILE_PARAM_DESC + "[@" + DAMLConstants.RDF_ID + "]" + "/" + DAMLConstants.PROFILE_PARAM_NAME;
+
+				case enuIOPESearchBy.REFERS_TO: return "/" + DAMLConstants.DEFAULT_NS + ":" + DAMLConstants.INPUT + "/" + DAMLConstants.PROFILE_PARAM_DESC + "[@" + DAMLConstants.RDF_ID + "]" + "/" + DAMLConstants.PROFILE_REFERS_TO;
+
+				default: throw new ArgumentException( "Invalid filter value" );
+			};
+		}
+
+		public string BuildExpression( enuIOPESearchBy filter, string strSearchKey )
+		{
+			string strXPath = "";
+
+			switch( filter )
+			{
+				case enuIOPESearchBy.PARAM_DESC: strXPath = BuildExpression( filter );
+												 strXPath += "[@" + DAMLConstants.RDF_ID + "='" + strSearchKey + "']";
+												 return strXPath;
+
+				case enuIOPESearchBy.PARAM_NAME: strXPath = BuildExpression( filter );
+												 strXPath += "[." + "='" + strSearchKey + "']";
+												 return strXPath;
+
+				case enuIOPESearchBy.REFERS_TO: strXPath = BuildExpression( filter );
+					strXPath += "[@" + DAMLConstants.RDF_RESOURCE + "='" + strSearchKey + "']";
+					return strXPath;
+
+
+				default: throw new ArgumentException( "Invalid filter value" );
+			};
+		}
+	}// End - InputXPathExprBuilder
+
+	internal sealed class OutputXPathExprBuilder:IIOPEXPathExprBuilder
+	{
+		/* Constructor */
+		internal OutputXPathExprBuilder()
+		{}
+
+		public string BuildExpression( enuIOPESearchBy filter )
+		{
+			switch( filter )
+			{
+				case enuIOPESearchBy.PARAM_DESC: return  "/" + DAMLConstants.DEFAULT_NS + ":" + DAMLConstants.OUTPUT + "/" + DAMLConstants.PROFILE_PARAM_DESC;
+
+				case enuIOPESearchBy.PARAM_NAME: return "/" + DAMLConstants.DEFAULT_NS + ":" + DAMLConstants.OUTPUT + "/" + DAMLConstants.PROFILE_PARAM_DESC + "[@" + DAMLConstants.RDF_ID + "]" + "/" + DAMLConstants.PROFILE_PARAM_NAME;
+
+				case enuIOPESearchBy.REFERS_TO: return "/" + DAMLConstants.DEFAULT_NS + ":" + DAMLConstants.OUTPUT + "/" + DAMLConstants.PROFILE_PARAM_DESC + "[@" + DAMLConstants.RDF_ID + "]" + "/" + DAMLConstants.PROFILE_REFERS_TO;
+
+				default: throw new ArgumentException( "Invalid filter value" );
+			};
+		}
+
+		public string BuildExpression( enuIOPESearchBy filter, string strSearchKey )
+		{
+			string strXPath = "";
+
+			switch( filter )
+			{
+				case enuIOPESearchBy.PARAM_DESC: strXPath = BuildExpression( filter );
+					strXPath += "[@" + DAMLConstants.RDF_ID + "='" + strSearchKey + "']";
+					return strXPath;
+
+				case enuIOPESearchBy.PARAM_NAME: strXPath = BuildExpression( filter );
+					strXPath += "[." + "='" + strSearchKey + "']";
+					return strXPath;
+
+				case enuIOPESearchBy.REFERS_TO: strXPath = BuildExpression( filter );
+					strXPath += "[@" + DAMLConstants.RDF_RESOURCE + "='" + strSearchKey + "']";
+					return strXPath;
+
+				default: throw new ArgumentException( "Invalid filter value" );
+			};
+		}
+	}// End OutputXPathExprBuilder
+
+
+	internal sealed class PreconditionXPathExprBuilder:IIOPEXPathExprBuilder
+	{
+		/* Constructor */
+		internal PreconditionXPathExprBuilder()
+		{}
+
+		public string BuildExpression( enuIOPESearchBy filter )
+		{
+			switch( filter )
+			{
+				case enuIOPESearchBy.COND_DESC: return  "/" + DAMLConstants.DEFAULT_NS + ":" + DAMLConstants.PRECONDITION + "/" + DAMLConstants.PROFILE_CONDITION_DESC;
+
+				case enuIOPESearchBy.COND_NAME: return "/" + DAMLConstants.DEFAULT_NS + ":" + DAMLConstants.PRECONDITION + "/" + DAMLConstants.PROFILE_CONDITION_DESC + "[@" + DAMLConstants.RDF_ID + "]" + "/" + DAMLConstants.PROFILE_CONDITION_NAME;
+
+				case enuIOPESearchBy.REFERS_TO: return "/" + DAMLConstants.DEFAULT_NS + ":" + DAMLConstants.PRECONDITION + "/" + DAMLConstants.PROFILE_CONDITION_DESC + "[@" + DAMLConstants.RDF_ID + "]" + "/" + DAMLConstants.PROFILE_REFERS_TO;
+
+				default: throw new ArgumentException( "Invalid filter value" );
+			};
+		}
+
+		public string BuildExpression( enuIOPESearchBy filter, string strSearchKey )
+		{
+			string strXPath = "";
+
+			switch( filter )
+			{
+				case enuIOPESearchBy.COND_DESC: strXPath = BuildExpression( filter );
+					strXPath += "[@" + DAMLConstants.RDF_ID + "='" + strSearchKey + "']";
+					return strXPath;
+
+				case enuIOPESearchBy.COND_NAME: strXPath = BuildExpression( filter );
+					strXPath += "[." + "='" + strSearchKey + "']";
+					return strXPath;
+
+				case enuIOPESearchBy.REFERS_TO: strXPath = BuildExpression( filter );
+					strXPath += "[@" + DAMLConstants.RDF_RESOURCE + "='" + strSearchKey + "']";
+					return strXPath;
+
+				default: throw new ArgumentException( "Invalid filter value" );
+			};
+		}
+	}// End PreconditionXPathExprBuilder
+
+	internal sealed class EffectXPathExprBuilder:IIOPEXPathExprBuilder
+	{
+		/* Constructor */
+		internal EffectXPathExprBuilder()
+		{}
+
+		public string BuildExpression( enuIOPESearchBy filter )
+		{
+			switch( filter )
+			{
+				case enuIOPESearchBy.COND_DESC: return  "/" + DAMLConstants.DEFAULT_NS + ":" + DAMLConstants.EFFECT + "/" + DAMLConstants.PROFILE_CONDITION_DESC;
+
+				case enuIOPESearchBy.COND_NAME: return "/" + DAMLConstants.DEFAULT_NS + ":" + DAMLConstants.EFFECT + "/" + DAMLConstants.PROFILE_CONDITION_DESC + "[@" + DAMLConstants.RDF_ID + "]" + "/" + DAMLConstants.PROFILE_CONDITION_NAME;
+
+				case enuIOPESearchBy.REFERS_TO: return "/" + DAMLConstants.DEFAULT_NS + ":" + DAMLConstants.EFFECT + "/" + DAMLConstants.PROFILE_CONDITION_DESC + "[@" + DAMLConstants.RDF_ID + "]" + "/" + DAMLConstants.PROFILE_REFERS_TO;
+
+				default: throw new ArgumentException( "Invalid filter value" );
+			};
+		}
+		public string BuildExpression( enuIOPESearchBy filter, string strSearchKey )
+		{
+			string strXPath = "";
+
+			switch( filter )
+			{
+				case enuIOPESearchBy.COND_DESC: strXPath = BuildExpression( filter );
+					strXPath += "[@" + DAMLConstants.RDF_ID + "='" + strSearchKey + "']";
+					return strXPath;
+
+				case enuIOPESearchBy.COND_NAME: strXPath = BuildExpression( filter );
+					strXPath += "[." + "='" + strSearchKey + "']";
+					return strXPath;
+
+				case enuIOPESearchBy.REFERS_TO: strXPath = BuildExpression( filter );
+					strXPath += "[@" + DAMLConstants.RDF_RESOURCE + "='" + strSearchKey + "']";
+					return strXPath;
+
+				default: throw new ArgumentException( "Invalid filter value" );
+			};
+		}
+	}// End EffectXPathExprBuilder
+}